diff --git a/.dockerignore b/.dockerignore
new file mode 100644
index 0000000..6bf26d4
--- /dev/null
+++ b/.dockerignore
@@ -0,0 +1,28 @@
+# Was NICHT in den Build-Kontext gehoert. Ohne diese Datei schickt Docker das
+# ganze Verzeichnis an den Daemon - mitsamt Website (rund 50 MB), PDF und
+# Notebooks, die im Image nichts zu suchen haben.
+
+# Erzeugte Ausgaben
+OR_HTML_04/
+Notebooks_04/
+*.pdf
+Operations_Research_mit_Python_Version_04.md
+
+# Quellen des Buchsatzes - das Image fuehrt die Programme aus, es baut das
+# Buch nicht. Wer das PDF bauen will, braucht pandoc, xelatex und inkscape
+# und ist mit einer lokalen Installation besser bedient.
+bilder_04/
+pandoc/
+pandoc-defaults-*.yaml
+Kritik_und_Verbesserungsvorschlaege/
+PLAN.md
+PROGRESS.md
+CLAUDE.md
+
+# Von Laeufen erzeugte Dateien
+**/__pycache__/
+**/output/
+*.xlsx
+.git/
+.venv/
+venv/
diff --git a/CLAUDE.md b/CLAUDE.md
index 4a6c31e..871a862 100644
--- a/CLAUDE.md
+++ b/CLAUDE.md
@@ -23,7 +23,7 @@ Dieses Verzeichnis ist die Wurzel; alle Skripte leiten ihre Pfade daraus ab
 (`BASIS = dirname(dirname(__file__))` bzw. `dirname(HIER)`).
 
 ```
-Operations_Research_mit_Python_Version_04/     Quelle: 31 Kapiteldateien + Build-Skripte
+Operations_Research_mit_Python_Version_04/     Quelle: 36 Kapiteldateien + Build-Skripte
 bilder_04/                                     Quelle: Diagramme + erzeuge_*.py-Generatoren
 Operations_Research_mit_Python_Version_04.md   generiert: Gesamtdokument
 Operations_Research_mit_Python_Version_04.pdf  generiert: PDF (xelatex)
@@ -33,6 +33,7 @@ Notebooks_04/                                  generiert: ein .ipynb je Kapitel
 Kritik_und_Verbesserungsvorschlaege/           Quelle: Rezension, Verbesserungsvorschläge,
                                                NEUER_TITEL.md (Vorlage des Titelblatts)
 pyproject.toml                                 Quelle: Abhängigkeiten in Gruppen
+Dockerfile, .dockerignore                      Quelle: Kurs-Image (nur Programme)
 pandoc-defaults-basis.yaml, pandoc/, pandoc-defaults-buch.yaml   PDF-Konfiguration
 ```
 
@@ -66,15 +67,24 @@ sonst fälschlich als sichtbaren Umbruch dar.
 ## Die wichtigsten Konventionen
 
 **Keine abgeleiteten Zahlen im Quelltext.** Das ist die Regel, an der dieses Projekt am
-häufigsten gescheitert ist — sie wurde vier Mal an verschiedenen Stellen verletzt gefunden
-(Anhang A, 66 Programm-Docstrings, die Übersichtstabellen der Anhänge, `CLAUDE.md` selbst).
-Konkret:
+häufigsten gescheitert ist — **sieben** Mal an verschiedenen Stellen verletzt gefunden
+(Anhang A, 66 Programm-Docstrings, die Übersichtstabellen der Anhänge, `CLAUDE.md` selbst,
+eine Tabellenzelle, die 98 Lösungsmarken des Anhangs, neun Denkfehler-Verweise).
+Seit dem letzten Fund trägt **keine** Marke mehr eine handgeschriebene Nummer, und `--check`
+bewacht jede Familie. Konkret:
 
 * Überschriften: `# Kapitel: <Titel> {#kap:<label>}`, `## Titel {#sec:<label>}` — die Nummer
   vergibt der Build (`resolve_numbering()`, `nummeriere_abschnitte()`).
-* Aufgaben, Handrechnungen, Abbildungen: `**Aufgabe ⭐ — Titel.**`,
-  `> **✏️ Handrechnung: Titel**`, `![Bildunterschrift](bilder_04/…)` — Nummern von
-  `nummeriere_marken()`.
+* Aufgaben, Handrechnungen, Abbildungen, Micro-Quiz: `**Aufgabe ⭐ — Titel.**`,
+  `> **✏️ Handrechnung: Titel**`, `![Bildunterschrift](bilder_04/…)`,
+  `> **❓ Micro-Quiz: Titel**` — Nummern von `nummeriere_marken()`.
+* **Lösungen in Anhang A: `**{loesung} — Titel.**`** Der Präfix kommt nicht aus
+  `# Anhang A:`, sondern aus dem Kapitel des umgebenden `{#sec:loesungen-<X>}`-Abschnitts —
+  die Zuordnung `sec:loesungen-<X>` ↔ `kap:<X>` gilt für alle 23. `--check` zählt zusätzlich
+  ab, dass es je Kapitel so viele Lösungen wie Aufgaben gibt.
+* **Der Denkfehler bekommt bewusst gar keine Nummer.** Es gibt je Kapitel genau einen, unter
+  einer bereits nummerierten Überschrift. Verwiesen wird auf
+  `{ref:sec:<kapitel>-denkfehler}`.
 * Im Fließtext `{ref:<label>}`, nie eine Literalzahl.
 * In Code-Kommentaren und Docstrings der Kapitel**name** („Kapitel Metaheuristiken:"), nie
   die Nummer. Auch nicht im Dateinamen.
diff --git a/Dockerfile b/Dockerfile
new file mode 100644
index 0000000..c19e596
--- /dev/null
+++ b/Dockerfile
@@ -0,0 +1,79 @@
+# Kurs-Image zu "Optimierte Entscheidungsfindung mit Python".
+#
+# Was es ist: eine reproduzierbare Umgebung, in der alle Beispielprogramme
+# laufen - ohne dass jemand Solver, BLAS-Bibliotheken und Python-Versionen von
+# Hand zusammensuchen muss.
+#
+# Was es NICHT ist: eine Bauumgebung fuer das Buch. Das PDF braucht pandoc,
+# xelatex und inkscape, zusammen ueber ein Gigabyte. Wer das Buch selbst baut,
+# ist mit einer lokalen Installation besser bedient (siehe README.md).
+#
+#   docker build -t or-mit-python .
+#   docker run --rm or-mit-python Installationstest.py
+#   docker run --rm -it or-mit-python                    # Python-Eingabe
+#   docker run --rm -v "$PWD/ausgabe:/buch/output" or-mit-python Excel_Bruecke.py
+#
+# Zwei Stufen: Die erste baut die Abhaengigkeiten in eine virtuelle Umgebung
+# (und braucht dafuer Compiler), die zweite kopiert nur das Ergebnis. Das
+# spart im fertigen Image die gesamte Bauumgebung.
+
+# --- Stufe 1: Abhaengigkeiten uebersetzen und einsammeln ---------------------
+FROM python:3.12-slim AS bau
+
+# build-essential wird von Paketen gebraucht, die kein passendes Wheel
+# mitbringen. Bleibt in dieser Stufe und landet nie im fertigen Image.
+RUN apt-get update && apt-get install --no-install-recommends -y \
+        build-essential \
+    && rm -rf /var/lib/apt/lists/*
+
+ENV PIP_NO_CACHE_DIR=1 \
+    PIP_DISABLE_PIP_VERSION_CHECK=1
+RUN python -m venv /opt/venv
+ENV PATH="/opt/venv/bin:$PATH"
+
+# Nur die Abhaengigkeitsbeschreibung kopieren, nicht den Quelltext: So bleibt
+# diese Schicht im Cache, solange sich die Abhaengigkeiten nicht aendern.
+WORKDIR /buch
+COPY pyproject.toml README.md ./
+
+# Die Gruppen aus pyproject.toml. 'figures' fehlt bewusst - es dient dem
+# Neuerzeugen der Diagramme, wofuer zusaetzlich Graphviz noetig waere.
+#
+# ACHTUNG, gewollt: Das Image enthaelt ortools UND highspy, obwohl beide eine
+# eigene HiGHS-Kopie mitbringen und sich nicht gemeinsam importieren lassen.
+# Der Konflikt wird nicht durch Weglassen geloest, sondern zur Laufzeit durch
+# getrennte Prozesse (Kapitel Oekosystem). Ein Image, das nur eines von beiden
+# enthaelt, koennte die Haelfte der Beispiele nicht ausfuehren.
+RUN pip install ".[finance,large-scale,api,dev]"
+
+# --- Stufe 2: das eigentliche Image -----------------------------------------
+FROM python:3.12-slim AS laufzeit
+
+# libgomp1 wird von OR-Tools und HiGHS zur Laufzeit gebraucht (OpenMP) und ist
+# im slim-Image nicht enthalten. Ohne es scheitert der erste Solveraufruf mit
+# einem 'libgomp.so.1: cannot open shared object file'.
+RUN apt-get update && apt-get install --no-install-recommends -y \
+        libgomp1 \
+    && rm -rf /var/lib/apt/lists/*
+
+COPY --from=bau /opt/venv /opt/venv
+ENV PATH="/opt/venv/bin:$PATH" \
+    PYTHONUNBUFFERED=1 \
+    MPLBACKEND=Agg
+
+# Kein root. Die Programme brauchen keine Rechte, und ein Kurs-Image, das als
+# root laeuft, ist eine schlechte Angewohnheit, die man weitergibt.
+RUN useradd --create-home --uid 1000 kurs
+WORKDIR /buch
+COPY --chown=kurs:kurs Operations_Research_mit_Python_Version_04_Programme/ ./
+
+# Verzeichnis fuer erzeugte Dateien - als Volume einhaengbar, damit
+# Excel-Ausgaben und Diagramme den Container ueberleben. Angelegt wird es
+# VOR dem Benutzerwechsel, denn /buch gehoert root.
+RUN mkdir -p /buch/output && chown kurs:kurs /buch/output
+USER kurs
+
+# Ohne Argument eine Python-Eingabeaufforderung, mit Argument das genannte
+# Programm: 'docker run --rm or-mit-python Rucksack.py'
+ENTRYPOINT ["python"]
+CMD []
diff --git a/Notebooks_04/cpsat.ipynb b/Notebooks_04/cpsat.ipynb
index 1ed1cb0..d7ebcb5 100644
--- a/Notebooks_04/cpsat.ipynb
+++ b/Notebooks_04/cpsat.ipynb
@@ -496,6 +496,218 @@
     "    loese_jobshop()"
    ]
   },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Parallele Suche: was `num_workers` wirklich bewirkt\n",
+    "\n",
+    "`Parallele_Suche.py`\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "#!/usr/bin/env python3\n",
+    "\n",
+    "# Parallele_Suche.py\n",
+    "\"\"\"\n",
+    "Kapitel CP-SAT: Was mehrere Arbeiter wirklich bringen - und was sie kosten.\n",
+    "\n",
+    "Das Buch setzt an mehreren Stellen 'num_workers = 1', damit die abgedruckte\n",
+    "Ausgabe reproduzierbar ist. Behauptet wird dabei zweierlei: dass parallele\n",
+    "Suche schneller ist, und dass sie von Lauf zu Lauf verschiedene, gleich gute\n",
+    "Loesungen findet. Beides wird hier gemessen statt geglaubt.\n",
+    "\n",
+    "Gerechnet wird auf einem Job-Shop wie in JobShop_Intervalle.py, nur gross\n",
+    "genug, dass die Suche wirklich arbeitet: 12 Auftraege auf 10 Maschinen,\n",
+    "jeder Auftrag besucht jede Maschine.\n",
+    "\n",
+    "Zwei Messungen:\n",
+    "  1. Dieselbe Aufgabe mit 1, 2, 4 und 8 Arbeitern - Laufzeit und Ergebnis.\n",
+    "  2. Dieselbe Konfiguration mehrfach, bei FESTEM random_seed - wie oft kommt\n",
+    "     derselbe Plan heraus?\n",
+    "\n",
+    "Die zweite ist die wichtigere: Sie entscheidet, wie man Tests schreibt.\n",
+    "\n",
+    "Achtung, Laufzeiten sind hardwareabhaengig. Die ZAHL der verschiedenen\n",
+    "Plaene ist es auch - und genau das ist die Aussage.\n",
+    "\n",
+    "Benoetigt: numpy, ortools\n",
+    "\"\"\"\n",
+    "\n",
+    "from __future__ import annotations\n",
+    "\n",
+    "import collections\n",
+    "import time\n",
+    "\n",
+    "import numpy as np\n",
+    "from ortools.sat.python import cp_model\n",
+    "\n",
+    "AUFTRAEGE = 12\n",
+    "MASCHINEN = 10\n",
+    "INSTANZ_SEED = 20260908\n",
+    "SOLVER_SEED = 1          # bleibt ueber ALLE Laeufe gleich - das ist der Punkt\n",
+    "ARBEITERZAHLEN = (1, 2, 4, 8)\n",
+    "WIEDERHOLUNGEN = 4\n",
+    "ZEITLIMIT = 120.0\n",
+    "\n",
+    "\n",
+    "def baue_instanz() -> list[list[tuple[int, int]]]:\n",
+    "    \"\"\"Klassischer Job-Shop: Jeder Auftrag besucht jede Maschine genau einmal,\n",
+    "    in einer eigenen zufaelligen Reihenfolge.\"\"\"\n",
+    "    rng = np.random.default_rng(INSTANZ_SEED)\n",
+    "    return [[(int(m), int(rng.integers(2, 20))) for m in rng.permutation(MASCHINEN)]\n",
+    "            for _ in range(AUFTRAEGE)]\n",
+    "\n",
+    "\n",
+    "def loese(auftraege, arbeiter: int):\n",
+    "    \"\"\"Minimiert den Makespan. Gibt Status, Zielwert, Laufzeit und den Plan\n",
+    "    zurueck - den Plan als Tupel aller Startzeiten, damit sich zwei Laeufe\n",
+    "    vergleichen lassen.\"\"\"\n",
+    "    horizont = sum(dauer for auftrag in auftraege for _, dauer in auftrag)\n",
+    "    modell = cp_model.CpModel()\n",
+    "    Gang = collections.namedtuple(\"Gang\", \"start ende intervall\")\n",
+    "    plaene: dict[tuple[int, int], Gang] = {}\n",
+    "    je_maschine = collections.defaultdict(list)\n",
+    "\n",
+    "    for a, auftrag in enumerate(auftraege):\n",
+    "        for g, (maschine, dauer) in enumerate(auftrag):\n",
+    "            start = modell.NewIntVar(0, horizont, f\"start_{a}_{g}\")\n",
+    "            ende = modell.NewIntVar(0, horizont, f\"ende_{a}_{g}\")\n",
+    "            intervall = modell.NewIntervalVar(start, dauer, ende, f\"iv_{a}_{g}\")\n",
+    "            plaene[a, g] = Gang(start, ende, intervall)\n",
+    "            je_maschine[maschine].append(intervall)\n",
+    "\n",
+    "    for maschine in range(MASCHINEN):\n",
+    "        modell.AddNoOverlap(je_maschine[maschine])\n",
+    "    for a, auftrag in enumerate(auftraege):\n",
+    "        for g in range(len(auftrag) - 1):\n",
+    "            modell.Add(plaene[a, g + 1].start >= plaene[a, g].ende)\n",
+    "\n",
+    "    makespan = modell.NewIntVar(0, horizont, \"makespan\")\n",
+    "    modell.AddMaxEquality(\n",
+    "        makespan, [plaene[a, len(auftrag) - 1].ende\n",
+    "                   for a, auftrag in enumerate(auftraege)])\n",
+    "    modell.Minimize(makespan)\n",
+    "\n",
+    "    loeser = cp_model.CpSolver()\n",
+    "    loeser.parameters.num_workers = arbeiter\n",
+    "    loeser.parameters.random_seed = SOLVER_SEED\n",
+    "    loeser.parameters.max_time_in_seconds = ZEITLIMIT\n",
+    "\n",
+    "    beginn = time.perf_counter()\n",
+    "    status = loeser.Solve(modell)\n",
+    "    dauer = time.perf_counter() - beginn\n",
+    "\n",
+    "    if status not in (cp_model.OPTIMAL, cp_model.FEASIBLE):\n",
+    "        return loeser.StatusName(status), None, dauer, None\n",
+    "    plan = tuple(loeser.Value(plaene[a, g].start)\n",
+    "                 for a, auftrag in enumerate(auftraege)\n",
+    "                 for g in range(len(auftrag)))\n",
+    "    return loeser.StatusName(status), int(loeser.ObjectiveValue()), dauer, plan\n",
+    "\n",
+    "\n",
+    "if __name__ == \"__main__\":\n",
+    "    auftraege = baue_instanz()\n",
+    "    gaenge = sum(len(a) for a in auftraege)\n",
+    "\n",
+    "    print(\"=\" * 78)\n",
+    "    print(\"  WAS MEHRERE ARBEITER WIRKLICH BRINGEN\")\n",
+    "    print(\"=\" * 78)\n",
+    "    print(f\"Job-Shop: {AUFTRAEGE} Auftraege, {MASCHINEN} Maschinen, \"\n",
+    "          f\"{gaenge} Arbeitsgaenge.\")\n",
+    "    print(f\"random_seed = {SOLVER_SEED} in JEDEM Lauf, \"\n",
+    "          f\"{WIEDERHOLUNGEN} Wiederholungen je Arbeiterzahl.\\n\")\n",
+    "\n",
+    "    # Jede Konfiguration mehrfach - ein einzelner Zeitwert sagt nichts.\n",
+    "    ergebnisse: dict[int, list[tuple]] = {}\n",
+    "    for arbeiter in ARBEITERZAHLEN:\n",
+    "        ergebnisse[arbeiter] = [loese(auftraege, arbeiter)\n",
+    "                                for _ in range(WIEDERHOLUNGEN)]\n",
+    "\n",
+    "    print(\"=\" * 78)\n",
+    "    print(\"  (1) Laufzeit: was die Arbeiter bringen\")\n",
+    "    print(\"=\" * 78)\n",
+    "    print(f\"{'Arbeiter':>9} {'Status':>9} {'Makespan':>9} \"\n",
+    "          f\"{'schnellste':>11} {'langsamste':>11} {'Beschleunigung':>15}\")\n",
+    "    print(\"-\" * 78)\n",
+    "    basis_zeit = min(d for _, _, d, _ in ergebnisse[1])\n",
+    "    for arbeiter in ARBEITERZAHLEN:\n",
+    "        laeufe = ergebnisse[arbeiter]\n",
+    "        zeiten = [d for _, _, d, _ in laeufe]\n",
+    "        ziele = {o for _, o, _, _ in laeufe}\n",
+    "        status = {s for s, _, _, _ in laeufe}\n",
+    "        print(f\"{arbeiter:>9} {'/'.join(sorted(status)):>9} \"\n",
+    "              f\"{'/'.join(str(z) for z in sorted(ziele)):>9} \"\n",
+    "              f\"{min(zeiten):>10.2f}s {max(zeiten):>10.2f}s \"\n",
+    "              f\"{basis_zeit / min(zeiten):>14.1f}x\")\n",
+    "\n",
+    "    beste = min(ARBEITERZAHLEN, key=lambda w: min(d for _, _, d, _ in ergebnisse[w]))\n",
+    "    faktor = basis_zeit / min(d for _, _, d, _ in ergebnisse[beste])\n",
+    "    print(f\"\\n  Am schnellsten sind {beste} Arbeiter: Faktor {faktor:.1f} gegenueber\")\n",
+    "    print(f\"  einem einzigen - also MEHR, als {beste} Kerne hergeben sollten.\")\n",
+    "    print(f\"  Das ist kein Messfehler. CP-SAT laesst nicht {beste}-mal dieselbe Suche\")\n",
+    "    print(\"  laufen, sondern verschiedene Strategien nebeneinander, die einander\")\n",
+    "    print(\"  ihre Schranken zurufen. Der zweite Arbeiter ist deshalb nicht der\")\n",
+    "    print(\"  'zweite Kern', sondern ein anderes Verfahren.\")\n",
+    "    letzte = ARBEITERZAHLEN[-1]\n",
+    "    if beste != letzte:\n",
+    "        zeit_letzte = min(d for _, _, d, _ in ergebnisse[letzte])\n",
+    "        print(f\"\\n  Und mehr ist nicht immer besser: {letzte} Arbeiter brauchen \"\n",
+    "              f\"{zeit_letzte:.2f}s\")\n",
+    "        print(f\"  gegenueber {min(d for _, _, d, _ in ergebnisse[beste]):.2f}s bei \"\n",
+    "              f\"{beste}. Ab einer gewissen Zahl kosten Abstimmung\")\n",
+    "        print(\"  und Speicherbandbreite mehr, als ein weiterer Suchstrang einbringt.\")\n",
+    "\n",
+    "    print(\"\\n\" + \"=\" * 78)\n",
+    "    print(\"  (2) Reproduzierbarkeit: derselbe Seed, derselbe Plan?\")\n",
+    "    print(\"=\" * 78)\n",
+    "    print(f\"{'Arbeiter':>9} {'Laeufe':>7} {'verschiedene Plaene':>21} \"\n",
+    "          f\"{'Makespan':>10}\")\n",
+    "    print(\"-\" * 78)\n",
+    "    for arbeiter in ARBEITERZAHLEN:\n",
+    "        plaene = {p for _, _, _, p in ergebnisse[arbeiter] if p is not None}\n",
+    "        ziele = {o for _, o, _, _ in ergebnisse[arbeiter]}\n",
+    "        print(f\"{arbeiter:>9} {WIEDERHOLUNGEN:>7} {len(plaene):>21} \"\n",
+    "              f\"{'/'.join(str(z) for z in sorted(ziele)):>10}\")\n",
+    "\n",
+    "    einer = len({p for _, _, _, p in ergebnisse[1]})\n",
+    "    # Ab welcher Arbeiterzahl bricht die Reproduzierbarkeit? Das ist die\n",
+    "    # eigentliche Zahl - nicht, was acht Arbeiter anrichten.\n",
+    "    ab = next((w for w in ARBEITERZAHLEN\n",
+    "               if len({p for _, _, _, p in ergebnisse[w]}) > 1), None)\n",
+    "    print(f\"\\n  Mit einem Arbeiter: {einer} Plan aus {WIEDERHOLUNGEN} Laeufen.\")\n",
+    "    if ab is not None:\n",
+    "        viele = len({p for _, _, _, p in ergebnisse[ab]})\n",
+    "        print(f\"  Schon mit {ab} Arbeitern: {viele} verschiedene Plaene aus \"\n",
+    "              f\"{WIEDERHOLUNGEN} Laeufen -\")\n",
+    "        print(\"  bei identischem random_seed und identischem Zielwert.\")\n",
+    "        print(f\"  Es braucht also keine acht Arbeiter, um die Reproduzierbarkeit\")\n",
+    "        print(f\"  zu verlieren. {ab} genuegen.\")\n",
+    "    print(\"\\n  Der Seed allein macht einen Lauf also NICHT reproduzierbar. Er legt\")\n",
+    "    print(\"  fest, wie ein einzelner Suchstrang wuerfelt - nicht, welcher von\")\n",
+    "    print(\"  mehreren zuerst fertig wird. Das entscheidet die Uhr.\")\n",
+    "\n",
+    "    print(\"\\n\" + \"=\" * 78)\n",
+    "    print(\"  (3) Was daraus fuer Tests folgt\")\n",
+    "    print(\"=\" * 78)\n",
+    "    print(\"  Ein Test der Form  assert plan == erwarteter_plan  besteht mal und\")\n",
+    "    print(\"  scheitert mal, ohne dass sich am Code etwas geaendert haette.\")\n",
+    "    print(\"  Zu pruefen sind stattdessen:\")\n",
+    "    print(\"    * der ZIELWERT (hier in allen Laeufen gleich),\")\n",
+    "    print(\"    * die Einhaltung aller Regeln (Abnahmepruefung, Kapitel Praxisfallen),\")\n",
+    "    print(\"    * und der Status - nicht die Gestalt der Loesung.\")\n",
+    "    print(\"\\n  Wer doch einen bestimmten Plan braucht - fuer eine abgedruckte\")\n",
+    "    print(\"  Ausgabe, fuer einen Regressionstest -, setzt num_workers = 1.\")\n",
+    "    print(f\"  Das kostet hier den Faktor {faktor:.1f} an Laufzeit und ist genau\")\n",
+    "    print(\"  deshalb eine Entscheidung fuer den Test, nicht fuer den Betrieb.\")\n",
+    "    print(\"=\" * 78)"
+   ]
+  },
   {
    "cell_type": "markdown",
    "metadata": {},
diff --git a/Notebooks_04/finanzdaten.ipynb b/Notebooks_04/finanzdaten.ipynb
index 99ff2e3..0d3f0e8 100644
--- a/Notebooks_04/finanzdaten.ipynb
+++ b/Notebooks_04/finanzdaten.ipynb
@@ -455,7 +455,8 @@
     "    exakt positiv semidefinit ist - rechne trotzdem.' Das ist hier bewusst so\n",
     "    gewaehlt, denn genau diese Eigenschaft wollen wir vorfuehren. Im\n",
     "    Produktivbetrieb waere die DCP-Fehlermeldung das Warnsignal, dem man\n",
-    "    nachgehen muss (siehe Denkfehler 8.1).\n",
+    "    nachgehen muss (siehe den Denkfehler im Kapitel Quadratische und\n",
+    "    nichtlineare Optimierung).\n",
     "    \"\"\"\n",
     "    gewichte = cp.Variable(ANZAHL_ANLAGEN)\n",
     "    problem = cp.Problem(cp.Minimize(cp.quad_form(gewichte, cp.psd_wrap(kovarianz))),\n",
diff --git a/Notebooks_04/milp.ipynb b/Notebooks_04/milp.ipynb
index 6ee1d17..a9bb7ca 100644
--- a/Notebooks_04/milp.ipynb
+++ b/Notebooks_04/milp.ipynb
@@ -757,7 +757,8 @@
     "\n",
     "    loeser = cp_model.CpSolver()\n",
     "    loeser.parameters.max_time_in_seconds = zeitlimit\n",
-    "    # Ein Arbeiter und fester Startwert, damit die Messung reproduzierbar ist.\n",
+    "    # Ein Arbeiter und fester Startwert, damit die Messung reproduzierbar ist -\n",
+    "    # der Seed allein genuegt dafuer NICHT (Kapitel Constraint Programming).\n",
     "    # Im Produktivbetrieb laesst man beides auf den Standardwerten.\n",
     "    loeser.parameters.num_workers = 1\n",
     "    loeser.parameters.random_seed = 1\n",
diff --git a/Notebooks_04/oekosystem.ipynb b/Notebooks_04/oekosystem.ipynb
index eb02e7e..ae42071 100644
--- a/Notebooks_04/oekosystem.ipynb
+++ b/Notebooks_04/oekosystem.ipynb
@@ -115,7 +115,7 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "## Ein System — vier Programmieransätze\n",
+    "## Wie die Isolation aussieht, wenn sie tragen soll\n",
     "\n",
     "`Ein_System_Vier_Ansaetze.py`\n"
    ]
@@ -136,85 +136,104 @@
     "          2*x1 + 3*x2 + x3 <= 50\n",
     "          x >= 0\n",
     "\n",
-    "Deckt scipy.optimize, highspy, CVXPY und OR-Tools/GLOP ab, mit Kreuzvergleich am Ende.\n",
+    "Deckt scipy.optimize, highspy, CVXPY und OR-Tools/GLOP ab, mit Kreuzvergleich\n",
+    "am Ende.\n",
     "\n",
-    "WICHTIG: Jeder Solver läuft in einem EIGENEN Prozess, weil sich ortools und\n",
+    "WICHTIG: Jeder Solver laeuft in einem EIGENEN Prozess, weil sich ortools und\n",
     "highspy auf vielen Systemen nicht gemeinsam importieren lassen (beide bringen\n",
     "eine eigene HiGHS-Kopie mit -> Symbolkonflikt).\n",
+    "\n",
+    "Die Isolation besorgt ein ProcessPoolExecutor. Drei Einstellungen ergeben\n",
+    "zusammen die Garantie:\n",
+    "\n",
+    "  mp_context \"spawn\"     Der Kindprozess startet mit einem FRISCHEN\n",
+    "                         Interpreter, statt den Speicher des Elternprozesses\n",
+    "                         zu erben. Was hier schon importiert ist, ist dort\n",
+    "                         nicht importiert. Mit dem Standard \"fork\" auf Linux\n",
+    "                         waere das nicht so.\n",
+    "  max_tasks_per_child=1  Jede Aufgabe bekommt einen NEUEN Prozess. Ohne das\n",
+    "                         wuerde der Pool seinen Arbeiter wiederverwenden - und\n",
+    "                         beim zweiten Solver waere der Konflikt zurueck.\n",
+    "  max_workers=1          Haelt die vier Laeufe nacheinander. Nicht aus\n",
+    "                         Vorsicht, sondern damit die gemessenen Zeiten\n",
+    "                         vergleichbar bleiben.\n",
+    "\n",
+    "Jeder Solver steht in einer eigenen Funktion mit LOKALEM Import. Das ist der\n",
+    "Unterschied zu einem Codestring, den man an 'python -c' uebergibt: Die\n",
+    "Funktion laesst sich einzeln aufrufen, testen und vom Editor pruefen - ein\n",
+    "String nicht.\n",
+    "\n",
+    "Benoetigt: scipy, highspy, cvxpy, ortools\n",
     "\"\"\"\n",
     "\n",
-    "import json\n",
-    "import subprocess\n",
-    "import sys\n",
-    "import textwrap\n",
+    "import multiprocessing\n",
     "import time\n",
+    "from concurrent.futures import ProcessPoolExecutor\n",
     "\n",
     "ERWARTET = 530.0            # Ergebnis der Handrechnung zum Produktionsprogramm\n",
     "\n",
-    "# Jeder Eintrag ist ein eigenständiges Miniprogramm, das sein Ergebnis als\n",
-    "# JSON auf stdout ausgibt. So bleibt jeder Import in seinem eigenen Prozess.\n",
-    "ANSAETZE: dict[str, str] = {\n",
+    "# Die Instanz - einmal notiert, von allen vier Funktionen benutzt.\n",
+    "ZIEL = [10.0, 15.0, 25.0]\n",
+    "MATRIX = [[1, 1, 2], [2, 3, 1]]\n",
+    "KAPAZITAET = [40.0, 50.0]\n",
     "\n",
-    "    \"scipy.optimize.linprog\": \"\"\"\n",
-    "        from scipy.optimize import linprog\n",
-    "        res = linprog(c=[-10.0, -15.0, -25.0],           # linprog MINIMIERT -> negieren\n",
-    "                      A_ub=[[1, 1, 2], [2, 3, 1]], b_ub=[40, 50],\n",
-    "                      bounds=[(0, None)] * 3, method=\"highs\")\n",
-    "        ausgabe = (-res.fun, list(res.x))\n",
-    "    \"\"\",\n",
     "\n",
-    "    \"highspy (natives HiGHS)\": \"\"\"\n",
-    "        import numpy as np, highspy\n",
-    "        h = highspy.Highs()\n",
-    "        h.setOptionValue(\"output_flag\", False)\n",
-    "        h.addVars(3, np.zeros(3), np.full(3, highspy.kHighsInf))\n",
-    "        h.changeObjectiveSense(highspy.ObjSense.kMaximize)\n",
-    "        for j, wert in enumerate([10.0, 15.0, 25.0]):\n",
-    "            h.changeColCost(j, wert)\n",
-    "        # CSR-Format: starts[i] = Beginn von Zeile i in indices/values\n",
-    "        h.addRows(2, np.full(2, -highspy.kHighsInf), np.array([40.0, 50.0]), 6,\n",
-    "                  np.array([0, 3], dtype=np.int32),\n",
-    "                  np.array([0, 1, 2, 0, 1, 2], dtype=np.int32),\n",
-    "                  np.array([1.0, 1.0, 2.0, 2.0, 3.0, 1.0]))\n",
-    "        h.run()\n",
-    "        ausgabe = (h.getInfo().objective_function_value,\n",
-    "                   list(h.getSolution().col_value[:3]))\n",
-    "    \"\"\",\n",
+    "def loese_mit_scipy() -> tuple[float, list[float]]:\n",
+    "    from scipy.optimize import linprog\n",
+    "    ergebnis = linprog(c=[-w for w in ZIEL],          # linprog MINIMIERT -> negieren\n",
+    "                       A_ub=MATRIX, b_ub=KAPAZITAET,\n",
+    "                       bounds=[(0, None)] * 3, method=\"highs\")\n",
+    "    return -ergebnis.fun, list(ergebnis.x)\n",
     "\n",
-    "    \"cvxpy\": \"\"\"\n",
-    "        import numpy as np, cvxpy as cp\n",
-    "        x = cp.Variable(3, nonneg=True)\n",
-    "        problem = cp.Problem(cp.Maximize(np.array([10.0, 15.0, 25.0]) @ x),\n",
-    "                             [np.array([[1, 1, 2], [2, 3, 1]]) @ x <= np.array([40, 50])])\n",
-    "        problem.solve()\n",
-    "        ausgabe = (float(problem.value), [float(v) for v in x.value])\n",
-    "    \"\"\",\n",
     "\n",
-    "    \"ortools / GLOP\": \"\"\"\n",
-    "        from ortools.linear_solver import pywraplp\n",
-    "        s = pywraplp.Solver.CreateSolver(\"GLOP\")\n",
-    "        x = [s.NumVar(0, s.infinity(), f\"x{j+1}\") for j in range(3)]\n",
-    "        A = [[1, 1, 2], [2, 3, 1]]\n",
-    "        for i, kap in enumerate([40, 50]):\n",
-    "            s.Add(sum(A[i][j] * x[j] for j in range(3)) <= kap)\n",
-    "        s.Maximize(10 * x[0] + 15 * x[1] + 25 * x[2])\n",
-    "        s.Solve()\n",
-    "        ausgabe = (s.Objective().Value(), [v.solution_value() for v in x])\n",
-    "    \"\"\",\n",
+    "def loese_mit_highspy() -> tuple[float, list[float]]:\n",
+    "    import highspy\n",
+    "    import numpy as np\n",
+    "    h = highspy.Highs()\n",
+    "    h.setOptionValue(\"output_flag\", False)\n",
+    "    h.addVars(3, np.zeros(3), np.full(3, highspy.kHighsInf))\n",
+    "    h.changeObjectiveSense(highspy.ObjSense.kMaximize)\n",
+    "    for j, wert in enumerate(ZIEL):\n",
+    "        h.changeColCost(j, wert)\n",
+    "    # CSR-Format: starts[i] = Beginn von Zeile i in indices/values\n",
+    "    h.addRows(2, np.full(2, -highspy.kHighsInf), np.array(KAPAZITAET), 6,\n",
+    "              np.array([0, 3], dtype=np.int32),\n",
+    "              np.array([0, 1, 2, 0, 1, 2], dtype=np.int32),\n",
+    "              np.array([float(w) for zeile in MATRIX for w in zeile]))\n",
+    "    h.run()\n",
+    "    return (h.getInfo().objective_function_value,\n",
+    "            list(h.getSolution().col_value[:3]))\n",
+    "\n",
+    "\n",
+    "def loese_mit_cvxpy() -> tuple[float, list[float]]:\n",
+    "    import cvxpy as cp\n",
+    "    import numpy as np\n",
+    "    x = cp.Variable(3, nonneg=True)\n",
+    "    problem = cp.Problem(cp.Maximize(np.array(ZIEL) @ x),\n",
+    "                         [np.array(MATRIX) @ x <= np.array(KAPAZITAET)])\n",
+    "    problem.solve()\n",
+    "    return float(problem.value), [float(v) for v in x.value]\n",
+    "\n",
+    "\n",
+    "def loese_mit_ortools() -> tuple[float, list[float]]:\n",
+    "    from ortools.linear_solver import pywraplp\n",
+    "    s = pywraplp.Solver.CreateSolver(\"GLOP\")\n",
+    "    x = [s.NumVar(0, s.infinity(), f\"x{j+1}\") for j in range(3)]\n",
+    "    for i, kapazitaet in enumerate(KAPAZITAET):\n",
+    "        s.Add(sum(MATRIX[i][j] * x[j] for j in range(3)) <= kapazitaet)\n",
+    "    s.Maximize(sum(ZIEL[j] * x[j] for j in range(3)))\n",
+    "    s.Solve()\n",
+    "    return s.Objective().Value(), [v.solution_value() for v in x]\n",
+    "\n",
+    "\n",
+    "ANSAETZE = {\n",
+    "    \"scipy.optimize.linprog\": loese_mit_scipy,\n",
+    "    \"highspy (natives HiGHS)\": loese_mit_highspy,\n",
+    "    \"cvxpy\": loese_mit_cvxpy,\n",
+    "    \"ortools / GLOP\": loese_mit_ortools,\n",
     "}\n",
     "\n",
     "\n",
-    "def fuehre_in_eigenem_prozess_aus(quelltext: str) -> tuple[float, list[float]]:\n",
-    "    \"\"\"Startet den Codeschnipsel als separaten Python-Prozess und liest das Ergebnis.\"\"\"\n",
-    "    programm = textwrap.dedent(quelltext) + \"\\nimport json; print(json.dumps(ausgabe))\\n\"\n",
-    "    ergebnis = subprocess.run([sys.executable, \"-c\", programm],\n",
-    "                              capture_output=True, text=True, timeout=120)\n",
-    "    if ergebnis.returncode != 0:\n",
-    "        raise RuntimeError(ergebnis.stderr.strip().splitlines()[-1])\n",
-    "    wert, loesung = json.loads(ergebnis.stdout.strip().splitlines()[-1])\n",
-    "    return wert, loesung\n",
-    "\n",
-    "\n",
     "if __name__ == \"__main__\":\n",
     "    print(\"=\" * 78)\n",
     "    print(\"  EIN SYSTEM - VIER ANSAETZE (je eigener Prozess)\")\n",
@@ -223,17 +242,23 @@
     "    print(\"-\" * 78)\n",
     "\n",
     "    werte = []\n",
-    "    for name, quelltext in ANSAETZE.items():\n",
-    "        t0 = time.perf_counter()\n",
-    "        try:\n",
-    "            wert, x = fuehre_in_eigenem_prozess_aus(quelltext)\n",
-    "        except RuntimeError as fehler:\n",
-    "            print(f\"{name:<26} nicht verfuegbar: {fehler[:40]}\")\n",
-    "            continue\n",
-    "        dauer = time.perf_counter() - t0\n",
-    "        werte.append(wert)\n",
-    "        print(f\"{name:<26} {wert:>10.2f} {x[0]:>7.2f} {x[1]:>7.2f} {x[2]:>7.2f} \"\n",
-    "              f\"{dauer:>8.2f} s\")\n",
+    "    # Ein Pool, vier Aufgaben, vier frische Prozesse. Der Kontext muss\n",
+    "    # \"spawn\" sein - siehe Modulkommentar.\n",
+    "    with ProcessPoolExecutor(\n",
+    "            max_workers=1,\n",
+    "            mp_context=multiprocessing.get_context(\"spawn\"),\n",
+    "            max_tasks_per_child=1) as pool:\n",
+    "        for name, funktion in ANSAETZE.items():\n",
+    "            beginn = time.perf_counter()\n",
+    "            try:\n",
+    "                wert, x = pool.submit(funktion).result(timeout=120)\n",
+    "            except Exception as fehler:                     # Bibliothek fehlt o. Ae.\n",
+    "                print(f\"{name:<26} nicht verfuegbar: {str(fehler)[:40]}\")\n",
+    "                continue\n",
+    "            dauer = time.perf_counter() - beginn\n",
+    "            werte.append(wert)\n",
+    "            print(f\"{name:<26} {wert:>10.2f} {x[0]:>7.2f} {x[1]:>7.2f} {x[2]:>7.2f} \"\n",
+    "                  f\"{dauer:>8.2f} s\")\n",
     "\n",
     "    print(\"-\" * 78)\n",
     "    spanne = max(werte) - min(werte)\n",
@@ -243,8 +268,8 @@
     "    assert spanne < 1e-6, \"Die Bibliotheken widersprechen sich!\"\n",
     "    assert abs(werte[0] - ERWARTET) < 1e-6, \"Ergebnis weicht von der Handrechnung ab!\"\n",
     "    print(\"Alle Wege fuehren zum selben, von Hand bestaetigten Optimum.\")\n",
-    "    print(\"(Die Zeiten enthalten den Prozessstart und den Import - sie messen\")\n",
-    "    print(\" NICHT die reine Solverleistung, siehe Uebung 3.5.)\")\n",
+    "    print(\"(Die Zeiten enthalten Prozessstart und Import - sie messen NICHT die\")\n",
+    "    print(\" reine Solverleistung. Die Uebungsaufgabe 'Laufzeitvergleich' trennt beides.)\")\n",
     "    print(\"=\" * 78)"
    ]
   },
diff --git a/Notebooks_04/praxisfallen.ipynb b/Notebooks_04/praxisfallen.ipynb
index 9af1b14..73bd1ba 100644
--- a/Notebooks_04/praxisfallen.ipynb
+++ b/Notebooks_04/praxisfallen.ipynb
@@ -252,6 +252,328 @@
     "    print(\"=\" * 78)"
    ]
   },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Constraint Attribution: welche Bedingung kostet wie viel?\n",
+    "\n",
+    "`Constraint_Attribution.py`\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "#!/usr/bin/env python3\n",
+    "\n",
+    "# Constraint_Attribution.py\n",
+    "\"\"\"\n",
+    "Kapitel Praxisfallen: Welche Bedingung kostet wie viel - und was sagt man\n",
+    "dem Management?\n",
+    "\n",
+    "Zwischen den beiden bekannten Faellen klafft eine Luecke:\n",
+    "\n",
+    "  * Erklaerbarkeit.py beantwortet \"warum diese eine Zuweisung?\"\n",
+    "  * Konfliktsuche.py (Anhang Fehlerdiagnose) beantwortet \"warum geht es gar\n",
+    "    nicht?\"\n",
+    "\n",
+    "Der haeufigste Fall in der Praxis liegt dazwischen: Das Modell rechnet, der\n",
+    "Plan ist zulaessig - und trotzdem unbefriedigend. Niemand weiss, WORAN es\n",
+    "liegt. Genau das beantwortet Constraint Attribution.\n",
+    "\n",
+    "Gerechnet wird auf derselben Fabrik wie in Konfliktsuche.py, nur nach der\n",
+    "Reparatur: Dort war die Lackierkapazitaet von 150 Stunden der Kern des\n",
+    "Widerspruchs (2*40 + 3*30 = 170 > 150). Eine zweite Schicht hat sie auf 210\n",
+    "gebracht, und der Mindestumsatz wurde auf 10.000 EUR gesenkt. Jetzt ist das\n",
+    "Modell loesbar - und die Frage lautet nicht mehr \"warum nicht?\", sondern\n",
+    "\"was kostet uns was?\".\n",
+    "\n",
+    "Gezeigt werden vier Dinge:\n",
+    "  1. Welche Bedingungen binden - und dass \"bindend\" nicht \"teuer\" heisst.\n",
+    "  2. Dass der Schattenpreis eine MOMENTAUFNAHME ist: hochgerechnet auf eine\n",
+    "     realistische Sonderschicht verspricht er hier das Doppelte des\n",
+    "     tatsaechlichen Nutzens.\n",
+    "  3. Dass ein Wunsch aus dem Vertrieb nicht teuer, sondern unmoeglich sein\n",
+    "     kann - und welche Bedingungen ihn gemeinsam blockieren.\n",
+    "  4. Wie aus alledem ein Bericht in Alltagssprache wird.\n",
+    "\n",
+    "Benoetigt: numpy, scipy\n",
+    "\"\"\"\n",
+    "\n",
+    "from __future__ import annotations\n",
+    "\n",
+    "import textwrap\n",
+    "\n",
+    "import numpy as np\n",
+    "from scipy.optimize import linprog\n",
+    "\n",
+    "PRODUKTE = [\"Rahmen\", \"Gehaeuse\", \"Deckel\", \"Traeger\", \"Halter\"]\n",
+    "DECKUNGSBEITRAG = np.array([35.0, 28.0, 9.0, 22.0, 6.0])   # EUR je Stueck\n",
+    "\n",
+    "# Dieselben Bedingungen wie in Konfliktsuche.py, mit den beiden Reparaturen.\n",
+    "# Der sprechende Name ist keine Kosmetik: Ohne ihn ist kein Bericht moeglich,\n",
+    "# der jemandem ausserhalb der Modellierung etwas sagt.\n",
+    "BEDINGUNGEN: list[tuple[str, list[float], str, float]] = [\n",
+    "    (\"Kapazitaet Montage\",       [3, 2, 1, 4, 2],      \"<=\",   400),\n",
+    "    (\"Kapazitaet Lackieren\",     [2, 3, 0, 1, 0],      \"<=\",   210),\n",
+    "    (\"Kapazitaet Pruefung\",      [1, 1, 1, 1, 1],      \"<=\",   300),\n",
+    "    (\"Liefervertrag Rahmen\",     [1, 0, 0, 0, 0],      \">=\",    40),\n",
+    "    (\"Liefervertrag Gehaeuse\",   [0, 1, 0, 0, 0],      \">=\",    30),\n",
+    "    (\"Liefervertrag Deckel\",     [0, 0, 1, 0, 0],      \">=\",    20),\n",
+    "    (\"Liefervertrag Traeger\",    [0, 0, 0, 1, 0],      \">=\",    25),\n",
+    "    (\"Marktgrenze Rahmen\",       [1, 0, 0, 0, 0],      \"<=\",   120),\n",
+    "    (\"Marktgrenze Gehaeuse\",     [0, 1, 0, 0, 0],      \"<=\",    90),\n",
+    "    (\"Marktgrenze Deckel\",       [0, 0, 1, 0, 0],      \"<=\",   150),\n",
+    "    (\"Marktgrenze Halter\",       [0, 0, 0, 0, 1],      \"<=\",   200),\n",
+    "    (\"Mindestumsatz\",            [90, 70, 30, 60, 20], \">=\", 10000),\n",
+    "    (\"Sortimentsbreite\",         [0, 0, 1, 1, 1],      \">=\",   100),\n",
+    "    (\"Lackierbudget Schicht 2\",  [0, 1, 0, 1, 0],      \"<=\",    55),\n",
+    "]\n",
+    "\n",
+    "# Was liesse sich im Ernstfall wirklich bewegen - und um wie viel? Nicht \"eine\n",
+    "# Einheit\", sondern der Schritt, den ein Planer tatsaechlich gehen kann: eine\n",
+    "# Sonderschicht, ein nachverhandelter Vertrag. Genau an dieser Groesse\n",
+    "# scheitert das blosse Hochrechnen des Schattenpreises.\n",
+    "STELLSCHRAUBEN: dict[str, tuple[float, str]] = {\n",
+    "    \"Kapazitaet Montage\":      (+50, \"eine Sonderschicht Montage\"),\n",
+    "    \"Kapazitaet Lackieren\":    (+30, \"eine Sonderschicht Lackieren\"),\n",
+    "    \"Kapazitaet Pruefung\":     (+50, \"eine Sonderschicht Pruefung\"),\n",
+    "    \"Lackierbudget Schicht 2\": (+10, \"10 Stunden mehr Budget in Schicht 2\"),\n",
+    "    \"Liefervertrag Traeger\":   (-10, \"10 Stueck weniger Abnahmepflicht Traeger\"),\n",
+    "    \"Liefervertrag Gehaeuse\":  (-10, \"10 Stueck weniger Abnahmepflicht Gehaeuse\"),\n",
+    "}\n",
+    "\n",
+    "WUNSCH_MENGE = 55.0      # der Vertrieb haette gern mehr Rahmen\n",
+    "WUNSCH_PRODUKT = \"Rahmen\"\n",
+    "\n",
+    "\n",
+    "def loese(bedingungen: list[tuple[str, list[float], str, float]]):\n",
+    "    \"\"\"Maximiert den Deckungsbeitrag. linprog minimiert, daher das Vorzeichen.\"\"\"\n",
+    "    matrix, rechte_seite = [], []\n",
+    "    for _, koeffizienten, richtung, grenze in bedingungen:\n",
+    "        zeile = np.array(koeffizienten, dtype=float)\n",
+    "        matrix.append(zeile if richtung == \"<=\" else -zeile)\n",
+    "        rechte_seite.append(grenze if richtung == \"<=\" else -grenze)\n",
+    "    return linprog(-DECKUNGSBEITRAG,\n",
+    "                   A_ub=np.array(matrix), b_ub=np.array(rechte_seite),\n",
+    "                   bounds=[(0, None)] * len(PRODUKTE), method=\"highs\")\n",
+    "\n",
+    "\n",
+    "def geaendert(name: str, delta: float,\n",
+    "              basis=None) -> list[tuple[str, list[float], str, float]]:\n",
+    "    \"\"\"Dieselben Bedingungen, eine davon um delta verschoben.\"\"\"\n",
+    "    return [(n, k, r, g + delta if n == name else g)\n",
+    "            for n, k, r, g in (basis or BEDINGUNGEN)]\n",
+    "\n",
+    "\n",
+    "def auswertung(ergebnis, bedingungen=None):\n",
+    "    \"\"\"Schlupf und Schattenpreis je Bedingung.\"\"\"\n",
+    "    x = ergebnis.x\n",
+    "    dual = ergebnis.ineqlin.marginals\n",
+    "    zeilen = []\n",
+    "    for i, (name, koeff, richtung, grenze) in enumerate(bedingungen or BEDINGUNGEN):\n",
+    "        links = float(np.array(koeff, dtype=float) @ x)\n",
+    "        schlupf = (grenze - links) if richtung == \"<=\" else (links - grenze)\n",
+    "        zeilen.append((name, links, richtung, grenze, schlupf, abs(dual[i])))\n",
+    "    return zeilen\n",
+    "\n",
+    "\n",
+    "def blockierer(bedingungen, zusatz) -> list[str]:\n",
+    "    \"\"\"Welche Bedingungen verhindern 'zusatz' - einzeln weggelassen.\n",
+    "\n",
+    "    Dasselbe Vorgehen wie der Deletion Filter in Konfliktsuche.py, nur mit\n",
+    "    umgekehrtem Vorzeichen: Dort wird gesucht, was den Widerspruch AUSMACHT,\n",
+    "    hier, was einen Wunsch VERHINDERT. Wird das Modell ohne eine Bedingung\n",
+    "    loesbar, gehoert sie zum Konflikt.\n",
+    "    \"\"\"\n",
+    "    gefunden = []\n",
+    "    for i, (name, _, _, _) in enumerate(bedingungen):\n",
+    "        rest = [c for j, c in enumerate(bedingungen) if j != i] + [zusatz]\n",
+    "        if loese(rest).success:\n",
+    "            gefunden.append(name)\n",
+    "    return gefunden\n",
+    "\n",
+    "\n",
+    "def euro(betrag: float) -> str:\n",
+    "    return f\"{betrag:,.2f} EUR\"\n",
+    "\n",
+    "\n",
+    "if __name__ == \"__main__\":\n",
+    "    basis = loese(BEDINGUNGEN)\n",
+    "    db_basis = -basis.fun\n",
+    "    plan = dict(zip(PRODUKTE, basis.x))\n",
+    "\n",
+    "    print(\"=\" * 78)\n",
+    "    print(\"  CONSTRAINT ATTRIBUTION: Was kostet uns welche Bedingung?\")\n",
+    "    print(\"=\" * 78)\n",
+    "    print(f\"Status: {basis.message.split('(')[0].strip()}\")\n",
+    "    print(f\"Deckungsbeitrag des Plans: {euro(db_basis)}\\n\")\n",
+    "    print(\"  \" + \"  \".join(f\"{p}: {m:.1f}\" for p, m in plan.items()))\n",
+    "\n",
+    "    # --- 1. Wer begrenzt den Plan? -----------------------------------------\n",
+    "    print(\"\\n\" + \"=\" * 78)\n",
+    "    print(\"  (1) Welche Bedingungen binden - und was kostet die naechste Einheit?\")\n",
+    "    print(\"=\" * 78)\n",
+    "    print(f\"{'Bedingung':<24} {'genutzt':>9} {'Grenze':>7} {'Schlupf':>8} \"\n",
+    "          f\"{'Schattenpreis':>11}\")\n",
+    "    print(\"-\" * 78)\n",
+    "    bindend = []\n",
+    "    for name, links, richtung, grenze, schlupf, dual in auswertung(basis):\n",
+    "        marke = \"\"\n",
+    "        if abs(schlupf) < 1e-6:\n",
+    "            bindend.append((name, dual))\n",
+    "            marke = \"  <-- bindend\"\n",
+    "        print(f\"{name:<24} {links:>9.1f} {grenze:>7.0f} {schlupf:>8.1f} \"\n",
+    "              f\"{dual:>11.2f}{marke}\")\n",
+    "\n",
+    "    ohne_preis = [n for n, d in bindend if d < 1e-9]\n",
+    "    print(f\"\\n  {len(bindend)} Bedingungen binden. Aber: \"\n",
+    "          f\"{', '.join(ohne_preis)} bindet\")\n",
+    "    print(\"  mit einem Schattenpreis von 0,00 EUR - sie beruehrt den Plan, ohne ihn\")\n",
+    "    print(\"  zu verteuern. Bindend und kostenrelevant sind zwei verschiedene Dinge.\")\n",
+    "\n",
+    "    # --- 2. Der Schattenpreis als Momentaufnahme ---------------------------\n",
+    "    print(\"\\n\" + \"=\" * 78)\n",
+    "    print(\"  (2) Was der Schattenpreis verschweigt\")\n",
+    "    print(\"=\" * 78)\n",
+    "    print(\"Der Schattenpreis gilt fuer die NAECHSTE Einheit. Ein Planer kauft aber\")\n",
+    "    print(\"keine Einheit, sondern eine ganze Schicht. Beides gegenuebergestellt:\\n\")\n",
+    "    preise = {name: dual for name, *_, dual in auswertung(basis)}\n",
+    "    print(f\"{'Stellschraube':<24} {'Preis':>9} {'Schritt':>7} \"\n",
+    "          f\"{'hochgerechnet':>13} {'gemessen':>9} {'Abw.':>9}\")\n",
+    "    print(\"-\" * 78)\n",
+    "    wirkung = {}\n",
+    "    for name, (delta, _) in STELLSCHRAUBEN.items():\n",
+    "        ergebnis = loese(geaendert(name, delta))\n",
+    "        echt = (-ergebnis.fun) - db_basis if ergebnis.success else 0.0\n",
+    "        linear = preise[name] * abs(delta)\n",
+    "        wirkung[name] = echt\n",
+    "        print(f\"{name:<24} {preise[name]:>9.2f} {delta:>+7.0f} \"\n",
+    "              f\"{linear:>13.2f} {echt:>9.2f} {echt - linear:>+9.2f}\")\n",
+    "\n",
+    "    # Wo endet der Gueltigkeitsbereich? Schrittweise nachfahren.\n",
+    "    abweichler = max(STELLSCHRAUBEN,\n",
+    "                     key=lambda n: preise[n] * abs(STELLSCHRAUBEN[n][0]) - wirkung[n])\n",
+    "    delta_max = STELLSCHRAUBEN[abweichler][0]\n",
+    "    grenze_gueltig = 0.0\n",
+    "    schritt = delta_max / 60.0\n",
+    "    vorher = db_basis\n",
+    "    for i in range(1, 61):\n",
+    "        d = schritt * i\n",
+    "        e = loese(geaendert(abweichler, d))\n",
+    "        db = -e.fun if e.success else vorher\n",
+    "        if db - vorher > 1e-9:\n",
+    "            grenze_gueltig = d\n",
+    "        vorher = db\n",
+    "    print(f\"\\n  '{abweichler}': hochgerechnet \"\n",
+    "          f\"{preise[abweichler] * abs(delta_max):.2f} EUR, tatsaechlich \"\n",
+    "          f\"{wirkung[abweichler]:.2f} EUR.\")\n",
+    "    print(f\"  Der Preis von {preise[abweichler]:.2f} EUR gilt nur bis \"\n",
+    "          f\"+{grenze_gueltig:.0f} Stunden. Jede weitere Stunde\")\n",
+    "    print(\"  dieser Sonderschicht bringt exakt nichts - der Engpass ist dann ein anderer.\")\n",
+    "\n",
+    "    nach_preis = sorted(STELLSCHRAUBEN, key=lambda n: -preise[n])[0]\n",
+    "    nach_wirkung = max(wirkung, key=wirkung.get)\n",
+    "    print(f\"\\n  Und die Ranglisten drehen sich: Nach Schattenpreis fuehrt\")\n",
+    "    print(f\"  '{nach_preis}' ({preise[nach_preis]:.2f} EUR je Einheit),\")\n",
+    "    print(f\"  nach tatsaechlicher Wirkung '{nach_wirkung}' \"\n",
+    "          f\"({wirkung[nach_wirkung]:.2f} EUR).\")\n",
+    "    print(\"  Der Schattenpreis sagt, was eine Einheit wert ist - nicht, wie viele\")\n",
+    "    print(\"  Einheiten zu haben sind.\")\n",
+    "\n",
+    "    # --- 3. Der Wunsch aus dem Vertrieb ------------------------------------\n",
+    "    print(\"\\n\" + \"=\" * 78)\n",
+    "    print(f\"  (3) Was-waere-wenn: mindestens {WUNSCH_MENGE:.0f} \"\n",
+    "          f\"{WUNSCH_PRODUKT} statt {plan[WUNSCH_PRODUKT]:.1f}\")\n",
+    "    print(\"=\" * 78)\n",
+    "    wunsch = (f\"Wunsch Vertrieb {WUNSCH_PRODUKT}\",\n",
+    "              [1 if p == WUNSCH_PRODUKT else 0 for p in PRODUKTE], \">=\", WUNSCH_MENGE)\n",
+    "    mit_wunsch = loese(BEDINGUNGEN + [wunsch])\n",
+    "    schuldige: list[str] = []\n",
+    "    engpass = noetig = None\n",
+    "    wunsch_gratis = False\n",
+    "\n",
+    "    if mit_wunsch.success:\n",
+    "        print(f\"Erfuellbar, kostet {euro(db_basis - (-mit_wunsch.fun))}.\")\n",
+    "    else:\n",
+    "        schuldige = blockierer(BEDINGUNGEN, wunsch)\n",
+    "        print(\"Der Wunsch ist nicht teuer - er ist UNMOEGLICH.\\n\")\n",
+    "        print(f\"Blockiert wird er von {len(schuldige)} Bedingungen gemeinsam. \"\n",
+    "              f\"Faellt eine davon\")\n",
+    "        print(\"weg, ist er erfuellbar; keine allein ist 'der' Grund:\")\n",
+    "        for name in schuldige:\n",
+    "            e = loese([c for c in BEDINGUNGEN if c[0] != name] + [wunsch])\n",
+    "            print(f\"   ohne '{name}': moeglich, Deckungsbeitrag {euro(-e.fun)}\")\n",
+    "\n",
+    "        engpass = next((n for n in schuldige if n in STELLSCHRAUBEN), schuldige[0])\n",
+    "        for schritt in range(1, 61):\n",
+    "            if loese(geaendert(engpass, schritt) + [wunsch]).success:\n",
+    "                noetig = schritt\n",
+    "                break\n",
+    "        if noetig is not None:\n",
+    "            e = loese(geaendert(engpass, noetig) + [wunsch])\n",
+    "            ohne = loese(geaendert(engpass, noetig))\n",
+    "            wunsch_gratis = abs((-e.fun) - (-ohne.fun)) < 1e-6\n",
+    "            print(f\"\\n   Mit +{noetig} bei '{engpass}' wird der Wunsch erfuellbar:\")\n",
+    "            print(f\"   Deckungsbeitrag {euro(-e.fun)} \"\n",
+    "                  f\"({-e.fun - db_basis:+,.2f} gegenueber heute).\")\n",
+    "            if wunsch_gratis:\n",
+    "                print(f\"   Und ohne den Wunsch ergaebe dieselbe Lockerung \"\n",
+    "                      f\"{euro(-ohne.fun)} bei\")\n",
+    "                print(f\"   {ohne.x[PRODUKTE.index(WUNSCH_PRODUKT)]:.0f} \"\n",
+    "                      f\"{WUNSCH_PRODUKT} - der Wunsch kostet also NICHTS.\")\n",
+    "                print(\"   Er war nie das Problem. Der Engpass war es.\")\n",
+    "\n",
+    "    # --- 4. Der Bericht ----------------------------------------------------\n",
+    "    # Aus denselben Zahlen, die oben in Tabellen stehen, wird hier Prosa. Kein\n",
+    "    # Satz enthaelt eine Zahl, die nicht vorher gerechnet wurde - das ist der\n",
+    "    # ganze Trick und zugleich die Bedingung dafuer, dass der Bericht nicht\n",
+    "    # irgendwann leise falsch wird.\n",
+    "    print(\"\\n\" + \"=\" * 78)\n",
+    "    print(\"  (4) Und so steht es in der Vorlage fuer die Abteilungsleiterrunde\")\n",
+    "    print(\"=\" * 78)\n",
+    "\n",
+    "    teuerste = sorted(((n, d) for n, d in bindend if d > 0), key=lambda t: -t[1])\n",
+    "    gross = STELLSCHRAUBEN[nach_wirkung][1]\n",
+    "    klein = STELLSCHRAUBEN[abweichler][1]\n",
+    "\n",
+    "    absaetze = [\n",
+    "        f\"Der Plan bringt {euro(db_basis)} Deckungsbeitrag. Begrenzt wird er von \"\n",
+    "        f\"{len(bindend)} Bedingungen, von denen {len(teuerste)} tatsaechlich Geld \"\n",
+    "        f\"kosten; \\\"{ohne_preis[0]}\\\" beruehrt den Plan, ohne ihn zu verteuern.\",\n",
+    "\n",
+    "        f\"Teuerste Bindung ist \\\"{teuerste[0][0]}\\\" mit \"\n",
+    "        f\"{teuerste[0][1]:.2f} EUR je Einheit, gefolgt von \\\"{teuerste[1][0]}\\\" \"\n",
+    "        f\"mit {teuerste[1][1]:.2f} EUR.\",\n",
+    "\n",
+    "        f\"Die groesste einzelne Verbesserung bringt {gross}: \"\n",
+    "        f\"{euro(wirkung[nach_wirkung])} mehr Deckungsbeitrag. {klein[0].upper()}{klein[1:]} \"\n",
+    "        f\"dagegen bringt nur {euro(wirkung[abweichler])} statt der rechnerischen \"\n",
+    "        f\"{euro(preise[abweichler] * abs(delta_max))} - ab +{grenze_gueltig:.0f} \"\n",
+    "        f\"Stunden begrenzt uns etwas anderes. Wer die ganze Schicht bezahlt, \"\n",
+    "        f\"bezahlt die zweite Haelfte umsonst.\",\n",
+    "    ]\n",
+    "\n",
+    "    if schuldige and noetig is not None:\n",
+    "        namen = \", \".join(f'\"{s}\"' for s in schuldige)\n",
+    "        satz = (f\"Zum Wunsch des Vertriebs ({WUNSCH_MENGE:.0f} {WUNSCH_PRODUKT} statt \"\n",
+    "                f\"{plan[WUNSCH_PRODUKT]:.1f}): Er ist mit der heutigen Ausstattung \"\n",
+    "                f\"nicht erfuellbar - nicht aus Kostengruenden, sondern weil {namen} \"\n",
+    "                f\"ihn gemeinsam blockieren. Mit +{noetig} Stunden bei \"\n",
+    "                f'\"{engpass}\" wird er moeglich')\n",
+    "        satz += (\", und er kostet dann nichts: Der Plan waehlt diese Menge von \"\n",
+    "                 \"sich aus.\" if wunsch_gratis else \".\")\n",
+    "        absaetze.append(satz)\n",
+    "\n",
+    "    for absatz in absaetze:\n",
+    "        print()\n",
+    "        print(textwrap.fill(absatz, width=76))\n",
+    "    print(\"\\n\" + \"=\" * 78)"
+   ]
+  },
   {
    "cell_type": "markdown",
    "metadata": {},
@@ -826,9 +1148,9 @@
     "\n",
     "from __future__ import annotations\n",
     "\n",
-    "import subprocess\n",
-    "import sys\n",
+    "import multiprocessing\n",
     "import time\n",
+    "from concurrent.futures import ProcessPoolExecutor\n",
     "\n",
     "import numpy as np\n",
     "from pydantic import BaseModel, Field, model_validator\n",
@@ -1031,25 +1353,29 @@
     "            if any(loesung.werte[problem.schluessel(i, j)] > 0.5 for j in range(m))]\n",
     "\n",
     "\n",
-    "def loese_in_eigenem_prozess(name: str) -> Loesung:\n",
-    "    \"\"\"Startet dieses Programm noch einmal - mit genau einem Solverimport.\"\"\"\n",
-    "    ergebnis = subprocess.run([sys.executable, __file__, name],\n",
-    "                              capture_output=True, text=True, timeout=300)\n",
-    "    if ergebnis.returncode != 0:\n",
-    "        raise RuntimeError(ergebnis.stderr.strip().splitlines()[-1])\n",
-    "    # Das DTO als JSON - genau dafuer ist ein Datenobjekt ohne Solverbezug gut.\n",
-    "    return Loesung.model_validate_json(ergebnis.stdout.strip().splitlines()[-1])\n",
+    "def loese_in_eigenem_prozess(name: str, problem: Standortproblem) -> Loesung:\n",
+    "    \"\"\"Laesst genau einen Modellbauer in einem frischen Prozess rechnen.\n",
+    "\n",
+    "    'spawn' statt des Linux-Standards 'fork': Der Kindprozess startet mit\n",
+    "    einem leeren Interpreter und importiert nur den Solver, den SEIN\n",
+    "    Modellbauer braucht. max_tasks_per_child=1 sorgt dafuer, dass der Pool\n",
+    "    seinen Arbeiter nicht wiederverwendet - sonst saessen beim zweiten Aufruf\n",
+    "    wieder beide Bibliotheken im selben Prozess.\n",
+    "\n",
+    "    Hin und zurueck wandert das Domaenenmodell bzw. das Loesungs-DTO. Beide\n",
+    "    kennen keinen Solver, sind also serialisierbar - genau dafuer sind sie da.\n",
+    "    \"\"\"\n",
+    "    with ProcessPoolExecutor(\n",
+    "            max_workers=1,\n",
+    "            mp_context=multiprocessing.get_context(\"spawn\"),\n",
+    "            max_tasks_per_child=1) as pool:\n",
+    "        return pool.submit(MODELLBAUER[name], problem).result(timeout=300)\n",
     "\n",
     "\n",
     "if __name__ == \"__main__\":\n",
     "    problem = beispielproblem()\n",
     "\n",
-    "    # --- Kindprozess: rechnen und das DTO als JSON ausgeben ---------------\n",
-    "    if len(sys.argv) > 1:\n",
-    "        print(MODELLBAUER[sys.argv[1]](problem).model_dump_json())\n",
-    "        sys.exit(0)\n",
-    "\n",
-    "    # --- Hauptprozess: beide Solver anstossen und vergleichen -------------\n",
+    "    # --- Beide Solver anstossen und vergleichen ---------------------------\n",
     "    print(\"=\" * 82)\n",
     "    print(\"  DERSELBE FALL, ZWEI SOLVER - UND EIN AUSWERTUNGSCODE\")\n",
     "    print(\"=\" * 82)\n",
@@ -1061,7 +1387,7 @@
     "    loesungen: dict[str, Loesung] = {}\n",
     "    for name, beschriftung in [(\"cpsat\", \"OR-Tools CP-SAT\"),\n",
     "                               (\"highs\", \"HiGHS (highspy)\")]:\n",
-    "        loesung = loesungen[name] = loese_in_eigenem_prozess(name)\n",
+    "        loesung = loesungen[name] = loese_in_eigenem_prozess(name, problem)\n",
     "        beanstandungen = pruefe_zuordnung(problem, loesung)\n",
     "\n",
     "        print(f\"{beschriftung}\")\n",
diff --git a/Notebooks_04/testing.ipynb b/Notebooks_04/testing.ipynb
index 51d110c..7ce275c 100644
--- a/Notebooks_04/testing.ipynb
+++ b/Notebooks_04/testing.ipynb
@@ -593,113 +593,124 @@
     "\n",
     "from __future__ import annotations\n",
     "\n",
-    "import json\n",
-    "import subprocess\n",
-    "import sys\n",
-    "import textwrap\n",
+    "import multiprocessing\n",
+    "import resource\n",
+    "import time\n",
+    "from concurrent.futures import ProcessPoolExecutor\n",
+    "\n",
+    "import numpy as np\n",
     "\n",
     "GROESSEN = [(10, 10), (32, 32), (100, 100)]   # (Lager, Kunden) -> 100 / 1.024 / 10.000 Variablen\n",
     "\n",
     "\n",
-    "# Jeder Eintrag ist ein eigenstaendiges Programm: Instanz aufbauen, loesen,\n",
-    "# Ergebnis als JSON ausgeben. Die Instanz wird in jedem Kindprozess aus\n",
-    "# derselben Saat neu erzeugt - so reist nichts ueber die Prozessgrenze,\n",
-    "# was das Ergebnis verfaelschen koennte.\n",
-    "VORSPANN = \"\"\"\n",
-    "import json, time, resource\n",
-    "import numpy as np\n",
+    "# Instanz und Speichermessung stehen als gewoehnliche Funktionen hier - nicht\n",
+    "# in einem String, den ein Kindprozess ausfuehrt. Jede Messfunktion baut die\n",
+    "# Instanz aus derselben Saat neu auf, damit ueber die Prozessgrenze nichts\n",
+    "# reist, was das Ergebnis verfaelschen koennte.\n",
     "\n",
-    "def instanz(m, n):\n",
+    "def instanz(m: int, n: int):\n",
     "    rng = np.random.default_rng(20)\n",
     "    kosten = rng.integers(5, 95, (m, n)).astype(float)\n",
     "    angebot = rng.integers(50, 150, m).astype(float)\n",
     "    bedarf = angebot.sum() * rng.dirichlet(np.ones(n))\n",
     "    return kosten, angebot, bedarf\n",
     "\n",
-    "def speicher_mb():\n",
-    "    # ru_maxrss ist unter Linux in Kilobyte\n",
+    "\n",
+    "def speicher_mb() -> float:\n",
+    "    # ru_maxrss ist unter Linux in Kilobyte. Gemessen wird der Kindprozess -\n",
+    "    # deshalb muss jede Messung einen eigenen bekommen.\n",
     "    return resource.getrusage(resource.RUSAGE_SELF).ru_maxrss / 1024\n",
     "\n",
-    "M, N = {m}, {n}\n",
-    "kosten, angebot, bedarf = instanz(M, N)\n",
-    "\"\"\"\n",
     "\n",
-    "ANSAETZE = {\n",
-    "    \"scipy.linprog\": \"\"\"\n",
-    "        from scipy.optimize import linprog\n",
-    "        t0 = time.perf_counter()\n",
-    "        c = kosten.reshape(-1)\n",
-    "        A_ub = np.zeros((M, M * N)); A_eq = np.zeros((N, M * N))\n",
-    "        for i in range(M):\n",
-    "            A_ub[i, i * N:(i + 1) * N] = 1.0\n",
-    "        for j in range(N):\n",
-    "            A_eq[j, j::N] = 1.0\n",
-    "        aufbau = time.perf_counter() - t0\n",
-    "        t0 = time.perf_counter()\n",
-    "        r = linprog(c=c, A_ub=A_ub, b_ub=angebot, A_eq=A_eq, b_eq=bedarf,\n",
-    "                    bounds=(0, None), method=\"highs\")\n",
-    "        loesen = time.perf_counter() - t0\n",
-    "        ausgabe = (float(r.fun), aufbau, loesen, speicher_mb())\n",
-    "    \"\"\",\n",
-    "\n",
-    "    \"highspy\": \"\"\"\n",
-    "        import highspy\n",
-    "        t0 = time.perf_counter()\n",
-    "        h = highspy.Highs(); h.setOptionValue(\"output_flag\", False)\n",
-    "        h.addVars(M * N, np.zeros(M * N), np.full(M * N, highspy.kHighsInf))\n",
-    "        for k in range(M * N):\n",
-    "            h.changeColCost(k, float(kosten.reshape(-1)[k]))\n",
-    "        for i in range(M):\n",
-    "            idx = np.arange(i * N, (i + 1) * N, dtype=np.int32)\n",
-    "            h.addRow(-highspy.kHighsInf, float(angebot[i]), N, idx, np.ones(N))\n",
-    "        for j in range(N):\n",
-    "            idx = np.arange(j, M * N, N, dtype=np.int32)\n",
-    "            h.addRow(float(bedarf[j]), float(bedarf[j]), M, idx, np.ones(M))\n",
-    "        aufbau = time.perf_counter() - t0\n",
-    "        t0 = time.perf_counter(); h.run(); loesen = time.perf_counter() - t0\n",
-    "        ausgabe = (h.getInfo().objective_function_value, aufbau, loesen, speicher_mb())\n",
-    "    \"\"\",\n",
-    "\n",
-    "    \"ortools/GLOP\": \"\"\"\n",
-    "        from ortools.linear_solver import pywraplp\n",
-    "        t0 = time.perf_counter()\n",
-    "        s = pywraplp.Solver.CreateSolver(\"GLOP\")\n",
-    "        x = [[s.NumVar(0, s.infinity(), f\"x{i}_{j}\") for j in range(N)]\n",
-    "             for i in range(M)]\n",
-    "        for i in range(M):\n",
-    "            s.Add(sum(x[i]) <= float(angebot[i]))\n",
-    "        for j in range(N):\n",
-    "            s.Add(sum(x[i][j] for i in range(M)) == float(bedarf[j]))\n",
-    "        s.Minimize(sum(float(kosten[i, j]) * x[i][j]\n",
-    "                       for i in range(M) for j in range(N)))\n",
-    "        aufbau = time.perf_counter() - t0\n",
-    "        t0 = time.perf_counter(); s.Solve(); loesen = time.perf_counter() - t0\n",
-    "        ausgabe = (s.Objective().Value(), aufbau, loesen, speicher_mb())\n",
-    "    \"\"\",\n",
-    "\n",
-    "    \"cvxpy\": \"\"\"\n",
-    "        import cvxpy as cp\n",
-    "        t0 = time.perf_counter()\n",
-    "        x = cp.Variable((M, N), nonneg=True)\n",
-    "        problem = cp.Problem(cp.Minimize(cp.sum(cp.multiply(kosten, x))),\n",
-    "                             [cp.sum(x, axis=1) <= angebot,\n",
-    "                              cp.sum(x, axis=0) == bedarf])\n",
-    "        aufbau = time.perf_counter() - t0\n",
-    "        t0 = time.perf_counter(); problem.solve(); loesen = time.perf_counter() - t0\n",
-    "        ausgabe = (float(problem.value), aufbau, loesen, speicher_mb())\n",
-    "    \"\"\",\n",
-    "}\n",
+    "def messe_scipy(m: int, n: int):\n",
+    "    from scipy.optimize import linprog\n",
+    "    kosten, angebot, bedarf = instanz(m, n)\n",
+    "    t0 = time.perf_counter()\n",
+    "    c = kosten.reshape(-1)\n",
+    "    A_ub = np.zeros((m, m * n)); A_eq = np.zeros((n, m * n))\n",
+    "    for i in range(m):\n",
+    "        A_ub[i, i * n:(i + 1) * n] = 1.0\n",
+    "    for j in range(n):\n",
+    "        A_eq[j, j::n] = 1.0\n",
+    "    aufbau = time.perf_counter() - t0\n",
+    "    t0 = time.perf_counter()\n",
+    "    r = linprog(c=c, A_ub=A_ub, b_ub=angebot, A_eq=A_eq, b_eq=bedarf,\n",
+    "                bounds=(0, None), method=\"highs\")\n",
+    "    loesen = time.perf_counter() - t0\n",
+    "    return float(r.fun), aufbau, loesen, speicher_mb()\n",
     "\n",
     "\n",
-    "def messe(name: str, quelltext: str, m: int, n: int):\n",
-    "    \"\"\"Fuehrt einen Ansatz in einem eigenen Prozess aus.\"\"\"\n",
-    "    programm = (VORSPANN.format(m=m, n=n) + textwrap.dedent(quelltext)\n",
-    "                + \"\\nprint(json.dumps(ausgabe))\\n\")\n",
-    "    ergebnis = subprocess.run([sys.executable, \"-c\", programm],\n",
-    "                              capture_output=True, text=True, timeout=600)\n",
-    "    if ergebnis.returncode != 0:\n",
-    "        return None, ergebnis.stderr.strip().splitlines()[-1][:60]\n",
-    "    return json.loads(ergebnis.stdout.strip().splitlines()[-1]), None\n",
+    "def messe_highspy(m: int, n: int):\n",
+    "    import highspy\n",
+    "    kosten, angebot, bedarf = instanz(m, n)\n",
+    "    t0 = time.perf_counter()\n",
+    "    h = highspy.Highs(); h.setOptionValue(\"output_flag\", False)\n",
+    "    h.addVars(m * n, np.zeros(m * n), np.full(m * n, highspy.kHighsInf))\n",
+    "    for k in range(m * n):\n",
+    "        h.changeColCost(k, float(kosten.reshape(-1)[k]))\n",
+    "    for i in range(m):\n",
+    "        idx = np.arange(i * n, (i + 1) * n, dtype=np.int32)\n",
+    "        h.addRow(-highspy.kHighsInf, float(angebot[i]), n, idx, np.ones(n))\n",
+    "    for j in range(n):\n",
+    "        idx = np.arange(j, m * n, n, dtype=np.int32)\n",
+    "        h.addRow(float(bedarf[j]), float(bedarf[j]), m, idx, np.ones(m))\n",
+    "    aufbau = time.perf_counter() - t0\n",
+    "    t0 = time.perf_counter(); h.run(); loesen = time.perf_counter() - t0\n",
+    "    return h.getInfo().objective_function_value, aufbau, loesen, speicher_mb()\n",
+    "\n",
+    "\n",
+    "def messe_ortools(m: int, n: int):\n",
+    "    from ortools.linear_solver import pywraplp\n",
+    "    kosten, angebot, bedarf = instanz(m, n)\n",
+    "    t0 = time.perf_counter()\n",
+    "    s = pywraplp.Solver.CreateSolver(\"GLOP\")\n",
+    "    x = [[s.NumVar(0, s.infinity(), f\"x{i}_{j}\") for j in range(n)]\n",
+    "         for i in range(m)]\n",
+    "    for i in range(m):\n",
+    "        s.Add(sum(x[i]) <= float(angebot[i]))\n",
+    "    for j in range(n):\n",
+    "        s.Add(sum(x[i][j] for i in range(m)) == float(bedarf[j]))\n",
+    "    s.Minimize(sum(float(kosten[i, j]) * x[i][j]\n",
+    "                   for i in range(m) for j in range(n)))\n",
+    "    aufbau = time.perf_counter() - t0\n",
+    "    t0 = time.perf_counter(); s.Solve(); loesen = time.perf_counter() - t0\n",
+    "    return s.Objective().Value(), aufbau, loesen, speicher_mb()\n",
+    "\n",
+    "\n",
+    "def messe_cvxpy(m: int, n: int):\n",
+    "    import cvxpy as cp\n",
+    "    kosten, angebot, bedarf = instanz(m, n)\n",
+    "    t0 = time.perf_counter()\n",
+    "    x = cp.Variable((m, n), nonneg=True)\n",
+    "    problem = cp.Problem(cp.Minimize(cp.sum(cp.multiply(kosten, x))),\n",
+    "                         [cp.sum(x, axis=1) <= angebot,\n",
+    "                          cp.sum(x, axis=0) == bedarf])\n",
+    "    aufbau = time.perf_counter() - t0\n",
+    "    t0 = time.perf_counter(); problem.solve(); loesen = time.perf_counter() - t0\n",
+    "    return float(problem.value), aufbau, loesen, speicher_mb()\n",
+    "\n",
+    "\n",
+    "ANSAETZE = {\"scipy.linprog\": messe_scipy, \"highspy\": messe_highspy,\n",
+    "            \"ortools/GLOP\": messe_ortools, \"cvxpy\": messe_cvxpy}\n",
+    "\n",
+    "\n",
+    "def messe(funktion, m: int, n: int):\n",
+    "    \"\"\"Fuehrt eine Messfunktion in einem FRISCHEN Prozess aus.\n",
+    "\n",
+    "    'spawn' und max_tasks_per_child=1 zusammen garantieren, was Regel 1\n",
+    "    verlangt: Jede Messung sieht einen leeren Interpreter. Ohne das\n",
+    "    zweite wuerde der Pool seinen Arbeiter wiederverwenden - dann waere\n",
+    "    der Speicherwert der zweiten Bibliothek um die erste zu hoch, und\n",
+    "    ortools und highspy saessen im selben Prozess.\n",
+    "    \"\"\"\n",
+    "    with ProcessPoolExecutor(\n",
+    "            max_workers=1,\n",
+    "            mp_context=multiprocessing.get_context(\"spawn\"),\n",
+    "            max_tasks_per_child=1) as pool:\n",
+    "        try:\n",
+    "            return pool.submit(funktion, m, n).result(timeout=600), None\n",
+    "        except Exception as fehler:\n",
+    "            return None, str(fehler).strip().splitlines()[-1][:60]\n",
     "\n",
     "\n",
     "if __name__ == \"__main__\":\n",
@@ -717,8 +728,8 @@
     "              f\"{'Loesen':>9} {'Anteil':>8} {'Speicher':>10}\")\n",
     "        print(\"  \" + \"-\" * 72)\n",
     "        zielwerte = {}\n",
-    "        for name, quelltext in ANSAETZE.items():\n",
-    "            werte, fehler = messe(name, quelltext, m, n)\n",
+    "        for name, funktion in ANSAETZE.items():\n",
+    "            werte, fehler = messe(funktion, m, n)\n",
     "            if werte is None:\n",
     "                print(f\"  {name:<16} nicht verfuegbar: {fehler}\")\n",
     "                continue\n",
diff --git a/OR_HTML_04/Notebooks_04/cpsat.ipynb b/OR_HTML_04/Notebooks_04/cpsat.ipynb
index 1ed1cb0..d7ebcb5 100644
--- a/OR_HTML_04/Notebooks_04/cpsat.ipynb
+++ b/OR_HTML_04/Notebooks_04/cpsat.ipynb
@@ -496,6 +496,218 @@
     "    loese_jobshop()"
    ]
   },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Parallele Suche: was `num_workers` wirklich bewirkt\n",
+    "\n",
+    "`Parallele_Suche.py`\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "#!/usr/bin/env python3\n",
+    "\n",
+    "# Parallele_Suche.py\n",
+    "\"\"\"\n",
+    "Kapitel CP-SAT: Was mehrere Arbeiter wirklich bringen - und was sie kosten.\n",
+    "\n",
+    "Das Buch setzt an mehreren Stellen 'num_workers = 1', damit die abgedruckte\n",
+    "Ausgabe reproduzierbar ist. Behauptet wird dabei zweierlei: dass parallele\n",
+    "Suche schneller ist, und dass sie von Lauf zu Lauf verschiedene, gleich gute\n",
+    "Loesungen findet. Beides wird hier gemessen statt geglaubt.\n",
+    "\n",
+    "Gerechnet wird auf einem Job-Shop wie in JobShop_Intervalle.py, nur gross\n",
+    "genug, dass die Suche wirklich arbeitet: 12 Auftraege auf 10 Maschinen,\n",
+    "jeder Auftrag besucht jede Maschine.\n",
+    "\n",
+    "Zwei Messungen:\n",
+    "  1. Dieselbe Aufgabe mit 1, 2, 4 und 8 Arbeitern - Laufzeit und Ergebnis.\n",
+    "  2. Dieselbe Konfiguration mehrfach, bei FESTEM random_seed - wie oft kommt\n",
+    "     derselbe Plan heraus?\n",
+    "\n",
+    "Die zweite ist die wichtigere: Sie entscheidet, wie man Tests schreibt.\n",
+    "\n",
+    "Achtung, Laufzeiten sind hardwareabhaengig. Die ZAHL der verschiedenen\n",
+    "Plaene ist es auch - und genau das ist die Aussage.\n",
+    "\n",
+    "Benoetigt: numpy, ortools\n",
+    "\"\"\"\n",
+    "\n",
+    "from __future__ import annotations\n",
+    "\n",
+    "import collections\n",
+    "import time\n",
+    "\n",
+    "import numpy as np\n",
+    "from ortools.sat.python import cp_model\n",
+    "\n",
+    "AUFTRAEGE = 12\n",
+    "MASCHINEN = 10\n",
+    "INSTANZ_SEED = 20260908\n",
+    "SOLVER_SEED = 1          # bleibt ueber ALLE Laeufe gleich - das ist der Punkt\n",
+    "ARBEITERZAHLEN = (1, 2, 4, 8)\n",
+    "WIEDERHOLUNGEN = 4\n",
+    "ZEITLIMIT = 120.0\n",
+    "\n",
+    "\n",
+    "def baue_instanz() -> list[list[tuple[int, int]]]:\n",
+    "    \"\"\"Klassischer Job-Shop: Jeder Auftrag besucht jede Maschine genau einmal,\n",
+    "    in einer eigenen zufaelligen Reihenfolge.\"\"\"\n",
+    "    rng = np.random.default_rng(INSTANZ_SEED)\n",
+    "    return [[(int(m), int(rng.integers(2, 20))) for m in rng.permutation(MASCHINEN)]\n",
+    "            for _ in range(AUFTRAEGE)]\n",
+    "\n",
+    "\n",
+    "def loese(auftraege, arbeiter: int):\n",
+    "    \"\"\"Minimiert den Makespan. Gibt Status, Zielwert, Laufzeit und den Plan\n",
+    "    zurueck - den Plan als Tupel aller Startzeiten, damit sich zwei Laeufe\n",
+    "    vergleichen lassen.\"\"\"\n",
+    "    horizont = sum(dauer for auftrag in auftraege for _, dauer in auftrag)\n",
+    "    modell = cp_model.CpModel()\n",
+    "    Gang = collections.namedtuple(\"Gang\", \"start ende intervall\")\n",
+    "    plaene: dict[tuple[int, int], Gang] = {}\n",
+    "    je_maschine = collections.defaultdict(list)\n",
+    "\n",
+    "    for a, auftrag in enumerate(auftraege):\n",
+    "        for g, (maschine, dauer) in enumerate(auftrag):\n",
+    "            start = modell.NewIntVar(0, horizont, f\"start_{a}_{g}\")\n",
+    "            ende = modell.NewIntVar(0, horizont, f\"ende_{a}_{g}\")\n",
+    "            intervall = modell.NewIntervalVar(start, dauer, ende, f\"iv_{a}_{g}\")\n",
+    "            plaene[a, g] = Gang(start, ende, intervall)\n",
+    "            je_maschine[maschine].append(intervall)\n",
+    "\n",
+    "    for maschine in range(MASCHINEN):\n",
+    "        modell.AddNoOverlap(je_maschine[maschine])\n",
+    "    for a, auftrag in enumerate(auftraege):\n",
+    "        for g in range(len(auftrag) - 1):\n",
+    "            modell.Add(plaene[a, g + 1].start >= plaene[a, g].ende)\n",
+    "\n",
+    "    makespan = modell.NewIntVar(0, horizont, \"makespan\")\n",
+    "    modell.AddMaxEquality(\n",
+    "        makespan, [plaene[a, len(auftrag) - 1].ende\n",
+    "                   for a, auftrag in enumerate(auftraege)])\n",
+    "    modell.Minimize(makespan)\n",
+    "\n",
+    "    loeser = cp_model.CpSolver()\n",
+    "    loeser.parameters.num_workers = arbeiter\n",
+    "    loeser.parameters.random_seed = SOLVER_SEED\n",
+    "    loeser.parameters.max_time_in_seconds = ZEITLIMIT\n",
+    "\n",
+    "    beginn = time.perf_counter()\n",
+    "    status = loeser.Solve(modell)\n",
+    "    dauer = time.perf_counter() - beginn\n",
+    "\n",
+    "    if status not in (cp_model.OPTIMAL, cp_model.FEASIBLE):\n",
+    "        return loeser.StatusName(status), None, dauer, None\n",
+    "    plan = tuple(loeser.Value(plaene[a, g].start)\n",
+    "                 for a, auftrag in enumerate(auftraege)\n",
+    "                 for g in range(len(auftrag)))\n",
+    "    return loeser.StatusName(status), int(loeser.ObjectiveValue()), dauer, plan\n",
+    "\n",
+    "\n",
+    "if __name__ == \"__main__\":\n",
+    "    auftraege = baue_instanz()\n",
+    "    gaenge = sum(len(a) for a in auftraege)\n",
+    "\n",
+    "    print(\"=\" * 78)\n",
+    "    print(\"  WAS MEHRERE ARBEITER WIRKLICH BRINGEN\")\n",
+    "    print(\"=\" * 78)\n",
+    "    print(f\"Job-Shop: {AUFTRAEGE} Auftraege, {MASCHINEN} Maschinen, \"\n",
+    "          f\"{gaenge} Arbeitsgaenge.\")\n",
+    "    print(f\"random_seed = {SOLVER_SEED} in JEDEM Lauf, \"\n",
+    "          f\"{WIEDERHOLUNGEN} Wiederholungen je Arbeiterzahl.\\n\")\n",
+    "\n",
+    "    # Jede Konfiguration mehrfach - ein einzelner Zeitwert sagt nichts.\n",
+    "    ergebnisse: dict[int, list[tuple]] = {}\n",
+    "    for arbeiter in ARBEITERZAHLEN:\n",
+    "        ergebnisse[arbeiter] = [loese(auftraege, arbeiter)\n",
+    "                                for _ in range(WIEDERHOLUNGEN)]\n",
+    "\n",
+    "    print(\"=\" * 78)\n",
+    "    print(\"  (1) Laufzeit: was die Arbeiter bringen\")\n",
+    "    print(\"=\" * 78)\n",
+    "    print(f\"{'Arbeiter':>9} {'Status':>9} {'Makespan':>9} \"\n",
+    "          f\"{'schnellste':>11} {'langsamste':>11} {'Beschleunigung':>15}\")\n",
+    "    print(\"-\" * 78)\n",
+    "    basis_zeit = min(d for _, _, d, _ in ergebnisse[1])\n",
+    "    for arbeiter in ARBEITERZAHLEN:\n",
+    "        laeufe = ergebnisse[arbeiter]\n",
+    "        zeiten = [d for _, _, d, _ in laeufe]\n",
+    "        ziele = {o for _, o, _, _ in laeufe}\n",
+    "        status = {s for s, _, _, _ in laeufe}\n",
+    "        print(f\"{arbeiter:>9} {'/'.join(sorted(status)):>9} \"\n",
+    "              f\"{'/'.join(str(z) for z in sorted(ziele)):>9} \"\n",
+    "              f\"{min(zeiten):>10.2f}s {max(zeiten):>10.2f}s \"\n",
+    "              f\"{basis_zeit / min(zeiten):>14.1f}x\")\n",
+    "\n",
+    "    beste = min(ARBEITERZAHLEN, key=lambda w: min(d for _, _, d, _ in ergebnisse[w]))\n",
+    "    faktor = basis_zeit / min(d for _, _, d, _ in ergebnisse[beste])\n",
+    "    print(f\"\\n  Am schnellsten sind {beste} Arbeiter: Faktor {faktor:.1f} gegenueber\")\n",
+    "    print(f\"  einem einzigen - also MEHR, als {beste} Kerne hergeben sollten.\")\n",
+    "    print(f\"  Das ist kein Messfehler. CP-SAT laesst nicht {beste}-mal dieselbe Suche\")\n",
+    "    print(\"  laufen, sondern verschiedene Strategien nebeneinander, die einander\")\n",
+    "    print(\"  ihre Schranken zurufen. Der zweite Arbeiter ist deshalb nicht der\")\n",
+    "    print(\"  'zweite Kern', sondern ein anderes Verfahren.\")\n",
+    "    letzte = ARBEITERZAHLEN[-1]\n",
+    "    if beste != letzte:\n",
+    "        zeit_letzte = min(d for _, _, d, _ in ergebnisse[letzte])\n",
+    "        print(f\"\\n  Und mehr ist nicht immer besser: {letzte} Arbeiter brauchen \"\n",
+    "              f\"{zeit_letzte:.2f}s\")\n",
+    "        print(f\"  gegenueber {min(d for _, _, d, _ in ergebnisse[beste]):.2f}s bei \"\n",
+    "              f\"{beste}. Ab einer gewissen Zahl kosten Abstimmung\")\n",
+    "        print(\"  und Speicherbandbreite mehr, als ein weiterer Suchstrang einbringt.\")\n",
+    "\n",
+    "    print(\"\\n\" + \"=\" * 78)\n",
+    "    print(\"  (2) Reproduzierbarkeit: derselbe Seed, derselbe Plan?\")\n",
+    "    print(\"=\" * 78)\n",
+    "    print(f\"{'Arbeiter':>9} {'Laeufe':>7} {'verschiedene Plaene':>21} \"\n",
+    "          f\"{'Makespan':>10}\")\n",
+    "    print(\"-\" * 78)\n",
+    "    for arbeiter in ARBEITERZAHLEN:\n",
+    "        plaene = {p for _, _, _, p in ergebnisse[arbeiter] if p is not None}\n",
+    "        ziele = {o for _, o, _, _ in ergebnisse[arbeiter]}\n",
+    "        print(f\"{arbeiter:>9} {WIEDERHOLUNGEN:>7} {len(plaene):>21} \"\n",
+    "              f\"{'/'.join(str(z) for z in sorted(ziele)):>10}\")\n",
+    "\n",
+    "    einer = len({p for _, _, _, p in ergebnisse[1]})\n",
+    "    # Ab welcher Arbeiterzahl bricht die Reproduzierbarkeit? Das ist die\n",
+    "    # eigentliche Zahl - nicht, was acht Arbeiter anrichten.\n",
+    "    ab = next((w for w in ARBEITERZAHLEN\n",
+    "               if len({p for _, _, _, p in ergebnisse[w]}) > 1), None)\n",
+    "    print(f\"\\n  Mit einem Arbeiter: {einer} Plan aus {WIEDERHOLUNGEN} Laeufen.\")\n",
+    "    if ab is not None:\n",
+    "        viele = len({p for _, _, _, p in ergebnisse[ab]})\n",
+    "        print(f\"  Schon mit {ab} Arbeitern: {viele} verschiedene Plaene aus \"\n",
+    "              f\"{WIEDERHOLUNGEN} Laeufen -\")\n",
+    "        print(\"  bei identischem random_seed und identischem Zielwert.\")\n",
+    "        print(f\"  Es braucht also keine acht Arbeiter, um die Reproduzierbarkeit\")\n",
+    "        print(f\"  zu verlieren. {ab} genuegen.\")\n",
+    "    print(\"\\n  Der Seed allein macht einen Lauf also NICHT reproduzierbar. Er legt\")\n",
+    "    print(\"  fest, wie ein einzelner Suchstrang wuerfelt - nicht, welcher von\")\n",
+    "    print(\"  mehreren zuerst fertig wird. Das entscheidet die Uhr.\")\n",
+    "\n",
+    "    print(\"\\n\" + \"=\" * 78)\n",
+    "    print(\"  (3) Was daraus fuer Tests folgt\")\n",
+    "    print(\"=\" * 78)\n",
+    "    print(\"  Ein Test der Form  assert plan == erwarteter_plan  besteht mal und\")\n",
+    "    print(\"  scheitert mal, ohne dass sich am Code etwas geaendert haette.\")\n",
+    "    print(\"  Zu pruefen sind stattdessen:\")\n",
+    "    print(\"    * der ZIELWERT (hier in allen Laeufen gleich),\")\n",
+    "    print(\"    * die Einhaltung aller Regeln (Abnahmepruefung, Kapitel Praxisfallen),\")\n",
+    "    print(\"    * und der Status - nicht die Gestalt der Loesung.\")\n",
+    "    print(\"\\n  Wer doch einen bestimmten Plan braucht - fuer eine abgedruckte\")\n",
+    "    print(\"  Ausgabe, fuer einen Regressionstest -, setzt num_workers = 1.\")\n",
+    "    print(f\"  Das kostet hier den Faktor {faktor:.1f} an Laufzeit und ist genau\")\n",
+    "    print(\"  deshalb eine Entscheidung fuer den Test, nicht fuer den Betrieb.\")\n",
+    "    print(\"=\" * 78)"
+   ]
+  },
   {
    "cell_type": "markdown",
    "metadata": {},
diff --git a/OR_HTML_04/Notebooks_04/finanzdaten.ipynb b/OR_HTML_04/Notebooks_04/finanzdaten.ipynb
index 99ff2e3..0d3f0e8 100644
--- a/OR_HTML_04/Notebooks_04/finanzdaten.ipynb
+++ b/OR_HTML_04/Notebooks_04/finanzdaten.ipynb
@@ -455,7 +455,8 @@
     "    exakt positiv semidefinit ist - rechne trotzdem.' Das ist hier bewusst so\n",
     "    gewaehlt, denn genau diese Eigenschaft wollen wir vorfuehren. Im\n",
     "    Produktivbetrieb waere die DCP-Fehlermeldung das Warnsignal, dem man\n",
-    "    nachgehen muss (siehe Denkfehler 8.1).\n",
+    "    nachgehen muss (siehe den Denkfehler im Kapitel Quadratische und\n",
+    "    nichtlineare Optimierung).\n",
     "    \"\"\"\n",
     "    gewichte = cp.Variable(ANZAHL_ANLAGEN)\n",
     "    problem = cp.Problem(cp.Minimize(cp.quad_form(gewichte, cp.psd_wrap(kovarianz))),\n",
diff --git a/OR_HTML_04/Notebooks_04/milp.ipynb b/OR_HTML_04/Notebooks_04/milp.ipynb
index 6ee1d17..a9bb7ca 100644
--- a/OR_HTML_04/Notebooks_04/milp.ipynb
+++ b/OR_HTML_04/Notebooks_04/milp.ipynb
@@ -757,7 +757,8 @@
     "\n",
     "    loeser = cp_model.CpSolver()\n",
     "    loeser.parameters.max_time_in_seconds = zeitlimit\n",
-    "    # Ein Arbeiter und fester Startwert, damit die Messung reproduzierbar ist.\n",
+    "    # Ein Arbeiter und fester Startwert, damit die Messung reproduzierbar ist -\n",
+    "    # der Seed allein genuegt dafuer NICHT (Kapitel Constraint Programming).\n",
     "    # Im Produktivbetrieb laesst man beides auf den Standardwerten.\n",
     "    loeser.parameters.num_workers = 1\n",
     "    loeser.parameters.random_seed = 1\n",
diff --git a/OR_HTML_04/Notebooks_04/oekosystem.ipynb b/OR_HTML_04/Notebooks_04/oekosystem.ipynb
index eb02e7e..ae42071 100644
--- a/OR_HTML_04/Notebooks_04/oekosystem.ipynb
+++ b/OR_HTML_04/Notebooks_04/oekosystem.ipynb
@@ -115,7 +115,7 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "## Ein System — vier Programmieransätze\n",
+    "## Wie die Isolation aussieht, wenn sie tragen soll\n",
     "\n",
     "`Ein_System_Vier_Ansaetze.py`\n"
    ]
@@ -136,85 +136,104 @@
     "          2*x1 + 3*x2 + x3 <= 50\n",
     "          x >= 0\n",
     "\n",
-    "Deckt scipy.optimize, highspy, CVXPY und OR-Tools/GLOP ab, mit Kreuzvergleich am Ende.\n",
+    "Deckt scipy.optimize, highspy, CVXPY und OR-Tools/GLOP ab, mit Kreuzvergleich\n",
+    "am Ende.\n",
     "\n",
-    "WICHTIG: Jeder Solver läuft in einem EIGENEN Prozess, weil sich ortools und\n",
+    "WICHTIG: Jeder Solver laeuft in einem EIGENEN Prozess, weil sich ortools und\n",
     "highspy auf vielen Systemen nicht gemeinsam importieren lassen (beide bringen\n",
     "eine eigene HiGHS-Kopie mit -> Symbolkonflikt).\n",
+    "\n",
+    "Die Isolation besorgt ein ProcessPoolExecutor. Drei Einstellungen ergeben\n",
+    "zusammen die Garantie:\n",
+    "\n",
+    "  mp_context \"spawn\"     Der Kindprozess startet mit einem FRISCHEN\n",
+    "                         Interpreter, statt den Speicher des Elternprozesses\n",
+    "                         zu erben. Was hier schon importiert ist, ist dort\n",
+    "                         nicht importiert. Mit dem Standard \"fork\" auf Linux\n",
+    "                         waere das nicht so.\n",
+    "  max_tasks_per_child=1  Jede Aufgabe bekommt einen NEUEN Prozess. Ohne das\n",
+    "                         wuerde der Pool seinen Arbeiter wiederverwenden - und\n",
+    "                         beim zweiten Solver waere der Konflikt zurueck.\n",
+    "  max_workers=1          Haelt die vier Laeufe nacheinander. Nicht aus\n",
+    "                         Vorsicht, sondern damit die gemessenen Zeiten\n",
+    "                         vergleichbar bleiben.\n",
+    "\n",
+    "Jeder Solver steht in einer eigenen Funktion mit LOKALEM Import. Das ist der\n",
+    "Unterschied zu einem Codestring, den man an 'python -c' uebergibt: Die\n",
+    "Funktion laesst sich einzeln aufrufen, testen und vom Editor pruefen - ein\n",
+    "String nicht.\n",
+    "\n",
+    "Benoetigt: scipy, highspy, cvxpy, ortools\n",
     "\"\"\"\n",
     "\n",
-    "import json\n",
-    "import subprocess\n",
-    "import sys\n",
-    "import textwrap\n",
+    "import multiprocessing\n",
     "import time\n",
+    "from concurrent.futures import ProcessPoolExecutor\n",
     "\n",
     "ERWARTET = 530.0            # Ergebnis der Handrechnung zum Produktionsprogramm\n",
     "\n",
-    "# Jeder Eintrag ist ein eigenständiges Miniprogramm, das sein Ergebnis als\n",
-    "# JSON auf stdout ausgibt. So bleibt jeder Import in seinem eigenen Prozess.\n",
-    "ANSAETZE: dict[str, str] = {\n",
+    "# Die Instanz - einmal notiert, von allen vier Funktionen benutzt.\n",
+    "ZIEL = [10.0, 15.0, 25.0]\n",
+    "MATRIX = [[1, 1, 2], [2, 3, 1]]\n",
+    "KAPAZITAET = [40.0, 50.0]\n",
     "\n",
-    "    \"scipy.optimize.linprog\": \"\"\"\n",
-    "        from scipy.optimize import linprog\n",
-    "        res = linprog(c=[-10.0, -15.0, -25.0],           # linprog MINIMIERT -> negieren\n",
-    "                      A_ub=[[1, 1, 2], [2, 3, 1]], b_ub=[40, 50],\n",
-    "                      bounds=[(0, None)] * 3, method=\"highs\")\n",
-    "        ausgabe = (-res.fun, list(res.x))\n",
-    "    \"\"\",\n",
     "\n",
-    "    \"highspy (natives HiGHS)\": \"\"\"\n",
-    "        import numpy as np, highspy\n",
-    "        h = highspy.Highs()\n",
-    "        h.setOptionValue(\"output_flag\", False)\n",
-    "        h.addVars(3, np.zeros(3), np.full(3, highspy.kHighsInf))\n",
-    "        h.changeObjectiveSense(highspy.ObjSense.kMaximize)\n",
-    "        for j, wert in enumerate([10.0, 15.0, 25.0]):\n",
-    "            h.changeColCost(j, wert)\n",
-    "        # CSR-Format: starts[i] = Beginn von Zeile i in indices/values\n",
-    "        h.addRows(2, np.full(2, -highspy.kHighsInf), np.array([40.0, 50.0]), 6,\n",
-    "                  np.array([0, 3], dtype=np.int32),\n",
-    "                  np.array([0, 1, 2, 0, 1, 2], dtype=np.int32),\n",
-    "                  np.array([1.0, 1.0, 2.0, 2.0, 3.0, 1.0]))\n",
-    "        h.run()\n",
-    "        ausgabe = (h.getInfo().objective_function_value,\n",
-    "                   list(h.getSolution().col_value[:3]))\n",
-    "    \"\"\",\n",
+    "def loese_mit_scipy() -> tuple[float, list[float]]:\n",
+    "    from scipy.optimize import linprog\n",
+    "    ergebnis = linprog(c=[-w for w in ZIEL],          # linprog MINIMIERT -> negieren\n",
+    "                       A_ub=MATRIX, b_ub=KAPAZITAET,\n",
+    "                       bounds=[(0, None)] * 3, method=\"highs\")\n",
+    "    return -ergebnis.fun, list(ergebnis.x)\n",
     "\n",
-    "    \"cvxpy\": \"\"\"\n",
-    "        import numpy as np, cvxpy as cp\n",
-    "        x = cp.Variable(3, nonneg=True)\n",
-    "        problem = cp.Problem(cp.Maximize(np.array([10.0, 15.0, 25.0]) @ x),\n",
-    "                             [np.array([[1, 1, 2], [2, 3, 1]]) @ x <= np.array([40, 50])])\n",
-    "        problem.solve()\n",
-    "        ausgabe = (float(problem.value), [float(v) for v in x.value])\n",
-    "    \"\"\",\n",
     "\n",
-    "    \"ortools / GLOP\": \"\"\"\n",
-    "        from ortools.linear_solver import pywraplp\n",
-    "        s = pywraplp.Solver.CreateSolver(\"GLOP\")\n",
-    "        x = [s.NumVar(0, s.infinity(), f\"x{j+1}\") for j in range(3)]\n",
-    "        A = [[1, 1, 2], [2, 3, 1]]\n",
-    "        for i, kap in enumerate([40, 50]):\n",
-    "            s.Add(sum(A[i][j] * x[j] for j in range(3)) <= kap)\n",
-    "        s.Maximize(10 * x[0] + 15 * x[1] + 25 * x[2])\n",
-    "        s.Solve()\n",
-    "        ausgabe = (s.Objective().Value(), [v.solution_value() for v in x])\n",
-    "    \"\"\",\n",
+    "def loese_mit_highspy() -> tuple[float, list[float]]:\n",
+    "    import highspy\n",
+    "    import numpy as np\n",
+    "    h = highspy.Highs()\n",
+    "    h.setOptionValue(\"output_flag\", False)\n",
+    "    h.addVars(3, np.zeros(3), np.full(3, highspy.kHighsInf))\n",
+    "    h.changeObjectiveSense(highspy.ObjSense.kMaximize)\n",
+    "    for j, wert in enumerate(ZIEL):\n",
+    "        h.changeColCost(j, wert)\n",
+    "    # CSR-Format: starts[i] = Beginn von Zeile i in indices/values\n",
+    "    h.addRows(2, np.full(2, -highspy.kHighsInf), np.array(KAPAZITAET), 6,\n",
+    "              np.array([0, 3], dtype=np.int32),\n",
+    "              np.array([0, 1, 2, 0, 1, 2], dtype=np.int32),\n",
+    "              np.array([float(w) for zeile in MATRIX for w in zeile]))\n",
+    "    h.run()\n",
+    "    return (h.getInfo().objective_function_value,\n",
+    "            list(h.getSolution().col_value[:3]))\n",
+    "\n",
+    "\n",
+    "def loese_mit_cvxpy() -> tuple[float, list[float]]:\n",
+    "    import cvxpy as cp\n",
+    "    import numpy as np\n",
+    "    x = cp.Variable(3, nonneg=True)\n",
+    "    problem = cp.Problem(cp.Maximize(np.array(ZIEL) @ x),\n",
+    "                         [np.array(MATRIX) @ x <= np.array(KAPAZITAET)])\n",
+    "    problem.solve()\n",
+    "    return float(problem.value), [float(v) for v in x.value]\n",
+    "\n",
+    "\n",
+    "def loese_mit_ortools() -> tuple[float, list[float]]:\n",
+    "    from ortools.linear_solver import pywraplp\n",
+    "    s = pywraplp.Solver.CreateSolver(\"GLOP\")\n",
+    "    x = [s.NumVar(0, s.infinity(), f\"x{j+1}\") for j in range(3)]\n",
+    "    for i, kapazitaet in enumerate(KAPAZITAET):\n",
+    "        s.Add(sum(MATRIX[i][j] * x[j] for j in range(3)) <= kapazitaet)\n",
+    "    s.Maximize(sum(ZIEL[j] * x[j] for j in range(3)))\n",
+    "    s.Solve()\n",
+    "    return s.Objective().Value(), [v.solution_value() for v in x]\n",
+    "\n",
+    "\n",
+    "ANSAETZE = {\n",
+    "    \"scipy.optimize.linprog\": loese_mit_scipy,\n",
+    "    \"highspy (natives HiGHS)\": loese_mit_highspy,\n",
+    "    \"cvxpy\": loese_mit_cvxpy,\n",
+    "    \"ortools / GLOP\": loese_mit_ortools,\n",
     "}\n",
     "\n",
     "\n",
-    "def fuehre_in_eigenem_prozess_aus(quelltext: str) -> tuple[float, list[float]]:\n",
-    "    \"\"\"Startet den Codeschnipsel als separaten Python-Prozess und liest das Ergebnis.\"\"\"\n",
-    "    programm = textwrap.dedent(quelltext) + \"\\nimport json; print(json.dumps(ausgabe))\\n\"\n",
-    "    ergebnis = subprocess.run([sys.executable, \"-c\", programm],\n",
-    "                              capture_output=True, text=True, timeout=120)\n",
-    "    if ergebnis.returncode != 0:\n",
-    "        raise RuntimeError(ergebnis.stderr.strip().splitlines()[-1])\n",
-    "    wert, loesung = json.loads(ergebnis.stdout.strip().splitlines()[-1])\n",
-    "    return wert, loesung\n",
-    "\n",
-    "\n",
     "if __name__ == \"__main__\":\n",
     "    print(\"=\" * 78)\n",
     "    print(\"  EIN SYSTEM - VIER ANSAETZE (je eigener Prozess)\")\n",
@@ -223,17 +242,23 @@
     "    print(\"-\" * 78)\n",
     "\n",
     "    werte = []\n",
-    "    for name, quelltext in ANSAETZE.items():\n",
-    "        t0 = time.perf_counter()\n",
-    "        try:\n",
-    "            wert, x = fuehre_in_eigenem_prozess_aus(quelltext)\n",
-    "        except RuntimeError as fehler:\n",
-    "            print(f\"{name:<26} nicht verfuegbar: {fehler[:40]}\")\n",
-    "            continue\n",
-    "        dauer = time.perf_counter() - t0\n",
-    "        werte.append(wert)\n",
-    "        print(f\"{name:<26} {wert:>10.2f} {x[0]:>7.2f} {x[1]:>7.2f} {x[2]:>7.2f} \"\n",
-    "              f\"{dauer:>8.2f} s\")\n",
+    "    # Ein Pool, vier Aufgaben, vier frische Prozesse. Der Kontext muss\n",
+    "    # \"spawn\" sein - siehe Modulkommentar.\n",
+    "    with ProcessPoolExecutor(\n",
+    "            max_workers=1,\n",
+    "            mp_context=multiprocessing.get_context(\"spawn\"),\n",
+    "            max_tasks_per_child=1) as pool:\n",
+    "        for name, funktion in ANSAETZE.items():\n",
+    "            beginn = time.perf_counter()\n",
+    "            try:\n",
+    "                wert, x = pool.submit(funktion).result(timeout=120)\n",
+    "            except Exception as fehler:                     # Bibliothek fehlt o. Ae.\n",
+    "                print(f\"{name:<26} nicht verfuegbar: {str(fehler)[:40]}\")\n",
+    "                continue\n",
+    "            dauer = time.perf_counter() - beginn\n",
+    "            werte.append(wert)\n",
+    "            print(f\"{name:<26} {wert:>10.2f} {x[0]:>7.2f} {x[1]:>7.2f} {x[2]:>7.2f} \"\n",
+    "                  f\"{dauer:>8.2f} s\")\n",
     "\n",
     "    print(\"-\" * 78)\n",
     "    spanne = max(werte) - min(werte)\n",
@@ -243,8 +268,8 @@
     "    assert spanne < 1e-6, \"Die Bibliotheken widersprechen sich!\"\n",
     "    assert abs(werte[0] - ERWARTET) < 1e-6, \"Ergebnis weicht von der Handrechnung ab!\"\n",
     "    print(\"Alle Wege fuehren zum selben, von Hand bestaetigten Optimum.\")\n",
-    "    print(\"(Die Zeiten enthalten den Prozessstart und den Import - sie messen\")\n",
-    "    print(\" NICHT die reine Solverleistung, siehe Uebung 3.5.)\")\n",
+    "    print(\"(Die Zeiten enthalten Prozessstart und Import - sie messen NICHT die\")\n",
+    "    print(\" reine Solverleistung. Die Uebungsaufgabe 'Laufzeitvergleich' trennt beides.)\")\n",
     "    print(\"=\" * 78)"
    ]
   },
diff --git a/OR_HTML_04/Notebooks_04/praxisfallen.ipynb b/OR_HTML_04/Notebooks_04/praxisfallen.ipynb
index 9af1b14..73bd1ba 100644
--- a/OR_HTML_04/Notebooks_04/praxisfallen.ipynb
+++ b/OR_HTML_04/Notebooks_04/praxisfallen.ipynb
@@ -252,6 +252,328 @@
     "    print(\"=\" * 78)"
    ]
   },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Constraint Attribution: welche Bedingung kostet wie viel?\n",
+    "\n",
+    "`Constraint_Attribution.py`\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "#!/usr/bin/env python3\n",
+    "\n",
+    "# Constraint_Attribution.py\n",
+    "\"\"\"\n",
+    "Kapitel Praxisfallen: Welche Bedingung kostet wie viel - und was sagt man\n",
+    "dem Management?\n",
+    "\n",
+    "Zwischen den beiden bekannten Faellen klafft eine Luecke:\n",
+    "\n",
+    "  * Erklaerbarkeit.py beantwortet \"warum diese eine Zuweisung?\"\n",
+    "  * Konfliktsuche.py (Anhang Fehlerdiagnose) beantwortet \"warum geht es gar\n",
+    "    nicht?\"\n",
+    "\n",
+    "Der haeufigste Fall in der Praxis liegt dazwischen: Das Modell rechnet, der\n",
+    "Plan ist zulaessig - und trotzdem unbefriedigend. Niemand weiss, WORAN es\n",
+    "liegt. Genau das beantwortet Constraint Attribution.\n",
+    "\n",
+    "Gerechnet wird auf derselben Fabrik wie in Konfliktsuche.py, nur nach der\n",
+    "Reparatur: Dort war die Lackierkapazitaet von 150 Stunden der Kern des\n",
+    "Widerspruchs (2*40 + 3*30 = 170 > 150). Eine zweite Schicht hat sie auf 210\n",
+    "gebracht, und der Mindestumsatz wurde auf 10.000 EUR gesenkt. Jetzt ist das\n",
+    "Modell loesbar - und die Frage lautet nicht mehr \"warum nicht?\", sondern\n",
+    "\"was kostet uns was?\".\n",
+    "\n",
+    "Gezeigt werden vier Dinge:\n",
+    "  1. Welche Bedingungen binden - und dass \"bindend\" nicht \"teuer\" heisst.\n",
+    "  2. Dass der Schattenpreis eine MOMENTAUFNAHME ist: hochgerechnet auf eine\n",
+    "     realistische Sonderschicht verspricht er hier das Doppelte des\n",
+    "     tatsaechlichen Nutzens.\n",
+    "  3. Dass ein Wunsch aus dem Vertrieb nicht teuer, sondern unmoeglich sein\n",
+    "     kann - und welche Bedingungen ihn gemeinsam blockieren.\n",
+    "  4. Wie aus alledem ein Bericht in Alltagssprache wird.\n",
+    "\n",
+    "Benoetigt: numpy, scipy\n",
+    "\"\"\"\n",
+    "\n",
+    "from __future__ import annotations\n",
+    "\n",
+    "import textwrap\n",
+    "\n",
+    "import numpy as np\n",
+    "from scipy.optimize import linprog\n",
+    "\n",
+    "PRODUKTE = [\"Rahmen\", \"Gehaeuse\", \"Deckel\", \"Traeger\", \"Halter\"]\n",
+    "DECKUNGSBEITRAG = np.array([35.0, 28.0, 9.0, 22.0, 6.0])   # EUR je Stueck\n",
+    "\n",
+    "# Dieselben Bedingungen wie in Konfliktsuche.py, mit den beiden Reparaturen.\n",
+    "# Der sprechende Name ist keine Kosmetik: Ohne ihn ist kein Bericht moeglich,\n",
+    "# der jemandem ausserhalb der Modellierung etwas sagt.\n",
+    "BEDINGUNGEN: list[tuple[str, list[float], str, float]] = [\n",
+    "    (\"Kapazitaet Montage\",       [3, 2, 1, 4, 2],      \"<=\",   400),\n",
+    "    (\"Kapazitaet Lackieren\",     [2, 3, 0, 1, 0],      \"<=\",   210),\n",
+    "    (\"Kapazitaet Pruefung\",      [1, 1, 1, 1, 1],      \"<=\",   300),\n",
+    "    (\"Liefervertrag Rahmen\",     [1, 0, 0, 0, 0],      \">=\",    40),\n",
+    "    (\"Liefervertrag Gehaeuse\",   [0, 1, 0, 0, 0],      \">=\",    30),\n",
+    "    (\"Liefervertrag Deckel\",     [0, 0, 1, 0, 0],      \">=\",    20),\n",
+    "    (\"Liefervertrag Traeger\",    [0, 0, 0, 1, 0],      \">=\",    25),\n",
+    "    (\"Marktgrenze Rahmen\",       [1, 0, 0, 0, 0],      \"<=\",   120),\n",
+    "    (\"Marktgrenze Gehaeuse\",     [0, 1, 0, 0, 0],      \"<=\",    90),\n",
+    "    (\"Marktgrenze Deckel\",       [0, 0, 1, 0, 0],      \"<=\",   150),\n",
+    "    (\"Marktgrenze Halter\",       [0, 0, 0, 0, 1],      \"<=\",   200),\n",
+    "    (\"Mindestumsatz\",            [90, 70, 30, 60, 20], \">=\", 10000),\n",
+    "    (\"Sortimentsbreite\",         [0, 0, 1, 1, 1],      \">=\",   100),\n",
+    "    (\"Lackierbudget Schicht 2\",  [0, 1, 0, 1, 0],      \"<=\",    55),\n",
+    "]\n",
+    "\n",
+    "# Was liesse sich im Ernstfall wirklich bewegen - und um wie viel? Nicht \"eine\n",
+    "# Einheit\", sondern der Schritt, den ein Planer tatsaechlich gehen kann: eine\n",
+    "# Sonderschicht, ein nachverhandelter Vertrag. Genau an dieser Groesse\n",
+    "# scheitert das blosse Hochrechnen des Schattenpreises.\n",
+    "STELLSCHRAUBEN: dict[str, tuple[float, str]] = {\n",
+    "    \"Kapazitaet Montage\":      (+50, \"eine Sonderschicht Montage\"),\n",
+    "    \"Kapazitaet Lackieren\":    (+30, \"eine Sonderschicht Lackieren\"),\n",
+    "    \"Kapazitaet Pruefung\":     (+50, \"eine Sonderschicht Pruefung\"),\n",
+    "    \"Lackierbudget Schicht 2\": (+10, \"10 Stunden mehr Budget in Schicht 2\"),\n",
+    "    \"Liefervertrag Traeger\":   (-10, \"10 Stueck weniger Abnahmepflicht Traeger\"),\n",
+    "    \"Liefervertrag Gehaeuse\":  (-10, \"10 Stueck weniger Abnahmepflicht Gehaeuse\"),\n",
+    "}\n",
+    "\n",
+    "WUNSCH_MENGE = 55.0      # der Vertrieb haette gern mehr Rahmen\n",
+    "WUNSCH_PRODUKT = \"Rahmen\"\n",
+    "\n",
+    "\n",
+    "def loese(bedingungen: list[tuple[str, list[float], str, float]]):\n",
+    "    \"\"\"Maximiert den Deckungsbeitrag. linprog minimiert, daher das Vorzeichen.\"\"\"\n",
+    "    matrix, rechte_seite = [], []\n",
+    "    for _, koeffizienten, richtung, grenze in bedingungen:\n",
+    "        zeile = np.array(koeffizienten, dtype=float)\n",
+    "        matrix.append(zeile if richtung == \"<=\" else -zeile)\n",
+    "        rechte_seite.append(grenze if richtung == \"<=\" else -grenze)\n",
+    "    return linprog(-DECKUNGSBEITRAG,\n",
+    "                   A_ub=np.array(matrix), b_ub=np.array(rechte_seite),\n",
+    "                   bounds=[(0, None)] * len(PRODUKTE), method=\"highs\")\n",
+    "\n",
+    "\n",
+    "def geaendert(name: str, delta: float,\n",
+    "              basis=None) -> list[tuple[str, list[float], str, float]]:\n",
+    "    \"\"\"Dieselben Bedingungen, eine davon um delta verschoben.\"\"\"\n",
+    "    return [(n, k, r, g + delta if n == name else g)\n",
+    "            for n, k, r, g in (basis or BEDINGUNGEN)]\n",
+    "\n",
+    "\n",
+    "def auswertung(ergebnis, bedingungen=None):\n",
+    "    \"\"\"Schlupf und Schattenpreis je Bedingung.\"\"\"\n",
+    "    x = ergebnis.x\n",
+    "    dual = ergebnis.ineqlin.marginals\n",
+    "    zeilen = []\n",
+    "    for i, (name, koeff, richtung, grenze) in enumerate(bedingungen or BEDINGUNGEN):\n",
+    "        links = float(np.array(koeff, dtype=float) @ x)\n",
+    "        schlupf = (grenze - links) if richtung == \"<=\" else (links - grenze)\n",
+    "        zeilen.append((name, links, richtung, grenze, schlupf, abs(dual[i])))\n",
+    "    return zeilen\n",
+    "\n",
+    "\n",
+    "def blockierer(bedingungen, zusatz) -> list[str]:\n",
+    "    \"\"\"Welche Bedingungen verhindern 'zusatz' - einzeln weggelassen.\n",
+    "\n",
+    "    Dasselbe Vorgehen wie der Deletion Filter in Konfliktsuche.py, nur mit\n",
+    "    umgekehrtem Vorzeichen: Dort wird gesucht, was den Widerspruch AUSMACHT,\n",
+    "    hier, was einen Wunsch VERHINDERT. Wird das Modell ohne eine Bedingung\n",
+    "    loesbar, gehoert sie zum Konflikt.\n",
+    "    \"\"\"\n",
+    "    gefunden = []\n",
+    "    for i, (name, _, _, _) in enumerate(bedingungen):\n",
+    "        rest = [c for j, c in enumerate(bedingungen) if j != i] + [zusatz]\n",
+    "        if loese(rest).success:\n",
+    "            gefunden.append(name)\n",
+    "    return gefunden\n",
+    "\n",
+    "\n",
+    "def euro(betrag: float) -> str:\n",
+    "    return f\"{betrag:,.2f} EUR\"\n",
+    "\n",
+    "\n",
+    "if __name__ == \"__main__\":\n",
+    "    basis = loese(BEDINGUNGEN)\n",
+    "    db_basis = -basis.fun\n",
+    "    plan = dict(zip(PRODUKTE, basis.x))\n",
+    "\n",
+    "    print(\"=\" * 78)\n",
+    "    print(\"  CONSTRAINT ATTRIBUTION: Was kostet uns welche Bedingung?\")\n",
+    "    print(\"=\" * 78)\n",
+    "    print(f\"Status: {basis.message.split('(')[0].strip()}\")\n",
+    "    print(f\"Deckungsbeitrag des Plans: {euro(db_basis)}\\n\")\n",
+    "    print(\"  \" + \"  \".join(f\"{p}: {m:.1f}\" for p, m in plan.items()))\n",
+    "\n",
+    "    # --- 1. Wer begrenzt den Plan? -----------------------------------------\n",
+    "    print(\"\\n\" + \"=\" * 78)\n",
+    "    print(\"  (1) Welche Bedingungen binden - und was kostet die naechste Einheit?\")\n",
+    "    print(\"=\" * 78)\n",
+    "    print(f\"{'Bedingung':<24} {'genutzt':>9} {'Grenze':>7} {'Schlupf':>8} \"\n",
+    "          f\"{'Schattenpreis':>11}\")\n",
+    "    print(\"-\" * 78)\n",
+    "    bindend = []\n",
+    "    for name, links, richtung, grenze, schlupf, dual in auswertung(basis):\n",
+    "        marke = \"\"\n",
+    "        if abs(schlupf) < 1e-6:\n",
+    "            bindend.append((name, dual))\n",
+    "            marke = \"  <-- bindend\"\n",
+    "        print(f\"{name:<24} {links:>9.1f} {grenze:>7.0f} {schlupf:>8.1f} \"\n",
+    "              f\"{dual:>11.2f}{marke}\")\n",
+    "\n",
+    "    ohne_preis = [n for n, d in bindend if d < 1e-9]\n",
+    "    print(f\"\\n  {len(bindend)} Bedingungen binden. Aber: \"\n",
+    "          f\"{', '.join(ohne_preis)} bindet\")\n",
+    "    print(\"  mit einem Schattenpreis von 0,00 EUR - sie beruehrt den Plan, ohne ihn\")\n",
+    "    print(\"  zu verteuern. Bindend und kostenrelevant sind zwei verschiedene Dinge.\")\n",
+    "\n",
+    "    # --- 2. Der Schattenpreis als Momentaufnahme ---------------------------\n",
+    "    print(\"\\n\" + \"=\" * 78)\n",
+    "    print(\"  (2) Was der Schattenpreis verschweigt\")\n",
+    "    print(\"=\" * 78)\n",
+    "    print(\"Der Schattenpreis gilt fuer die NAECHSTE Einheit. Ein Planer kauft aber\")\n",
+    "    print(\"keine Einheit, sondern eine ganze Schicht. Beides gegenuebergestellt:\\n\")\n",
+    "    preise = {name: dual for name, *_, dual in auswertung(basis)}\n",
+    "    print(f\"{'Stellschraube':<24} {'Preis':>9} {'Schritt':>7} \"\n",
+    "          f\"{'hochgerechnet':>13} {'gemessen':>9} {'Abw.':>9}\")\n",
+    "    print(\"-\" * 78)\n",
+    "    wirkung = {}\n",
+    "    for name, (delta, _) in STELLSCHRAUBEN.items():\n",
+    "        ergebnis = loese(geaendert(name, delta))\n",
+    "        echt = (-ergebnis.fun) - db_basis if ergebnis.success else 0.0\n",
+    "        linear = preise[name] * abs(delta)\n",
+    "        wirkung[name] = echt\n",
+    "        print(f\"{name:<24} {preise[name]:>9.2f} {delta:>+7.0f} \"\n",
+    "              f\"{linear:>13.2f} {echt:>9.2f} {echt - linear:>+9.2f}\")\n",
+    "\n",
+    "    # Wo endet der Gueltigkeitsbereich? Schrittweise nachfahren.\n",
+    "    abweichler = max(STELLSCHRAUBEN,\n",
+    "                     key=lambda n: preise[n] * abs(STELLSCHRAUBEN[n][0]) - wirkung[n])\n",
+    "    delta_max = STELLSCHRAUBEN[abweichler][0]\n",
+    "    grenze_gueltig = 0.0\n",
+    "    schritt = delta_max / 60.0\n",
+    "    vorher = db_basis\n",
+    "    for i in range(1, 61):\n",
+    "        d = schritt * i\n",
+    "        e = loese(geaendert(abweichler, d))\n",
+    "        db = -e.fun if e.success else vorher\n",
+    "        if db - vorher > 1e-9:\n",
+    "            grenze_gueltig = d\n",
+    "        vorher = db\n",
+    "    print(f\"\\n  '{abweichler}': hochgerechnet \"\n",
+    "          f\"{preise[abweichler] * abs(delta_max):.2f} EUR, tatsaechlich \"\n",
+    "          f\"{wirkung[abweichler]:.2f} EUR.\")\n",
+    "    print(f\"  Der Preis von {preise[abweichler]:.2f} EUR gilt nur bis \"\n",
+    "          f\"+{grenze_gueltig:.0f} Stunden. Jede weitere Stunde\")\n",
+    "    print(\"  dieser Sonderschicht bringt exakt nichts - der Engpass ist dann ein anderer.\")\n",
+    "\n",
+    "    nach_preis = sorted(STELLSCHRAUBEN, key=lambda n: -preise[n])[0]\n",
+    "    nach_wirkung = max(wirkung, key=wirkung.get)\n",
+    "    print(f\"\\n  Und die Ranglisten drehen sich: Nach Schattenpreis fuehrt\")\n",
+    "    print(f\"  '{nach_preis}' ({preise[nach_preis]:.2f} EUR je Einheit),\")\n",
+    "    print(f\"  nach tatsaechlicher Wirkung '{nach_wirkung}' \"\n",
+    "          f\"({wirkung[nach_wirkung]:.2f} EUR).\")\n",
+    "    print(\"  Der Schattenpreis sagt, was eine Einheit wert ist - nicht, wie viele\")\n",
+    "    print(\"  Einheiten zu haben sind.\")\n",
+    "\n",
+    "    # --- 3. Der Wunsch aus dem Vertrieb ------------------------------------\n",
+    "    print(\"\\n\" + \"=\" * 78)\n",
+    "    print(f\"  (3) Was-waere-wenn: mindestens {WUNSCH_MENGE:.0f} \"\n",
+    "          f\"{WUNSCH_PRODUKT} statt {plan[WUNSCH_PRODUKT]:.1f}\")\n",
+    "    print(\"=\" * 78)\n",
+    "    wunsch = (f\"Wunsch Vertrieb {WUNSCH_PRODUKT}\",\n",
+    "              [1 if p == WUNSCH_PRODUKT else 0 for p in PRODUKTE], \">=\", WUNSCH_MENGE)\n",
+    "    mit_wunsch = loese(BEDINGUNGEN + [wunsch])\n",
+    "    schuldige: list[str] = []\n",
+    "    engpass = noetig = None\n",
+    "    wunsch_gratis = False\n",
+    "\n",
+    "    if mit_wunsch.success:\n",
+    "        print(f\"Erfuellbar, kostet {euro(db_basis - (-mit_wunsch.fun))}.\")\n",
+    "    else:\n",
+    "        schuldige = blockierer(BEDINGUNGEN, wunsch)\n",
+    "        print(\"Der Wunsch ist nicht teuer - er ist UNMOEGLICH.\\n\")\n",
+    "        print(f\"Blockiert wird er von {len(schuldige)} Bedingungen gemeinsam. \"\n",
+    "              f\"Faellt eine davon\")\n",
+    "        print(\"weg, ist er erfuellbar; keine allein ist 'der' Grund:\")\n",
+    "        for name in schuldige:\n",
+    "            e = loese([c for c in BEDINGUNGEN if c[0] != name] + [wunsch])\n",
+    "            print(f\"   ohne '{name}': moeglich, Deckungsbeitrag {euro(-e.fun)}\")\n",
+    "\n",
+    "        engpass = next((n for n in schuldige if n in STELLSCHRAUBEN), schuldige[0])\n",
+    "        for schritt in range(1, 61):\n",
+    "            if loese(geaendert(engpass, schritt) + [wunsch]).success:\n",
+    "                noetig = schritt\n",
+    "                break\n",
+    "        if noetig is not None:\n",
+    "            e = loese(geaendert(engpass, noetig) + [wunsch])\n",
+    "            ohne = loese(geaendert(engpass, noetig))\n",
+    "            wunsch_gratis = abs((-e.fun) - (-ohne.fun)) < 1e-6\n",
+    "            print(f\"\\n   Mit +{noetig} bei '{engpass}' wird der Wunsch erfuellbar:\")\n",
+    "            print(f\"   Deckungsbeitrag {euro(-e.fun)} \"\n",
+    "                  f\"({-e.fun - db_basis:+,.2f} gegenueber heute).\")\n",
+    "            if wunsch_gratis:\n",
+    "                print(f\"   Und ohne den Wunsch ergaebe dieselbe Lockerung \"\n",
+    "                      f\"{euro(-ohne.fun)} bei\")\n",
+    "                print(f\"   {ohne.x[PRODUKTE.index(WUNSCH_PRODUKT)]:.0f} \"\n",
+    "                      f\"{WUNSCH_PRODUKT} - der Wunsch kostet also NICHTS.\")\n",
+    "                print(\"   Er war nie das Problem. Der Engpass war es.\")\n",
+    "\n",
+    "    # --- 4. Der Bericht ----------------------------------------------------\n",
+    "    # Aus denselben Zahlen, die oben in Tabellen stehen, wird hier Prosa. Kein\n",
+    "    # Satz enthaelt eine Zahl, die nicht vorher gerechnet wurde - das ist der\n",
+    "    # ganze Trick und zugleich die Bedingung dafuer, dass der Bericht nicht\n",
+    "    # irgendwann leise falsch wird.\n",
+    "    print(\"\\n\" + \"=\" * 78)\n",
+    "    print(\"  (4) Und so steht es in der Vorlage fuer die Abteilungsleiterrunde\")\n",
+    "    print(\"=\" * 78)\n",
+    "\n",
+    "    teuerste = sorted(((n, d) for n, d in bindend if d > 0), key=lambda t: -t[1])\n",
+    "    gross = STELLSCHRAUBEN[nach_wirkung][1]\n",
+    "    klein = STELLSCHRAUBEN[abweichler][1]\n",
+    "\n",
+    "    absaetze = [\n",
+    "        f\"Der Plan bringt {euro(db_basis)} Deckungsbeitrag. Begrenzt wird er von \"\n",
+    "        f\"{len(bindend)} Bedingungen, von denen {len(teuerste)} tatsaechlich Geld \"\n",
+    "        f\"kosten; \\\"{ohne_preis[0]}\\\" beruehrt den Plan, ohne ihn zu verteuern.\",\n",
+    "\n",
+    "        f\"Teuerste Bindung ist \\\"{teuerste[0][0]}\\\" mit \"\n",
+    "        f\"{teuerste[0][1]:.2f} EUR je Einheit, gefolgt von \\\"{teuerste[1][0]}\\\" \"\n",
+    "        f\"mit {teuerste[1][1]:.2f} EUR.\",\n",
+    "\n",
+    "        f\"Die groesste einzelne Verbesserung bringt {gross}: \"\n",
+    "        f\"{euro(wirkung[nach_wirkung])} mehr Deckungsbeitrag. {klein[0].upper()}{klein[1:]} \"\n",
+    "        f\"dagegen bringt nur {euro(wirkung[abweichler])} statt der rechnerischen \"\n",
+    "        f\"{euro(preise[abweichler] * abs(delta_max))} - ab +{grenze_gueltig:.0f} \"\n",
+    "        f\"Stunden begrenzt uns etwas anderes. Wer die ganze Schicht bezahlt, \"\n",
+    "        f\"bezahlt die zweite Haelfte umsonst.\",\n",
+    "    ]\n",
+    "\n",
+    "    if schuldige and noetig is not None:\n",
+    "        namen = \", \".join(f'\"{s}\"' for s in schuldige)\n",
+    "        satz = (f\"Zum Wunsch des Vertriebs ({WUNSCH_MENGE:.0f} {WUNSCH_PRODUKT} statt \"\n",
+    "                f\"{plan[WUNSCH_PRODUKT]:.1f}): Er ist mit der heutigen Ausstattung \"\n",
+    "                f\"nicht erfuellbar - nicht aus Kostengruenden, sondern weil {namen} \"\n",
+    "                f\"ihn gemeinsam blockieren. Mit +{noetig} Stunden bei \"\n",
+    "                f'\"{engpass}\" wird er moeglich')\n",
+    "        satz += (\", und er kostet dann nichts: Der Plan waehlt diese Menge von \"\n",
+    "                 \"sich aus.\" if wunsch_gratis else \".\")\n",
+    "        absaetze.append(satz)\n",
+    "\n",
+    "    for absatz in absaetze:\n",
+    "        print()\n",
+    "        print(textwrap.fill(absatz, width=76))\n",
+    "    print(\"\\n\" + \"=\" * 78)"
+   ]
+  },
   {
    "cell_type": "markdown",
    "metadata": {},
@@ -826,9 +1148,9 @@
     "\n",
     "from __future__ import annotations\n",
     "\n",
-    "import subprocess\n",
-    "import sys\n",
+    "import multiprocessing\n",
     "import time\n",
+    "from concurrent.futures import ProcessPoolExecutor\n",
     "\n",
     "import numpy as np\n",
     "from pydantic import BaseModel, Field, model_validator\n",
@@ -1031,25 +1353,29 @@
     "            if any(loesung.werte[problem.schluessel(i, j)] > 0.5 for j in range(m))]\n",
     "\n",
     "\n",
-    "def loese_in_eigenem_prozess(name: str) -> Loesung:\n",
-    "    \"\"\"Startet dieses Programm noch einmal - mit genau einem Solverimport.\"\"\"\n",
-    "    ergebnis = subprocess.run([sys.executable, __file__, name],\n",
-    "                              capture_output=True, text=True, timeout=300)\n",
-    "    if ergebnis.returncode != 0:\n",
-    "        raise RuntimeError(ergebnis.stderr.strip().splitlines()[-1])\n",
-    "    # Das DTO als JSON - genau dafuer ist ein Datenobjekt ohne Solverbezug gut.\n",
-    "    return Loesung.model_validate_json(ergebnis.stdout.strip().splitlines()[-1])\n",
+    "def loese_in_eigenem_prozess(name: str, problem: Standortproblem) -> Loesung:\n",
+    "    \"\"\"Laesst genau einen Modellbauer in einem frischen Prozess rechnen.\n",
+    "\n",
+    "    'spawn' statt des Linux-Standards 'fork': Der Kindprozess startet mit\n",
+    "    einem leeren Interpreter und importiert nur den Solver, den SEIN\n",
+    "    Modellbauer braucht. max_tasks_per_child=1 sorgt dafuer, dass der Pool\n",
+    "    seinen Arbeiter nicht wiederverwendet - sonst saessen beim zweiten Aufruf\n",
+    "    wieder beide Bibliotheken im selben Prozess.\n",
+    "\n",
+    "    Hin und zurueck wandert das Domaenenmodell bzw. das Loesungs-DTO. Beide\n",
+    "    kennen keinen Solver, sind also serialisierbar - genau dafuer sind sie da.\n",
+    "    \"\"\"\n",
+    "    with ProcessPoolExecutor(\n",
+    "            max_workers=1,\n",
+    "            mp_context=multiprocessing.get_context(\"spawn\"),\n",
+    "            max_tasks_per_child=1) as pool:\n",
+    "        return pool.submit(MODELLBAUER[name], problem).result(timeout=300)\n",
     "\n",
     "\n",
     "if __name__ == \"__main__\":\n",
     "    problem = beispielproblem()\n",
     "\n",
-    "    # --- Kindprozess: rechnen und das DTO als JSON ausgeben ---------------\n",
-    "    if len(sys.argv) > 1:\n",
-    "        print(MODELLBAUER[sys.argv[1]](problem).model_dump_json())\n",
-    "        sys.exit(0)\n",
-    "\n",
-    "    # --- Hauptprozess: beide Solver anstossen und vergleichen -------------\n",
+    "    # --- Beide Solver anstossen und vergleichen ---------------------------\n",
     "    print(\"=\" * 82)\n",
     "    print(\"  DERSELBE FALL, ZWEI SOLVER - UND EIN AUSWERTUNGSCODE\")\n",
     "    print(\"=\" * 82)\n",
@@ -1061,7 +1387,7 @@
     "    loesungen: dict[str, Loesung] = {}\n",
     "    for name, beschriftung in [(\"cpsat\", \"OR-Tools CP-SAT\"),\n",
     "                               (\"highs\", \"HiGHS (highspy)\")]:\n",
-    "        loesung = loesungen[name] = loese_in_eigenem_prozess(name)\n",
+    "        loesung = loesungen[name] = loese_in_eigenem_prozess(name, problem)\n",
     "        beanstandungen = pruefe_zuordnung(problem, loesung)\n",
     "\n",
     "        print(f\"{beschriftung}\")\n",
diff --git a/OR_HTML_04/Notebooks_04/testing.ipynb b/OR_HTML_04/Notebooks_04/testing.ipynb
index 51d110c..7ce275c 100644
--- a/OR_HTML_04/Notebooks_04/testing.ipynb
+++ b/OR_HTML_04/Notebooks_04/testing.ipynb
@@ -593,113 +593,124 @@
     "\n",
     "from __future__ import annotations\n",
     "\n",
-    "import json\n",
-    "import subprocess\n",
-    "import sys\n",
-    "import textwrap\n",
+    "import multiprocessing\n",
+    "import resource\n",
+    "import time\n",
+    "from concurrent.futures import ProcessPoolExecutor\n",
+    "\n",
+    "import numpy as np\n",
     "\n",
     "GROESSEN = [(10, 10), (32, 32), (100, 100)]   # (Lager, Kunden) -> 100 / 1.024 / 10.000 Variablen\n",
     "\n",
     "\n",
-    "# Jeder Eintrag ist ein eigenstaendiges Programm: Instanz aufbauen, loesen,\n",
-    "# Ergebnis als JSON ausgeben. Die Instanz wird in jedem Kindprozess aus\n",
-    "# derselben Saat neu erzeugt - so reist nichts ueber die Prozessgrenze,\n",
-    "# was das Ergebnis verfaelschen koennte.\n",
-    "VORSPANN = \"\"\"\n",
-    "import json, time, resource\n",
-    "import numpy as np\n",
+    "# Instanz und Speichermessung stehen als gewoehnliche Funktionen hier - nicht\n",
+    "# in einem String, den ein Kindprozess ausfuehrt. Jede Messfunktion baut die\n",
+    "# Instanz aus derselben Saat neu auf, damit ueber die Prozessgrenze nichts\n",
+    "# reist, was das Ergebnis verfaelschen koennte.\n",
     "\n",
-    "def instanz(m, n):\n",
+    "def instanz(m: int, n: int):\n",
     "    rng = np.random.default_rng(20)\n",
     "    kosten = rng.integers(5, 95, (m, n)).astype(float)\n",
     "    angebot = rng.integers(50, 150, m).astype(float)\n",
     "    bedarf = angebot.sum() * rng.dirichlet(np.ones(n))\n",
     "    return kosten, angebot, bedarf\n",
     "\n",
-    "def speicher_mb():\n",
-    "    # ru_maxrss ist unter Linux in Kilobyte\n",
+    "\n",
+    "def speicher_mb() -> float:\n",
+    "    # ru_maxrss ist unter Linux in Kilobyte. Gemessen wird der Kindprozess -\n",
+    "    # deshalb muss jede Messung einen eigenen bekommen.\n",
     "    return resource.getrusage(resource.RUSAGE_SELF).ru_maxrss / 1024\n",
     "\n",
-    "M, N = {m}, {n}\n",
-    "kosten, angebot, bedarf = instanz(M, N)\n",
-    "\"\"\"\n",
     "\n",
-    "ANSAETZE = {\n",
-    "    \"scipy.linprog\": \"\"\"\n",
-    "        from scipy.optimize import linprog\n",
-    "        t0 = time.perf_counter()\n",
-    "        c = kosten.reshape(-1)\n",
-    "        A_ub = np.zeros((M, M * N)); A_eq = np.zeros((N, M * N))\n",
-    "        for i in range(M):\n",
-    "            A_ub[i, i * N:(i + 1) * N] = 1.0\n",
-    "        for j in range(N):\n",
-    "            A_eq[j, j::N] = 1.0\n",
-    "        aufbau = time.perf_counter() - t0\n",
-    "        t0 = time.perf_counter()\n",
-    "        r = linprog(c=c, A_ub=A_ub, b_ub=angebot, A_eq=A_eq, b_eq=bedarf,\n",
-    "                    bounds=(0, None), method=\"highs\")\n",
-    "        loesen = time.perf_counter() - t0\n",
-    "        ausgabe = (float(r.fun), aufbau, loesen, speicher_mb())\n",
-    "    \"\"\",\n",
-    "\n",
-    "    \"highspy\": \"\"\"\n",
-    "        import highspy\n",
-    "        t0 = time.perf_counter()\n",
-    "        h = highspy.Highs(); h.setOptionValue(\"output_flag\", False)\n",
-    "        h.addVars(M * N, np.zeros(M * N), np.full(M * N, highspy.kHighsInf))\n",
-    "        for k in range(M * N):\n",
-    "            h.changeColCost(k, float(kosten.reshape(-1)[k]))\n",
-    "        for i in range(M):\n",
-    "            idx = np.arange(i * N, (i + 1) * N, dtype=np.int32)\n",
-    "            h.addRow(-highspy.kHighsInf, float(angebot[i]), N, idx, np.ones(N))\n",
-    "        for j in range(N):\n",
-    "            idx = np.arange(j, M * N, N, dtype=np.int32)\n",
-    "            h.addRow(float(bedarf[j]), float(bedarf[j]), M, idx, np.ones(M))\n",
-    "        aufbau = time.perf_counter() - t0\n",
-    "        t0 = time.perf_counter(); h.run(); loesen = time.perf_counter() - t0\n",
-    "        ausgabe = (h.getInfo().objective_function_value, aufbau, loesen, speicher_mb())\n",
-    "    \"\"\",\n",
-    "\n",
-    "    \"ortools/GLOP\": \"\"\"\n",
-    "        from ortools.linear_solver import pywraplp\n",
-    "        t0 = time.perf_counter()\n",
-    "        s = pywraplp.Solver.CreateSolver(\"GLOP\")\n",
-    "        x = [[s.NumVar(0, s.infinity(), f\"x{i}_{j}\") for j in range(N)]\n",
-    "             for i in range(M)]\n",
-    "        for i in range(M):\n",
-    "            s.Add(sum(x[i]) <= float(angebot[i]))\n",
-    "        for j in range(N):\n",
-    "            s.Add(sum(x[i][j] for i in range(M)) == float(bedarf[j]))\n",
-    "        s.Minimize(sum(float(kosten[i, j]) * x[i][j]\n",
-    "                       for i in range(M) for j in range(N)))\n",
-    "        aufbau = time.perf_counter() - t0\n",
-    "        t0 = time.perf_counter(); s.Solve(); loesen = time.perf_counter() - t0\n",
-    "        ausgabe = (s.Objective().Value(), aufbau, loesen, speicher_mb())\n",
-    "    \"\"\",\n",
-    "\n",
-    "    \"cvxpy\": \"\"\"\n",
-    "        import cvxpy as cp\n",
-    "        t0 = time.perf_counter()\n",
-    "        x = cp.Variable((M, N), nonneg=True)\n",
-    "        problem = cp.Problem(cp.Minimize(cp.sum(cp.multiply(kosten, x))),\n",
-    "                             [cp.sum(x, axis=1) <= angebot,\n",
-    "                              cp.sum(x, axis=0) == bedarf])\n",
-    "        aufbau = time.perf_counter() - t0\n",
-    "        t0 = time.perf_counter(); problem.solve(); loesen = time.perf_counter() - t0\n",
-    "        ausgabe = (float(problem.value), aufbau, loesen, speicher_mb())\n",
-    "    \"\"\",\n",
-    "}\n",
+    "def messe_scipy(m: int, n: int):\n",
+    "    from scipy.optimize import linprog\n",
+    "    kosten, angebot, bedarf = instanz(m, n)\n",
+    "    t0 = time.perf_counter()\n",
+    "    c = kosten.reshape(-1)\n",
+    "    A_ub = np.zeros((m, m * n)); A_eq = np.zeros((n, m * n))\n",
+    "    for i in range(m):\n",
+    "        A_ub[i, i * n:(i + 1) * n] = 1.0\n",
+    "    for j in range(n):\n",
+    "        A_eq[j, j::n] = 1.0\n",
+    "    aufbau = time.perf_counter() - t0\n",
+    "    t0 = time.perf_counter()\n",
+    "    r = linprog(c=c, A_ub=A_ub, b_ub=angebot, A_eq=A_eq, b_eq=bedarf,\n",
+    "                bounds=(0, None), method=\"highs\")\n",
+    "    loesen = time.perf_counter() - t0\n",
+    "    return float(r.fun), aufbau, loesen, speicher_mb()\n",
     "\n",
     "\n",
-    "def messe(name: str, quelltext: str, m: int, n: int):\n",
-    "    \"\"\"Fuehrt einen Ansatz in einem eigenen Prozess aus.\"\"\"\n",
-    "    programm = (VORSPANN.format(m=m, n=n) + textwrap.dedent(quelltext)\n",
-    "                + \"\\nprint(json.dumps(ausgabe))\\n\")\n",
-    "    ergebnis = subprocess.run([sys.executable, \"-c\", programm],\n",
-    "                              capture_output=True, text=True, timeout=600)\n",
-    "    if ergebnis.returncode != 0:\n",
-    "        return None, ergebnis.stderr.strip().splitlines()[-1][:60]\n",
-    "    return json.loads(ergebnis.stdout.strip().splitlines()[-1]), None\n",
+    "def messe_highspy(m: int, n: int):\n",
+    "    import highspy\n",
+    "    kosten, angebot, bedarf = instanz(m, n)\n",
+    "    t0 = time.perf_counter()\n",
+    "    h = highspy.Highs(); h.setOptionValue(\"output_flag\", False)\n",
+    "    h.addVars(m * n, np.zeros(m * n), np.full(m * n, highspy.kHighsInf))\n",
+    "    for k in range(m * n):\n",
+    "        h.changeColCost(k, float(kosten.reshape(-1)[k]))\n",
+    "    for i in range(m):\n",
+    "        idx = np.arange(i * n, (i + 1) * n, dtype=np.int32)\n",
+    "        h.addRow(-highspy.kHighsInf, float(angebot[i]), n, idx, np.ones(n))\n",
+    "    for j in range(n):\n",
+    "        idx = np.arange(j, m * n, n, dtype=np.int32)\n",
+    "        h.addRow(float(bedarf[j]), float(bedarf[j]), m, idx, np.ones(m))\n",
+    "    aufbau = time.perf_counter() - t0\n",
+    "    t0 = time.perf_counter(); h.run(); loesen = time.perf_counter() - t0\n",
+    "    return h.getInfo().objective_function_value, aufbau, loesen, speicher_mb()\n",
+    "\n",
+    "\n",
+    "def messe_ortools(m: int, n: int):\n",
+    "    from ortools.linear_solver import pywraplp\n",
+    "    kosten, angebot, bedarf = instanz(m, n)\n",
+    "    t0 = time.perf_counter()\n",
+    "    s = pywraplp.Solver.CreateSolver(\"GLOP\")\n",
+    "    x = [[s.NumVar(0, s.infinity(), f\"x{i}_{j}\") for j in range(n)]\n",
+    "         for i in range(m)]\n",
+    "    for i in range(m):\n",
+    "        s.Add(sum(x[i]) <= float(angebot[i]))\n",
+    "    for j in range(n):\n",
+    "        s.Add(sum(x[i][j] for i in range(m)) == float(bedarf[j]))\n",
+    "    s.Minimize(sum(float(kosten[i, j]) * x[i][j]\n",
+    "                   for i in range(m) for j in range(n)))\n",
+    "    aufbau = time.perf_counter() - t0\n",
+    "    t0 = time.perf_counter(); s.Solve(); loesen = time.perf_counter() - t0\n",
+    "    return s.Objective().Value(), aufbau, loesen, speicher_mb()\n",
+    "\n",
+    "\n",
+    "def messe_cvxpy(m: int, n: int):\n",
+    "    import cvxpy as cp\n",
+    "    kosten, angebot, bedarf = instanz(m, n)\n",
+    "    t0 = time.perf_counter()\n",
+    "    x = cp.Variable((m, n), nonneg=True)\n",
+    "    problem = cp.Problem(cp.Minimize(cp.sum(cp.multiply(kosten, x))),\n",
+    "                         [cp.sum(x, axis=1) <= angebot,\n",
+    "                          cp.sum(x, axis=0) == bedarf])\n",
+    "    aufbau = time.perf_counter() - t0\n",
+    "    t0 = time.perf_counter(); problem.solve(); loesen = time.perf_counter() - t0\n",
+    "    return float(problem.value), aufbau, loesen, speicher_mb()\n",
+    "\n",
+    "\n",
+    "ANSAETZE = {\"scipy.linprog\": messe_scipy, \"highspy\": messe_highspy,\n",
+    "            \"ortools/GLOP\": messe_ortools, \"cvxpy\": messe_cvxpy}\n",
+    "\n",
+    "\n",
+    "def messe(funktion, m: int, n: int):\n",
+    "    \"\"\"Fuehrt eine Messfunktion in einem FRISCHEN Prozess aus.\n",
+    "\n",
+    "    'spawn' und max_tasks_per_child=1 zusammen garantieren, was Regel 1\n",
+    "    verlangt: Jede Messung sieht einen leeren Interpreter. Ohne das\n",
+    "    zweite wuerde der Pool seinen Arbeiter wiederverwenden - dann waere\n",
+    "    der Speicherwert der zweiten Bibliothek um die erste zu hoch, und\n",
+    "    ortools und highspy saessen im selben Prozess.\n",
+    "    \"\"\"\n",
+    "    with ProcessPoolExecutor(\n",
+    "            max_workers=1,\n",
+    "            mp_context=multiprocessing.get_context(\"spawn\"),\n",
+    "            max_tasks_per_child=1) as pool:\n",
+    "        try:\n",
+    "            return pool.submit(funktion, m, n).result(timeout=600), None\n",
+    "        except Exception as fehler:\n",
+    "            return None, str(fehler).strip().splitlines()[-1][:60]\n",
     "\n",
     "\n",
     "if __name__ == \"__main__\":\n",
@@ -717,8 +728,8 @@
     "              f\"{'Loesen':>9} {'Anteil':>8} {'Speicher':>10}\")\n",
     "        print(\"  \" + \"-\" * 72)\n",
     "        zielwerte = {}\n",
-    "        for name, quelltext in ANSAETZE.items():\n",
-    "            werte, fehler = messe(name, quelltext, m, n)\n",
+    "        for name, funktion in ANSAETZE.items():\n",
+    "            werte, fehler = messe(funktion, m, n)\n",
     "            if werte is None:\n",
     "                print(f\"  {name:<16} nicht verfuegbar: {fehler}\")\n",
     "                continue\n",
diff --git a/OR_HTML_04/Operations_Research_mit_Python_Version_04.pdf b/OR_HTML_04/Operations_Research_mit_Python_Version_04.pdf
index d5e8848..077f0a4 100644
Binary files a/OR_HTML_04/Operations_Research_mit_Python_Version_04.pdf and b/OR_HTML_04/Operations_Research_mit_Python_Version_04.pdf differ
diff --git a/OR_HTML_04/anhang-fehlerdiagnose.html b/OR_HTML_04/anhang-fehlerdiagnose.html
index f41a211..47a4ca9 100644
--- a/OR_HTML_04/anhang-fehlerdiagnose.html
+++ b/OR_HTML_04/anhang-fehlerdiagnose.html
@@ -94,7 +94,7 @@
 </header>
 <div class="site-body">
   <div class="sidebar-overlay" id="sidebar-overlay" hidden></div>
-  <nav class="sidebar" id="sidebar" aria-label="Kapitelnavigation"><div class="sidebar-inhalt"><details class="sidebar-gruppe"><summary>Einstieg</summary><ul><li data-kapitel="vorwort.html"><a href="vorwort.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Vorwort & Lesehilfe</span></a></li><li data-kapitel="notation.html"><a href="notation.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Notation & Abkürzungen</span></a></li></ul></details><details class="sidebar-gruppe"><summary>Teil I: Grundlagen des Operations Research</summary><ul><li data-kapitel="einfuehrung.html"><a href="einfuehrung.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 1: Einführung in Operations Research — Vom Ursprung zur mathematischen Entscheidungsfindung</span></a></li><li data-kapitel="fundament.html"><a href="fundament.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 2: Das mathematische Fundament — Vektoren, Matrizen, Konvexität</span></a></li><li data-kapitel="oekosystem.html"><a href="oekosystem.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 3: Das Python-Ökosystem für OR — Solver, Bindings und Modellierungsschichten</span></a></li><li data-kapitel="modellierung.html"><a href="modellierung.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 4: Vom Management-Wunsch zum Modell</span></a></li></ul></details><details class="sidebar-gruppe"><summary>Teil II: Die Kernverfahren der deterministischen Optimierung</summary><ul><li data-kapitel="lp.html"><a href="lp.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 5: Lineare Programmierung — Simplex, Dualität und Schattenpreise</span></a></li><li data-kapitel="milp.html"><a href="milp.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 6: Gemischt-ganzzahlige Optimierung — Diskrete Entscheidungen und Branch-and-Bound</span></a></li><li data-kapitel="cpsat.html"><a href="cpsat.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 7: Constraint Programming mit CP-SAT — Logik, Scheduling und Zuweisung</span></a></li><li data-kapitel="graphen.html"><a href="graphen.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 8: Graphen, Flüsse und Touren — Min-Cost-Flow, Matching und VRP</span></a></li><li data-kapitel="metaheuristiken.html"><a href="metaheuristiken.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 9: Metaheuristiken — wenn der exakte Solver aussteigt</span></a></li><li data-kapitel="dekomposition.html"><a href="dekomposition.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 10: Spaltengenerierung — das Modell umbauen statt die Lösung raten</span></a></li></ul></details><details class="sidebar-gruppe"><summary>Teil III: Nichtlinearität, Unsicherheit und mehrperiodige Dynamik</summary><ul><li data-kapitel="qp-nlp.html"><a href="qp-nlp.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 11: Quadratische und nichtlineare Optimierung — KKT, Lagrange, Konvexität</span></a></li><li data-kapitel="unsicherheit.html"><a href="unsicherheit.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 12: Optimierung unter Unsicherheit — Monte-Carlo, Stochastik, Robustheit</span></a></li><li data-kapitel="dynamische-programmierung.html"><a href="dynamische-programmierung.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 13: Dynamische Programmierung — Die Bellman-Gleichung und Order-Execution</span></a></li><li data-kapitel="mehrziel.html"><a href="mehrziel.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 14: Mehrere Ziele — Pareto-Fronten statt Gewichte</span></a></li><li data-kapitel="prognose.html"><a href="prognose.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 15: Predict-then-Optimize — die bessere Prognose, die schlechtere Entscheidung</span></a></li></ul></details><details class="sidebar-gruppe"><summary>Teil IV: Anwendungen — Energiewirtschaft und Finanzmärkte</summary><ul><li data-kapitel="bruecke.html"><a href="bruecke.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 16: Die Strukturbrücke — dieselbe Mathematik, zwei Welten</span></a></li><li data-kapitel="supplychain.html"><a href="supplychain.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 17: Supply-Chain und Energieeinsatz unter Unsicherheit</span></a></li><li data-kapitel="finanzdaten.html"><a href="finanzdaten.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 18: Finanzdaten-Modellierung — Renditen, Kovarianz und Shrinkage</span></a></li><li data-kapitel="markowitz.html"><a href="markowitz.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 19: Die moderne Portfoliotheorie nach Markowitz</span></a></li><li data-kapitel="cvar.html"><a href="cvar.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 20: Tail-Risiko, CVaR und Transaktionskosten</span></a></li><li data-kapitel="handelsmaschine.html"><a href="handelsmaschine.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 21: Die vollständige quantitative Handelsmaschine</span></a></li></ul></details><details class="sidebar-gruppe"><summary>Teil V: Praxis</summary><ul><li data-kapitel="praxisfallen.html"><a href="praxisfallen.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 22: Praxisfallen und der Weg zum produktiven Einsatz</span></a></li><li data-kapitel="testing.html"><a href="testing.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 23: Testen, Messen, Ausliefern</span></a></li><li data-kapitel="projektwerkstatt.html"><a href="projektwerkstatt.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Projektwerkstatt</span></a></li></ul></details><details class="sidebar-gruppe" open><summary>Anhänge</summary><ul><li data-kapitel="anhang-loesungen.html"><a href="anhang-loesungen.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Anhang A: Lösungen zu allen Übungsaufgaben</span></a></li><li data-kapitel="anhang-modellierungsmuster.html"><a href="anhang-modellierungsmuster.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Anhang B: Katalog der Modellierungsmuster</span></a></li><li data-kapitel="anhang-fehlerdiagnose.html" class="aktiv"><a href="anhang-fehlerdiagnose.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Anhang C: Fehlerdiagnose-Handbuch</span></a></li><li data-kapitel="anhang-spickzettel.html"><a href="anhang-spickzettel.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Anhang D: Spickzettel der Solver</span></a></li><li data-kapitel="anhang-glossar-literatur.html"><a href="anhang-glossar-literatur.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Anhang E: Glossar und Literatur</span></a></li></ul></details><ul class="sidebar-extra"><li><a href="programme.html"><svg class="icon" aria-hidden="true"><use href="#icon-book"></use></svg> Beispielprogramme</a></li><li><a href="stichwortverzeichnis.html"><svg class="icon" aria-hidden="true"><use href="#icon-search"></use></svg> Stichwortverzeichnis</a></li><li><a href="gesamtdokument.html"><svg class="icon" aria-hidden="true"><use href="#icon-external-link"></use></svg> Gesamtdokument (eine Seite)</a></li><li><a href="Operations_Research_mit_Python_Version_04.pdf" download><svg class="icon" aria-hidden="true"><use href="#icon-download"></use></svg> Download als PDF</a></li></ul></div></nav>
+  <nav class="sidebar" id="sidebar" aria-label="Kapitelnavigation"><div class="sidebar-inhalt"><details class="sidebar-gruppe"><summary>Einstieg</summary><ul><li data-kapitel="vorwort.html"><a href="vorwort.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Vorwort & Lesehilfe</span></a></li><li data-kapitel="notation.html"><a href="notation.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Notation & Abkürzungen</span></a></li></ul></details><details class="sidebar-gruppe"><summary>Teil I: Grundlagen des Operations Research</summary><ul><li data-kapitel="einfuehrung.html"><a href="einfuehrung.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 1: Einführung in Operations Research — Vom Ursprung zur mathematischen Entscheidungsfindung</span></a></li><li data-kapitel="fundament.html"><a href="fundament.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 2: Das mathematische Fundament — Vektoren, Matrizen, Konvexität</span></a></li><li data-kapitel="oekosystem.html"><a href="oekosystem.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 3: Das Python-Ökosystem für OR — Solver, Bindings und Modellierungsschichten</span></a></li><li data-kapitel="modellierung.html"><a href="modellierung.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 4: Vom Management-Wunsch zum Modell</span></a></li><li data-kapitel="synthese-grundlagen.html"><a href="synthese-grundlagen.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Synthese Teil I</span></a></li></ul></details><details class="sidebar-gruppe"><summary>Teil II: Die Kernverfahren der deterministischen Optimierung</summary><ul><li data-kapitel="lp.html"><a href="lp.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 5: Lineare Programmierung — Simplex, Dualität und Schattenpreise</span></a></li><li data-kapitel="milp.html"><a href="milp.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 6: Gemischt-ganzzahlige Optimierung — Diskrete Entscheidungen und Branch-and-Bound</span></a></li><li data-kapitel="cpsat.html"><a href="cpsat.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 7: Constraint Programming mit CP-SAT — Logik, Scheduling und Zuweisung</span></a></li><li data-kapitel="graphen.html"><a href="graphen.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 8: Graphen, Flüsse und Touren — Min-Cost-Flow, Matching und VRP</span></a></li><li data-kapitel="metaheuristiken.html"><a href="metaheuristiken.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 9: Metaheuristiken — wenn der exakte Solver aussteigt</span></a></li><li data-kapitel="dekomposition.html"><a href="dekomposition.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 10: Spaltengenerierung — das Modell umbauen statt die Lösung raten</span></a></li><li data-kapitel="synthese-kernverfahren.html"><a href="synthese-kernverfahren.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Synthese Teil II</span></a></li></ul></details><details class="sidebar-gruppe"><summary>Teil III: Nichtlinearität, Unsicherheit und mehrperiodige Dynamik</summary><ul><li data-kapitel="qp-nlp.html"><a href="qp-nlp.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 11: Quadratische und nichtlineare Optimierung — KKT, Lagrange, Konvexität</span></a></li><li data-kapitel="unsicherheit.html"><a href="unsicherheit.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 12: Optimierung unter Unsicherheit — Monte-Carlo, Stochastik, Robustheit</span></a></li><li data-kapitel="dynamische-programmierung.html"><a href="dynamische-programmierung.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 13: Dynamische Programmierung — Die Bellman-Gleichung und Order-Execution</span></a></li><li data-kapitel="mehrziel.html"><a href="mehrziel.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 14: Mehrere Ziele — Pareto-Fronten statt Gewichte</span></a></li><li data-kapitel="prognose.html"><a href="prognose.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 15: Predict-then-Optimize — die bessere Prognose, die schlechtere Entscheidung</span></a></li><li data-kapitel="synthese-nichtlinear.html"><a href="synthese-nichtlinear.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Synthese Teil III</span></a></li></ul></details><details class="sidebar-gruppe"><summary>Teil IV: Anwendungen — Energiewirtschaft und Finanzmärkte</summary><ul><li data-kapitel="bruecke.html"><a href="bruecke.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 16: Die Strukturbrücke — dieselbe Mathematik, zwei Welten</span></a></li><li data-kapitel="supplychain.html"><a href="supplychain.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 17: Supply-Chain und Energieeinsatz unter Unsicherheit</span></a></li><li data-kapitel="finanzdaten.html"><a href="finanzdaten.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 18: Finanzdaten-Modellierung — Renditen, Kovarianz und Shrinkage</span></a></li><li data-kapitel="markowitz.html"><a href="markowitz.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 19: Die moderne Portfoliotheorie nach Markowitz</span></a></li><li data-kapitel="cvar.html"><a href="cvar.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 20: Tail-Risiko, CVaR und Transaktionskosten</span></a></li><li data-kapitel="handelsmaschine.html"><a href="handelsmaschine.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 21: Die vollständige quantitative Handelsmaschine</span></a></li><li data-kapitel="synthese-anwendungen.html"><a href="synthese-anwendungen.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Synthese Teil IV</span></a></li></ul></details><details class="sidebar-gruppe"><summary>Teil V: Praxis</summary><ul><li data-kapitel="praxisfallen.html"><a href="praxisfallen.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 22: Praxisfallen und der Weg zum produktiven Einsatz</span></a></li><li data-kapitel="testing.html"><a href="testing.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 23: Testen, Messen, Ausliefern</span></a></li><li data-kapitel="synthese-praxis.html"><a href="synthese-praxis.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Synthese Teil V</span></a></li><li data-kapitel="projektwerkstatt.html"><a href="projektwerkstatt.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Projektwerkstatt</span></a></li></ul></details><details class="sidebar-gruppe" open><summary>Anhänge</summary><ul><li data-kapitel="anhang-loesungen.html"><a href="anhang-loesungen.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Anhang A: Lösungen zu allen Übungsaufgaben</span></a></li><li data-kapitel="anhang-modellierungsmuster.html"><a href="anhang-modellierungsmuster.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Anhang B: Katalog der Modellierungsmuster</span></a></li><li data-kapitel="anhang-fehlerdiagnose.html" class="aktiv"><a href="anhang-fehlerdiagnose.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Anhang C: Fehlerdiagnose-Handbuch</span></a></li><li data-kapitel="anhang-spickzettel.html"><a href="anhang-spickzettel.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Anhang D: Spickzettel der Solver</span></a></li><li data-kapitel="anhang-glossar-literatur.html"><a href="anhang-glossar-literatur.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Anhang E: Glossar und Literatur</span></a></li></ul></details><ul class="sidebar-extra"><li><a href="programme.html"><svg class="icon" aria-hidden="true"><use href="#icon-book"></use></svg> Beispielprogramme</a></li><li><a href="stichwortverzeichnis.html"><svg class="icon" aria-hidden="true"><use href="#icon-search"></use></svg> Stichwortverzeichnis</a></li><li><a href="gesamtdokument.html"><svg class="icon" aria-hidden="true"><use href="#icon-external-link"></use></svg> Gesamtdokument (eine Seite)</a></li><li><a href="Operations_Research_mit_Python_Version_04.pdf" download><svg class="icon" aria-hidden="true"><use href="#icon-download"></use></svg> Download als PDF</a></li></ul></div></nav>
   <main class="content">
     <nav class="breadcrumb" aria-label="Breadcrumb"><a href="index.html">Start</a> › <span>Anhang C: Fehlerdiagnose-Handbuch</span></nav>
     <nav class="prev-next"><a class="prev-next-knopf prev-next-prev" href="anhang-modellierungsmuster.html"><svg class="icon" aria-hidden="true"><use href="#icon-chevron-left"></use></svg><span><small>Zurück</small>Anhang B: Katalog der Modellierungsmuster</span></a><a class="prev-next-knopf prev-next-next" href="anhang-spickzettel.html"><span><small>Weiter</small>Anhang D: Spickzettel der Solver</span><svg class="icon" aria-hidden="true"><use href="#icon-chevron-right"></use></svg></a></nav>
@@ -731,7 +731,7 @@ Insgesamt 2874 Solveraufrufe fuer die gesamte Diagnose.
 <h2 id="c9-importfehler">C9 — Importfehler</h2>
 <pre><code>ImportError: .../highspy/_core...so: undefined symbol: _ZN5Highs13releaseMemoryEv</code></pre>
 <p><strong>Ursache.</strong> <code>ortools</code> und <code>highspy</code> bringen beide eine eigene HiGHS-Kopie mit; sie lassen sich auf vielen Systemen <strong>nicht im selben Prozess</strong> importieren (siehe <a href="oekosystem.html#sec:oekosystem-ein-system-vier-programmieransaetze">Abschnitt 3.5</a>). Der Konflikt entsteht auch <strong>indirekt</strong>: <code>cvxpy</code> importiert ein installiertes <code>highspy</code> bei der Solver-Erkennung selbst mit — ein Skript, das erst <code>cvxpy</code> und dann <code>ortools</code> importiert, crasht daher mit derselben Meldung.</p>
-<p><strong>Abhilfen (in dieser Reihenfolge):</strong> 1. Nur eines von beiden im selben Skript verwenden. 2. Getrennte Prozesse (<code>subprocess</code>) — siehe <code>Ein_System_Vier_Ansaetze.py</code>. 3. Auf <code>highspy</code> verzichten: HiGHS ist ohnehin Backend von <code>scipy.optimize.linprog</code> und CVXPY. 4. Getrennte virtuelle Umgebungen.</p>
+<p><strong>Abhilfen (in dieser Reihenfolge):</strong> 1. Nur eines von beiden im selben Skript verwenden. 2. Getrennte Prozesse — ein <code>ProcessPoolExecutor</code> mit <code>mp_context="spawn"</code> und <code>max_tasks_per_child=1</code>, siehe <code>Ein_System_Vier_Ansaetze.py</code>. 3. Auf <code>highspy</code> verzichten: HiGHS ist ohnehin Backend von <code>scipy.optimize.linprog</code> und CVXPY. 4. Getrennte virtuelle Umgebungen.</p>
 <hr />
 <h2 id="c10-verdächtig-guter-backtest">C10 — Verdächtig guter Backtest</h2>
 <p><strong>Faustregel:</strong> Eine Sharpe Ratio über 2 bei einer einfachen Strategie ist fast immer ein Fehler, kein Fund.</p>
diff --git a/OR_HTML_04/anhang-glossar-literatur.html b/OR_HTML_04/anhang-glossar-literatur.html
index 678db7f..8ec842a 100644
--- a/OR_HTML_04/anhang-glossar-literatur.html
+++ b/OR_HTML_04/anhang-glossar-literatur.html
@@ -94,7 +94,7 @@
 </header>
 <div class="site-body">
   <div class="sidebar-overlay" id="sidebar-overlay" hidden></div>
-  <nav class="sidebar" id="sidebar" aria-label="Kapitelnavigation"><div class="sidebar-inhalt"><details class="sidebar-gruppe"><summary>Einstieg</summary><ul><li data-kapitel="vorwort.html"><a href="vorwort.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Vorwort & Lesehilfe</span></a></li><li data-kapitel="notation.html"><a href="notation.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Notation & Abkürzungen</span></a></li></ul></details><details class="sidebar-gruppe"><summary>Teil I: Grundlagen des Operations Research</summary><ul><li data-kapitel="einfuehrung.html"><a href="einfuehrung.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 1: Einführung in Operations Research — Vom Ursprung zur mathematischen Entscheidungsfindung</span></a></li><li data-kapitel="fundament.html"><a href="fundament.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 2: Das mathematische Fundament — Vektoren, Matrizen, Konvexität</span></a></li><li data-kapitel="oekosystem.html"><a href="oekosystem.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 3: Das Python-Ökosystem für OR — Solver, Bindings und Modellierungsschichten</span></a></li><li data-kapitel="modellierung.html"><a href="modellierung.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 4: Vom Management-Wunsch zum Modell</span></a></li></ul></details><details class="sidebar-gruppe"><summary>Teil II: Die Kernverfahren der deterministischen Optimierung</summary><ul><li data-kapitel="lp.html"><a href="lp.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 5: Lineare Programmierung — Simplex, Dualität und Schattenpreise</span></a></li><li data-kapitel="milp.html"><a href="milp.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 6: Gemischt-ganzzahlige Optimierung — Diskrete Entscheidungen und Branch-and-Bound</span></a></li><li data-kapitel="cpsat.html"><a href="cpsat.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 7: Constraint Programming mit CP-SAT — Logik, Scheduling und Zuweisung</span></a></li><li data-kapitel="graphen.html"><a href="graphen.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 8: Graphen, Flüsse und Touren — Min-Cost-Flow, Matching und VRP</span></a></li><li data-kapitel="metaheuristiken.html"><a href="metaheuristiken.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 9: Metaheuristiken — wenn der exakte Solver aussteigt</span></a></li><li data-kapitel="dekomposition.html"><a href="dekomposition.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 10: Spaltengenerierung — das Modell umbauen statt die Lösung raten</span></a></li></ul></details><details class="sidebar-gruppe"><summary>Teil III: Nichtlinearität, Unsicherheit und mehrperiodige Dynamik</summary><ul><li data-kapitel="qp-nlp.html"><a href="qp-nlp.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 11: Quadratische und nichtlineare Optimierung — KKT, Lagrange, Konvexität</span></a></li><li data-kapitel="unsicherheit.html"><a href="unsicherheit.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 12: Optimierung unter Unsicherheit — Monte-Carlo, Stochastik, Robustheit</span></a></li><li data-kapitel="dynamische-programmierung.html"><a href="dynamische-programmierung.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 13: Dynamische Programmierung — Die Bellman-Gleichung und Order-Execution</span></a></li><li data-kapitel="mehrziel.html"><a href="mehrziel.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 14: Mehrere Ziele — Pareto-Fronten statt Gewichte</span></a></li><li data-kapitel="prognose.html"><a href="prognose.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 15: Predict-then-Optimize — die bessere Prognose, die schlechtere Entscheidung</span></a></li></ul></details><details class="sidebar-gruppe"><summary>Teil IV: Anwendungen — Energiewirtschaft und Finanzmärkte</summary><ul><li data-kapitel="bruecke.html"><a href="bruecke.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 16: Die Strukturbrücke — dieselbe Mathematik, zwei Welten</span></a></li><li data-kapitel="supplychain.html"><a href="supplychain.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 17: Supply-Chain und Energieeinsatz unter Unsicherheit</span></a></li><li data-kapitel="finanzdaten.html"><a href="finanzdaten.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 18: Finanzdaten-Modellierung — Renditen, Kovarianz und Shrinkage</span></a></li><li data-kapitel="markowitz.html"><a href="markowitz.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 19: Die moderne Portfoliotheorie nach Markowitz</span></a></li><li data-kapitel="cvar.html"><a href="cvar.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 20: Tail-Risiko, CVaR und Transaktionskosten</span></a></li><li data-kapitel="handelsmaschine.html"><a href="handelsmaschine.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 21: Die vollständige quantitative Handelsmaschine</span></a></li></ul></details><details class="sidebar-gruppe"><summary>Teil V: Praxis</summary><ul><li data-kapitel="praxisfallen.html"><a href="praxisfallen.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 22: Praxisfallen und der Weg zum produktiven Einsatz</span></a></li><li data-kapitel="testing.html"><a href="testing.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 23: Testen, Messen, Ausliefern</span></a></li><li data-kapitel="projektwerkstatt.html"><a href="projektwerkstatt.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Projektwerkstatt</span></a></li></ul></details><details class="sidebar-gruppe" open><summary>Anhänge</summary><ul><li data-kapitel="anhang-loesungen.html"><a href="anhang-loesungen.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Anhang A: Lösungen zu allen Übungsaufgaben</span></a></li><li data-kapitel="anhang-modellierungsmuster.html"><a href="anhang-modellierungsmuster.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Anhang B: Katalog der Modellierungsmuster</span></a></li><li data-kapitel="anhang-fehlerdiagnose.html"><a href="anhang-fehlerdiagnose.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Anhang C: Fehlerdiagnose-Handbuch</span></a></li><li data-kapitel="anhang-spickzettel.html"><a href="anhang-spickzettel.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Anhang D: Spickzettel der Solver</span></a></li><li data-kapitel="anhang-glossar-literatur.html" class="aktiv"><a href="anhang-glossar-literatur.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Anhang E: Glossar und Literatur</span></a></li></ul></details><ul class="sidebar-extra"><li><a href="programme.html"><svg class="icon" aria-hidden="true"><use href="#icon-book"></use></svg> Beispielprogramme</a></li><li><a href="stichwortverzeichnis.html"><svg class="icon" aria-hidden="true"><use href="#icon-search"></use></svg> Stichwortverzeichnis</a></li><li><a href="gesamtdokument.html"><svg class="icon" aria-hidden="true"><use href="#icon-external-link"></use></svg> Gesamtdokument (eine Seite)</a></li><li><a href="Operations_Research_mit_Python_Version_04.pdf" download><svg class="icon" aria-hidden="true"><use href="#icon-download"></use></svg> Download als PDF</a></li></ul></div></nav>
+  <nav class="sidebar" id="sidebar" aria-label="Kapitelnavigation"><div class="sidebar-inhalt"><details class="sidebar-gruppe"><summary>Einstieg</summary><ul><li data-kapitel="vorwort.html"><a href="vorwort.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Vorwort & Lesehilfe</span></a></li><li data-kapitel="notation.html"><a href="notation.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Notation & Abkürzungen</span></a></li></ul></details><details class="sidebar-gruppe"><summary>Teil I: Grundlagen des Operations Research</summary><ul><li data-kapitel="einfuehrung.html"><a href="einfuehrung.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 1: Einführung in Operations Research — Vom Ursprung zur mathematischen Entscheidungsfindung</span></a></li><li data-kapitel="fundament.html"><a href="fundament.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 2: Das mathematische Fundament — Vektoren, Matrizen, Konvexität</span></a></li><li data-kapitel="oekosystem.html"><a href="oekosystem.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 3: Das Python-Ökosystem für OR — Solver, Bindings und Modellierungsschichten</span></a></li><li data-kapitel="modellierung.html"><a href="modellierung.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 4: Vom Management-Wunsch zum Modell</span></a></li><li data-kapitel="synthese-grundlagen.html"><a href="synthese-grundlagen.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Synthese Teil I</span></a></li></ul></details><details class="sidebar-gruppe"><summary>Teil II: Die Kernverfahren der deterministischen Optimierung</summary><ul><li data-kapitel="lp.html"><a href="lp.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 5: Lineare Programmierung — Simplex, Dualität und Schattenpreise</span></a></li><li data-kapitel="milp.html"><a href="milp.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 6: Gemischt-ganzzahlige Optimierung — Diskrete Entscheidungen und Branch-and-Bound</span></a></li><li data-kapitel="cpsat.html"><a href="cpsat.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 7: Constraint Programming mit CP-SAT — Logik, Scheduling und Zuweisung</span></a></li><li data-kapitel="graphen.html"><a href="graphen.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 8: Graphen, Flüsse und Touren — Min-Cost-Flow, Matching und VRP</span></a></li><li data-kapitel="metaheuristiken.html"><a href="metaheuristiken.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 9: Metaheuristiken — wenn der exakte Solver aussteigt</span></a></li><li data-kapitel="dekomposition.html"><a href="dekomposition.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 10: Spaltengenerierung — das Modell umbauen statt die Lösung raten</span></a></li><li data-kapitel="synthese-kernverfahren.html"><a href="synthese-kernverfahren.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Synthese Teil II</span></a></li></ul></details><details class="sidebar-gruppe"><summary>Teil III: Nichtlinearität, Unsicherheit und mehrperiodige Dynamik</summary><ul><li data-kapitel="qp-nlp.html"><a href="qp-nlp.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 11: Quadratische und nichtlineare Optimierung — KKT, Lagrange, Konvexität</span></a></li><li data-kapitel="unsicherheit.html"><a href="unsicherheit.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 12: Optimierung unter Unsicherheit — Monte-Carlo, Stochastik, Robustheit</span></a></li><li data-kapitel="dynamische-programmierung.html"><a href="dynamische-programmierung.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 13: Dynamische Programmierung — Die Bellman-Gleichung und Order-Execution</span></a></li><li data-kapitel="mehrziel.html"><a href="mehrziel.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 14: Mehrere Ziele — Pareto-Fronten statt Gewichte</span></a></li><li data-kapitel="prognose.html"><a href="prognose.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 15: Predict-then-Optimize — die bessere Prognose, die schlechtere Entscheidung</span></a></li><li data-kapitel="synthese-nichtlinear.html"><a href="synthese-nichtlinear.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Synthese Teil III</span></a></li></ul></details><details class="sidebar-gruppe"><summary>Teil IV: Anwendungen — Energiewirtschaft und Finanzmärkte</summary><ul><li data-kapitel="bruecke.html"><a href="bruecke.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 16: Die Strukturbrücke — dieselbe Mathematik, zwei Welten</span></a></li><li data-kapitel="supplychain.html"><a href="supplychain.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 17: Supply-Chain und Energieeinsatz unter Unsicherheit</span></a></li><li data-kapitel="finanzdaten.html"><a href="finanzdaten.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 18: Finanzdaten-Modellierung — Renditen, Kovarianz und Shrinkage</span></a></li><li data-kapitel="markowitz.html"><a href="markowitz.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 19: Die moderne Portfoliotheorie nach Markowitz</span></a></li><li data-kapitel="cvar.html"><a href="cvar.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 20: Tail-Risiko, CVaR und Transaktionskosten</span></a></li><li data-kapitel="handelsmaschine.html"><a href="handelsmaschine.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 21: Die vollständige quantitative Handelsmaschine</span></a></li><li data-kapitel="synthese-anwendungen.html"><a href="synthese-anwendungen.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Synthese Teil IV</span></a></li></ul></details><details class="sidebar-gruppe"><summary>Teil V: Praxis</summary><ul><li data-kapitel="praxisfallen.html"><a href="praxisfallen.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 22: Praxisfallen und der Weg zum produktiven Einsatz</span></a></li><li data-kapitel="testing.html"><a href="testing.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 23: Testen, Messen, Ausliefern</span></a></li><li data-kapitel="synthese-praxis.html"><a href="synthese-praxis.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Synthese Teil V</span></a></li><li data-kapitel="projektwerkstatt.html"><a href="projektwerkstatt.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Projektwerkstatt</span></a></li></ul></details><details class="sidebar-gruppe" open><summary>Anhänge</summary><ul><li data-kapitel="anhang-loesungen.html"><a href="anhang-loesungen.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Anhang A: Lösungen zu allen Übungsaufgaben</span></a></li><li data-kapitel="anhang-modellierungsmuster.html"><a href="anhang-modellierungsmuster.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Anhang B: Katalog der Modellierungsmuster</span></a></li><li data-kapitel="anhang-fehlerdiagnose.html"><a href="anhang-fehlerdiagnose.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Anhang C: Fehlerdiagnose-Handbuch</span></a></li><li data-kapitel="anhang-spickzettel.html"><a href="anhang-spickzettel.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Anhang D: Spickzettel der Solver</span></a></li><li data-kapitel="anhang-glossar-literatur.html" class="aktiv"><a href="anhang-glossar-literatur.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Anhang E: Glossar und Literatur</span></a></li></ul></details><ul class="sidebar-extra"><li><a href="programme.html"><svg class="icon" aria-hidden="true"><use href="#icon-book"></use></svg> Beispielprogramme</a></li><li><a href="stichwortverzeichnis.html"><svg class="icon" aria-hidden="true"><use href="#icon-search"></use></svg> Stichwortverzeichnis</a></li><li><a href="gesamtdokument.html"><svg class="icon" aria-hidden="true"><use href="#icon-external-link"></use></svg> Gesamtdokument (eine Seite)</a></li><li><a href="Operations_Research_mit_Python_Version_04.pdf" download><svg class="icon" aria-hidden="true"><use href="#icon-download"></use></svg> Download als PDF</a></li></ul></div></nav>
   <main class="content">
     <nav class="breadcrumb" aria-label="Breadcrumb"><a href="index.html">Start</a> › <span>Anhang E: Glossar und Literatur</span></nav>
     <nav class="prev-next"><a class="prev-next-knopf prev-next-prev" href="anhang-spickzettel.html"><svg class="icon" aria-hidden="true"><use href="#icon-chevron-left"></use></svg><span><small>Zurück</small>Anhang D: Spickzettel der Solver</span></a><span class="prev-next-leer"></span></nav>
diff --git a/OR_HTML_04/anhang-loesungen.html b/OR_HTML_04/anhang-loesungen.html
index eb8f287..a1d76ce 100644
--- a/OR_HTML_04/anhang-loesungen.html
+++ b/OR_HTML_04/anhang-loesungen.html
@@ -94,7 +94,7 @@
 </header>
 <div class="site-body">
   <div class="sidebar-overlay" id="sidebar-overlay" hidden></div>
-  <nav class="sidebar" id="sidebar" aria-label="Kapitelnavigation"><div class="sidebar-inhalt"><details class="sidebar-gruppe"><summary>Einstieg</summary><ul><li data-kapitel="vorwort.html"><a href="vorwort.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Vorwort & Lesehilfe</span></a></li><li data-kapitel="notation.html"><a href="notation.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Notation & Abkürzungen</span></a></li></ul></details><details class="sidebar-gruppe"><summary>Teil I: Grundlagen des Operations Research</summary><ul><li data-kapitel="einfuehrung.html"><a href="einfuehrung.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 1: Einführung in Operations Research — Vom Ursprung zur mathematischen Entscheidungsfindung</span></a></li><li data-kapitel="fundament.html"><a href="fundament.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 2: Das mathematische Fundament — Vektoren, Matrizen, Konvexität</span></a></li><li data-kapitel="oekosystem.html"><a href="oekosystem.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 3: Das Python-Ökosystem für OR — Solver, Bindings und Modellierungsschichten</span></a></li><li data-kapitel="modellierung.html"><a href="modellierung.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 4: Vom Management-Wunsch zum Modell</span></a></li></ul></details><details class="sidebar-gruppe"><summary>Teil II: Die Kernverfahren der deterministischen Optimierung</summary><ul><li data-kapitel="lp.html"><a href="lp.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 5: Lineare Programmierung — Simplex, Dualität und Schattenpreise</span></a></li><li data-kapitel="milp.html"><a href="milp.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 6: Gemischt-ganzzahlige Optimierung — Diskrete Entscheidungen und Branch-and-Bound</span></a></li><li data-kapitel="cpsat.html"><a href="cpsat.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 7: Constraint Programming mit CP-SAT — Logik, Scheduling und Zuweisung</span></a></li><li data-kapitel="graphen.html"><a href="graphen.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 8: Graphen, Flüsse und Touren — Min-Cost-Flow, Matching und VRP</span></a></li><li data-kapitel="metaheuristiken.html"><a href="metaheuristiken.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 9: Metaheuristiken — wenn der exakte Solver aussteigt</span></a></li><li data-kapitel="dekomposition.html"><a href="dekomposition.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 10: Spaltengenerierung — das Modell umbauen statt die Lösung raten</span></a></li></ul></details><details class="sidebar-gruppe"><summary>Teil III: Nichtlinearität, Unsicherheit und mehrperiodige Dynamik</summary><ul><li data-kapitel="qp-nlp.html"><a href="qp-nlp.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 11: Quadratische und nichtlineare Optimierung — KKT, Lagrange, Konvexität</span></a></li><li data-kapitel="unsicherheit.html"><a href="unsicherheit.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 12: Optimierung unter Unsicherheit — Monte-Carlo, Stochastik, Robustheit</span></a></li><li data-kapitel="dynamische-programmierung.html"><a href="dynamische-programmierung.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 13: Dynamische Programmierung — Die Bellman-Gleichung und Order-Execution</span></a></li><li data-kapitel="mehrziel.html"><a href="mehrziel.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 14: Mehrere Ziele — Pareto-Fronten statt Gewichte</span></a></li><li data-kapitel="prognose.html"><a href="prognose.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 15: Predict-then-Optimize — die bessere Prognose, die schlechtere Entscheidung</span></a></li></ul></details><details class="sidebar-gruppe"><summary>Teil IV: Anwendungen — Energiewirtschaft und Finanzmärkte</summary><ul><li data-kapitel="bruecke.html"><a href="bruecke.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 16: Die Strukturbrücke — dieselbe Mathematik, zwei Welten</span></a></li><li data-kapitel="supplychain.html"><a href="supplychain.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 17: Supply-Chain und Energieeinsatz unter Unsicherheit</span></a></li><li data-kapitel="finanzdaten.html"><a href="finanzdaten.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 18: Finanzdaten-Modellierung — Renditen, Kovarianz und Shrinkage</span></a></li><li data-kapitel="markowitz.html"><a href="markowitz.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 19: Die moderne Portfoliotheorie nach Markowitz</span></a></li><li data-kapitel="cvar.html"><a href="cvar.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 20: Tail-Risiko, CVaR und Transaktionskosten</span></a></li><li data-kapitel="handelsmaschine.html"><a href="handelsmaschine.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 21: Die vollständige quantitative Handelsmaschine</span></a></li></ul></details><details class="sidebar-gruppe"><summary>Teil V: Praxis</summary><ul><li data-kapitel="praxisfallen.html"><a href="praxisfallen.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 22: Praxisfallen und der Weg zum produktiven Einsatz</span></a></li><li data-kapitel="testing.html"><a href="testing.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 23: Testen, Messen, Ausliefern</span></a></li><li data-kapitel="projektwerkstatt.html"><a href="projektwerkstatt.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Projektwerkstatt</span></a></li></ul></details><details class="sidebar-gruppe" open><summary>Anhänge</summary><ul><li data-kapitel="anhang-loesungen.html" class="aktiv"><a href="anhang-loesungen.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Anhang A: Lösungen zu allen Übungsaufgaben</span></a></li><li data-kapitel="anhang-modellierungsmuster.html"><a href="anhang-modellierungsmuster.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Anhang B: Katalog der Modellierungsmuster</span></a></li><li data-kapitel="anhang-fehlerdiagnose.html"><a href="anhang-fehlerdiagnose.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Anhang C: Fehlerdiagnose-Handbuch</span></a></li><li data-kapitel="anhang-spickzettel.html"><a href="anhang-spickzettel.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Anhang D: Spickzettel der Solver</span></a></li><li data-kapitel="anhang-glossar-literatur.html"><a href="anhang-glossar-literatur.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Anhang E: Glossar und Literatur</span></a></li></ul></details><ul class="sidebar-extra"><li><a href="programme.html"><svg class="icon" aria-hidden="true"><use href="#icon-book"></use></svg> Beispielprogramme</a></li><li><a href="stichwortverzeichnis.html"><svg class="icon" aria-hidden="true"><use href="#icon-search"></use></svg> Stichwortverzeichnis</a></li><li><a href="gesamtdokument.html"><svg class="icon" aria-hidden="true"><use href="#icon-external-link"></use></svg> Gesamtdokument (eine Seite)</a></li><li><a href="Operations_Research_mit_Python_Version_04.pdf" download><svg class="icon" aria-hidden="true"><use href="#icon-download"></use></svg> Download als PDF</a></li></ul></div></nav>
+  <nav class="sidebar" id="sidebar" aria-label="Kapitelnavigation"><div class="sidebar-inhalt"><details class="sidebar-gruppe"><summary>Einstieg</summary><ul><li data-kapitel="vorwort.html"><a href="vorwort.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Vorwort & Lesehilfe</span></a></li><li data-kapitel="notation.html"><a href="notation.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Notation & Abkürzungen</span></a></li></ul></details><details class="sidebar-gruppe"><summary>Teil I: Grundlagen des Operations Research</summary><ul><li data-kapitel="einfuehrung.html"><a href="einfuehrung.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 1: Einführung in Operations Research — Vom Ursprung zur mathematischen Entscheidungsfindung</span></a></li><li data-kapitel="fundament.html"><a href="fundament.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 2: Das mathematische Fundament — Vektoren, Matrizen, Konvexität</span></a></li><li data-kapitel="oekosystem.html"><a href="oekosystem.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 3: Das Python-Ökosystem für OR — Solver, Bindings und Modellierungsschichten</span></a></li><li data-kapitel="modellierung.html"><a href="modellierung.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 4: Vom Management-Wunsch zum Modell</span></a></li><li data-kapitel="synthese-grundlagen.html"><a href="synthese-grundlagen.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Synthese Teil I</span></a></li></ul></details><details class="sidebar-gruppe"><summary>Teil II: Die Kernverfahren der deterministischen Optimierung</summary><ul><li data-kapitel="lp.html"><a href="lp.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 5: Lineare Programmierung — Simplex, Dualität und Schattenpreise</span></a></li><li data-kapitel="milp.html"><a href="milp.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 6: Gemischt-ganzzahlige Optimierung — Diskrete Entscheidungen und Branch-and-Bound</span></a></li><li data-kapitel="cpsat.html"><a href="cpsat.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 7: Constraint Programming mit CP-SAT — Logik, Scheduling und Zuweisung</span></a></li><li data-kapitel="graphen.html"><a href="graphen.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 8: Graphen, Flüsse und Touren — Min-Cost-Flow, Matching und VRP</span></a></li><li data-kapitel="metaheuristiken.html"><a href="metaheuristiken.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 9: Metaheuristiken — wenn der exakte Solver aussteigt</span></a></li><li data-kapitel="dekomposition.html"><a href="dekomposition.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 10: Spaltengenerierung — das Modell umbauen statt die Lösung raten</span></a></li><li data-kapitel="synthese-kernverfahren.html"><a href="synthese-kernverfahren.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Synthese Teil II</span></a></li></ul></details><details class="sidebar-gruppe"><summary>Teil III: Nichtlinearität, Unsicherheit und mehrperiodige Dynamik</summary><ul><li data-kapitel="qp-nlp.html"><a href="qp-nlp.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 11: Quadratische und nichtlineare Optimierung — KKT, Lagrange, Konvexität</span></a></li><li data-kapitel="unsicherheit.html"><a href="unsicherheit.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 12: Optimierung unter Unsicherheit — Monte-Carlo, Stochastik, Robustheit</span></a></li><li data-kapitel="dynamische-programmierung.html"><a href="dynamische-programmierung.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 13: Dynamische Programmierung — Die Bellman-Gleichung und Order-Execution</span></a></li><li data-kapitel="mehrziel.html"><a href="mehrziel.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 14: Mehrere Ziele — Pareto-Fronten statt Gewichte</span></a></li><li data-kapitel="prognose.html"><a href="prognose.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 15: Predict-then-Optimize — die bessere Prognose, die schlechtere Entscheidung</span></a></li><li data-kapitel="synthese-nichtlinear.html"><a href="synthese-nichtlinear.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Synthese Teil III</span></a></li></ul></details><details class="sidebar-gruppe"><summary>Teil IV: Anwendungen — Energiewirtschaft und Finanzmärkte</summary><ul><li data-kapitel="bruecke.html"><a href="bruecke.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 16: Die Strukturbrücke — dieselbe Mathematik, zwei Welten</span></a></li><li data-kapitel="supplychain.html"><a href="supplychain.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 17: Supply-Chain und Energieeinsatz unter Unsicherheit</span></a></li><li data-kapitel="finanzdaten.html"><a href="finanzdaten.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 18: Finanzdaten-Modellierung — Renditen, Kovarianz und Shrinkage</span></a></li><li data-kapitel="markowitz.html"><a href="markowitz.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 19: Die moderne Portfoliotheorie nach Markowitz</span></a></li><li data-kapitel="cvar.html"><a href="cvar.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 20: Tail-Risiko, CVaR und Transaktionskosten</span></a></li><li data-kapitel="handelsmaschine.html"><a href="handelsmaschine.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 21: Die vollständige quantitative Handelsmaschine</span></a></li><li data-kapitel="synthese-anwendungen.html"><a href="synthese-anwendungen.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Synthese Teil IV</span></a></li></ul></details><details class="sidebar-gruppe"><summary>Teil V: Praxis</summary><ul><li data-kapitel="praxisfallen.html"><a href="praxisfallen.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 22: Praxisfallen und der Weg zum produktiven Einsatz</span></a></li><li data-kapitel="testing.html"><a href="testing.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 23: Testen, Messen, Ausliefern</span></a></li><li data-kapitel="synthese-praxis.html"><a href="synthese-praxis.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Synthese Teil V</span></a></li><li data-kapitel="projektwerkstatt.html"><a href="projektwerkstatt.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Projektwerkstatt</span></a></li></ul></details><details class="sidebar-gruppe" open><summary>Anhänge</summary><ul><li data-kapitel="anhang-loesungen.html" class="aktiv"><a href="anhang-loesungen.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Anhang A: Lösungen zu allen Übungsaufgaben</span></a></li><li data-kapitel="anhang-modellierungsmuster.html"><a href="anhang-modellierungsmuster.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Anhang B: Katalog der Modellierungsmuster</span></a></li><li data-kapitel="anhang-fehlerdiagnose.html"><a href="anhang-fehlerdiagnose.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Anhang C: Fehlerdiagnose-Handbuch</span></a></li><li data-kapitel="anhang-spickzettel.html"><a href="anhang-spickzettel.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Anhang D: Spickzettel der Solver</span></a></li><li data-kapitel="anhang-glossar-literatur.html"><a href="anhang-glossar-literatur.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Anhang E: Glossar und Literatur</span></a></li></ul></details><ul class="sidebar-extra"><li><a href="programme.html"><svg class="icon" aria-hidden="true"><use href="#icon-book"></use></svg> Beispielprogramme</a></li><li><a href="stichwortverzeichnis.html"><svg class="icon" aria-hidden="true"><use href="#icon-search"></use></svg> Stichwortverzeichnis</a></li><li><a href="gesamtdokument.html"><svg class="icon" aria-hidden="true"><use href="#icon-external-link"></use></svg> Gesamtdokument (eine Seite)</a></li><li><a href="Operations_Research_mit_Python_Version_04.pdf" download><svg class="icon" aria-hidden="true"><use href="#icon-download"></use></svg> Download als PDF</a></li></ul></div></nav>
   <main class="content">
     <nav class="breadcrumb" aria-label="Breadcrumb"><a href="index.html">Start</a> › <span>Anhang A: Lösungen zu allen Übungsaufgaben</span></nav>
     <nav class="prev-next"><a class="prev-next-knopf prev-next-prev" href="projektwerkstatt.html"><svg class="icon" aria-hidden="true"><use href="#icon-chevron-left"></use></svg><span><small>Zurück</small>Projektwerkstatt</span></a><a class="prev-next-knopf prev-next-next" href="anhang-modellierungsmuster.html"><span><small>Weiter</small>Anhang B: Katalog der Modellierungsmuster</span><svg class="icon" aria-hidden="true"><use href="#icon-chevron-right"></use></svg></a></nav>
@@ -124,7 +124,7 @@
 <p><strong>Zwei lehrreiche Beobachtungen:</strong> 1. Die <strong>Vertragsbedingung <span class="math inline">x_1 \ge 40</span> ist nicht bindend</strong> — der Solver backt freiwillig 96 Brote. Wer aus der Aufgabenstellung schließt, die Mindestmenge werde „gerade so“ erfüllt, liegt falsch. 2. Das <strong>kontinuierliche</strong> Optimum <span class="math inline">(40;\ 116{,}67)</span> liefert <strong>denselben</strong> Zielwert 450. Das Problem hat also mehrere optimale Lösungen — die Zielfunktion verläuft parallel zur Mehlrestriktion (<span class="math inline">2{,}5/0{,}5 = 5 = 3{,}0/0{,}6</span>). Prüfen Sie das nach: Genau deshalb ist hier auch die ganzzahlige Lösung ohne Verlust erreichbar.</p>
 <p><strong>1.6 — Sensitivität durch Ausprobieren.</strong> Schleife über <code>RAM_GESAMT in range(54, 73, 2)</code>, jeweils Modell neu lösen. (a) Ab 62 GB steigt der Gewinn nicht mehr — dann bindet die <strong>vCPU</strong>-Grenze, RAM ist nicht mehr der Engpass. (b) Der Zuwachs je GB ist der <strong>Schattenpreis</strong> (<a href="lp.html#kap-lp">Kapitel 5</a>). Solange RAM bindet, liegt er bei 31,25 €/GB; danach fällt er auf 0.</p>
 <p><strong>1.7 — Eigenes Problem.</strong> Individuell. Prüfkriterien: Sind die Variablen wirklich <em>entscheidbar</em> (nicht bereits festgelegt)? Hat die Zielfunktion eine <strong>Einheit</strong>? Ist jede harte Bedingung wirklich unverhandelbar?</p>
-<h3 id="finde-den-denkfehler-1.1-die-schreinerei-verdoppelt-ihren-gewinn">Finde den Denkfehler 1.1 — Die Schreinerei verdoppelt ihren Gewinn</h3>
+<h3 id="finde-den-denkfehler-die-schreinerei-verdoppelt-ihren-gewinn">Finde den Denkfehler — Die Schreinerei verdoppelt ihren Gewinn</h3>
 <ol type="a">
 <li><p><strong>Nachrechnen.</strong> Der Plan lautet 40 Tische und 150 Stühle: <span class="math inline">40 \cdot 3 + 150 \cdot 1 = \mathbf{270}</span> Montagestunden bei 150 verfügbaren, und <span class="math inline">40 \cdot 6 + 150 \cdot 1 = \mathbf{390}</span> m² Material bei 240 verfügbaren. Beide Vorräte sind fast doppelt überzogen — der Plan ist in der Werkstatt nicht ausführbar.</p></li>
 <li><p><strong>Der Fehler.</strong> Die Nebenbedingungen stehen <strong>innerhalb</strong> der Produktschleife. Dadurch entsteht je Produkt eine eigene Kapazitätsgrenze („der Tisch allein darf 150 Stunden verbrauchen“, „der Stuhl allein darf 150 Stunden verbrauchen“) statt einer <strong>gemeinsamen</strong> Grenze über alle Produkte hinweg. Die Ressource wird so für jedes Produkt neu verteilt — im Modell existiert sie mehrfach.</p></li>
@@ -167,7 +167,7 @@
 <span id="cb4-2"><a href="#cb4-2" aria-hidden="true" tabindex="-1"></a>    lam, V <span class="op">=</span> np.linalg.eigh(P)</span>
 <span id="cb4-3"><a href="#cb4-3" aria-hidden="true" tabindex="-1"></a>    <span class="cf">return</span> V <span class="op">@</span> np.diag(np.maximum(lam, <span class="fl">0.0</span>)) <span class="op">@</span> V.T</span></code></pre></div>
 <p>Für <span class="math inline">\mathbf{P}_2</span> ergibt sich eine PSD-Matrix mit Korrelation exakt <span class="math inline">1{,}0</span> — das Verfahren zieht die unmögliche Korrelation auf den nächstgelegenen zulässigen Wert. Für Kovarianzmatrizen setzt man in der Praxis auf einen kleinen positiven Wert statt auf 0 (<code>np.maximum(lam, 1e-10)</code>), damit die Matrix invertierbar bleibt.</p>
-<h3 id="finde-den-denkfehler-2.1-die-unauffällige-transposition">Finde den Denkfehler 2.1 — Die unauffällige Transposition</h3>
+<h3 id="finde-den-denkfehler-die-unauffällige-transposition">Finde den Denkfehler — Die unauffällige Transposition</h3>
 <ol type="a">
 <li><p><strong>Warum nichts auffällt.</strong> <span class="math inline">\mathbf{A}</span> ist quadratisch, also passen die Dimensionen auch transponiert. NumPy prüft Formen, nicht Bedeutungen; der Solver bekommt ein vollkommen zulässiges LP vorgelegt und löst es korrekt — nur eben ein <strong>anderes</strong>. Eine Transposition ist genau dann gefährlich, wenn sie folgenlos <em>aussieht</em>: Wäre die Matrix <span class="math inline">2 \times 3</span> gewesen, hätte NumPy sofort einen Dimensionsfehler geworfen.</p></li>
 <li><p><strong>Der Plan an den echten Restriktionen.</strong> Mit <span class="math inline">\mathbf{A} = \begin{pmatrix} 1 &amp; 2 \\ 3 &amp; 1\end{pmatrix}</span> und <span class="math inline">\mathbf{x} = (5{,}6;\ 0{,}8)</span>:</p></li>
@@ -175,7 +175,7 @@
 <p><span class="math display">\mathbf{A}\mathbf{x} = \begin{pmatrix} 1\cdot5{,}6 + 2\cdot0{,}8 \\ 3\cdot5{,}6 + 1\cdot0{,}8\end{pmatrix} = \begin{pmatrix} 7{,}2 \\ 17{,}6 \end{pmatrix} \quad\text{gegen}\quad \mathbf{b} = \begin{pmatrix} 8 \\ 12\end{pmatrix}</span></p>
 <p>Die zweite Ressource ist um <strong>47 % überzogen</strong> (17,6 statt 12). Der Plan ist in der Werkstatt nicht ausführbar.</p>
 <ol start="3" type="a">
-<li><p><strong>Warum „zu klein“ schlimmer ist als „zu groß“.</strong> Ein unerwartet <em>hoher</em> Zielwert weckt Misstrauen — man rechnet nach (siehe Denkfehler 1.1). Ein leicht <em>niedrigerer</em> Wert wirkt dagegen wie ein normales, etwas enttäuschendes Ergebnis: Niemand prüft nach, warum die Optimierung „nur“ 20,80 € statt der erhofften 22 € bringt. Fehler, die sich als Bescheidenheit tarnen, überleben am längsten.</p></li>
+<li><p><strong>Warum „zu klein“ schlimmer ist als „zu groß“.</strong> Ein unerwartet <em>hoher</em> Zielwert weckt Misstrauen — man rechnet nach (siehe <a href="einfuehrung.html#sec:einfuehrung-denkfehler">Abschnitt 1.10</a>). Ein leicht <em>niedrigerer</em> Wert wirkt dagegen wie ein normales, etwas enttäuschendes Ergebnis: Niemand prüft nach, warum die Optimierung „nur“ 20,80 € statt der erhofften 22 € bringt. Fehler, die sich als Bescheidenheit tarnen, überleben am längsten.</p></li>
 <li><p><strong>Zwei Zeilen, die es aufgedeckt hätten.</strong> Erstens beim Einlesen die Form gegen die Bedeutung prüfen, zweitens nach dem Lösen den Verbrauch gegen den Vorrat:</p></li>
 </ol>
 <div class="sourceCode" id="cb5"><pre class="sourceCode python"><code class="sourceCode python"><span id="cb5-1"><a href="#cb5-1" aria-hidden="true" tabindex="-1"></a><span class="cf">assert</span> A.shape <span class="op">==</span> (<span class="bu">len</span>(b), <span class="bu">len</span>(c)), <span class="st">&quot;A: Zeilen = Ressourcen, Spalten = Variablen&quot;</span></span>
@@ -202,7 +202,7 @@
 <p><strong>3.4 — Konvexitätsprüfung.</strong> <span class="math inline">\min x^3</span> wirft <code>DCPError: Problem does not follow DCP rules</code>, weil <span class="math inline">x^3</span> auf <span class="math inline">[-2,2]</span> weder konvex noch konkav ist. <span class="math inline">\min x^2</span> läuft und liefert <span class="math inline">x=0</span>. Der Unterschied: CVXPY akzeptiert nur Ausdrücke, deren Konvexität es <strong>beweisen</strong> kann — dafür garantiert es das globale Optimum.</p>
 <p><strong>3.5 — Laufzeitvergleich.</strong> Erwartetes Muster: <code>linprog</code> und <code>highspy</code> liegen bei kleinen Modellen gleichauf (Overhead dominiert); ab etwa <span class="math inline">n \gtrsim 500</span> zieht <code>highspy</code> davon, weil der Modellaufbau effizienter ist. CVXPY hat den größten festen Aufwand (Ausdrucksbaum-Kompilierung), der bei wiederholten Läufen mit <code>cp.Parameter</code> teilweise entfällt.</p>
 <p><strong>3.6 — Eigene Entscheidungshilfe.</strong> Ergänzungen: Bei kommerzieller Lizenz Gurobi/CPLEX über Pyomo oder CVXPY empfehlen; bei Lesbarkeitsanforderung Pyomo (algebraische Notation, Trennung von Daten und Modell).</p>
-<h3 id="finde-den-denkfehler-3.1-der-solver-der-angeblich-dreimal-schneller-ist">Finde den Denkfehler 3.1 — Der Solver, der angeblich dreimal schneller ist</h3>
+<h3 id="finde-den-denkfehler-der-solver-der-angeblich-dreimal-schneller-ist">Finde den Denkfehler — Der Solver, der angeblich dreimal schneller ist</h3>
 <ol type="a">
 <li><strong>Was da alles mitgemessen wird.</strong> Die Stoppuhr läuft ab der ersten Zeile, also mindestens über drei Dinge, die mit Lösegeschwindigkeit nichts zu tun haben:</li>
 </ol>
@@ -248,19 +248,20 @@
 </ol>
 <hr />
 <h2 id="sec:loesungen-modellierung">A.4 Lösungen zu Kapitel „Vom Management-Wunsch zum Modell“</h2>
-<p><strong>Die fehlende Lesart.</strong> Eine dritte Lesart: <strong>„Der Umsatzanteil der Stammkunden darf nicht unter 30 % fallen.”</strong> Sie zielt weder auf einzelne Aufträge noch auf einzelne Kunden, sondern auf das Gesamtbild. Sie beschreibt einen Betrieb, dem die <em>Struktur</em> seines Geschäfts wichtig ist — etwa weil Stammkunden verlässlicher zahlen oder weil eine zu große Abhängigkeit von Neukunden als Risiko gilt. Sie lässt zu, dass ein einzelner Stammkunde in einem Quartal leer ausgeht, solange die Summe stimmt.</p>
+<p><strong>4.1 — Die fehlende Lesart.</strong> Eine dritte Lesart: <strong>„Der Umsatzanteil der Stammkunden darf nicht unter 30 % fallen.”</strong> Sie zielt weder auf einzelne Aufträge noch auf einzelne Kunden, sondern auf das Gesamtbild. Sie beschreibt einen Betrieb, dem die <em>Struktur</em> seines Geschäfts wichtig ist — etwa weil Stammkunden verlässlicher zahlen oder weil eine zu große Abhängigkeit von Neukunden als Risiko gilt. Sie lässt zu, dass ein einzelner Stammkunde in einem Quartal leer ausgeht, solange die Summe stimmt.</p>
 <p>Der Punkt der Aufgabe: Alle drei Lesarten sind vertretbar, und keine ist aus dem Satz ableitbar. Die Wahl trifft man — im Zweifel unbewusst.</p>
-<p><strong>Frage 5 anwenden.</strong> Wird die <em>durchschnittliche</em> Wartezeit minimiert, lohnt es sich, viele leichte Fälle schnell abzuarbeiten und die aufwendigen nach hinten zu schieben: Ein Fall mit vier Stunden Wartezeit zählt genauso viel wie vier Fälle mit einer Stunde. Der optimale Plan behandelt also bevorzugt Bagatellen und lässt schwere Fälle warten — medizinisch das Gegenteil des Gewollten.</p>
+<p><strong>4.2 — Frage 5 anwenden.</strong> Wird die <em>durchschnittliche</em> Wartezeit minimiert, lohnt es sich, viele leichte Fälle schnell abzuarbeiten und die aufwendigen nach hinten zu schieben: Ein Fall mit vier Stunden Wartezeit zählt genauso viel wie vier Fälle mit einer Stunde. Der optimale Plan behandelt also bevorzugt Bagatellen und lässt schwere Fälle warten — medizinisch das Gegenteil des Gewollten.</p>
 <p>Das ist genau der Ertrag von Frage 5: Der Plan lässt sich <em>ablehnen</em>, und aus der Ablehnung folgt die richtige Zielgröße — etwa die maximale Wartezeit je Dringlichkeitsstufe, oder die Einhaltung von Zielzeiten je Triage-Kategorie.</p>
-<p><strong>Der Kompromiss dazwischen.</strong> Je Stammkunde eine Nebenbedingung: Die Summe der zugeteilten Stunden dieses Kunden muss mindestens die Hälfte seiner angefragten Stunden betragen.</p>
+<p><strong>4.3 — Der Kompromiss dazwischen.</strong> Je Stammkunde eine Nebenbedingung: Die Summe der zugeteilten Stunden dieses Kunden muss mindestens die Hälfte seiner angefragten Stunden betragen.</p>
 <div class="sourceCode" id="cb7"><pre class="sourceCode python"><code class="sourceCode python"><span id="cb7-1"><a href="#cb7-1" aria-hidden="true" tabindex="-1"></a><span class="cf">for</span> kunde <span class="kw">in</span> STAMMKUNDEN:</span>
 <span id="cb7-2"><a href="#cb7-2" aria-hidden="true" tabindex="-1"></a>    stunden_kunde <span class="op">=</span> [a[<span class="dv">3</span>] <span class="cf">if</span> a[<span class="dv">1</span>] <span class="op">==</span> kunde <span class="cf">else</span> <span class="dv">0</span> <span class="cf">for</span> a <span class="kw">in</span> AUFTRAEGE]</span>
 <span id="cb7-3"><a href="#cb7-3" aria-hidden="true" tabindex="-1"></a>    je_kunde_ub.append([<span class="op">-</span>s <span class="cf">for</span> s <span class="kw">in</span> stunden_kunde])</span>
 <span id="cb7-4"><a href="#cb7-4" aria-hidden="true" tabindex="-1"></a>    je_kunde_b.append(<span class="op">-</span><span class="fl">0.5</span> <span class="op">*</span> <span class="bu">sum</span>(stunden_kunde))</span></code></pre></div>
 <p>Erwartung: Das Ergebnis liegt zwischen Lesart A und B — die Regel bindet stärker als „ein Auftrag genügt”, aber schwächer als „alle Aufträge”. Der Lehrpunkt ist nicht die Zahl, sondern dass sich zwischen zwei Lesarten beliebig fein abstufen lässt, sobald man sie einmal als Ungleichung geschrieben hat.</p>
-<p><strong>Zwei Ziele gleichzeitig.</strong> Bei <span class="math inline">\lambda = 0</span> ergibt sich der DB-Plan (78 500 € DB), bei großem <span class="math inline">\lambda</span> der Umsatzplan (66 000 € DB). Dazwischen kippt es an genau einer Stelle — und zwar <strong>sprunghaft</strong>, nicht allmählich: Weil die Entscheidungsvariablen binär sind, gibt es nur endlich viele Pläne, und der Wechsel erfolgt, sobald ein anderer Plan den höheren gewichteten Wert hat.</p>
+<p><strong>4.4 — Zwei Ziele gleichzeitig.</strong> Bei <span class="math inline">\lambda = 0</span> ergibt sich der DB-Plan (78 500 € DB), bei großem <span class="math inline">\lambda</span> der Umsatzplan (66 000 € DB). Dazwischen kippt es an genau einer Stelle — und zwar <strong>sprunghaft</strong>, nicht allmählich: Weil die Entscheidungsvariablen binär sind, gibt es nur endlich viele Pläne, und der Wechsel erfolgt, sobald ein anderer Plan den höheren gewichteten Wert hat.</p>
 <p>Der Kippwert sagt dem Betrieb etwas Konkretes: <em>„Erst wenn Ihnen ein Euro Umsatz mehr wert ist als λ Euro Deckungsbeitrag, ändert sich Ihr Plan.”</em> Das ist eine Frage, die ein Kaufmann beantworten kann — anders als „welche Gewichtung hätten Sie gern?“.</p>
-<p><strong>Die Anforderung schreiben.</strong> Eine tragfähige Anforderung enthält mindestens:</p>
+<p><strong>4.5 — Übersetzen, wo es nicht eindeutig ist.</strong> (a) Drei Lesarten von „gleichmäßig ausgelastet”: <strong>(1) Spannweite minimieren</strong> — <span class="math inline">\max_i a_i - \min_i a_i</span>. Bestraft Ausreißer nach beiden Seiten; ein einzelner Untätiger ist genauso schlimm wie ein Überlasteter. <strong>(2) Den Schlechtestgestellten verbessern</strong> — <span class="math inline">\max_i a_i</span> minimieren (B11). Interessiert sich nicht dafür, wie ungleich die übrigen liegen, solange die Spitze sinkt. <strong>(3) Abweichung vom Mittel minimieren</strong> — <span class="math inline">\sum_i |a_i - \bar a|</span> (B10). Verteilt die Last am gleichmäßigsten, kann aber die Spitze höher lassen als (2). Wo es sichtbar wird: Bei fünf Monteuren mit 8, 8, 8, 8 und 16 Stunden senkt (2) die 16 zuerst; bei 4, 8, 8, 8, 12 tut (1) am meisten gegen die Spreizung, während (2) kaum etwas findet. Und wenn ein Monteur aus guten Gründen nur halbtags da ist, bestrafen (1) und (3) genau das — (2) nicht. (b) Hart: <span class="math inline">w_k \le 3</span> für jeden Kunden <span class="math inline">k</span>. Weich: <span class="math inline">w_k \le 3 + s_k</span> mit <span class="math inline">s_k \ge 0</span> und Strafkosten <span class="math inline">c \cdot s_k</span> in der Zielfunktion (B8, B18). Die Frage an den Betrieb ist die dritte der vier: <em>Was passiert, wenn es einmal nicht geht?</em> Führt die Antwort zu „dann müssen wir eben” — weich. Führt sie zu „das darf nicht passieren, dann rufen wir an und verschieben” — dann ist auch das ein Prozess, und die Bedingung bleibt weich, nur mit sehr hohen Strafkosten. Wirklich hart ist sie nur, wenn ein Verstoß rechtlich unmöglich ist. (c) Individuell. Prüfkriterium: Wird eine Wendung gefunden, die <strong>zwei</strong> vertretbare Modelle zulässt — und wird benannt, wer die Wahl treffen muss? Die häufigsten Kandidaten in echten Anforderungen sind „in der Regel”, „zeitnah”, „vergleichbar” und jede Zahl ohne Bezugszeitraum.</p>
+<p><strong>4.6 — Die Anforderung schreiben.</strong> Eine tragfähige Anforderung enthält mindestens:</p>
 <ul>
 <li><strong>Entscheidung:</strong> Für jede Anfrage im Planungszeitraum: annehmen oder ablehnen.</li>
 <li><strong>Ziel:</strong> Deckungsbeitrag maximieren (Umsatz minus Material).</li>
@@ -323,14 +324,14 @@
 </ol>
 <hr />
 <h2 id="sec:loesungen-lp">A.5 Lösungen zu Kapitel „Lineare Programmierung — Simplex, Dualität und Schattenpreise“</h2>
-<p><strong>4.1 — Schlupf deuten.</strong> (a) Ressourcen 1 und 3 (Schlupf 0). (b) Ja: Überall ist <span class="math inline">s_i \cdot y_i = 0</span>. (c) In Ressource 3 — der höchste Schattenpreis (9,8) bedeutet den größten Grenznutzen.</p>
-<p><strong>4.2 — Vorzeichen.</strong> Er hat die Zielfunktion für <code>linprog</code> negiert und die Dualwerte nicht zurückgedreht. Der korrekte Schattenpreis ist <strong>+45 €</strong>.</p>
-<p><strong>4.3 — Simplex von Hand.</strong> Starttableau mit <span class="math inline">s_1, s_2</span> in der Basis. Erste Iteration: Pivotspalte <span class="math inline">x_1</span> (<span class="math inline">-5</span>), Quotienten <span class="math inline">24/6 = 4</span> und <span class="math inline">6/1 = 6</span> → Pivotzeile 1. Nach dem Tausch: <span class="math inline">x_1 = 4</span>, <span class="math inline">Z = 20</span>. Zweite Iteration: Pivotspalte <span class="math inline">x_2</span>, Pivotzeile 2 → <span class="math inline">x_1 = 3</span>, <span class="math inline">x_2 = 1{,}5</span>, <span class="math inline">Z = 21</span>. <strong>Optimum:</strong> <span class="math inline">\mathbf{x}^* = (3;\ 1{,}5)</span>, <span class="math inline">Z^* = 21</span>, Schattenpreise <span class="math inline">y^* = (0{,}75;\ 0{,}50)</span>.</p>
-<p><strong>4.4 — Duales Problem.</strong> <span class="math inline">\min 24y_1 + 6y_2</span> u. d. N. <span class="math inline">6y_1 + y_2 \ge 5</span>, <span class="math inline">4y_1 + 2y_2 \ge 4</span>, <span class="math inline">y \ge 0</span>. Lösung <span class="math inline">y^* = (0{,}75;\ 0{,}50)</span>. Probe der Restriktionen: <span class="math inline">6\cdot0{,}75 + 0{,}5 = 5</span> ✓ (mit Gleichheit, weil <span class="math inline">x_1 &gt; 0</span>), <span class="math inline">4\cdot0{,}75 + 2\cdot0{,}5 = 4</span> ✓ (ebenfalls Gleichheit, weil <span class="math inline">x_2 &gt; 0</span>). Zielwert <span class="math inline">24\cdot0{,}75 + 6\cdot0{,}5 = 18 + 3 = 21 = Z^*</span> ✓ — starker Dualitätssatz bestätigt.</p>
-<p><strong>4.5 — Unbeschränktheit.</strong> Der Solver wirft „Problem ist unbeschränkt“. Geometrisch: Der zulässige Bereich <span class="math inline">\{x_1 - x_2 \le 5,\ x \ge 0\}</span> ist nach oben offen — man kann <span class="math inline">x_1</span> und <span class="math inline">x_2</span> gemeinsam beliebig wachsen lassen (z. B. <span class="math inline">x_1 = x_2 = t</span> für <span class="math inline">t \to \infty</span>), ohne eine Bedingung zu verletzen, und <span class="math inline">Z = 2t</span> wächst mit. In der Praxis fehlt fast immer eine Kapazitätsgrenze.</p>
-<p><strong>4.6 — Gültigkeitsbereich.</strong> (a) Bei ca. 66,7 Stunden Prüfkapazität wird die <strong>Lackierzeit</strong> zum Engpass; der Schattenpreis der Prüfung fällt dann. (b) Zukaufen lohnt bis zu dem Punkt, an dem der Schattenpreis unter 18 €/h fällt. (c) Der Gewinnverlauf ist <strong>stückweise linear und konkav</strong>: Jedes Teilstück hat die Steigung des jeweils gültigen Schattenpreises, und die Steigungen werden immer flacher — jede zusätzliche Einheit bringt weniger, weil andere Engpässe nachrücken.</p>
-<p><strong>4.7 — Phase 1.</strong> Ansatz: Für jede Zeile mit <span class="math inline">b_i &lt; 0</span> (nach Umformung zu <span class="math inline">\ge</span>) eine künstliche Variable <span class="math inline">a_i \ge 0</span> einführen, Hilfszielfunktion <span class="math inline">\min \sum a_i</span> lösen. Ist das Minimum 0, existiert eine zulässige Basislösung, und man startet Phase 2 mit dem erreichten Tableau. Ist es <span class="math inline">&gt; 0</span>, ist das Problem unzulässig. Für das Beispiel: Optimum <span class="math inline">(12;\ 0)</span>, <span class="math inline">Z = 36</span>.</p>
-<h3 id="finde-den-denkfehler-4.1-die-380-000-euro-maschine">Finde den Denkfehler 4.1 — Die 380 000-Euro-Maschine</h3>
+<p><strong>5.1 — Schlupf deuten.</strong> (a) Ressourcen 1 und 3 (Schlupf 0). (b) Ja: Überall ist <span class="math inline">s_i \cdot y_i = 0</span>. (c) In Ressource 3 — der höchste Schattenpreis (9,8) bedeutet den größten Grenznutzen.</p>
+<p><strong>5.2 — Vorzeichen.</strong> Er hat die Zielfunktion für <code>linprog</code> negiert und die Dualwerte nicht zurückgedreht. Der korrekte Schattenpreis ist <strong>+45 €</strong>.</p>
+<p><strong>5.3 — Simplex von Hand.</strong> Starttableau mit <span class="math inline">s_1, s_2</span> in der Basis. Erste Iteration: Pivotspalte <span class="math inline">x_1</span> (<span class="math inline">-5</span>), Quotienten <span class="math inline">24/6 = 4</span> und <span class="math inline">6/1 = 6</span> → Pivotzeile 1. Nach dem Tausch: <span class="math inline">x_1 = 4</span>, <span class="math inline">Z = 20</span>. Zweite Iteration: Pivotspalte <span class="math inline">x_2</span>, Pivotzeile 2 → <span class="math inline">x_1 = 3</span>, <span class="math inline">x_2 = 1{,}5</span>, <span class="math inline">Z = 21</span>. <strong>Optimum:</strong> <span class="math inline">\mathbf{x}^* = (3;\ 1{,}5)</span>, <span class="math inline">Z^* = 21</span>, Schattenpreise <span class="math inline">y^* = (0{,}75;\ 0{,}50)</span>.</p>
+<p><strong>5.4 — Duales Problem.</strong> <span class="math inline">\min 24y_1 + 6y_2</span> u. d. N. <span class="math inline">6y_1 + y_2 \ge 5</span>, <span class="math inline">4y_1 + 2y_2 \ge 4</span>, <span class="math inline">y \ge 0</span>. Lösung <span class="math inline">y^* = (0{,}75;\ 0{,}50)</span>. Probe der Restriktionen: <span class="math inline">6\cdot0{,}75 + 0{,}5 = 5</span> ✓ (mit Gleichheit, weil <span class="math inline">x_1 &gt; 0</span>), <span class="math inline">4\cdot0{,}75 + 2\cdot0{,}5 = 4</span> ✓ (ebenfalls Gleichheit, weil <span class="math inline">x_2 &gt; 0</span>). Zielwert <span class="math inline">24\cdot0{,}75 + 6\cdot0{,}5 = 18 + 3 = 21 = Z^*</span> ✓ — starker Dualitätssatz bestätigt.</p>
+<p><strong>5.5 — Unbeschränktheit.</strong> Der Solver wirft „Problem ist unbeschränkt“. Geometrisch: Der zulässige Bereich <span class="math inline">\{x_1 - x_2 \le 5,\ x \ge 0\}</span> ist nach oben offen — man kann <span class="math inline">x_1</span> und <span class="math inline">x_2</span> gemeinsam beliebig wachsen lassen (z. B. <span class="math inline">x_1 = x_2 = t</span> für <span class="math inline">t \to \infty</span>), ohne eine Bedingung zu verletzen, und <span class="math inline">Z = 2t</span> wächst mit. In der Praxis fehlt fast immer eine Kapazitätsgrenze.</p>
+<p><strong>5.6 — Gültigkeitsbereich.</strong> (a) Bei ca. 66,7 Stunden Prüfkapazität wird die <strong>Lackierzeit</strong> zum Engpass; der Schattenpreis der Prüfung fällt dann. (b) Zukaufen lohnt bis zu dem Punkt, an dem der Schattenpreis unter 18 €/h fällt. (c) Der Gewinnverlauf ist <strong>stückweise linear und konkav</strong>: Jedes Teilstück hat die Steigung des jeweils gültigen Schattenpreises, und die Steigungen werden immer flacher — jede zusätzliche Einheit bringt weniger, weil andere Engpässe nachrücken.</p>
+<p><strong>5.7 — Phase 1.</strong> Ansatz: Für jede Zeile mit <span class="math inline">b_i &lt; 0</span> (nach Umformung zu <span class="math inline">\ge</span>) eine künstliche Variable <span class="math inline">a_i \ge 0</span> einführen, Hilfszielfunktion <span class="math inline">\min \sum a_i</span> lösen. Ist das Minimum 0, existiert eine zulässige Basislösung, und man startet Phase 2 mit dem erreichten Tableau. Ist es <span class="math inline">&gt; 0</span>, ist das Problem unzulässig. Für das Beispiel: Optimum <span class="math inline">(12;\ 0)</span>, <span class="math inline">Z = 36</span>.</p>
+<h3 id="finde-den-denkfehler-die-380-000-euro-maschine">Finde den Denkfehler — Die 380 000-Euro-Maschine</h3>
 <ol type="a">
 <li><p><strong>Eine Ableitung gilt lokal.</strong> <span class="math inline">y_i = \partial Z^*/\partial b_i</span> beschreibt die Steigung der Zielfunktion <strong>am aktuellen Punkt</strong>. Sie sagt: „Die <em>nächste</em> Stunde ist 50 € wert“ — nicht: „jede der nächsten 2 000 Stunden ist 50 € wert“. Der Werksleiter behandelt eine Ableitung wie eine Konstante und multipliziert sie mit einer großen Zahl. Genau daran scheitert die Rechnung.</p></li>
 <li><p><strong>Der wahre Verlauf ist stückweise linear und knickt ab.</strong> Solange der Lackierofen der Engpass bleibt, gilt tatsächlich 50 €/h. Irgendwann ist aber genug Ofenzeit da — dann bindet eine <strong>andere</strong> Ressource, und weitere Ofenstunden bringen nichts mehr. Am Beispiel aus dem Kapitelanfang (Zusatzstunden <span class="math inline">h</span> am Lackierofen):</p></li>
@@ -420,14 +421,14 @@
 </ol>
 <hr />
 <h2 id="sec:loesungen-milp">A.6 Lösungen zu Kapitel „Gemischt-ganzzahlige Optimierung — Diskrete Entscheidungen und Branch-and-Bound“</h2>
-<p><strong>5.1 — Runden widerlegen.</strong> Beispiel: <span class="math inline">\max x_1 + x_2</span> u. d. N. <span class="math inline">10x_1 + 10x_2 \le 15</span>, ganzzahlig. LP-Optimum <span class="math inline">Z = 1{,}5</span>; Abrunden ergibt <span class="math inline">(0,0)</span> mit <span class="math inline">Z = 0</span> — <strong>100 % Verlust</strong>. Das ganzzahlige Optimum ist <span class="math inline">(1,0)</span> mit <span class="math inline">Z = 1</span>. Prinzip: kleine Zahlen plus knappe Kapazität.</p>
-<p><strong>5.2 — Big-M wählen.</strong> <span class="math inline">M = 250</span> (die bekannte Kapazität). Bei <span class="math inline">M = 10^6</span> bleibt das Modell korrekt, aber die LP-Relaxation wird extrem schwach: <span class="math inline">y_j</span> darf schon bei <span class="math inline">x_j/10^6</span> liegen, die Schranke ist praktisch wertlos, und Branch-and-Bound muss weit mehr Knoten durchsuchen.</p>
-<p><strong>5.3 — Regeln übersetzen.</strong> (a) <span class="math inline">y_A + y_B \le 1</span>. (b) <span class="math inline">\sum_{j=1}^4 y_j \ge 2</span>. (c) <span class="math inline">y_1 + y_2 - 1 \le y_{\text{Lager}}</span>. (d) <span class="math inline">500\,y \le x \le 2000\,y</span> mit <span class="math inline">y \in \{0,1\}</span>. (e) <span class="math inline">\sum_{j=1}^3 y_j = 1</span>.</p>
-<p><strong>5.4 — Branch-and-Bound.</strong> LP-Relaxation der Wurzel: nach Nutzen/Gewicht sortieren (<span class="math inline">8/5=1{,}6</span>; <span class="math inline">11/7=1{,}57</span>; <span class="math inline">6/4=1{,}5</span>; <span class="math inline">4/3=1{,}33</span>). Gierig füllen: <span class="math inline">x_1=1</span> (Rest 9), <span class="math inline">x_2=1</span> (Rest 2), <span class="math inline">x_3 = 0{,}5</span> → <span class="math inline">Z_{LP} = 8+11+3 = 22</span>. Verzweigen über <span class="math inline">x_3</span>. Ast <span class="math inline">x_3=0</span>: <span class="math inline">x_1=1,x_2=1,x_4=2/3</span> → <span class="math inline">Z = 21{,}67</span>; weiter verzweigen → beste ganzzahlige Lösung <span class="math inline">(1,1,0,0)</span> mit <span class="math inline">Z=19</span>. Ast <span class="math inline">x_3=1</span>: <span class="math inline">x_1=1</span>, <span class="math inline">x_3=1</span>, Rest 5 → <span class="math inline">x_2=5/7</span> → <span class="math inline">Z = 21{,}86</span>; verzweigen führt auf <span class="math inline">(1,0,1,1)</span> mit <span class="math inline">Z = 18</span> und <span class="math inline">(0,1,1,0)</span> mit <span class="math inline">Z=17</span>. <strong>Optimum: <span class="math inline">(1,1,0,0)</span>, <span class="math inline">Z = 19</span>.</strong></p>
-<p><strong>5.5 — Kardinalität variieren.</strong> (a) Ab <span class="math inline">K = 3</span> steigt der Ertrag nicht mehr wesentlich, weil bereits drei Positionen à 40 000 € das Budget von 100 000 € abdecken können. (b) Rechenzeit steigt zunächst (mehr Kombinationen), fällt bei großem <span class="math inline">K</span> wieder (Restriktion bindet nicht mehr). (c) Der faire Preis ist die Differenz der Netto-Erträge zwischen <span class="math inline">K=3</span> und <span class="math inline">K=4</span> — bei den gegebenen Daten nahe null, weil die Obergrenze von 40 000 € bereits bindet.</p>
-<p><strong>5.6 — Big-M-Effekt.</strong> Erwartetes Muster: Knotenzahl und Laufzeit steigen deutlich mit <span class="math inline">M</span>. Bei <span class="math inline">M = 10^9</span> ist die Relaxation so schwach, dass der Solver kaum noch prunen kann.</p>
-<p><strong>5.7 — Standortplanung.</strong> Modell wie in Projekt P4. Prüfen Sie: Gesamtkapazität der eröffneten Lager <span class="math inline">\ge</span> Gesamtbedarf (140); bei Kapazität 80 je Lager sind mindestens <span class="math inline">\lceil 140/80 \rceil = 2</span> Lager nötig.</p>
-<h3 id="finde-den-denkfehler-5.1-elf-lager-die-keine-fixkosten-kosten">Finde den Denkfehler 5.1 — Elf Lager, die keine Fixkosten kosten</h3>
+<p><strong>6.1 — Runden widerlegen.</strong> Beispiel: <span class="math inline">\max x_1 + x_2</span> u. d. N. <span class="math inline">10x_1 + 10x_2 \le 15</span>, ganzzahlig. LP-Optimum <span class="math inline">Z = 1{,}5</span>; Abrunden ergibt <span class="math inline">(0,0)</span> mit <span class="math inline">Z = 0</span> — <strong>100 % Verlust</strong>. Das ganzzahlige Optimum ist <span class="math inline">(1,0)</span> mit <span class="math inline">Z = 1</span>. Prinzip: kleine Zahlen plus knappe Kapazität.</p>
+<p><strong>6.2 — Big-M wählen.</strong> <span class="math inline">M = 250</span> (die bekannte Kapazität). Bei <span class="math inline">M = 10^6</span> bleibt das Modell korrekt, aber die LP-Relaxation wird extrem schwach: <span class="math inline">y_j</span> darf schon bei <span class="math inline">x_j/10^6</span> liegen, die Schranke ist praktisch wertlos, und Branch-and-Bound muss weit mehr Knoten durchsuchen.</p>
+<p><strong>6.3 — Regeln übersetzen.</strong> (a) <span class="math inline">y_A + y_B \le 1</span>. (b) <span class="math inline">\sum_{j=1}^4 y_j \ge 2</span>. (c) <span class="math inline">y_1 + y_2 - 1 \le y_{\text{Lager}}</span>. (d) <span class="math inline">500\,y \le x \le 2000\,y</span> mit <span class="math inline">y \in \{0,1\}</span>. (e) <span class="math inline">\sum_{j=1}^3 y_j = 1</span>.</p>
+<p><strong>6.4 — Branch-and-Bound.</strong> LP-Relaxation der Wurzel: nach Nutzen/Gewicht sortieren (<span class="math inline">8/5=1{,}6</span>; <span class="math inline">11/7=1{,}57</span>; <span class="math inline">6/4=1{,}5</span>; <span class="math inline">4/3=1{,}33</span>). Gierig füllen: <span class="math inline">x_1=1</span> (Rest 9), <span class="math inline">x_2=1</span> (Rest 2), <span class="math inline">x_3 = 0{,}5</span> → <span class="math inline">Z_{LP} = 8+11+3 = 22</span>. Verzweigen über <span class="math inline">x_3</span>. Ast <span class="math inline">x_3=0</span>: <span class="math inline">x_1=1,x_2=1,x_4=2/3</span> → <span class="math inline">Z = 21{,}67</span>; weiter verzweigen → beste ganzzahlige Lösung <span class="math inline">(1,1,0,0)</span> mit <span class="math inline">Z=19</span>. Ast <span class="math inline">x_3=1</span>: <span class="math inline">x_1=1</span>, <span class="math inline">x_3=1</span>, Rest 5 → <span class="math inline">x_2=5/7</span> → <span class="math inline">Z = 21{,}86</span>; verzweigen führt auf <span class="math inline">(1,0,1,1)</span> mit <span class="math inline">Z = 18</span> und <span class="math inline">(0,1,1,0)</span> mit <span class="math inline">Z=17</span>. <strong>Optimum: <span class="math inline">(1,1,0,0)</span>, <span class="math inline">Z = 19</span>.</strong></p>
+<p><strong>6.5 — Kardinalität variieren.</strong> (a) Ab <span class="math inline">K = 3</span> steigt der Ertrag nicht mehr wesentlich, weil bereits drei Positionen à 40 000 € das Budget von 100 000 € abdecken können. (b) Rechenzeit steigt zunächst (mehr Kombinationen), fällt bei großem <span class="math inline">K</span> wieder (Restriktion bindet nicht mehr). (c) Der faire Preis ist die Differenz der Netto-Erträge zwischen <span class="math inline">K=3</span> und <span class="math inline">K=4</span> — bei den gegebenen Daten nahe null, weil die Obergrenze von 40 000 € bereits bindet.</p>
+<p><strong>6.6 — Big-M-Effekt.</strong> Erwartetes Muster: Knotenzahl und Laufzeit steigen deutlich mit <span class="math inline">M</span>. Bei <span class="math inline">M = 10^9</span> ist die Relaxation so schwach, dass der Solver kaum noch prunen kann.</p>
+<p><strong>6.7 — Standortplanung.</strong> Modell wie in Projekt P4. Prüfen Sie: Gesamtkapazität der eröffneten Lager <span class="math inline">\ge</span> Gesamtbedarf (140); bei Kapazität 80 je Lager sind mindestens <span class="math inline">\lceil 140/80 \rceil = 2</span> Lager nötig.</p>
+<h3 id="finde-den-denkfehler-elf-lager-die-keine-fixkosten-kosten">Finde den Denkfehler — Elf Lager, die keine Fixkosten kosten</h3>
 <ol type="a">
 <li><p><strong>Warum die Zahl kleiner ist.</strong> Ein größeres <span class="math inline">M</span> <strong>lockert</strong> die Nebenbedingung <span class="math inline">\sum_j x_{ij} \le M y_i</span>. Der zulässige Bereich des Modells wird also größer, und in einem größeren Bereich kann das Minimum nur kleiner oder gleich bleiben. Bei einem <em>korrekt</em> formulierten Modell dürfte das aber gar nicht auffallen: Solange <span class="math inline">y_i</span> wirklich binär ist, ist <span class="math inline">M \cdot 1 = M</span> ohnehin größer als jede mögliche Liefermenge — die Lockerung wäre wirkungslos. Dass sich der Zielwert überhaupt ändert, ist deshalb schon der Beweis, dass <span class="math inline">y_i</span> <strong>nicht</strong> wirklich binär ist.</p></li>
 <li><p><strong>Die Binärvariablen.</strong> Sie stehen bei rund <span class="math inline">4 \cdot 10^{-8}</span> — nicht bei 0 und nicht bei 1. Die Ganzzahltoleranz von HiGHS (wie der meisten Solver) beträgt <span class="math inline">10^{-6}</span>. Alles, was näher als das an einer ganzen Zahl liegt, gilt als ganzzahlig. <span class="math inline">4 \cdot 10^{-8}</span> ist damit für den Solver eine saubere <strong>0</strong>: „Lager geschlossen“.</p></li>
@@ -469,11 +470,11 @@
 </ol>
 <hr />
 <h2 id="sec:loesungen-cpsat">A.7 Lösungen zu Kapitel „Constraint Programming mit CP-SAT — Logik, Scheduling und Zuweisung“</h2>
-<p><strong>6.1 — Propagation.</strong> Aus <span class="math inline">x_1 + x_2 = 8</span> und <span class="math inline">x_1 &lt; x_2</span> folgt <span class="math inline">x_1 &lt; 4</span>, also <span class="math inline">x_1 \in \{2,3\}</span> (denn <span class="math inline">x_2 = 8-x_1 \le 6</span> verlangt <span class="math inline">x_1 \ge 2</span>) und entsprechend <span class="math inline">x_2 \in \{5,6\}</span>. Aus 36 Kombinationen werden 2 zulässige.</p>
-<p><strong>6.2 — Hart oder weich.</strong> (a) hart. (b) weich, mittlere Strafe (~50). (c) hart. (d) weich, mittlere Strafe (~80, weil geteilte Dienste stark belasten). (e) hart, falls gesetzlich; sonst weich mit sehr hoher Strafe (~1000).</p>
-<p><strong>6.3 — Regeln ergänzen.</strong> (a) <code>for s in (2,3): modell.Add(x["Frau_Albrecht", s] == 0)</code> (b) Hilfsvariablen <code>arbeitet_bauer</code>, <code>arbeitet_koch</code> per <code>AddMaxEquality</code> an die Zuweisungssummen koppeln, dann <code>modell.Add(arbeitet_bauer + arbeitet_koch &lt;= 1)</code>. (c) Belohnung = negative Strafe: <code>strafterme.append(-30 * folge_var)</code>, wobei <code>folge_var</code> per <code>AddBoolAnd</code>/<code>OnlyEnforceIf</code> an <span class="math inline">x_{p,0} \wedge x_{p,1}</span> gekoppelt wird.</p>
-<p><strong>6.4 — Infeasibility.</strong> Mit <code>MAX_VERTRETUNGEN = 0</code> meldet der Solver <code>INFEASIBLE</code>. Nach Einbau der Schlupfvariablen lässt der Solver <strong>alle vier</strong> Stunden ausfallen (4 × 10 000 = 40 000 Strafpunkte) — es geht nicht anders. Interessanter wird es bei <code>MAX_VERTRETUNGEN = 1</code>: Dann fällt genau die Stunde aus, für die am wenigsten qualifiziertes Personal zur Verfügung steht.</p>
-<p><strong>6.5 — Sudoku.</strong></p>
+<p><strong>7.1 — Propagation.</strong> Aus <span class="math inline">x_1 + x_2 = 8</span> und <span class="math inline">x_1 &lt; x_2</span> folgt <span class="math inline">x_1 &lt; 4</span>, also <span class="math inline">x_1 \in \{2,3\}</span> (denn <span class="math inline">x_2 = 8-x_1 \le 6</span> verlangt <span class="math inline">x_1 \ge 2</span>) und entsprechend <span class="math inline">x_2 \in \{5,6\}</span>. Aus 36 Kombinationen werden 2 zulässige.</p>
+<p><strong>7.2 — Hart oder weich.</strong> (a) hart. (b) weich, mittlere Strafe (~50). (c) hart. (d) weich, mittlere Strafe (~80, weil geteilte Dienste stark belasten). (e) hart, falls gesetzlich; sonst weich mit sehr hoher Strafe (~1000).</p>
+<p><strong>7.3 — Regeln ergänzen.</strong> (a) <code>for s in (2,3): modell.Add(x["Frau_Albrecht", s] == 0)</code> (b) Hilfsvariablen <code>arbeitet_bauer</code>, <code>arbeitet_koch</code> per <code>AddMaxEquality</code> an die Zuweisungssummen koppeln, dann <code>modell.Add(arbeitet_bauer + arbeitet_koch &lt;= 1)</code>. (c) Belohnung = negative Strafe: <code>strafterme.append(-30 * folge_var)</code>, wobei <code>folge_var</code> per <code>AddBoolAnd</code>/<code>OnlyEnforceIf</code> an <span class="math inline">x_{p,0} \wedge x_{p,1}</span> gekoppelt wird.</p>
+<p><strong>7.4 — Infeasibility.</strong> Mit <code>MAX_VERTRETUNGEN = 0</code> meldet der Solver <code>INFEASIBLE</code>. Nach Einbau der Schlupfvariablen lässt der Solver <strong>alle vier</strong> Stunden ausfallen (4 × 10 000 = 40 000 Strafpunkte) — es geht nicht anders. Interessanter wird es bei <code>MAX_VERTRETUNGEN = 1</code>: Dann fällt genau die Stunde aus, für die am wenigsten qualifiziertes Personal zur Verfügung steht.</p>
+<p><strong>7.5 — Sudoku.</strong></p>
 <div class="sourceCode" id="cb10"><pre class="sourceCode python"><code class="sourceCode python"><span id="cb10-1"><a href="#cb10-1" aria-hidden="true" tabindex="-1"></a>x <span class="op">=</span> [[m.NewIntVar(<span class="dv">1</span>, <span class="dv">9</span>, <span class="ss">f&quot;x</span><span class="sc">{</span>i<span class="sc">}{</span>j<span class="sc">}</span><span class="ss">&quot;</span>) <span class="cf">for</span> j <span class="kw">in</span> <span class="bu">range</span>(<span class="dv">9</span>)] <span class="cf">for</span> i <span class="kw">in</span> <span class="bu">range</span>(<span class="dv">9</span>)]</span>
 <span id="cb10-2"><a href="#cb10-2" aria-hidden="true" tabindex="-1"></a><span class="cf">for</span> i <span class="kw">in</span> <span class="bu">range</span>(<span class="dv">9</span>): m.AddAllDifferent(x[i])                       <span class="co"># Zeilen</span></span>
 <span id="cb10-3"><a href="#cb10-3" aria-hidden="true" tabindex="-1"></a><span class="cf">for</span> j <span class="kw">in</span> <span class="bu">range</span>(<span class="dv">9</span>): m.AddAllDifferent([x[i][j] <span class="cf">for</span> i <span class="kw">in</span> <span class="bu">range</span>(<span class="dv">9</span>)]) <span class="co"># Spalten</span></span>
@@ -484,9 +485,32 @@
 <span id="cb10-8"><a href="#cb10-8" aria-hidden="true" tabindex="-1"></a>    <span class="cf">for</span> j <span class="kw">in</span> <span class="bu">range</span>(<span class="dv">9</span>):</span>
 <span id="cb10-9"><a href="#cb10-9" aria-hidden="true" tabindex="-1"></a>        <span class="cf">if</span> vorgabe[i][j]: m.Add(x[i][j] <span class="op">==</span> vorgabe[i][j])</span></code></pre></div>
 <p><strong>Etwa 10 Zeilen Modellcode</strong> — und der Solver löst jedes Sudoku in Millisekunden. Das ist die Stärke globaler Constraints.</p>
-<p><strong>6.6 — Job-Shop erweitern.</strong> (a) Rüstzeiten: <code>AddNoOverlap</code> durch paarweise Disjunktionen mit Übergangszeit ersetzen, oder <code>AddCircuit</code> je Maschine mit Übergangsmatrix. (b) Verspätung: <code>tardiness = MaxEquality(0, ende - faellig)</code>, in die Zielfunktion. (c) <code>AddCumulative(intervalle, [1]*n, 2)</code> statt <code>AddNoOverlap</code> für die Doppelmaschine.</p>
-<p><strong>6.7 — Wochendienstplan.</strong> Siehe Projekt P2. Kernpunkte: Nachtschicht-Folgeregel über <code>AddImplication</code>; „höchstens 5 Tage in Folge“ über gleitende Fenster (<code>sum(x[p,t..t+5]) &lt;= 5</code>).</p>
-<h3 id="finde-den-denkfehler-6.1-die-betriebsvereinbarung-die-niemanden-interessiert">Finde den Denkfehler 6.1 — Die Betriebsvereinbarung, die niemanden interessiert</h3>
+<p><strong>7.6 — Die Grenze der Parallelität finden.</strong> (a) Der Gewinn flacht ab und kehrt sich um. Auf einem Rechner mit 24 Kernen gemessen (Faktor gegenüber einem Arbeiter): 8 Arbeiter <strong>10,2</strong>, 16 Arbeiter <strong>12,3</strong>, 24 Arbeiter <strong>9,0</strong>. Wer alle Kerne belegt, ist langsamer als mit zwei Dritteln — dem Betriebssystem, dem Speicherbus und den Suchsträngen untereinander bleibt zu wenig Luft. Die Faustregel „so viele Arbeiter wie Kerne” ist also falsch; die richtige Zahl ist eine Messung, keine Einstellung. (b) <strong>Fünf verschiedene Pläne aus fünf Seeds</strong> — bei <code>num_workers = 1</code> und identischem Zielwert 183. Das ist die andere Hälfte der Antwort: Der Seed <em>wirkt</em>, aber nur auf den einzelnen Suchstrang. Es sichert also <strong>keiner der beiden Parameter allein</strong> die Reproduzierbarkeit:</p>
+<table>
+<thead>
+<tr class="header">
+<th></th>
+<th>Seed fest</th>
+<th>Seed variabel</th>
+</tr>
+</thead>
+<tbody>
+<tr class="odd">
+<td><strong>1 Arbeiter</strong></td>
+<td>reproduzierbar</td>
+<td>5 Pläne aus 5 Läufen</td>
+</tr>
+<tr class="even">
+<td><strong>mehrere Arbeiter</strong></td>
+<td>3 Pläne aus 4 Läufen</td>
+<td>erst recht nicht</td>
+</tr>
+</tbody>
+</table>
+<p>Nur die Kombination trägt. (c) Bei <strong>15 Aufträgen</strong> (60 s Zeitlimit): Ein Arbeiter läuft ins Limit und meldet <code>FEASIBLE</code> mit Makespan 200; acht Arbeiter melden <code>OPTIMAL</code> mit <strong>demselben</strong> Makespan 200 nach 26,4 s. Bei 13 Aufträgen sind es 11,2 s gegen 2,8 s, bei 14 schon 21,4 s gegen 3,7 s. Bemerkenswert ist, dass beide denselben Wert finden — der Unterschied liegt nicht in der Lösung, sondern im <strong>Beweis</strong>, dass es keine bessere gibt. Genau diese Arbeit teilen sich die parallelen Stränge auf.</p>
+<p><strong>7.7 — Job-Shop erweitern.</strong> (a) Rüstzeiten: <code>AddNoOverlap</code> durch paarweise Disjunktionen mit Übergangszeit ersetzen, oder <code>AddCircuit</code> je Maschine mit Übergangsmatrix. (b) Verspätung: <code>tardiness = MaxEquality(0, ende - faellig)</code>, in die Zielfunktion. (c) <code>AddCumulative(intervalle, [1]*n, 2)</code> statt <code>AddNoOverlap</code> für die Doppelmaschine.</p>
+<p><strong>7.8 — Wochendienstplan.</strong> Siehe Projekt P2. Kernpunkte: Nachtschicht-Folgeregel über <code>AddImplication</code>; „höchstens 5 Tage in Folge“ über gleitende Fenster (<code>sum(x[p,t..t+5]) &lt;= 5</code>).</p>
+<h3 id="finde-den-denkfehler-die-betriebsvereinbarung-die-niemanden-interessiert">Finde den Denkfehler — Die Betriebsvereinbarung, die niemanden interessiert</h3>
 <ol type="a">
 <li><p><strong>Warum die Regel verletzt wird.</strong> Weil sie einen <strong>Preis</strong> hat. Eine weiche Nebenbedingung verbietet nichts — sie verteuert. Der Solver vergleicht in jedem Schritt, was ihn eine Verletzung kostet und was sie ihm einbringt. Bei einem Gewicht von 1 gegen 10 lohnt sich eine Drei-Tage-Serie, sobald sie auch nur ein Zehntel eines Wunsches rettet. Der Solver hat genau das getan, was im Modell steht — er hat nur nicht getan, was gemeint war.</p></li>
 <li><p><strong>Was <span class="math inline">(1, 10)</span> wörtlich bedeutet.</strong> Nicht „Wunschfrei ist wichtiger“, sondern:</p></li>
@@ -563,12 +587,14 @@
 <li>Eine Variable mit Start, Dauer und Ende; sie garantiert automatisch <code>start + dauer == ende</code>.</li>
 <li>Weil jede zusätzliche harte Bedingung das Risiko von <code>INFEASIBLE</code> erhöht — und eine Fehlermeldung dem Anwender nicht hilft.</li>
 <li>Weil Anwender die Frage „Warum ich?“ stellen. Ohne Antwort wird das System umgangen.</li>
+<li>Weil der Seed nur festlegt, wie ein <strong>einzelner</strong> Suchstrang würfelt — nicht, welcher von mehreren parallelen zuerst fertig wird. Das entscheidet die Ausführungsreihenfolge, also die Uhr. Abhilfe: zusätzlich <code>num_workers = 1</code>. Gemessen: schon zwei Arbeiter liefern bei identischem Seed drei verschiedene Pläne zum selben Zielwert.</li>
+<li>Weil CP-SAT nicht dieselbe Suche vervielfacht, sondern <strong>verschiedene Strategien</strong> nebeneinander laufen lässt (LP-gestützt, andere Verzweigungsregeln, lokale Suche), die einander ihre Schranken mitteilen. Ein zusätzlicher Arbeiter ist deshalb nicht ein weiterer Kern für dieselbe Arbeit, sondern ein anderes Verfahren — und wenn eines davon früh eine gute Schranke findet, profitieren alle.</li>
 </ol>
 <hr />
 <h2 id="sec:loesungen-graphen">A.8 Lösungen zu Kapitel „Graphen, Flüsse und Touren — Min-Cost-Flow, Matching und VRP“</h2>
-<p><strong>7.1 — Flusserhaltung.</strong> <span class="math inline">b_i = (15+3) - (12+8) = -2</span> → <strong>Senke</strong> (Nettobedarf 2).</p>
-<p><strong>7.2 — Unlösbarkeit.</strong> Die Summe aller Flusserhaltungsgleichungen ergibt <span class="math inline">\sum_i b_i = 0</span> (jede Kante taucht einmal mit <span class="math inline">+1</span> und einmal mit <span class="math inline">-1</span> auf). Ist die Summe ungleich null, widersprechen sich die Gleichungen. Bei Angebotsüberschuss führt man einen künstlichen <strong>Dummy-Senkenknoten</strong> mit dem Restbedarf und Kosten 0 ein.</p>
-<p><strong>7.3 — Transportproblem.</strong> (a) Angebot <span class="math inline">30+25+45 = 100</span>, Bedarf <span class="math inline">25+30+20+25 = 100</span> ✓ (b) Optimale Kosten: <strong>790</strong>. Transportplan:</p>
+<p><strong>8.1 — Flusserhaltung.</strong> <span class="math inline">b_i = (15+3) - (12+8) = -2</span> → <strong>Senke</strong> (Nettobedarf 2).</p>
+<p><strong>8.2 — Unlösbarkeit.</strong> Die Summe aller Flusserhaltungsgleichungen ergibt <span class="math inline">\sum_i b_i = 0</span> (jede Kante taucht einmal mit <span class="math inline">+1</span> und einmal mit <span class="math inline">-1</span> auf). Ist die Summe ungleich null, widersprechen sich die Gleichungen. Bei Angebotsüberschuss führt man einen künstlichen <strong>Dummy-Senkenknoten</strong> mit dem Restbedarf und Kosten 0 ein.</p>
+<p><strong>8.3 — Transportproblem.</strong> (a) Angebot <span class="math inline">30+25+45 = 100</span>, Bedarf <span class="math inline">25+30+20+25 = 100</span> ✓ (b) Optimale Kosten: <strong>790</strong>. Transportplan:</p>
 <table>
 <thead>
 <tr class="header">
@@ -616,11 +642,11 @@
 </tbody>
 </table>
 <p>Beachten Sie, dass Werk 3 seine günstigste Verbindung (L4 zu 5) voll ausschöpft und W2 ausschließlich L1 beliefert (9), obwohl L4 mit 7 billiger wäre — dort ist der Bedarf bereits von W3 gedeckt. (c) Die Lösung ist ganzzahlig, obwohl nicht gefordert — die Transportmatrix ist <strong>total unimodular</strong>, alle Ecken sind ganzzahlig.</p>
-<p><strong>7.4 — Zuordnung mit Verboten.</strong> Kosten auf einen sehr hohen Wert setzen (<code>kosten[2][2] = 1e6</code>) oder mit <code>np.inf</code> arbeiten (bei <code>linear_sum_assignment</code> erlaubt). Die Lösung weicht auf die zweitbeste Zuordnung für Carla aus; die Gesamtkosten steigen um die Differenz.</p>
-<p><strong>7.5 — Engpass finden.</strong> Die Dualwerte der Kapazitätsschranken (<code>res.upper.marginals</code> bei <code>linprog</code>) zeigen es direkt; alternativ jede Kapazität einzeln um 1 erhöhen und neu rechnen. Im Beispiel ist die Kante <code>Werk_A → Umschlag</code> der Engpass (voll ausgelastet, günstigster Weg).</p>
-<p><strong>7.6 — VRP variieren.</strong> (a) Mit 3 Fahrzeugen werden die Touren länger, die Gesamtfahrzeit steigt leicht, die Auslastung deutlich. (b) Unlösbar, sobald <span class="math inline">\text{Kapazität} \times \text{Fahrzeuge} &lt; \text{Gesamtbedarf}</span> (hier: bei 3 Fahrzeugen à 10 sind 30 &lt; 37 → unlösbar) <strong>oder</strong> wenn Zeitfenster nicht mehr eingehalten werden können. (c) 1 s liefert meist eine brauchbare, 30 s eine spürbar bessere Lösung — die Metaheuristik verbessert kontinuierlich. (d) Doppelte Servicezeit kann Zeitfenster verletzen → möglicherweise unlösbar.</p>
-<p><strong>7.7 — TSP mit MTZ.</strong> Erwartetes Ergebnis: Bei 8 Städten löst das MILP in Sekunden. Ab etwa 12–15 Städten wird die schwache MTZ-Relaxation zum Problem, und die Laufzeit steigt stark — während OR-Tools weiterhin in Sekundenbruchteilen sehr gute Touren liefert.</p>
-<h3 id="finde-den-denkfehler-7.1-die-vergessene-dimension">Finde den Denkfehler 7.1 — Die vergessene Dimension</h3>
+<p><strong>8.4 — Zuordnung mit Verboten.</strong> Kosten auf einen sehr hohen Wert setzen (<code>kosten[2][2] = 1e6</code>) oder mit <code>np.inf</code> arbeiten (bei <code>linear_sum_assignment</code> erlaubt). Die Lösung weicht auf die zweitbeste Zuordnung für Carla aus; die Gesamtkosten steigen um die Differenz.</p>
+<p><strong>8.5 — Engpass finden.</strong> Die Dualwerte der Kapazitätsschranken (<code>res.upper.marginals</code> bei <code>linprog</code>) zeigen es direkt; alternativ jede Kapazität einzeln um 1 erhöhen und neu rechnen. Im Beispiel ist die Kante <code>Werk_A → Umschlag</code> der Engpass (voll ausgelastet, günstigster Weg).</p>
+<p><strong>8.6 — VRP variieren.</strong> (a) Mit 3 Fahrzeugen werden die Touren länger, die Gesamtfahrzeit steigt leicht, die Auslastung deutlich. (b) Unlösbar, sobald <span class="math inline">\text{Kapazität} \times \text{Fahrzeuge} &lt; \text{Gesamtbedarf}</span> (hier: bei 3 Fahrzeugen à 10 sind 30 &lt; 37 → unlösbar) <strong>oder</strong> wenn Zeitfenster nicht mehr eingehalten werden können. (c) 1 s liefert meist eine brauchbare, 30 s eine spürbar bessere Lösung — die Metaheuristik verbessert kontinuierlich. (d) Doppelte Servicezeit kann Zeitfenster verletzen → möglicherweise unlösbar.</p>
+<p><strong>8.7 — TSP mit MTZ.</strong> Erwartetes Ergebnis: Bei 8 Städten löst das MILP in Sekunden. Ab etwa 12–15 Städten wird die schwache MTZ-Relaxation zum Problem, und die Laufzeit steigt stark — während OR-Tools weiterhin in Sekundenbruchteilen sehr gute Touren liefert.</p>
+<h3 id="finde-den-denkfehler-die-vergessene-dimension">Finde den Denkfehler — Die vergessene Dimension</h3>
 <ol type="a">
 <li><strong>Was die Fahrzeuge tun.</strong> Fahrzeuge 1, 2 und 3 fahren <strong>gar nicht</strong> — sie stehen mit null Stopps im Depot. Fahrzeug 4 bedient alle 16 Kunden und lädt dabei <strong>37 Paletten</strong> bei einer Kapazität von 10. Es ist um 270 % überladen. Physikalisch ist dieser Plan nicht ausführbar; im Modell ist er die beste Lösung.</li>
 </ol>
@@ -643,11 +669,11 @@
 <div class="sourceCode" id="cb12"><pre class="sourceCode python"><code class="sourceCode python"><span id="cb12-1"><a href="#cb12-1" aria-hidden="true" tabindex="-1"></a><span class="co"># FALSCH als Pruefung:</span></span>
 <span id="cb12-2"><a href="#cb12-2" aria-hidden="true" tabindex="-1"></a>ladung <span class="op">=</span> loesung.Value(routing.GetDimensionOrDie(<span class="st">&quot;Ladung&quot;</span>).CumulVar(index))</span></code></pre></div>
 <p>Diese Zeile fragt das Modell, ob das Modell sich an sich selbst hält. Existiert die Dimension „Ladung“ gar nicht, stürzt sie ab — und existiert sie, kann sie per Konstruktion nie verletzt sein. Sie prüft also entweder nichts oder gar nichts.</p>
-<p><strong>Die allgemeine Regel:</strong> Eine Prüfung, die dieselben Bausteine verwendet wie das Modell, prüft das Modell gegen sich selbst. Nützlich ist nur eine Prüfung, die von der <strong>ausgegebenen Lösung</strong> ausgeht und die Anforderungen der Wirklichkeit unabhängig nachrechnet — genau wie die Kostengegenrechnung in <a href="#kapitel-5">Denkfehler 5.1</a> und die Verbrauchsprüfung in <a href="#kapitel-1">Denkfehler 1.1</a>.</p>
+<p><strong>Die allgemeine Regel:</strong> Eine Prüfung, die dieselben Bausteine verwendet wie das Modell, prüft das Modell gegen sich selbst. Nützlich ist nur eine Prüfung, die von der <strong>ausgegebenen Lösung</strong> ausgeht und die Anforderungen der Wirklichkeit unabhängig nachrechnet — genau wie die Kostengegenrechnung in <a href="milp.html#sec:milp-denkfehler">Abschnitt 6.10</a> und die Verbrauchsprüfung in <a href="einfuehrung.html#sec:einfuehrung-denkfehler">Abschnitt 1.10</a>.</p>
 <h3 id="quiz-loesung-graphen">Micro-Quiz</h3>
 <p><strong>1 — (b) totale Unimodularität.</strong> Jede quadratische Teilmatrix hat Determinante <span class="math inline">0</span>, <span class="math inline">+1</span> oder <span class="math inline">-1</span>; bei ganzzahliger rechter Seite sind deshalb alle Ecken des zulässigen Bereichs ganzzahlig. Da das LP-Optimum nach dem Fundamentalsatz in einer Ecke liegt, ist es automatisch 0/1-wertig. (a) unterschätzt das: Es ist kein Zufall, sondern eine Struktureigenschaft, die für <strong>jede</strong> Kostenmatrix gilt. (c) ist falsch — <code>linprog</code> rundet nichts.</p>
 <p><strong>2 — (b) die Struktur geht verloren.</strong> „Höchstens 4 von 12“ ist eine Kardinalitätsregel; ihre Zeile passt nicht in das Schema, das die totale Unimodularität sichert. Die Relaxation kann dann Brüche liefern (etwa vier Monteure zu je 0,75 Überstunden), und man braucht Binärvariablen und Branch-and-Bound. (a) ist die gefährliche Fehlannahme: Die Eigenschaft ist <strong>zerbrechlich</strong>, eine einzige zusätzliche Zeile genügt. (c) verwechselt „schwerer zu lösen“ mit „unlösbar“.</p>
-<p><strong>3 — (b) fehlende Dimension.</strong> Ohne begrenzende Dimension ist jede zusätzliche Tour reine Zusatzstrecke — ein Optimierer legt dann folgerichtig alles auf ein Fahrzeug. Genau dieses Bild zeigt Denkfehler 7.1. (a) wäre zu prüfen, wenn die Lösung <em>schlecht</em> aussähe, nicht wenn sie verdächtig gut ist. (c) ist zwar eine sinnvolle Datenprüfung, erklärt aber nicht, warum drei Fahrzeuge unbenutzt bleiben.</p>
+<p><strong>3 — (b) fehlende Dimension.</strong> Ohne begrenzende Dimension ist jede zusätzliche Tour reine Zusatzstrecke — ein Optimierer legt dann folgerichtig alles auf ein Fahrzeug. Genau dieses Bild zeigt <a href="graphen.html#sec:graphen-denkfehler">Abschnitt 8.7</a>. (a) wäre zu prüfen, wenn die Lösung <em>schlecht</em> aussähe, nicht wenn sie verdächtig gut ist. (c) ist zwar eine sinnvolle Datenprüfung, erklärt aber nicht, warum drei Fahrzeuge unbenutzt bleiben.</p>
 <h3 id="selbsttest-loesung-graphen">Selbsttest</h3>
 <ol type="1">
 <li>Abfluss minus Zufluss = Knotensaldo; entspricht der Kirchhoffschen Knotenregel.</li>
@@ -658,11 +684,11 @@
 </ol>
 <hr />
 <h2 id="sec:loesungen-metaheuristiken">A.9 Lösungen zu Kapitel „Metaheuristiken — wenn der exakte Solver aussteigt“</h2>
-<p><strong>Die Kurzsichtigkeit von Hand.</strong> Ab <em>Schwarz</em> wählt die Faustregel: Schwarz → Dunkelrot (26) → Rot (5) → … und muss dann in die helle Gruppe: Rot → Weiß (50) → Elfenbein (2) → Beige (2). Summe <strong>85 Minuten</strong> — also noch einen Deut schlechter als die 84 ab Weiß. Der Grund ist derselbe: Die Regel erwischt den Gruppenwechsel an der teuersten Stelle. Bemerkenswert ist aber, dass der <em>Startpunkt</em> kaum etwas ändert. Das ist typisch: Eine kurzsichtige Regel scheitert nicht am Anfang, sondern an der Reihenfolge, in der sie ihre Möglichkeiten verbraucht.</p>
-<p><strong>Zuggröße und Temperatur.</strong> Gesucht ist <span class="math inline">T</span> mit <span class="math inline">e^{-70/T} = e^{-1}</span>, also <strong><span class="math inline">T = 70</span></strong>. Die getesteten Temperaturen liegen zwischen 0,5 und 8 — allesamt <strong>eine Größenordnung darunter</strong>. Bei <span class="math inline">T_0 = 8</span> hat eine mediane Verschlechterung die Annahmewahrscheinlichkeit <span class="math inline">e^{-70/8} \approx 0{,}00016</span>. Genau das ist der Punkt der Warnung im Kapitel: Die verbreitete Regel „20 bis 50 % Annahmequote“ würde hier <span class="math inline">T_0 \approx 50</span> verlangen, und bei dieser Temperatur ist die Suche ein reiner Zufallslauf.</p>
-<p><strong>Die teure Bewertung.</strong> Statt <code>delta_verschieben</code> die Reihenfolge tatsächlich umbauen und <code>gesamtruestzeit()</code> neu rechnen. Bei <span class="math inline">n = 200</span> kostet das rund 200 Matrixzugriffe statt sechs. Erwartung: Die Zugzahl je Sekunde bricht um etwa zwei Größenordnungen ein. Bei gleichem <strong>Zeitbudget</strong> kommt die Suche entsprechend weniger weit; bei gleichem <strong>Zugbudget</strong> ist das Ergebnis identisch (die Bewertung ist ja korrekt, nur langsam). Genau diese Unterscheidung ist der Lehrpunkt: Die Implementierung ändert nicht das Verfahren, sondern nur, wie viel davon in das Zeitbudget passt.</p>
-<p><strong>Der Umschlagpunkt genauer.</strong> Sinnvolle Zwischengrößen sind 250, 300, 350 und 400. Zu erwarten ist ein <strong>verwaschener</strong> Übergang, kein scharfer Punkt: Der exakte Solver verschlechtert sich nicht sprunghaft, sondern sein Gap wächst, und irgendwann liegt seine beste gefundene Lösung über der heuristischen. Wo genau das passiert, hängt zusätzlich vom Zeitlimit ab — mit 300 Sekunden statt 30 verschiebt sich der Punkt nach oben. Die belastbare Aussage ist deshalb nie „ab <span class="math inline">n = 380</span>“, sondern immer „ab <span class="math inline">n \approx 380</span> <strong>bei diesem Zeitbudget</strong>“.</p>
-<p><strong>Zerstören nach Maß.</strong> Die kostenbasierte Zerstörung entfernt gezielt dort, wo etwas zu holen ist, und findet deshalb pro Runde mehr. Sie hat aber zwei Nachteile: Sie muss die Übergangskosten jedes Mal sortieren, und die entfernten Aufträge liegen über den ganzen Plan verstreut — das Teilproblem für CP-SAT ist damit schwieriger als ein zusammenhängendes Fenster gleicher Größe, weil auch alle Einfügestellen offen sind.</p>
+<p><strong>9.1 — Die Kurzsichtigkeit von Hand.</strong> Ab <em>Schwarz</em> wählt die Faustregel: Schwarz → Dunkelrot (26) → Rot (5) → … und muss dann in die helle Gruppe: Rot → Weiß (50) → Elfenbein (2) → Beige (2). Summe <strong>85 Minuten</strong> — also noch einen Deut schlechter als die 84 ab Weiß. Der Grund ist derselbe: Die Regel erwischt den Gruppenwechsel an der teuersten Stelle. Bemerkenswert ist aber, dass der <em>Startpunkt</em> kaum etwas ändert. Das ist typisch: Eine kurzsichtige Regel scheitert nicht am Anfang, sondern an der Reihenfolge, in der sie ihre Möglichkeiten verbraucht.</p>
+<p><strong>9.2 — Zuggröße und Temperatur.</strong> Gesucht ist <span class="math inline">T</span> mit <span class="math inline">e^{-70/T} = e^{-1}</span>, also <strong><span class="math inline">T = 70</span></strong>. Die getesteten Temperaturen liegen zwischen 0,5 und 8 — allesamt <strong>eine Größenordnung darunter</strong>. Bei <span class="math inline">T_0 = 8</span> hat eine mediane Verschlechterung die Annahmewahrscheinlichkeit <span class="math inline">e^{-70/8} \approx 0{,}00016</span>. Genau das ist der Punkt der Warnung im Kapitel: Die verbreitete Regel „20 bis 50 % Annahmequote“ würde hier <span class="math inline">T_0 \approx 50</span> verlangen, und bei dieser Temperatur ist die Suche ein reiner Zufallslauf.</p>
+<p><strong>9.3 — Die teure Bewertung.</strong> Statt <code>delta_verschieben</code> die Reihenfolge tatsächlich umbauen und <code>gesamtruestzeit()</code> neu rechnen. Bei <span class="math inline">n = 200</span> kostet das rund 200 Matrixzugriffe statt sechs. Erwartung: Die Zugzahl je Sekunde bricht um etwa zwei Größenordnungen ein. Bei gleichem <strong>Zeitbudget</strong> kommt die Suche entsprechend weniger weit; bei gleichem <strong>Zugbudget</strong> ist das Ergebnis identisch (die Bewertung ist ja korrekt, nur langsam). Genau diese Unterscheidung ist der Lehrpunkt: Die Implementierung ändert nicht das Verfahren, sondern nur, wie viel davon in das Zeitbudget passt.</p>
+<p><strong>9.4 — Der Umschlagpunkt genauer.</strong> Sinnvolle Zwischengrößen sind 250, 300, 350 und 400. Zu erwarten ist ein <strong>verwaschener</strong> Übergang, kein scharfer Punkt: Der exakte Solver verschlechtert sich nicht sprunghaft, sondern sein Gap wächst, und irgendwann liegt seine beste gefundene Lösung über der heuristischen. Wo genau das passiert, hängt zusätzlich vom Zeitlimit ab — mit 300 Sekunden statt 30 verschiebt sich der Punkt nach oben. Die belastbare Aussage ist deshalb nie „ab <span class="math inline">n = 380</span>“, sondern immer „ab <span class="math inline">n \approx 380</span> <strong>bei diesem Zeitbudget</strong>“.</p>
+<p><strong>9.5 — Zerstören nach Maß.</strong> Die kostenbasierte Zerstörung entfernt gezielt dort, wo etwas zu holen ist, und findet deshalb pro Runde mehr. Sie hat aber zwei Nachteile: Sie muss die Übergangskosten jedes Mal sortieren, und die entfernten Aufträge liegen über den ganzen Plan verstreut — das Teilproblem für CP-SAT ist damit schwieriger als ein zusammenhängendes Fenster gleicher Größe, weil auch alle Einfügestellen offen sind.</p>
 <p>Die Aufgabe ist bewusst so gestellt, dass die Antwort <strong>gemessen</strong> werden muss. Wer nur die Ergebniswerte vergleicht, kann Strategie und Rundenzahl nicht trennen. Die saubere Auswertung protokolliert beides: Verbesserungen <strong>je Runde</strong> (Güte der Strategie) und Runden <strong>je Sekunde</strong> (ihr Preis).</p>
 <h3 id="denkfehler-loesung-metaheuristiken">Finde den Denkfehler — „Unsere Heuristik ist 6 % besser“</h3>
 <p><strong>Es fehlt die Schranke.</strong></p>
@@ -686,20 +712,20 @@
 </ol>
 <hr />
 <h2 id="sec:loesungen-dekomposition">A.10 Lösungen zu Kapitel „Spaltengenerierung“</h2>
-<p><strong>Das Abbruchkriterium.</strong> Die Eins ist der Zielfunktionskoeffizient eines Musters: Jedes geschnittene Muster verbraucht <strong>genau eine</strong> Mutterrolle, und die Zielfunktion lautet <span class="math inline">\min \sum_p x_p</span>. Die reduzierten Kosten einer neuen Spalte sind <span class="math inline">c_p - \pi^\top a_p = 1 - \sum_i \pi_i a_{ip}</span>; sie sind negativ — die Spalte lohnt sich also —, wenn <span class="math inline">\sum_i \pi_i a_{ip} &gt; 1</span>.</p>
+<p><strong>10.1 — Das Abbruchkriterium.</strong> Die Eins ist der Zielfunktionskoeffizient eines Musters: Jedes geschnittene Muster verbraucht <strong>genau eine</strong> Mutterrolle, und die Zielfunktion lautet <span class="math inline">\min \sum_p x_p</span>. Die reduzierten Kosten einer neuen Spalte sind <span class="math inline">c_p - \pi^\top a_p = 1 - \sum_i \pi_i a_{ip}</span>; sie sind negativ — die Spalte lohnt sich also —, wenn <span class="math inline">\sum_i \pi_i a_{ip} &gt; 1</span>.</p>
 <p>Wäre die Zielfunktion eine andere — etwa „minimiere den Verschnitt in Millimetern” —, stünde dort statt der Eins der Verschnitt des Musters. Die Eins ist also kein Zauberwert, sondern schlicht die Kosten der Spalte.</p>
-<p><strong>Die Startbasis.</strong> Ein Muster, das nur eine einzige Breite enthält, ist immer zulässig: <span class="math inline">\lfloor W / b_i \rfloor</span> Stücke der Breite <span class="math inline">i</span> passen in jede Rolle. Mit diesen <span class="math inline">n</span> Mustern lässt sich <strong>jeder</strong> Bedarf decken — notfalls sehr verschwenderisch, aber zulässig.</p>
+<p><strong>10.2 — Die Startbasis.</strong> Ein Muster, das nur eine einzige Breite enthält, ist immer zulässig: <span class="math inline">\lfloor W / b_i \rfloor</span> Stücke der Breite <span class="math inline">i</span> passen in jede Rolle. Mit diesen <span class="math inline">n</span> Mustern lässt sich <strong>jeder</strong> Bedarf decken — notfalls sehr verschwenderisch, aber zulässig.</p>
 <p>Eine leere Startmenge wäre ein Problem, weil das Master-LP dann unzulässig ist: Es gibt keine Spalten, mit denen sich die Bedarfszeilen erfüllen ließen. Ohne zulässige Lösung gibt es keine Dualwerte, und ohne Dualwerte kann das Pricing nicht arbeiten. Die Schleife käme nie in Gang.</p>
 <p>(In der Literatur behilft man sich alternativ mit künstlichen Variablen und sehr hohen Strafkosten — dieselbe Idee wie die Big-M-Phase des Simplex aus <a href="lp.html#kap-lp">Kapitel 5</a>.)</p>
-<p><strong>Die Kennzahl prüfen.</strong> Zu erwarten ist ein deutlicher, monotoner Zusammenhang: Je mehr Stücke auf eine Rolle passen, desto kleiner die Ersparnis. Bei zwei Stücken je Rolle entscheidet jede Paarung, und die Faustregel verschenkt regelmäßig ganze Rollen; ab acht bis zehn Stücken ist sie praktisch immer optimal.</p>
+<p><strong>10.3 — Die Kennzahl prüfen.</strong> Zu erwarten ist ein deutlicher, monotoner Zusammenhang: Je mehr Stücke auf eine Rolle passen, desto kleiner die Ersparnis. Bei zwei Stücken je Rolle entscheidet jede Paarung, und die Faustregel verschenkt regelmäßig ganze Rollen; ab acht bis zehn Stücken ist sie praktisch immer optimal.</p>
 <p>Der Grund ist ein Verhältnis: Der Verschnitt einer Rolle ist höchstens so groß wie das kleinste nicht mehr passende Stück. Sind die Stücke klein gegen die Rolle, ist auch dieser Rest klein — und der Gesamtverschnitt nähert sich der theoretischen Untergrenze <span class="math inline">\lceil \sum_i b_i d_i / W \rceil</span>, die jede Methode erreichen muss.</p>
-<p><strong>Dienstplanung.</strong> Eine „Spalte” ist ein <strong>vollständiger zulässiger Wochenplan einer Person</strong>: an welchen Tagen sie welche Schicht übernimmt.</p>
+<p><strong>10.4 — Dienstplanung.</strong> Eine „Spalte” ist ein <strong>vollständiger zulässiger Wochenplan einer Person</strong>: an welchen Tagen sie welche Schicht übernimmt.</p>
 <ul>
 <li><strong>Ins Master gehört</strong>, was Personen miteinander koppelt: Jede Schicht muss besetzt sein (<span class="math inline">\sum_p a_{sp} x_p \ge</span> Bedarf je Schicht <span class="math inline">s</span>), und jede Person bekommt genau einen Plan.</li>
 <li><strong>Ins Teilproblem gehört</strong>, was innerhalb einer Person gilt: Höchstarbeitszeit, Ruhezeiten, Qualifikation, keine zwei Schichten am selben Tag, höchstens zwei Wochenenden im Monat.</li>
 </ul>
 <p>Das ist der eigentliche Gewinn der Zerlegung: Die komplizierten arbeitsrechtlichen Regeln stehen im Teilproblem und werden dort <strong>einmal je Person</strong> geprüft, statt das Master zu überfrachten. Das Teilproblem ist meist ein kürzester Weg über ein Zeit-Zustands-Netz (<a href="graphen.html#kap-graphen">Kapitel 8</a>) statt eines Rucksacks.</p>
-<p><strong>Branch-and-Price.</strong> Das Problem: Verzweigt man auf einer Mustervariablen (<span class="math inline">x_p \le 3</span> gegen <span class="math inline">x_p \ge 4</span>), so ist diese Bedingung im <strong>Pricing</strong> nicht darstellbar. Das Teilproblem erzeugt Muster, es kennt keine Verzweigungsentscheidungen über einzelne Spalten — es könnte im nächsten Schritt genau das ausgeschlossene Muster wieder erzeugen.</p>
+<p><strong>10.5 — Branch-and-Price.</strong> Das Problem: Verzweigt man auf einer Mustervariablen (<span class="math inline">x_p \le 3</span> gegen <span class="math inline">x_p \ge 4</span>), so ist diese Bedingung im <strong>Pricing</strong> nicht darstellbar. Das Teilproblem erzeugt Muster, es kennt keine Verzweigungsentscheidungen über einzelne Spalten — es könnte im nächsten Schritt genau das ausgeschlossene Muster wieder erzeugen.</p>
 <p>Branch-and-Price löst das, indem es auf <strong>Originalgrößen</strong> verzweigt statt auf Spalten: etwa „in wie vielen Rollen kommen Breite <span class="math inline">i</span> und Breite <span class="math inline">j</span> gemeinsam vor?” Solche Bedingungen lassen sich ins Pricing-Teilproblem einbauen, weil sie über die Struktur eines Musters sprechen und nicht über seine Identität.</p>
 <p>Für das Kapitel genügt der einfachere Weg: das ganzzahlige Master über die erzeugten Spalten. Es ist nicht garantiert optimal, liegt in der Praxis aber fast immer auf oder dicht bei der Schranke — hier exakt darauf (73 gegen 72,92).</p>
 <h3 id="denkfehler-loesung-dekomposition">Finde den Denkfehler — „Die LP-Lösung sagt 72,92 — also runden wir auf“</h3>
@@ -747,13 +773,13 @@
 </ol>
 <hr />
 <h2 id="sec:loesungen-qp-nlp">A.11 Lösungen zu Kapitel „Quadratische und nichtlineare Optimierung — KKT, Lagrange, Konvexität“</h2>
-<p><strong>8.1 — Konvexität einordnen.</strong> PSD (alle <span class="math inline">\ge 0</span>) → <strong>konvex</strong>, aber <strong>nicht streng</strong> konvex; die Lösung ist <strong>nicht notwendig eindeutig</strong>. Der Eigenwert 0 bedeutet eine <strong>flache Richtung</strong>: Entlang des zugehörigen Eigenvektors ändert sich der quadratische Term nicht — es gibt eine Rinne statt eines Punktes.</p>
-<p><strong>8.2 — Komplementärer Schlupf.</strong> Ja, verträglich: <span class="math inline">\lambda_i w_i = 0</span> gilt für alle <span class="math inline">i</span> (<span class="math inline">w_2 = 0</span> mit <span class="math inline">\lambda_2 &gt; 0</span>; die anderen mit <span class="math inline">\lambda = 0</span>). <span class="math inline">\lambda_2 = 0{,}03</span> bedeutet: Würde man Titel 2 zwingen, ein kleines positives Gewicht zu tragen, verschlechterte sich der Zielwert um 0,03 je Einheit — die Nichtnegativitätsschranke ist dort <strong>bindend</strong>.</p>
-<p><strong>8.3 — KKT von Hand.</strong> <span class="math inline">\mathcal{L} = x_1^2 + x_2^2 + \lambda(4 - x_1 - x_2)</span>. Stationarität: <span class="math inline">2x_1 = \lambda</span>, <span class="math inline">2x_2 = \lambda</span> → <span class="math inline">x_1 = x_2</span>. Bindend (<span class="math inline">\lambda &gt; 0</span>): <span class="math inline">x_1 + x_2 = 4</span> → <span class="math inline">x_1 = x_2 = 2</span>, <span class="math inline">\lambda = 4</span>. Prüfung: <span class="math inline">\lambda = 4 &gt; 0</span> ✓, <span class="math inline">f = 8</span>. <strong>Interpretation:</strong> Würde die Forderung auf <span class="math inline">\ge 4{,}1</span> steigen, stiege <span class="math inline">f</span> um etwa <span class="math inline">4 \cdot 0{,}1 = 0{,}4</span>. Probe: <span class="math inline">2\cdot(2{,}05)^2 = 8{,}405</span> ✓.</p>
-<p><strong>8.4 — Unmögliche Korrelationsmatrix.</strong> Eigenwerte <span class="math inline">\approx (-0{,}62;\ 1{,}0;\ 2{,}62)</span> → <strong>nicht PSD</strong>, also unmöglich. Anschaulich: Wenn A stark <strong>positiv</strong> mit B korreliert und B stark positiv mit C, kann A nicht gleichzeitig stark <strong>negativ</strong> mit C korrelieren — Korrelation ist eingeschränkt transitiv. Formal: <span class="math inline">\rho_{AC} \ge \rho_{AB}\rho_{BC} - \sqrt{(1-\rho_{AB}^2)(1-\rho_{BC}^2)} = 0{,}81 - 0{,}19 = 0{,}62</span>; verlangt waren <span class="math inline">-0{,}9</span>.</p>
-<p><strong>8.5 — Gewichtung untersuchen.</strong> Erwartetes Muster: Größeres <span class="math inline">\alpha</span> → mehr Rendite, mehr Konzentration im Titel mit höchstem <span class="math inline">\mu</span>. Größeres <span class="math inline">\beta</span> → gleichmäßigere Gewichte, Entropie steigt Richtung <span class="math inline">\ln 4 = 1{,}386</span>. Ab etwa <span class="math inline">\beta \approx 0{,}1</span> dominiert die Entropie und man nähert sich der Gleichgewichtung. <strong>Empfehlung an einen Ausschuss:</strong> Nicht mit <span class="math inline">\beta</span> argumentieren, sondern mit der resultierenden <strong>Maximalposition</strong> — „mit dieser Einstellung liegt keine Position über 40 %“ ist verständlich, „<span class="math inline">\beta = 0{,}015</span>“ nicht.</p>
-<p><strong>8.6 — Nicht-Konvexität demonstrieren.</strong> Mit der bewusst fehlerhaft konstruierten Matrix finden 20 Startpunkte typischerweise mehrere verschiedene Optima; die „Portfoliovarianz“ <span class="math inline">w^\top\Sigma w</span> kann bei geeigneten Gewichten negativ werden (der zugehörige Eigenvektor liegt allerdings teilweise außerhalb des zulässigen Bereichs <span class="math inline">w \ge 0{,}001</span>, <span class="math inline">\sum w = 1</span> — deshalb fällt der Fehler bei naiver Prüfung nicht auf).</p>
-<h3 id="finde-den-denkfehler-8.1-die-kovarianzmatrix-aus-dem-controlling">Finde den Denkfehler 8.1 — Die Kovarianzmatrix aus dem Controlling</h3>
+<p><strong>11.1 — Konvexität einordnen.</strong> PSD (alle <span class="math inline">\ge 0</span>) → <strong>konvex</strong>, aber <strong>nicht streng</strong> konvex; die Lösung ist <strong>nicht notwendig eindeutig</strong>. Der Eigenwert 0 bedeutet eine <strong>flache Richtung</strong>: Entlang des zugehörigen Eigenvektors ändert sich der quadratische Term nicht — es gibt eine Rinne statt eines Punktes.</p>
+<p><strong>11.2 — Komplementärer Schlupf.</strong> Ja, verträglich: <span class="math inline">\lambda_i w_i = 0</span> gilt für alle <span class="math inline">i</span> (<span class="math inline">w_2 = 0</span> mit <span class="math inline">\lambda_2 &gt; 0</span>; die anderen mit <span class="math inline">\lambda = 0</span>). <span class="math inline">\lambda_2 = 0{,}03</span> bedeutet: Würde man Titel 2 zwingen, ein kleines positives Gewicht zu tragen, verschlechterte sich der Zielwert um 0,03 je Einheit — die Nichtnegativitätsschranke ist dort <strong>bindend</strong>.</p>
+<p><strong>11.3 — KKT von Hand.</strong> <span class="math inline">\mathcal{L} = x_1^2 + x_2^2 + \lambda(4 - x_1 - x_2)</span>. Stationarität: <span class="math inline">2x_1 = \lambda</span>, <span class="math inline">2x_2 = \lambda</span> → <span class="math inline">x_1 = x_2</span>. Bindend (<span class="math inline">\lambda &gt; 0</span>): <span class="math inline">x_1 + x_2 = 4</span> → <span class="math inline">x_1 = x_2 = 2</span>, <span class="math inline">\lambda = 4</span>. Prüfung: <span class="math inline">\lambda = 4 &gt; 0</span> ✓, <span class="math inline">f = 8</span>. <strong>Interpretation:</strong> Würde die Forderung auf <span class="math inline">\ge 4{,}1</span> steigen, stiege <span class="math inline">f</span> um etwa <span class="math inline">4 \cdot 0{,}1 = 0{,}4</span>. Probe: <span class="math inline">2\cdot(2{,}05)^2 = 8{,}405</span> ✓.</p>
+<p><strong>11.4 — Unmögliche Korrelationsmatrix.</strong> Eigenwerte <span class="math inline">\approx (-0{,}62;\ 1{,}0;\ 2{,}62)</span> → <strong>nicht PSD</strong>, also unmöglich. Anschaulich: Wenn A stark <strong>positiv</strong> mit B korreliert und B stark positiv mit C, kann A nicht gleichzeitig stark <strong>negativ</strong> mit C korrelieren — Korrelation ist eingeschränkt transitiv. Formal: <span class="math inline">\rho_{AC} \ge \rho_{AB}\rho_{BC} - \sqrt{(1-\rho_{AB}^2)(1-\rho_{BC}^2)} = 0{,}81 - 0{,}19 = 0{,}62</span>; verlangt waren <span class="math inline">-0{,}9</span>.</p>
+<p><strong>11.5 — Gewichtung untersuchen.</strong> Erwartetes Muster: Größeres <span class="math inline">\alpha</span> → mehr Rendite, mehr Konzentration im Titel mit höchstem <span class="math inline">\mu</span>. Größeres <span class="math inline">\beta</span> → gleichmäßigere Gewichte, Entropie steigt Richtung <span class="math inline">\ln 4 = 1{,}386</span>. Ab etwa <span class="math inline">\beta \approx 0{,}1</span> dominiert die Entropie und man nähert sich der Gleichgewichtung. <strong>Empfehlung an einen Ausschuss:</strong> Nicht mit <span class="math inline">\beta</span> argumentieren, sondern mit der resultierenden <strong>Maximalposition</strong> — „mit dieser Einstellung liegt keine Position über 40 %“ ist verständlich, „<span class="math inline">\beta = 0{,}015</span>“ nicht.</p>
+<p><strong>11.6 — Nicht-Konvexität demonstrieren.</strong> Mit der bewusst fehlerhaft konstruierten Matrix finden 20 Startpunkte typischerweise mehrere verschiedene Optima; die „Portfoliovarianz“ <span class="math inline">w^\top\Sigma w</span> kann bei geeigneten Gewichten negativ werden (der zugehörige Eigenvektor liegt allerdings teilweise außerhalb des zulässigen Bereichs <span class="math inline">w \ge 0{,}001</span>, <span class="math inline">\sum w = 1</span> — deshalb fällt der Fehler bei naiver Prüfung nicht auf).</p>
+<h3 id="finde-den-denkfehler-die-kovarianzmatrix-aus-dem-controlling">Finde den Denkfehler — Die Kovarianzmatrix aus dem Controlling</h3>
 <ol type="a">
 <li><strong>Ohne zu rechnen.</strong> Stellen Sie sich die drei Anlagen als drei Personen vor, die nebeneinander gehen. A und B gehen fast im Gleichschritt (<span class="math inline">0{,}9</span>). B und C gehen fast im Gleichschritt (<span class="math inline">0{,}9</span>). Können A und C dann in <em>entgegengesetzte</em> Richtungen laufen? Nein — wenn A B folgt und B C folgt, muss A ungefähr auch C folgen. Korrelation ist zwar nicht transitiv im strengen Sinne, aber sie ist <strong>eingeschränkt</strong>: Zwei starke Bindungen zwingen die dritte in einen engen Bereich.</li>
 </ol>
@@ -787,7 +813,7 @@
 <p><strong>Der Merksatz dazu:</strong> Eine Kovarianzmatrix ist kein Behälter für einzeln geschätzte Zahlen, sondern ein geometrisches Objekt. Nicht jede Kombination von Korrelationen existiert.</p>
 </blockquote>
 <h3 id="quiz-loesung-qp-nlp">Micro-Quiz</h3>
-<p><strong>1 — (b).</strong> Der <code>DCPError</code> ist eine inhaltliche Aussage: Für diese Formulierung kann es keine Optimalitätsgarantie geben. Auf <code>scipy</code> auszuweichen (a) beseitigt die Meldung, nicht die Ursache — man bekommt dann ein lokales Ergebnis ohne Garantie und ohne Warnung, wie Denkfehler 8.1 zeigt. Toleranzen (c) haben mit Konvexität nichts zu tun. Richtig ist, zwischen zwei bewussten Wegen zu wählen: konvex umformulieren, oder lokal rechnen <strong>und</strong> das im Bericht kenntlich machen.</p>
+<p><strong>1 — (b).</strong> Der <code>DCPError</code> ist eine inhaltliche Aussage: Für diese Formulierung kann es keine Optimalitätsgarantie geben. Auf <code>scipy</code> auszuweichen (a) beseitigt die Meldung, nicht die Ursache — man bekommt dann ein lokales Ergebnis ohne Garantie und ohne Warnung, wie <a href="qp-nlp.html#sec:qp-nlp-denkfehler">Abschnitt 11.8</a> zeigt. Toleranzen (c) haben mit Konvexität nichts zu tun. Richtig ist, zwischen zwei bewussten Wegen zu wählen: konvex umformulieren, oder lokal rechnen <strong>und</strong> das im Bericht kenntlich machen.</p>
 <p><strong>2 — (b) ein lokales Minimum.</strong> <code>success: True</code> beschreibt die Konvergenz des Verfahrens, nicht die Qualität des Ergebnisses. Bei Mengenrabatten ist die Zielfunktion nicht konvex, also kann es mehrere lokale Minima geben — im Kapitelbeispiel fünf, mit 8 % Spanne. (a) wäre nur bei einem konvexen Problem richtig. (c) ist zu pessimistisch: Ein lokales Minimum ist es sehr wohl, die Zulässigkeit wird von SLSQP eingehalten.</p>
 <p><strong>3 — (c) Schattenpreis.</strong> <span class="math inline">\lambda^*</span> ist die Ableitung des optimalen Zielwerts nach der rechten Seite der Nebenbedingung — dieselbe Bedeutung wie der Dualwert im LP (<a href="lp.html#kap-lp">Kapitel 5</a>), nur für allgemeine, auch krumme Nebenbedingungen. (a) und (b) verwechseln den Multiplikator mit einer Verletzungszahl beziehungsweise mit dem Schlupf; der Schlupf ist bei einer bindenden Bedingung gerade <strong>null</strong> (komplementärer Schlupf).</p>
 <h3 id="selbsttest-loesung-qp-nlp">Selbsttest</h3>
@@ -800,17 +826,17 @@
 </ol>
 <hr />
 <h2 id="sec:loesungen-unsicherheit">A.12 Lösungen zu Kapitel „Optimierung unter Unsicherheit — Monte-Carlo, Stochastik, Robustheit“</h2>
-<p><strong>9.1 — Fluch des Durchschnitts.</strong> Weil sich Verzögerungen <strong>fortpflanzen</strong> und die Verteilung rechtsschief ist: Ein Gewerk, das früher fertig wird, beschleunigt selten den Gesamtablauf (der nächste Schritt ist noch nicht bereit), ein verspätetes verzögert alles. Weitere Beispiele: Wartezeiten in Warteschlangen (nichtlinear in der Auslastung), Projektkosten mit Nachträgen.</p>
-<p><strong>9.2 — Ansatz wählen.</strong> (a) robust (Ausfall ist existenziell, Wahrscheinlichkeiten unzuverlässig). (b) stochastisch (Verteilung bekannt). (c) robust bzw. Extremwertstatistik (seltene Ereignisse, katastrophale Folgen). (d) stochastisch (Szenarien mit Wahrscheinlichkeiten liegen vor). (e) Chance Constraint — die Zusage ist bereits als Quote formuliert („an 99 % aller Wintertage“). Robust wäre hier zu teuer (es gibt immer einen kälteren Tag), der Erwartungswert zu schwach (er sagt nichts über die Zusage).</p>
-<p><strong>9.3 — Zweistufig rechnen.</strong> (a) Mit Spot = 60: Ableitung bei <span class="math inline">x \in (100,250)</span>: <span class="math inline">40 - 60\cdot0{,}5 + 5\cdot0{,}5 = 40-30+2{,}5 = +12{,}5 &gt; 0</span> → Kapazität <strong>senken</strong>. Bei <span class="math inline">x &lt; 100</span>: <span class="math inline">40 - 60 = -20 &lt; 0</span> → erhöhen. Optimum daher <span class="math inline">x^* = 100</span>. (b) Billige Nachbesserung macht Vorhalten unattraktiv. (c) Bei <span class="math inline">x = 225</span> optimal müsste die Ableitung dort das Vorzeichen wechseln — das ist bei diskreten Szenarien nur zufällig der Fall; der Mittelwert ist nur bei symmetrischen Kosten und stetiger Verteilung optimal.</p>
-<p><strong>9.4 — EVPI interpretieren.</strong> Selbst eine <strong>perfekte</strong> Prognose wäre nur 8 400 € pro Jahr wert. Eine Lösung für 15 000 € kann sich also <strong>niemals</strong> rechnen — unabhängig von ihrer Güte. Argument: „Der theoretische Maximalnutzen liegt unter dem Preis.“</p>
-<p><strong>9.5 — Monte-Carlo erweitern.</strong> (a) Servicelevel 95 %: Kapazität = 95 %-Quantil des Bedarfs (ca. 485). Die Zusatzkosten gegenüber dem Kostenoptimum (180) betragen ein Vielfaches — Servicelevel ist teuer, und genau diese Zahl braucht die Geschäftsleitung für die Entscheidung. (b) <code>cvar = kosten[kosten &gt;= np.quantile(kosten, 0.95)].mean()</code>. (c) Erwartetes Bild: Bei kleiner Kapazität ist die Kostenverteilung stark rechtsschief (seltene, teure Notzukäufe); bei großer Kapazität schmal und nach rechts verschoben.</p>
-<p><strong>9.6 — Den Preis der Zusage selbst bestimmen.</strong> (a) Die Kosten je Prozentpunkt steigen weiter steil an; der Mix verschiebt sich dabei fast nur noch zugunsten des Gaskraftwerks, weil Biomasse längst an ihrer Ausbaugrenze liegt. Wind und Sonne bleiben bei einem kleinen Rest — sie senken über ihre Gegenläufigkeit die Norm, tragen zur gesicherten Leistung aber kaum bei. (b) Der Unterschied ist <strong>nicht</strong> numerisch, sondern inhaltlich. Bei 200 MW Biomasse liefert selbst der <strong>Vollausbau</strong> in der Kältewelle nur rund 440 MW — 7,5 % der Szenarien sind schlicht nicht bedienbar, egal wie viel Geld man ausgibt. Das Szenariomodell sieht diese Fälle in den Daten und meldet korrekt <code>infeasible</code>, sobald die Zusage über 92 % steigt. Das analytische Modell kennt sie nicht: Für eine Normalverteilung ist jede Zusage unter 100 % erfüllbar, wenn man nur genug Streuung wegkauft. Es meldet <code>optimal</code> — und der Plan hält gemessen 87,4 %. Glauben sollte man dem Szenariomodell: Ein <code>infeasible</code> ist hier die <strong>richtige</strong> Antwort. Es sagt, dass die Zusage nicht am Budget scheitert, sondern am Kraftwerkspark, und dass nicht mehr Geld hilft, sondern nur eine andere Anlage oder eine kleinere Zusage. (c) Sinngemäß: „99,99 % kosten nicht 5 % mehr als 99 %, sondern ein Vielfaches — der letzte Prozentpunkt ist bereits 4,5-mal so teuer wie der erste. Sagen Sie mir, was ein Ausfalltag das Unternehmen kostet, dann rechne ich aus, welche Quote sich lohnt. Und die Zusage gilt nur für die Wetterlagen, die wir modelliert haben — die Kältewelle gehört hinein.“</p>
-<p><strong>9.7 — Budgeted Uncertainty.</strong></p>
+<p><strong>12.1 — Fluch des Durchschnitts.</strong> Weil sich Verzögerungen <strong>fortpflanzen</strong> und die Verteilung rechtsschief ist: Ein Gewerk, das früher fertig wird, beschleunigt selten den Gesamtablauf (der nächste Schritt ist noch nicht bereit), ein verspätetes verzögert alles. Weitere Beispiele: Wartezeiten in Warteschlangen (nichtlinear in der Auslastung), Projektkosten mit Nachträgen.</p>
+<p><strong>12.2 — Ansatz wählen.</strong> (a) robust (Ausfall ist existenziell, Wahrscheinlichkeiten unzuverlässig). (b) stochastisch (Verteilung bekannt). (c) robust bzw. Extremwertstatistik (seltene Ereignisse, katastrophale Folgen). (d) stochastisch (Szenarien mit Wahrscheinlichkeiten liegen vor). (e) Chance Constraint — die Zusage ist bereits als Quote formuliert („an 99 % aller Wintertage“). Robust wäre hier zu teuer (es gibt immer einen kälteren Tag), der Erwartungswert zu schwach (er sagt nichts über die Zusage).</p>
+<p><strong>12.3 — Zweistufig rechnen.</strong> (a) Mit Spot = 60: Ableitung bei <span class="math inline">x \in (100,250)</span>: <span class="math inline">40 - 60\cdot0{,}5 + 5\cdot0{,}5 = 40-30+2{,}5 = +12{,}5 &gt; 0</span> → Kapazität <strong>senken</strong>. Bei <span class="math inline">x &lt; 100</span>: <span class="math inline">40 - 60 = -20 &lt; 0</span> → erhöhen. Optimum daher <span class="math inline">x^* = 100</span>. (b) Billige Nachbesserung macht Vorhalten unattraktiv. (c) Bei <span class="math inline">x = 225</span> optimal müsste die Ableitung dort das Vorzeichen wechseln — das ist bei diskreten Szenarien nur zufällig der Fall; der Mittelwert ist nur bei symmetrischen Kosten und stetiger Verteilung optimal.</p>
+<p><strong>12.4 — EVPI interpretieren.</strong> Selbst eine <strong>perfekte</strong> Prognose wäre nur 8 400 € pro Jahr wert. Eine Lösung für 15 000 € kann sich also <strong>niemals</strong> rechnen — unabhängig von ihrer Güte. Argument: „Der theoretische Maximalnutzen liegt unter dem Preis.“</p>
+<p><strong>12.5 — Monte-Carlo erweitern.</strong> (a) Servicelevel 95 %: Kapazität = 95 %-Quantil des Bedarfs (ca. 485). Die Zusatzkosten gegenüber dem Kostenoptimum (180) betragen ein Vielfaches — Servicelevel ist teuer, und genau diese Zahl braucht die Geschäftsleitung für die Entscheidung. (b) <code>cvar = kosten[kosten &gt;= np.quantile(kosten, 0.95)].mean()</code>. (c) Erwartetes Bild: Bei kleiner Kapazität ist die Kostenverteilung stark rechtsschief (seltene, teure Notzukäufe); bei großer Kapazität schmal und nach rechts verschoben.</p>
+<p><strong>12.6 — Den Preis der Zusage selbst bestimmen.</strong> (a) Die Kosten je Prozentpunkt steigen weiter steil an; der Mix verschiebt sich dabei fast nur noch zugunsten des Gaskraftwerks, weil Biomasse längst an ihrer Ausbaugrenze liegt. Wind und Sonne bleiben bei einem kleinen Rest — sie senken über ihre Gegenläufigkeit die Norm, tragen zur gesicherten Leistung aber kaum bei. (b) Der Unterschied ist <strong>nicht</strong> numerisch, sondern inhaltlich. Bei 200 MW Biomasse liefert selbst der <strong>Vollausbau</strong> in der Kältewelle nur rund 440 MW — 7,5 % der Szenarien sind schlicht nicht bedienbar, egal wie viel Geld man ausgibt. Das Szenariomodell sieht diese Fälle in den Daten und meldet korrekt <code>infeasible</code>, sobald die Zusage über 92 % steigt. Das analytische Modell kennt sie nicht: Für eine Normalverteilung ist jede Zusage unter 100 % erfüllbar, wenn man nur genug Streuung wegkauft. Es meldet <code>optimal</code> — und der Plan hält gemessen 87,4 %. Glauben sollte man dem Szenariomodell: Ein <code>infeasible</code> ist hier die <strong>richtige</strong> Antwort. Es sagt, dass die Zusage nicht am Budget scheitert, sondern am Kraftwerkspark, und dass nicht mehr Geld hilft, sondern nur eine andere Anlage oder eine kleinere Zusage. (c) Sinngemäß: „99,99 % kosten nicht 5 % mehr als 99 %, sondern ein Vielfaches — der letzte Prozentpunkt ist bereits 4,5-mal so teuer wie der erste. Sagen Sie mir, was ein Ausfalltag das Unternehmen kostet, dann rechne ich aus, welche Quote sich lohnt. Und die Zusage gilt nur für die Wetterlagen, die wir modelliert haben — die Kältewelle gehört hinein.“</p>
+<p><strong>12.7 — Budgeted Uncertainty.</strong></p>
 <div class="sourceCode" id="cb14"><pre class="sourceCode python"><code class="sourceCode python"><span id="cb14-1"><a href="#cb14-1" aria-hidden="true" tabindex="-1"></a>abzug <span class="op">=</span> cp.sum_largest(cp.multiply(UNSICHERHEIT, w), Gamma)</span>
 <span id="cb14-2"><a href="#cb14-2" aria-hidden="true" tabindex="-1"></a>ziel <span class="op">=</span> cp.Maximize(MU_SCHAETZUNG <span class="op">@</span> w <span class="op">-</span> abzug <span class="op">-</span> <span class="fl">0.5</span><span class="op">*</span>LAMBDA<span class="op">*</span>cp.quad_form(w, SIGMA))</span></code></pre></div>
 <p><span class="math inline">\Gamma = 0</span> entspricht dem nominalen Fall, <span class="math inline">\Gamma = n</span> dem vollen Worst Case. Dazwischen steuert <span class="math inline">\Gamma</span> die Vorsicht stufenlos — der praktisch nützlichste Bereich liegt meist bei <span class="math inline">\Gamma \approx \sqrt{n}</span>.</p>
-<h3 id="finde-den-denkfehler-9.1-warum-jedes-projekt-zu-spät-fertig-wird">Finde den Denkfehler 9.1 — Warum jedes Projekt zu spät fertig wird</h3>
+<h3 id="finde-den-denkfehler-warum-jedes-projekt-zu-spät-fertig-wird">Finde den Denkfehler — Warum jedes Projekt zu spät fertig wird</h3>
 <ol type="a">
 <li><strong>Warum 14,38 statt 11,34 Tage.</strong> Der Projektleiter hat den Mittelwert der <strong>Einzeldauer</strong> berechnet und ihn für den Mittelwert der <strong>Projektdauer</strong> gehalten. Das sind zwei verschiedene Größen:</li>
 </ol>
@@ -845,7 +871,7 @@ F(11{,}33) = 1 - \frac{(18-11{,}33)^2}{(18-6)(18-10)} = 1 - \frac{44{,}4}{96} =
 <h3 id="quiz-loesung-unsicherheit">Micro-Quiz</h3>
 <p><strong>1 — (b).</strong> Das kritische Verhältnis <span class="math inline">1400/(1400+120) = 0{,}921</span> gibt an, wie weit man sich auf die günstigere Fehlerseite stellen soll: Bestellt wird das 92,1-%-Quantil des Bedarfs, hier 38 Stück. (a) ignoriert die Kostenasymmetrie und kostet im Kapitelbeispiel 160 % mehr. (c) verwechselt die Fragestellung: Die Kapitalbindung <em>ist</em> bereits in den 120 € je überzähligem Stück enthalten — sie rechtfertigt keine zusätzliche Kürzung.</p>
 <p><strong>2 — (b).</strong> Der Unterschied liegt darin, <strong>was man wissen muss</strong>: Stochastische Optimierung setzt eine Wahrscheinlichkeitsverteilung voraus und minimiert den Erwartungswert; robuste Optimierung kommt mit einer bloßen Bandbreite aus und sichert den ungünstigsten Fall darin ab. Keines ist „genauer“ (a) — sie beantworten verschiedene Fragen. (c) trifft es nicht: Robuste Optimierung betrachtet nicht mehr Szenarien, sondern eine ganze Menge auf einmal, und interessiert sich darin nur für den schlechtesten Punkt.</p>
-<p><strong>3 — (c).</strong> Bei durchgehender Linearität und ohne nachgelagerte Entscheidung gilt <span class="math inline">\mathbb{E}[f(X)] = f(\mathbb{E}[X])</span> — dann ist Rechnen mit Mittelwerten korrekt. Sobald aber ein Maximum, ein Minimum, ein Betrag oder eine Nachbesserungsentscheidung auftaucht, gilt das nicht mehr: Genau das sind die beiden Fälle aus Schnellstart (asymmetrische Kosten über <code>maximum</code>) und Denkfehler 9.1 (Maximum über parallele Vorgänge). (a) ist die Fehlannahme, um die es im ganzen Kapitel geht; (b) ist zu absolut — es gibt den linearen Fall, in dem es tatsächlich zulässig ist.</p>
+<p><strong>3 — (c).</strong> Bei durchgehender Linearität und ohne nachgelagerte Entscheidung gilt <span class="math inline">\mathbb{E}[f(X)] = f(\mathbb{E}[X])</span> — dann ist Rechnen mit Mittelwerten korrekt. Sobald aber ein Maximum, ein Minimum, ein Betrag oder eine Nachbesserungsentscheidung auftaucht, gilt das nicht mehr: Genau das sind die beiden Fälle aus Schnellstart (asymmetrische Kosten über <code>maximum</code>) und <a href="unsicherheit.html#sec:unsicherheit-denkfehler">Abschnitt 12.9</a> (Maximum über parallele Vorgänge). (a) ist die Fehlannahme, um die es im ganzen Kapitel geht; (b) ist zu absolut — es gibt den linearen Fall, in dem es tatsächlich zulässig ist.</p>
 <h3 id="selbsttest-loesung-unsicherheit">Selbsttest</h3>
 <ol type="1">
 <li>Wegen der Jensenschen Ungleichung: Bei konvexen Kosten ist <span class="math inline">\mathbb{E}[f(X)] \ge f(\mathbb{E}[X])</span> — Planung mit dem Mittelwert unterschätzt die Kosten systematisch.</li>
@@ -858,10 +884,10 @@ F(11{,}33) = 1 - \frac{(18-11{,}33)^2}{(18-6)(18-10)} = 1 - \frac{44{,}4}{96} =
 </ol>
 <hr />
 <h2 id="sec:loesungen-dynamische-programmierung">A.13 Lösungen zu Kapitel „Dynamische Programmierung — Die Bellman-Gleichung und Order-Execution“</h2>
-<p><strong>10.1 — Bausteine.</strong> Stufe = Tag 1–5; Zustand = verbleibende Distanz (ggf. plus Erschöpfungsgrad); Aktion = heutige Tagesetappe; Wertfunktion = minimale Restanstrengung. <strong>Nicht</strong> in den Zustand gehören: bereits gelaufene Kilometer (redundant, wenn die Restdistanz bekannt ist) und das Wetter von gestern (ohne Einfluss auf die Zukunft).</p>
-<p><strong>10.2 — Optimalitätsprinzip.</strong> Weil der Wert eines Zustands nur von den <em>künftigen</em> Entscheidungen abhängt, kann man ihn ab dem Ende rekursiv berechnen. Hängen die Kosten zusätzlich von <strong>früheren</strong> Aktionen ab, ist die Markov-Eigenschaft verletzt — die Lösung: die relevante Vergangenheit <strong>in den Zustand aufnehmen</strong> (dann wächst allerdings der Zustandsraum).</p>
-<p><strong>10.3 — Rückwärtsinduktion.</strong> Mit <span class="math inline">C(n) = n^2 + 2n</span> und 5 Einheiten in 3 Perioden ergibt sich als optimaler Pfad <span class="math inline">2 \to 2 \to 1</span> (oder eine Permutation davon) mit Gesamtkosten <span class="math inline">8 + 8 + 3 = 19</span>. Alles auf einmal kostet <span class="math inline">25 + 10 = 35</span>.</p>
-<p><strong>10.4 — Rucksack als DP.</strong></p>
+<p><strong>13.1 — Bausteine.</strong> Stufe = Tag 1–5; Zustand = verbleibende Distanz (ggf. plus Erschöpfungsgrad); Aktion = heutige Tagesetappe; Wertfunktion = minimale Restanstrengung. <strong>Nicht</strong> in den Zustand gehören: bereits gelaufene Kilometer (redundant, wenn die Restdistanz bekannt ist) und das Wetter von gestern (ohne Einfluss auf die Zukunft).</p>
+<p><strong>13.2 — Optimalitätsprinzip.</strong> Weil der Wert eines Zustands nur von den <em>künftigen</em> Entscheidungen abhängt, kann man ihn ab dem Ende rekursiv berechnen. Hängen die Kosten zusätzlich von <strong>früheren</strong> Aktionen ab, ist die Markov-Eigenschaft verletzt — die Lösung: die relevante Vergangenheit <strong>in den Zustand aufnehmen</strong> (dann wächst allerdings der Zustandsraum).</p>
+<p><strong>13.3 — Rückwärtsinduktion.</strong> Mit <span class="math inline">C(n) = n^2 + 2n</span> und 5 Einheiten in 3 Perioden ergibt sich als optimaler Pfad <span class="math inline">2 \to 2 \to 1</span> (oder eine Permutation davon) mit Gesamtkosten <span class="math inline">8 + 8 + 3 = 19</span>. Alles auf einmal kostet <span class="math inline">25 + 10 = 35</span>.</p>
+<p><strong>13.4 — Rucksack als DP.</strong></p>
 <div class="sourceCode" id="cb16"><pre class="sourceCode python"><code class="sourceCode python"><span id="cb16-1"><a href="#cb16-1" aria-hidden="true" tabindex="-1"></a>V <span class="op">=</span> np.zeros((n <span class="op">+</span> <span class="dv">1</span>, kapazitaet <span class="op">+</span> <span class="dv">1</span>))</span>
 <span id="cb16-2"><a href="#cb16-2" aria-hidden="true" tabindex="-1"></a><span class="cf">for</span> i <span class="kw">in</span> <span class="bu">range</span>(<span class="dv">1</span>, n <span class="op">+</span> <span class="dv">1</span>):</span>
 <span id="cb16-3"><a href="#cb16-3" aria-hidden="true" tabindex="-1"></a>    <span class="cf">for</span> c <span class="kw">in</span> <span class="bu">range</span>(kapazitaet <span class="op">+</span> <span class="dv">1</span>):</span>
@@ -869,9 +895,9 @@ F(11{,}33) = 1 - \frac{(18-11{,}33)^2}{(18-6)(18-10)} = 1 - \frac{44{,}4}{96} =
 <span id="cb16-5"><a href="#cb16-5" aria-hidden="true" tabindex="-1"></a>        <span class="cf">if</span> gewicht[i<span class="op">-</span><span class="dv">1</span>] <span class="op">&lt;=</span> c:</span>
 <span id="cb16-6"><a href="#cb16-6" aria-hidden="true" tabindex="-1"></a>            V[i][c] <span class="op">=</span> <span class="bu">max</span>(V[i][c], V[i<span class="op">-</span><span class="dv">1</span>][c <span class="op">-</span> gewicht[i<span class="op">-</span><span class="dv">1</span>]] <span class="op">+</span> nutzen[i<span class="op">-</span><span class="dv">1</span>])</span></code></pre></div>
 <p>Ergebnis identisch zum MILP (110). Laufzeit <span class="math inline">O(n \cdot C)</span> — bei kleinen ganzzahligen Kapazitäten schneller als Branch-and-Bound, bei großen oder nicht-ganzzahligen Kapazitäten schlechter (dann ist das MILP überlegen). Man nennt das <strong>pseudopolynomiell</strong>.</p>
-<p><strong>10.5 — Risikoaversion kalibrieren.</strong> (a) Zwischen <span class="math inline">\lambda = 10^{-5}</span> (41 %) und <span class="math inline">10^{-4}</span> (78 %); genauer etwa bei <span class="math inline">\lambda \approx 3\cdot10^{-5}</span>. (b) Höheres <span class="math inline">\lambda</span> → höhere Gesamtkosten (man kauft Sicherheit mit Slippage). (c) Iterativ: <span class="math inline">\lambda</span> so wählen, dass der Anteil der Marktauswirkungskosten an den Gesamtkosten bei 20 % liegt — im Programm ausrechnen und per Bisektion einstellen.</p>
-<p><strong>10.6 — Zustandsraum erweitern.</strong> Der Zustand wird zu (Restbestand, Orderbuchtiefe); der Zustandsraum verdreifacht sich, die Rechenzeit ebenfalls. Die Strategie wird <strong>zustandsabhängig</strong>: Bei tiefem Buch wird mehr verkauft, bei dünnem gewartet. Genau diese Adaptivität ist der Mehrwert von DP gegenüber einem festen Pfad.</p>
-<h3 id="finde-den-denkfehler-10.1-der-zustand-der-zu-wenig-weiß">Finde den Denkfehler 10.1 — Der Zustand, der zu wenig weiß</h3>
+<p><strong>13.5 — Risikoaversion kalibrieren.</strong> (a) Zwischen <span class="math inline">\lambda = 10^{-5}</span> (41 %) und <span class="math inline">10^{-4}</span> (78 %); genauer etwa bei <span class="math inline">\lambda \approx 3\cdot10^{-5}</span>. (b) Höheres <span class="math inline">\lambda</span> → höhere Gesamtkosten (man kauft Sicherheit mit Slippage). (c) Iterativ: <span class="math inline">\lambda</span> so wählen, dass der Anteil der Marktauswirkungskosten an den Gesamtkosten bei 20 % liegt — im Programm ausrechnen und per Bisektion einstellen.</p>
+<p><strong>13.6 — Zustandsraum erweitern.</strong> Der Zustand wird zu (Restbestand, Orderbuchtiefe); der Zustandsraum verdreifacht sich, die Rechenzeit ebenfalls. Die Strategie wird <strong>zustandsabhängig</strong>: Bei tiefem Buch wird mehr verkauft, bei dünnem gewartet. Genau diese Adaptivität ist der Mehrwert von DP gegenüber einem festen Pfad.</p>
+<h3 id="finde-den-denkfehler-der-zustand-der-zu-wenig-weiß">Finde den Denkfehler — Der Zustand, der zu wenig weiß</h3>
 <ol type="a">
 <li><strong>Die fehlende Information.</strong> Die Zeile</li>
 </ol>
@@ -930,7 +956,7 @@ F(11{,}33) = 1 - \frac{(18-11{,}33)^2}{(18-6)(18-10)} = 1 - \frac{44{,}4}{96} =
 <h3 id="quiz-loesung-dynamische-programmierung">Micro-Quiz</h3>
 <p><strong>1 — (b).</strong> <span class="math inline">V_t</span> setzt <span class="math inline">V_{t+1}</span> voraus: Eine Entscheidung lässt sich erst bewerten, wenn feststeht, was sie für die Zukunft bedeutet. Am Ende ist dieser Wert bekannt (<span class="math inline">V_T = g</span>), deshalb beginnt die Rechnung dort. (a) verwechselt ein mathematisches Erfordernis mit einer Implementierungsfrage; (c) ist frei erfunden und hätte mit der Rechenrichtung ohnehin nichts zu tun.</p>
 <p><strong>2 — (b).</strong> Das Optimalitätsprinzip sagt, dass jedes <strong>Reststück</strong> einer optimalen Lösung selbst optimal ist. Deshalb genügt es, je Zustand einen einzigen Wert zu speichern, statt alle Wege dorthin zu unterscheiden. (a) ist die verbreitetste Fehldeutung — sie beschriebe gieriges Vorgehen, und genau das scheitert im Schnellstart dieses Kapitels (21 statt 14 Minuten). (c) ist eine Allgemeinplatz-Aussage ohne Bezug zum Prinzip.</p>
-<p><strong>3 — (b).</strong> Der Rabatt hängt von der bisher kumulierten Menge ab; ohne diese Größe im Zustand kann das Modell die Kosten der nächsten Bestellung nicht bestimmen — dasselbe Muster wie in Denkfehler 10.1. (a) übersieht genau das: Kosten, die von der Vorgeschichte abhängen, <strong>sind</strong> Zustandsinformation. (c) ist zu absolut — DP bleibt anwendbar, der Zustandsraum wird nur größer; ob sich stattdessen ein MILP lohnt, ist eine Frage der Größe, nicht der Eignung.</p>
+<p><strong>3 — (b).</strong> Der Rabatt hängt von der bisher kumulierten Menge ab; ohne diese Größe im Zustand kann das Modell die Kosten der nächsten Bestellung nicht bestimmen — dasselbe Muster wie in <a href="dynamische-programmierung.html#sec:dynamische-programmierung-denkfehler">Abschnitt 13.7</a>. (a) übersieht genau das: Kosten, die von der Vorgeschichte abhängen, <strong>sind</strong> Zustandsinformation. (c) ist zu absolut — DP bleibt anwendbar, der Zustandsraum wird nur größer; ob sich stattdessen ein MILP lohnt, ist eine Frage der Größe, nicht der Eignung.</p>
 <h3 id="selbsttest-loesung-dynamische-programmierung">Selbsttest</h3>
 <ol type="1">
 <li>Jeder Teilabschnitt einer optimalen Strategie ist selbst optimal für den Zustand, in dem er beginnt.</li>
@@ -941,16 +967,16 @@ F(11{,}33) = 1 - \frac{(18-11{,}33)^2}{(18-6)(18-10)} = 1 - \frac{44{,}4}{96} =
 </ol>
 <hr />
 <h2 id="sec:loesungen-mehrziel">A.14 Lösungen zu Kapitel „Mehrere Ziele — Pareto-Fronten statt Gewichte“</h2>
-<p><strong>Dominanz prüfen.</strong> P (14 000 €, 6 000 kg) und Q (13 800 €, 6 100 kg): <strong>keiner dominiert den anderen.</strong> Q ist billiger, P ist sauberer — beide sind pareto-optimal, die Wahl ist eine Präferenzfrage.</p>
+<p><strong>14.1 — Dominanz prüfen.</strong> P (14 000 €, 6 000 kg) und Q (13 800 €, 6 100 kg): <strong>keiner dominiert den anderen.</strong> Q ist billiger, P ist sauberer — beide sind pareto-optimal, die Wahl ist eine Präferenzfrage.</p>
 <p>R (14 000 €, 6 100 kg) dagegen wird <strong>von beiden dominiert</strong>: gleich teuer wie P, aber schmutziger; schmutziger als Q <em>und</em> teurer. R kann man wegwerfen, ohne jemanden zu fragen — und genau das ist der Zweck des Dominanzbegriffs: Er trennt die Fälle, in denen der Modellierer entscheiden darf, von denen, in denen er es nicht darf.</p>
-<p><strong>Der Schattenpreis in der Praxis.</strong> Man geht die Front von unten durch, solange der Schattenpreis unter 0,90 €/kg liegt. Aus der Ausgabe: 0,58 — 0,93 — 0,40 — 0,59 — 0,77 — 0,65 — 0,77 — 1,09 — 1,32. Die Werte steigen nicht monoton, weil die Front bei ganzzahligen Modellen keine glatte Kurve ist; maßgeblich ist deshalb nicht der einzelne Schritt, sondern der <strong>Gesamtschattenpreis</strong> gegenüber dem Kostenminimum.</p>
+<p><strong>14.2 — Der Schattenpreis in der Praxis.</strong> Man geht die Front von unten durch, solange der Schattenpreis unter 0,90 €/kg liegt. Aus der Ausgabe: 0,58 — 0,93 — 0,40 — 0,59 — 0,77 — 0,65 — 0,77 — 1,09 — 1,32. Die Werte steigen nicht monoton, weil die Front bei ganzzahligen Modellen keine glatte Kurve ist; maßgeblich ist deshalb nicht der einzelne Schritt, sondern der <strong>Gesamtschattenpreis</strong> gegenüber dem Kostenminimum.</p>
 <p>Der letzte Punkt, dessen Gesamtschattenpreis unter 0,90 € liegt, ist <strong>14 189 € / 5 632 kg</strong>: 646 € Aufpreis für 843 kg Ersparnis, also 0,77 €/kg. Der nächste Punkt kostet 1,09 €/kg und liegt damit über dem internen Preis.</p>
 <p>Begründung in einem Satz: <em>„Für 646 Euro sparen wir 843 Kilogramm CO₂ — zu 77 Cent je Kilogramm, während wir intern mit 90 Cent rechnen.“</em></p>
-<p><strong>Mehr Trassen.</strong> Mit 8 statt 5 Trassen wird der Engpass schwächer. Zu erwarten ist eine <strong>kürzere</strong> Front: Der Zielkonflikt entsteht ja allein aus der Knappheit; je mehr Trassen, desto näher rücken Kostenminimum und CO₂-Minimum zusammen. Im Grenzfall genügend vieler Trassen fallen beide zusammen — die Bahn ist billiger <em>und</em> sauberer, also gibt es gar keinen Konflikt mehr und die Front schrumpft auf einen Punkt.</p>
+<p><strong>14.3 — Mehr Trassen.</strong> Mit 8 statt 5 Trassen wird der Engpass schwächer. Zu erwarten ist eine <strong>kürzere</strong> Front: Der Zielkonflikt entsteht ja allein aus der Knappheit; je mehr Trassen, desto näher rücken Kostenminimum und CO₂-Minimum zusammen. Im Grenzfall genügend vieler Trassen fallen beide zusammen — die Bahn ist billiger <em>und</em> sauberer, also gibt es gar keinen Konflikt mehr und die Front schrumpft auf einen Punkt.</p>
 <p>Der Lehrpunkt: <strong>Ein Zielkonflikt ist keine Eigenschaft der Ziele, sondern der Knappheit.</strong> Wer ihn auflösen will, sollte zuerst prüfen, ob sich die Ressource vermehren lässt, statt über Gewichte zu verhandeln.</p>
-<p><strong>Die Front der Relaxation.</strong> Ohne <code>integrality</code> ist der zulässige Bereich konvex, und die Pareto-Front liegt vollständig auf ihrer eigenen unteren konvexen Hülle. Es gibt also <strong>keinen</strong> Punkt oberhalb — jeder Punkt der Front ist durch ein passendes Gewicht erreichbar.</p>
+<p><strong>14.4 — Die Front der Relaxation.</strong> Ohne <code>integrality</code> ist der zulässige Bereich konvex, und die Pareto-Front liegt vollständig auf ihrer eigenen unteren konvexen Hülle. Es gibt also <strong>keinen</strong> Punkt oberhalb — jeder Punkt der Front ist durch ein passendes Gewicht erreichbar.</p>
 <p>Genau das ist der Grund, warum das Problem in Lehrbüchern zur linearen Programmierung nicht vorkommt und in der betrieblichen Praxis ständig: Sobald „welcher Träger“, „welches Lager“ oder „welche Schicht“ entschieden wird, zerfällt der Bereich in einzelne Punkte, und zwischen ihnen entstehen die Einbuchtungen, in denen die nicht gestützten Lösungen liegen.</p>
-<p><strong>Drei Ziele.</strong> Die Front wird zu einer Fläche im dreidimensionalen Zielraum. Das ε-Verfahren braucht dann ein <strong>Gitter</strong> über zwei Schranken statt einer Folge über eine — der Aufwand wächst von <span class="math inline">O(k)</span> auf <span class="math inline">O(k^2)</span>, bei <span class="math inline">m</span> Zielen auf <span class="math inline">O(k^{m-1})</span>.</p>
+<p><strong>14.5 — Drei Ziele.</strong> Die Front wird zu einer Fläche im dreidimensionalen Zielraum. Das ε-Verfahren braucht dann ein <strong>Gitter</strong> über zwei Schranken statt einer Folge über eine — der Aufwand wächst von <span class="math inline">O(k)</span> auf <span class="math inline">O(k^2)</span>, bei <span class="math inline">m</span> Zielen auf <span class="math inline">O(k^{m-1})</span>.</p>
 <p>Zwei praktische Folgerungen: Erstens ist bei drei und mehr Zielen die vollständige Front meist nicht mehr bezahlbar; man arbeitet dann mit einer Stichprobe oder mit Metaheuristiken, die eine Front approximieren (NSGA-II, in <code>pymoo</code> enthalten). Zweitens ist eine Front mit hunderten Punkten für die Entscheidung ohnehin unbrauchbar — ab drei Zielen ist die bessere Frage meist, ob sich zwei davon zusammenfassen lassen.</p>
 <h3 id="denkfehler-loesung-mehrziel">Finde den Denkfehler — „Wir haben die Gewichte sauber kalibriert“</h3>
 <p><strong>Der Lösungsraum wurde nicht vollständig abgetastet — und zwar aus prinzipiellen Gründen.</strong></p>
@@ -974,15 +1000,15 @@ F(11{,}33) = 1 - \frac{(18-11{,}33)^2}{(18-6)(18-10)} = 1 - \frac{44{,}4}{96} =
 </ol>
 <hr />
 <h2 id="sec:loesungen-prognose">A.15 Lösungen zu Kapitel „Predict-then-Optimize“</h2>
-<p><strong>Andere Preise.</strong> Der Überhang kostet nur noch 1,50 €, die Fehlmenge weiterhin 6 €. Das kritische Verhältnis steigt von <span class="math inline">6/9 = 0{,}667</span> auf <span class="math inline">6/7{,}5 = 0{,}80</span>. Die Bestellmenge verschiebt sich also <strong>nach oben</strong> — man bestellt jetzt das 80-%-Quantil statt des 66,7-%-Quantils.</p>
+<p><strong>15.1 — Andere Preise.</strong> Der Überhang kostet nur noch 1,50 €, die Fehlmenge weiterhin 6 €. Das kritische Verhältnis steigt von <span class="math inline">6/9 = 0{,}667</span> auf <span class="math inline">6/7{,}5 = 0{,}80</span>. Die Bestellmenge verschiebt sich also <strong>nach oben</strong> — man bestellt jetzt das 80-%-Quantil statt des 66,7-%-Quantils.</p>
 <p>Das ist die richtige Richtung und leicht zu merken: Je billiger der Überhang, desto großzügiger darf man ansetzen. Im Grenzfall kostenloser Entsorgung (<span class="math inline">c_+ \to 0</span>) geht das kritische Verhältnis gegen 1 — man bestellt so viel, dass praktisch nie etwas fehlt.</p>
-<p><strong>Wann ist der Mittelwert richtig?</strong> Nur wenn <span class="math inline">c_- = c_+</span> <strong>und</strong> die Nachfrageverteilung symmetrisch ist. Dann liegt das kritische Verhältnis bei 0,5, das 50-%-Quantil ist der Median, und bei Symmetrie fällt der Median mit dem Mittelwert zusammen.</p>
+<p><strong>15.2 — Wann ist der Mittelwert richtig?</strong> Nur wenn <span class="math inline">c_- = c_+</span> <strong>und</strong> die Nachfrageverteilung symmetrisch ist. Dann liegt das kritische Verhältnis bei 0,5, das 50-%-Quantil ist der Median, und bei Symmetrie fällt der Median mit dem Mittelwert zusammen.</p>
 <p>Beide Bedingungen sind unrealistisch. Fehlmenge und Überhang kosten fast nie dasselbe — bei Frischware ist der Überhang teurer, bei Ersatzteilen die Fehlmenge um Größenordnungen. Und Nachfrageverteilungen sind meist rechtsschief. Der Mittelwert ist damit die Ausnahme, nicht die Regel — er wird nur benutzt, weil Regressionsmodelle ihn standardmäßig liefern.</p>
-<p><strong>Die Kennzahl der Prognoseabteilung.</strong> Die Rangfolge bleibt: Die Punktprognose gewinnt auch beim MAPE, weil beide Maße den <em>Erwartungswert</em> belohnen — der MAPE etwas anders gewichtet, aber ebenfalls symmetrisch in dem Sinne, dass er nicht weiß, dass Unterschätzung teurer ist als Überschätzung.</p>
+<p><strong>15.3 — Die Kennzahl der Prognoseabteilung.</strong> Die Rangfolge bleibt: Die Punktprognose gewinnt auch beim MAPE, weil beide Maße den <em>Erwartungswert</em> belohnen — der MAPE etwas anders gewichtet, aber ebenfalls symmetrisch in dem Sinne, dass er nicht weiß, dass Unterschätzung teurer ist als Überschätzung.</p>
 <p>Das ist kein Zufall, sondern der Kern des Kapitels: <strong>Jedes rein statistische Fehlermaß ignoriert die Kostenasymmetrie.</strong> Man kann das Problem nicht lösen, indem man das Fehlermaß wechselt; man muss die Kosten selbst messen. (Die einzige Ausnahme ist der <em>Pinball Loss</em> — genau das Maß, das die Quantilregression minimiert, und das ist eben kein allgemeines Prognosemaß, sondern eines für ein bestimmtes Quantil.)</p>
-<p><strong>Zwei Quantile.</strong> Das Band ist an <strong>Aktionstagen</strong> deutlich breiter — dort ist die Streuung im Modell fast viermal so groß. Genau das ist die Information, die eine Punktprognose plus fester Zuschlag wegwirft.</p>
+<p><strong>15.4 — Zwei Quantile.</strong> Das Band ist an <strong>Aktionstagen</strong> deutlich breiter — dort ist die Streuung im Modell fast viermal so groß. Genau das ist die Information, die eine Punktprognose plus fester Zuschlag wegwirft.</p>
 <p>Ein praktischer Nebeneffekt: Ein solches Band ist die verständlichste Form, Unsicherheit an die Disposition zu berichten. „Zwischen 130 und 210” sagt einem Menschen mehr als „170 ± Sicherheitszuschlag”.</p>
-<p><strong>Der Wert der Merkmale.</strong> Zu erwarten ist, dass die <strong>Kosten stärker steigen als der MSE</strong>. Der Grund: Das Merkmal „Aktion” trägt zwei verschiedene Informationen — es verschiebt den Erwartungswert (um 45 Stück) <em>und</em> die Streuung (von 8 auf 30). Der MSE bemerkt nur den ersten Teil; die Entscheidungskosten spüren beide.</p>
+<p><strong>15.5 — Der Wert der Merkmale.</strong> Zu erwarten ist, dass die <strong>Kosten stärker steigen als der MSE</strong>. Der Grund: Das Merkmal „Aktion” trägt zwei verschiedene Informationen — es verschiebt den Erwartungswert (um 45 Stück) <em>und</em> die Streuung (von 8 auf 30). Der MSE bemerkt nur den ersten Teil; die Entscheidungskosten spüren beide.</p>
 <p>Der Lehrsatz dahinter: <strong>Der Wert eines Merkmals hängt davon ab, wofür man es benutzt.</strong> Eine Merkmalsauswahl, die nach MSE-Beitrag sortiert, wirft möglicherweise genau die Merkmale weg, die für die Entscheidung am wichtigsten sind — nämlich die, die etwas über die Unsicherheit sagen.</p>
 <h3 id="denkfehler-loesung-prognose">Finde den Denkfehler — „Wir haben die Prognose um 18 % verbessert“</h3>
 <p><strong>Der Sicherheitszuschlag stammt aus den Residuen des alten Modells.</strong></p>
@@ -1010,17 +1036,17 @@ F(11{,}33) = 1 - \frac{(18-11{,}33)^2}{(18-6)(18-10)} = 1 - \frac{44{,}4}{96} =
 </ol>
 <hr />
 <h2 id="sec:loesungen-bruecke">A.16 Lösungen zu Kapitel „Die Strukturbrücke — dieselbe Mathematik, zwei Welten“</h2>
-<p><strong>Die dritte Ressource.</strong> „Liquidität” — wie schnell sich eine Position ohne Kursabschlag verkaufen lässt — entspricht in der Werkstatt der <strong>Umrüstbarkeit</strong> oder der <strong>Vorlaufzeit</strong>: Wie schnell lässt sich die Fertigung von diesem Produkt wieder wegdrehen, wenn der Auftrag storniert wird? In beiden Fällen ist es eine knappe Größe, die nichts mit dem Ertrag zu tun hat und trotzdem die Auswahl einschränkt.</p>
+<p><strong>16.1 — Die dritte Ressource.</strong> „Liquidität” — wie schnell sich eine Position ohne Kursabschlag verkaufen lässt — entspricht in der Werkstatt der <strong>Umrüstbarkeit</strong> oder der <strong>Vorlaufzeit</strong>: Wie schnell lässt sich die Fertigung von diesem Produkt wieder wegdrehen, wenn der Auftrag storniert wird? In beiden Fällen ist es eine knappe Größe, die nichts mit dem Ertrag zu tun hat und trotzdem die Auswahl einschränkt.</p>
 <p>Im Modell ist es schlicht eine weitere Zeile in <code>kapazitaeten</code> und ein weiterer Eintrag in jedem <code>verbrauch</code>. Genau das ist der Punkt des Kapitels: Eine neue Ressource kostet keinen Modellcode.</p>
-<p><strong>Den Schattenpreis lesen.</strong> Bis zu <strong>602,60 €</strong> für 10 Einheiten (10 × 60,26 €) lohnt sich der Kauf — darüber nicht.</p>
+<p><strong>16.2 — Den Schattenpreis lesen.</strong> Bis zu <strong>602,60 €</strong> für 10 Einheiten (10 × 60,26 €) lohnt sich der Kauf — darüber nicht.</p>
 <p>Die Einschränkung aus <a href="lp.html#sec:lp-entartung">Abschnitt 5.9</a>: Der Schattenpreis gilt nur <strong>lokal</strong>, solange sich die optimale Basis nicht ändert. Nach einer gewissen Erhöhung wird eine andere Nebenbedingung bindend (hier voraussichtlich das Kapital), und ab dort ist die zusätzliche Einheit weniger wert. Bei 10 Einheiten auf 90 ist das eine Erhöhung um 11 % — schon groß genug, dass man es nachrechnen sollte, statt zu extrapolieren.</p>
 <p>Zweite Einschränkung: Bei <strong>Entartung</strong> ist der Schattenpreis nicht eindeutig. Verschiedene Solver können dann verschiedene, gleichermaßen gültige Werte liefern — auch das steht in <a href="lp.html#sec:lp-entartung">Abschnitt 5.9</a>.</p>
-<p><strong>Die Brücke rückwärts.</strong> Shrinkage hilft, wenn man eine <strong>Kovarianzmatrix</strong> aus wenigen Beobachtungen schätzt. Bei Lieferzeiten tritt genau dasselbe Problem auf, sobald man die <em>Korrelationen zwischen</em> Lieferanten braucht — und die braucht man, sobald Lieferanten gemeinsame Ursachen haben: derselbe Hafen, dasselbe Vorprodukt, dieselbe Region.</p>
+<p><strong>16.3 — Die Brücke rückwärts.</strong> Shrinkage hilft, wenn man eine <strong>Kovarianzmatrix</strong> aus wenigen Beobachtungen schätzt. Bei Lieferzeiten tritt genau dasselbe Problem auf, sobald man die <em>Korrelationen zwischen</em> Lieferanten braucht — und die braucht man, sobald Lieferanten gemeinsame Ursachen haben: derselbe Hafen, dasselbe Vorprodukt, dieselbe Region.</p>
 <p>Bei 40 Lieferanten hat die Kovarianzmatrix 820 zu schätzende Einträge. Wer dafür 36 Monatswerte hat, schätzt 820 Zahlen aus 36 Beobachtungen — dasselbe Missverhältnis wie bei Aktienrenditen, mit denselben Folgen (<code>Kovarianz_Falle.py</code>).</p>
 <p>Benötigt würden: Lieferzeit-Zeitreihen je Lieferant über denselben Zeitraum, gleich getaktet. Genau daran scheitert es in der Praxis meist — die Daten liegen in Bestellvorgängen, nicht in einer Matrix.</p>
-<p><strong>CVaR mit Ganzzahligkeit.</strong> Man ergänzt Binärvariablen <span class="math inline">y_j</span> je Lieferant und die Kopplung <span class="math inline">w_j \le y_j</span> sowie <span class="math inline">\sum_j y_j \le 3</span>. Da CVXPY gemischt-ganzzahlige Probleme unterstützt, genügt <code>cp.Variable(n, boolean=True)</code>.</p>
+<p><strong>16.4 — CVaR mit Ganzzahligkeit.</strong> Man ergänzt Binärvariablen <span class="math inline">y_j</span> je Lieferant und die Kopplung <span class="math inline">w_j \le y_j</span> sowie <span class="math inline">\sum_j y_j \le 3</span>. Da CVXPY gemischt-ganzzahlige Probleme unterstützt, genügt <code>cp.Variable(n, boolean=True)</code>.</p>
 <p>Zu erwarten ist ein <strong>höherer</strong> CVaR: Der zulässige Bereich wird kleiner, und die Feinabstimmung über sechs Lieferanten fällt weg. Der Aufschlag ist der Preis der Vertragswirklichkeit — und genau die Zahl, die man dem Einkauf vorlegt, wenn dort jemand sagt, drei Lieferanten seien genug.</p>
-<p><strong>Die eigene Brücke.</strong> Freie Antwort. Eine gute Bearbeitung nennt das Modell, die Entsprechung und <strong>die Zeile der Grenztabelle, die im Weg steht</strong> — meist ist es die dritte (Teilbarkeit) oder die erste (gemessen gegen geschätzt). Wenn keine im Weg steht, ist die Übertragung wahrscheinlich zu oberflächlich geprüft.</p>
+<p><strong>16.5 — Die eigene Brücke.</strong> Freie Antwort. Eine gute Bearbeitung nennt das Modell, die Entsprechung und <strong>die Zeile der Grenztabelle, die im Weg steht</strong> — meist ist es die dritte (Teilbarkeit) oder die erste (gemessen gegen geschätzt). Wenn keine im Weg steht, ist die Übertragung wahrscheinlich zu oberflächlich geprüft.</p>
 <h3 id="denkfehler-loesung-bruecke">Finde den Denkfehler — „Das ist doch dasselbe Problem“</h3>
 <p><strong>Fehler 1: Varianz ist hier das falsche Risikomaß — genau der Fall, für den es CVaR gibt.</strong></p>
 <p>Markowitz minimiert die <strong>Varianz</strong>, und die bestraft Abweichungen nach <em>beiden</em> Seiten gleich. Ein Lieferant, der manchmal zwei Tage zu früh liefert, erhöht die Varianz genauso wie einer, der zwei Tage zu spät liefert — obwohl das eine harmlos und das andere teuer ist.</p>
@@ -1044,20 +1070,20 @@ F(11{,}33) = 1 - \frac{(18-11{,}33)^2}{(18-6)(18-10)} = 1 - \frac{44{,}4}{96} =
 </ol>
 <hr />
 <h2 id="sec:loesungen-supplychain">A.17 Lösungen zu Kapitel „Supply-Chain und Energieeinsatz unter Unsicherheit“</h2>
-<p><strong>Der Umschlagpunkt.</strong> Bei 60 MW statt 120 MW halbiert sich die Grenzkostendifferenz je Stunde (83 €/MWh × 60 MW = 4 980 €/h). Der Umschlagpunkt verdoppelt sich auf <strong>7,7 Stunden</strong>.</p>
+<p><strong>17.1 — Der Umschlagpunkt.</strong> Bei 60 MW statt 120 MW halbiert sich die Grenzkostendifferenz je Stunde (83 €/MWh × 60 MW = 4 980 €/h). Der Umschlagpunkt verdoppelt sich auf <strong>7,7 Stunden</strong>.</p>
 <p>Das ist plausibel: Je kleiner die abzudeckende Leistung, desto länger dauert es, bis der Grenzkostenvorteil des großen Blocks seine Anfahrkosten einspielt. Ein Kernblock lohnt sich für eine kleine Restlast noch weniger als für eine große — was erklärt, warum Grundlastblöcke gerade dann unwirtschaftlich werden, wenn viel Wind einspeist und nur eine kleine Restlast bleibt.</p>
-<p><strong>Die fehlende Nebenbedingung.</strong> Analog zum Anfahren braucht man eine Abfahr-Indikatorvariable <span class="math inline">b_{k,t} \ge u_{k,t-1} - u_{k,t}</span> und dann:</p>
+<p><strong>17.2 — Die fehlende Nebenbedingung.</strong> Analog zum Anfahren braucht man eine Abfahr-Indikatorvariable <span class="math inline">b_{k,t} \ge u_{k,t-1} - u_{k,t}</span> und dann:</p>
 <p><span class="math display">
 u_{k,\tau} \le 1 - b_{k,t} \qquad \text{für } \tau = t, \dots, t + M_k - 1
 </span></p>
 <p>In Worten: Wer abfährt, bleibt <span class="math inline">M_k</span> Stunden aus.</p>
 <p>Der reale Sachverhalt: Ein abgeschalteter Dampfblock kühlt aus und darf aus werkstofftechnischen Gründen nicht sofort wieder hochgefahren werden — die Temperaturwechsel würden das Material schädigen. Bei Gasturbinen ist die Mindeststillstandszeit kurz oder null, bei Kernblöcken beträgt sie viele Stunden.</p>
-<p><strong>Wie viele Szenarien?</strong> Zu erwarten ist, dass der Commitment-Plan ab einer gewissen Szenarienzahl stabil bleibt — oft schon bei 20 bis 40. Der Grund: Die erste Stufe ist binär und <strong>grob</strong>; sie kann nur ganze Blockstunden verschieben. Feine Unterschiede in der Szenarienmenge ändern daran nichts mehr.</p>
+<p><strong>17.3 — Wie viele Szenarien?</strong> Zu erwarten ist, dass der Commitment-Plan ab einer gewissen Szenarienzahl stabil bleibt — oft schon bei 20 bis 40. Der Grund: Die erste Stufe ist binär und <strong>grob</strong>; sie kann nur ganze Blockstunden verschieben. Feine Unterschiede in der Szenarienmenge ändern daran nichts mehr.</p>
 <p>Der Zusammenhang mit <a href="prognose.html#sec:prognose-messfalle">Abschnitt 15.6</a> ist der interessante Teil: Dort ging es um die Zahl der <strong>Beobachtungen</strong> bei einer Bewertung, hier um die Zahl der <strong>Szenarien</strong> in einem Modell. Beide Male lautet die Frage nicht „wie viele sind genug?“, sondern „ab wann ändert sich die Antwort nicht mehr?” — und beide Male beantwortet man sie, indem man es ausprobiert, statt eine Faustregel zu übernehmen.</p>
-<p><strong>Der Wert eines Speichers.</strong> Der Speicher braucht Variablen für Ladung, Entladung und Füllstand je Szenario und Stunde, mit der Bilanz <span class="math inline">F_{t} = F_{t-1} + \eta\, L_t - E_t/\eta</span> und Grenzen für Leistung und Kapazität. Er gehört in die <strong>zweite</strong> Stufe: Wann geladen wird, darf sich am Tag selbst entscheiden.</p>
+<p><strong>17.4 — Der Wert eines Speichers.</strong> Der Speicher braucht Variablen für Ladung, Entladung und Füllstand je Szenario und Stunde, mit der Bilanz <span class="math inline">F_{t} = F_{t-1} + \eta\, L_t - E_t/\eta</span> und Grenzen für Leistung und Kapazität. Er gehört in die <strong>zweite</strong> Stufe: Wann geladen wird, darf sich am Tag selbst entscheiden.</p>
 <p>Zu erwarten ist ein deutlicher Rückgang der erwarteten Kosten, und zwar aus zwei Quellen: Er verschiebt Energie aus billigen in teure Stunden <em>und</em> er ersetzt Vorhaltung — ein Speicher ist in Sekunden verfügbar, ein Kernblock in acht Stunden. Der zweite Effekt ist der größere und wird bei einer Betrachtung ohne Szenarien komplett übersehen.</p>
 <p>Der Wert je MWh Kapazität ergibt sich als Kostenersparnis geteilt durch 400 MWh. Er ist mit den Investitionskosten vergleichbar — dieselbe Rechnung wie der Schattenpreis in <a href="lp.html#kap-lp">Kapitel 5</a>, nur über einen ganzen Tag.</p>
-<p><strong>Wenn es größer wird.</strong> Mit 20 Blöcken und 168 Stunden hat die erste Stufe 3 360 Binärvariablen statt 120, und die Szenarienkopplung vervielfacht die kontinuierlichen Variablen. Zu erwarten ist, dass der MIP-Gap nach dem Zeitlimit nicht mehr auf null geht.</p>
+<p><strong>17.5 — Wenn es größer wird.</strong> Mit 20 Blöcken und 168 Stunden hat die erste Stufe 3 360 Binärvariablen statt 120, und die Szenarienkopplung vervielfacht die kontinuierlichen Variablen. Zu erwarten ist, dass der MIP-Gap nach dem Zeitlimit nicht mehr auf null geht.</p>
 <p>Zwei Wege aus <a href="metaheuristiken.html#kap-metaheuristiken">Kapitel 9</a>: <strong>Erstens</strong> — und in der Praxis meist ausreichend — den Gap akzeptieren; 1 bis 2 % sind bei Unit Commitment üblich und betriebswirtschaftlich belanglos. <strong>Zweitens</strong> LNS: Das Commitment eines Tages herausbrechen und exakt neu optimieren, während der Rest der Woche festbleibt. Das ist genau die Struktur aus <code>Large_Neighborhood_Search.py</code> — ein zusammenhängendes Fenster zerstören und mit dem exakten Solver reparieren.</p>
 <p>Was <strong>nicht</strong> funktioniert: eine reine Metaheuristik ohne Solver. Die Fahrweise ist bei gegebenem Commitment ein LP mit tausenden Variablen; die will man nicht heuristisch lösen.</p>
 <h3 id="denkfehler-loesung-supplychain">Finde den Denkfehler — „Wir rechnen mit dem P50-Szenario“</h3>
@@ -1083,13 +1109,13 @@ u_{k,\tau} \le 1 - b_{k,t} \qquad \text{für } \tau = t, \dots, t + M_k - 1
 </ol>
 <hr />
 <h2 id="sec:loesungen-finanzdaten">A.18 Lösungen zu Kapitel „Finanzdaten-Modellierung — Renditen, Kovarianz und Shrinkage“</h2>
-<p><strong>11.1 — Renditeart.</strong> (a) diskret. (b) logarithmisch. (c) logarithmisch (bzw. diskret kumuliert über Produkt). (d) logarithmisch (statistische Eigenschaften).</p>
-<p><strong>11.2 — Mittelwertfalle.</strong> (a) Arithmetisches Mittel: <span class="math inline">(60-40+60-40)/4 = +10\,\%</span>. (b) <span class="math inline">10\,000 \cdot 1{,}6 \cdot 0{,}6 \cdot 1{,}6 \cdot 0{,}6 = 10\,000 \cdot 0{,}9216 = \mathbf{9216\ €}</span> — ein <strong>Verlust</strong>. (c) Geometrisches Mittel: <span class="math inline">0{,}9216^{1/4} - 1 = -2{,}0\,\%</span> p. a. Der Unterschied zwischen <span class="math inline">+10\,\%</span> und <span class="math inline">-2\,\%</span> ist der Grund, warum Fondswerbung gern arithmetische Mittel zeigt.</p>
-<p><strong>11.3 — Konditionszahl.</strong> Erwartetes Muster: Bei <span class="math inline">T = 40 &lt; N = 30</span>… (hier <span class="math inline">T &gt; N</span>, aber knapp): sehr große Konditionszahl, kleinster Eigenwert nahe null. Bei <span class="math inline">T = 100</span>: deutlich besser. Bei <span class="math inline">T = 1000</span>: stabil. Faustregel <span class="math inline">T \ge 5N</span> bis <span class="math inline">10N</span>.</p>
-<p><strong>11.4 — Spaltenreihenfolge.</strong> <code>raw["Close"].columns</code> ist alphabetisch; <code>raw["Close"][tickers]</code> stellt die eigene Reihenfolge her. Existiert ein Ticker nicht, wirft <code>[tickers]</code> einen <code>KeyError</code> — <strong>das ist erwünscht</strong>: lieber ein lauter Fehler als eine stille Verschiebung.</p>
-<p><strong>11.5 — Beide Ziele vergleichen.</strong> Erwartetes Ergebnis: Das Konstant-Korrelations-Ziel schneidet bei Aktien meist etwas besser ab, weil es die unterschiedlichen Einzelvolatilitäten erhält. Der Unterschied ist aber kleiner als der Unterschied zwischen „mit“ und „ohne“ Shrinkage — die Wahl des Ziels ist zweitrangig gegenüber der Entscheidung, überhaupt zu schrumpfen.</p>
-<p><strong>11.6 — Error-Maximizer messen.</strong> (a)/(b) Erwartetes Ergebnis: Die Gleichgewichtung schlägt die Stichproben-Optimierung bis etwa <span class="math inline">T/N \approx 5</span>–10; Ledoit-Wolf schlägt sie schon früher. (c) <strong>Praktische Folgerung:</strong> Bei knapper Datenlage ist 1/N ein ernstzunehmender Kandidat, und jede Optimierung muss sich daran messen lassen.</p>
-<h3 id="finde-den-denkfehler-11.1-das-risikofreie-portfolio">Finde den Denkfehler 11.1 — Das risikofreie Portfolio</h3>
+<p><strong>18.1 — Renditeart.</strong> (a) diskret. (b) logarithmisch. (c) logarithmisch (bzw. diskret kumuliert über Produkt). (d) logarithmisch (statistische Eigenschaften).</p>
+<p><strong>18.2 — Mittelwertfalle.</strong> (a) Arithmetisches Mittel: <span class="math inline">(60-40+60-40)/4 = +10\,\%</span>. (b) <span class="math inline">10\,000 \cdot 1{,}6 \cdot 0{,}6 \cdot 1{,}6 \cdot 0{,}6 = 10\,000 \cdot 0{,}9216 = \mathbf{9216\ €}</span> — ein <strong>Verlust</strong>. (c) Geometrisches Mittel: <span class="math inline">0{,}9216^{1/4} - 1 = -2{,}0\,\%</span> p. a. Der Unterschied zwischen <span class="math inline">+10\,\%</span> und <span class="math inline">-2\,\%</span> ist der Grund, warum Fondswerbung gern arithmetische Mittel zeigt.</p>
+<p><strong>18.3 — Konditionszahl.</strong> Erwartetes Muster: Bei <span class="math inline">T = 40 &lt; N = 30</span>… (hier <span class="math inline">T &gt; N</span>, aber knapp): sehr große Konditionszahl, kleinster Eigenwert nahe null. Bei <span class="math inline">T = 100</span>: deutlich besser. Bei <span class="math inline">T = 1000</span>: stabil. Faustregel <span class="math inline">T \ge 5N</span> bis <span class="math inline">10N</span>.</p>
+<p><strong>18.4 — Spaltenreihenfolge.</strong> <code>raw["Close"].columns</code> ist alphabetisch; <code>raw["Close"][tickers]</code> stellt die eigene Reihenfolge her. Existiert ein Ticker nicht, wirft <code>[tickers]</code> einen <code>KeyError</code> — <strong>das ist erwünscht</strong>: lieber ein lauter Fehler als eine stille Verschiebung.</p>
+<p><strong>18.5 — Beide Ziele vergleichen.</strong> Erwartetes Ergebnis: Das Konstant-Korrelations-Ziel schneidet bei Aktien meist etwas besser ab, weil es die unterschiedlichen Einzelvolatilitäten erhält. Der Unterschied ist aber kleiner als der Unterschied zwischen „mit“ und „ohne“ Shrinkage — die Wahl des Ziels ist zweitrangig gegenüber der Entscheidung, überhaupt zu schrumpfen.</p>
+<p><strong>18.6 — Error-Maximizer messen.</strong> (a)/(b) Erwartetes Ergebnis: Die Gleichgewichtung schlägt die Stichproben-Optimierung bis etwa <span class="math inline">T/N \approx 5</span>–10; Ledoit-Wolf schlägt sie schon früher. (c) <strong>Praktische Folgerung:</strong> Bei knapper Datenlage ist 1/N ein ernstzunehmender Kandidat, und jede Optimierung muss sich daran messen lassen.</p>
+<h3 id="finde-den-denkfehler-das-risikofreie-portfolio">Finde den Denkfehler — Das risikofreie Portfolio</h3>
 <ol type="a">
 <li><strong>Der Rang.</strong> Eine aus <span class="math inline">T</span> Beobachtungen geschätzte Kovarianzmatrix hat höchstens den Rang <span class="math inline">T-1</span> — hier also <strong>19</strong> statt der nötigen 30. Geometrisch heißt das: Die 20 beobachteten Renditevektoren spannen nur einen 19-dimensionalen Unterraum des 30-dimensionalen Anlageraums auf. Es bleiben <strong>11 Richtungen</strong> übrig, über die die Daten schlicht <strong>nichts</strong> aussagen.</li>
 </ol>
@@ -1131,7 +1157,7 @@ u_{k,\tau} \le 1 - b_{k,t} \qquad \text{für } \tau = t, \dots, t + M_k - 1
 </ol>
 <hr />
 <h2 id="sec:loesungen-markowitz">A.19 Lösungen zu Kapitel „Die moderne Portfoliotheorie nach Markowitz“</h2>
-<p><strong>12.1 — Diversifikationseffekt.</strong></p>
+<p><strong>19.1 — Diversifikationseffekt.</strong></p>
 <table>
 <thead>
 <tr class="header">
@@ -1170,13 +1196,13 @@ u_{k,\tau} \le 1 - b_{k,t} \qquad \text{für } \tau = t, \dots, t + M_k - 1
 </table>
 <p>Rechenweg für <span class="math inline">(0{,}5;\ 0{,}5)</span>: <span class="math inline">\sigma_p^2 = 0{,}25\cdot0{,}0625 + 0{,}25\cdot0{,}0144 + 2\cdot0{,}25\cdot(-0{,}2)\cdot0{,}25\cdot0{,}12 = 0{,}015625 + 0{,}0036 - 0{,}003 = 0{,}016225</span>, also <span class="math inline">\sigma_p = 12{,}74\,\%</span>.</p>
 <p>Beste Sharpe Ratio unter den vier Kandidaten: <span class="math inline">(0{,}3;\ 0{,}7)</span>. Das exakte Optimum liegt bei <span class="math inline">w_1 = 0{,}318</span>. <strong>Bemerkenswert:</strong> Die Mischung <span class="math inline">(0{,}3;\ 0{,}7)</span> hat mit 10,08 % eine <strong>geringere</strong> Volatilität als <em>beide</em> Einzeltitel (25 % und 12 %) — genau der Diversifikationseffekt, den die negative Korrelation ermöglicht.</p>
-<p><strong>12.2 — Lambda deuten.</strong> Von <span class="math inline">\lambda=0</span> (GMV, linker unterer Punkt der Kurve) wandert die Lösung entlang der Effizienzgrenze nach rechts oben, bis sie bei <span class="math inline">\lambda\to\infty</span> im Titel mit der höchsten Rendite endet (bzw. an der Positionsobergrenze).</p>
-<p><strong>12.3 — Korn-Transformation.</strong> <span class="math inline">\text{SR}(c\mathbf{w}) = \frac{c\mathbf{w}^\top\boldsymbol{\mu}-r_f}{\sqrt{c^2\mathbf{w}^\top\boldsymbol{\Sigma}\mathbf{w}}}</span> — bei einem Portfolio mit <span class="math inline">\sum w_i = 1</span> und Überrenditen geschrieben als <span class="math inline">\mathbf{w}^\top(\boldsymbol{\mu}-r_f\mathbf{1})</span> kürzt sich <span class="math inline">c</span> heraus. Mit der Bedingung <span class="math inline">\sum w_i = 1</span> ist die Skala jedoch <strong>fixiert</strong>, man kann also nicht frei skalieren. Die Transformation ersetzt diese Bedingung durch <span class="math inline">\sum y_i = \kappa</span> mit freiem <span class="math inline">\kappa</span> und normiert stattdessen die Überrendite auf 1 — dadurch wird die Skala wieder frei und das Problem konvex.</p>
-<p><strong>12.4 — Restriktionen kosten.</strong> Erwartetes Muster: Sharpe Ratio sinkt monoton mit strengerer Grenze. Unlösbar wird es bei <span class="math inline">w_{\max} &lt; 1/n</span> — dann kann die Summe der Gewichte 1 nicht mehr erreicht werden.</p>
-<p><strong>12.5 — Den Sektorfehler nachstellen.</strong> (a) AAPL, AMZN, CVX, GS statt AAPL, MSFT, NVDA, AMZN. (b) Die Gewichte unterscheiden sich deutlich, weil die eigentlich zu begrenzenden Tech-Titel frei laufen. (c) <strong>Nein</strong> — die Kennzahlen sehen völlig plausibel aus. Genau das macht den Fehler so gefährlich.</p>
-<p><strong>12.6 — Kardinalität.</strong> Erwartung: Die Sharpe Ratio sinkt leicht, die Rechenzeit steigt deutlich (MIQP statt QP). Bei <span class="math inline">K \ge 5</span> und <span class="math inline">w_{\max} = 0{,}20</span> ist die Restriktion praktisch nicht mehr bindend.</p>
-<p><strong>12.7 — Out-of-Sample.</strong> Typisches Ergebnis: Max-Sharpe schneidet in der zweiten Hälfte <strong>schlechter</strong> ab als in der ersten — es hat Schätzrauschen mitoptimiert. GMV ist stabiler (keine Renditeprognose nötig), 1/N oft überraschend gut. Mit Ledoit-Wolf verbessern sich GMV und Max-Sharpe spürbar. <strong>Praxisfolgerung:</strong> Renditeprognosen sind viel unzuverlässiger als Risikoschätzungen — Modelle, die ohne sie auskommen, sind robuster.</p>
-<h3 id="finde-den-denkfehler-12.1-zwölf-gleiche-anlagen-ein-sehr-ungleiches-portfolio">Finde den Denkfehler 12.1 — Zwölf gleiche Anlagen, ein sehr ungleiches Portfolio</h3>
+<p><strong>19.2 — Lambda deuten.</strong> Von <span class="math inline">\lambda=0</span> (GMV, linker unterer Punkt der Kurve) wandert die Lösung entlang der Effizienzgrenze nach rechts oben, bis sie bei <span class="math inline">\lambda\to\infty</span> im Titel mit der höchsten Rendite endet (bzw. an der Positionsobergrenze).</p>
+<p><strong>19.3 — Korn-Transformation.</strong> <span class="math inline">\text{SR}(c\mathbf{w}) = \frac{c\mathbf{w}^\top\boldsymbol{\mu}-r_f}{\sqrt{c^2\mathbf{w}^\top\boldsymbol{\Sigma}\mathbf{w}}}</span> — bei einem Portfolio mit <span class="math inline">\sum w_i = 1</span> und Überrenditen geschrieben als <span class="math inline">\mathbf{w}^\top(\boldsymbol{\mu}-r_f\mathbf{1})</span> kürzt sich <span class="math inline">c</span> heraus. Mit der Bedingung <span class="math inline">\sum w_i = 1</span> ist die Skala jedoch <strong>fixiert</strong>, man kann also nicht frei skalieren. Die Transformation ersetzt diese Bedingung durch <span class="math inline">\sum y_i = \kappa</span> mit freiem <span class="math inline">\kappa</span> und normiert stattdessen die Überrendite auf 1 — dadurch wird die Skala wieder frei und das Problem konvex.</p>
+<p><strong>19.4 — Restriktionen kosten.</strong> Erwartetes Muster: Sharpe Ratio sinkt monoton mit strengerer Grenze. Unlösbar wird es bei <span class="math inline">w_{\max} &lt; 1/n</span> — dann kann die Summe der Gewichte 1 nicht mehr erreicht werden.</p>
+<p><strong>19.5 — Den Sektorfehler nachstellen.</strong> (a) AAPL, AMZN, CVX, GS statt AAPL, MSFT, NVDA, AMZN. (b) Die Gewichte unterscheiden sich deutlich, weil die eigentlich zu begrenzenden Tech-Titel frei laufen. (c) <strong>Nein</strong> — die Kennzahlen sehen völlig plausibel aus. Genau das macht den Fehler so gefährlich.</p>
+<p><strong>19.6 — Kardinalität.</strong> Erwartung: Die Sharpe Ratio sinkt leicht, die Rechenzeit steigt deutlich (MIQP statt QP). Bei <span class="math inline">K \ge 5</span> und <span class="math inline">w_{\max} = 0{,}20</span> ist die Restriktion praktisch nicht mehr bindend.</p>
+<p><strong>19.7 — Out-of-Sample.</strong> Typisches Ergebnis: Max-Sharpe schneidet in der zweiten Hälfte <strong>schlechter</strong> ab als in der ersten — es hat Schätzrauschen mitoptimiert. GMV ist stabiler (keine Renditeprognose nötig), 1/N oft überraschend gut. Mit Ledoit-Wolf verbessern sich GMV und Max-Sharpe spürbar. <strong>Praxisfolgerung:</strong> Renditeprognosen sind viel unzuverlässiger als Risikoschätzungen — Modelle, die ohne sie auskommen, sind robuster.</p>
+<h3 id="finde-den-denkfehler-zwölf-gleiche-anlagen-ein-sehr-ungleiches-portfolio">Finde den Denkfehler — Zwölf gleiche Anlagen, ein sehr ungleiches Portfolio</h3>
 <ol type="a">
 <li><strong>Woher die Spanne kommt.</strong> Aus reinem Rauschen. Der Mittelwert von 250 Beobachtungen einer Größe mit Standardabweichung <span class="math inline">\sigma = 1{,}2\,\%</span> hat selbst noch den <strong>Standardfehler</strong></li>
 </ol>
@@ -1207,7 +1233,7 @@ T \ge \left(\frac{2\sigma}{\mu}\right)^2 = \left(\frac{2 \cdot 0{,}012}{0{,}0004
 <ol type="1">
 <li><strong>Renditeschätzung ganz vermeiden.</strong> Das <strong>Minimum-Varianz-Portfolio</strong> minimiert nur <span class="math inline">\mathbf{w}^\top\boldsymbol{\Sigma}\mathbf{w}</span> und braucht überhaupt kein <span class="math inline">\boldsymbol{\mu}</span>. Damit fällt die unzuverlässigste Eingangsgröße ersatzlos weg. Das ist das wirksamste Mittel, weil es das Problem nicht abmildert, sondern <strong>beseitigt</strong> — man kann eine Größe nicht falsch schätzen, die man nicht verwendet.</li>
 <li><strong>Stark schrumpfen.</strong> Wenn Renditen gebraucht werden, zieht man sie kräftig zum Gesamtmittel (James-Stein) oder zu einer Gleichgewichtsannahme (Black-Litterman) — deutlich stärker als bei Kovarianzen, aus den Gründen unter (c).</li>
-<li><strong>Freiheit begrenzen.</strong> Obergrenzen je Position (etwa 15 %), Sektorgrenzen, maximale Abweichung von einer Referenzgewichtung. Was der Optimierer nicht darf, kann er auch nicht auf Rauschen setzen — dasselbe Rezept wie in <a href="#kapitel-11">Denkfehler 11.1</a>.</li>
+<li><strong>Freiheit begrenzen.</strong> Obergrenzen je Position (etwa 15 %), Sektorgrenzen, maximale Abweichung von einer Referenzgewichtung. Was der Optimierer nicht darf, kann er auch nicht auf Rauschen setzen — dasselbe Rezept wie in <a href="finanzdaten.html#sec:finanzdaten-denkfehler">Abschnitt 18.8</a>.</li>
 </ol>
 <p><strong>Und die Kontrollfrage für den Alltag:</strong> Rechnen Sie Ihr Modell mit den Daten des halben Zeitraums und dann mit denen der anderen Hälfte. Wenn die Gewichte dabei stark springen, optimieren Sie Rauschen — unabhängig davon, wie gut die Kennzahlen im Schätzzeitraum aussehen.</p>
 <h3 id="quiz-loesung-markowitz">Micro-Quiz</h3>
@@ -1224,13 +1250,13 @@ T \ge \left(\frac{2\sigma}{\mu}\right)^2 = \left(\frac{2 \cdot 0{,}012}{0{,}0004
 </ol>
 <hr />
 <h2 id="sec:loesungen-cvar">A.20 Lösungen zu Kapitel „Tail-Risiko, CVaR und Transaktionskosten“</h2>
-<p><strong>13.1 — VaR und CVaR von Hand.</strong> Sortierte Verluste: <span class="math inline">-2{,}0; -1{,}2; -0{,}8; -0{,}4; 0{,}3; 0{,}6; 1{,}1; 2{,}1; 5{,}4; 8{,}9</span>. Das 80 %-Quantil ist der 8. Wert: <span class="math inline">\text{VaR}_{80\%} = 2{,}1</span>. $_{80%} = $ Mittel der schlechtesten 20 % <span class="math inline">= (5{,}4+8{,}9)/2 = \mathbf{7{,}15}</span>.</p>
-<p><strong>13.2 — Subadditivität.</strong> Ein Risikomaß sollte Diversifikation nie bestrafen: Das Risiko eines zusammengelegten Portfolios darf nicht größer sein als die Summe der Einzelrisiken. Wird das verletzt, hätte eine Bank einen Anreiz, Portfolios künstlich aufzuspalten, um Eigenkapitalanforderungen zu senken — ökonomisch unsinnig.</p>
-<p><strong>13.3 — Rockafellar-Uryasev nachvollziehen.</strong> (a) Schlechtestes Drittel von <span class="math inline">(1,4,9)</span> ist <span class="math inline">\{9\}</span> → CVaR <span class="math inline">= 9</span>. (b) Mit <span class="math inline">\frac{1}{S(1-\alpha)} = \frac{1}{3\cdot(1/3)} = 1</span>: <span class="math inline">\gamma=0</span>: <span class="math inline">0 + (1+4+9) = 14</span>. <span class="math inline">\gamma=1</span>: <span class="math inline">1 + (0+3+8) = 12</span>. <span class="math inline">\gamma=4</span>: <span class="math inline">4 + (0+0+5) = \mathbf{9}</span>. <span class="math inline">\gamma=5</span>: <span class="math inline">5+4 = 9</span>. <span class="math inline">\gamma=9</span>: <span class="math inline">9+0 = 9</span>. (c) Minimum ab <span class="math inline">\gamma = 4</span> bei <strong>9</strong> — identisch mit (a) ✓. (Das Minimum wird auf einem ganzen Intervall angenommen, weil die Funktion stückweise linear ist — genau der Grund, warum der CVaR nicht <em>streng</em> konvex ist.)</p>
-<p><strong>13.4 — Einheiten prüfen.</strong> In einem Modell, das annualisierte Rendite gegen täglichen CVaR verrechnet, wirkt <span class="math inline">1{,}5</span> effektiv als <span class="math inline">1{,}5/252 \approx 0{,}006</span> auf Tagesbasis — der Risikoterm ist also um Faktor 252 zu leicht gewichtet. Um dieselbe Wirkung wie <code>RISIKOAVERSION = 1.5</code> im konsistenten Tagesmodell zu erzielen, hätte man dort <code>lambda_risk = 1.5 * 252 = 378</code> setzen müssen.</p>
-<p><strong>13.5 — Risikoaversion kalibrieren.</strong> (a) Konkav, ähnlich der Markowitz-Frontier, aber im Rendite-CVaR-Raum. (b) Bei Normalverteilung entspricht CVaR-Optimierung ungefähr der Varianz-Optimierung; die Ergebnisse divergieren umso stärker, je schiefer die Verteilung ist. (c) Empfehlung ohne Fachjargon: „Bei dieser Einstellung liegt der durchschnittliche Verlust an den schlechtesten fünf Prozent der Tage bei X Prozent — bei einer erwarteten Rendite von Y Prozent.“ Das ist entscheidbar; „<span class="math inline">\lambda = 4</span>“ ist es nicht.</p>
-<p><strong>13.6 — Grenze statt Strafe.</strong> (a) Mit engerer Grenze sinkt die erreichbare Rendite; bei <span class="math inline">\tau = 0</span> bleibt das Altportfolio. (b) <strong>Vorteil der Grenze:</strong> garantierte Obergrenze für die Handelsaktivität — wichtig, wenn Liquidität oder Compliance eine harte Schranke verlangen. <strong>Nachteil:</strong> Sie kann das Modell unlösbar machen und ignoriert, dass ein sehr lohnender Trade den Aufwand wert wäre. (c) Strafe bei ökonomischer Abwägung, Grenze bei regulatorischen oder Liquiditätsvorgaben.</p>
-<h3 id="finde-den-denkfehler-13.1-das-risikobudget-das-durch-diversifikation-stieg">Finde den Denkfehler 13.1 — Das Risikobudget, das durch Diversifikation stieg</h3>
+<p><strong>20.1 — VaR und CVaR von Hand.</strong> Sortierte Verluste: <span class="math inline">-2{,}0; -1{,}2; -0{,}8; -0{,}4; 0{,}3; 0{,}6; 1{,}1; 2{,}1; 5{,}4; 8{,}9</span>. Das 80 %-Quantil ist der 8. Wert: <span class="math inline">\text{VaR}_{80\%} = 2{,}1</span>. $_{80%} = $ Mittel der schlechtesten 20 % <span class="math inline">= (5{,}4+8{,}9)/2 = \mathbf{7{,}15}</span>.</p>
+<p><strong>20.2 — Subadditivität.</strong> Ein Risikomaß sollte Diversifikation nie bestrafen: Das Risiko eines zusammengelegten Portfolios darf nicht größer sein als die Summe der Einzelrisiken. Wird das verletzt, hätte eine Bank einen Anreiz, Portfolios künstlich aufzuspalten, um Eigenkapitalanforderungen zu senken — ökonomisch unsinnig.</p>
+<p><strong>20.3 — Rockafellar-Uryasev nachvollziehen.</strong> (a) Schlechtestes Drittel von <span class="math inline">(1,4,9)</span> ist <span class="math inline">\{9\}</span> → CVaR <span class="math inline">= 9</span>. (b) Mit <span class="math inline">\frac{1}{S(1-\alpha)} = \frac{1}{3\cdot(1/3)} = 1</span>: <span class="math inline">\gamma=0</span>: <span class="math inline">0 + (1+4+9) = 14</span>. <span class="math inline">\gamma=1</span>: <span class="math inline">1 + (0+3+8) = 12</span>. <span class="math inline">\gamma=4</span>: <span class="math inline">4 + (0+0+5) = \mathbf{9}</span>. <span class="math inline">\gamma=5</span>: <span class="math inline">5+4 = 9</span>. <span class="math inline">\gamma=9</span>: <span class="math inline">9+0 = 9</span>. (c) Minimum ab <span class="math inline">\gamma = 4</span> bei <strong>9</strong> — identisch mit (a) ✓. (Das Minimum wird auf einem ganzen Intervall angenommen, weil die Funktion stückweise linear ist — genau der Grund, warum der CVaR nicht <em>streng</em> konvex ist.)</p>
+<p><strong>20.4 — Einheiten prüfen.</strong> In einem Modell, das annualisierte Rendite gegen täglichen CVaR verrechnet, wirkt <span class="math inline">1{,}5</span> effektiv als <span class="math inline">1{,}5/252 \approx 0{,}006</span> auf Tagesbasis — der Risikoterm ist also um Faktor 252 zu leicht gewichtet. Um dieselbe Wirkung wie <code>RISIKOAVERSION = 1.5</code> im konsistenten Tagesmodell zu erzielen, hätte man dort <code>lambda_risk = 1.5 * 252 = 378</code> setzen müssen.</p>
+<p><strong>20.5 — Risikoaversion kalibrieren.</strong> (a) Konkav, ähnlich der Markowitz-Frontier, aber im Rendite-CVaR-Raum. (b) Bei Normalverteilung entspricht CVaR-Optimierung ungefähr der Varianz-Optimierung; die Ergebnisse divergieren umso stärker, je schiefer die Verteilung ist. (c) Empfehlung ohne Fachjargon: „Bei dieser Einstellung liegt der durchschnittliche Verlust an den schlechtesten fünf Prozent der Tage bei X Prozent — bei einer erwarteten Rendite von Y Prozent.“ Das ist entscheidbar; „<span class="math inline">\lambda = 4</span>“ ist es nicht.</p>
+<p><strong>20.6 — Grenze statt Strafe.</strong> (a) Mit engerer Grenze sinkt die erreichbare Rendite; bei <span class="math inline">\tau = 0</span> bleibt das Altportfolio. (b) <strong>Vorteil der Grenze:</strong> garantierte Obergrenze für die Handelsaktivität — wichtig, wenn Liquidität oder Compliance eine harte Schranke verlangen. <strong>Nachteil:</strong> Sie kann das Modell unlösbar machen und ignoriert, dass ein sehr lohnender Trade den Aufwand wert wäre. (c) Strafe bei ökonomischer Abwägung, Grenze bei regulatorischen oder Liquiditätsvorgaben.</p>
+<h3 id="finde-den-denkfehler-das-risikobudget-das-durch-diversifikation-stieg">Finde den Denkfehler — Das Risikobudget, das durch Diversifikation stieg</h3>
 <ol type="a">
 <li><strong>Die entscheidende Wahrscheinlichkeit.</strong> Bei zwei unabhängigen Anleihen mit je 4 % Ausfallwahrscheinlichkeit fällt <strong>mindestens eine</strong> aus mit</li>
 </ol>
@@ -1273,13 +1299,13 @@ T \ge \left(\frac{2\sigma}{\mu}\right)^2 = \left(\frac{2 \cdot 0{,}012}{0{,}0004
 </ol>
 <hr />
 <h2 id="sec:loesungen-handelsmaschine">A.21 Lösungen zu Kapitel „Die vollständige quantitative Handelsmaschine“</h2>
-<p><strong>14.1 — Lookahead erkennen.</strong> (a) sauber (<code>:heute</code>). (b) <strong>Lookahead</strong> — gesamter Zeitraum. (c) <strong>Lookahead</strong> — Volatilität über den ganzen Zeitraum enthält Zukunft. (d) sauber — Gewichte aus Daten bis heute, angewendet auf heute (idealerweise auf morgen). (e) <strong>Survivorship-Bias</strong> — das Universum wird danach gefiltert, wer über den gesamten Zeitraum Daten hat.</p>
-<p><strong>14.2 — Kennzahlen deuten.</strong> A: Sharpe <span class="math inline">= (12-2)/22 = 0{,}45</span>, Calmar <span class="math inline">= 12/35 = 0{,}34</span>. B: Sharpe <span class="math inline">= (8-2)/9 = 0{,}67</span>, Calmar <span class="math inline">= 8/12 = 0{,}67</span>. <strong>Empfehlung: B</strong> — für einen Pensionsfonds ist der Drawdown entscheidend, weil laufende Auszahlungen in einer Verlustphase Substanz vernichten. B ist in beiden risikoadjustierten Maßen besser.</p>
-<p><strong>14.3 — Rebalancing-Kalender.</strong> Etwa 25–30 % der Termine fallen aus. Die Kennzahlen ändern sich messbar — in welche Richtung, ist zufällig. Genau das ist der Punkt: Der Fehler verzerrt, ohne aufzufallen.</p>
-<p><strong>14.4 — Rebalancing-Frequenz.</strong> Typisches Muster: Turnover und Kosten steigen etwa linear mit der Frequenz, der Bruttoertrag verbessert sich nur unterproportional. Bei 0,15 % Gebühren ist monatlich meist vertretbar, bei 0,5 % eher quartalsweise. Ein <strong>Toleranzband</strong> (nur handeln bei Abweichung &gt; x %) schlägt fast immer die feste Frequenz.</p>
-<p><strong>14.5 — Krisenverhalten.</strong> Erwartung: Die Überrendite ist selten stabil; oft stammt sie aus wenigen Perioden. Folgerung: Eine gute Gesamtkennzahl kann von einer einzigen glücklichen Phase getragen sein — <strong>immer</strong> nach Teilzeiträumen aufschlüsseln.</p>
-<p><strong>14.6 — Data Snooping messen.</strong> Erwartetes Ergebnis: Die beste In-Sample-Sharpe-Ratio liegt deutlich über dem Mittelwert aller Varianten; auf dem zurückgehaltenen Zeitraum fällt sie Richtung Mittelwert zurück. Die <strong>Differenz zwischen (a) und (c) ist der Selektionseffekt</strong> — genau das, was die Deflated Sharpe Ratio korrigieren soll.</p>
-<h3 id="finde-den-denkfehler-14.1-die-strategie-mit-dem-hochsignifikanten-ergebnis">Finde den Denkfehler 14.1 — Die Strategie mit dem hochsignifikanten Ergebnis</h3>
+<p><strong>21.1 — Lookahead erkennen.</strong> (a) sauber (<code>:heute</code>). (b) <strong>Lookahead</strong> — gesamter Zeitraum. (c) <strong>Lookahead</strong> — Volatilität über den ganzen Zeitraum enthält Zukunft. (d) sauber — Gewichte aus Daten bis heute, angewendet auf heute (idealerweise auf morgen). (e) <strong>Survivorship-Bias</strong> — das Universum wird danach gefiltert, wer über den gesamten Zeitraum Daten hat.</p>
+<p><strong>21.2 — Kennzahlen deuten.</strong> A: Sharpe <span class="math inline">= (12-2)/22 = 0{,}45</span>, Calmar <span class="math inline">= 12/35 = 0{,}34</span>. B: Sharpe <span class="math inline">= (8-2)/9 = 0{,}67</span>, Calmar <span class="math inline">= 8/12 = 0{,}67</span>. <strong>Empfehlung: B</strong> — für einen Pensionsfonds ist der Drawdown entscheidend, weil laufende Auszahlungen in einer Verlustphase Substanz vernichten. B ist in beiden risikoadjustierten Maßen besser.</p>
+<p><strong>21.3 — Rebalancing-Kalender.</strong> Etwa 25–30 % der Termine fallen aus. Die Kennzahlen ändern sich messbar — in welche Richtung, ist zufällig. Genau das ist der Punkt: Der Fehler verzerrt, ohne aufzufallen.</p>
+<p><strong>21.4 — Rebalancing-Frequenz.</strong> Typisches Muster: Turnover und Kosten steigen etwa linear mit der Frequenz, der Bruttoertrag verbessert sich nur unterproportional. Bei 0,15 % Gebühren ist monatlich meist vertretbar, bei 0,5 % eher quartalsweise. Ein <strong>Toleranzband</strong> (nur handeln bei Abweichung &gt; x %) schlägt fast immer die feste Frequenz.</p>
+<p><strong>21.5 — Krisenverhalten.</strong> Erwartung: Die Überrendite ist selten stabil; oft stammt sie aus wenigen Perioden. Folgerung: Eine gute Gesamtkennzahl kann von einer einzigen glücklichen Phase getragen sein — <strong>immer</strong> nach Teilzeiträumen aufschlüsseln.</p>
+<p><strong>21.6 — Data Snooping messen.</strong> Erwartetes Ergebnis: Die beste In-Sample-Sharpe-Ratio liegt deutlich über dem Mittelwert aller Varianten; auf dem zurückgehaltenen Zeitraum fällt sie Richtung Mittelwert zurück. Die <strong>Differenz zwischen (a) und (c) ist der Selektionseffekt</strong> — genau das, was die Deflated Sharpe Ratio korrigieren soll.</p>
+<h3 id="finde-den-denkfehler-die-strategie-mit-dem-hochsignifikanten-ergebnis">Finde den Denkfehler — Die Strategie mit dem hochsignifikanten Ergebnis</h3>
 <ol type="a">
 <li><strong>Warum ein korrekter Backtest wertlos sein kann.</strong> Der Backtest misst genau das, was er messen soll: die Wertentwicklung <em>dieser einen</em> Strategie. Die Frage, die beantwortet werden soll, lautet aber anders — nämlich: <em>„Ist dieses Ergebnis besser, als es Zufall erklären kann?“</em></li>
 </ol>
@@ -1344,13 +1370,14 @@ T \ge \left(\frac{2\sigma}{\mu}\right)^2 = \left(\frac{2 \cdot 0{,}012}{0{,}0004
 </ol>
 <hr />
 <h2 id="sec:loesungen-praxisfallen">A.22 Lösungen zu Kapitel „Praxisfallen und der Weg zum produktiven Einsatz“</h2>
-<p><strong>15.1 — Hart oder weich, revisited.</strong> (a) hart: gesetzliche Ruhezeit, Qualifikationspflicht. (b) weich: individuelle Wunschtage, Vermeidung von Freistunden. (c) diskutabel: Höchstzahl Vertretungsstunden pro Tag (tariflich vs. Notfall), gleichmäßige Wochenendverteilung.</p>
-<p><strong>15.2 — Zeitlimit wählen.</strong> (a) 1–3 s, Gap 5–10 % (Echtzeit schlägt Optimalität). (b) 1–5 min, Gap 1–2 %. (c) Stunden, Gap ~0 % (einmalige, folgenreiche Entscheidung). (d) 30–60 s, Gap 1 % — die Datenunsicherheit ist ohnehin größer.</p>
-<p><strong>15.3 — Relaxation einbauen.</strong> Muster wie in <code>Infeasibility_Diagnose.py</code>: Schlupfvariable je Mindestbesetzung, Strafe deutlich über allen weichen Zielen, aber endlich. Wichtig: <strong>gestaffelte</strong> Strafen, damit der Solver die <em>am wenigsten schmerzhafte</em> Verletzung wählt.</p>
-<p><strong>15.4 — Erklärbarkeit.</strong> Report-Struktur: (1) Zielwert und Aufschlüsselung nach Bestandteilen; (2) je Entscheidung die bindenden Bedingungen; (3) Schattenpreise der knappsten Ressourcen mit Handlungsempfehlung.</p>
-<p><strong>15.5 — Gap gegen Laufzeit.</strong> Erwartetes Muster: Von 10 % auf 2 % kostet wenig Zeit; von 1 % auf 0 % kann die Laufzeit um Größenordnungen steigen, ohne dass sich der Zielwert nennenswert verbessert. Empfehlung: Gap dort ansetzen, wo die Kurve knickt — typischerweise 1–2 %.</p>
-<p><strong>15.6 — Post-Mortem.</strong> Bewertungskriterien: Wird zwischen <strong>Symptom</strong>, <strong>Ursache</strong> und <strong>fehlender Prüfung</strong> unterschieden? Ist die abgeleitete Regel allgemein genug, um beim nächsten Projekt zu helfen (z. B. „Nach jeder Vorzeichenumkehr eine numerische Gegenprobe“), aber konkret genug, um überprüfbar zu sein?</p>
-<h3 id="finde-den-denkfehler-15.1-das-modell-das-seit-einem-jahr-nicht-mehr-optimiert">Finde den Denkfehler 15.1 — Das Modell, das seit einem Jahr nicht mehr optimiert</h3>
+<p><strong>22.1 — Hart oder weich, revisited.</strong> (a) hart: gesetzliche Ruhezeit, Qualifikationspflicht. (b) weich: individuelle Wunschtage, Vermeidung von Freistunden. (c) diskutabel: Höchstzahl Vertretungsstunden pro Tag (tariflich vs. Notfall), gleichmäßige Wochenendverteilung.</p>
+<p><strong>22.2 — Zeitlimit wählen.</strong> (a) 1–3 s, Gap 5–10 % (Echtzeit schlägt Optimalität). (b) 1–5 min, Gap 1–2 %. (c) Stunden, Gap ~0 % (einmalige, folgenreiche Entscheidung). (d) 30–60 s, Gap 1 % — die Datenunsicherheit ist ohnehin größer.</p>
+<p><strong>22.3 — Relaxation einbauen.</strong> Muster wie in <code>Infeasibility_Diagnose.py</code>: Schlupfvariable je Mindestbesetzung, Strafe deutlich über allen weichen Zielen, aber endlich. Wichtig: <strong>gestaffelte</strong> Strafen, damit der Solver die <em>am wenigsten schmerzhafte</em> Verletzung wählt.</p>
+<p><strong>22.4 — Erklärbarkeit.</strong> Report-Struktur: (1) Zielwert und Aufschlüsselung nach Bestandteilen; (2) je Entscheidung die bindenden Bedingungen; (3) Schattenpreise der knappsten Ressourcen mit Handlungsempfehlung.</p>
+<p><strong>22.5 — Den Bericht in die Irre führen.</strong> (a) Der Plan kippt: <em>Rahmen</em> fällt von 47,5 auf <strong>40</strong> — das Minimum aus dem Liefervertrag —, <em>Deckel</em> steigt von 97,5 auf <strong>120</strong>, die Marktgrenze. Der Deckungsbeitrag springt von 3 930 € auf <strong>5 190 €</strong>. Mit ihm wechselt die Engpassstruktur: „Kapazität Lackieren” bindet <strong>nicht mehr</strong>, dafür bindet jetzt „Liefervertrag Rahmen” — und zwar als <em>Kosten</em> von 25 € je Stück, weil der Vertrag zur Herstellung eines inzwischen unattraktiven Produkts zwingt. Alle Schattenpreise steigen deutlich (Träger von 18 € auf 58 €). Der entscheidende Punkt der Aufgabe: Der Satz <em>„Teuerste Bindung ist Liefervertrag Träger”</em> steht <strong>wörtlich unverändert</strong> im Bericht — obwohl die Zahl dahinter sich mehr als verdreifacht hat und ein anderer Engpass die Fabrik begrenzt. Ein Bericht, der sich nicht ändert, ist kein Beweis dafür, dass sich nichts geändert hat. (b) Etwa: <em>„Unter der Annahme eines Deckungsbeitrags von 9 € je Deckel ist ‚Liefervertrag Träger’ die teuerste Bindung (18 € je Stück).”</em> Die Aussage bekommt damit ihre Voraussetzung mit — und wird angreifbar, was sie sein soll. (c) Mindestens eines von beidem: den <strong>Gültigkeitsbereich</strong> jedes Schattenpreises (bis wohin gilt er?), oder das Ergebnis einer <strong>Sensitivitätsrechnung</strong> über die unsichersten Eingangsgrößen — etwa „bei ±20 % Deckungsbeitrag Deckel bleibt die Rangfolge/kippt sie”. Das Programm rechnet den Gültigkeitsbereich für die auffälligste Stellschraube bereits aus; ihn für alle auszuweisen ist eine kleine Erweiterung.</p>
+<p><strong>22.6 — Gap gegen Laufzeit.</strong> Erwartetes Muster: Von 10 % auf 2 % kostet wenig Zeit; von 1 % auf 0 % kann die Laufzeit um Größenordnungen steigen, ohne dass sich der Zielwert nennenswert verbessert. Empfehlung: Gap dort ansetzen, wo die Kurve knickt — typischerweise 1–2 %.</p>
+<p><strong>22.7 — Post-Mortem.</strong> Bewertungskriterien: Wird zwischen <strong>Symptom</strong>, <strong>Ursache</strong> und <strong>fehlender Prüfung</strong> unterschieden? Ist die abgeleitete Regel allgemein genug, um beim nächsten Projekt zu helfen (z. B. „Nach jeder Vorzeichenumkehr eine numerische Gegenprobe“), aber konkret genug, um überprüfbar zu sein?</p>
+<h3 id="finde-den-denkfehler-das-modell-das-seit-einem-jahr-nicht-mehr-optimiert">Finde den Denkfehler — Das Modell, das seit einem Jahr nicht mehr optimiert</h3>
 <ol type="a">
 <li><strong>Warum die konstante Laufzeit das Symptom ist.</strong> Ein Solver, der fertig wird, braucht so lange, wie das Problem eben dauert — und diese Zeit wächst mit den Daten. Eine Laufzeit, die über Jahre exakt bei 3,00 Sekunden liegt, kann deshalb nur eines bedeuten: Der Job wird nicht fertig, sondern <strong>abgeschnitten</strong>.</li>
 </ol>
@@ -1409,13 +1436,15 @@ T \ge \left(\frac{2\sigma}{\mu}\right)^2 = \left(\frac{2 \cdot 0{,}012}{0{,}0004
 <li>Weil die Datenunsicherheit (oft ±10 %) die verbleibende Optimalitätslücke bei Weitem übersteigt.</li>
 <li>Jeder Lauf arbeitet auf einem unveränderlichen, mit ID versehenen Datenstand — nur so sind Ergebnisse reproduzierbar und belegbar.</li>
 <li>Die <strong>Einführung</strong>: mangelnde Akzeptanz, weil Ergebnisse nicht nachvollziehbar sind.</li>
+<li>Sie berührt den Plan, ohne ihn zu verteuern — die Lösung liegt genau auf ihrer Grenze, wäre aber auch ohne sie dieselbe (Entartung). Für eine Nachverhandlung folgt: <strong>nichts tun.</strong> Der Aufwand brächte 0 €. „Bindend” ist ein geometrischer, „teuer” ein wirtschaftlicher Befund.</li>
+<li>Weil der Schattenpreis nur für die <strong>nächste</strong> Einheit gilt und sein Gültigkeitsbereich endet, sobald ein anderer Engpass bindend wird. Realistische Lockerungen sind unterschiedlich groß — eine Sonderschicht bringt 50 Einheiten, ein nachverhandelter Vertrag 10. Der Preis je Einheit sagt daher nichts darüber, welcher Hebel insgesamt am meisten bringt; dafür muss man die Lockerung rechnen, nicht den Preis multiplizieren.</li>
 </ol>
 <hr />
 <p><em>Zurück zum</em> <strong>Wegweiser</strong> <em>oder weiter zu</em> <a href="anhang-modellierungsmuster.html">[Anhang B](anhang-modellierungsmuster.html#anhang-modellierungsmuster) — Modellierungsmuster</a></p>
 <h2 id="sec:loesungen-testing">A.23 Lösungen zu Kapitel „Testen, Messen, Ausliefern“</h2>
-<p><strong>Den Schnellstart reparieren.</strong> Zwei Wege: (a) <strong>Abrunden statt runden</strong> — <code>np.floor</code> statt <code>np.round</code>. Das ist immer zulässig, weil weniger produzieren nie eine Kapazität sprengt, kostet aber Deckungsbeitrag und ist im Allgemeinen <strong>nicht</strong> die optimale ganzzahlige Lösung. (b) <strong>Ganzzahlig modellieren</strong> — <code>linprog(..., integrality=1)</code> bzw. <code>IntVar</code>. Das ist der richtige Weg.</p>
+<p><strong>23.1 — Den Schnellstart reparieren.</strong> Zwei Wege: (a) <strong>Abrunden statt runden</strong> — <code>np.floor</code> statt <code>np.round</code>. Das ist immer zulässig, weil weniger produzieren nie eine Kapazität sprengt, kostet aber Deckungsbeitrag und ist im Allgemeinen <strong>nicht</strong> die optimale ganzzahlige Lösung. (b) <strong>Ganzzahlig modellieren</strong> — <code>linprog(..., integrality=1)</code> bzw. <code>IntVar</code>. Das ist der richtige Weg.</p>
 <p>Warum das ein eigenes Kapitel wert ist (<a href="milp.html#kap-milp">Kapitel 6</a>): Runden ist nicht nur ungenau, sondern kann <em>beliebig</em> danebenliegen. Es gibt Instanzen, bei denen die gerundete LP-Lösung nicht nur suboptimal, sondern unzulässig ist — genau das zeigt der Schnellstart — und andere, bei denen zwischen gerundetem LP und echtem Optimum Welten liegen (<code>Runden_Gegenbeispiel.py</code>).</p>
-<p><strong>Eine Invariante mehr.</strong></p>
+<p><strong>23.2 — Eine Invariante mehr.</strong></p>
 <div class="sourceCode" id="cb19"><pre class="sourceCode python"><code class="sourceCode python"><span id="cb19-1"><a href="#cb19-1" aria-hidden="true" tabindex="-1"></a><span class="kw">def</span> test_kapazitaeten_verdoppeln(bauer):</span>
 <span id="cb19-2"><a href="#cb19-2" aria-hidden="true" tabindex="-1"></a>    problem <span class="op">=</span> schreinerei()</span>
 <span id="cb19-3"><a href="#cb19-3" aria-hidden="true" tabindex="-1"></a>    doppelt <span class="op">=</span> Produktionsproblem(</span>
@@ -1424,14 +1453,14 @@ T \ge \left(\frac{2\sigma}{\mu}\right)^2 = \left(\frac{2 \cdot 0{,}012}{0{,}0004
 <span id="cb19-6"><a href="#cb19-6" aria-hidden="true" tabindex="-1"></a>    basis, gross <span class="op">=</span> bauer(problem), bauer(doppelt)</span>
 <span id="cb19-7"><a href="#cb19-7" aria-hidden="true" tabindex="-1"></a>    <span class="cf">assert</span> gross.zielwert <span class="op">==</span> pytest.approx(<span class="dv">2</span> <span class="op">*</span> basis.zielwert, rel<span class="op">=</span><span class="fl">1e-9</span>)</span></code></pre></div>
 <p>Bei einem <strong>LP</strong> gilt das exakt: Der zulässige Bereich wird um den Faktor 2 gestreckt, und weil die Zielfunktion linear ist, skaliert das Optimum mit. Bei einem <strong>MILP</strong> gilt es nicht: Die Ganzzahligkeitsbedingung skaliert nicht mit. Aus 30,67 wird beim Verdoppeln 61,33 — und ob dazwischen eine bessere ganzzahlige Lösung liegt, hängt vom Einzelfall ab. Der Test wäre dort also falsch.</p>
-<p><strong>Eine eigene Mutation.</strong> Zwei lohnende Kandidaten:</p>
+<p><strong>23.3 — Eine eigene Mutation.</strong> Zwei lohnende Kandidaten:</p>
 <div class="sourceCode" id="cb20"><pre class="sourceCode python"><code class="sourceCode python"><span id="cb20-1"><a href="#cb20-1" aria-hidden="true" tabindex="-1"></a>(<span class="st">&quot;Kapazitaetspruefung mit falschem Vergleich&quot;</span>,</span>
 <span id="cb20-2"><a href="#cb20-2" aria-hidden="true" tabindex="-1"></a> <span class="st">&quot;if ist &gt; grenze + toleranz:&quot;</span>, <span class="st">&quot;if ist &lt; grenze - toleranz:&quot;</span>),</span>
 <span id="cb20-3"><a href="#cb20-3" aria-hidden="true" tabindex="-1"></a>(<span class="st">&quot;Toleranz mit falschem Vorzeichen&quot;</span>,</span>
 <span id="cb20-4"><a href="#cb20-4" aria-hidden="true" tabindex="-1"></a> <span class="st">&quot;if (mengen &lt; -toleranz).any():&quot;</span>, <span class="st">&quot;if (mengen &lt; toleranz).any():&quot;</span>),</span></code></pre></div>
 <p>Die erste wird getötet (<code>test_pruefung_findet_kapazitaetsverletzung</code>). Die zweite ist interessanter: Sie macht die Prüfung <em>strenger</em> statt schwächer — eine Lösung mit einer Menge von exakt 0 würde als negativ beanstandet. Ob sie überlebt, hängt daran, ob die Suite eine Instanz enthält, in der ein Produkt mit Menge 0 vorkommt. In der Schreinerei ist das nicht der Fall — die Mutation überlebt also und zeigt eine echte Lücke: Es fehlt eine Testinstanz, in der ein Produkt nicht produziert wird.</p>
-<p><strong>Der Benchmark mit MILP.</strong> Zu erwarten ist, dass sich die Reihenfolge ändert. Beim reinen LP entscheidet vor allem der Modellaufbau in Python; beim MILP verschiebt sich das Gewicht zum Lösen, und dort spielen die Branch-and-Bound-Heuristiken der Bibliotheken gegeneinander. Die Spalte „Anteil” sollte bei allen deutlich <strong>fallen</strong> — nicht weil der Aufbau schneller würde, sondern weil das Lösen langsamer wird. Genau deshalb steht im Kapitel, dass die Tabelle nichts über MILPs sagt.</p>
-<p><strong>Der Dienst mit Zeitlimit.</strong> Der Modellbauer in <code>or_kern.py</code> nimmt bisher kein Zeitlimit entgegen — das ist der erste Schritt (bei GLOP <code>solver.SetTimeLimit(millisekunden)</code>). Danach im Arbeiter durchreichen und den Status auswerten: Liefert der Solver <code>ZEITLIMIT</code>, ist <code>stand</code> weiterhin <code>gescheitert</code>, aber mit einer anderen Begründung als bei <code>UNZULAESSIG</code> — der Unterschied zwischen „rechne länger” und „ändere das Modell” (<a href="milp.html#kap-milp">Kapitel 6</a>).</p>
+<p><strong>23.4 — Der Benchmark mit MILP.</strong> Zu erwarten ist, dass sich die Reihenfolge ändert. Beim reinen LP entscheidet vor allem der Modellaufbau in Python; beim MILP verschiebt sich das Gewicht zum Lösen, und dort spielen die Branch-and-Bound-Heuristiken der Bibliotheken gegeneinander. Die Spalte „Anteil” sollte bei allen deutlich <strong>fallen</strong> — nicht weil der Aufbau schneller würde, sondern weil das Lösen langsamer wird. Genau deshalb steht im Kapitel, dass die Tabelle nichts über MILPs sagt.</p>
+<p><strong>23.5 — Der Dienst mit Zeitlimit.</strong> Der Modellbauer in <code>or_kern.py</code> nimmt bisher kein Zeitlimit entgegen — das ist der erste Schritt (bei GLOP <code>solver.SetTimeLimit(millisekunden)</code>). Danach im Arbeiter durchreichen und den Status auswerten: Liefert der Solver <code>ZEITLIMIT</code>, ist <code>stand</code> weiterhin <code>gescheitert</code>, aber mit einer anderen Begründung als bei <code>UNZULAESSIG</code> — der Unterschied zwischen „rechne länger” und „ändere das Modell” (<a href="milp.html#kap-milp">Kapitel 6</a>).</p>
 <p>Für den Test braucht es eine Instanz, die das Limit reißt. Ein LP eignet sich schlecht dafür; nehmen Sie ein MILP mit einigen hundert Binärvariablen und ein Limit von 0,1 Sekunden.</p>
 <h3 id="denkfehler-loesung-testing">Finde den Denkfehler — „Die Suite ist grün, das Modell stimmt”</h3>
 <p><strong>Alle Prüfungen benutzen dieselbe falsche Zahl.</strong></p>
diff --git a/OR_HTML_04/anhang-modellierungsmuster.html b/OR_HTML_04/anhang-modellierungsmuster.html
index cad7b2e..5c1fe95 100644
--- a/OR_HTML_04/anhang-modellierungsmuster.html
+++ b/OR_HTML_04/anhang-modellierungsmuster.html
@@ -94,7 +94,7 @@
 </header>
 <div class="site-body">
   <div class="sidebar-overlay" id="sidebar-overlay" hidden></div>
-  <nav class="sidebar" id="sidebar" aria-label="Kapitelnavigation"><div class="sidebar-inhalt"><details class="sidebar-gruppe"><summary>Einstieg</summary><ul><li data-kapitel="vorwort.html"><a href="vorwort.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Vorwort & Lesehilfe</span></a></li><li data-kapitel="notation.html"><a href="notation.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Notation & Abkürzungen</span></a></li></ul></details><details class="sidebar-gruppe"><summary>Teil I: Grundlagen des Operations Research</summary><ul><li data-kapitel="einfuehrung.html"><a href="einfuehrung.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 1: Einführung in Operations Research — Vom Ursprung zur mathematischen Entscheidungsfindung</span></a></li><li data-kapitel="fundament.html"><a href="fundament.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 2: Das mathematische Fundament — Vektoren, Matrizen, Konvexität</span></a></li><li data-kapitel="oekosystem.html"><a href="oekosystem.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 3: Das Python-Ökosystem für OR — Solver, Bindings und Modellierungsschichten</span></a></li><li data-kapitel="modellierung.html"><a href="modellierung.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 4: Vom Management-Wunsch zum Modell</span></a></li></ul></details><details class="sidebar-gruppe"><summary>Teil II: Die Kernverfahren der deterministischen Optimierung</summary><ul><li data-kapitel="lp.html"><a href="lp.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 5: Lineare Programmierung — Simplex, Dualität und Schattenpreise</span></a></li><li data-kapitel="milp.html"><a href="milp.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 6: Gemischt-ganzzahlige Optimierung — Diskrete Entscheidungen und Branch-and-Bound</span></a></li><li data-kapitel="cpsat.html"><a href="cpsat.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 7: Constraint Programming mit CP-SAT — Logik, Scheduling und Zuweisung</span></a></li><li data-kapitel="graphen.html"><a href="graphen.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 8: Graphen, Flüsse und Touren — Min-Cost-Flow, Matching und VRP</span></a></li><li data-kapitel="metaheuristiken.html"><a href="metaheuristiken.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 9: Metaheuristiken — wenn der exakte Solver aussteigt</span></a></li><li data-kapitel="dekomposition.html"><a href="dekomposition.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 10: Spaltengenerierung — das Modell umbauen statt die Lösung raten</span></a></li></ul></details><details class="sidebar-gruppe"><summary>Teil III: Nichtlinearität, Unsicherheit und mehrperiodige Dynamik</summary><ul><li data-kapitel="qp-nlp.html"><a href="qp-nlp.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 11: Quadratische und nichtlineare Optimierung — KKT, Lagrange, Konvexität</span></a></li><li data-kapitel="unsicherheit.html"><a href="unsicherheit.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 12: Optimierung unter Unsicherheit — Monte-Carlo, Stochastik, Robustheit</span></a></li><li data-kapitel="dynamische-programmierung.html"><a href="dynamische-programmierung.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 13: Dynamische Programmierung — Die Bellman-Gleichung und Order-Execution</span></a></li><li data-kapitel="mehrziel.html"><a href="mehrziel.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 14: Mehrere Ziele — Pareto-Fronten statt Gewichte</span></a></li><li data-kapitel="prognose.html"><a href="prognose.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 15: Predict-then-Optimize — die bessere Prognose, die schlechtere Entscheidung</span></a></li></ul></details><details class="sidebar-gruppe"><summary>Teil IV: Anwendungen — Energiewirtschaft und Finanzmärkte</summary><ul><li data-kapitel="bruecke.html"><a href="bruecke.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 16: Die Strukturbrücke — dieselbe Mathematik, zwei Welten</span></a></li><li data-kapitel="supplychain.html"><a href="supplychain.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 17: Supply-Chain und Energieeinsatz unter Unsicherheit</span></a></li><li data-kapitel="finanzdaten.html"><a href="finanzdaten.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 18: Finanzdaten-Modellierung — Renditen, Kovarianz und Shrinkage</span></a></li><li data-kapitel="markowitz.html"><a href="markowitz.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 19: Die moderne Portfoliotheorie nach Markowitz</span></a></li><li data-kapitel="cvar.html"><a href="cvar.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 20: Tail-Risiko, CVaR und Transaktionskosten</span></a></li><li data-kapitel="handelsmaschine.html"><a href="handelsmaschine.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 21: Die vollständige quantitative Handelsmaschine</span></a></li></ul></details><details class="sidebar-gruppe"><summary>Teil V: Praxis</summary><ul><li data-kapitel="praxisfallen.html"><a href="praxisfallen.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 22: Praxisfallen und der Weg zum produktiven Einsatz</span></a></li><li data-kapitel="testing.html"><a href="testing.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 23: Testen, Messen, Ausliefern</span></a></li><li data-kapitel="projektwerkstatt.html"><a href="projektwerkstatt.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Projektwerkstatt</span></a></li></ul></details><details class="sidebar-gruppe" open><summary>Anhänge</summary><ul><li data-kapitel="anhang-loesungen.html"><a href="anhang-loesungen.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Anhang A: Lösungen zu allen Übungsaufgaben</span></a></li><li data-kapitel="anhang-modellierungsmuster.html" class="aktiv"><a href="anhang-modellierungsmuster.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Anhang B: Katalog der Modellierungsmuster</span></a></li><li data-kapitel="anhang-fehlerdiagnose.html"><a href="anhang-fehlerdiagnose.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Anhang C: Fehlerdiagnose-Handbuch</span></a></li><li data-kapitel="anhang-spickzettel.html"><a href="anhang-spickzettel.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Anhang D: Spickzettel der Solver</span></a></li><li data-kapitel="anhang-glossar-literatur.html"><a href="anhang-glossar-literatur.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Anhang E: Glossar und Literatur</span></a></li></ul></details><ul class="sidebar-extra"><li><a href="programme.html"><svg class="icon" aria-hidden="true"><use href="#icon-book"></use></svg> Beispielprogramme</a></li><li><a href="stichwortverzeichnis.html"><svg class="icon" aria-hidden="true"><use href="#icon-search"></use></svg> Stichwortverzeichnis</a></li><li><a href="gesamtdokument.html"><svg class="icon" aria-hidden="true"><use href="#icon-external-link"></use></svg> Gesamtdokument (eine Seite)</a></li><li><a href="Operations_Research_mit_Python_Version_04.pdf" download><svg class="icon" aria-hidden="true"><use href="#icon-download"></use></svg> Download als PDF</a></li></ul></div></nav>
+  <nav class="sidebar" id="sidebar" aria-label="Kapitelnavigation"><div class="sidebar-inhalt"><details class="sidebar-gruppe"><summary>Einstieg</summary><ul><li data-kapitel="vorwort.html"><a href="vorwort.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Vorwort & Lesehilfe</span></a></li><li data-kapitel="notation.html"><a href="notation.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Notation & Abkürzungen</span></a></li></ul></details><details class="sidebar-gruppe"><summary>Teil I: Grundlagen des Operations Research</summary><ul><li data-kapitel="einfuehrung.html"><a href="einfuehrung.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 1: Einführung in Operations Research — Vom Ursprung zur mathematischen Entscheidungsfindung</span></a></li><li data-kapitel="fundament.html"><a href="fundament.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 2: Das mathematische Fundament — Vektoren, Matrizen, Konvexität</span></a></li><li data-kapitel="oekosystem.html"><a href="oekosystem.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 3: Das Python-Ökosystem für OR — Solver, Bindings und Modellierungsschichten</span></a></li><li data-kapitel="modellierung.html"><a href="modellierung.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 4: Vom Management-Wunsch zum Modell</span></a></li><li data-kapitel="synthese-grundlagen.html"><a href="synthese-grundlagen.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Synthese Teil I</span></a></li></ul></details><details class="sidebar-gruppe"><summary>Teil II: Die Kernverfahren der deterministischen Optimierung</summary><ul><li data-kapitel="lp.html"><a href="lp.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 5: Lineare Programmierung — Simplex, Dualität und Schattenpreise</span></a></li><li data-kapitel="milp.html"><a href="milp.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 6: Gemischt-ganzzahlige Optimierung — Diskrete Entscheidungen und Branch-and-Bound</span></a></li><li data-kapitel="cpsat.html"><a href="cpsat.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 7: Constraint Programming mit CP-SAT — Logik, Scheduling und Zuweisung</span></a></li><li data-kapitel="graphen.html"><a href="graphen.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 8: Graphen, Flüsse und Touren — Min-Cost-Flow, Matching und VRP</span></a></li><li data-kapitel="metaheuristiken.html"><a href="metaheuristiken.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 9: Metaheuristiken — wenn der exakte Solver aussteigt</span></a></li><li data-kapitel="dekomposition.html"><a href="dekomposition.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 10: Spaltengenerierung — das Modell umbauen statt die Lösung raten</span></a></li><li data-kapitel="synthese-kernverfahren.html"><a href="synthese-kernverfahren.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Synthese Teil II</span></a></li></ul></details><details class="sidebar-gruppe"><summary>Teil III: Nichtlinearität, Unsicherheit und mehrperiodige Dynamik</summary><ul><li data-kapitel="qp-nlp.html"><a href="qp-nlp.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 11: Quadratische und nichtlineare Optimierung — KKT, Lagrange, Konvexität</span></a></li><li data-kapitel="unsicherheit.html"><a href="unsicherheit.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 12: Optimierung unter Unsicherheit — Monte-Carlo, Stochastik, Robustheit</span></a></li><li data-kapitel="dynamische-programmierung.html"><a href="dynamische-programmierung.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 13: Dynamische Programmierung — Die Bellman-Gleichung und Order-Execution</span></a></li><li data-kapitel="mehrziel.html"><a href="mehrziel.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 14: Mehrere Ziele — Pareto-Fronten statt Gewichte</span></a></li><li data-kapitel="prognose.html"><a href="prognose.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 15: Predict-then-Optimize — die bessere Prognose, die schlechtere Entscheidung</span></a></li><li data-kapitel="synthese-nichtlinear.html"><a href="synthese-nichtlinear.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Synthese Teil III</span></a></li></ul></details><details class="sidebar-gruppe"><summary>Teil IV: Anwendungen — Energiewirtschaft und Finanzmärkte</summary><ul><li data-kapitel="bruecke.html"><a href="bruecke.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 16: Die Strukturbrücke — dieselbe Mathematik, zwei Welten</span></a></li><li data-kapitel="supplychain.html"><a href="supplychain.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 17: Supply-Chain und Energieeinsatz unter Unsicherheit</span></a></li><li data-kapitel="finanzdaten.html"><a href="finanzdaten.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 18: Finanzdaten-Modellierung — Renditen, Kovarianz und Shrinkage</span></a></li><li data-kapitel="markowitz.html"><a href="markowitz.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 19: Die moderne Portfoliotheorie nach Markowitz</span></a></li><li data-kapitel="cvar.html"><a href="cvar.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 20: Tail-Risiko, CVaR und Transaktionskosten</span></a></li><li data-kapitel="handelsmaschine.html"><a href="handelsmaschine.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 21: Die vollständige quantitative Handelsmaschine</span></a></li><li data-kapitel="synthese-anwendungen.html"><a href="synthese-anwendungen.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Synthese Teil IV</span></a></li></ul></details><details class="sidebar-gruppe"><summary>Teil V: Praxis</summary><ul><li data-kapitel="praxisfallen.html"><a href="praxisfallen.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 22: Praxisfallen und der Weg zum produktiven Einsatz</span></a></li><li data-kapitel="testing.html"><a href="testing.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 23: Testen, Messen, Ausliefern</span></a></li><li data-kapitel="synthese-praxis.html"><a href="synthese-praxis.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Synthese Teil V</span></a></li><li data-kapitel="projektwerkstatt.html"><a href="projektwerkstatt.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Projektwerkstatt</span></a></li></ul></details><details class="sidebar-gruppe" open><summary>Anhänge</summary><ul><li data-kapitel="anhang-loesungen.html"><a href="anhang-loesungen.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Anhang A: Lösungen zu allen Übungsaufgaben</span></a></li><li data-kapitel="anhang-modellierungsmuster.html" class="aktiv"><a href="anhang-modellierungsmuster.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Anhang B: Katalog der Modellierungsmuster</span></a></li><li data-kapitel="anhang-fehlerdiagnose.html"><a href="anhang-fehlerdiagnose.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Anhang C: Fehlerdiagnose-Handbuch</span></a></li><li data-kapitel="anhang-spickzettel.html"><a href="anhang-spickzettel.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Anhang D: Spickzettel der Solver</span></a></li><li data-kapitel="anhang-glossar-literatur.html"><a href="anhang-glossar-literatur.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Anhang E: Glossar und Literatur</span></a></li></ul></details><ul class="sidebar-extra"><li><a href="programme.html"><svg class="icon" aria-hidden="true"><use href="#icon-book"></use></svg> Beispielprogramme</a></li><li><a href="stichwortverzeichnis.html"><svg class="icon" aria-hidden="true"><use href="#icon-search"></use></svg> Stichwortverzeichnis</a></li><li><a href="gesamtdokument.html"><svg class="icon" aria-hidden="true"><use href="#icon-external-link"></use></svg> Gesamtdokument (eine Seite)</a></li><li><a href="Operations_Research_mit_Python_Version_04.pdf" download><svg class="icon" aria-hidden="true"><use href="#icon-download"></use></svg> Download als PDF</a></li></ul></div></nav>
   <main class="content">
     <nav class="breadcrumb" aria-label="Breadcrumb"><a href="index.html">Start</a> › <span>Anhang B: Katalog der Modellierungsmuster</span></nav>
     <nav class="prev-next"><a class="prev-next-knopf prev-next-prev" href="anhang-loesungen.html"><svg class="icon" aria-hidden="true"><use href="#icon-chevron-left"></use></svg><span><small>Zurück</small>Anhang A: Lösungen zu allen Übungsaufgaben</span></a><a class="prev-next-knopf prev-next-next" href="anhang-fehlerdiagnose.html"><span><small>Weiter</small>Anhang C: Fehlerdiagnose-Handbuch</span><svg class="icon" aria-hidden="true"><use href="#icon-chevron-right"></use></svg></a></nav>
@@ -316,6 +316,7 @@
 </tbody>
 </table>
 <blockquote>
+<p><strong>Umgekehrte Richtung:</strong> Wer von einem Satz aus der Besprechung kommt und das Muster sucht, findet in <a href="modellierung.html#sec:modellierung-glossar">Abschnitt 4.6</a> ein Lexikon, das genau so herum aufgebaut ist — und die Wendungen benennt, bei denen es keine eindeutige Übersetzung gibt.</p>
 <p>Die Spalte „Wo im Buch“ nennt das Kapitel, in dem das Muster <strong>im Zusammenhang</strong> vorkommt — nicht die einzige Stelle, an der es taugt. Die Nummern entstehen beim Bauen; im Quelltext dieses Anhangs steht keine einzige.</p>
 </blockquote>
 <hr />
diff --git a/OR_HTML_04/anhang-spickzettel.html b/OR_HTML_04/anhang-spickzettel.html
index c232248..c57927e 100644
--- a/OR_HTML_04/anhang-spickzettel.html
+++ b/OR_HTML_04/anhang-spickzettel.html
@@ -94,7 +94,7 @@
 </header>
 <div class="site-body">
   <div class="sidebar-overlay" id="sidebar-overlay" hidden></div>
-  <nav class="sidebar" id="sidebar" aria-label="Kapitelnavigation"><div class="sidebar-inhalt"><details class="sidebar-gruppe"><summary>Einstieg</summary><ul><li data-kapitel="vorwort.html"><a href="vorwort.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Vorwort & Lesehilfe</span></a></li><li data-kapitel="notation.html"><a href="notation.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Notation & Abkürzungen</span></a></li></ul></details><details class="sidebar-gruppe"><summary>Teil I: Grundlagen des Operations Research</summary><ul><li data-kapitel="einfuehrung.html"><a href="einfuehrung.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 1: Einführung in Operations Research — Vom Ursprung zur mathematischen Entscheidungsfindung</span></a></li><li data-kapitel="fundament.html"><a href="fundament.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 2: Das mathematische Fundament — Vektoren, Matrizen, Konvexität</span></a></li><li data-kapitel="oekosystem.html"><a href="oekosystem.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 3: Das Python-Ökosystem für OR — Solver, Bindings und Modellierungsschichten</span></a></li><li data-kapitel="modellierung.html"><a href="modellierung.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 4: Vom Management-Wunsch zum Modell</span></a></li></ul></details><details class="sidebar-gruppe"><summary>Teil II: Die Kernverfahren der deterministischen Optimierung</summary><ul><li data-kapitel="lp.html"><a href="lp.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 5: Lineare Programmierung — Simplex, Dualität und Schattenpreise</span></a></li><li data-kapitel="milp.html"><a href="milp.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 6: Gemischt-ganzzahlige Optimierung — Diskrete Entscheidungen und Branch-and-Bound</span></a></li><li data-kapitel="cpsat.html"><a href="cpsat.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 7: Constraint Programming mit CP-SAT — Logik, Scheduling und Zuweisung</span></a></li><li data-kapitel="graphen.html"><a href="graphen.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 8: Graphen, Flüsse und Touren — Min-Cost-Flow, Matching und VRP</span></a></li><li data-kapitel="metaheuristiken.html"><a href="metaheuristiken.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 9: Metaheuristiken — wenn der exakte Solver aussteigt</span></a></li><li data-kapitel="dekomposition.html"><a href="dekomposition.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 10: Spaltengenerierung — das Modell umbauen statt die Lösung raten</span></a></li></ul></details><details class="sidebar-gruppe"><summary>Teil III: Nichtlinearität, Unsicherheit und mehrperiodige Dynamik</summary><ul><li data-kapitel="qp-nlp.html"><a href="qp-nlp.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 11: Quadratische und nichtlineare Optimierung — KKT, Lagrange, Konvexität</span></a></li><li data-kapitel="unsicherheit.html"><a href="unsicherheit.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 12: Optimierung unter Unsicherheit — Monte-Carlo, Stochastik, Robustheit</span></a></li><li data-kapitel="dynamische-programmierung.html"><a href="dynamische-programmierung.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 13: Dynamische Programmierung — Die Bellman-Gleichung und Order-Execution</span></a></li><li data-kapitel="mehrziel.html"><a href="mehrziel.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 14: Mehrere Ziele — Pareto-Fronten statt Gewichte</span></a></li><li data-kapitel="prognose.html"><a href="prognose.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 15: Predict-then-Optimize — die bessere Prognose, die schlechtere Entscheidung</span></a></li></ul></details><details class="sidebar-gruppe"><summary>Teil IV: Anwendungen — Energiewirtschaft und Finanzmärkte</summary><ul><li data-kapitel="bruecke.html"><a href="bruecke.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 16: Die Strukturbrücke — dieselbe Mathematik, zwei Welten</span></a></li><li data-kapitel="supplychain.html"><a href="supplychain.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 17: Supply-Chain und Energieeinsatz unter Unsicherheit</span></a></li><li data-kapitel="finanzdaten.html"><a href="finanzdaten.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 18: Finanzdaten-Modellierung — Renditen, Kovarianz und Shrinkage</span></a></li><li data-kapitel="markowitz.html"><a href="markowitz.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 19: Die moderne Portfoliotheorie nach Markowitz</span></a></li><li data-kapitel="cvar.html"><a href="cvar.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 20: Tail-Risiko, CVaR und Transaktionskosten</span></a></li><li data-kapitel="handelsmaschine.html"><a href="handelsmaschine.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 21: Die vollständige quantitative Handelsmaschine</span></a></li></ul></details><details class="sidebar-gruppe"><summary>Teil V: Praxis</summary><ul><li data-kapitel="praxisfallen.html"><a href="praxisfallen.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 22: Praxisfallen und der Weg zum produktiven Einsatz</span></a></li><li data-kapitel="testing.html"><a href="testing.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 23: Testen, Messen, Ausliefern</span></a></li><li data-kapitel="projektwerkstatt.html"><a href="projektwerkstatt.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Projektwerkstatt</span></a></li></ul></details><details class="sidebar-gruppe" open><summary>Anhänge</summary><ul><li data-kapitel="anhang-loesungen.html"><a href="anhang-loesungen.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Anhang A: Lösungen zu allen Übungsaufgaben</span></a></li><li data-kapitel="anhang-modellierungsmuster.html"><a href="anhang-modellierungsmuster.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Anhang B: Katalog der Modellierungsmuster</span></a></li><li data-kapitel="anhang-fehlerdiagnose.html"><a href="anhang-fehlerdiagnose.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Anhang C: Fehlerdiagnose-Handbuch</span></a></li><li data-kapitel="anhang-spickzettel.html" class="aktiv"><a href="anhang-spickzettel.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Anhang D: Spickzettel der Solver</span></a></li><li data-kapitel="anhang-glossar-literatur.html"><a href="anhang-glossar-literatur.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Anhang E: Glossar und Literatur</span></a></li></ul></details><ul class="sidebar-extra"><li><a href="programme.html"><svg class="icon" aria-hidden="true"><use href="#icon-book"></use></svg> Beispielprogramme</a></li><li><a href="stichwortverzeichnis.html"><svg class="icon" aria-hidden="true"><use href="#icon-search"></use></svg> Stichwortverzeichnis</a></li><li><a href="gesamtdokument.html"><svg class="icon" aria-hidden="true"><use href="#icon-external-link"></use></svg> Gesamtdokument (eine Seite)</a></li><li><a href="Operations_Research_mit_Python_Version_04.pdf" download><svg class="icon" aria-hidden="true"><use href="#icon-download"></use></svg> Download als PDF</a></li></ul></div></nav>
+  <nav class="sidebar" id="sidebar" aria-label="Kapitelnavigation"><div class="sidebar-inhalt"><details class="sidebar-gruppe"><summary>Einstieg</summary><ul><li data-kapitel="vorwort.html"><a href="vorwort.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Vorwort & Lesehilfe</span></a></li><li data-kapitel="notation.html"><a href="notation.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Notation & Abkürzungen</span></a></li></ul></details><details class="sidebar-gruppe"><summary>Teil I: Grundlagen des Operations Research</summary><ul><li data-kapitel="einfuehrung.html"><a href="einfuehrung.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 1: Einführung in Operations Research — Vom Ursprung zur mathematischen Entscheidungsfindung</span></a></li><li data-kapitel="fundament.html"><a href="fundament.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 2: Das mathematische Fundament — Vektoren, Matrizen, Konvexität</span></a></li><li data-kapitel="oekosystem.html"><a href="oekosystem.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 3: Das Python-Ökosystem für OR — Solver, Bindings und Modellierungsschichten</span></a></li><li data-kapitel="modellierung.html"><a href="modellierung.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 4: Vom Management-Wunsch zum Modell</span></a></li><li data-kapitel="synthese-grundlagen.html"><a href="synthese-grundlagen.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Synthese Teil I</span></a></li></ul></details><details class="sidebar-gruppe"><summary>Teil II: Die Kernverfahren der deterministischen Optimierung</summary><ul><li data-kapitel="lp.html"><a href="lp.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 5: Lineare Programmierung — Simplex, Dualität und Schattenpreise</span></a></li><li data-kapitel="milp.html"><a href="milp.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 6: Gemischt-ganzzahlige Optimierung — Diskrete Entscheidungen und Branch-and-Bound</span></a></li><li data-kapitel="cpsat.html"><a href="cpsat.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 7: Constraint Programming mit CP-SAT — Logik, Scheduling und Zuweisung</span></a></li><li data-kapitel="graphen.html"><a href="graphen.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 8: Graphen, Flüsse und Touren — Min-Cost-Flow, Matching und VRP</span></a></li><li data-kapitel="metaheuristiken.html"><a href="metaheuristiken.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 9: Metaheuristiken — wenn der exakte Solver aussteigt</span></a></li><li data-kapitel="dekomposition.html"><a href="dekomposition.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 10: Spaltengenerierung — das Modell umbauen statt die Lösung raten</span></a></li><li data-kapitel="synthese-kernverfahren.html"><a href="synthese-kernverfahren.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Synthese Teil II</span></a></li></ul></details><details class="sidebar-gruppe"><summary>Teil III: Nichtlinearität, Unsicherheit und mehrperiodige Dynamik</summary><ul><li data-kapitel="qp-nlp.html"><a href="qp-nlp.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 11: Quadratische und nichtlineare Optimierung — KKT, Lagrange, Konvexität</span></a></li><li data-kapitel="unsicherheit.html"><a href="unsicherheit.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 12: Optimierung unter Unsicherheit — Monte-Carlo, Stochastik, Robustheit</span></a></li><li data-kapitel="dynamische-programmierung.html"><a href="dynamische-programmierung.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 13: Dynamische Programmierung — Die Bellman-Gleichung und Order-Execution</span></a></li><li data-kapitel="mehrziel.html"><a href="mehrziel.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 14: Mehrere Ziele — Pareto-Fronten statt Gewichte</span></a></li><li data-kapitel="prognose.html"><a href="prognose.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 15: Predict-then-Optimize — die bessere Prognose, die schlechtere Entscheidung</span></a></li><li data-kapitel="synthese-nichtlinear.html"><a href="synthese-nichtlinear.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Synthese Teil III</span></a></li></ul></details><details class="sidebar-gruppe"><summary>Teil IV: Anwendungen — Energiewirtschaft und Finanzmärkte</summary><ul><li data-kapitel="bruecke.html"><a href="bruecke.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 16: Die Strukturbrücke — dieselbe Mathematik, zwei Welten</span></a></li><li data-kapitel="supplychain.html"><a href="supplychain.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 17: Supply-Chain und Energieeinsatz unter Unsicherheit</span></a></li><li data-kapitel="finanzdaten.html"><a href="finanzdaten.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 18: Finanzdaten-Modellierung — Renditen, Kovarianz und Shrinkage</span></a></li><li data-kapitel="markowitz.html"><a href="markowitz.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 19: Die moderne Portfoliotheorie nach Markowitz</span></a></li><li data-kapitel="cvar.html"><a href="cvar.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 20: Tail-Risiko, CVaR und Transaktionskosten</span></a></li><li data-kapitel="handelsmaschine.html"><a href="handelsmaschine.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 21: Die vollständige quantitative Handelsmaschine</span></a></li><li data-kapitel="synthese-anwendungen.html"><a href="synthese-anwendungen.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Synthese Teil IV</span></a></li></ul></details><details class="sidebar-gruppe"><summary>Teil V: Praxis</summary><ul><li data-kapitel="praxisfallen.html"><a href="praxisfallen.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 22: Praxisfallen und der Weg zum produktiven Einsatz</span></a></li><li data-kapitel="testing.html"><a href="testing.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 23: Testen, Messen, Ausliefern</span></a></li><li data-kapitel="synthese-praxis.html"><a href="synthese-praxis.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Synthese Teil V</span></a></li><li data-kapitel="projektwerkstatt.html"><a href="projektwerkstatt.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Projektwerkstatt</span></a></li></ul></details><details class="sidebar-gruppe" open><summary>Anhänge</summary><ul><li data-kapitel="anhang-loesungen.html"><a href="anhang-loesungen.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Anhang A: Lösungen zu allen Übungsaufgaben</span></a></li><li data-kapitel="anhang-modellierungsmuster.html"><a href="anhang-modellierungsmuster.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Anhang B: Katalog der Modellierungsmuster</span></a></li><li data-kapitel="anhang-fehlerdiagnose.html"><a href="anhang-fehlerdiagnose.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Anhang C: Fehlerdiagnose-Handbuch</span></a></li><li data-kapitel="anhang-spickzettel.html" class="aktiv"><a href="anhang-spickzettel.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Anhang D: Spickzettel der Solver</span></a></li><li data-kapitel="anhang-glossar-literatur.html"><a href="anhang-glossar-literatur.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Anhang E: Glossar und Literatur</span></a></li></ul></details><ul class="sidebar-extra"><li><a href="programme.html"><svg class="icon" aria-hidden="true"><use href="#icon-book"></use></svg> Beispielprogramme</a></li><li><a href="stichwortverzeichnis.html"><svg class="icon" aria-hidden="true"><use href="#icon-search"></use></svg> Stichwortverzeichnis</a></li><li><a href="gesamtdokument.html"><svg class="icon" aria-hidden="true"><use href="#icon-external-link"></use></svg> Gesamtdokument (eine Seite)</a></li><li><a href="Operations_Research_mit_Python_Version_04.pdf" download><svg class="icon" aria-hidden="true"><use href="#icon-download"></use></svg> Download als PDF</a></li></ul></div></nav>
   <main class="content">
     <nav class="breadcrumb" aria-label="Breadcrumb"><a href="index.html">Start</a> › <span>Anhang D: Spickzettel der Solver</span></nav>
     <nav class="prev-next"><a class="prev-next-knopf prev-next-prev" href="anhang-fehlerdiagnose.html"><svg class="icon" aria-hidden="true"><use href="#icon-chevron-left"></use></svg><span><small>Zurück</small>Anhang C: Fehlerdiagnose-Handbuch</span></a><a class="prev-next-knopf prev-next-next" href="anhang-glossar-literatur.html"><span><small>Weiter</small>Anhang E: Glossar und Literatur</span><svg class="icon" aria-hidden="true"><use href="#icon-chevron-right"></use></svg></a></nav>
diff --git a/OR_HTML_04/assets/programme.js b/OR_HTML_04/assets/programme.js
index 5c39e70..1d8d3b6 100644
--- a/OR_HTML_04/assets/programme.js
+++ b/OR_HTML_04/assets/programme.js
@@ -1 +1 @@
-window.OR_PROGRAMME = ["Backtest_Fallen.py", "Bausteine_Vorlage.py", "Bellman_Minimalbeispiel.py", "Benchmark_Skalierung.py", "Betriebsueberwachung.py", "Big_M_Falle.py", "Bot_Allokation.py", "Brute_Force_Vergleich.py", "CP_SAT_Statusfaelle.py", "CP_SAT_Vertretungssystem.py", "CVaR_Portfolio.py", "Chance_Constraints.py", "Data_Snooping.py", "Diversifikation_Demo.py", "Dualitaet_Nachweis.py", "Ein_System_Vier_Ansaetze.py", "Entropie_Maximierte_Allokation.py", "Erklaerbarkeit.py", "Excel_Bruecke.py", "Finanzdaten_Ledoit_Wolf.py", "Fluch_des_Durchschnitts.py", "Infeasibility_Diagnose.py", "Installationstest.py", "JobShop_Intervalle.py", "KKT_Nachweis.py", "Konfliktsuche.py", "Konvexitaet_Demo.py", "Kovarianz_Falle.py", "Kraftwerkseinsatz.py", "Large_Neighborhood_Search.py", "Lokale_Optima_Multistart.py", "MILP_Portfolio_Fixgebuehren.py", "Markowitz_CVXPY.py", "Matrixform.py", "Mehrperiodige_Order_Execution.py", "Mehrziel_Pareto.py", "Metaheuristik_vs_Exakt.py", "Min_Cost_Flow.py", "Modellierungsschichten.py", "Monte_Carlo.py", "Mutationstest.py", "Optimierungsdienst.py", "Predict_then_Optimize.py", "Propagation_Demo.py", "QP_Grundlagen.py", "QuantitativeTradingEngine.py", "Renditen_Vergleich.py", "Renditeschaetzung_Falle.py", "Robuste_Optimierung.py", "Rucksack.py", "Runden_Gegenbeispiel.py", "Schaetzrauschen_Demo.py", "Sensitivitaetsanalyse.py", "Simplex_Tableau_LP.py", "Simulated_Annealing.py", "Skalierung_Kondition.py", "Solver_Wahl.py", "Solverstatus_und_Gap.py", "Solverwechsel_CPSAT_HiGHS.py", "Spaltengenerierung.py", "Stochastische_Optimierung.py", "Strafgewichte.py", "Strukturbruecke.py", "Toleranzen_und_Entartung.py", "VRP_Flotten_Routing.py", "VRP_Kapazitaetsfalle.py", "VaR_CVaR_Demo.py", "Vektorisierte_Modellgenerierung.py", "Visualisierung_Loesungsraum.py", "Vom_Wunsch_zum_Modell.py", "Warmstart_Effekt.py", "Zuordnung_Ungarisch.py", "or_kern.py", "test_or_kern.py"];
+window.OR_PROGRAMME = ["Backtest_Fallen.py", "Bausteine_Vorlage.py", "Bellman_Minimalbeispiel.py", "Benchmark_Skalierung.py", "Betriebsueberwachung.py", "Big_M_Falle.py", "Bot_Allokation.py", "Brute_Force_Vergleich.py", "CP_SAT_Statusfaelle.py", "CP_SAT_Vertretungssystem.py", "CVaR_Portfolio.py", "Chance_Constraints.py", "Constraint_Attribution.py", "Data_Snooping.py", "Diversifikation_Demo.py", "Dualitaet_Nachweis.py", "Ein_System_Vier_Ansaetze.py", "Entropie_Maximierte_Allokation.py", "Erklaerbarkeit.py", "Excel_Bruecke.py", "Finanzdaten_Ledoit_Wolf.py", "Fluch_des_Durchschnitts.py", "Infeasibility_Diagnose.py", "Installationstest.py", "JobShop_Intervalle.py", "KKT_Nachweis.py", "Konfliktsuche.py", "Konvexitaet_Demo.py", "Kovarianz_Falle.py", "Kraftwerkseinsatz.py", "Large_Neighborhood_Search.py", "Lokale_Optima_Multistart.py", "MILP_Portfolio_Fixgebuehren.py", "Markowitz_CVXPY.py", "Matrixform.py", "Mehrperiodige_Order_Execution.py", "Mehrziel_Pareto.py", "Metaheuristik_vs_Exakt.py", "Min_Cost_Flow.py", "Modellierungsschichten.py", "Monte_Carlo.py", "Mutationstest.py", "Optimierungsdienst.py", "Parallele_Suche.py", "Predict_then_Optimize.py", "Propagation_Demo.py", "QP_Grundlagen.py", "QuantitativeTradingEngine.py", "Renditen_Vergleich.py", "Renditeschaetzung_Falle.py", "Robuste_Optimierung.py", "Rucksack.py", "Runden_Gegenbeispiel.py", "Schaetzrauschen_Demo.py", "Sensitivitaetsanalyse.py", "Simplex_Tableau_LP.py", "Simulated_Annealing.py", "Skalierung_Kondition.py", "Solver_Wahl.py", "Solverstatus_und_Gap.py", "Solverwechsel_CPSAT_HiGHS.py", "Spaltengenerierung.py", "Stochastische_Optimierung.py", "Strafgewichte.py", "Strukturbruecke.py", "Toleranzen_und_Entartung.py", "VRP_Flotten_Routing.py", "VRP_Kapazitaetsfalle.py", "VaR_CVaR_Demo.py", "Vektorisierte_Modellgenerierung.py", "Visualisierung_Loesungsraum.py", "Vom_Wunsch_zum_Modell.py", "Warmstart_Effekt.py", "Zuordnung_Ungarisch.py", "or_kern.py", "test_or_kern.py"];
diff --git a/OR_HTML_04/assets/search-index.js b/OR_HTML_04/assets/search-index.js
index 8325380..e346890 100644
--- a/OR_HTML_04/assets/search-index.js
+++ b/OR_HTML_04/assets/search-index.js
@@ -1 +1 @@
-window.OR_SEARCH_INDEX = [{"seite":"vorwort.html","titel":"Vorwort & Lesehilfe","anker":null,"text":""},{"seite":"notation.html","titel":"Notation & Abkürzungen","anker":null,"text":""},{"seite":"notation.html","titel":"1. Die Symbole der Optimierung","anker":"die-symbole-der-optimierung","text":""},{"seite":"notation.html","titel":"1.1 Grundgrößen jedes Modells","anker":"grundgrößen-jedes-modells","text":""},{"seite":"notation.html","titel":"1.2 Mengen und Zahlbereiche","anker":"mengen-und-zahlbereiche","text":""},{"seite":"notation.html","titel":"1.3 Operatoren und Schreibweisen","anker":"operatoren-und-schreibweisen","text":""},{"seite":"notation.html","titel":"1.4 Symbole der Finanzkapitel (Teil IV)","anker":"symbole-der-finanzkapitel-teil-iv","text":""},{"seite":"notation.html","titel":"1.5 Symbole der Verfahrenskapitel (Teil II und III)","anker":"symbole-der-verfahrenskapitel-teil-ii-und-iii","text":"Diese Zeichen kommen erst in den Kapiteln vor, die über das klassische LP hinausgehen."},{"seite":"notation.html","titel":"2. Abkürzungen — vollständig ausgeschrieben","anker":"abkürzungen-vollständig-ausgeschrieben","text":""},{"seite":"notation.html","titel":"2.1 Problemklassen und Verfahren","anker":"problemklassen-und-verfahren","text":""},{"seite":"notation.html","titel":"2.2 Probleme mit Eigennamen","anker":"probleme-mit-eigennamen","text":""},{"seite":"notation.html","titel":"2.3 Finanz- und Risikokennzahlen","anker":"finanz--und-risikokennzahlen","text":""},{"seite":"notation.html","titel":"2.4 Software, Solver und Schnittstellen","anker":"software-solver-und-schnittstellen","text":""},{"seite":"notation.html","titel":"2.5 Begriffe aus dem Solver-Alltag","anker":"begriffe-aus-dem-solver-alltag","text":""},{"seite":"notation.html","titel":"3. Konventionen in diesem Buch","anker":"konventionen-in-diesem-buch","text":"Vektoren sind grundsätzlich Spaltenvektoren und werden fett gesetzt: \\mathbf{x}. Ein transponierter Vektor \\mathbf{x}^\\top ist eine Zeile. Skalare bleiben mager: n, Z."},{"seite":"einfuehrung.html","titel":"Kapitel 1: Einführung in Operations Research — Vom Ursprung zur mathematischen Entscheidungsfindung","anker":null,"text":""},{"seite":"einfuehrung.html","titel":"1.1 In 5 Minuten gelöst","anker":"sec:einfuehrung-schnellstart","text":"Bevor wir über Theorie sprechen, lösen Sie ein echtes Problem. Kopieren Sie den folgenden Block, führen Sie ihn aus, sehen Sie das Ergebnis — die Erklärung kommt danach."},{"seite":"einfuehrung.html","titel":"1.2 Lernziele","anker":"sec:einfuehrung-lernziele","text":"Nach diesem Kapitel können Sie …"},{"seite":"einfuehrung.html","titel":"1.3 Was ist Operations Research wirklich?","anker":"sec:einfuehrung-was-ist-operations-research-wirklich","text":"Im Alltag lösen wir Probleme intuitiv: durch Ausprobieren, Daumenregeln, Erfahrung. Das funktioniert erstaunlich gut — bis eine bestimmte Schwelle überschritten wird. Dann bricht d"},{"seite":"einfuehrung.html","titel":"Die drei Stufen der Analytik","anker":"die-drei-stufen-der-analytik","text":"OR beantwortet nicht die beschreibende Frage „Was ist passiert?“ und nicht die vorhersagende Frage „Was wird passieren?“, sondern die vorschreibende (präskriptive) Kernfrage:"},{"seite":"einfuehrung.html","titel":"1.4 Warum Ausprobieren scheitert — mit eigener Rechnung","anker":"sec:einfuehrung-warum-ausprobieren-scheitert-mit-eigener-rechnung","text":"Die Behauptung „vollständiges Durchprobieren ist unmöglich“ wird oft aufgestellt und selten belegt. Rechnen wir sie einmal selbst nach — das Ergebnis prägt sich besser ein als jede"},{"seite":"einfuehrung.html","titel":"1.5 Historischer Kontext und Evolution","anker":"sec:einfuehrung-historischer-kontext-und-evolution","text":"Der Begriff entstand im Vorfeld des Zweiten Weltkriegs in Großbritannien. Militärische Führungsstäbe standen vor neuartigen logistischen und strategischen Fragen: Wie platziert man"},{"seite":"einfuehrung.html","titel":"1.6 Die vier universellen Bausteine jedes OR-Problems","anker":"sec:einfuehrung-die-vier-universellen-bausteine-jedes-or","text":"Dies ist der wichtigste Abschnitt des Kapitels. Jedes Optimierungsproblem der Welt lässt sich — unabhängig von der Branche — auf vier Elemente reduzieren. Wenn Sie später vor einem"},{"seite":"einfuehrung.html","titel":"Baustein 1 — Entscheidungsvariablen (x)","anker":"baustein-1-entscheidungsvariablen-x","text":"Die Stellschrauben des Modells: Werte, die der Algorithmus aktiv festlegen darf."},{"seite":"einfuehrung.html","titel":"Baustein 2 — Parameter / Eingabedaten (c, A, b)","anker":"baustein-2-parameter-eingabedaten-c-a-b","text":"Die unveränderlichen Fakten der Realität: historische Renditen, Maschinenstundensätze, Lagerkapazitäten, Steuerquoten, Entfernungen, Qualifikationen."},{"seite":"einfuehrung.html","titel":"Baustein 3 — Zielfunktion (f(x))","anker":"baustein-3-zielfunktion-fx","text":"Ein mathematischer Ausdruck, der die Güte einer Lösung zu einer einzigen Zahl verdichtet:"},{"seite":"einfuehrung.html","titel":"Baustein 4 — Nebenbedingungen (Constraints)","anker":"baustein-4-nebenbedingungen-constraints","text":"Regeln, die den Raum der erlaubten Lösungen einschränken:"},{"seite":"einfuehrung.html","titel":"Die vier Bausteine als eine Formel","anker":"die-vier-bausteine-als-eine-formel","text":"Setzt man die vier Bausteine zusammen, entsteht die Standardform, in der Ihnen jedes Optimierungsmodell dieses Buches begegnen wird. Sie sieht auf den ersten Blick sperrig aus — de"},{"seite":"einfuehrung.html","titel":"Die Bausteine in der Praxis: eine Vorlage","anker":"die-bausteine-in-der-praxis-eine-vorlage","text":"Damit die Zerlegung zur Gewohnheit wird, hier eine Vorlage, die Sie bei jedem neuen Problem ausfüllen können — vor der ersten Codezeile."},{"seite":"einfuehrung.html","titel":"1.7 Erstes Python-Vollbeispiel: Ressourcenallokation im Rechenzentrum","anker":"sec:einfuehrung-erstes-python-vollbeispiel-ressourcenallokation-im-rechenzentrum","text":""},{"seite":"einfuehrung.html","titel":"Szenario","anker":"szenario","text":"Ein quantitatives Handelshaus betreibt Serverkapazitäten für zwei Algorithmentypen:"},{"seite":"einfuehrung.html","titel":"Mathematische Formulierung","anker":"mathematische-formulierung","text":"Entscheidungsvariablen:"},{"seite":"einfuehrung.html","titel":"Umsetzung mit Google OR-Tools","anker":"umsetzung-mit-google-or-tools","text":""},{"seite":"einfuehrung.html","titel":"1.8 Von Excel zu Python: Ihre Daten liegen schon da","anker":"sec:einfuehrung-excel-bruecke","text":"In den allermeisten Betrieben liegen die Zahlen, die ein Optimierungsmodell braucht, nicht in einer Datenbank, sondern in einer Tabellenkalkulation. Und viele Leserinnen und Leser "},{"seite":"einfuehrung.html","titel":"1.9 Übungsaufgaben","anker":"sec:einfuehrung-uebungsaufgaben","text":""},{"seite":"einfuehrung.html","titel":"1.10 Finde den Denkfehler","anker":"sec:einfuehrung-denkfehler","text":"Ein Programm, das abstürzt, ist harmlos — Sie sehen sofort, dass etwas nicht stimmt. Gefährlich sind Programme, die fehlerfrei durchlaufen, einen Status OPTIMAL melden und eine Zah"},{"seite":"einfuehrung.html","titel":"1.11 Micro-Quiz","anker":"sec:einfuehrung-quiz","text":""},{"seite":"einfuehrung.html","titel":"1.12 Selbsttest","anker":"sec:einfuehrung-selbsttest","text":""},{"seite":"einfuehrung.html","titel":"1.13 Zusammenfassung","anker":"sec:einfuehrung-zusammenfassung","text":""},{"seite":"fundament.html","titel":"Kapitel 2: Das mathematische Fundament — Vektoren, Matrizen, Konvexität","anker":null,"text":""},{"seite":"fundament.html","titel":"2.1 In 5 Minuten gelöst","anker":"sec:fundament-schnellstart","text":"Dieses Kapitel handelt von Geometrie. Bevor wir Vektoren und Matrizen einführen, sehen Sie die zentrale Einsicht in Aktion — ganz ohne Solver, mit acht Zeilen NumPy."},{"seite":"fundament.html","titel":"2.2 Lernziele","anker":"sec:fundament-lernziele","text":"Nach diesem Kapitel können Sie …"},{"seite":"fundament.html","titel":"2.3 Warum überhaupt Vektoren und Matrizen?","anker":"sec:fundament-warum-ueberhaupt-vektoren-und-matrizen","text":"In Kapitel 1 hatten wir zwei Variablen und drei Nebenbedingungen. Das ließ sich bequem ausschreiben. Reale Modelle haben hunderte bis hunderttausende Variablen — dort wäre Ausschre"},{"seite":"fundament.html","titel":"Die Bausteine","anker":"die-bausteine","text":"Sei n die Anzahl der Entscheidungsvariablen und m die Anzahl der Nebenbedingungen."},{"seite":"fundament.html","titel":"Die kanonische Standardform","anker":"die-kanonische-standardform","text":"Damit lässt sich jedes lineare Programm in drei Zeilen schreiben:"},{"seite":"fundament.html","titel":"Dasselbe in Python","anker":"dasselbe-in-python","text":""},{"seite":"fundament.html","titel":"2.4 Der zulässige Lösungsraum und das Polyeder","anker":"sec:fundament-der-zulaessige-loesungsraum-und-das-polyeder","text":"Jede lineare Ungleichung a_{i1}x_1 + a_{i2}x_2 \\le b_i definiert geometrisch eine Halbebene (im \\mathbb{R}^2) bzw. einen Halbraum (im \\mathbb{R}^n): Die zugehörige Gleichung ist ei"},{"seite":"fundament.html","titel":"Der Fundamentalsatz der linearen Optimierung","anker":"der-fundamentalsatz-der-linearen-optimierung","text":""},{"seite":"fundament.html","titel":"2.5 Konvexität: die Grenze zwischen leicht und schwer","anker":"sec:fundament-konvexitaet-die-grenze-zwischen-leicht-und","text":"Hier kommt die vielleicht wichtigste Einsicht des ganzen Buches. In der Optimierungstheorie verläuft die Trennlinie zwischen „zuverlässig lösbar“ und „im Allgemeinen hoffnungslos“ "},{"seite":"fundament.html","titel":"Konvexe Menge","anker":"konvexe-menge","text":"Eine Menge \\mathcal{C} \\subseteq \\mathbb{R}^n heißt konvex, wenn für alle Punkte \\mathbf{x}, \\mathbf{y} \\in \\mathcal{C} und jedes \\theta \\in [0,1] gilt:"},{"seite":"fundament.html","titel":"Konvexe Funktion","anker":"konvexe-funktion","text":"Eine Funktion f: \\mathcal{C} \\to \\mathbb{R} heißt konvex, wenn für alle \\mathbf{x}, \\mathbf{y} \\in \\mathcal{C} und \\theta \\in [0,1] gilt:"},{"seite":"fundament.html","titel":"Der zentrale Satz","anker":"der-zentrale-satz","text":""},{"seite":"fundament.html","titel":"Was ist konvex, was nicht?","anker":"was-ist-konvex-was-nicht","text":""},{"seite":"fundament.html","titel":"Konvexität sichtbar machen","anker":"konvexität-sichtbar-machen","text":""},{"seite":"fundament.html","titel":"2.6 Geometrische Visualisierung des Lösungsraums","anker":"sec:fundament-geometrische-visualisierung-des-loesungsraums","text":"Wir zeichnen nun den Lösungsraum aus Kapitel 1 und lesen das Optimum ab. Zweidimensionale Bilder sind der schnellste Weg, Intuition für höhere Dimensionen aufzubauen — auch wenn ma"},{"seite":"fundament.html","titel":"2.7 Wenn die Zahlen nicht zusammenpassen: Kondition und Skalierung","anker":"sec:fundament-kondition","text":"Bis hierher war die lineare Algebra exakt. Ein Rechner rechnet aber nicht exakt, sondern mit rund 16 signifikanten Stellen — und Ihre Betriebsdaten sind ohnehin nur auf wenige Stel"},{"seite":"fundament.html","titel":"Die geometrische Vorstellung: zwei fast parallele Linien","anker":"die-geometrische-vorstellung-zwei-fast-parallele-linien","text":"Zwei Nebenbedingungen legen im Zweidimensionalen einen Schnittpunkt fest. Stehen die zugehörigen Geraden kreuzweise aufeinander, ist der Schnittpunkt robust: Verschiebt man eine Ge"},{"seite":"fundament.html","titel":"Woher schlechte Kondition im Alltag kommt","anker":"woher-schlechte-kondition-im-alltag-kommt","text":"Fast nie aus exotischer Mathematik — fast immer aus Einheiten:"},{"seite":"fundament.html","titel":"Ruiz-Equilibrierung: das Modell gesundrechnen","anker":"ruiz-equilibrierung-das-modell-gesundrechnen","text":"Die Gegenmaßnahme ist erstaunlich schlicht. Man multipliziert jede Zeile und jede Spalte der Matrix mit einem Faktor, sodass die Beträge überall in derselben Größenordnung landen:"},{"seite":"fundament.html","titel":"Das Experiment","anker":"das-experiment","text":"Das folgende Programm führt beides vor — die Fehlerverstärkung und ihre Behebung — und schließt mit der praktischen Konsequenz, die Sie in Kapitel 6 wieder brauchen werden: warum e"},{"seite":"fundament.html","titel":"2.8 Übungsaufgaben","anker":"sec:fundament-uebungsaufgaben","text":""},{"seite":"fundament.html","titel":"2.9 Finde den Denkfehler","anker":"sec:fundament-denkfehler","text":""},{"seite":"fundament.html","titel":"2.10 Micro-Quiz","anker":"sec:fundament-quiz","text":""},{"seite":"fundament.html","titel":"2.11 Selbsttest","anker":"sec:fundament-selbsttest","text":""},{"seite":"fundament.html","titel":"2.12 Zusammenfassung","anker":"sec:fundament-zusammenfassung","text":""},{"seite":"oekosystem.html","titel":"Kapitel 3: Das Python-Ökosystem für OR — Solver, Bindings und Modellierungsschichten","anker":null,"text":""},{"seite":"oekosystem.html","titel":"3.1 In 5 Minuten gelöst","anker":"sec:oekosystem-schnellstart","text":""},{"seite":"oekosystem.html","titel":"3.2 Lernziele","anker":"sec:oekosystem-lernziele","text":"Nach diesem Kapitel können Sie …"},{"seite":"oekosystem.html","titel":"3.3 Die Zwei-Schichten-Architektur","anker":"sec:oekosystem-die-zwei-schichten-architektur","text":"Im modernen Operations Research schreibt man Optimierungsalgorithmen nicht selbst. Man nutzt eine zweischichtige Architektur:"},{"seite":"oekosystem.html","titel":"3.4 Die Werkzeuge im Vergleich","anker":"sec:oekosystem-die-werkzeuge-im-vergleich","text":""},{"seite":"oekosystem.html","titel":"Die Entscheidung in drei Fragen","anker":"die-entscheidung-in-drei-fragen","text":"Statt die Tabelle auswendig zu lernen, beantworten Sie drei Fragen:"},{"seite":"oekosystem.html","titel":"3.5 Ein System — vier Programmieransätze","anker":"sec:oekosystem-ein-system-vier-programmieransaetze","text":"Nichts macht die Unterschiede so deutlich wie dasselbe Problem, viermal gelöst. Wir nehmen:"},{"seite":"oekosystem.html","titel":"Was das CSR-Format bedeutet","anker":"was-das-csr-format-bedeutet","text":"highspy erwartet die Nebenbedingungsmatrix im CSR-Format (Compressed Sparse Row, komprimierte Zeilendarstellung). Statt der vollen Matrix speichert man nur die Einträge ungleich nu"},{"seite":"oekosystem.html","titel":"3.6 Wann lohnt sich welche Ebene?","anker":"sec:oekosystem-wann-lohnt-sich-welche-ebene","text":""},{"seite":"oekosystem.html","titel":"3.7 Modellierungsschichten für große Modelle: Pyomo und Linopy","anker":"sec:oekosystem-pyomo-linopy","text":"Die vier Bibliotheken aus dem Vierfach-Vergleich decken den Alltag weitgehend ab. Sobald Modelle industrielle Größe erreichen — zehntausende Variablen, Daten aus mehreren Systemen,"},{"seite":"oekosystem.html","titel":"Pyomo: die algebraische Denkweise","anker":"pyomo-die-algebraische-denkweise","text":"Pyomo ist im deutschsprachigen Raum der De-facto-Standard für große LP- und MILP-Modelle in Energiewirtschaft, Chemie und Logistik. Sein Kennzeichen: Es denkt in Mengen und Indizes"},{"seite":"oekosystem.html","titel":"Linopy: eine Zeile, zehntausend Nebenbedingungen","anker":"linopy-eine-zeile-zehntausend-nebenbedingungen","text":"Linopy verfolgt einen anderen Ansatz: Variablen sind beschriftete Arrays (xarray), keine indizierten Einzelobjekte. Damit wird aus"},{"seite":"oekosystem.html","titel":"Die Schichten im Überblick","anker":"die-schichten-im-überblick","text":""},{"seite":"oekosystem.html","titel":"3.8 Wo die Zeit wirklich hingeht: vektorisierte Modellgenerierung","anker":"sec:oekosystem-vektorisierung","text":"Eine der hartnäckigsten Fehlannahmen in Optimierungsprojekten lautet: „Wenn es zu langsam ist, brauchen wir einen besseren Solver.“ Messen Sie erst — oft stimmt das nicht."},{"seite":"oekosystem.html","titel":"Vier Stufen an einem Transportproblem","anker":"vier-stufen-an-einem-transportproblem","text":"Wir bauen dasselbe Transportproblem (m Werke, n Kunden, m \\cdot n Variablen) auf vier Arten auf:"},{"seite":"oekosystem.html","titel":"3.9 Übungsaufgaben","anker":"sec:oekosystem-uebungsaufgaben","text":""},{"seite":"oekosystem.html","titel":"3.10 Finde den Denkfehler","anker":"sec:oekosystem-denkfehler","text":""},{"seite":"oekosystem.html","titel":"3.11 Micro-Quiz","anker":"sec:oekosystem-quiz","text":""},{"seite":"oekosystem.html","titel":"3.12 Selbsttest","anker":"sec:oekosystem-selbsttest","text":""},{"seite":"oekosystem.html","titel":"3.13 Zusammenfassung","anker":"sec:oekosystem-zusammenfassung","text":""},{"seite":"modellierung.html","titel":"Kapitel 4: Vom Management-Wunsch zum Modell","anker":null,"text":""},{"seite":"modellierung.html","titel":"4.1 In 5 Minuten gelöst","anker":"sec:modellierung-schnellstart","text":""},{"seite":"modellierung.html","titel":"4.2 Lernziele","anker":"sec:modellierung-lernziele","text":"Nach diesem Kapitel können Sie …"},{"seite":"modellierung.html","titel":"4.3 Ein Satz ist noch kein Modell","anker":"sec:modellierung-vier-fragen","text":"Was aus einer Besprechung mitkommt, klingt meist so:"},{"seite":"modellierung.html","titel":"4.4 Derselbe Datensatz, fünf Modelle","anker":"sec:modellierung-fuenf-modelle","text":"Das Programm dieses Kapitels arbeitet die vier Fragen an einer Auftragsannahme ab: 14 Anfragen verlangen 800 Maschinenstunden, verfügbar sind 300."},{"seite":"modellierung.html","titel":"Teil 1: Drei Ziele, drei Pläne","anker":"teil-1-drei-ziele-drei-pläne","text":""},{"seite":"modellierung.html","titel":"Teil 2: Ein Satz, drei Lesarten","anker":"teil-2-ein-satz-drei-lesarten","text":"„Stammkunden dürfen wir nicht verlieren.” Jeder im Raum nickt. Niemand merkt, dass drei verschiedene Modelle gemeint sein können:"},{"seite":"modellierung.html","titel":"Teil 3: Hart oder weich","anker":"teil-3-hart-oder-weich","text":"Dieselbe Regel als Strafkosten je abgelehntem Stammkundenauftrag:"},{"seite":"modellierung.html","titel":"Teil 4: Ein Quartal später","anker":"teil-4-ein-quartal-später","text":"Die harte Lesart A wurde eingebaut, alles lief drei Monate lang. Dann fragt Weber einen Auftrag über 320 Maschinenstunden an — mehr, als der ganze Zeitraum hergibt."},{"seite":"modellierung.html","titel":"4.5 Der Gesprächsleitfaden","anker":"sec:modellierung-leitfaden","text":"Was aus den vier Teilen als Handwerkszeug bleibt — Fragen, die man in der ersten Besprechung stellt, bevor eine Zeile Code entsteht:"},{"seite":"modellierung.html","titel":"4.6 Übungsaufgaben","anker":"sec:modellierung-uebungsaufgaben","text":""},{"seite":"modellierung.html","titel":"4.7 Finde den Denkfehler","anker":"sec:modellierung-denkfehler","text":""},{"seite":"modellierung.html","titel":"4.8 Micro-Quiz","anker":"sec:modellierung-quiz","text":""},{"seite":"modellierung.html","titel":"4.9 Selbsttest","anker":"sec:modellierung-selbsttest","text":""},{"seite":"modellierung.html","titel":"4.10 Zusammenfassung","anker":"sec:modellierung-zusammenfassung","text":""},{"seite":"lp.html","titel":"Kapitel 5: Lineare Programmierung — Simplex, Dualität und Schattenpreise","anker":null,"text":""},{"seite":"lp.html","titel":"5.1 In 5 Minuten gelöst","anker":"sec:lp-schnellstart","text":"Bisher hat ein Solver Ihnen gesagt, was Sie tun sollen. Jetzt sagt er Ihnen zusätzlich, was eine zusätzliche Stunde wert wäre — und das ist die Zahl, für die Sie im Betrieb gehört "},{"seite":"lp.html","titel":"5.2 Lernziele","anker":"sec:lp-lernziele","text":"Nach diesem Kapitel können Sie …"},{"seite":"lp.html","titel":"5.3 Die Standardform und Schlupfvariablen","anker":"sec:lp-die-standardform-und-schlupfvariablen","text":"Lineare Programme zeichnen sich dadurch aus, dass Zielfunktion und alle Nebenbedingungen strikt linear sind — keine Produkte von Variablen, keine Quadrate, keine Logarithmen."},{"seite":"lp.html","titel":"5.4 Der Simplex-Algorithmus Schritt für Schritt","anker":"sec:lp-der-simplex-algorithmus-schritt-fuer-schritt","text":"Der von George Dantzig 1947 formulierte Simplex-Algorithmus nutzt den Fundamentalsatz aus Kapitel 2: Das Optimum liegt in einer Ecke. Statt alle Ecken aufzuzählen, wandert er von E"},{"seite":"lp.html","titel":"Der Ablauf","anker":"der-ablauf","text":""},{"seite":"lp.html","titel":"5.5 Das Simplex-Tableau in Python","anker":"sec:lp-das-simplex-tableau-in-python","text":""},{"seite":"lp.html","titel":"5.6 Dualität und Schattenpreise","anker":"sec:lp-dualitaet-und-schattenpreise","text":"Zu jedem linearen Optimierungsproblem (dem primalen Problem) existiert ein spiegelbildliches Zwillingsproblem: das duale Problem."},{"seite":"lp.html","titel":"Der starke Dualitätssatz","anker":"der-starke-dualitätssatz","text":""},{"seite":"lp.html","titel":"Der Schattenpreis als Ableitung","anker":"der-schattenpreis-als-ableitung","text":"Der Dualwert y_i^* ist die Grenzproduktivität der Ressource i:"},{"seite":"lp.html","titel":"5.7 Die Vorzeichenfalle bei Schattenpreisen","anker":"sec:lp-die-vorzeichenfalle-bei-schattenpreisen","text":"Diese Falle sollten Sie sich merken, weil sie in jedem Projekt wieder auftaucht."},{"seite":"lp.html","titel":"5.8 Praxisfall: Sensitivitätsanalyse mit korrekten Schattenpreisen","anker":"sec:lp-praxisfall-sensitivitaetsanalyse-mit-korrekten-schattenpreisen","text":"Szenario. Ein Fertigungsbetrieb stellt drei Produkte her und will wissen:"},{"seite":"lp.html","titel":"5.9 Wann Schattenpreise lügen: Entartung und Toleranzen","anker":"sec:lp-entartung","text":"Der vorige Abschnitt hat gezeigt, wie wertvoll Schattenpreise sind. Dieser zeigt die zwei Fälle, in denen sie eine Entscheidung nicht tragen — und wie man beide erkennt, bevor jema"},{"seite":"lp.html","titel":"Fall 1: Entartung","anker":"fall-1-entartung","text":"Erinnern Sie sich an Abschnitt 2.4: In zwei Dimensionen legen zwei sich schneidende Geraden eine Ecke fest, in drei Dimensionen drei Ebenen, allgemein n Restriktionen bei n Variabl"},{"seite":"lp.html","titel":"Fall 2: Toleranzen","anker":"fall-2-toleranzen","text":"Der zweite Fall ist unscheinbarer und deshalb häufiger. Wie stellt man fest, ob eine Ressource ausgelastet ist? Naheliegend wäre if schlupf == 0. Genau das ist falsch."},{"seite":"lp.html","titel":"Die ehrliche Auskunft: Schattenpreis-Spannen","anker":"die-ehrliche-auskunft-schattenpreis-spannen","text":"Was tut man also, wenn das Modell entartet ist? Man meldet keinen Einzelwert, sondern die Spanne. Die Menge aller optimalen Dualvektoren ist selbst ein Polyeder:"},{"seite":"lp.html","titel":"5.10 Übungsaufgaben","anker":"sec:lp-uebungsaufgaben","text":""},{"seite":"lp.html","titel":"5.11 Finde den Denkfehler","anker":"sec:lp-denkfehler","text":""},{"seite":"lp.html","titel":"5.12 Micro-Quiz","anker":"sec:lp-quiz","text":""},{"seite":"lp.html","titel":"5.13 Selbsttest","anker":"sec:lp-selbsttest","text":""},{"seite":"lp.html","titel":"5.14 Zusammenfassung","anker":"sec:lp-zusammenfassung","text":""},{"seite":"milp.html","titel":"Kapitel 6: Gemischt-ganzzahlige Optimierung — Diskrete Entscheidungen und Branch-and-Bound","anker":null,"text":""},{"seite":"milp.html","titel":"6.1 In 5 Minuten gelöst","anker":"sec:milp-schnellstart","text":""},{"seite":"milp.html","titel":"6.2 Lernziele","anker":"sec:milp-lernziele","text":"Nach diesem Kapitel können Sie …"},{"seite":"milp.html","titel":"6.3 Warum Runden fundamental scheitert","anker":"sec:milp-warum-runden-fundamental-scheitert","text":"In der realen Welt sind viele Entscheidungen nicht teilbar. Man kann nicht 0,47 Flugzeuge kaufen, keine halbe Lagerhalle bauen, keinen Mitarbeiter zu 38 % einstellen. Noch wichtige"},{"seite":"milp.html","titel":"6.4 Branch-and-Bound","anker":"sec:milp-branch-and-bound","text":"MILP-Probleme sind NP-schwer. Der Standardansatz moderner Solver (HiGHS, SCIP, Gurobi) heißt Branch-and-Cut — Branch-and-Bound plus Schnittebenen."},{"seite":"milp.html","titel":"Die drei Phasen","anker":"die-drei-phasen","text":""},{"seite":"milp.html","titel":"6.5 Modellierungstricks: Big-M und logische Bedingungen","anker":"sec:milp-modellierungstricks-big-m-und-logische-bedingungen","text":"Hier kommt das Handwerkszeug, das MILP so mächtig macht: Man übersetzt Geschäftsregeln in lineare Ungleichungen — mithilfe binärer Hilfsvariablen y \\in \\{0,1\\} und einer hinreichen"},{"seite":"milp.html","titel":"Muster 1 — Fixkosten / Aktivierungsschalter","anker":"muster-1-fixkosten-aktivierungsschalter","text":"Regel: Wird Maschine j genutzt (x_j &gt; 0), fallen Rüstkosten F_j an."},{"seite":"milp.html","titel":"Muster 2 — Entweder-Oder (disjunctive constraints)","anker":"muster-2-entweder-oder-disjunctive-constraints","text":"Regel: Es muss entweder f(\\mathbf{x}) \\le b_1 oder g(\\mathbf{x}) \\le b_2 gelten."},{"seite":"milp.html","titel":"Muster 3 — Wenn-Dann (Implikation)","anker":"muster-3-wenn-dann-implikation","text":"Regel: Wenn y_1 = 1, dann muss auch y_2 = 1 sein."},{"seite":"milp.html","titel":"Muster 4 — Kardinalität („höchstens K aus N“)","anker":"muster-4-kardinalität-höchstens-k-aus-n","text":"\\sum_{j=1}^N y_j \\le K"},{"seite":"milp.html","titel":"Muster 5 — Semikontinuierlich („entweder 0 oder mindestens L“)","anker":"muster-5-semikontinuierlich-entweder-0-oder-mindestens-l","text":"Regel: Eine Position ist entweder gar nicht besetzt oder mit mindestens L Euro."},{"seite":"milp.html","titel":"6.6 Beispiel: Das Rucksackproblem","anker":"sec:milp-beispiel-das-rucksackproblem","text":"Bevor wir zum Portfolio kommen, das klassische Einstiegsproblem — kurz, verständlich und überall wiederzuerkennen."},{"seite":"milp.html","titel":"6.7 Praxisfall: Portfolio mit Ordergebühren und Kardinalitätsgrenze","anker":"sec:milp-praxisfall-portfolio-mit-ordergebuehren-und-kardinalitaetsgrenze","text":"Szenario. Ein Investor verteilt 100\\,000\\,\\text{€} auf sechs Anlageklassen."},{"seite":"milp.html","titel":"6.8 Wenn der Solver nicht fertig wird: Gap, Zeitlimit und Warm-Start","anker":"sec:milp-gap","text":"Bei einem LP gibt es zwei Ausgänge: eine optimale Lösung oder eine klare Absage. Bei einem MILP gibt es einen dritten, und im Betrieb ist er der häufigste:"},{"seite":"milp.html","titel":"Die zwei Zahlen, die zählen","anker":"die-zwei-zahlen-die-zählen","text":"Branch-and-Bound führt zu jedem Zeitpunkt zwei Werte mit:"},{"seite":"milp.html","titel":"Alle Statusfälle behandeln","anker":"alle-statusfälle-behandeln","text":"Der zweite Teil der Professionalität ist unspektakulär, aber entscheidend: jeden Rückgabewert auswerten, nicht nur OPTIMAL."},{"seite":"milp.html","titel":"Warm-Starts: was sie können und was nicht","anker":"warm-starts-was-sie-können-und-was-nicht","text":"Ein Warm-Start gibt dem Solver eine bekannte Lösung als Startpunkt mit. Die Idee ist verlockend: Wer schon eine brauchbare Lösung hat, muss nicht bei null anfangen."},{"seite":"milp.html","titel":"6.9 Übungsaufgaben","anker":"sec:milp-uebungsaufgaben","text":""},{"seite":"milp.html","titel":"6.10 Finde den Denkfehler","anker":"sec:milp-denkfehler","text":"Die Warnung „M so klein wie möglich“ wird meist mit der Laufzeit begründet: schwache Relaxation, mehr Knoten. Das stimmt — und ist die harmlosere Hälfte der Wahrheit."},{"seite":"milp.html","titel":"6.11 Micro-Quiz","anker":"sec:milp-quiz","text":""},{"seite":"milp.html","titel":"6.12 Selbsttest","anker":"sec:milp-selbsttest","text":""},{"seite":"milp.html","titel":"6.13 Zusammenfassung","anker":"sec:milp-zusammenfassung","text":""},{"seite":"cpsat.html","titel":"Kapitel 7: Constraint Programming mit CP-SAT — Logik, Scheduling und Zuweisung","anker":null,"text":""},{"seite":"cpsat.html","titel":"7.1 In 5 Minuten gelöst","anker":"sec:cpsat-schnellstart","text":""},{"seite":"cpsat.html","titel":"7.2 Lernziele","anker":"sec:cpsat-lernziele","text":"Nach diesem Kapitel können Sie …"},{"seite":"cpsat.html","titel":"7.3 Ein anderes Denkmodell","anker":"sec:cpsat-ein-anderes-denkmodell","text":"Während LP und MILP auf algebraischen Gleichungen und Simplex-Matrizen beruhen, kommt Constraint Programming (CP) aus der künstlichen Intelligenz:"},{"seite":"cpsat.html","titel":"Was Propagation leistet","anker":"was-propagation-leistet","text":""},{"seite":"cpsat.html","titel":"7.4 Globale Constraints — die Bausteine von CP-SAT","anker":"sec:cpsat-globale-constraints-die-bausteine-von-cp","text":"CP-SAT stellt mächtige Makros bereit, die in MILP hunderte Big-M-Ungleichungen erfordern würden. Jedes davon hat einen spezialisierten, hocheffizienten Propagator."},{"seite":"cpsat.html","titel":"7.5 Praxisfall: Dynamisches Vertretungssystem","anker":"sec:cpsat-praxisfall-dynamisches-vertretungssystem","text":"Problemstellung. Eine Schule muss nach spontanen Ausfällen vier Unterrichtsstunden nachbesetzen."},{"seite":"cpsat.html","titel":"7.6 Intervallvariablen: Job-Shop-Scheduling","anker":"sec:cpsat-intervallvariablen-job-shop-scheduling","text":"Die Königsdisziplin von CP-SAT sind Zeitplanungsprobleme. Intervallvariablen sind dabei das zentrale Werkzeug."},{"seite":"cpsat.html","titel":"7.7 Die fünf Antworten von CP-SAT","anker":"sec:cpsat-statusfaelle","text":"Abschnitt 6.8 hat gezeigt, warum OPTIMAL bei ganzzahligen Problemen nicht der Normalfall ist. Bei CP-SAT kommt eine Besonderheit hinzu: Es gibt fünf verschiedene Antworten, und dre"},{"seite":"cpsat.html","titel":"7.8 Übungsaufgaben","anker":"sec:cpsat-uebungsaufgaben","text":""},{"seite":"cpsat.html","titel":"7.9 Finde den Denkfehler","anker":"sec:cpsat-denkfehler","text":""},{"seite":"cpsat.html","titel":"7.10 Micro-Quiz","anker":"sec:cpsat-quiz","text":""},{"seite":"cpsat.html","titel":"7.11 Selbsttest","anker":"sec:cpsat-selbsttest","text":""},{"seite":"cpsat.html","titel":"7.12 Zusammenfassung","anker":"sec:cpsat-zusammenfassung","text":""},{"seite":"graphen.html","titel":"Kapitel 8: Graphen, Flüsse und Touren — Min-Cost-Flow, Matching und VRP","anker":null,"text":""},{"seite":"graphen.html","titel":"8.1 In 5 Minuten gelöst","anker":"sec:graphen-schnellstart","text":""},{"seite":"graphen.html","titel":"8.2 Lernziele","anker":"sec:graphen-lernziele","text":"Nach diesem Kapitel können Sie …"},{"seite":"graphen.html","titel":"8.3 Graphen als Modellsprache","anker":"sec:graphen-graphen-als-modellsprache","text":"Viele reale Probleme in Logistik, Kommunikation und Finanzströmen sind keine flachen Ungleichungssysteme, sondern Graphen G = (V, E):"},{"seite":"graphen.html","titel":"Das Minimum-Cost-Flow-Problem (MCNFP)","anker":"das-minimum-cost-flow-problem-mcnfp","text":"Minimum-Cost Network Flow Problem — deutsch: kostenminimales Flussproblem. Es ist das mathematische Fundament für Transportketten, Liquiditätsrouting und Datenverteilung."},{"seite":"graphen.html","titel":"8.4 Bipartites Matching: das Zuordnungsproblem","anker":"sec:graphen-bipartites-matching-das-zuordnungsproblem","text":"Wenn N Aufgaben auf N Ressourcen eins zu eins verteilt werden — Orders auf Broker, Schichten auf Mitarbeitende, Aufträge auf Maschinen — spricht man von bipartitem Matching."},{"seite":"graphen.html","titel":"Der Satz von Birkhoff und von Neumann","anker":"der-satz-von-birkhoff-und-von-neumann","text":""},{"seite":"graphen.html","titel":"8.5 Das Vehicle Routing Problem mit Zeitfenstern","anker":"sec:graphen-das-vehicle-routing-problem-mit-zeitfenstern","text":"Das Traveling Salesperson Problem (TSP), deutsch Problem des Handlungsreisenden, fragt nach der kürzesten Rundreise durch N Städte. Das Capacitated Vehicle Routing Problem with Tim"},{"seite":"graphen.html","titel":"Kurzzyklen verhindern","anker":"kurzzyklen-verhindern","text":"Ein naives Modell erlaubt Subtouren: isolierte Kreise, die das Depot nie anfahren. Die klassische Gegenmaßnahme ist die MTZ-Formulierung nach Miller, Tucker und Zemlin. Man führt R"},{"seite":"graphen.html","titel":"Praxisbeispiel: Flotten-Routing","anker":"praxisbeispiel-flotten-routing","text":""},{"seite":"graphen.html","titel":"8.6 Übungsaufgaben","anker":"sec:graphen-uebungsaufgaben","text":""},{"seite":"graphen.html","titel":"8.7 Finde den Denkfehler","anker":"sec:graphen-denkfehler","text":""},{"seite":"graphen.html","titel":"8.8 Micro-Quiz","anker":"sec:graphen-quiz","text":""},{"seite":"graphen.html","titel":"8.9 Selbsttest","anker":"sec:graphen-selbsttest","text":""},{"seite":"graphen.html","titel":"8.10 Zusammenfassung","anker":"sec:graphen-zusammenfassung","text":""},{"seite":"metaheuristiken.html","titel":"Kapitel 9: Metaheuristiken — wenn der exakte Solver aussteigt","anker":null,"text":""},{"seite":"metaheuristiken.html","titel":"9.1 In 5 Minuten gelöst","anker":"sec:metaheuristiken-schnellstart","text":""},{"seite":"metaheuristiken.html","titel":"9.2 Lernziele","anker":"sec:metaheuristiken-lernziele","text":"Nach diesem Kapitel können Sie …"},{"seite":"metaheuristiken.html","titel":"9.3 Die Aufgabe: Rüstzeiten an der Lackieranlage","anker":"sec:metaheuristiken-aufgabe","text":"Der Schnellstart war ein Spielzeug. Die Aufgabe dieses Kapitels ist dieselbe, nur in Betriebsgröße: n Aufträge in eine Reihenfolge bringen, so dass die Summe der Rüstzeiten minimal"},{"seite":"metaheuristiken.html","titel":"Die Instanz","anker":"die-instanz","text":"Alle Programme dieses Kapitels benutzen dieselbe Aufgabe. Die Rüstzeit setzt sich aus zwei Teilen zusammen: einem unregelmäßigen Reinigungsaufwand zwischen den Produktfamilien und "},{"seite":"metaheuristiken.html","titel":"9.4 Lokale Suche: der Zug und seine Kosten","anker":"sec:metaheuristiken-lokale-suche","text":"Eine lokale Suche braucht drei Dinge: eine Startlösung, einen Zug und eine Regel, welche Züge übernommen werden."},{"seite":"metaheuristiken.html","titel":"9.5 Simulated Annealing","anker":"sec:metaheuristiken-annealing","text":"Reines Bergsteigen — nur Verbesserungen annehmen — bleibt im ersten lokalen Optimum stehen. Simulated Annealing nimmt Verschlechterungen mit einer Wahrscheinlichkeit an, die von de"},{"seite":"metaheuristiken.html","titel":"Was die Messung zeigt — und was sie nicht zeigt","anker":"was-die-messung-zeigt-und-was-sie-nicht-zeigt","text":"Erstens: Der Beitrag des Annealings ist bescheiden. Bergsteigen kommt auf 917 Minuten, Annealing auf 907 — das simple Verfahren holt 93 % des Ertrags. Das ist kein Argument gegen A"},{"seite":"metaheuristiken.html","titel":"9.6 Ab wann lohnt es sich?","anker":"sec:metaheuristiken-umschlagpunkt","text":"„Kleine Probleme exakt, große mit Metaheuristiken“ ist richtig und nutzlos, solange niemand sagt, wo groß anfängt. Diese Zahl lässt sich messen."},{"seite":"metaheuristiken.html","titel":"Die Spalte, die man nicht weglassen darf","anker":"die-spalte-die-man-nicht-weglassen-darf","text":"Bei 500 Aufträgen haben wir die CP-SAT-Lösung verworfen. Seine Schranke ist trotzdem das Wertvollste in der ganzen Tabelle."},{"seite":"metaheuristiken.html","titel":"9.7 Large Neighborhood Search","anker":"sec:metaheuristiken-lns","text":"Die Tabelle oben endet mit einem Widerspruch. Bei 500 Aufträgen scheitert der exakte Solver an der Größe; die Metaheuristik scheitert an der Kleinheit ihrer Züge — sie verschiebt j"},{"seite":"metaheuristiken.html","titel":"Das Fenster ist die eine Stellschraube","anker":"das-fenster-ist-die-eine-stellschraube","text":""},{"seite":"metaheuristiken.html","titel":"Das Gesamtbild","anker":"das-gesamtbild","text":""},{"seite":"metaheuristiken.html","titel":"9.8 Was dieses Kapitel nicht behandelt","anker":"sec:metaheuristiken-abgrenzung","text":"Damit die Landkarte vollständig ist — drei Verfahren, die in dieselbe Familie gehören und hier bewusst nur benannt werden:"},{"seite":"metaheuristiken.html","titel":"9.9 Übungsaufgaben","anker":"sec:metaheuristiken-uebungsaufgaben","text":""},{"seite":"metaheuristiken.html","titel":"9.10 Finde den Denkfehler","anker":"sec:metaheuristiken-denkfehler","text":""},{"seite":"metaheuristiken.html","titel":"9.11 Micro-Quiz","anker":"sec:metaheuristiken-quiz","text":""},{"seite":"metaheuristiken.html","titel":"9.12 Selbsttest","anker":"sec:metaheuristiken-selbsttest","text":""},{"seite":"metaheuristiken.html","titel":"9.13 Zusammenfassung","anker":"sec:metaheuristiken-zusammenfassung","text":""},{"seite":"dekomposition.html","titel":"Kapitel 10: Spaltengenerierung — das Modell umbauen statt die Lösung raten","anker":null,"text":""},{"seite":"dekomposition.html","titel":"10.1 In 5 Minuten gelöst","anker":"sec:dekomposition-schnellstart","text":""},{"seite":"dekomposition.html","titel":"10.2 Lernziele","anker":"sec:dekomposition-lernziele","text":"Nach diesem Kapitel können Sie …"},{"seite":"dekomposition.html","titel":"10.3 Warum das naheliegende Modell scheitert","anker":"sec:dekomposition-symmetrie","text":"Der erste Entwurf eines Zuschnittmodells sieht fast immer so aus: eine Binärvariable z_{jr} für „Stück j liegt auf Rolle r“, dazu y_r für „Rolle r wird benutzt”."},{"seite":"dekomposition.html","titel":"10.4 Rechnen mit Mustern, ohne sie aufzuschreiben","anker":"sec:dekomposition-schleife","text":"Die Idee ist alt (Gilmore und Gomory, 1961) und in einem Satz gesagt:"},{"seite":"dekomposition.html","titel":"10.5 Das Programm","anker":"sec:dekomposition-programm","text":""},{"seite":"dekomposition.html","titel":"10.6 Was die Zahlen zeigen","anker":"sec:dekomposition-befund","text":""},{"seite":"dekomposition.html","titel":"Die Musterzahl explodiert, der Bedarf nicht","anker":"die-musterzahl-explodiert-der-bedarf-nicht","text":""},{"seite":"dekomposition.html","titel":"Der unbequeme Teil: Es lohnt sich nicht immer","anker":"der-unbequeme-teil-es-lohnt-sich-nicht-immer","text":""},{"seite":"dekomposition.html","titel":"10.7 Übungsaufgaben","anker":"sec:dekomposition-uebungsaufgaben","text":""},{"seite":"dekomposition.html","titel":"10.8 Finde den Denkfehler","anker":"sec:dekomposition-denkfehler","text":""},{"seite":"dekomposition.html","titel":"10.9 Micro-Quiz","anker":"sec:dekomposition-quiz","text":""},{"seite":"dekomposition.html","titel":"10.10 Selbsttest","anker":"sec:dekomposition-selbsttest","text":""},{"seite":"dekomposition.html","titel":"10.11 Zusammenfassung","anker":"sec:dekomposition-zusammenfassung","text":""},{"seite":"qp-nlp.html","titel":"Kapitel 11: Quadratische und nichtlineare Optimierung — KKT, Lagrange, Konvexität","anker":null,"text":""},{"seite":"qp-nlp.html","titel":"11.1 In 5 Minuten gelöst","anker":"sec:qp-nlp-schnellstart","text":""},{"seite":"qp-nlp.html","titel":"11.2 Lernziele","anker":"sec:qp-nlp-lernziele","text":"Nach diesem Kapitel können Sie …"},{"seite":"qp-nlp.html","titel":"Auffrischung: Gradient in einer Minute","anker":"auffrischung-gradient-in-einer-minute","text":"Der Gradient \\nabla f(\\mathbf{x}) ist der Vektor aller partiellen Ableitungen:"},{"seite":"qp-nlp.html","titel":"11.3 Das quadratische Programm (QP)","anker":"sec:qp-nlp-das-quadratische-programm-qp","text":"Ein quadratisches Programm hat eine quadratische Zielfunktion und lineare Nebenbedingungen:"},{"seite":"qp-nlp.html","titel":"Konvexität: die präzise Aussage","anker":"konvexität-die-präzise-aussage","text":"Eine verbreitete, aber zu stark formulierte Aussage lautet: „Wenn \\mathbf{P} positiv semi-definit ist, ist das QP streng konvex; es existiert ein eindeutiges globales Minimum.“ Kor"},{"seite":"qp-nlp.html","titel":"11.4 Die Karush-Kuhn-Tucker-Bedingungen","anker":"sec:qp-nlp-die-karush-kuhn-tucker-bedingungen","text":"Die KKT-Bedingungen verallgemeinern den Lagrange-Ansatz auf Probleme mit Ungleichungen. Sie sind notwendig für ein Optimum — und bei konvexen Problemen auch hinreichend."},{"seite":"qp-nlp.html","titel":"Die vier KKT-Bedingungen","anker":"die-vier-kkt-bedingungen","text":"Am Optimum (\\mathbf{x}^*, \\boldsymbol{\\lambda}^*, \\boldsymbol{\\nu}^*) gilt:"},{"seite":"qp-nlp.html","titel":"11.5 Nichtlineare Optimierung mit scipy.optimize.minimize","anker":"sec:qp-nlp-nichtlineare-optimierung-mit-scipy-optimize-minimize","text":"Wenn Zielfunktion oder Nebenbedingungen weder linear noch quadratisch sind — Logarithmen, Wurzeln, Exponentialfunktionen — nutzt man gradientenbasierte Verfahren wie SLSQP (Sequent"},{"seite":"qp-nlp.html","titel":"Praxisfall: Entropie-maximierte Kapitalallokation","anker":"praxisfall-entropie-maximierte-kapitalallokation","text":"Wir optimieren ein Portfolio nicht nur nach Varianz, sondern maximieren zusätzlich die Shannon-Entropie der Gewichte, um Klumpenrisiken glatt zu bestrafen:"},{"seite":"qp-nlp.html","titel":"11.6 Jenseits der Konvexität: lokale Optima, Multistart und MINLP","anker":"sec:qp-nlp-nichtkonvex","text":"Alles bisher in diesem Kapitel stand unter einer Bedingung: Konvexität. Sie ist der Grund, warum CVXPY eine Optimalitätsgarantie geben kann und warum die KKT-Bedingungen nicht nur "},{"seite":"qp-nlp.html","titel":"Woher Nicht-Konvexität im Alltag kommt","anker":"woher-nicht-konvexität-im-alltag-kommt","text":"Nicht aus exotischer Mathematik, sondern aus ganz gewöhnlichen betriebswirtschaftlichen Effekten:"},{"seite":"qp-nlp.html","titel":"Was ein lokales Optimum praktisch bedeutet","anker":"was-ein-lokales-optimum-praktisch-bedeutet","text":"scipy.optimize.minimize verweigert nichts. Es rechnet, meldet success: True und liefert eine Zahl. Diese Meldung heißt aber nicht „das ist das Optimum“, sondern nur:"},{"seite":"qp-nlp.html","titel":"Die Zahlen im Klartext","anker":"die-zahlen-im-klartext","text":""},{"seite":"qp-nlp.html","titel":"Ausblick: MINLP und globale Solver","anker":"ausblick-minlp-und-globale-solver","text":"Wird zusätzlich noch ganzzahlig entschieden — „welche Anlage läuft überhaupt“ und „wie stark“ —, entsteht ein MINLP (Mixed-Integer Nonlinear Program), die schwierigste der in diese"},{"seite":"qp-nlp.html","titel":"11.7 Übungsaufgaben","anker":"sec:qp-nlp-uebungsaufgaben","text":""},{"seite":"qp-nlp.html","titel":"11.8 Finde den Denkfehler","anker":"sec:qp-nlp-denkfehler","text":""},{"seite":"qp-nlp.html","titel":"11.9 Micro-Quiz","anker":"sec:qp-nlp-quiz","text":""},{"seite":"qp-nlp.html","titel":"11.10 Selbsttest","anker":"sec:qp-nlp-selbsttest","text":""},{"seite":"qp-nlp.html","titel":"11.11 Zusammenfassung","anker":"sec:qp-nlp-zusammenfassung","text":""},{"seite":"unsicherheit.html","titel":"Kapitel 12: Optimierung unter Unsicherheit — Monte-Carlo, Stochastik, Robustheit","anker":null,"text":""},{"seite":"unsicherheit.html","titel":"12.1 In 5 Minuten gelöst","anker":"sec:unsicherheit-schnellstart","text":""},{"seite":"unsicherheit.html","titel":"12.2 Lernziele","anker":"sec:unsicherheit-lernziele","text":"Nach diesem Kapitel können Sie …"},{"seite":"unsicherheit.html","titel":"12.3 Der Fluch des Durchschnitts","anker":"sec:unsicherheit-der-fluch-des-durchschnitts","text":"Der naheliegende Umgang mit Unsicherheit lautet: „Wir setzen den Erwartungswert ein und rechnen deterministisch.“ Das ist fast immer falsch — und zwar nicht ungenau, sondern system"},{"seite":"unsicherheit.html","titel":"Die vier Ansätze im Überblick","anker":"die-vier-ansätze-im-überblick","text":""},{"seite":"unsicherheit.html","titel":"12.4 Monte-Carlo-Simulation","anker":"sec:unsicherheit-monte-carlo-simulation","text":"Monte-Carlo heißt schlicht: Ziehe sehr viele Zufallsszenarien, werte für jedes den Plan aus, und betrachte die Verteilung der Ergebnisse statt eines einzigen Werts."},{"seite":"unsicherheit.html","titel":"12.5 Zweistufige stochastische Programmierung","anker":"sec:unsicherheit-zweistufige-stochastische-programmierung","text":"Das zweistufige Modell mit Recourse bildet ab, dass Entscheidungen zeitlich gestaffelt sind:"},{"seite":"unsicherheit.html","titel":"12.6 Robuste Optimierung: gegen den Worst Case absichern","anker":"sec:unsicherheit-robuste-optimierung-gegen-den-worst-case","text":"Wenn Wahrscheinlichkeiten unbekannt oder instabil sind — Marktcrashs, Lieferkettenabrisse, Pandemien —, hilft die robuste Optimierung. Sie fragt nicht nach dem Mittel, sondern nach"},{"seite":"unsicherheit.html","titel":"12.7 Wahrscheinlichkeitsbeschränkungen: „mit 95 % Sicherheit“","anker":"sec:unsicherheit-chance-constraints","text":"Die drei bisherigen Ansätze beantworten Fragen, die im Sitzungssaal selten so gestellt werden. „Was ist im Mittel am besten?“ hört ein Vorstand als Ausflucht; „was hält auch im sch"},{"seite":"unsicherheit.html","titel":"Weg 1: Normalverteilung — die Bedingung wird ein Kegel","anker":"weg-1-normalverteilung-die-bedingung-wird-ein-kegel","text":"Ist \\mathbf{a} \\sim \\mathcal{N}(\\hat{\\mathbf{a}}, \\boldsymbol{\\Sigma}), dann ist \\mathbf{a}^\\top\\mathbf{x} für festes \\mathbf{x} selbst normalverteilt, mit Erwartungswert \\hat{\\mat"},{"seite":"unsicherheit.html","titel":"Weg 2: Szenarien — Big-M ohne Verteilungsannahme","anker":"weg-2-szenarien-big-m-ohne-verteilungsannahme","text":"Liegen statt einer Verteilung nur S beobachtete Szenarien vor, bekommt jedes eine Binärvariable z_s, die sagt, ob es verletzt werden darf:"},{"seite":"unsicherheit.html","titel":"Der Fall: ein Kraftwerkspark mit 500 MW Zusage","anker":"der-fall-ein-kraftwerkspark-mit-500-mw-zusage","text":""},{"seite":"unsicherheit.html","titel":"12.8 Übungsaufgaben","anker":"sec:unsicherheit-uebungsaufgaben","text":""},{"seite":"unsicherheit.html","titel":"12.9 Finde den Denkfehler","anker":"sec:unsicherheit-denkfehler","text":""},{"seite":"unsicherheit.html","titel":"12.10 Micro-Quiz","anker":"sec:unsicherheit-quiz","text":""},{"seite":"unsicherheit.html","titel":"12.11 Selbsttest","anker":"sec:unsicherheit-selbsttest","text":""},{"seite":"unsicherheit.html","titel":"12.12 Zusammenfassung","anker":"sec:unsicherheit-zusammenfassung","text":""},{"seite":"dynamische-programmierung.html","titel":"Kapitel 13: Dynamische Programmierung — Die Bellman-Gleichung und Order-Execution","anker":null,"text":""},{"seite":"dynamische-programmierung.html","titel":"13.1 In 5 Minuten gelöst","anker":"sec:dynamische-programmierung-schnellstart","text":""},{"seite":"dynamische-programmierung.html","titel":"13.2 Lernziele","anker":"sec:dynamische-programmierung-lernziele","text":"Nach diesem Kapitel können Sie …"},{"seite":"dynamische-programmierung.html","titel":"13.3 Das Bellmansche Optimalitätsprinzip","anker":"sec:dynamische-programmierung-das-bellmansche-optimalitaetsprinzip","text":"Richard Bellman formulierte 1957 das Grundprinzip der Dynamischen Programmierung (DP):"},{"seite":"dynamische-programmierung.html","titel":"Die vier Bausteine eines DP-Modells","anker":"die-vier-bausteine-eines-dp-modells","text":""},{"seite":"dynamische-programmierung.html","titel":"Die Bellman-Gleichung","anker":"die-bellman-gleichung","text":"V_t(S_t) = \\min_{a_t\\in\\mathcal{A}(S_t)}\\Big\\{\\,C(S_t,a_t) \\;+\\; \\gamma\\cdot\\mathbb{E}\\big[V_{t+1}(S_{t+1})\\mid S_t,a_t\\big]\\Big\\}"},{"seite":"dynamische-programmierung.html","titel":"13.4 Das Almgren-Chriss-Problem: optimale Orderausführung","anker":"sec:dynamische-programmierung-das-almgren-chriss-problem-optimale-orderausfuehrung","text":"Ein klassisches OR-Problem an Börsen: Ein institutioneller Händler muss X_0 = 100\\,000 Aktien innerhalb von T Handelsperioden verkaufen."},{"seite":"dynamische-programmierung.html","titel":"13.5 Der Fluch der Dimensionalität","anker":"sec:dynamische-programmierung-der-fluch-der-dimensionalitaet","text":"DP ist mächtig, aber es hat eine harte Grenze. Der Aufwand der Rückwärtsinduktion ist"},{"seite":"dynamische-programmierung.html","titel":"13.6 Übungsaufgaben","anker":"sec:dynamische-programmierung-uebungsaufgaben","text":""},{"seite":"dynamische-programmierung.html","titel":"13.7 Finde den Denkfehler","anker":"sec:dynamische-programmierung-denkfehler","text":"Bei dynamischer Programmierung entscheidet eine einzige Frage über Erfolg oder Misserfolg: Was gehört in den Zustand? Ist er zu klein, rechnet das Verfahren völlig korrekt — nur eb"},{"seite":"dynamische-programmierung.html","titel":"13.8 Micro-Quiz","anker":"sec:dynamische-programmierung-quiz","text":""},{"seite":"dynamische-programmierung.html","titel":"13.9 Selbsttest","anker":"sec:dynamische-programmierung-selbsttest","text":""},{"seite":"dynamische-programmierung.html","titel":"13.10 Zusammenfassung","anker":"sec:dynamische-programmierung-zusammenfassung","text":""},{"seite":"mehrziel.html","titel":"Kapitel 14: Mehrere Ziele — Pareto-Fronten statt Gewichte","anker":null,"text":""},{"seite":"mehrziel.html","titel":"14.1 In 5 Minuten gelöst","anker":"sec:mehrziel-schnellstart","text":""},{"seite":"mehrziel.html","titel":"14.2 Lernziele","anker":"sec:mehrziel-lernziele","text":"Nach diesem Kapitel können Sie …"},{"seite":"mehrziel.html","titel":"14.3 Wann ein Kompromiss gut ist","anker":"sec:mehrziel-dominanz","text":"Bei einem Ziel ist „besser” eindeutig. Bei zwei Zielen nicht mehr: Ein Plan kann billiger und schmutziger sein als ein anderer, und dann ist keiner von beiden besser."},{"seite":"mehrziel.html","titel":"14.4 Der Reflex: alles in ein Ziel rühren","anker":"sec:mehrziel-skalarisierung","text":"Der naheliegende Weg, zwei Ziele zu einem zu machen, ist die gewichtete Summe:"},{"seite":"mehrziel.html","titel":"14.5 Das Programm","anker":"sec:mehrziel-programm","text":"Zwölf Sendungen, drei Verkehrsträger, fünf freie Bahntrassen. Der Zielkonflikt entsteht nicht zwischen den Trägern — die Bahn ist immer billiger und sauberer als der LKW —, sondern"},{"seite":"mehrziel.html","titel":"14.6 Was die gewichtete Summe nicht sieht","anker":"sec:mehrziel-luecke","text":"Die Front hat zehn Punkte. Ein Raster aus 1 401 Gewichten findet sechs davon. Vier Kompromisse sind für kein Gewicht erreichbar — und das ist keine Frage der Rasterweite."},{"seite":"mehrziel.html","titel":"Das Gewicht ist keine Feineinstellung","anker":"das-gewicht-ist-keine-feineinstellung","text":"Die zweite Beobachtung aus derselben Tabelle: 1 401 Gewichte erzeugen sechs verschiedene Pläne. Weite Gewichtsbereiche liefern dasselbe Ergebnis, und dazwischen springt es."},{"seite":"mehrziel.html","titel":"14.7 Das ε-Constraint-Verfahren","anker":"sec:mehrziel-epsilon","text":"Der Ausweg ist unspektakulär: Man macht aus dem zweiten Ziel eine Nebenbedingung."},{"seite":"mehrziel.html","titel":"Wenn es eine klare Rangfolge gibt: lexikografisch","anker":"wenn-es-eine-klare-rangfolge-gibt-lexikografisch","text":"Manchmal ist ein Ziel wirklich vorrangig. Dann optimiert man lexikografisch: erst das erste Ziel, dann das zweite unter der Bedingung, dass das erste (fast) erhalten bleibt."},{"seite":"mehrziel.html","titel":"14.8 Wie man die Front vorlegt","anker":"sec:mehrziel-vorlegen","text":"Eine Front mit zehn Punkten ist kein Ergebnis, sondern eine Speisekarte. Damit sie entscheidbar wird, gehört eine Spalte dazu, die im Programm EUR je kg heißt:"},{"seite":"mehrziel.html","titel":"14.9 Übungsaufgaben","anker":"sec:mehrziel-uebungsaufgaben","text":""},{"seite":"mehrziel.html","titel":"14.10 Finde den Denkfehler","anker":"sec:mehrziel-denkfehler","text":""},{"seite":"mehrziel.html","titel":"14.11 Micro-Quiz","anker":"sec:mehrziel-quiz","text":""},{"seite":"mehrziel.html","titel":"14.12 Selbsttest","anker":"sec:mehrziel-selbsttest","text":""},{"seite":"mehrziel.html","titel":"14.13 Zusammenfassung","anker":"sec:mehrziel-zusammenfassung","text":""},{"seite":"prognose.html","titel":"Kapitel 15: Predict-then-Optimize — die bessere Prognose, die schlechtere Entscheidung","anker":null,"text":""},{"seite":"prognose.html","titel":"15.1 In 5 Minuten gelöst","anker":"sec:prognose-schnellstart","text":""},{"seite":"prognose.html","titel":"15.2 Lernziele","anker":"sec:prognose-lernziele","text":"Nach diesem Kapitel können Sie …"},{"seite":"prognose.html","titel":"15.3 Die Naht zwischen zwei Abteilungen","anker":"sec:prognose-naht","text":"In fast jedem Unternehmen sieht der Ablauf so aus:"},{"seite":"prognose.html","titel":"15.4 Das Programm","anker":"sec:prognose-programm","text":"Dieselbe Bäckerei, aber mit Merkmalen: Wochentag, Temperatur, Aktionstage. Die Nachfrage muss jetzt modelliert werden."},{"seite":"prognose.html","titel":"15.5 Der Befund","anker":"sec:prognose-befund","text":""},{"seite":"prognose.html","titel":"Warum ein pauschaler Zuschlag zu kurz greift","anker":"warum-ein-pauschaler-zuschlag-zu-kurz-greift","text":"Die zweite Zeile der Tabelle ist die verbreitete Praxis: Punktprognose plus Sicherheitsbestand. Sie hilft (−7,3 %), bleibt aber hinter der Quantilregression zurück. Das Programm re"},{"seite":"prognose.html","titel":"15.6 Eine Messfalle, in die der Autor selbst getappt ist","anker":"sec:prognose-messfalle","text":"Der erste Entwurf dieses Programms bewertete auf 230 Testtagen — ein realistischer Zeitraum, gut sieben Monate. Dort hatte die Quantilregression den besseren MSE, und die ganze Aus"},{"seite":"prognose.html","titel":"15.7 Wie weit das Verfahren reicht","anker":"sec:prognose-ausblick","text":"Die dritte Zeile der Ergebnistabelle — „Zuschlag auf Kosten trainiert” — ist die einfachste denkbare Form einer Idee, die derzeit erforscht wird: das Prognosemodell direkt auf die "},{"seite":"prognose.html","titel":"15.8 Übungsaufgaben","anker":"sec:prognose-uebungsaufgaben","text":""},{"seite":"prognose.html","titel":"15.9 Finde den Denkfehler","anker":"sec:prognose-denkfehler","text":""},{"seite":"prognose.html","titel":"15.10 Micro-Quiz","anker":"sec:prognose-quiz","text":""},{"seite":"prognose.html","titel":"15.11 Selbsttest","anker":"sec:prognose-selbsttest","text":""},{"seite":"prognose.html","titel":"15.12 Zusammenfassung","anker":"sec:prognose-zusammenfassung","text":""},{"seite":"bruecke.html","titel":"Kapitel 16: Die Strukturbrücke — dieselbe Mathematik, zwei Welten","anker":null,"text":""},{"seite":"bruecke.html","titel":"16.1 In 5 Minuten gelöst","anker":"sec:bruecke-schnellstart","text":""},{"seite":"bruecke.html","titel":"16.2 Lernziele","anker":"sec:bruecke-lernziele","text":"Nach diesem Kapitel können Sie …"},{"seite":"bruecke.html","titel":"16.3 Das Programm","anker":"sec:bruecke-programm","text":""},{"seite":"bruecke.html","titel":"16.4 Die zwei Brücken im Einzelnen","anker":"sec:bruecke-einzelnen","text":""},{"seite":"bruecke.html","titel":"Erste Brücke: Allokation","anker":"erste-brücke-allokation","text":""},{"seite":"bruecke.html","titel":"Zweite Brücke: Absicherung gegen den schlechtesten Fall","anker":"zweite-brücke-absicherung-gegen-den-schlechtesten-fall","text":"Hier ist die Übereinstimmung noch enger, weil sie nicht nur die Struktur betrifft, sondern die Formel. Die Rockafellar-Uryasev-Formulierung aus Kapitel 20"},{"seite":"bruecke.html","titel":"Wo die Lösungen sich unterscheiden","anker":"wo-die-lösungen-sich-unterscheiden","text":"Der Vergleich fördert nebenbei einen Unterschied zutage, den man nicht erwartet: Die Streuungsgrenze von 40 % bindet nur im Einkauf, nicht im Depot."},{"seite":"bruecke.html","titel":"16.5 Wo die Brücke endet","anker":"sec:bruecke-grenzen","text":"Eine Analogie ist nur so nützlich wie die Grenzen, die man ihr zieht. Drei Dinge wandern nicht mit:"},{"seite":"bruecke.html","titel":"16.6 Übungsaufgaben","anker":"sec:bruecke-uebungsaufgaben","text":""},{"seite":"bruecke.html","titel":"16.7 Finde den Denkfehler","anker":"sec:bruecke-denkfehler","text":""},{"seite":"bruecke.html","titel":"16.8 Micro-Quiz","anker":"sec:bruecke-quiz","text":""},{"seite":"bruecke.html","titel":"16.9 Selbsttest","anker":"sec:bruecke-selbsttest","text":""},{"seite":"bruecke.html","titel":"16.10 Zusammenfassung","anker":"sec:bruecke-zusammenfassung","text":""},{"seite":"supplychain.html","titel":"Kapitel 17: Supply-Chain und Energieeinsatz unter Unsicherheit","anker":null,"text":""},{"seite":"supplychain.html","titel":"17.1 In 5 Minuten gelöst","anker":"sec:supplychain-schnellstart","text":""},{"seite":"supplychain.html","titel":"17.2 Lernziele","anker":"sec:supplychain-lernziele","text":"Nach diesem Kapitel können Sie …"},{"seite":"supplychain.html","titel":"17.3 Die Aufgabe","anker":"sec:supplychain-aufgabe","text":"Fünf Blöcke, 24 Stunden, eine Last zwischen 270 und 804 MW. Dazu Windeinspeisung, die niemand am Vorabend kennt."},{"seite":"supplychain.html","titel":"Die Zeitstruktur der Entscheidung","anker":"die-zeitstruktur-der-entscheidung","text":"Hier geht das Kapitel über Abschnitt 12.5 hinaus:"},{"seite":"supplychain.html","titel":"17.4 Das Programm","anker":"sec:supplychain-programm","text":""},{"seite":"supplychain.html","titel":"17.5 Der Befund","anker":"sec:supplychain-befund","text":""},{"seite":"supplychain.html","titel":"17.6 Was Versorgungssicherheit kostet","anker":"sec:supplychain-sicherheit","text":"Der dritte Plan legt eine CVaR-Schranke auf die nicht gedeckte Energie: Im Mittel der schlechtesten 10 % der Szenarien darf nichts fehlen. Dieselbe Rockafellar-Uryasev-Konstruktion"},{"seite":"supplychain.html","titel":"17.7 Übungsaufgaben","anker":"sec:supplychain-uebungsaufgaben","text":""},{"seite":"supplychain.html","titel":"17.8 Finde den Denkfehler","anker":"sec:supplychain-denkfehler","text":""},{"seite":"supplychain.html","titel":"17.9 Micro-Quiz","anker":"sec:supplychain-quiz","text":""},{"seite":"supplychain.html","titel":"17.10 Selbsttest","anker":"sec:supplychain-selbsttest","text":""},{"seite":"supplychain.html","titel":"17.11 Zusammenfassung","anker":"sec:supplychain-zusammenfassung","text":""},{"seite":"finanzdaten.html","titel":"Kapitel 18: Finanzdaten-Modellierung — Renditen, Kovarianz und Shrinkage","anker":null,"text":""},{"seite":"finanzdaten.html","titel":"18.1 In 5 Minuten gelöst","anker":"sec:finanzdaten-schnellstart","text":""},{"seite":"finanzdaten.html","titel":"18.2 Lernziele","anker":"sec:finanzdaten-lernziele","text":"Nach diesem Kapitel können Sie …"},{"seite":"finanzdaten.html","titel":"18.3 Diskrete und logarithmische Renditen","anker":"sec:finanzdaten-diskrete-und-logarithmische-renditen","text":"Sei P_{i,t} der bereinigte Schlusskurs (adjusted close) von Titel i zum Zeitpunkt t. „Bereinigt“ heißt: um Dividenden und Aktiensplits korrigiert — sonst erscheint jede Dividendenz"},{"seite":"finanzdaten.html","titel":"Diskrete Rendite","anker":"diskrete-rendite","text":"R_{i,t} = \\frac{P_{i,t} - P_{i,t-1}}{P_{i,t-1}} = \\frac{P_{i,t}}{P_{i,t-1}} - 1"},{"seite":"finanzdaten.html","titel":"Logarithmische Rendite","anker":"logarithmische-rendite","text":"r_{i,t} = \\ln\\!\\left(\\frac{P_{i,t}}{P_{i,t-1}}\\right) = \\ln P_{i,t} - \\ln P_{i,t-1}"},{"seite":"finanzdaten.html","titel":"18.4 Das Schätzfehler-Problem","anker":"sec:finanzdaten-das-schaetzfehler-problem","text":"Sei \\mathbf{X}\\in\\mathbb{R}^{T\\times N} die Matrix zentrierter Renditen von N Titeln über T Handelstage. Die Stichproben-Kovarianzmatrix lautet:"},{"seite":"finanzdaten.html","titel":"18.5 Ledoit-Wolf-Shrinkage","anker":"sec:finanzdaten-ledoit-wolf-shrinkage","text":"Olivier Ledoit und Michael Wolf lösten das Dilemma durch lineare Schrumpfung:"},{"seite":"finanzdaten.html","titel":"Welches Ziel \\mathbf{F}?","anker":"welches-ziel-mathbff","text":"Ein häufiges Missverständnis: Es gibt nämlich mehrere Ledoit-Wolf-Varianten, und Text und Code müssen sich konsistent auf dieselbe beziehen:"},{"seite":"finanzdaten.html","titel":"18.6 Praxis: Datenpipeline mit korrekter Spaltenreihenfolge","anker":"sec:finanzdaten-praxis-datenpipeline-mit-korrekter-spaltenreihenfolge","text":""},{"seite":"finanzdaten.html","titel":"18.7 Übungsaufgaben","anker":"sec:finanzdaten-uebungsaufgaben","text":""},{"seite":"finanzdaten.html","titel":"18.8 Finde den Denkfehler","anker":"sec:finanzdaten-denkfehler","text":""},{"seite":"finanzdaten.html","titel":"18.9 Micro-Quiz","anker":"sec:finanzdaten-quiz","text":""},{"seite":"finanzdaten.html","titel":"18.10 Selbsttest","anker":"sec:finanzdaten-selbsttest","text":""},{"seite":"finanzdaten.html","titel":"18.11 Zusammenfassung","anker":"sec:finanzdaten-zusammenfassung","text":""},{"seite":"markowitz.html","titel":"Kapitel 19: Die moderne Portfoliotheorie nach Markowitz","anker":null,"text":""},{"seite":"markowitz.html","titel":"19.1 In 5 Minuten gelöst","anker":"sec:markowitz-schnellstart","text":""},{"seite":"markowitz.html","titel":"19.2 Lernziele","anker":"sec:markowitz-lernziele","text":"Nach diesem Kapitel können Sie …"},{"seite":"markowitz.html","titel":"19.3 Warum Diversifikation funktioniert","anker":"sec:markowitz-warum-diversifikation-funktioniert","text":"Harry Markowitz’ zentrale Einsicht von 1952: Das Risiko eines Portfolios ist nicht die Summe der Einzelrisiken. Es hängt davon ab, wie die Titel zusammenspielen."},{"seite":"markowitz.html","titel":"19.4 Das Mean-Variance-Modell","anker":"sec:markowitz-das-mean-variance-modell","text":"Sei \\mathbf{w} = (w_1,\\dots,w_n)^\\top der Vektor der Portfoliogewichte:"},{"seite":"markowitz.html","titel":"Die Effizienzgrenze und das Tangentialportfolio","anker":"die-effizienzgrenze-und-das-tangentialportfolio","text":"Die Effizienzgrenze (efficient frontier) ist die Kurve aller Portfolios, die zu jedem Risikoniveau die höchstmögliche Rendite liefern."},{"seite":"markowitz.html","titel":"Die Korn-Transformation","anker":"die-korn-transformation","text":"Die Sharpe Ratio ist ein Bruch — und damit nicht konvex. CVXPY würde sie ablehnen. Der Ausweg ist ein eleganter Trick, der die Homogenität des Problems ausnutzt:"},{"seite":"markowitz.html","titel":"19.5 Institutionelle Nebenbedingungen","anker":"sec:markowitz-institutionelle-nebenbedingungen","text":"In der Praxis gelten regulatorische und interne Regeln:"},{"seite":"markowitz.html","titel":"Was diese Regeln kosten","anker":"was-diese-regeln-kosten","text":"Jede Regel schneidet etwas vom Erreichbaren ab. Wie viel, lässt sich ausrechnen — man legt die Effizienzlinie ohne und mit Beschränkungen übereinander:"},{"seite":"markowitz.html","titel":"19.6 Vollimplementierung mit CVXPY","anker":"sec:markowitz-vollimplementierung-mit-cvxpy","text":""},{"seite":"markowitz.html","titel":"19.7 Übungsaufgaben","anker":"sec:markowitz-uebungsaufgaben","text":""},{"seite":"markowitz.html","titel":"19.8 Finde den Denkfehler","anker":"sec:markowitz-denkfehler","text":"Kapitel 18 hat gezeigt, was eine schlecht geschätzte Kovarianzmatrix anrichtet. Bei den erwarteten Renditen ist es schlimmer — und weil sie in der Zielfunktion stehen statt in der "},{"seite":"markowitz.html","titel":"19.9 Micro-Quiz","anker":"sec:markowitz-quiz","text":""},{"seite":"markowitz.html","titel":"19.10 Selbsttest","anker":"sec:markowitz-selbsttest","text":""},{"seite":"markowitz.html","titel":"19.11 Zusammenfassung","anker":"sec:markowitz-zusammenfassung","text":""},{"seite":"cvar.html","titel":"Kapitel 20: Tail-Risiko, CVaR und Transaktionskosten","anker":null,"text":""},{"seite":"cvar.html","titel":"20.1 In 5 Minuten gelöst","anker":"sec:cvar-schnellstart","text":""},{"seite":"cvar.html","titel":"20.2 Lernziele","anker":"sec:cvar-lernziele","text":"Nach diesem Kapitel können Sie …"},{"seite":"cvar.html","titel":"20.3 Die zwei Schwächen des Markowitz-Modells","anker":"sec:cvar-die-zwei-schwaechen-des-markowitz-modells","text":"Erstens: die Normalverteilungs-Illusion. Die Varianz behandelt Aufwärts- und Abwärtsschwankungen gleich und unterstellt implizit symmetrische, dünn auslaufende Verteilungen. Reale "},{"seite":"cvar.html","titel":"20.4 Value at Risk und Conditional Value at Risk","anker":"sec:cvar-value-at-risk-und-conditional-value","text":""},{"seite":"cvar.html","titel":"Das Rockafellar-Uryasev-Theorem (2000)","anker":"das-rockafellar-uryasev-theorem-2000","text":"Rockafellar und Uryasev zeigten, dass sich der CVaR über S Szenarien exakt als lineares Programm formulieren lässt:"},{"seite":"cvar.html","titel":"20.5 Transaktionskosten über die L_1-Norm","anker":"sec:cvar-transaktionskosten-ueber-die-l-1-norm","text":"Sei \\mathbf{w}_{\\text{alt}} das bestehende Portfolio und \\mathbf{w} das neue Ziel. Der Umschlag (turnover) ist:"},{"seite":"cvar.html","titel":"20.6 Implementierung: CVaR-Portfolio mit Reibung","anker":"sec:cvar-implementierung-cvar-portfolio-mit-reibung","text":""},{"seite":"cvar.html","titel":"20.7 Übungsaufgaben","anker":"sec:cvar-uebungsaufgaben","text":""},{"seite":"cvar.html","titel":"20.8 Finde den Denkfehler","anker":"sec:cvar-denkfehler","text":""},{"seite":"cvar.html","titel":"20.9 Micro-Quiz","anker":"sec:cvar-quiz","text":""},{"seite":"cvar.html","titel":"20.10 Selbsttest","anker":"sec:cvar-selbsttest","text":""},{"seite":"cvar.html","titel":"20.11 Zusammenfassung","anker":"sec:cvar-zusammenfassung","text":""},{"seite":"handelsmaschine.html","titel":"Kapitel 21: Die vollständige quantitative Handelsmaschine","anker":null,"text":""},{"seite":"handelsmaschine.html","titel":"21.1 In 5 Minuten gelöst","anker":"sec:handelsmaschine-schnellstart","text":""},{"seite":"handelsmaschine.html","titel":"21.2 Lernziele","anker":"sec:handelsmaschine-lernziele","text":"Nach diesem Kapitel können Sie …"},{"seite":"handelsmaschine.html","titel":"21.3 Die Architektur","anker":"sec:handelsmaschine-die-architektur","text":""},{"seite":"handelsmaschine.html","titel":"21.4 Rebalancing-Termine richtig bestimmen","anker":"sec:handelsmaschine-rebalancing-termine-richtig-bestimmen","text":""},{"seite":"handelsmaschine.html","titel":"21.5 Die Engine","anker":"sec:handelsmaschine-die-engine","text":""},{"seite":"handelsmaschine.html","titel":"21.6 Die fünf Selbsttäuschungen des Backtestens","anker":"sec:handelsmaschine-die-fuenf-selbsttaeuschungen-des-backtestens","text":""},{"seite":"handelsmaschine.html","titel":"21.7 Vom Backtest zum Betrieb","anker":"sec:handelsmaschine-vom-backtest-zum-betrieb","text":"Ein guter Backtest ist eine notwendige, keine hinreichende Bedingung. Was zwischen Backtest und echtem Einsatz liegt:"},{"seite":"handelsmaschine.html","titel":"21.8 Übungsaufgaben","anker":"sec:handelsmaschine-uebungsaufgaben","text":""},{"seite":"handelsmaschine.html","titel":"21.9 Finde den Denkfehler","anker":"sec:handelsmaschine-denkfehler","text":"Backtest_Fallen.py zeigt drei Fehler, die im Backtest stecken: Lookahead, Survivorship, vergessene Kosten. Alle drei kann man einem Programm ansehen, wenn man es liest."},{"seite":"handelsmaschine.html","titel":"21.10 Micro-Quiz","anker":"sec:handelsmaschine-quiz","text":""},{"seite":"handelsmaschine.html","titel":"21.11 Selbsttest","anker":"sec:handelsmaschine-selbsttest","text":""},{"seite":"handelsmaschine.html","titel":"21.12 Zusammenfassung","anker":"sec:handelsmaschine-zusammenfassung","text":""},{"seite":"praxisfallen.html","titel":"Kapitel 22: Praxisfallen und der Weg zum produktiven Einsatz","anker":null,"text":""},{"seite":"praxisfallen.html","titel":"22.1 In 5 Minuten gelöst","anker":"sec:praxisfallen-schnellstart","text":"Die vorangegangenen vierzehn Kapitel enden fast alle mit derselben Empfehlung: Prüfen Sie das Ergebnis gegen die Wirklichkeit. Dieses Kapitel beginnt damit, diese Prüfung als wiede"},{"seite":"praxisfallen.html","titel":"22.2 Lernziele","anker":"sec:praxisfallen-lernziele","text":"Nach diesem Kapitel können Sie …"},{"seite":"praxisfallen.html","titel":"22.3 Die fünf typischen Praxisfallen","anker":"sec:praxisfallen-die-fuenf-typischen-praxisfallen","text":""},{"seite":"praxisfallen.html","titel":"Falle 1 — Infeasibility","anker":"falle-1-infeasibility","text":"Wenn Parameter unglücklich zusammentreffen — drei Mitarbeitende gleichzeitig krank, kein qualifizierter Ersatz —, meldet der Solver schlicht INFEASIBLE."},{"seite":"praxisfallen.html","titel":"Falle 2 — Der Black-Box-Effekt","anker":"falle-2-der-black-box-effekt","text":"Ein Planer oder Trader lehnt ein System ab, wenn er die Zuweisungen nicht nachvollziehen kann. Akzeptanz ist keine Nebensache, sondern Voraussetzung für den Betrieb."},{"seite":"praxisfallen.html","titel":"Falle 3 — Regimewechsel und Schätzfehler","anker":"falle-3-regimewechsel-und-schätzfehler","text":"Ein Modell, das auf einer mehrjährigen Aufwärtsphase kalibriert wurde, kennt keine Liquiditätskrise und keine Zinswende."},{"seite":"praxisfallen.html","titel":"Falle 4 — Lookahead- und Survivorship-Bias","anker":"falle-4-lookahead--und-survivorship-bias","text":"Ausführlich in Kapitel 21 behandelt. Die Kurzfassung: Beide Fehler machen Backtests systematisch zu gut, ohne eine Fehlermeldung zu erzeugen. Der Lookahead-Selbsttest aus Abschnitt"},{"seite":"praxisfallen.html","titel":"Falle 5 — Laufzeitexplosion","anker":"falle-5-laufzeitexplosion","text":"Exakte Optimalität kann bei MILP oder CP-SAT Minuten bis Stunden dauern — und die Laufzeit wächst nicht linear mit der Problemgröße."},{"seite":"praxisfallen.html","titel":"22.4 Architektur einer produktionsreifen OR-Plattform","anker":"sec:praxisfallen-architektur-einer-produktionsreifen-or-plattform","text":""},{"seite":"praxisfallen.html","titel":"22.5 Der gemeinsame Unterbau: or_kern.py","anker":"sec:praxisfallen-or-kern","text":"Die fünf Prinzipien oben beschreiben eine Plattform. Der Weg dorthin beginnt aber viel kleiner — mit der Frage, welche Teile eines Optimierungsprogramms immer dieselben sind."},{"seite":"praxisfallen.html","titel":"Die vier Schichten","anker":"die-vier-schichten","text":"\\underbrace{\\text{Rohdaten}}_{\\text{Excel, CSV, ERP}}\n\\;\\longrightarrow\\;\n\\underbrace{\\text{Domänenmodell}}_{\\text{geprüft, solverfrei}}\n\\;\\longrightarrow\\;\n\\underbrace{\\text{Model"},{"seite":"praxisfallen.html","titel":"Ein Enum für fünf Bibliotheken","anker":"ein-enum-für-fünf-bibliotheken","text":"Der unscheinbarste, aber wirksamste Teil ist die Statusübersetzung. Dieselbe Aussage heißt in den fünf im Buch verwendeten Bibliotheken:"},{"seite":"praxisfallen.html","titel":"22.6 Der Solverwechsel in der Praxis","anker":"sec:praxisfallen-solverwechsel","text":"Der vorige Abschnitt endet mit einer Behauptung: Ein Solverwechsel betreffe genau einen Baustein. Das ist die Art Satz, die in jedem Architekturvortrag vorkommt und die man deshalb"},{"seite":"praxisfallen.html","titel":"22.7 Eine Checkliste vor dem Produktivgang","anker":"sec:praxisfallen-eine-checkliste-vor-dem-produktivgang","text":"Arbeiten Sie diese Liste ab, bevor ein OR-System in Betrieb geht:"},{"seite":"praxisfallen.html","titel":"22.8 Weiterführende Literatur und Roadmap","anker":"sec:praxisfallen-weiterfuehrende-literatur-und-roadmap","text":"Grundlagen und lineare/ganzzahlige Optimierung * Bertsimas &amp; Tsitsiklis: Introduction to Linear Optimization — Standardwerk zu Simplex, Dualität, Polyedertheorie. * Wolsey: Int"},{"seite":"praxisfallen.html","titel":"22.9 Übungsaufgaben","anker":"sec:praxisfallen-uebungsaufgaben","text":""},{"seite":"praxisfallen.html","titel":"22.10 Finde den Denkfehler","anker":"sec:praxisfallen-denkfehler","text":"Falle 5 — die Laufzeitexplosion — zeigt sich im Betrieb selten als Absturz. Sie zeigt sich als gar nichts."},{"seite":"praxisfallen.html","titel":"22.11 Micro-Quiz","anker":"sec:praxisfallen-quiz","text":""},{"seite":"praxisfallen.html","titel":"22.12 Selbsttest","anker":"sec:praxisfallen-selbsttest","text":""},{"seite":"praxisfallen.html","titel":"22.13 Zusammenfassung","anker":"sec:praxisfallen-zusammenfassung","text":""},{"seite":"testing.html","titel":"Kapitel 23: Testen, Messen, Ausliefern","anker":null,"text":""},{"seite":"testing.html","titel":"23.1 In 5 Minuten gelöst","anker":"sec:testing-schnellstart","text":""},{"seite":"testing.html","titel":"23.2 Lernziele","anker":"sec:testing-lernziele","text":"Nach diesem Kapitel können Sie …"},{"seite":"testing.html","titel":"23.3 Warum Optimierungsmodelle schwer zu testen sind","anker":"sec:testing-warum-schwer","text":"Bei einer gewöhnlichen Funktion schreibt man den erwarteten Wert hin:"},{"seite":"testing.html","titel":"23.4 Die Testsuite","anker":"sec:testing-suite","text":""},{"seite":"testing.html","titel":"23.5 Wer testet die Tests?","anker":"sec:testing-mutation","text":"33 grüne Tests. Das ist noch kein Ergebnis."},{"seite":"testing.html","titel":"Der erste Lauf fand zwei Lücken","anker":"der-erste-lauf-fand-zwei-lücken","text":"Die Suite hatte zunächst 31 Tests. Der Mutationstest sagte dazu:"},{"seite":"testing.html","titel":"23.6 Ein Vergleich, dem man glauben kann","anker":"sec:testing-benchmark","text":"Solververgleiche stehen in jedem Blog, und die meisten sind wertlos. Nicht, weil falsch gemessen wurde, sondern weil zu wenig dazugesagt wird."},{"seite":"testing.html","titel":"Die interessanteste Spalte heißt „Anteil”","anker":"die-interessanteste-spalte-heißt-anteil","text":"Sie sagt, wie viel der Zeit in den Aufbau des Modells geht statt ins Lösen — und die Zahlen sind unbequem:"},{"seite":"testing.html","titel":"23.7 Das Modell als Dienst","anker":"sec:testing-dienst","text":"Ein Modell hinter eine HTTP-Schnittstelle zu hängen sieht nach einer Fingerübung aus. Es gibt aber einen Unterschied, der die ganze Bauform bestimmt:"},{"seite":"testing.html","titel":"Threads oder Prozesse? Eine Messung, keine Meinung","anker":"threads-oder-prozesse-eine-messung-keine-meinung","text":"Punkt 6 des Selbsttests misst, ob vier Solverläufe in Threads sich überlappen. Das Ergebnis ist ein Faktor von rund 3,5 bei vier Threads: OR-Tools rechnet in C++ und gibt den GIL w"},{"seite":"testing.html","titel":"Was im echten Betrieb dazukommt","anker":"was-im-echten-betrieb-dazukommt","text":"Das Beispiel hält das Auftragsbuch in einem dict und rechnet in Threads desselben Prozesses. Für einen einzelnen Rechner reicht das; darüber hinaus nicht:"},{"seite":"testing.html","titel":"23.8 Übungsaufgaben","anker":"sec:testing-uebungsaufgaben","text":""},{"seite":"testing.html","titel":"23.9 Finde den Denkfehler","anker":"sec:testing-denkfehler","text":""},{"seite":"testing.html","titel":"23.10 Micro-Quiz","anker":"sec:testing-quiz","text":""},{"seite":"testing.html","titel":"23.11 Selbsttest","anker":"sec:testing-selbsttest","text":""},{"seite":"testing.html","titel":"23.12 Zusammenfassung","anker":"sec:testing-zusammenfassung","text":""},{"seite":"projektwerkstatt.html","titel":"Projektwerkstatt","anker":null,"text":""},{"seite":"projektwerkstatt.html","titel":"Wie Sie ein Projekt bearbeiten","anker":"wie-sie-ein-projekt-bearbeiten","text":"Halten Sie sich an diese Reihenfolge — sie ist aus vielen gescheiterten und einigen gelungenen Projekten destilliert:"},{"seite":"projektwerkstatt.html","titel":"P1 — Vertretungsplaner für eine Schule","anker":"p1-vertretungsplaner-für-eine-schule","text":""},{"seite":"projektwerkstatt.html","titel":"P2 — Schichtplanung für ein Pflegeteam","anker":"p2-schichtplanung-für-ein-pflegeteam","text":""},{"seite":"projektwerkstatt.html","titel":"P3 — Tourenplanung für einen Lieferdienst","anker":"p3-tourenplanung-für-einen-lieferdienst","text":""},{"seite":"projektwerkstatt.html","titel":"P4 — Standort- und Lagernetzplanung","anker":"p4-standort--und-lagernetzplanung","text":""},{"seite":"projektwerkstatt.html","titel":"P5 — Produktionsplanung mit Rüstkosten","anker":"p5-produktionsplanung-mit-rüstkosten","text":""},{"seite":"projektwerkstatt.html","titel":"P6 — Portfolio-Rebalancer für ein Privatdepot","anker":"p6-portfolio-rebalancer-für-ein-privatdepot","text":""},{"seite":"projektwerkstatt.html","titel":"P7 — Risikoreport mit CVaR und Stresstests","anker":"p7-risikoreport-mit-cvar-und-stresstests","text":""},{"seite":"projektwerkstatt.html","titel":"P9 — Wenn der Solver aussteigt: Tourenplanung in Echtgröße","anker":"p9-wenn-der-solver-aussteigt-tourenplanung-in-echtgröße","text":""},{"seite":"projektwerkstatt.html","titel":"P10 — Zwei Ziele, eine Entscheidung: Kosten gegen CO₂","anker":"p10-zwei-ziele-eine-entscheidung-kosten-gegen-co₂","text":""},{"seite":"projektwerkstatt.html","titel":"P11 — Vom Skript zum Dienst: das Modell übergeben","anker":"p11-vom-skript-zum-dienst-das-modell-übergeben","text":""},{"seite":"projektwerkstatt.html","titel":"P8 — Freies Projekt aus Ihrem eigenen Umfeld","anker":"p8-freies-projekt-aus-ihrem-eigenen-umfeld","text":""},{"seite":"projektwerkstatt.html","titel":"Eine Bitte zum Schluss","anker":"eine-bitte-zum-schluss","text":"Wenn Sie ein Projekt fertig haben, machen Sie zwei Dinge:"},{"seite":"anhang-loesungen.html","titel":"Anhang A: Lösungen zu allen Übungsaufgaben","anker":null,"text":""},{"seite":"anhang-loesungen.html","titel":"A.1 Lösungen zu Kapitel „Einführung in Operations Research — Vom Ursprung zur mathematischen Entscheidungsfindung“","anker":"sec:loesungen-einfuehrung","text":"1.1 — Analytik-Stufen. (a) deskriptiv (Vergangenheit beschreiben). (b) prädiktiv (Prognose). (c) präskriptiv (Handlungsanweisung unter Restriktionen). (d) prädiktiv (Klassifikation"},{"seite":"anhang-loesungen.html","titel":"Finde den Denkfehler 1.1 — Die Schreinerei verdoppelt ihren Gewinn","anker":"finde-den-denkfehler-1.1-die-schreinerei-verdoppelt-ihren-gewinn","text":""},{"seite":"anhang-loesungen.html","titel":"Micro-Quiz","anker":"quiz-loesung-einfuehrung","text":"1 — (c) präskriptiv. Die Frage lautet „was tun“, und es gibt eine Restriktion (das Restbudget). Dass man für die Bewertung eine Prognose braucht, macht die Frage nicht prädiktiv — "},{"seite":"anhang-loesungen.html","titel":"Selbsttest","anker":"selbsttest-loesung-einfuehrung","text":""},{"seite":"anhang-loesungen.html","titel":"A.2 Lösungen zu Kapitel „Das mathematische Fundament — Vektoren, Matrizen, Konvexität“","anker":"sec:loesungen-fundament","text":"2.1 — Matrixform lesen. \\max 4x_1 + x_2 + 6x_3 u. d. N. x_1 + 2x_2 \\le 10, x_2 + 3x_3 \\le 12, x \\ge 0. 3 Variablen, 2 Nebenbedingungen (plus Nichtnegativität)."},{"seite":"anhang-loesungen.html","titel":"Finde den Denkfehler 2.1 — Die unauffällige Transposition","anker":"finde-den-denkfehler-2.1-die-unauffällige-transposition","text":""},{"seite":"anhang-loesungen.html","titel":"Micro-Quiz","anker":"quiz-loesung-fundament","text":"1 — (b). Der Fundamentalsatz sagt nur, dass ein Optimum in einer Ecke angenommen wird. (a) ist falsch, weil es mehrere optimale Ecken geben kann (wenn die Zielfunktion parallel zu "},{"seite":"anhang-loesungen.html","titel":"Selbsttest","anker":"selbsttest-loesung-fundament","text":""},{"seite":"anhang-loesungen.html","titel":"A.3 Lösungen zu Kapitel „Das Python-Ökosystem für OR — Solver, Bindings und Modellierungsschichten“","anker":"sec:loesungen-oekosystem","text":"3.1 — Solverwahl. (a) CP-SAT (diskrete Zuordnung mit Zeitfenstern). (b) scipy.optimize.linprog (klassisches Mischungs-LP, klein). (c) CVXPY (konvexes QP). (d) MIQP — CVXPY mit Binä"},{"seite":"anhang-loesungen.html","titel":"Finde den Denkfehler 3.1 — Der Solver, der angeblich dreimal schneller ist","anker":"finde-den-denkfehler-3.1-der-solver-der-angeblich-dreimal-schneller-ist","text":""},{"seite":"anhang-loesungen.html","titel":"Micro-Quiz","anker":"quiz-loesung-oekosystem","text":"1 — (b) CP-SAT. Es geht um diskrete Zuweisung mit logischen Regeln („nicht gleichzeitig“) — CP-SATs Kerngebiet, und Regeln dieser Art formuliert man dort direkt statt über Big-M-Um"},{"seite":"anhang-loesungen.html","titel":"Selbsttest","anker":"selbsttest-loesung-oekosystem","text":""},{"seite":"anhang-loesungen.html","titel":"A.4 Lösungen zu Kapitel „Vom Management-Wunsch zum Modell“","anker":"sec:loesungen-modellierung","text":"Die fehlende Lesart. Eine dritte Lesart: „Der Umsatzanteil der Stammkunden darf nicht unter 30 % fallen.” Sie zielt weder auf einzelne Aufträge noch auf einzelne Kunden, sondern au"},{"seite":"anhang-loesungen.html","titel":"Finde den Denkfehler — „Die Engpassmaschine soll zu mindestens 92 % ausgelastet sein“","anker":"denkfehler-loesung-modellierung","text":"Fehler 1: Auslastung ist ein Ergebnis, keine Anforderung."},{"seite":"anhang-loesungen.html","titel":"Micro-Quiz","anker":"quiz-loesung-modellierung","text":"1. b) Die Zielfunktion ist eine vollständige Aussage darüber, was zählt. Was nicht darin steht, ist für das Modell nicht „weniger wichtig”, sondern wertlos. (a) und (c) sind frei e"},{"seite":"anhang-loesungen.html","titel":"Selbsttest","anker":"selbsttest-loesung-modellierung","text":""},{"seite":"anhang-loesungen.html","titel":"A.5 Lösungen zu Kapitel „Lineare Programmierung — Simplex, Dualität und Schattenpreise“","anker":"sec:loesungen-lp","text":"4.1 — Schlupf deuten. (a) Ressourcen 1 und 3 (Schlupf 0). (b) Ja: Überall ist s_i \\cdot y_i = 0. (c) In Ressource 3 — der höchste Schattenpreis (9,8) bedeutet den größten Grenznutz"},{"seite":"anhang-loesungen.html","titel":"Finde den Denkfehler 4.1 — Die 380 000-Euro-Maschine","anker":"finde-den-denkfehler-4.1-die-380-000-euro-maschine","text":""},{"seite":"anhang-loesungen.html","titel":"Micro-Quiz","anker":"quiz-loesung-lp","text":"1 — (b). Genau der Satz vom komplementären Schlupf: s_i \\cdot y_i = 0. Ist Schlupf vorhanden, muss der Dualwert null sein. (a) hat die Aussage in ihr Gegenteil verkehrt; (c) verwec"},{"seite":"anhang-loesungen.html","titel":"Selbsttest","anker":"selbsttest-loesung-lp","text":""},{"seite":"anhang-loesungen.html","titel":"A.6 Lösungen zu Kapitel „Gemischt-ganzzahlige Optimierung — Diskrete Entscheidungen und Branch-and-Bound“","anker":"sec:loesungen-milp","text":"5.1 — Runden widerlegen. Beispiel: \\max x_1 + x_2 u. d. N. 10x_1 + 10x_2 \\le 15, ganzzahlig. LP-Optimum Z = 1{,}5; Abrunden ergibt (0,0) mit Z = 0 — 100 % Verlust. Das ganzzahlige "},{"seite":"anhang-loesungen.html","titel":"Finde den Denkfehler 5.1 — Elf Lager, die keine Fixkosten kosten","anker":"finde-den-denkfehler-5.1-elf-lager-die-keine-fixkosten-kosten","text":""},{"seite":"anhang-loesungen.html","titel":"Micro-Quiz","anker":"quiz-loesung-milp","text":"1 — (b). Der Gap (48\\,200 - 47\\,100)/48\\,200 = 2{,}3\\,\\% ist eine Garantie, keine Schätzung: Besser als 47 100 € kann es nachweislich nicht werden, also ist der vorliegende Plan hö"},{"seite":"anhang-loesungen.html","titel":"Selbsttest","anker":"selbsttest-loesung-milp","text":""},{"seite":"anhang-loesungen.html","titel":"A.7 Lösungen zu Kapitel „Constraint Programming mit CP-SAT — Logik, Scheduling und Zuweisung“","anker":"sec:loesungen-cpsat","text":"6.1 — Propagation. Aus x_1 + x_2 = 8 und x_1 &lt; x_2 folgt x_1 &lt; 4, also x_1 \\in \\{2,3\\} (denn x_2 = 8-x_1 \\le 6 verlangt x_1 \\ge 2) und entsprechend x_2 \\in \\{5,6\\}. Aus 36 Ko"},{"seite":"anhang-loesungen.html","titel":"Finde den Denkfehler 6.1 — Die Betriebsvereinbarung, die niemanden interessiert","anker":"finde-den-denkfehler-6.1-die-betriebsvereinbarung-die-niemanden-interessiert","text":""},{"seite":"anhang-loesungen.html","titel":"Micro-Quiz","anker":"quiz-loesung-cpsat","text":"1 — (b) wirkungslos. INFEASIBLE ist kein Abbruch, sondern ein Beweis: CP-SAT hat gezeigt, dass keine zulässige Lösung existiert. Mehr Zeit (a) oder mehr Arbeiter (c) ändern daran n"},{"seite":"anhang-loesungen.html","titel":"Selbsttest","anker":"selbsttest-loesung-cpsat","text":""},{"seite":"anhang-loesungen.html","titel":"A.8 Lösungen zu Kapitel „Graphen, Flüsse und Touren — Min-Cost-Flow, Matching und VRP“","anker":"sec:loesungen-graphen","text":"7.1 — Flusserhaltung. b_i = (15+3) - (12+8) = -2 → Senke (Nettobedarf 2)."},{"seite":"anhang-loesungen.html","titel":"Finde den Denkfehler 7.1 — Die vergessene Dimension","anker":"finde-den-denkfehler-7.1-die-vergessene-dimension","text":""},{"seite":"anhang-loesungen.html","titel":"Micro-Quiz","anker":"quiz-loesung-graphen","text":"1 — (b) totale Unimodularität. Jede quadratische Teilmatrix hat Determinante 0, +1 oder -1; bei ganzzahliger rechter Seite sind deshalb alle Ecken des zulässigen Bereichs ganzzahli"},{"seite":"anhang-loesungen.html","titel":"Selbsttest","anker":"selbsttest-loesung-graphen","text":""},{"seite":"anhang-loesungen.html","titel":"A.9 Lösungen zu Kapitel „Metaheuristiken — wenn der exakte Solver aussteigt“","anker":"sec:loesungen-metaheuristiken","text":"Die Kurzsichtigkeit von Hand. Ab Schwarz wählt die Faustregel: Schwarz → Dunkelrot (26) → Rot (5) → … und muss dann in die helle Gruppe: Rot → Weiß (50) → Elfenbein (2) → Beige (2)"},{"seite":"anhang-loesungen.html","titel":"Finde den Denkfehler — „Unsere Heuristik ist 6 % besser“","anker":"denkfehler-loesung-metaheuristiken","text":"Es fehlt die Schranke."},{"seite":"anhang-loesungen.html","titel":"Micro-Quiz","anker":"quiz-loesung-metaheuristiken","text":"1. b) Eine lokale Suche lebt von der Zahl geprüfter Züge. Die volle Summe kostet O(n) statt O(1) — bei 500 Aufträgen zwei Größenordnungen weniger Züge im selben Zeitbudget. Numeris"},{"seite":"anhang-loesungen.html","titel":"Selbsttest","anker":"selbsttest-loesung-metaheuristiken","text":""},{"seite":"anhang-loesungen.html","titel":"A.10 Lösungen zu Kapitel „Spaltengenerierung“","anker":"sec:loesungen-dekomposition","text":"Das Abbruchkriterium. Die Eins ist der Zielfunktionskoeffizient eines Musters: Jedes geschnittene Muster verbraucht genau eine Mutterrolle, und die Zielfunktion lautet \\min \\sum_p "},{"seite":"anhang-loesungen.html","titel":"Finde den Denkfehler — „Die LP-Lösung sagt 72,92 — also runden wir auf“","anker":"denkfehler-loesung-dekomposition","text":"Das Aufrunden kostet sechs Rollen — acht Prozent."},{"seite":"anhang-loesungen.html","titel":"Micro-Quiz","anker":"quiz-loesung-dekomposition","text":"1. b) Das Mustermodell kennt keine einzelnen Rollen und damit keine austauschbaren Objekte — die Symmetrie verschwindet. (a) trifft zufällig auch zu, ist aber nicht der Grund; (c) "},{"seite":"anhang-loesungen.html","titel":"Selbsttest","anker":"selbsttest-loesung-dekomposition","text":""},{"seite":"anhang-loesungen.html","titel":"A.11 Lösungen zu Kapitel „Quadratische und nichtlineare Optimierung — KKT, Lagrange, Konvexität“","anker":"sec:loesungen-qp-nlp","text":"8.1 — Konvexität einordnen. PSD (alle \\ge 0) → konvex, aber nicht streng konvex; die Lösung ist nicht notwendig eindeutig. Der Eigenwert 0 bedeutet eine flache Richtung: Entlang de"},{"seite":"anhang-loesungen.html","titel":"Finde den Denkfehler 8.1 — Die Kovarianzmatrix aus dem Controlling","anker":"finde-den-denkfehler-8.1-die-kovarianzmatrix-aus-dem-controlling","text":""},{"seite":"anhang-loesungen.html","titel":"Micro-Quiz","anker":"quiz-loesung-qp-nlp","text":"1 — (b). Der DCPError ist eine inhaltliche Aussage: Für diese Formulierung kann es keine Optimalitätsgarantie geben. Auf scipy auszuweichen (a) beseitigt die Meldung, nicht die Urs"},{"seite":"anhang-loesungen.html","titel":"Selbsttest","anker":"selbsttest-loesung-qp-nlp","text":""},{"seite":"anhang-loesungen.html","titel":"A.12 Lösungen zu Kapitel „Optimierung unter Unsicherheit — Monte-Carlo, Stochastik, Robustheit“","anker":"sec:loesungen-unsicherheit","text":"9.1 — Fluch des Durchschnitts. Weil sich Verzögerungen fortpflanzen und die Verteilung rechtsschief ist: Ein Gewerk, das früher fertig wird, beschleunigt selten den Gesamtablauf (d"},{"seite":"anhang-loesungen.html","titel":"Finde den Denkfehler 9.1 — Warum jedes Projekt zu spät fertig wird","anker":"finde-den-denkfehler-9.1-warum-jedes-projekt-zu-spät-fertig-wird","text":""},{"seite":"anhang-loesungen.html","titel":"Micro-Quiz","anker":"quiz-loesung-unsicherheit","text":"1 — (b). Das kritische Verhältnis 1400/(1400+120) = 0{,}921 gibt an, wie weit man sich auf die günstigere Fehlerseite stellen soll: Bestellt wird das 92,1-%-Quantil des Bedarfs, hi"},{"seite":"anhang-loesungen.html","titel":"Selbsttest","anker":"selbsttest-loesung-unsicherheit","text":""},{"seite":"anhang-loesungen.html","titel":"A.13 Lösungen zu Kapitel „Dynamische Programmierung — Die Bellman-Gleichung und Order-Execution“","anker":"sec:loesungen-dynamische-programmierung","text":"10.1 — Bausteine. Stufe = Tag 1–5; Zustand = verbleibende Distanz (ggf. plus Erschöpfungsgrad); Aktion = heutige Tagesetappe; Wertfunktion = minimale Restanstrengung. Nicht in den "},{"seite":"anhang-loesungen.html","titel":"Finde den Denkfehler 10.1 — Der Zustand, der zu wenig weiß","anker":"finde-den-denkfehler-10.1-der-zustand-der-zu-wenig-weiß","text":""},{"seite":"anhang-loesungen.html","titel":"Micro-Quiz","anker":"quiz-loesung-dynamische-programmierung","text":"1 — (b). V_t setzt V_{t+1} voraus: Eine Entscheidung lässt sich erst bewerten, wenn feststeht, was sie für die Zukunft bedeutet. Am Ende ist dieser Wert bekannt (V_T = g), deshalb "},{"seite":"anhang-loesungen.html","titel":"Selbsttest","anker":"selbsttest-loesung-dynamische-programmierung","text":""},{"seite":"anhang-loesungen.html","titel":"A.14 Lösungen zu Kapitel „Mehrere Ziele — Pareto-Fronten statt Gewichte“","anker":"sec:loesungen-mehrziel","text":"Dominanz prüfen. P (14 000 €, 6 000 kg) und Q (13 800 €, 6 100 kg): keiner dominiert den anderen. Q ist billiger, P ist sauberer — beide sind pareto-optimal, die Wahl ist eine Präf"},{"seite":"anhang-loesungen.html","titel":"Finde den Denkfehler — „Wir haben die Gewichte sauber kalibriert“","anker":"denkfehler-loesung-mehrziel","text":"Der Lösungsraum wurde nicht vollständig abgetastet — und zwar aus prinzipiellen Gründen."},{"seite":"anhang-loesungen.html","titel":"Micro-Quiz","anker":"quiz-loesung-mehrziel","text":"1. b) Geometrisch heißt „gewichtete Summe minimieren“: eine Gerade von links unten an die Punktwolke schieben. Sie berührt immer einen Eckpunkt der unteren konvexen Hülle; Punkte d"},{"seite":"anhang-loesungen.html","titel":"Selbsttest","anker":"selbsttest-loesung-mehrziel","text":""},{"seite":"anhang-loesungen.html","titel":"A.15 Lösungen zu Kapitel „Predict-then-Optimize“","anker":"sec:loesungen-prognose","text":"Andere Preise. Der Überhang kostet nur noch 1,50 €, die Fehlmenge weiterhin 6 €. Das kritische Verhältnis steigt von 6/9 = 0{,}667 auf 6/7{,}5 = 0{,}80. Die Bestellmenge verschiebt"},{"seite":"anhang-loesungen.html","titel":"Finde den Denkfehler — „Wir haben die Prognose um 18 % verbessert“","anker":"denkfehler-loesung-prognose","text":"Der Sicherheitszuschlag stammt aus den Residuen des alten Modells."},{"seite":"anhang-loesungen.html","titel":"Micro-Quiz","anker":"quiz-loesung-prognose","text":"1. b) Die Kostenasymmetrie verschiebt das Optimum vom Erwartungswert zum kritischen Quantil. (a) und (c) sind reale Probleme, aber nicht dieses: Selbst bei perfekt bekannter, norma"},{"seite":"anhang-loesungen.html","titel":"Selbsttest","anker":"selbsttest-loesung-prognose","text":""},{"seite":"anhang-loesungen.html","titel":"A.16 Lösungen zu Kapitel „Die Strukturbrücke — dieselbe Mathematik, zwei Welten“","anker":"sec:loesungen-bruecke","text":"Die dritte Ressource. „Liquidität” — wie schnell sich eine Position ohne Kursabschlag verkaufen lässt — entspricht in der Werkstatt der Umrüstbarkeit oder der Vorlaufzeit: Wie schn"},{"seite":"anhang-loesungen.html","titel":"Finde den Denkfehler — „Das ist doch dasselbe Problem“","anker":"denkfehler-loesung-bruecke","text":"Fehler 1: Varianz ist hier das falsche Risikomaß — genau der Fall, für den es CVaR gibt."},{"seite":"anhang-loesungen.html","titel":"Micro-Quiz","anker":"quiz-loesung-bruecke","text":"1. b) Beide Probleme haben dieselbe Struktur: knappe Größen auf konkurrierende Verwendungen verteilen. (a) ist falsch — Produktionsproblem ist streng typisiert und validiert beim E"},{"seite":"anhang-loesungen.html","titel":"Selbsttest","anker":"selbsttest-loesung-bruecke","text":""},{"seite":"anhang-loesungen.html","titel":"A.17 Lösungen zu Kapitel „Supply-Chain und Energieeinsatz unter Unsicherheit“","anker":"sec:loesungen-supplychain","text":"Der Umschlagpunkt. Bei 60 MW statt 120 MW halbiert sich die Grenzkostendifferenz je Stunde (83 €/MWh × 60 MW = 4 980 €/h). Der Umschlagpunkt verdoppelt sich auf 7,7 Stunden."},{"seite":"anhang-loesungen.html","titel":"Finde den Denkfehler — „Wir rechnen mit dem P50-Szenario“","anker":"denkfehler-loesung-supplychain","text":"Fehler 1: Der Median ist keine Absicherung, sondern eine Wette auf die Hälfte der Fälle."},{"seite":"anhang-loesungen.html","titel":"Micro-Quiz","anker":"quiz-loesung-supplychain","text":"1. b) Anfahrkosten und Mindestlaufzeiten koppeln die Stunden. Die Merit-Order ist eine Sortierung und kennt keine Kopplung über die Zeit; sie ist für einen einzelnen Zeitpunkt rich"},{"seite":"anhang-loesungen.html","titel":"Selbsttest","anker":"selbsttest-loesung-supplychain","text":""},{"seite":"anhang-loesungen.html","titel":"A.18 Lösungen zu Kapitel „Finanzdaten-Modellierung — Renditen, Kovarianz und Shrinkage“","anker":"sec:loesungen-finanzdaten","text":"11.1 — Renditeart. (a) diskret. (b) logarithmisch. (c) logarithmisch (bzw. diskret kumuliert über Produkt). (d) logarithmisch (statistische Eigenschaften)."},{"seite":"anhang-loesungen.html","titel":"Finde den Denkfehler 11.1 — Das risikofreie Portfolio","anker":"finde-den-denkfehler-11.1-das-risikofreie-portfolio","text":""},{"seite":"anhang-loesungen.html","titel":"Micro-Quiz","anker":"quiz-loesung-finanzdaten","text":"1 — (b) bei 75 %. 1{,}0 \\cdot 0{,}5 \\cdot 1{,}5 = 0{,}75. Prozentuale Änderungen verknüpfen sich multiplikativ; ein Verlust wiegt schwerer als ein gleich großer Gewinn, weil er von"},{"seite":"anhang-loesungen.html","titel":"Selbsttest","anker":"selbsttest-loesung-finanzdaten","text":""},{"seite":"anhang-loesungen.html","titel":"A.19 Lösungen zu Kapitel „Die moderne Portfoliotheorie nach Markowitz“","anker":"sec:loesungen-markowitz","text":"12.1 — Diversifikationseffekt."},{"seite":"anhang-loesungen.html","titel":"Finde den Denkfehler 12.1 — Zwölf gleiche Anlagen, ein sehr ungleiches Portfolio","anker":"finde-den-denkfehler-12.1-zwölf-gleiche-anlagen-ein-sehr-ungleiches-portfolio","text":""},{"seite":"anhang-loesungen.html","titel":"Micro-Quiz","anker":"quiz-loesung-markowitz","text":"1 — (b). Das renditestärkste Portfolio auf der Effizienzlinie hat notwendig das schlechteste Rendite-Risiko-Verhältnis (im Kapitelbeispiel 0,44 gegenüber 0,75 beim Optimum) und bes"},{"seite":"anhang-loesungen.html","titel":"Selbsttest","anker":"selbsttest-loesung-markowitz","text":""},{"seite":"anhang-loesungen.html","titel":"A.20 Lösungen zu Kapitel „Tail-Risiko, CVaR und Transaktionskosten“","anker":"sec:loesungen-cvar","text":"13.1 — VaR und CVaR von Hand. Sortierte Verluste: -2{,}0; -1{,}2; -0{,}8; -0{,}4; 0{,}3; 0{,}6; 1{,}1; 2{,}1; 5{,}4; 8{,}9. Das 80 %-Quantil ist der 8. Wert: \\text{VaR}_{80\\%} = 2{"},{"seite":"anhang-loesungen.html","titel":"Finde den Denkfehler 13.1 — Das Risikobudget, das durch Diversifikation stieg","anker":"finde-den-denkfehler-13.1-das-risikobudget-das-durch-diversifikation-stieg","text":""},{"seite":"anhang-loesungen.html","titel":"Micro-Quiz","anker":"quiz-loesung-cvar","text":"1 — (b) nichts. Der VaR ist ein Quantil: Er markiert die Schwelle und sagt nichts über den Bereich dahinter. Genau das zeigt der Schnellstart dieses Kapitels — zwei Anlagen mit ide"},{"seite":"anhang-loesungen.html","titel":"Selbsttest","anker":"selbsttest-loesung-cvar","text":""},{"seite":"anhang-loesungen.html","titel":"A.21 Lösungen zu Kapitel „Die vollständige quantitative Handelsmaschine“","anker":"sec:loesungen-handelsmaschine","text":"14.1 — Lookahead erkennen. (a) sauber (:heute). (b) Lookahead — gesamter Zeitraum. (c) Lookahead — Volatilität über den ganzen Zeitraum enthält Zukunft. (d) sauber — Gewichte aus D"},{"seite":"anhang-loesungen.html","titel":"Finde den Denkfehler 14.1 — Die Strategie mit dem hochsignifikanten Ergebnis","anker":"finde-den-denkfehler-14.1-die-strategie-mit-dem-hochsignifikanten-ergebnis","text":""},{"seite":"anhang-loesungen.html","titel":"Micro-Quiz","anker":"quiz-loesung-handelsmaschine","text":"1 — (b) nichts. Beide Kennzahlen sind Mittelwerte über die Zeit und blind für die Reihenfolge. Der Schnellstart dieses Kapitels zeigt es an denselben Tagesrenditen, nur anders ange"},{"seite":"anhang-loesungen.html","titel":"Selbsttest","anker":"selbsttest-loesung-handelsmaschine","text":""},{"seite":"anhang-loesungen.html","titel":"A.22 Lösungen zu Kapitel „Praxisfallen und der Weg zum produktiven Einsatz“","anker":"sec:loesungen-praxisfallen","text":"15.1 — Hart oder weich, revisited. (a) hart: gesetzliche Ruhezeit, Qualifikationspflicht. (b) weich: individuelle Wunschtage, Vermeidung von Freistunden. (c) diskutabel: Höchstzahl"},{"seite":"anhang-loesungen.html","titel":"Finde den Denkfehler 15.1 — Das Modell, das seit einem Jahr nicht mehr optimiert","anker":"finde-den-denkfehler-15.1-das-modell-das-seit-einem-jahr-nicht-mehr-optimiert","text":""},{"seite":"anhang-loesungen.html","titel":"Micro-Quiz","anker":"quiz-loesung-praxisfallen","text":"1 — (b) das Zeitlimit greift. Eine Laufzeit, die exakt dem Limit entspricht und über Monate konstant bleibt, ist kein Stabilitätsbeleg, sondern zeigt, dass der Solver jedes Mal abg"},{"seite":"anhang-loesungen.html","titel":"Selbsttest","anker":"selbsttest-loesung-praxisfallen","text":""},{"seite":"anhang-loesungen.html","titel":"A.23 Lösungen zu Kapitel „Testen, Messen, Ausliefern“","anker":"sec:loesungen-testing","text":"Den Schnellstart reparieren. Zwei Wege: (a) Abrunden statt runden — np.floor statt np.round. Das ist immer zulässig, weil weniger produzieren nie eine Kapazität sprengt, kostet abe"},{"seite":"anhang-loesungen.html","titel":"Finde den Denkfehler — „Die Suite ist grün, das Modell stimmt”","anker":"denkfehler-loesung-testing","text":"Alle Prüfungen benutzen dieselbe falsche Zahl."},{"seite":"anhang-loesungen.html","titel":"Micro-Quiz","anker":"quiz-loesung-testing","text":"1. b) Es gibt keine unabhängige Quelle für die richtige Antwort — sonst bräuchte man den Solver nicht. (a) ist bei festgelegtem Seed und Zeitlimit meist beherrschbar; (c) löst man "},{"seite":"anhang-loesungen.html","titel":"Selbsttest","anker":"selbsttest-loesung-testing","text":""},{"seite":"anhang-modellierungsmuster.html","titel":"Anhang B: Katalog der Modellierungsmuster","anker":null,"text":""},{"seite":"anhang-modellierungsmuster.html","titel":"Übersicht","anker":"übersicht","text":""},{"seite":"anhang-modellierungsmuster.html","titel":"Logische Schalter","anker":"logische-schalter","text":""},{"seite":"anhang-modellierungsmuster.html","titel":"B1 — Aktivierungsschalter (Fixkosten)","anker":"b1-aktivierungsschalter-fixkosten","text":"Regel. „Wenn überhaupt etwas produziert wird, fallen Rüstkosten F an.“"},{"seite":"anhang-modellierungsmuster.html","titel":"B2 — Semikontinuierliche Variable","anker":"b2-semikontinuierliche-variable","text":"Regel. „Entweder gar nicht oder mindestens L (und höchstens U).“"},{"seite":"anhang-modellierungsmuster.html","titel":"B3 — Implikation","anker":"b3-implikation","text":"Regel. „Wenn A gewählt wird, muss auch B gewählt werden.“"},{"seite":"anhang-modellierungsmuster.html","titel":"B4 — Entweder-Oder (disjunktive Bedingung)","anker":"b4-entweder-oder-disjunktive-bedingung","text":"Regel. „Es muss f(\\mathbf{x}) \\le b_1 oder g(\\mathbf{x}) \\le b_2 gelten.“"},{"seite":"anhang-modellierungsmuster.html","titel":"B5 — Exklusiv-Oder","anker":"b5-exklusiv-oder","text":"Regel. „Genau eine der Optionen wird gewählt.“"},{"seite":"anhang-modellierungsmuster.html","titel":"B6 — Kardinalität","anker":"b6-kardinalität","text":"Regel. „Höchstens (mindestens, genau) K von N.“"},{"seite":"anhang-modellierungsmuster.html","titel":"B7 — Bedingte Kopplung (Konjunktion)","anker":"b7-bedingte-kopplung-konjunktion","text":"Regel. „Wenn A und B, dann auch C.“"},{"seite":"anhang-modellierungsmuster.html","titel":"Mengen und Grenzen","anker":"mengen-und-grenzen","text":""},{"seite":"anhang-modellierungsmuster.html","titel":"B8 — Weiche Grenze mit Strafkosten","anker":"b8-weiche-grenze-mit-strafkosten","text":"Regel. „Möglichst nicht über b — wenn doch, kostet es.“"},{"seite":"anhang-modellierungsmuster.html","titel":"B9 — Gestaffelte Preise (stückweise linear)","anker":"b9-gestaffelte-preise-stückweise-linear","text":"Regel. „Die ersten 100 Stück kosten 5 €, danach 8 €.“"},{"seite":"anhang-modellierungsmuster.html","titel":"B10 — Absolutbetrag / Abweichung","anker":"b10-absolutbetrag-abweichung","text":"Regel. „Die Abweichung vom Zielwert soll klein sein, egal in welche Richtung.“"},{"seite":"anhang-modellierungsmuster.html","titel":"B11 — Min/Max in der Zielfunktion","anker":"b11-minmax-in-der-zielfunktion","text":"Regel. „Der am schlechtesten gestellte Beteiligte soll möglichst gut dastehen“ (Maximin/Fairness)."},{"seite":"anhang-modellierungsmuster.html","titel":"B12 — Verhältnis-Bedingung","anker":"b12-verhältnis-bedingung","text":"Regel. „Der Anteil von Gruppe G soll mindestens 30 % betragen.“"},{"seite":"anhang-modellierungsmuster.html","titel":"B25 — Mindestabnahmemenge über einen Zeitraum","anker":"b25-mindestabnahmemenge-über-einen-zeitraum","text":"Regel. „Entweder wir arbeiten mit diesem Lieferanten gar nicht, oder wir nehmen ihm im Jahr mindestens 500 Einheiten ab.“"},{"seite":"anhang-modellierungsmuster.html","titel":"B27 — Budgetlimit","anker":"b27-budgetlimit","text":"Regel. „Alle Maßnahmen zusammen dürfen 2 Mio. € nicht überschreiten.“"},{"seite":"anhang-modellierungsmuster.html","titel":"Zeit und Reihenfolge","anker":"zeit-und-reihenfolge","text":""},{"seite":"anhang-modellierungsmuster.html","titel":"B13 — Vorrangbeziehung","anker":"b13-vorrangbeziehung","text":"Regel. „Arbeitsgang B darf erst beginnen, wenn A fertig ist.“"},{"seite":"anhang-modellierungsmuster.html","titel":"B14 — Nichtüberlappung","anker":"b14-nichtüberlappung","text":"Regel. „Eine Maschine bearbeitet nur einen Job gleichzeitig.“"},{"seite":"anhang-modellierungsmuster.html","titel":"B15 — Kumulative Ressource","anker":"b15-kumulative-ressource","text":"Regel. „Zu keinem Zeitpunkt dürfen mehr als 3 Arbeiten gleichzeitig laufen“ bzw. „die Stromlast darf 500 kW nie übersteigen“."},{"seite":"anhang-modellierungsmuster.html","titel":"B16 — Gleitendes Fenster","anker":"b16-gleitendes-fenster","text":"Regel. „Höchstens 5 Arbeitstage in Folge“ / „mindestens 2 freie Tage je Woche“."},{"seite":"anhang-modellierungsmuster.html","titel":"B17 — Umrüst- bzw. Wechselkosten","anker":"b17-umrüst--bzw.-wechselkosten","text":"Regel. „Ein Produktwechsel kostet Rüstzeit.“"},{"seite":"anhang-modellierungsmuster.html","titel":"B26 — Rüstzeit als Kapazitätsverbrauch","anker":"b26-rüstzeit-als-kapazitätsverbrauch","text":"Regel. „Das Umrüsten kostet nicht nur Geld, es kostet Maschinenstunden — und die fehlen dann für die Produktion.“"},{"seite":"anhang-modellierungsmuster.html","titel":"Robustheit und Diagnose","anker":"robustheit-und-diagnose","text":""},{"seite":"anhang-modellierungsmuster.html","titel":"B18 — Schlupfvariablen gegen Unlösbarkeit","anker":"b18-schlupfvariablen-gegen-unlösbarkeit","text":"Das wichtigste Muster für den Produktivbetrieb."},{"seite":"anhang-modellierungsmuster.html","titel":"B19 — Hierarchische Ziele (lexikografisch)","anker":"b19-hierarchische-ziele-lexikografisch","text":"Regel. „Erst die Besetzung sicherstellen, dann die Fairness optimieren.“"},{"seite":"anhang-modellierungsmuster.html","titel":"B20 — Symmetriebrechung","anker":"b20-symmetriebrechung","text":"Regel. „Drei identische Maschinen — der Solver soll nicht alle Vertauschungen durchprobieren.“"},{"seite":"anhang-modellierungsmuster.html","titel":"B21 — Worst-Case-Abzug (robuste Formulierung)","anker":"b21-worst-case-abzug-robuste-formulierung","text":"Regel. „Rechne nicht mit dem geschätzten Wert, sondern mit dem ungünstigsten plausiblen.“"},{"seite":"anhang-modellierungsmuster.html","titel":"Netzwerke","anker":"netzwerke","text":""},{"seite":"anhang-modellierungsmuster.html","titel":"B22 — Flusserhaltung","anker":"b22-flusserhaltung","text":"\\sum_{j:(i,j)\\in E} x_{ij} - \\sum_{k:(k,i)\\in E} x_{ki} = b_i \\qquad \\forall i"},{"seite":"anhang-modellierungsmuster.html","titel":"B23 — Zuordnung 1:1","anker":"b23-zuordnung-11","text":""},{"seite":"anhang-modellierungsmuster.html","titel":"B24 — Subtour-Eliminierung","anker":"b24-subtour-eliminierung","text":"MTZ (einfach, aber schwach): u_i - u_j + C x_{ij} \\le C - d_j \\qquad \\forall i\\ne j"},{"seite":"anhang-modellierungsmuster.html","titel":"Ein Wort zur Auswahl","anker":"ein-wort-zur-auswahl","text":"Wenn mehrere Muster passen, entscheiden Sie nach dieser Reihenfolge:"},{"seite":"anhang-fehlerdiagnose.html","titel":"Anhang C: Fehlerdiagnose-Handbuch","anker":null,"text":""},{"seite":"anhang-fehlerdiagnose.html","titel":"Symptom-Schnellübersicht","anker":"symptom-schnellübersicht","text":""},{"seite":"anhang-fehlerdiagnose.html","titel":"C1 — INFEASIBLE","anker":"c1-infeasible","text":"Bedeutung. Es gibt keinen einzigen Punkt, der alle Bedingungen gleichzeitig erfüllt. Das ist eine Aussage über Ihr Modell, nicht über den Solver."},{"seite":"anhang-fehlerdiagnose.html","titel":"Diagnose in fünf Schritten","anker":"diagnose-in-fünf-schritten","text":"Schritt 1 — Trivialprüfungen von Hand. Rechnen Sie die offensichtlichen Bilanzen nach, bevor Sie den Solver befragen:"},{"seite":"anhang-fehlerdiagnose.html","titel":"Wenn die fünf Schritte nicht reichen: den Konflikt einkreisen","anker":"wenn-die-fünf-schritte-nicht-reichen-den-konflikt-einkreisen","text":"Warum Schritt 2 so oft ins Leere läuft. Bedingungen einzeln abzuschalten funktioniert nur, solange es einen Schuldigen gibt. Überlagern sich zwei unabhängige Widersprüche, bleibt d"},{"seite":"anhang-fehlerdiagnose.html","titel":"C2 — UNBOUNDED","anker":"c2-unbounded","text":"Bedeutung. Die Zielfunktion lässt sich unbegrenzt verbessern."},{"seite":"anhang-fehlerdiagnose.html","titel":"C3 — Zu langsam","anker":"c3-zu-langsam","text":""},{"seite":"anhang-fehlerdiagnose.html","titel":"Diagnosereihenfolge","anker":"diagnosereihenfolge","text":"1. Ist es überhaupt das Lösen?"},{"seite":"anhang-fehlerdiagnose.html","titel":"C4 — Unsinniges Ergebnis","anker":"c4-unsinniges-ergebnis","text":"Der Solver hat immer recht — bezogen auf das Modell, das Sie ihm gegeben haben. Wenn das Ergebnis unsinnig ist, beschreibt Ihr Modell nicht das Problem, das Sie meinen."},{"seite":"anhang-fehlerdiagnose.html","titel":"Checkliste","anker":"checkliste","text":""},{"seite":"anhang-fehlerdiagnose.html","titel":"Die wirksamste Gegenmaßnahme","anker":"die-wirksamste-gegenmaßnahme","text":""},{"seite":"anhang-fehlerdiagnose.html","titel":"C5 — Instabile Lösung","anker":"c5-instabile-lösung","text":"Symptom. Ein zusätzlicher Handelstag, und das Portfolio sieht völlig anders aus."},{"seite":"anhang-fehlerdiagnose.html","titel":"Derselbe Fehler außerhalb der Finanzwelt","anker":"derselbe-fehler-außerhalb-der-finanzwelt","text":"Instabilität ist kein Portfolioproblem, sondern ein Skalierungsproblem — und es trifft jedes Modell, in dem Größen sehr verschiedener Ordnung nebeneinanderstehen. Euro-Beträge (10^"},{"seite":"anhang-fehlerdiagnose.html","titel":"C6 — Falsche Dualwerte","anker":"c6-falsche-dualwerte","text":"Symptom. Schattenpreise sind negativ, wo sie positiv sein sollten — oder null bei einer offensichtlich knappen Ressource."},{"seite":"anhang-fehlerdiagnose.html","titel":"Die drei Prüfungen","anker":"die-drei-prüfungen","text":"1. Vorzeichenkonvention. Haben Sie zur Maximierung negiert?"},{"seite":"anhang-fehlerdiagnose.html","titel":"C7 — Widersprüchliche Solver","anker":"c7-widersprüchliche-solver","text":"Symptom. linprog sagt 530, CVXPY sagt 529,8."},{"seite":"anhang-fehlerdiagnose.html","titel":"C8 — DCPError","anker":"c8-dcperror","text":""},{"seite":"anhang-fehlerdiagnose.html","titel":"C9 — Importfehler","anker":"c9-importfehler","text":""},{"seite":"anhang-fehlerdiagnose.html","titel":"C10 — Verdächtig guter Backtest","anker":"c10-verdächtig-guter-backtest","text":"Faustregel: Eine Sharpe Ratio über 2 bei einer einfachen Strategie ist fast immer ein Fehler, kein Fund."},{"seite":"anhang-fehlerdiagnose.html","titel":"Prüfreihenfolge","anker":"prüfreihenfolge","text":"1. Lookahead-Selbsttest."},{"seite":"anhang-fehlerdiagnose.html","titel":"C11 — Vertauschte Spalten","anker":"c11-vertauschte-spalten","text":"Symptom. Ergebnisse sind plausibel, aber falsch beschriftet — oder eine Sektorgrenze greift auf die falschen Titel."},{"seite":"anhang-fehlerdiagnose.html","titel":"Die goldene Diagnoseregel","anker":"die-goldene-diagnoseregel","text":""},{"seite":"anhang-spickzettel.html","titel":"Anhang D: Spickzettel der Solver","anker":null,"text":""},{"seite":"anhang-spickzettel.html","titel":"D1 — SciPy: linprog und milp","anker":"d1-scipy-linprog-und-milp","text":"Wofür. Die Einstiegsschicht: keine zusätzliche Installation, HiGHS als Unterbau, ideal für lineare und gemischt-ganzzahlige Probleme in Matrixform. Wofür nicht: alles, was sich nic"},{"seite":"anhang-spickzettel.html","titel":"Lineares Programm","anker":"lineares-programm","text":""},{"seite":"anhang-spickzettel.html","titel":"Ganzzahlig: milp","anker":"ganzzahlig-milp","text":""},{"seite":"anhang-spickzettel.html","titel":"Die drei häufigsten Stolpersteine","anker":"die-drei-häufigsten-stolpersteine","text":""},{"seite":"anhang-spickzettel.html","titel":"D2 — HiGHS über highspy","anker":"d2-highs-über-highspy","text":"Wofür. Derselbe Solver wie unter SciPy, aber direkt gesteuert: Optionen, Warm-Starts, inkrementelles Ändern eines bestehenden Modells. Wofür nicht: schnelles Hinschreiben — die CSR"},{"seite":"anhang-spickzettel.html","titel":"Die drei häufigsten Stolpersteine","anker":"die-drei-häufigsten-stolpersteine-1","text":""},{"seite":"anhang-spickzettel.html","titel":"D3 — OR-Tools: pywraplp","anker":"d3-or-tools-pywraplp","text":"Wofür. Bequeme algebraische Schreibweise für LP und MILP mit umschaltbarem Backend (GLOP, SCIP, CBC, SAT). Wofür nicht: Scheduling und kombinatorische Bedingungen — dafür ist CP-SA"},{"seite":"anhang-spickzettel.html","titel":"Die drei häufigsten Stolpersteine","anker":"die-drei-häufigsten-stolpersteine-2","text":""},{"seite":"anhang-spickzettel.html","titel":"D4 — CP-SAT: cp_model","anker":"d4-cp-sat-cp_model","text":"Wofür. Scheduling, Zuordnung, Reihenfolgen, alles Kombinatorische mit globalen Bedingungen. Wofür nicht: stetige Größen — CP-SAT rechnet ausschließlich ganzzahlig. Wer Nachkommaste"},{"seite":"anhang-spickzettel.html","titel":"Die drei häufigsten Stolpersteine","anker":"die-drei-häufigsten-stolpersteine-3","text":""},{"seite":"anhang-spickzettel.html","titel":"D5 — CVXPY","anker":"d5-cvxpy","text":"Wofür. Konvexe Probleme: quadratische Ziele, Normen, CVaR, alles mit Regularisierungstermen. Wofür nicht: große kombinatorische Modelle — der Aufbau der Ausdrücke wird dann selbst "},{"seite":"anhang-spickzettel.html","titel":"Die drei häufigsten Stolpersteine","anker":"die-drei-häufigsten-stolpersteine-4","text":""},{"seite":"anhang-spickzettel.html","titel":"D6 — Modellierungssprachen: Pyomo und Linopy","anker":"d6-modellierungssprachen-pyomo-und-linopy","text":"Wofür. Beide trennen Modell von Solver: dasselbe Modell läuft ohne Änderung unter HiGHS, CBC, Gurobi. Pyomo denkt in Mengen und Indizes wie eine mathematische Formulierung; Linopy "},{"seite":"anhang-spickzettel.html","titel":"Pyomo","anker":"pyomo","text":""},{"seite":"anhang-spickzettel.html","titel":"Linopy","anker":"linopy","text":""},{"seite":"anhang-spickzettel.html","titel":"Die drei häufigsten Stolpersteine","anker":"die-drei-häufigsten-stolpersteine-5","text":""},{"seite":"anhang-spickzettel.html","titel":"Die gemeinsame Regel","anker":"die-gemeinsame-regel","text":"Alle sechs Seiten haben denselben längsten Abschnitt: die Statusauswertung. Das ist kein Zufall. Ein Solveraufruf hat nie zwei Ausgänge, sondern mindestens fünf — optimal, zulässig"},{"seite":"anhang-glossar-literatur.html","titel":"Anhang E: Glossar und Literatur","anker":null,"text":""},{"seite":"anhang-glossar-literatur.html","titel":"Mathematische Optimierung — Grundlagen","anker":"mathematische-optimierung-grundlagen","text":""},{"seite":"anhang-glossar-literatur.html","titel":"Konvexe, nichtlineare und robuste Optimierung","anker":"konvexe-nichtlineare-und-robuste-optimierung","text":""},{"seite":"anhang-glossar-literatur.html","titel":"Constraint Programming und Scheduling","anker":"constraint-programming-und-scheduling","text":""},{"seite":"anhang-glossar-literatur.html","titel":"Quantitative Finanzmathematik","anker":"quantitative-finanzmathematik","text":""},{"seite":"anhang-glossar-literatur.html","titel":"Software und Dokumentation","anker":"software-und-dokumentation","text":""},{"seite":"anhang-glossar-literatur.html","titel":"Verbände und Normen","anker":"verbände-und-normen","text":""}];
+window.OR_SEARCH_INDEX = [{"seite":"vorwort.html","titel":"Vorwort & Lesehilfe","anker":null,"text":""},{"seite":"notation.html","titel":"Notation & Abkürzungen","anker":null,"text":""},{"seite":"notation.html","titel":"1. Die Symbole der Optimierung","anker":"die-symbole-der-optimierung","text":""},{"seite":"notation.html","titel":"1.1 Grundgrößen jedes Modells","anker":"grundgrößen-jedes-modells","text":""},{"seite":"notation.html","titel":"1.2 Mengen und Zahlbereiche","anker":"mengen-und-zahlbereiche","text":""},{"seite":"notation.html","titel":"1.3 Operatoren und Schreibweisen","anker":"operatoren-und-schreibweisen","text":""},{"seite":"notation.html","titel":"1.4 Symbole der Finanzkapitel (Teil IV)","anker":"symbole-der-finanzkapitel-teil-iv","text":""},{"seite":"notation.html","titel":"1.5 Symbole der Verfahrenskapitel (Teil II und III)","anker":"symbole-der-verfahrenskapitel-teil-ii-und-iii","text":"Diese Zeichen kommen erst in den Kapiteln vor, die über das klassische LP hinausgehen."},{"seite":"notation.html","titel":"2. Abkürzungen — vollständig ausgeschrieben","anker":"abkürzungen-vollständig-ausgeschrieben","text":""},{"seite":"notation.html","titel":"2.1 Problemklassen und Verfahren","anker":"problemklassen-und-verfahren","text":""},{"seite":"notation.html","titel":"2.2 Probleme mit Eigennamen","anker":"probleme-mit-eigennamen","text":""},{"seite":"notation.html","titel":"2.3 Finanz- und Risikokennzahlen","anker":"finanz--und-risikokennzahlen","text":""},{"seite":"notation.html","titel":"2.4 Software, Solver und Schnittstellen","anker":"software-solver-und-schnittstellen","text":""},{"seite":"notation.html","titel":"2.5 Begriffe aus dem Solver-Alltag","anker":"begriffe-aus-dem-solver-alltag","text":""},{"seite":"notation.html","titel":"3. Konventionen in diesem Buch","anker":"konventionen-in-diesem-buch","text":"Vektoren sind grundsätzlich Spaltenvektoren und werden fett gesetzt: \\mathbf{x}. Ein transponierter Vektor \\mathbf{x}^\\top ist eine Zeile. Skalare bleiben mager: n, Z."},{"seite":"einfuehrung.html","titel":"Kapitel 1: Einführung in Operations Research — Vom Ursprung zur mathematischen Entscheidungsfindung","anker":null,"text":""},{"seite":"einfuehrung.html","titel":"1.1 In 5 Minuten gelöst","anker":"sec:einfuehrung-schnellstart","text":"Bevor wir über Theorie sprechen, lösen Sie ein echtes Problem. Kopieren Sie den folgenden Block, führen Sie ihn aus, sehen Sie das Ergebnis — die Erklärung kommt danach."},{"seite":"einfuehrung.html","titel":"1.2 Lernziele","anker":"sec:einfuehrung-lernziele","text":"Nach diesem Kapitel können Sie …"},{"seite":"einfuehrung.html","titel":"1.3 Was ist Operations Research wirklich?","anker":"sec:einfuehrung-was-ist-operations-research-wirklich","text":"Im Alltag lösen wir Probleme intuitiv: durch Ausprobieren, Daumenregeln, Erfahrung. Das funktioniert erstaunlich gut — bis eine bestimmte Schwelle überschritten wird. Dann bricht d"},{"seite":"einfuehrung.html","titel":"Die drei Stufen der Analytik","anker":"die-drei-stufen-der-analytik","text":"OR beantwortet nicht die beschreibende Frage „Was ist passiert?“ und nicht die vorhersagende Frage „Was wird passieren?“, sondern die vorschreibende (präskriptive) Kernfrage:"},{"seite":"einfuehrung.html","titel":"1.4 Warum Ausprobieren scheitert — mit eigener Rechnung","anker":"sec:einfuehrung-warum-ausprobieren-scheitert-mit-eigener-rechnung","text":"Die Behauptung „vollständiges Durchprobieren ist unmöglich“ wird oft aufgestellt und selten belegt. Rechnen wir sie einmal selbst nach — das Ergebnis prägt sich besser ein als jede"},{"seite":"einfuehrung.html","titel":"1.5 Historischer Kontext und Evolution","anker":"sec:einfuehrung-historischer-kontext-und-evolution","text":"Der Begriff entstand im Vorfeld des Zweiten Weltkriegs in Großbritannien. Militärische Führungsstäbe standen vor neuartigen logistischen und strategischen Fragen: Wie platziert man"},{"seite":"einfuehrung.html","titel":"1.6 Die vier universellen Bausteine jedes OR-Problems","anker":"sec:einfuehrung-die-vier-universellen-bausteine-jedes-or","text":"Dies ist der wichtigste Abschnitt des Kapitels. Jedes Optimierungsproblem der Welt lässt sich — unabhängig von der Branche — auf vier Elemente reduzieren. Wenn Sie später vor einem"},{"seite":"einfuehrung.html","titel":"Baustein 1 — Entscheidungsvariablen (x)","anker":"baustein-1-entscheidungsvariablen-x","text":"Die Stellschrauben des Modells: Werte, die der Algorithmus aktiv festlegen darf."},{"seite":"einfuehrung.html","titel":"Baustein 2 — Parameter / Eingabedaten (c, A, b)","anker":"baustein-2-parameter-eingabedaten-c-a-b","text":"Die unveränderlichen Fakten der Realität: historische Renditen, Maschinenstundensätze, Lagerkapazitäten, Steuerquoten, Entfernungen, Qualifikationen."},{"seite":"einfuehrung.html","titel":"Baustein 3 — Zielfunktion (f(x))","anker":"baustein-3-zielfunktion-fx","text":"Ein mathematischer Ausdruck, der die Güte einer Lösung zu einer einzigen Zahl verdichtet:"},{"seite":"einfuehrung.html","titel":"Baustein 4 — Nebenbedingungen (Constraints)","anker":"baustein-4-nebenbedingungen-constraints","text":"Regeln, die den Raum der erlaubten Lösungen einschränken:"},{"seite":"einfuehrung.html","titel":"Die vier Bausteine als eine Formel","anker":"die-vier-bausteine-als-eine-formel","text":"Setzt man die vier Bausteine zusammen, entsteht die Standardform, in der Ihnen jedes Optimierungsmodell dieses Buches begegnen wird. Sie sieht auf den ersten Blick sperrig aus — de"},{"seite":"einfuehrung.html","titel":"Die Bausteine in der Praxis: eine Vorlage","anker":"die-bausteine-in-der-praxis-eine-vorlage","text":"Damit die Zerlegung zur Gewohnheit wird, hier eine Vorlage, die Sie bei jedem neuen Problem ausfüllen können — vor der ersten Codezeile."},{"seite":"einfuehrung.html","titel":"1.7 Erstes Python-Vollbeispiel: Ressourcenallokation im Rechenzentrum","anker":"sec:einfuehrung-erstes-python-vollbeispiel-ressourcenallokation-im-rechenzentrum","text":""},{"seite":"einfuehrung.html","titel":"Szenario","anker":"szenario","text":"Ein quantitatives Handelshaus betreibt Serverkapazitäten für zwei Algorithmentypen:"},{"seite":"einfuehrung.html","titel":"Mathematische Formulierung","anker":"mathematische-formulierung","text":"Entscheidungsvariablen:"},{"seite":"einfuehrung.html","titel":"Umsetzung mit Google OR-Tools","anker":"umsetzung-mit-google-or-tools","text":""},{"seite":"einfuehrung.html","titel":"1.8 Von Excel zu Python: Ihre Daten liegen schon da","anker":"sec:einfuehrung-excel-bruecke","text":"In den allermeisten Betrieben liegen die Zahlen, die ein Optimierungsmodell braucht, nicht in einer Datenbank, sondern in einer Tabellenkalkulation. Und viele Leserinnen und Leser "},{"seite":"einfuehrung.html","titel":"1.9 Übungsaufgaben","anker":"sec:einfuehrung-uebungsaufgaben","text":""},{"seite":"einfuehrung.html","titel":"1.10 Finde den Denkfehler","anker":"sec:einfuehrung-denkfehler","text":"Ein Programm, das abstürzt, ist harmlos — Sie sehen sofort, dass etwas nicht stimmt. Gefährlich sind Programme, die fehlerfrei durchlaufen, einen Status OPTIMAL melden und eine Zah"},{"seite":"einfuehrung.html","titel":"1.11 Micro-Quiz","anker":"sec:einfuehrung-quiz","text":""},{"seite":"einfuehrung.html","titel":"1.12 Selbsttest","anker":"sec:einfuehrung-selbsttest","text":""},{"seite":"einfuehrung.html","titel":"1.13 Zusammenfassung","anker":"sec:einfuehrung-zusammenfassung","text":""},{"seite":"fundament.html","titel":"Kapitel 2: Das mathematische Fundament — Vektoren, Matrizen, Konvexität","anker":null,"text":""},{"seite":"fundament.html","titel":"2.1 In 5 Minuten gelöst","anker":"sec:fundament-schnellstart","text":"Dieses Kapitel handelt von Geometrie. Bevor wir Vektoren und Matrizen einführen, sehen Sie die zentrale Einsicht in Aktion — ganz ohne Solver, mit acht Zeilen NumPy."},{"seite":"fundament.html","titel":"2.2 Lernziele","anker":"sec:fundament-lernziele","text":"Nach diesem Kapitel können Sie …"},{"seite":"fundament.html","titel":"2.3 Warum überhaupt Vektoren und Matrizen?","anker":"sec:fundament-warum-ueberhaupt-vektoren-und-matrizen","text":"In Kapitel 1 hatten wir zwei Variablen und drei Nebenbedingungen. Das ließ sich bequem ausschreiben. Reale Modelle haben hunderte bis hunderttausende Variablen — dort wäre Ausschre"},{"seite":"fundament.html","titel":"Die Bausteine","anker":"die-bausteine","text":"Sei n die Anzahl der Entscheidungsvariablen und m die Anzahl der Nebenbedingungen."},{"seite":"fundament.html","titel":"Die kanonische Standardform","anker":"die-kanonische-standardform","text":"Damit lässt sich jedes lineare Programm in drei Zeilen schreiben:"},{"seite":"fundament.html","titel":"Dasselbe in Python","anker":"dasselbe-in-python","text":""},{"seite":"fundament.html","titel":"2.4 Der zulässige Lösungsraum und das Polyeder","anker":"sec:fundament-der-zulaessige-loesungsraum-und-das-polyeder","text":"Jede lineare Ungleichung a_{i1}x_1 + a_{i2}x_2 \\le b_i definiert geometrisch eine Halbebene (im \\mathbb{R}^2) bzw. einen Halbraum (im \\mathbb{R}^n): Die zugehörige Gleichung ist ei"},{"seite":"fundament.html","titel":"Der Fundamentalsatz der linearen Optimierung","anker":"der-fundamentalsatz-der-linearen-optimierung","text":""},{"seite":"fundament.html","titel":"2.5 Konvexität: die Grenze zwischen leicht und schwer","anker":"sec:fundament-konvexitaet-die-grenze-zwischen-leicht-und","text":"Hier kommt die vielleicht wichtigste Einsicht des ganzen Buches. In der Optimierungstheorie verläuft die Trennlinie zwischen „zuverlässig lösbar“ und „im Allgemeinen hoffnungslos“ "},{"seite":"fundament.html","titel":"Konvexe Menge","anker":"konvexe-menge","text":"Eine Menge \\mathcal{C} \\subseteq \\mathbb{R}^n heißt konvex, wenn für alle Punkte \\mathbf{x}, \\mathbf{y} \\in \\mathcal{C} und jedes \\theta \\in [0,1] gilt:"},{"seite":"fundament.html","titel":"Konvexe Funktion","anker":"konvexe-funktion","text":"Eine Funktion f: \\mathcal{C} \\to \\mathbb{R} heißt konvex, wenn für alle \\mathbf{x}, \\mathbf{y} \\in \\mathcal{C} und \\theta \\in [0,1] gilt:"},{"seite":"fundament.html","titel":"Der zentrale Satz","anker":"der-zentrale-satz","text":""},{"seite":"fundament.html","titel":"Was ist konvex, was nicht?","anker":"was-ist-konvex-was-nicht","text":""},{"seite":"fundament.html","titel":"Konvexität sichtbar machen","anker":"konvexität-sichtbar-machen","text":""},{"seite":"fundament.html","titel":"2.6 Geometrische Visualisierung des Lösungsraums","anker":"sec:fundament-geometrische-visualisierung-des-loesungsraums","text":"Wir zeichnen nun den Lösungsraum aus Kapitel 1 und lesen das Optimum ab. Zweidimensionale Bilder sind der schnellste Weg, Intuition für höhere Dimensionen aufzubauen — auch wenn ma"},{"seite":"fundament.html","titel":"2.7 Wenn die Zahlen nicht zusammenpassen: Kondition und Skalierung","anker":"sec:fundament-kondition","text":"Bis hierher war die lineare Algebra exakt. Ein Rechner rechnet aber nicht exakt, sondern mit rund 16 signifikanten Stellen — und Ihre Betriebsdaten sind ohnehin nur auf wenige Stel"},{"seite":"fundament.html","titel":"Die geometrische Vorstellung: zwei fast parallele Linien","anker":"die-geometrische-vorstellung-zwei-fast-parallele-linien","text":"Zwei Nebenbedingungen legen im Zweidimensionalen einen Schnittpunkt fest. Stehen die zugehörigen Geraden kreuzweise aufeinander, ist der Schnittpunkt robust: Verschiebt man eine Ge"},{"seite":"fundament.html","titel":"Woher schlechte Kondition im Alltag kommt","anker":"woher-schlechte-kondition-im-alltag-kommt","text":"Fast nie aus exotischer Mathematik — fast immer aus Einheiten:"},{"seite":"fundament.html","titel":"Ruiz-Equilibrierung: das Modell gesundrechnen","anker":"ruiz-equilibrierung-das-modell-gesundrechnen","text":"Die Gegenmaßnahme ist erstaunlich schlicht. Man multipliziert jede Zeile und jede Spalte der Matrix mit einem Faktor, sodass die Beträge überall in derselben Größenordnung landen:"},{"seite":"fundament.html","titel":"Das Experiment","anker":"das-experiment","text":"Das folgende Programm führt beides vor — die Fehlerverstärkung und ihre Behebung — und schließt mit der praktischen Konsequenz, die Sie in Kapitel 6 wieder brauchen werden: warum e"},{"seite":"fundament.html","titel":"2.8 Übungsaufgaben","anker":"sec:fundament-uebungsaufgaben","text":""},{"seite":"fundament.html","titel":"2.9 Finde den Denkfehler","anker":"sec:fundament-denkfehler","text":""},{"seite":"fundament.html","titel":"2.10 Micro-Quiz","anker":"sec:fundament-quiz","text":""},{"seite":"fundament.html","titel":"2.11 Selbsttest","anker":"sec:fundament-selbsttest","text":""},{"seite":"fundament.html","titel":"2.12 Zusammenfassung","anker":"sec:fundament-zusammenfassung","text":""},{"seite":"oekosystem.html","titel":"Kapitel 3: Das Python-Ökosystem für OR — Solver, Bindings und Modellierungsschichten","anker":null,"text":""},{"seite":"oekosystem.html","titel":"3.1 In 5 Minuten gelöst","anker":"sec:oekosystem-schnellstart","text":""},{"seite":"oekosystem.html","titel":"3.2 Lernziele","anker":"sec:oekosystem-lernziele","text":"Nach diesem Kapitel können Sie …"},{"seite":"oekosystem.html","titel":"3.3 Die Zwei-Schichten-Architektur","anker":"sec:oekosystem-die-zwei-schichten-architektur","text":"Im modernen Operations Research schreibt man Optimierungsalgorithmen nicht selbst. Man nutzt eine zweischichtige Architektur:"},{"seite":"oekosystem.html","titel":"3.4 Die Werkzeuge im Vergleich","anker":"sec:oekosystem-die-werkzeuge-im-vergleich","text":""},{"seite":"oekosystem.html","titel":"Die Entscheidung in drei Fragen","anker":"die-entscheidung-in-drei-fragen","text":"Statt die Tabelle auswendig zu lernen, beantworten Sie drei Fragen:"},{"seite":"oekosystem.html","titel":"3.5 Ein System — vier Programmieransätze","anker":"sec:oekosystem-ein-system-vier-programmieransaetze","text":"Nichts macht die Unterschiede so deutlich wie dasselbe Problem, viermal gelöst. Wir nehmen:"},{"seite":"oekosystem.html","titel":"Wie die Isolation aussieht, wenn sie tragen soll","anker":"wie-die-isolation-aussieht-wenn-sie-tragen-soll","text":"„Eigener Prozess” ist schnell gesagt. Die naheliegende Umsetzung — ein Codeschnipsel als Zeichenkette an python -c übergeben — funktioniert und ist trotzdem die schlechteste: Der S"},{"seite":"oekosystem.html","titel":"Was das CSR-Format bedeutet","anker":"was-das-csr-format-bedeutet","text":"highspy erwartet die Nebenbedingungsmatrix im CSR-Format (Compressed Sparse Row, komprimierte Zeilendarstellung). Statt der vollen Matrix speichert man nur die Einträge ungleich nu"},{"seite":"oekosystem.html","titel":"3.6 Wann lohnt sich welche Ebene?","anker":"sec:oekosystem-wann-lohnt-sich-welche-ebene","text":""},{"seite":"oekosystem.html","titel":"3.7 Modellierungsschichten für große Modelle: Pyomo und Linopy","anker":"sec:oekosystem-pyomo-linopy","text":"Die vier Bibliotheken aus dem Vierfach-Vergleich decken den Alltag weitgehend ab. Sobald Modelle industrielle Größe erreichen — zehntausende Variablen, Daten aus mehreren Systemen,"},{"seite":"oekosystem.html","titel":"Pyomo: die algebraische Denkweise","anker":"pyomo-die-algebraische-denkweise","text":"Pyomo ist im deutschsprachigen Raum der De-facto-Standard für große LP- und MILP-Modelle in Energiewirtschaft, Chemie und Logistik. Sein Kennzeichen: Es denkt in Mengen und Indizes"},{"seite":"oekosystem.html","titel":"Linopy: eine Zeile, zehntausend Nebenbedingungen","anker":"linopy-eine-zeile-zehntausend-nebenbedingungen","text":"Linopy verfolgt einen anderen Ansatz: Variablen sind beschriftete Arrays (xarray), keine indizierten Einzelobjekte. Damit wird aus"},{"seite":"oekosystem.html","titel":"Die Schichten im Überblick","anker":"die-schichten-im-überblick","text":""},{"seite":"oekosystem.html","titel":"3.8 Wo die Zeit wirklich hingeht: vektorisierte Modellgenerierung","anker":"sec:oekosystem-vektorisierung","text":"Eine der hartnäckigsten Fehlannahmen in Optimierungsprojekten lautet: „Wenn es zu langsam ist, brauchen wir einen besseren Solver.“ Messen Sie erst — oft stimmt das nicht."},{"seite":"oekosystem.html","titel":"Vier Stufen an einem Transportproblem","anker":"vier-stufen-an-einem-transportproblem","text":"Wir bauen dasselbe Transportproblem (m Werke, n Kunden, m \\cdot n Variablen) auf vier Arten auf:"},{"seite":"oekosystem.html","titel":"3.9 Übungsaufgaben","anker":"sec:oekosystem-uebungsaufgaben","text":""},{"seite":"oekosystem.html","titel":"3.10 Finde den Denkfehler","anker":"sec:oekosystem-denkfehler","text":""},{"seite":"oekosystem.html","titel":"3.11 Micro-Quiz","anker":"sec:oekosystem-quiz","text":""},{"seite":"oekosystem.html","titel":"3.12 Selbsttest","anker":"sec:oekosystem-selbsttest","text":""},{"seite":"oekosystem.html","titel":"3.13 Zusammenfassung","anker":"sec:oekosystem-zusammenfassung","text":""},{"seite":"modellierung.html","titel":"Kapitel 4: Vom Management-Wunsch zum Modell","anker":null,"text":""},{"seite":"modellierung.html","titel":"4.1 In 5 Minuten gelöst","anker":"sec:modellierung-schnellstart","text":""},{"seite":"modellierung.html","titel":"4.2 Lernziele","anker":"sec:modellierung-lernziele","text":"Nach diesem Kapitel können Sie …"},{"seite":"modellierung.html","titel":"4.3 Ein Satz ist noch kein Modell","anker":"sec:modellierung-vier-fragen","text":"Was aus einer Besprechung mitkommt, klingt meist so:"},{"seite":"modellierung.html","titel":"4.4 Derselbe Datensatz, fünf Modelle","anker":"sec:modellierung-fuenf-modelle","text":"Das Programm dieses Kapitels arbeitet die vier Fragen an einer Auftragsannahme ab: 14 Anfragen verlangen 800 Maschinenstunden, verfügbar sind 300."},{"seite":"modellierung.html","titel":"Teil 1: Drei Ziele, drei Pläne","anker":"teil-1-drei-ziele-drei-pläne","text":""},{"seite":"modellierung.html","titel":"Teil 2: Ein Satz, drei Lesarten","anker":"teil-2-ein-satz-drei-lesarten","text":"„Stammkunden dürfen wir nicht verlieren.” Jeder im Raum nickt. Niemand merkt, dass drei verschiedene Modelle gemeint sein können:"},{"seite":"modellierung.html","titel":"Teil 3: Hart oder weich","anker":"teil-3-hart-oder-weich","text":"Dieselbe Regel als Strafkosten je abgelehntem Stammkundenauftrag:"},{"seite":"modellierung.html","titel":"Teil 4: Ein Quartal später","anker":"teil-4-ein-quartal-später","text":"Die harte Lesart A wurde eingebaut, alles lief drei Monate lang. Dann fragt Weber einen Auftrag über 320 Maschinenstunden an — mehr, als der ganze Zeitraum hergibt."},{"seite":"modellierung.html","titel":"4.5 Der Gesprächsleitfaden","anker":"sec:modellierung-leitfaden","text":"Was aus den vier Teilen als Handwerkszeug bleibt — Fragen, die man in der ersten Besprechung stellt, bevor eine Zeile Code entsteht:"},{"seite":"modellierung.html","titel":"4.6 Deutsch — OR: ein Übersetzungslexikon","anker":"sec:modellierung-glossar","text":"Die zwölf Fragen liefern Sätze. Sätze sind noch kein Modell — aber die meisten von ihnen haben eine Standardübersetzung, und wer sie kennt, spart sich das Nachdenken für die Fälle,"},{"seite":"modellierung.html","titel":"Fünf Wendungen, bei denen die Übersetzung eine Entscheidung erzwingt","anker":"fünf-wendungen-bei-denen-die-übersetzung-eine-entscheidung-erzwingt","text":"Die Tabelle oben tut so, als sei die Zuordnung eindeutig. Bei den folgenden fünf ist sie es nicht — und das Nachfragen ist die eigentliche Modellierungsarbeit:"},{"seite":"modellierung.html","titel":"Und die Gegenrichtung: OR — Deutsch","anker":"und-die-gegenrichtung-or-deutsch","text":"Dieselbe Barriere gibt es rückwärts. Diese Sätze haben sich bewährt, wenn ein Ergebnis jemandem erklärt werden muss, der das Modell nicht kennt:"},{"seite":"modellierung.html","titel":"4.7 Übungsaufgaben","anker":"sec:modellierung-uebungsaufgaben","text":""},{"seite":"modellierung.html","titel":"4.8 Finde den Denkfehler","anker":"sec:modellierung-denkfehler","text":""},{"seite":"modellierung.html","titel":"4.9 Micro-Quiz","anker":"sec:modellierung-quiz","text":""},{"seite":"modellierung.html","titel":"4.10 Selbsttest","anker":"sec:modellierung-selbsttest","text":""},{"seite":"modellierung.html","titel":"4.11 Zusammenfassung","anker":"sec:modellierung-zusammenfassung","text":""},{"seite":"synthese-grundlagen.html","titel":"Synthese Teil I","anker":null,"text":""},{"seite":"synthese-grundlagen.html","titel":"Was welches Kapitel klärt","anker":"was-welches-kapitel-klärt","text":""},{"seite":"synthese-grundlagen.html","titel":"Die Reihenfolge ist die Aussage","anker":"die-reihenfolge-ist-die-aussage","text":"Dieser Teil steht bewusst vor den Verfahren. Die drei häufigsten Gründe, aus denen ein OR-Projekt scheitert, liegen alle hier — und keiner davon ist ein Solverproblem:"},{"seite":"synthese-grundlagen.html","titel":"Wenn Sie nur eines mitnehmen","anker":"wenn-sie-nur-eines-mitnehmen","text":""},{"seite":"lp.html","titel":"Kapitel 5: Lineare Programmierung — Simplex, Dualität und Schattenpreise","anker":null,"text":""},{"seite":"lp.html","titel":"5.1 In 5 Minuten gelöst","anker":"sec:lp-schnellstart","text":"Bisher hat ein Solver Ihnen gesagt, was Sie tun sollen. Jetzt sagt er Ihnen zusätzlich, was eine zusätzliche Stunde wert wäre — und das ist die Zahl, für die Sie im Betrieb gehört "},{"seite":"lp.html","titel":"5.2 Lernziele","anker":"sec:lp-lernziele","text":"Nach diesem Kapitel können Sie …"},{"seite":"lp.html","titel":"5.3 Die Standardform und Schlupfvariablen","anker":"sec:lp-die-standardform-und-schlupfvariablen","text":"Lineare Programme zeichnen sich dadurch aus, dass Zielfunktion und alle Nebenbedingungen strikt linear sind — keine Produkte von Variablen, keine Quadrate, keine Logarithmen."},{"seite":"lp.html","titel":"5.4 Der Simplex-Algorithmus Schritt für Schritt","anker":"sec:lp-der-simplex-algorithmus-schritt-fuer-schritt","text":"Der von George Dantzig 1947 formulierte Simplex-Algorithmus nutzt den Fundamentalsatz aus Kapitel 2: Das Optimum liegt in einer Ecke. Statt alle Ecken aufzuzählen, wandert er von E"},{"seite":"lp.html","titel":"Der Ablauf","anker":"der-ablauf","text":""},{"seite":"lp.html","titel":"5.5 Das Simplex-Tableau in Python","anker":"sec:lp-das-simplex-tableau-in-python","text":""},{"seite":"lp.html","titel":"5.6 Dualität und Schattenpreise","anker":"sec:lp-dualitaet-und-schattenpreise","text":"Zu jedem linearen Optimierungsproblem (dem primalen Problem) existiert ein spiegelbildliches Zwillingsproblem: das duale Problem."},{"seite":"lp.html","titel":"Der starke Dualitätssatz","anker":"der-starke-dualitätssatz","text":""},{"seite":"lp.html","titel":"Der Schattenpreis als Ableitung","anker":"der-schattenpreis-als-ableitung","text":"Der Dualwert y_i^* ist die Grenzproduktivität der Ressource i:"},{"seite":"lp.html","titel":"5.7 Die Vorzeichenfalle bei Schattenpreisen","anker":"sec:lp-die-vorzeichenfalle-bei-schattenpreisen","text":"Diese Falle sollten Sie sich merken, weil sie in jedem Projekt wieder auftaucht."},{"seite":"lp.html","titel":"5.8 Praxisfall: Sensitivitätsanalyse mit korrekten Schattenpreisen","anker":"sec:lp-praxisfall-sensitivitaetsanalyse-mit-korrekten-schattenpreisen","text":"Szenario. Ein Fertigungsbetrieb stellt drei Produkte her und will wissen:"},{"seite":"lp.html","titel":"5.9 Wann Schattenpreise lügen: Entartung und Toleranzen","anker":"sec:lp-entartung","text":"Der vorige Abschnitt hat gezeigt, wie wertvoll Schattenpreise sind. Dieser zeigt die zwei Fälle, in denen sie eine Entscheidung nicht tragen — und wie man beide erkennt, bevor jema"},{"seite":"lp.html","titel":"Fall 1: Entartung","anker":"fall-1-entartung","text":"Erinnern Sie sich an Abschnitt 2.4: In zwei Dimensionen legen zwei sich schneidende Geraden eine Ecke fest, in drei Dimensionen drei Ebenen, allgemein n Restriktionen bei n Variabl"},{"seite":"lp.html","titel":"Fall 2: Toleranzen","anker":"fall-2-toleranzen","text":"Der zweite Fall ist unscheinbarer und deshalb häufiger. Wie stellt man fest, ob eine Ressource ausgelastet ist? Naheliegend wäre if schlupf == 0. Genau das ist falsch."},{"seite":"lp.html","titel":"Die ehrliche Auskunft: Schattenpreis-Spannen","anker":"die-ehrliche-auskunft-schattenpreis-spannen","text":"Was tut man also, wenn das Modell entartet ist? Man meldet keinen Einzelwert, sondern die Spanne. Die Menge aller optimalen Dualvektoren ist selbst ein Polyeder:"},{"seite":"lp.html","titel":"5.10 Übungsaufgaben","anker":"sec:lp-uebungsaufgaben","text":""},{"seite":"lp.html","titel":"5.11 Finde den Denkfehler","anker":"sec:lp-denkfehler","text":""},{"seite":"lp.html","titel":"5.12 Micro-Quiz","anker":"sec:lp-quiz","text":""},{"seite":"lp.html","titel":"5.13 Selbsttest","anker":"sec:lp-selbsttest","text":""},{"seite":"lp.html","titel":"5.14 Zusammenfassung","anker":"sec:lp-zusammenfassung","text":""},{"seite":"milp.html","titel":"Kapitel 6: Gemischt-ganzzahlige Optimierung — Diskrete Entscheidungen und Branch-and-Bound","anker":null,"text":""},{"seite":"milp.html","titel":"6.1 In 5 Minuten gelöst","anker":"sec:milp-schnellstart","text":""},{"seite":"milp.html","titel":"6.2 Lernziele","anker":"sec:milp-lernziele","text":"Nach diesem Kapitel können Sie …"},{"seite":"milp.html","titel":"6.3 Warum Runden fundamental scheitert","anker":"sec:milp-warum-runden-fundamental-scheitert","text":"In der realen Welt sind viele Entscheidungen nicht teilbar. Man kann nicht 0,47 Flugzeuge kaufen, keine halbe Lagerhalle bauen, keinen Mitarbeiter zu 38 % einstellen. Noch wichtige"},{"seite":"milp.html","titel":"6.4 Branch-and-Bound","anker":"sec:milp-branch-and-bound","text":"MILP-Probleme sind NP-schwer. Der Standardansatz moderner Solver (HiGHS, SCIP, Gurobi) heißt Branch-and-Cut — Branch-and-Bound plus Schnittebenen."},{"seite":"milp.html","titel":"Die drei Phasen","anker":"die-drei-phasen","text":""},{"seite":"milp.html","titel":"6.5 Modellierungstricks: Big-M und logische Bedingungen","anker":"sec:milp-modellierungstricks-big-m-und-logische-bedingungen","text":"Hier kommt das Handwerkszeug, das MILP so mächtig macht: Man übersetzt Geschäftsregeln in lineare Ungleichungen — mithilfe binärer Hilfsvariablen y \\in \\{0,1\\} und einer hinreichen"},{"seite":"milp.html","titel":"Muster 1 — Fixkosten / Aktivierungsschalter","anker":"muster-1-fixkosten-aktivierungsschalter","text":"Regel: Wird Maschine j genutzt (x_j &gt; 0), fallen Rüstkosten F_j an."},{"seite":"milp.html","titel":"Muster 2 — Entweder-Oder (disjunctive constraints)","anker":"muster-2-entweder-oder-disjunctive-constraints","text":"Regel: Es muss entweder f(\\mathbf{x}) \\le b_1 oder g(\\mathbf{x}) \\le b_2 gelten."},{"seite":"milp.html","titel":"Muster 3 — Wenn-Dann (Implikation)","anker":"muster-3-wenn-dann-implikation","text":"Regel: Wenn y_1 = 1, dann muss auch y_2 = 1 sein."},{"seite":"milp.html","titel":"Muster 4 — Kardinalität („höchstens K aus N“)","anker":"muster-4-kardinalität-höchstens-k-aus-n","text":"\\sum_{j=1}^N y_j \\le K"},{"seite":"milp.html","titel":"Muster 5 — Semikontinuierlich („entweder 0 oder mindestens L“)","anker":"muster-5-semikontinuierlich-entweder-0-oder-mindestens-l","text":"Regel: Eine Position ist entweder gar nicht besetzt oder mit mindestens L Euro."},{"seite":"milp.html","titel":"6.6 Beispiel: Das Rucksackproblem","anker":"sec:milp-beispiel-das-rucksackproblem","text":"Bevor wir zum Portfolio kommen, das klassische Einstiegsproblem — kurz, verständlich und überall wiederzuerkennen."},{"seite":"milp.html","titel":"6.7 Praxisfall: Portfolio mit Ordergebühren und Kardinalitätsgrenze","anker":"sec:milp-praxisfall-portfolio-mit-ordergebuehren-und-kardinalitaetsgrenze","text":"Szenario. Ein Investor verteilt 100\\,000\\,\\text{€} auf sechs Anlageklassen."},{"seite":"milp.html","titel":"6.8 Wenn der Solver nicht fertig wird: Gap, Zeitlimit und Warm-Start","anker":"sec:milp-gap","text":"Bei einem LP gibt es zwei Ausgänge: eine optimale Lösung oder eine klare Absage. Bei einem MILP gibt es einen dritten, und im Betrieb ist er der häufigste:"},{"seite":"milp.html","titel":"Die zwei Zahlen, die zählen","anker":"die-zwei-zahlen-die-zählen","text":"Branch-and-Bound führt zu jedem Zeitpunkt zwei Werte mit:"},{"seite":"milp.html","titel":"Alle Statusfälle behandeln","anker":"alle-statusfälle-behandeln","text":"Der zweite Teil der Professionalität ist unspektakulär, aber entscheidend: jeden Rückgabewert auswerten, nicht nur OPTIMAL."},{"seite":"milp.html","titel":"Warm-Starts: was sie können und was nicht","anker":"warm-starts-was-sie-können-und-was-nicht","text":"Ein Warm-Start gibt dem Solver eine bekannte Lösung als Startpunkt mit. Die Idee ist verlockend: Wer schon eine brauchbare Lösung hat, muss nicht bei null anfangen."},{"seite":"milp.html","titel":"6.9 Übungsaufgaben","anker":"sec:milp-uebungsaufgaben","text":""},{"seite":"milp.html","titel":"6.10 Finde den Denkfehler","anker":"sec:milp-denkfehler","text":"Die Warnung „M so klein wie möglich“ wird meist mit der Laufzeit begründet: schwache Relaxation, mehr Knoten. Das stimmt — und ist die harmlosere Hälfte der Wahrheit."},{"seite":"milp.html","titel":"6.11 Micro-Quiz","anker":"sec:milp-quiz","text":""},{"seite":"milp.html","titel":"6.12 Selbsttest","anker":"sec:milp-selbsttest","text":""},{"seite":"milp.html","titel":"6.13 Zusammenfassung","anker":"sec:milp-zusammenfassung","text":""},{"seite":"cpsat.html","titel":"Kapitel 7: Constraint Programming mit CP-SAT — Logik, Scheduling und Zuweisung","anker":null,"text":""},{"seite":"cpsat.html","titel":"7.1 In 5 Minuten gelöst","anker":"sec:cpsat-schnellstart","text":""},{"seite":"cpsat.html","titel":"7.2 Lernziele","anker":"sec:cpsat-lernziele","text":"Nach diesem Kapitel können Sie …"},{"seite":"cpsat.html","titel":"7.3 Ein anderes Denkmodell","anker":"sec:cpsat-ein-anderes-denkmodell","text":"Während LP und MILP auf algebraischen Gleichungen und Simplex-Matrizen beruhen, kommt Constraint Programming (CP) aus der künstlichen Intelligenz:"},{"seite":"cpsat.html","titel":"Was Propagation leistet","anker":"was-propagation-leistet","text":""},{"seite":"cpsat.html","titel":"7.4 Globale Constraints — die Bausteine von CP-SAT","anker":"sec:cpsat-globale-constraints-die-bausteine-von-cp","text":"CP-SAT stellt mächtige Makros bereit, die in MILP hunderte Big-M-Ungleichungen erfordern würden. Jedes davon hat einen spezialisierten, hocheffizienten Propagator."},{"seite":"cpsat.html","titel":"7.5 Praxisfall: Dynamisches Vertretungssystem","anker":"sec:cpsat-praxisfall-dynamisches-vertretungssystem","text":"Problemstellung. Eine Schule muss nach spontanen Ausfällen vier Unterrichtsstunden nachbesetzen."},{"seite":"cpsat.html","titel":"7.6 Intervallvariablen: Job-Shop-Scheduling","anker":"sec:cpsat-intervallvariablen-job-shop-scheduling","text":"Die Königsdisziplin von CP-SAT sind Zeitplanungsprobleme. Intervallvariablen sind dabei das zentrale Werkzeug."},{"seite":"cpsat.html","titel":"7.7 Parallele Suche: was num_workers wirklich bewirkt","anker":"sec:cpsat-parallele-suche","text":"An mehreren Stellen dieses Buchs steht loeser.parameters.num_workers = 1, mit dem Kommentar „für eine reproduzierbare Ausgabe“. Darin stecken zwei Behauptungen: dass parallele Such"},{"seite":"cpsat.html","titel":"Was die Messung zeigt","anker":"was-die-messung-zeigt","text":"Erstens: Die Beschleunigung ist überlinear. Acht Arbeiter sind im abgedruckten Lauf nicht achtmal, sondern gut zwölfmal schneller als einer. Das sieht nach Messfehler aus, ist aber"},{"seite":"cpsat.html","titel":"Was daraus für Tests folgt","anker":"was-daraus-für-tests-folgt","text":"Der Zielwert war in allen sechzehn Läufen derselbe: 183. Die Gestalt der Lösung war es nicht. Genau daran entscheidet sich, was ein Test prüfen darf:"},{"seite":"cpsat.html","titel":"7.8 Die fünf Antworten von CP-SAT","anker":"sec:cpsat-statusfaelle","text":"Abschnitt 6.8 hat gezeigt, warum OPTIMAL bei ganzzahligen Problemen nicht der Normalfall ist. Bei CP-SAT kommt eine Besonderheit hinzu: Es gibt fünf verschiedene Antworten, und dre"},{"seite":"cpsat.html","titel":"7.9 Übungsaufgaben","anker":"sec:cpsat-uebungsaufgaben","text":""},{"seite":"cpsat.html","titel":"7.10 Finde den Denkfehler","anker":"sec:cpsat-denkfehler","text":""},{"seite":"cpsat.html","titel":"7.11 Micro-Quiz","anker":"sec:cpsat-quiz","text":""},{"seite":"cpsat.html","titel":"7.12 Selbsttest","anker":"sec:cpsat-selbsttest","text":""},{"seite":"cpsat.html","titel":"7.13 Zusammenfassung","anker":"sec:cpsat-zusammenfassung","text":""},{"seite":"graphen.html","titel":"Kapitel 8: Graphen, Flüsse und Touren — Min-Cost-Flow, Matching und VRP","anker":null,"text":""},{"seite":"graphen.html","titel":"8.1 In 5 Minuten gelöst","anker":"sec:graphen-schnellstart","text":""},{"seite":"graphen.html","titel":"8.2 Lernziele","anker":"sec:graphen-lernziele","text":"Nach diesem Kapitel können Sie …"},{"seite":"graphen.html","titel":"8.3 Graphen als Modellsprache","anker":"sec:graphen-graphen-als-modellsprache","text":"Viele reale Probleme in Logistik, Kommunikation und Finanzströmen sind keine flachen Ungleichungssysteme, sondern Graphen G = (V, E):"},{"seite":"graphen.html","titel":"Das Minimum-Cost-Flow-Problem (MCNFP)","anker":"das-minimum-cost-flow-problem-mcnfp","text":"Minimum-Cost Network Flow Problem — deutsch: kostenminimales Flussproblem. Es ist das mathematische Fundament für Transportketten, Liquiditätsrouting und Datenverteilung."},{"seite":"graphen.html","titel":"8.4 Bipartites Matching: das Zuordnungsproblem","anker":"sec:graphen-bipartites-matching-das-zuordnungsproblem","text":"Wenn N Aufgaben auf N Ressourcen eins zu eins verteilt werden — Orders auf Broker, Schichten auf Mitarbeitende, Aufträge auf Maschinen — spricht man von bipartitem Matching."},{"seite":"graphen.html","titel":"Der Satz von Birkhoff und von Neumann","anker":"der-satz-von-birkhoff-und-von-neumann","text":""},{"seite":"graphen.html","titel":"8.5 Das Vehicle Routing Problem mit Zeitfenstern","anker":"sec:graphen-das-vehicle-routing-problem-mit-zeitfenstern","text":"Das Traveling Salesperson Problem (TSP), deutsch Problem des Handlungsreisenden, fragt nach der kürzesten Rundreise durch N Städte. Das Capacitated Vehicle Routing Problem with Tim"},{"seite":"graphen.html","titel":"Kurzzyklen verhindern","anker":"kurzzyklen-verhindern","text":"Ein naives Modell erlaubt Subtouren: isolierte Kreise, die das Depot nie anfahren. Die klassische Gegenmaßnahme ist die MTZ-Formulierung nach Miller, Tucker und Zemlin. Man führt R"},{"seite":"graphen.html","titel":"Praxisbeispiel: Flotten-Routing","anker":"praxisbeispiel-flotten-routing","text":""},{"seite":"graphen.html","titel":"8.6 Übungsaufgaben","anker":"sec:graphen-uebungsaufgaben","text":""},{"seite":"graphen.html","titel":"8.7 Finde den Denkfehler","anker":"sec:graphen-denkfehler","text":""},{"seite":"graphen.html","titel":"8.8 Micro-Quiz","anker":"sec:graphen-quiz","text":""},{"seite":"graphen.html","titel":"8.9 Selbsttest","anker":"sec:graphen-selbsttest","text":""},{"seite":"graphen.html","titel":"8.10 Zusammenfassung","anker":"sec:graphen-zusammenfassung","text":""},{"seite":"metaheuristiken.html","titel":"Kapitel 9: Metaheuristiken — wenn der exakte Solver aussteigt","anker":null,"text":""},{"seite":"metaheuristiken.html","titel":"9.1 In 5 Minuten gelöst","anker":"sec:metaheuristiken-schnellstart","text":""},{"seite":"metaheuristiken.html","titel":"9.2 Lernziele","anker":"sec:metaheuristiken-lernziele","text":"Nach diesem Kapitel können Sie …"},{"seite":"metaheuristiken.html","titel":"9.3 Die Aufgabe: Rüstzeiten an der Lackieranlage","anker":"sec:metaheuristiken-aufgabe","text":"Der Schnellstart war ein Spielzeug. Die Aufgabe dieses Kapitels ist dieselbe, nur in Betriebsgröße: n Aufträge in eine Reihenfolge bringen, so dass die Summe der Rüstzeiten minimal"},{"seite":"metaheuristiken.html","titel":"Die Instanz","anker":"die-instanz","text":"Alle Programme dieses Kapitels benutzen dieselbe Aufgabe. Die Rüstzeit setzt sich aus zwei Teilen zusammen: einem unregelmäßigen Reinigungsaufwand zwischen den Produktfamilien und "},{"seite":"metaheuristiken.html","titel":"9.4 Lokale Suche: der Zug und seine Kosten","anker":"sec:metaheuristiken-lokale-suche","text":"Eine lokale Suche braucht drei Dinge: eine Startlösung, einen Zug und eine Regel, welche Züge übernommen werden."},{"seite":"metaheuristiken.html","titel":"9.5 Simulated Annealing","anker":"sec:metaheuristiken-annealing","text":"Reines Bergsteigen — nur Verbesserungen annehmen — bleibt im ersten lokalen Optimum stehen. Simulated Annealing nimmt Verschlechterungen mit einer Wahrscheinlichkeit an, die von de"},{"seite":"metaheuristiken.html","titel":"Was die Messung zeigt — und was sie nicht zeigt","anker":"was-die-messung-zeigt-und-was-sie-nicht-zeigt","text":"Erstens: Der Beitrag des Annealings ist bescheiden. Bergsteigen kommt auf 917 Minuten, Annealing auf 907 — das simple Verfahren holt 93 % des Ertrags. Das ist kein Argument gegen A"},{"seite":"metaheuristiken.html","titel":"9.6 Ab wann lohnt es sich?","anker":"sec:metaheuristiken-umschlagpunkt","text":"„Kleine Probleme exakt, große mit Metaheuristiken“ ist richtig und nutzlos, solange niemand sagt, wo groß anfängt. Diese Zahl lässt sich messen."},{"seite":"metaheuristiken.html","titel":"Die Spalte, die man nicht weglassen darf","anker":"die-spalte-die-man-nicht-weglassen-darf","text":"Bei 500 Aufträgen haben wir die CP-SAT-Lösung verworfen. Seine Schranke ist trotzdem das Wertvollste in der ganzen Tabelle."},{"seite":"metaheuristiken.html","titel":"9.7 Large Neighborhood Search","anker":"sec:metaheuristiken-lns","text":"Die Tabelle oben endet mit einem Widerspruch. Bei 500 Aufträgen scheitert der exakte Solver an der Größe; die Metaheuristik scheitert an der Kleinheit ihrer Züge — sie verschiebt j"},{"seite":"metaheuristiken.html","titel":"Das Fenster ist die eine Stellschraube","anker":"das-fenster-ist-die-eine-stellschraube","text":""},{"seite":"metaheuristiken.html","titel":"Das Gesamtbild","anker":"das-gesamtbild","text":""},{"seite":"metaheuristiken.html","titel":"9.8 Was dieses Kapitel nicht behandelt","anker":"sec:metaheuristiken-abgrenzung","text":"Damit die Landkarte vollständig ist — drei Verfahren, die in dieselbe Familie gehören und hier bewusst nur benannt werden:"},{"seite":"metaheuristiken.html","titel":"9.9 Übungsaufgaben","anker":"sec:metaheuristiken-uebungsaufgaben","text":""},{"seite":"metaheuristiken.html","titel":"9.10 Finde den Denkfehler","anker":"sec:metaheuristiken-denkfehler","text":""},{"seite":"metaheuristiken.html","titel":"9.11 Micro-Quiz","anker":"sec:metaheuristiken-quiz","text":""},{"seite":"metaheuristiken.html","titel":"9.12 Selbsttest","anker":"sec:metaheuristiken-selbsttest","text":""},{"seite":"metaheuristiken.html","titel":"9.13 Zusammenfassung","anker":"sec:metaheuristiken-zusammenfassung","text":""},{"seite":"dekomposition.html","titel":"Kapitel 10: Spaltengenerierung — das Modell umbauen statt die Lösung raten","anker":null,"text":""},{"seite":"dekomposition.html","titel":"10.1 In 5 Minuten gelöst","anker":"sec:dekomposition-schnellstart","text":""},{"seite":"dekomposition.html","titel":"10.2 Lernziele","anker":"sec:dekomposition-lernziele","text":"Nach diesem Kapitel können Sie …"},{"seite":"dekomposition.html","titel":"10.3 Warum das naheliegende Modell scheitert","anker":"sec:dekomposition-symmetrie","text":"Der erste Entwurf eines Zuschnittmodells sieht fast immer so aus: eine Binärvariable z_{jr} für „Stück j liegt auf Rolle r“, dazu y_r für „Rolle r wird benutzt”."},{"seite":"dekomposition.html","titel":"10.4 Rechnen mit Mustern, ohne sie aufzuschreiben","anker":"sec:dekomposition-schleife","text":"Die Idee ist alt (Gilmore und Gomory, 1961) und in einem Satz gesagt:"},{"seite":"dekomposition.html","titel":"10.5 Das Programm","anker":"sec:dekomposition-programm","text":""},{"seite":"dekomposition.html","titel":"10.6 Was die Zahlen zeigen","anker":"sec:dekomposition-befund","text":""},{"seite":"dekomposition.html","titel":"Die Musterzahl explodiert, der Bedarf nicht","anker":"die-musterzahl-explodiert-der-bedarf-nicht","text":""},{"seite":"dekomposition.html","titel":"Der unbequeme Teil: Es lohnt sich nicht immer","anker":"der-unbequeme-teil-es-lohnt-sich-nicht-immer","text":""},{"seite":"dekomposition.html","titel":"10.7 Übungsaufgaben","anker":"sec:dekomposition-uebungsaufgaben","text":""},{"seite":"dekomposition.html","titel":"10.8 Finde den Denkfehler","anker":"sec:dekomposition-denkfehler","text":""},{"seite":"dekomposition.html","titel":"10.9 Micro-Quiz","anker":"sec:dekomposition-quiz","text":""},{"seite":"dekomposition.html","titel":"10.10 Selbsttest","anker":"sec:dekomposition-selbsttest","text":""},{"seite":"dekomposition.html","titel":"10.11 Zusammenfassung","anker":"sec:dekomposition-zusammenfassung","text":""},{"seite":"synthese-kernverfahren.html","titel":"Synthese Teil II","anker":null,"text":""},{"seite":"synthese-kernverfahren.html","titel":"Die Entscheidungsmatrix","anker":"die-entscheidungsmatrix","text":""},{"seite":"synthese-kernverfahren.html","titel":"Was dieser Teil gemessen hat","anker":"was-dieser-teil-gemessen-hat","text":""},{"seite":"synthese-kernverfahren.html","titel":"Drei Fehler, die dieser Teil verhindert","anker":"drei-fehler-die-dieser-teil-verhindert","text":""},{"seite":"synthese-kernverfahren.html","titel":"Wenn Sie nur eines mitnehmen","anker":"wenn-sie-nur-eines-mitnehmen","text":""},{"seite":"qp-nlp.html","titel":"Kapitel 11: Quadratische und nichtlineare Optimierung — KKT, Lagrange, Konvexität","anker":null,"text":""},{"seite":"qp-nlp.html","titel":"11.1 In 5 Minuten gelöst","anker":"sec:qp-nlp-schnellstart","text":""},{"seite":"qp-nlp.html","titel":"11.2 Lernziele","anker":"sec:qp-nlp-lernziele","text":"Nach diesem Kapitel können Sie …"},{"seite":"qp-nlp.html","titel":"Auffrischung: Gradient in einer Minute","anker":"auffrischung-gradient-in-einer-minute","text":"Der Gradient \\nabla f(\\mathbf{x}) ist der Vektor aller partiellen Ableitungen:"},{"seite":"qp-nlp.html","titel":"11.3 Das quadratische Programm (QP)","anker":"sec:qp-nlp-das-quadratische-programm-qp","text":"Ein quadratisches Programm hat eine quadratische Zielfunktion und lineare Nebenbedingungen:"},{"seite":"qp-nlp.html","titel":"Konvexität: die präzise Aussage","anker":"konvexität-die-präzise-aussage","text":"Eine verbreitete, aber zu stark formulierte Aussage lautet: „Wenn \\mathbf{P} positiv semi-definit ist, ist das QP streng konvex; es existiert ein eindeutiges globales Minimum.“ Kor"},{"seite":"qp-nlp.html","titel":"11.4 Die Karush-Kuhn-Tucker-Bedingungen","anker":"sec:qp-nlp-die-karush-kuhn-tucker-bedingungen","text":"Die KKT-Bedingungen verallgemeinern den Lagrange-Ansatz auf Probleme mit Ungleichungen. Sie sind notwendig für ein Optimum — und bei konvexen Problemen auch hinreichend."},{"seite":"qp-nlp.html","titel":"Die vier KKT-Bedingungen","anker":"die-vier-kkt-bedingungen","text":"Am Optimum (\\mathbf{x}^*, \\boldsymbol{\\lambda}^*, \\boldsymbol{\\nu}^*) gilt:"},{"seite":"qp-nlp.html","titel":"11.5 Nichtlineare Optimierung mit scipy.optimize.minimize","anker":"sec:qp-nlp-nichtlineare-optimierung-mit-scipy-optimize-minimize","text":"Wenn Zielfunktion oder Nebenbedingungen weder linear noch quadratisch sind — Logarithmen, Wurzeln, Exponentialfunktionen — nutzt man gradientenbasierte Verfahren wie SLSQP (Sequent"},{"seite":"qp-nlp.html","titel":"Praxisfall: Entropie-maximierte Kapitalallokation","anker":"praxisfall-entropie-maximierte-kapitalallokation","text":"Wir optimieren ein Portfolio nicht nur nach Varianz, sondern maximieren zusätzlich die Shannon-Entropie der Gewichte, um Klumpenrisiken glatt zu bestrafen:"},{"seite":"qp-nlp.html","titel":"11.6 Jenseits der Konvexität: lokale Optima, Multistart und MINLP","anker":"sec:qp-nlp-nichtkonvex","text":"Alles bisher in diesem Kapitel stand unter einer Bedingung: Konvexität. Sie ist der Grund, warum CVXPY eine Optimalitätsgarantie geben kann und warum die KKT-Bedingungen nicht nur "},{"seite":"qp-nlp.html","titel":"Woher Nicht-Konvexität im Alltag kommt","anker":"woher-nicht-konvexität-im-alltag-kommt","text":"Nicht aus exotischer Mathematik, sondern aus ganz gewöhnlichen betriebswirtschaftlichen Effekten:"},{"seite":"qp-nlp.html","titel":"Was ein lokales Optimum praktisch bedeutet","anker":"was-ein-lokales-optimum-praktisch-bedeutet","text":"scipy.optimize.minimize verweigert nichts. Es rechnet, meldet success: True und liefert eine Zahl. Diese Meldung heißt aber nicht „das ist das Optimum“, sondern nur:"},{"seite":"qp-nlp.html","titel":"Die Zahlen im Klartext","anker":"die-zahlen-im-klartext","text":""},{"seite":"qp-nlp.html","titel":"Ausblick: MINLP und globale Solver","anker":"ausblick-minlp-und-globale-solver","text":"Wird zusätzlich noch ganzzahlig entschieden — „welche Anlage läuft überhaupt“ und „wie stark“ —, entsteht ein MINLP (Mixed-Integer Nonlinear Program), die schwierigste der in diese"},{"seite":"qp-nlp.html","titel":"11.7 Übungsaufgaben","anker":"sec:qp-nlp-uebungsaufgaben","text":""},{"seite":"qp-nlp.html","titel":"11.8 Finde den Denkfehler","anker":"sec:qp-nlp-denkfehler","text":""},{"seite":"qp-nlp.html","titel":"11.9 Micro-Quiz","anker":"sec:qp-nlp-quiz","text":""},{"seite":"qp-nlp.html","titel":"11.10 Selbsttest","anker":"sec:qp-nlp-selbsttest","text":""},{"seite":"qp-nlp.html","titel":"11.11 Zusammenfassung","anker":"sec:qp-nlp-zusammenfassung","text":""},{"seite":"unsicherheit.html","titel":"Kapitel 12: Optimierung unter Unsicherheit — Monte-Carlo, Stochastik, Robustheit","anker":null,"text":""},{"seite":"unsicherheit.html","titel":"12.1 In 5 Minuten gelöst","anker":"sec:unsicherheit-schnellstart","text":""},{"seite":"unsicherheit.html","titel":"12.2 Lernziele","anker":"sec:unsicherheit-lernziele","text":"Nach diesem Kapitel können Sie …"},{"seite":"unsicherheit.html","titel":"12.3 Der Fluch des Durchschnitts","anker":"sec:unsicherheit-der-fluch-des-durchschnitts","text":"Der naheliegende Umgang mit Unsicherheit lautet: „Wir setzen den Erwartungswert ein und rechnen deterministisch.“ Das ist fast immer falsch — und zwar nicht ungenau, sondern system"},{"seite":"unsicherheit.html","titel":"Die vier Ansätze im Überblick","anker":"die-vier-ansätze-im-überblick","text":""},{"seite":"unsicherheit.html","titel":"12.4 Monte-Carlo-Simulation","anker":"sec:unsicherheit-monte-carlo-simulation","text":"Monte-Carlo heißt schlicht: Ziehe sehr viele Zufallsszenarien, werte für jedes den Plan aus, und betrachte die Verteilung der Ergebnisse statt eines einzigen Werts."},{"seite":"unsicherheit.html","titel":"12.5 Zweistufige stochastische Programmierung","anker":"sec:unsicherheit-zweistufige-stochastische-programmierung","text":"Das zweistufige Modell mit Recourse bildet ab, dass Entscheidungen zeitlich gestaffelt sind:"},{"seite":"unsicherheit.html","titel":"12.6 Robuste Optimierung: gegen den Worst Case absichern","anker":"sec:unsicherheit-robuste-optimierung-gegen-den-worst-case","text":"Wenn Wahrscheinlichkeiten unbekannt oder instabil sind — Marktcrashs, Lieferkettenabrisse, Pandemien —, hilft die robuste Optimierung. Sie fragt nicht nach dem Mittel, sondern nach"},{"seite":"unsicherheit.html","titel":"12.7 Wahrscheinlichkeitsbeschränkungen: „mit 95 % Sicherheit“","anker":"sec:unsicherheit-chance-constraints","text":"Die drei bisherigen Ansätze beantworten Fragen, die im Sitzungssaal selten so gestellt werden. „Was ist im Mittel am besten?“ hört ein Vorstand als Ausflucht; „was hält auch im sch"},{"seite":"unsicherheit.html","titel":"Weg 1: Normalverteilung — die Bedingung wird ein Kegel","anker":"weg-1-normalverteilung-die-bedingung-wird-ein-kegel","text":"Ist \\mathbf{a} \\sim \\mathcal{N}(\\hat{\\mathbf{a}}, \\boldsymbol{\\Sigma}), dann ist \\mathbf{a}^\\top\\mathbf{x} für festes \\mathbf{x} selbst normalverteilt, mit Erwartungswert \\hat{\\mat"},{"seite":"unsicherheit.html","titel":"Weg 2: Szenarien — Big-M ohne Verteilungsannahme","anker":"weg-2-szenarien-big-m-ohne-verteilungsannahme","text":"Liegen statt einer Verteilung nur S beobachtete Szenarien vor, bekommt jedes eine Binärvariable z_s, die sagt, ob es verletzt werden darf:"},{"seite":"unsicherheit.html","titel":"Der Fall: ein Kraftwerkspark mit 500 MW Zusage","anker":"der-fall-ein-kraftwerkspark-mit-500-mw-zusage","text":""},{"seite":"unsicherheit.html","titel":"12.8 Übungsaufgaben","anker":"sec:unsicherheit-uebungsaufgaben","text":""},{"seite":"unsicherheit.html","titel":"12.9 Finde den Denkfehler","anker":"sec:unsicherheit-denkfehler","text":""},{"seite":"unsicherheit.html","titel":"12.10 Micro-Quiz","anker":"sec:unsicherheit-quiz","text":""},{"seite":"unsicherheit.html","titel":"12.11 Selbsttest","anker":"sec:unsicherheit-selbsttest","text":""},{"seite":"unsicherheit.html","titel":"12.12 Zusammenfassung","anker":"sec:unsicherheit-zusammenfassung","text":""},{"seite":"dynamische-programmierung.html","titel":"Kapitel 13: Dynamische Programmierung — Die Bellman-Gleichung und Order-Execution","anker":null,"text":""},{"seite":"dynamische-programmierung.html","titel":"13.1 In 5 Minuten gelöst","anker":"sec:dynamische-programmierung-schnellstart","text":""},{"seite":"dynamische-programmierung.html","titel":"13.2 Lernziele","anker":"sec:dynamische-programmierung-lernziele","text":"Nach diesem Kapitel können Sie …"},{"seite":"dynamische-programmierung.html","titel":"13.3 Das Bellmansche Optimalitätsprinzip","anker":"sec:dynamische-programmierung-das-bellmansche-optimalitaetsprinzip","text":"Richard Bellman formulierte 1957 das Grundprinzip der Dynamischen Programmierung (DP):"},{"seite":"dynamische-programmierung.html","titel":"Die vier Bausteine eines DP-Modells","anker":"die-vier-bausteine-eines-dp-modells","text":""},{"seite":"dynamische-programmierung.html","titel":"Die Bellman-Gleichung","anker":"die-bellman-gleichung","text":"V_t(S_t) = \\min_{a_t\\in\\mathcal{A}(S_t)}\\Big\\{\\,C(S_t,a_t) \\;+\\; \\gamma\\cdot\\mathbb{E}\\big[V_{t+1}(S_{t+1})\\mid S_t,a_t\\big]\\Big\\}"},{"seite":"dynamische-programmierung.html","titel":"13.4 Das Almgren-Chriss-Problem: optimale Orderausführung","anker":"sec:dynamische-programmierung-das-almgren-chriss-problem-optimale-orderausfuehrung","text":"Ein klassisches OR-Problem an Börsen: Ein institutioneller Händler muss X_0 = 100\\,000 Aktien innerhalb von T Handelsperioden verkaufen."},{"seite":"dynamische-programmierung.html","titel":"13.5 Der Fluch der Dimensionalität","anker":"sec:dynamische-programmierung-der-fluch-der-dimensionalitaet","text":"DP ist mächtig, aber es hat eine harte Grenze. Der Aufwand der Rückwärtsinduktion ist"},{"seite":"dynamische-programmierung.html","titel":"13.6 Übungsaufgaben","anker":"sec:dynamische-programmierung-uebungsaufgaben","text":""},{"seite":"dynamische-programmierung.html","titel":"13.7 Finde den Denkfehler","anker":"sec:dynamische-programmierung-denkfehler","text":"Bei dynamischer Programmierung entscheidet eine einzige Frage über Erfolg oder Misserfolg: Was gehört in den Zustand? Ist er zu klein, rechnet das Verfahren völlig korrekt — nur eb"},{"seite":"dynamische-programmierung.html","titel":"13.8 Micro-Quiz","anker":"sec:dynamische-programmierung-quiz","text":""},{"seite":"dynamische-programmierung.html","titel":"13.9 Selbsttest","anker":"sec:dynamische-programmierung-selbsttest","text":""},{"seite":"dynamische-programmierung.html","titel":"13.10 Zusammenfassung","anker":"sec:dynamische-programmierung-zusammenfassung","text":""},{"seite":"mehrziel.html","titel":"Kapitel 14: Mehrere Ziele — Pareto-Fronten statt Gewichte","anker":null,"text":""},{"seite":"mehrziel.html","titel":"14.1 In 5 Minuten gelöst","anker":"sec:mehrziel-schnellstart","text":""},{"seite":"mehrziel.html","titel":"14.2 Lernziele","anker":"sec:mehrziel-lernziele","text":"Nach diesem Kapitel können Sie …"},{"seite":"mehrziel.html","titel":"14.3 Wann ein Kompromiss gut ist","anker":"sec:mehrziel-dominanz","text":"Bei einem Ziel ist „besser” eindeutig. Bei zwei Zielen nicht mehr: Ein Plan kann billiger und schmutziger sein als ein anderer, und dann ist keiner von beiden besser."},{"seite":"mehrziel.html","titel":"14.4 Der Reflex: alles in ein Ziel rühren","anker":"sec:mehrziel-skalarisierung","text":"Der naheliegende Weg, zwei Ziele zu einem zu machen, ist die gewichtete Summe:"},{"seite":"mehrziel.html","titel":"14.5 Das Programm","anker":"sec:mehrziel-programm","text":"Zwölf Sendungen, drei Verkehrsträger, fünf freie Bahntrassen. Der Zielkonflikt entsteht nicht zwischen den Trägern — die Bahn ist immer billiger und sauberer als der LKW —, sondern"},{"seite":"mehrziel.html","titel":"14.6 Was die gewichtete Summe nicht sieht","anker":"sec:mehrziel-luecke","text":"Die Front hat zehn Punkte. Ein Raster aus 1 401 Gewichten findet sechs davon. Vier Kompromisse sind für kein Gewicht erreichbar — und das ist keine Frage der Rasterweite."},{"seite":"mehrziel.html","titel":"Das Gewicht ist keine Feineinstellung","anker":"das-gewicht-ist-keine-feineinstellung","text":"Die zweite Beobachtung aus derselben Tabelle: 1 401 Gewichte erzeugen sechs verschiedene Pläne. Weite Gewichtsbereiche liefern dasselbe Ergebnis, und dazwischen springt es."},{"seite":"mehrziel.html","titel":"14.7 Das ε-Constraint-Verfahren","anker":"sec:mehrziel-epsilon","text":"Der Ausweg ist unspektakulär: Man macht aus dem zweiten Ziel eine Nebenbedingung."},{"seite":"mehrziel.html","titel":"Wenn es eine klare Rangfolge gibt: lexikografisch","anker":"wenn-es-eine-klare-rangfolge-gibt-lexikografisch","text":"Manchmal ist ein Ziel wirklich vorrangig. Dann optimiert man lexikografisch: erst das erste Ziel, dann das zweite unter der Bedingung, dass das erste (fast) erhalten bleibt."},{"seite":"mehrziel.html","titel":"14.8 Wie man die Front vorlegt","anker":"sec:mehrziel-vorlegen","text":"Eine Front mit zehn Punkten ist kein Ergebnis, sondern eine Speisekarte. Damit sie entscheidbar wird, gehört eine Spalte dazu, die im Programm EUR je kg heißt:"},{"seite":"mehrziel.html","titel":"14.9 Übungsaufgaben","anker":"sec:mehrziel-uebungsaufgaben","text":""},{"seite":"mehrziel.html","titel":"14.10 Finde den Denkfehler","anker":"sec:mehrziel-denkfehler","text":""},{"seite":"mehrziel.html","titel":"14.11 Micro-Quiz","anker":"sec:mehrziel-quiz","text":""},{"seite":"mehrziel.html","titel":"14.12 Selbsttest","anker":"sec:mehrziel-selbsttest","text":""},{"seite":"mehrziel.html","titel":"14.13 Zusammenfassung","anker":"sec:mehrziel-zusammenfassung","text":""},{"seite":"prognose.html","titel":"Kapitel 15: Predict-then-Optimize — die bessere Prognose, die schlechtere Entscheidung","anker":null,"text":""},{"seite":"prognose.html","titel":"15.1 In 5 Minuten gelöst","anker":"sec:prognose-schnellstart","text":""},{"seite":"prognose.html","titel":"15.2 Lernziele","anker":"sec:prognose-lernziele","text":"Nach diesem Kapitel können Sie …"},{"seite":"prognose.html","titel":"15.3 Die Naht zwischen zwei Abteilungen","anker":"sec:prognose-naht","text":"In fast jedem Unternehmen sieht der Ablauf so aus:"},{"seite":"prognose.html","titel":"15.4 Das Programm","anker":"sec:prognose-programm","text":"Dieselbe Bäckerei, aber mit Merkmalen: Wochentag, Temperatur, Aktionstage. Die Nachfrage muss jetzt modelliert werden."},{"seite":"prognose.html","titel":"15.5 Der Befund","anker":"sec:prognose-befund","text":""},{"seite":"prognose.html","titel":"Warum ein pauschaler Zuschlag zu kurz greift","anker":"warum-ein-pauschaler-zuschlag-zu-kurz-greift","text":"Die zweite Zeile der Tabelle ist die verbreitete Praxis: Punktprognose plus Sicherheitsbestand. Sie hilft (−7,3 %), bleibt aber hinter der Quantilregression zurück. Das Programm re"},{"seite":"prognose.html","titel":"15.6 Eine Messfalle, in die der Autor selbst getappt ist","anker":"sec:prognose-messfalle","text":"Der erste Entwurf dieses Programms bewertete auf 230 Testtagen — ein realistischer Zeitraum, gut sieben Monate. Dort hatte die Quantilregression den besseren MSE, und die ganze Aus"},{"seite":"prognose.html","titel":"15.7 Wie weit das Verfahren reicht","anker":"sec:prognose-ausblick","text":"Die dritte Zeile der Ergebnistabelle — „Zuschlag auf Kosten trainiert” — ist die einfachste denkbare Form einer Idee, die derzeit erforscht wird: das Prognosemodell direkt auf die "},{"seite":"prognose.html","titel":"15.8 Übungsaufgaben","anker":"sec:prognose-uebungsaufgaben","text":""},{"seite":"prognose.html","titel":"15.9 Finde den Denkfehler","anker":"sec:prognose-denkfehler","text":""},{"seite":"prognose.html","titel":"15.10 Micro-Quiz","anker":"sec:prognose-quiz","text":""},{"seite":"prognose.html","titel":"15.11 Selbsttest","anker":"sec:prognose-selbsttest","text":""},{"seite":"prognose.html","titel":"15.12 Zusammenfassung","anker":"sec:prognose-zusammenfassung","text":""},{"seite":"synthese-nichtlinear.html","titel":"Synthese Teil III","anker":null,"text":""},{"seite":"synthese-nichtlinear.html","titel":"Welche Annahme fällt weg?","anker":"welche-annahme-fällt-weg","text":""},{"seite":"synthese-nichtlinear.html","titel":"Was dieser Teil gemessen hat","anker":"was-dieser-teil-gemessen-hat","text":""},{"seite":"synthese-nichtlinear.html","titel":"Drei Fehler, die dieser Teil verhindert","anker":"drei-fehler-die-dieser-teil-verhindert","text":""},{"seite":"synthese-nichtlinear.html","titel":"Wenn Sie nur eines mitnehmen","anker":"wenn-sie-nur-eines-mitnehmen","text":""},{"seite":"bruecke.html","titel":"Kapitel 16: Die Strukturbrücke — dieselbe Mathematik, zwei Welten","anker":null,"text":""},{"seite":"bruecke.html","titel":"16.1 In 5 Minuten gelöst","anker":"sec:bruecke-schnellstart","text":""},{"seite":"bruecke.html","titel":"16.2 Lernziele","anker":"sec:bruecke-lernziele","text":"Nach diesem Kapitel können Sie …"},{"seite":"bruecke.html","titel":"16.3 Das Programm","anker":"sec:bruecke-programm","text":""},{"seite":"bruecke.html","titel":"16.4 Die zwei Brücken im Einzelnen","anker":"sec:bruecke-einzelnen","text":""},{"seite":"bruecke.html","titel":"Erste Brücke: Allokation","anker":"erste-brücke-allokation","text":""},{"seite":"bruecke.html","titel":"Zweite Brücke: Absicherung gegen den schlechtesten Fall","anker":"zweite-brücke-absicherung-gegen-den-schlechtesten-fall","text":"Hier ist die Übereinstimmung noch enger, weil sie nicht nur die Struktur betrifft, sondern die Formel. Die Rockafellar-Uryasev-Formulierung aus Kapitel 20"},{"seite":"bruecke.html","titel":"Wo die Lösungen sich unterscheiden","anker":"wo-die-lösungen-sich-unterscheiden","text":"Der Vergleich fördert nebenbei einen Unterschied zutage, den man nicht erwartet: Die Streuungsgrenze von 40 % bindet nur im Einkauf, nicht im Depot."},{"seite":"bruecke.html","titel":"16.5 Wo die Brücke endet","anker":"sec:bruecke-grenzen","text":"Eine Analogie ist nur so nützlich wie die Grenzen, die man ihr zieht. Drei Dinge wandern nicht mit:"},{"seite":"bruecke.html","titel":"16.6 Übungsaufgaben","anker":"sec:bruecke-uebungsaufgaben","text":""},{"seite":"bruecke.html","titel":"16.7 Finde den Denkfehler","anker":"sec:bruecke-denkfehler","text":""},{"seite":"bruecke.html","titel":"16.8 Micro-Quiz","anker":"sec:bruecke-quiz","text":""},{"seite":"bruecke.html","titel":"16.9 Selbsttest","anker":"sec:bruecke-selbsttest","text":""},{"seite":"bruecke.html","titel":"16.10 Zusammenfassung","anker":"sec:bruecke-zusammenfassung","text":""},{"seite":"supplychain.html","titel":"Kapitel 17: Supply-Chain und Energieeinsatz unter Unsicherheit","anker":null,"text":""},{"seite":"supplychain.html","titel":"17.1 In 5 Minuten gelöst","anker":"sec:supplychain-schnellstart","text":""},{"seite":"supplychain.html","titel":"17.2 Lernziele","anker":"sec:supplychain-lernziele","text":"Nach diesem Kapitel können Sie …"},{"seite":"supplychain.html","titel":"17.3 Die Aufgabe","anker":"sec:supplychain-aufgabe","text":"Fünf Blöcke, 24 Stunden, eine Last zwischen 270 und 804 MW. Dazu Windeinspeisung, die niemand am Vorabend kennt."},{"seite":"supplychain.html","titel":"Die Zeitstruktur der Entscheidung","anker":"die-zeitstruktur-der-entscheidung","text":"Hier geht das Kapitel über Abschnitt 12.5 hinaus:"},{"seite":"supplychain.html","titel":"17.4 Das Programm","anker":"sec:supplychain-programm","text":""},{"seite":"supplychain.html","titel":"17.5 Der Befund","anker":"sec:supplychain-befund","text":""},{"seite":"supplychain.html","titel":"17.6 Was Versorgungssicherheit kostet","anker":"sec:supplychain-sicherheit","text":"Der dritte Plan legt eine CVaR-Schranke auf die nicht gedeckte Energie: Im Mittel der schlechtesten 10 % der Szenarien darf nichts fehlen. Dieselbe Rockafellar-Uryasev-Konstruktion"},{"seite":"supplychain.html","titel":"17.7 Übungsaufgaben","anker":"sec:supplychain-uebungsaufgaben","text":""},{"seite":"supplychain.html","titel":"17.8 Finde den Denkfehler","anker":"sec:supplychain-denkfehler","text":""},{"seite":"supplychain.html","titel":"17.9 Micro-Quiz","anker":"sec:supplychain-quiz","text":""},{"seite":"supplychain.html","titel":"17.10 Selbsttest","anker":"sec:supplychain-selbsttest","text":""},{"seite":"supplychain.html","titel":"17.11 Zusammenfassung","anker":"sec:supplychain-zusammenfassung","text":""},{"seite":"finanzdaten.html","titel":"Kapitel 18: Finanzdaten-Modellierung — Renditen, Kovarianz und Shrinkage","anker":null,"text":""},{"seite":"finanzdaten.html","titel":"18.1 In 5 Minuten gelöst","anker":"sec:finanzdaten-schnellstart","text":""},{"seite":"finanzdaten.html","titel":"18.2 Lernziele","anker":"sec:finanzdaten-lernziele","text":"Nach diesem Kapitel können Sie …"},{"seite":"finanzdaten.html","titel":"18.3 Diskrete und logarithmische Renditen","anker":"sec:finanzdaten-diskrete-und-logarithmische-renditen","text":"Sei P_{i,t} der bereinigte Schlusskurs (adjusted close) von Titel i zum Zeitpunkt t. „Bereinigt“ heißt: um Dividenden und Aktiensplits korrigiert — sonst erscheint jede Dividendenz"},{"seite":"finanzdaten.html","titel":"Diskrete Rendite","anker":"diskrete-rendite","text":"R_{i,t} = \\frac{P_{i,t} - P_{i,t-1}}{P_{i,t-1}} = \\frac{P_{i,t}}{P_{i,t-1}} - 1"},{"seite":"finanzdaten.html","titel":"Logarithmische Rendite","anker":"logarithmische-rendite","text":"r_{i,t} = \\ln\\!\\left(\\frac{P_{i,t}}{P_{i,t-1}}\\right) = \\ln P_{i,t} - \\ln P_{i,t-1}"},{"seite":"finanzdaten.html","titel":"18.4 Das Schätzfehler-Problem","anker":"sec:finanzdaten-das-schaetzfehler-problem","text":"Sei \\mathbf{X}\\in\\mathbb{R}^{T\\times N} die Matrix zentrierter Renditen von N Titeln über T Handelstage. Die Stichproben-Kovarianzmatrix lautet:"},{"seite":"finanzdaten.html","titel":"18.5 Ledoit-Wolf-Shrinkage","anker":"sec:finanzdaten-ledoit-wolf-shrinkage","text":"Olivier Ledoit und Michael Wolf lösten das Dilemma durch lineare Schrumpfung:"},{"seite":"finanzdaten.html","titel":"Welches Ziel \\mathbf{F}?","anker":"welches-ziel-mathbff","text":"Ein häufiges Missverständnis: Es gibt nämlich mehrere Ledoit-Wolf-Varianten, und Text und Code müssen sich konsistent auf dieselbe beziehen:"},{"seite":"finanzdaten.html","titel":"18.6 Praxis: Datenpipeline mit korrekter Spaltenreihenfolge","anker":"sec:finanzdaten-praxis-datenpipeline-mit-korrekter-spaltenreihenfolge","text":""},{"seite":"finanzdaten.html","titel":"18.7 Übungsaufgaben","anker":"sec:finanzdaten-uebungsaufgaben","text":""},{"seite":"finanzdaten.html","titel":"18.8 Finde den Denkfehler","anker":"sec:finanzdaten-denkfehler","text":""},{"seite":"finanzdaten.html","titel":"18.9 Micro-Quiz","anker":"sec:finanzdaten-quiz","text":""},{"seite":"finanzdaten.html","titel":"18.10 Selbsttest","anker":"sec:finanzdaten-selbsttest","text":""},{"seite":"finanzdaten.html","titel":"18.11 Zusammenfassung","anker":"sec:finanzdaten-zusammenfassung","text":""},{"seite":"markowitz.html","titel":"Kapitel 19: Die moderne Portfoliotheorie nach Markowitz","anker":null,"text":""},{"seite":"markowitz.html","titel":"19.1 In 5 Minuten gelöst","anker":"sec:markowitz-schnellstart","text":""},{"seite":"markowitz.html","titel":"19.2 Lernziele","anker":"sec:markowitz-lernziele","text":"Nach diesem Kapitel können Sie …"},{"seite":"markowitz.html","titel":"19.3 Warum Diversifikation funktioniert","anker":"sec:markowitz-warum-diversifikation-funktioniert","text":"Harry Markowitz’ zentrale Einsicht von 1952: Das Risiko eines Portfolios ist nicht die Summe der Einzelrisiken. Es hängt davon ab, wie die Titel zusammenspielen."},{"seite":"markowitz.html","titel":"19.4 Das Mean-Variance-Modell","anker":"sec:markowitz-das-mean-variance-modell","text":"Sei \\mathbf{w} = (w_1,\\dots,w_n)^\\top der Vektor der Portfoliogewichte:"},{"seite":"markowitz.html","titel":"Die Effizienzgrenze und das Tangentialportfolio","anker":"die-effizienzgrenze-und-das-tangentialportfolio","text":"Die Effizienzgrenze (efficient frontier) ist die Kurve aller Portfolios, die zu jedem Risikoniveau die höchstmögliche Rendite liefern."},{"seite":"markowitz.html","titel":"Die Korn-Transformation","anker":"die-korn-transformation","text":"Die Sharpe Ratio ist ein Bruch — und damit nicht konvex. CVXPY würde sie ablehnen. Der Ausweg ist ein eleganter Trick, der die Homogenität des Problems ausnutzt:"},{"seite":"markowitz.html","titel":"19.5 Institutionelle Nebenbedingungen","anker":"sec:markowitz-institutionelle-nebenbedingungen","text":"In der Praxis gelten regulatorische und interne Regeln:"},{"seite":"markowitz.html","titel":"Was diese Regeln kosten","anker":"was-diese-regeln-kosten","text":"Jede Regel schneidet etwas vom Erreichbaren ab. Wie viel, lässt sich ausrechnen — man legt die Effizienzlinie ohne und mit Beschränkungen übereinander:"},{"seite":"markowitz.html","titel":"19.6 Vollimplementierung mit CVXPY","anker":"sec:markowitz-vollimplementierung-mit-cvxpy","text":""},{"seite":"markowitz.html","titel":"19.7 Übungsaufgaben","anker":"sec:markowitz-uebungsaufgaben","text":""},{"seite":"markowitz.html","titel":"19.8 Finde den Denkfehler","anker":"sec:markowitz-denkfehler","text":"Kapitel 18 hat gezeigt, was eine schlecht geschätzte Kovarianzmatrix anrichtet. Bei den erwarteten Renditen ist es schlimmer — und weil sie in der Zielfunktion stehen statt in der "},{"seite":"markowitz.html","titel":"19.9 Micro-Quiz","anker":"sec:markowitz-quiz","text":""},{"seite":"markowitz.html","titel":"19.10 Selbsttest","anker":"sec:markowitz-selbsttest","text":""},{"seite":"markowitz.html","titel":"19.11 Zusammenfassung","anker":"sec:markowitz-zusammenfassung","text":""},{"seite":"cvar.html","titel":"Kapitel 20: Tail-Risiko, CVaR und Transaktionskosten","anker":null,"text":""},{"seite":"cvar.html","titel":"20.1 In 5 Minuten gelöst","anker":"sec:cvar-schnellstart","text":""},{"seite":"cvar.html","titel":"20.2 Lernziele","anker":"sec:cvar-lernziele","text":"Nach diesem Kapitel können Sie …"},{"seite":"cvar.html","titel":"20.3 Die zwei Schwächen des Markowitz-Modells","anker":"sec:cvar-die-zwei-schwaechen-des-markowitz-modells","text":"Erstens: die Normalverteilungs-Illusion. Die Varianz behandelt Aufwärts- und Abwärtsschwankungen gleich und unterstellt implizit symmetrische, dünn auslaufende Verteilungen. Reale "},{"seite":"cvar.html","titel":"20.4 Value at Risk und Conditional Value at Risk","anker":"sec:cvar-value-at-risk-und-conditional-value","text":""},{"seite":"cvar.html","titel":"Das Rockafellar-Uryasev-Theorem (2000)","anker":"das-rockafellar-uryasev-theorem-2000","text":"Rockafellar und Uryasev zeigten, dass sich der CVaR über S Szenarien exakt als lineares Programm formulieren lässt:"},{"seite":"cvar.html","titel":"20.5 Transaktionskosten über die L_1-Norm","anker":"sec:cvar-transaktionskosten-ueber-die-l-1-norm","text":"Sei \\mathbf{w}_{\\text{alt}} das bestehende Portfolio und \\mathbf{w} das neue Ziel. Der Umschlag (turnover) ist:"},{"seite":"cvar.html","titel":"20.6 Implementierung: CVaR-Portfolio mit Reibung","anker":"sec:cvar-implementierung-cvar-portfolio-mit-reibung","text":""},{"seite":"cvar.html","titel":"20.7 Übungsaufgaben","anker":"sec:cvar-uebungsaufgaben","text":""},{"seite":"cvar.html","titel":"20.8 Finde den Denkfehler","anker":"sec:cvar-denkfehler","text":""},{"seite":"cvar.html","titel":"20.9 Micro-Quiz","anker":"sec:cvar-quiz","text":""},{"seite":"cvar.html","titel":"20.10 Selbsttest","anker":"sec:cvar-selbsttest","text":""},{"seite":"cvar.html","titel":"20.11 Zusammenfassung","anker":"sec:cvar-zusammenfassung","text":""},{"seite":"handelsmaschine.html","titel":"Kapitel 21: Die vollständige quantitative Handelsmaschine","anker":null,"text":""},{"seite":"handelsmaschine.html","titel":"21.1 In 5 Minuten gelöst","anker":"sec:handelsmaschine-schnellstart","text":""},{"seite":"handelsmaschine.html","titel":"21.2 Lernziele","anker":"sec:handelsmaschine-lernziele","text":"Nach diesem Kapitel können Sie …"},{"seite":"handelsmaschine.html","titel":"21.3 Die Architektur","anker":"sec:handelsmaschine-die-architektur","text":""},{"seite":"handelsmaschine.html","titel":"21.4 Rebalancing-Termine richtig bestimmen","anker":"sec:handelsmaschine-rebalancing-termine-richtig-bestimmen","text":""},{"seite":"handelsmaschine.html","titel":"21.5 Die Engine","anker":"sec:handelsmaschine-die-engine","text":""},{"seite":"handelsmaschine.html","titel":"21.6 Die fünf Selbsttäuschungen des Backtestens","anker":"sec:handelsmaschine-die-fuenf-selbsttaeuschungen-des-backtestens","text":""},{"seite":"handelsmaschine.html","titel":"21.7 Vom Backtest zum Betrieb","anker":"sec:handelsmaschine-vom-backtest-zum-betrieb","text":"Ein guter Backtest ist eine notwendige, keine hinreichende Bedingung. Was zwischen Backtest und echtem Einsatz liegt:"},{"seite":"handelsmaschine.html","titel":"21.8 Übungsaufgaben","anker":"sec:handelsmaschine-uebungsaufgaben","text":""},{"seite":"handelsmaschine.html","titel":"21.9 Finde den Denkfehler","anker":"sec:handelsmaschine-denkfehler","text":"Backtest_Fallen.py zeigt drei Fehler, die im Backtest stecken: Lookahead, Survivorship, vergessene Kosten. Alle drei kann man einem Programm ansehen, wenn man es liest."},{"seite":"handelsmaschine.html","titel":"21.10 Micro-Quiz","anker":"sec:handelsmaschine-quiz","text":""},{"seite":"handelsmaschine.html","titel":"21.11 Selbsttest","anker":"sec:handelsmaschine-selbsttest","text":""},{"seite":"handelsmaschine.html","titel":"21.12 Zusammenfassung","anker":"sec:handelsmaschine-zusammenfassung","text":""},{"seite":"synthese-anwendungen.html","titel":"Synthese Teil IV","anker":null,"text":""},{"seite":"synthese-anwendungen.html","titel":"Dieselbe Struktur, andere Namen","anker":"dieselbe-struktur-andere-namen","text":""},{"seite":"synthese-anwendungen.html","titel":"Was dieser Teil gemessen hat","anker":"was-dieser-teil-gemessen-hat","text":""},{"seite":"synthese-anwendungen.html","titel":"Drei Fehler, die dieser Teil verhindert","anker":"drei-fehler-die-dieser-teil-verhindert","text":""},{"seite":"synthese-anwendungen.html","titel":"Wenn Sie nur eines mitnehmen","anker":"wenn-sie-nur-eines-mitnehmen","text":""},{"seite":"praxisfallen.html","titel":"Kapitel 22: Praxisfallen und der Weg zum produktiven Einsatz","anker":null,"text":""},{"seite":"praxisfallen.html","titel":"22.1 In 5 Minuten gelöst","anker":"sec:praxisfallen-schnellstart","text":"Die vorangegangenen vierzehn Kapitel enden fast alle mit derselben Empfehlung: Prüfen Sie das Ergebnis gegen die Wirklichkeit. Dieses Kapitel beginnt damit, diese Prüfung als wiede"},{"seite":"praxisfallen.html","titel":"22.2 Lernziele","anker":"sec:praxisfallen-lernziele","text":"Nach diesem Kapitel können Sie …"},{"seite":"praxisfallen.html","titel":"22.3 Die fünf typischen Praxisfallen","anker":"sec:praxisfallen-die-fuenf-typischen-praxisfallen","text":""},{"seite":"praxisfallen.html","titel":"Falle 1 — Infeasibility","anker":"falle-1-infeasibility","text":"Wenn Parameter unglücklich zusammentreffen — drei Mitarbeitende gleichzeitig krank, kein qualifizierter Ersatz —, meldet der Solver schlicht INFEASIBLE."},{"seite":"praxisfallen.html","titel":"Falle 2 — Der Black-Box-Effekt","anker":"falle-2-der-black-box-effekt","text":"Ein Planer oder Trader lehnt ein System ab, wenn er die Zuweisungen nicht nachvollziehen kann. Akzeptanz ist keine Nebensache, sondern Voraussetzung für den Betrieb."},{"seite":"praxisfallen.html","titel":"Falle 3 — Regimewechsel und Schätzfehler","anker":"falle-3-regimewechsel-und-schätzfehler","text":"Ein Modell, das auf einer mehrjährigen Aufwärtsphase kalibriert wurde, kennt keine Liquiditätskrise und keine Zinswende."},{"seite":"praxisfallen.html","titel":"Falle 4 — Lookahead- und Survivorship-Bias","anker":"falle-4-lookahead--und-survivorship-bias","text":"Ausführlich in Kapitel 21 behandelt. Die Kurzfassung: Beide Fehler machen Backtests systematisch zu gut, ohne eine Fehlermeldung zu erzeugen. Der Lookahead-Selbsttest aus Abschnitt"},{"seite":"praxisfallen.html","titel":"Falle 5 — Laufzeitexplosion","anker":"falle-5-laufzeitexplosion","text":"Exakte Optimalität kann bei MILP oder CP-SAT Minuten bis Stunden dauern — und die Laufzeit wächst nicht linear mit der Problemgröße."},{"seite":"praxisfallen.html","titel":"22.4 Constraint Attribution: welche Bedingung kostet wie viel?","anker":"sec:praxisfallen-attribution","text":"Der Constraint-Trace beantwortet „warum diese Zuweisung?“. Der Deletion Filter in Anhang C beantwortet „warum geht es gar nicht?“. Der häufigste Fall in der Praxis liegt dazwischen"},{"seite":"praxisfallen.html","titel":"Drei Befunde, und keiner steht im Solverergebnis","anker":"drei-befunde-und-keiner-steht-im-solverergebnis","text":"Erstens: bindend heißt nicht teuer. Fünf Bedingungen binden, aber „Lackierbudget Schicht 2“ tut es mit einem Schattenpreis von 0,00 €. Sie berührt den Plan, ohne ihn zu verteuern —"},{"seite":"praxisfallen.html","titel":"Vom Zahlenwerk zur Vorlage","anker":"vom-zahlenwerk-zur-vorlage","text":"Alle drei Antworten stehen bis hierhin in Tabellen. Tabellen liest niemand in einer Abteilungsleiterrunde. Teil (4) des Programms baut aus denselben Zahlen einen Text — und das ist"},{"seite":"praxisfallen.html","titel":"22.5 Architektur einer produktionsreifen OR-Plattform","anker":"sec:praxisfallen-architektur-einer-produktionsreifen-or-plattform","text":""},{"seite":"praxisfallen.html","titel":"22.6 Der gemeinsame Unterbau: or_kern.py","anker":"sec:praxisfallen-or-kern","text":"Die fünf Prinzipien oben beschreiben eine Plattform. Der Weg dorthin beginnt aber viel kleiner — mit der Frage, welche Teile eines Optimierungsprogramms immer dieselben sind."},{"seite":"praxisfallen.html","titel":"Die vier Schichten","anker":"die-vier-schichten","text":"\\underbrace{\\text{Rohdaten}}_{\\text{Excel, CSV, ERP}}\n\\;\\longrightarrow\\;\n\\underbrace{\\text{Domänenmodell}}_{\\text{geprüft, solverfrei}}\n\\;\\longrightarrow\\;\n\\underbrace{\\text{Model"},{"seite":"praxisfallen.html","titel":"Ein Enum für fünf Bibliotheken","anker":"ein-enum-für-fünf-bibliotheken","text":"Der unscheinbarste, aber wirksamste Teil ist die Statusübersetzung. Dieselbe Aussage heißt in den fünf im Buch verwendeten Bibliotheken:"},{"seite":"praxisfallen.html","titel":"22.7 Der Solverwechsel in der Praxis","anker":"sec:praxisfallen-solverwechsel","text":"Der vorige Abschnitt endet mit einer Behauptung: Ein Solverwechsel betreffe genau einen Baustein. Das ist die Art Satz, die in jedem Architekturvortrag vorkommt und die man deshalb"},{"seite":"praxisfallen.html","titel":"22.8 Eine Checkliste vor dem Produktivgang","anker":"sec:praxisfallen-eine-checkliste-vor-dem-produktivgang","text":"Arbeiten Sie diese Liste ab, bevor ein OR-System in Betrieb geht:"},{"seite":"praxisfallen.html","titel":"22.9 Weiterführende Literatur und Roadmap","anker":"sec:praxisfallen-weiterfuehrende-literatur-und-roadmap","text":"Grundlagen und lineare/ganzzahlige Optimierung * Bertsimas &amp; Tsitsiklis: Introduction to Linear Optimization — Standardwerk zu Simplex, Dualität, Polyedertheorie. * Wolsey: Int"},{"seite":"praxisfallen.html","titel":"22.10 Übungsaufgaben","anker":"sec:praxisfallen-uebungsaufgaben","text":""},{"seite":"praxisfallen.html","titel":"22.11 Finde den Denkfehler","anker":"sec:praxisfallen-denkfehler","text":"Falle 5 — die Laufzeitexplosion — zeigt sich im Betrieb selten als Absturz. Sie zeigt sich als gar nichts."},{"seite":"praxisfallen.html","titel":"22.12 Micro-Quiz","anker":"sec:praxisfallen-quiz","text":""},{"seite":"praxisfallen.html","titel":"22.13 Selbsttest","anker":"sec:praxisfallen-selbsttest","text":""},{"seite":"praxisfallen.html","titel":"22.14 Zusammenfassung","anker":"sec:praxisfallen-zusammenfassung","text":""},{"seite":"testing.html","titel":"Kapitel 23: Testen, Messen, Ausliefern","anker":null,"text":""},{"seite":"testing.html","titel":"23.1 In 5 Minuten gelöst","anker":"sec:testing-schnellstart","text":""},{"seite":"testing.html","titel":"23.2 Lernziele","anker":"sec:testing-lernziele","text":"Nach diesem Kapitel können Sie …"},{"seite":"testing.html","titel":"23.3 Warum Optimierungsmodelle schwer zu testen sind","anker":"sec:testing-warum-schwer","text":"Bei einer gewöhnlichen Funktion schreibt man den erwarteten Wert hin:"},{"seite":"testing.html","titel":"23.4 Die Testsuite","anker":"sec:testing-suite","text":""},{"seite":"testing.html","titel":"23.5 Wer testet die Tests?","anker":"sec:testing-mutation","text":"33 grüne Tests. Das ist noch kein Ergebnis."},{"seite":"testing.html","titel":"Der erste Lauf fand zwei Lücken","anker":"der-erste-lauf-fand-zwei-lücken","text":"Die Suite hatte zunächst 31 Tests. Der Mutationstest sagte dazu:"},{"seite":"testing.html","titel":"23.6 Ein Vergleich, dem man glauben kann","anker":"sec:testing-benchmark","text":"Solververgleiche stehen in jedem Blog, und die meisten sind wertlos. Nicht, weil falsch gemessen wurde, sondern weil zu wenig dazugesagt wird."},{"seite":"testing.html","titel":"Die interessanteste Spalte heißt „Anteil”","anker":"die-interessanteste-spalte-heißt-anteil","text":"Sie sagt, wie viel der Zeit in den Aufbau des Modells geht statt ins Lösen — und die Zahlen sind unbequem:"},{"seite":"testing.html","titel":"23.7 Das Modell als Dienst","anker":"sec:testing-dienst","text":"Ein Modell hinter eine HTTP-Schnittstelle zu hängen sieht nach einer Fingerübung aus. Es gibt aber einen Unterschied, der die ganze Bauform bestimmt:"},{"seite":"testing.html","titel":"Threads oder Prozesse? Eine Messung, keine Meinung","anker":"threads-oder-prozesse-eine-messung-keine-meinung","text":"Punkt 6 des Selbsttests misst, ob vier Solverläufe in Threads sich überlappen. Das Ergebnis ist ein Faktor von rund 3,5 bei vier Threads: OR-Tools rechnet in C++ und gibt den GIL w"},{"seite":"testing.html","titel":"Was im echten Betrieb dazukommt","anker":"was-im-echten-betrieb-dazukommt","text":"Das Beispiel hält das Auftragsbuch in einem dict und rechnet in Threads desselben Prozesses. Für einen einzelnen Rechner reicht das; darüber hinaus nicht:"},{"seite":"testing.html","titel":"23.8 Übungsaufgaben","anker":"sec:testing-uebungsaufgaben","text":""},{"seite":"testing.html","titel":"23.9 Finde den Denkfehler","anker":"sec:testing-denkfehler","text":""},{"seite":"testing.html","titel":"23.10 Micro-Quiz","anker":"sec:testing-quiz","text":""},{"seite":"testing.html","titel":"23.11 Selbsttest","anker":"sec:testing-selbsttest","text":""},{"seite":"testing.html","titel":"23.12 Zusammenfassung","anker":"sec:testing-zusammenfassung","text":""},{"seite":"synthese-praxis.html","titel":"Synthese Teil V","anker":null,"text":""},{"seite":"synthese-praxis.html","titel":"Was schiefgeht, und was dagegen hilft","anker":"was-schiefgeht-und-was-dagegen-hilft","text":""},{"seite":"synthese-praxis.html","titel":"Was dieser Teil gemessen hat","anker":"was-dieser-teil-gemessen-hat","text":""},{"seite":"synthese-praxis.html","titel":"Drei Fehler, die dieser Teil verhindert","anker":"drei-fehler-die-dieser-teil-verhindert","text":""},{"seite":"synthese-praxis.html","titel":"Wenn Sie nur eines mitnehmen","anker":"wenn-sie-nur-eines-mitnehmen","text":""},{"seite":"projektwerkstatt.html","titel":"Projektwerkstatt","anker":null,"text":""},{"seite":"projektwerkstatt.html","titel":"Wie Sie ein Projekt bearbeiten","anker":"wie-sie-ein-projekt-bearbeiten","text":"Halten Sie sich an diese Reihenfolge — sie ist aus vielen gescheiterten und einigen gelungenen Projekten destilliert:"},{"seite":"projektwerkstatt.html","titel":"P1 — Vertretungsplaner für eine Schule","anker":"p1-vertretungsplaner-für-eine-schule","text":""},{"seite":"projektwerkstatt.html","titel":"P2 — Schichtplanung für ein Pflegeteam","anker":"p2-schichtplanung-für-ein-pflegeteam","text":""},{"seite":"projektwerkstatt.html","titel":"P3 — Tourenplanung für einen Lieferdienst","anker":"p3-tourenplanung-für-einen-lieferdienst","text":""},{"seite":"projektwerkstatt.html","titel":"P4 — Standort- und Lagernetzplanung","anker":"p4-standort--und-lagernetzplanung","text":""},{"seite":"projektwerkstatt.html","titel":"P5 — Produktionsplanung mit Rüstkosten","anker":"p5-produktionsplanung-mit-rüstkosten","text":""},{"seite":"projektwerkstatt.html","titel":"P6 — Portfolio-Rebalancer für ein Privatdepot","anker":"p6-portfolio-rebalancer-für-ein-privatdepot","text":""},{"seite":"projektwerkstatt.html","titel":"P7 — Risikoreport mit CVaR und Stresstests","anker":"p7-risikoreport-mit-cvar-und-stresstests","text":""},{"seite":"projektwerkstatt.html","titel":"P9 — Wenn der Solver aussteigt: Tourenplanung in Echtgröße","anker":"p9-wenn-der-solver-aussteigt-tourenplanung-in-echtgröße","text":""},{"seite":"projektwerkstatt.html","titel":"P10 — Zwei Ziele, eine Entscheidung: Kosten gegen CO₂","anker":"p10-zwei-ziele-eine-entscheidung-kosten-gegen-co₂","text":""},{"seite":"projektwerkstatt.html","titel":"P11 — Vom Skript zum Dienst: das Modell übergeben","anker":"p11-vom-skript-zum-dienst-das-modell-übergeben","text":""},{"seite":"projektwerkstatt.html","titel":"P8 — Freies Projekt aus Ihrem eigenen Umfeld","anker":"p8-freies-projekt-aus-ihrem-eigenen-umfeld","text":""},{"seite":"projektwerkstatt.html","titel":"Eine Bitte zum Schluss","anker":"eine-bitte-zum-schluss","text":"Wenn Sie ein Projekt fertig haben, machen Sie zwei Dinge:"},{"seite":"anhang-loesungen.html","titel":"Anhang A: Lösungen zu allen Übungsaufgaben","anker":null,"text":""},{"seite":"anhang-loesungen.html","titel":"A.1 Lösungen zu Kapitel „Einführung in Operations Research — Vom Ursprung zur mathematischen Entscheidungsfindung“","anker":"sec:loesungen-einfuehrung","text":"1.1 — Analytik-Stufen. (a) deskriptiv (Vergangenheit beschreiben). (b) prädiktiv (Prognose). (c) präskriptiv (Handlungsanweisung unter Restriktionen). (d) prädiktiv (Klassifikation"},{"seite":"anhang-loesungen.html","titel":"Finde den Denkfehler — Die Schreinerei verdoppelt ihren Gewinn","anker":"finde-den-denkfehler-die-schreinerei-verdoppelt-ihren-gewinn","text":""},{"seite":"anhang-loesungen.html","titel":"Micro-Quiz","anker":"quiz-loesung-einfuehrung","text":"1 — (c) präskriptiv. Die Frage lautet „was tun“, und es gibt eine Restriktion (das Restbudget). Dass man für die Bewertung eine Prognose braucht, macht die Frage nicht prädiktiv — "},{"seite":"anhang-loesungen.html","titel":"Selbsttest","anker":"selbsttest-loesung-einfuehrung","text":""},{"seite":"anhang-loesungen.html","titel":"A.2 Lösungen zu Kapitel „Das mathematische Fundament — Vektoren, Matrizen, Konvexität“","anker":"sec:loesungen-fundament","text":"2.1 — Matrixform lesen. \\max 4x_1 + x_2 + 6x_3 u. d. N. x_1 + 2x_2 \\le 10, x_2 + 3x_3 \\le 12, x \\ge 0. 3 Variablen, 2 Nebenbedingungen (plus Nichtnegativität)."},{"seite":"anhang-loesungen.html","titel":"Finde den Denkfehler — Die unauffällige Transposition","anker":"finde-den-denkfehler-die-unauffällige-transposition","text":""},{"seite":"anhang-loesungen.html","titel":"Micro-Quiz","anker":"quiz-loesung-fundament","text":"1 — (b). Der Fundamentalsatz sagt nur, dass ein Optimum in einer Ecke angenommen wird. (a) ist falsch, weil es mehrere optimale Ecken geben kann (wenn die Zielfunktion parallel zu "},{"seite":"anhang-loesungen.html","titel":"Selbsttest","anker":"selbsttest-loesung-fundament","text":""},{"seite":"anhang-loesungen.html","titel":"A.3 Lösungen zu Kapitel „Das Python-Ökosystem für OR — Solver, Bindings und Modellierungsschichten“","anker":"sec:loesungen-oekosystem","text":"3.1 — Solverwahl. (a) CP-SAT (diskrete Zuordnung mit Zeitfenstern). (b) scipy.optimize.linprog (klassisches Mischungs-LP, klein). (c) CVXPY (konvexes QP). (d) MIQP — CVXPY mit Binä"},{"seite":"anhang-loesungen.html","titel":"Finde den Denkfehler — Der Solver, der angeblich dreimal schneller ist","anker":"finde-den-denkfehler-der-solver-der-angeblich-dreimal-schneller-ist","text":""},{"seite":"anhang-loesungen.html","titel":"Micro-Quiz","anker":"quiz-loesung-oekosystem","text":"1 — (b) CP-SAT. Es geht um diskrete Zuweisung mit logischen Regeln („nicht gleichzeitig“) — CP-SATs Kerngebiet, und Regeln dieser Art formuliert man dort direkt statt über Big-M-Um"},{"seite":"anhang-loesungen.html","titel":"Selbsttest","anker":"selbsttest-loesung-oekosystem","text":""},{"seite":"anhang-loesungen.html","titel":"A.4 Lösungen zu Kapitel „Vom Management-Wunsch zum Modell“","anker":"sec:loesungen-modellierung","text":"4.1 — Die fehlende Lesart. Eine dritte Lesart: „Der Umsatzanteil der Stammkunden darf nicht unter 30 % fallen.” Sie zielt weder auf einzelne Aufträge noch auf einzelne Kunden, sond"},{"seite":"anhang-loesungen.html","titel":"Finde den Denkfehler — „Die Engpassmaschine soll zu mindestens 92 % ausgelastet sein“","anker":"denkfehler-loesung-modellierung","text":"Fehler 1: Auslastung ist ein Ergebnis, keine Anforderung."},{"seite":"anhang-loesungen.html","titel":"Micro-Quiz","anker":"quiz-loesung-modellierung","text":"1. b) Die Zielfunktion ist eine vollständige Aussage darüber, was zählt. Was nicht darin steht, ist für das Modell nicht „weniger wichtig”, sondern wertlos. (a) und (c) sind frei e"},{"seite":"anhang-loesungen.html","titel":"Selbsttest","anker":"selbsttest-loesung-modellierung","text":""},{"seite":"anhang-loesungen.html","titel":"A.5 Lösungen zu Kapitel „Lineare Programmierung — Simplex, Dualität und Schattenpreise“","anker":"sec:loesungen-lp","text":"5.1 — Schlupf deuten. (a) Ressourcen 1 und 3 (Schlupf 0). (b) Ja: Überall ist s_i \\cdot y_i = 0. (c) In Ressource 3 — der höchste Schattenpreis (9,8) bedeutet den größten Grenznutz"},{"seite":"anhang-loesungen.html","titel":"Finde den Denkfehler — Die 380 000-Euro-Maschine","anker":"finde-den-denkfehler-die-380-000-euro-maschine","text":""},{"seite":"anhang-loesungen.html","titel":"Micro-Quiz","anker":"quiz-loesung-lp","text":"1 — (b). Genau der Satz vom komplementären Schlupf: s_i \\cdot y_i = 0. Ist Schlupf vorhanden, muss der Dualwert null sein. (a) hat die Aussage in ihr Gegenteil verkehrt; (c) verwec"},{"seite":"anhang-loesungen.html","titel":"Selbsttest","anker":"selbsttest-loesung-lp","text":""},{"seite":"anhang-loesungen.html","titel":"A.6 Lösungen zu Kapitel „Gemischt-ganzzahlige Optimierung — Diskrete Entscheidungen und Branch-and-Bound“","anker":"sec:loesungen-milp","text":"6.1 — Runden widerlegen. Beispiel: \\max x_1 + x_2 u. d. N. 10x_1 + 10x_2 \\le 15, ganzzahlig. LP-Optimum Z = 1{,}5; Abrunden ergibt (0,0) mit Z = 0 — 100 % Verlust. Das ganzzahlige "},{"seite":"anhang-loesungen.html","titel":"Finde den Denkfehler — Elf Lager, die keine Fixkosten kosten","anker":"finde-den-denkfehler-elf-lager-die-keine-fixkosten-kosten","text":""},{"seite":"anhang-loesungen.html","titel":"Micro-Quiz","anker":"quiz-loesung-milp","text":"1 — (b). Der Gap (48\\,200 - 47\\,100)/48\\,200 = 2{,}3\\,\\% ist eine Garantie, keine Schätzung: Besser als 47 100 € kann es nachweislich nicht werden, also ist der vorliegende Plan hö"},{"seite":"anhang-loesungen.html","titel":"Selbsttest","anker":"selbsttest-loesung-milp","text":""},{"seite":"anhang-loesungen.html","titel":"A.7 Lösungen zu Kapitel „Constraint Programming mit CP-SAT — Logik, Scheduling und Zuweisung“","anker":"sec:loesungen-cpsat","text":"7.1 — Propagation. Aus x_1 + x_2 = 8 und x_1 &lt; x_2 folgt x_1 &lt; 4, also x_1 \\in \\{2,3\\} (denn x_2 = 8-x_1 \\le 6 verlangt x_1 \\ge 2) und entsprechend x_2 \\in \\{5,6\\}. Aus 36 Ko"},{"seite":"anhang-loesungen.html","titel":"Finde den Denkfehler — Die Betriebsvereinbarung, die niemanden interessiert","anker":"finde-den-denkfehler-die-betriebsvereinbarung-die-niemanden-interessiert","text":""},{"seite":"anhang-loesungen.html","titel":"Micro-Quiz","anker":"quiz-loesung-cpsat","text":"1 — (b) wirkungslos. INFEASIBLE ist kein Abbruch, sondern ein Beweis: CP-SAT hat gezeigt, dass keine zulässige Lösung existiert. Mehr Zeit (a) oder mehr Arbeiter (c) ändern daran n"},{"seite":"anhang-loesungen.html","titel":"Selbsttest","anker":"selbsttest-loesung-cpsat","text":""},{"seite":"anhang-loesungen.html","titel":"A.8 Lösungen zu Kapitel „Graphen, Flüsse und Touren — Min-Cost-Flow, Matching und VRP“","anker":"sec:loesungen-graphen","text":"8.1 — Flusserhaltung. b_i = (15+3) - (12+8) = -2 → Senke (Nettobedarf 2)."},{"seite":"anhang-loesungen.html","titel":"Finde den Denkfehler — Die vergessene Dimension","anker":"finde-den-denkfehler-die-vergessene-dimension","text":""},{"seite":"anhang-loesungen.html","titel":"Micro-Quiz","anker":"quiz-loesung-graphen","text":"1 — (b) totale Unimodularität. Jede quadratische Teilmatrix hat Determinante 0, +1 oder -1; bei ganzzahliger rechter Seite sind deshalb alle Ecken des zulässigen Bereichs ganzzahli"},{"seite":"anhang-loesungen.html","titel":"Selbsttest","anker":"selbsttest-loesung-graphen","text":""},{"seite":"anhang-loesungen.html","titel":"A.9 Lösungen zu Kapitel „Metaheuristiken — wenn der exakte Solver aussteigt“","anker":"sec:loesungen-metaheuristiken","text":"9.1 — Die Kurzsichtigkeit von Hand. Ab Schwarz wählt die Faustregel: Schwarz → Dunkelrot (26) → Rot (5) → … und muss dann in die helle Gruppe: Rot → Weiß (50) → Elfenbein (2) → Bei"},{"seite":"anhang-loesungen.html","titel":"Finde den Denkfehler — „Unsere Heuristik ist 6 % besser“","anker":"denkfehler-loesung-metaheuristiken","text":"Es fehlt die Schranke."},{"seite":"anhang-loesungen.html","titel":"Micro-Quiz","anker":"quiz-loesung-metaheuristiken","text":"1. b) Eine lokale Suche lebt von der Zahl geprüfter Züge. Die volle Summe kostet O(n) statt O(1) — bei 500 Aufträgen zwei Größenordnungen weniger Züge im selben Zeitbudget. Numeris"},{"seite":"anhang-loesungen.html","titel":"Selbsttest","anker":"selbsttest-loesung-metaheuristiken","text":""},{"seite":"anhang-loesungen.html","titel":"A.10 Lösungen zu Kapitel „Spaltengenerierung“","anker":"sec:loesungen-dekomposition","text":"10.1 — Das Abbruchkriterium. Die Eins ist der Zielfunktionskoeffizient eines Musters: Jedes geschnittene Muster verbraucht genau eine Mutterrolle, und die Zielfunktion lautet \\min "},{"seite":"anhang-loesungen.html","titel":"Finde den Denkfehler — „Die LP-Lösung sagt 72,92 — also runden wir auf“","anker":"denkfehler-loesung-dekomposition","text":"Das Aufrunden kostet sechs Rollen — acht Prozent."},{"seite":"anhang-loesungen.html","titel":"Micro-Quiz","anker":"quiz-loesung-dekomposition","text":"1. b) Das Mustermodell kennt keine einzelnen Rollen und damit keine austauschbaren Objekte — die Symmetrie verschwindet. (a) trifft zufällig auch zu, ist aber nicht der Grund; (c) "},{"seite":"anhang-loesungen.html","titel":"Selbsttest","anker":"selbsttest-loesung-dekomposition","text":""},{"seite":"anhang-loesungen.html","titel":"A.11 Lösungen zu Kapitel „Quadratische und nichtlineare Optimierung — KKT, Lagrange, Konvexität“","anker":"sec:loesungen-qp-nlp","text":"11.1 — Konvexität einordnen. PSD (alle \\ge 0) → konvex, aber nicht streng konvex; die Lösung ist nicht notwendig eindeutig. Der Eigenwert 0 bedeutet eine flache Richtung: Entlang d"},{"seite":"anhang-loesungen.html","titel":"Finde den Denkfehler — Die Kovarianzmatrix aus dem Controlling","anker":"finde-den-denkfehler-die-kovarianzmatrix-aus-dem-controlling","text":""},{"seite":"anhang-loesungen.html","titel":"Micro-Quiz","anker":"quiz-loesung-qp-nlp","text":"1 — (b). Der DCPError ist eine inhaltliche Aussage: Für diese Formulierung kann es keine Optimalitätsgarantie geben. Auf scipy auszuweichen (a) beseitigt die Meldung, nicht die Urs"},{"seite":"anhang-loesungen.html","titel":"Selbsttest","anker":"selbsttest-loesung-qp-nlp","text":""},{"seite":"anhang-loesungen.html","titel":"A.12 Lösungen zu Kapitel „Optimierung unter Unsicherheit — Monte-Carlo, Stochastik, Robustheit“","anker":"sec:loesungen-unsicherheit","text":"12.1 — Fluch des Durchschnitts. Weil sich Verzögerungen fortpflanzen und die Verteilung rechtsschief ist: Ein Gewerk, das früher fertig wird, beschleunigt selten den Gesamtablauf ("},{"seite":"anhang-loesungen.html","titel":"Finde den Denkfehler — Warum jedes Projekt zu spät fertig wird","anker":"finde-den-denkfehler-warum-jedes-projekt-zu-spät-fertig-wird","text":""},{"seite":"anhang-loesungen.html","titel":"Micro-Quiz","anker":"quiz-loesung-unsicherheit","text":"1 — (b). Das kritische Verhältnis 1400/(1400+120) = 0{,}921 gibt an, wie weit man sich auf die günstigere Fehlerseite stellen soll: Bestellt wird das 92,1-%-Quantil des Bedarfs, hi"},{"seite":"anhang-loesungen.html","titel":"Selbsttest","anker":"selbsttest-loesung-unsicherheit","text":""},{"seite":"anhang-loesungen.html","titel":"A.13 Lösungen zu Kapitel „Dynamische Programmierung — Die Bellman-Gleichung und Order-Execution“","anker":"sec:loesungen-dynamische-programmierung","text":"13.1 — Bausteine. Stufe = Tag 1–5; Zustand = verbleibende Distanz (ggf. plus Erschöpfungsgrad); Aktion = heutige Tagesetappe; Wertfunktion = minimale Restanstrengung. Nicht in den "},{"seite":"anhang-loesungen.html","titel":"Finde den Denkfehler — Der Zustand, der zu wenig weiß","anker":"finde-den-denkfehler-der-zustand-der-zu-wenig-weiß","text":""},{"seite":"anhang-loesungen.html","titel":"Micro-Quiz","anker":"quiz-loesung-dynamische-programmierung","text":"1 — (b). V_t setzt V_{t+1} voraus: Eine Entscheidung lässt sich erst bewerten, wenn feststeht, was sie für die Zukunft bedeutet. Am Ende ist dieser Wert bekannt (V_T = g), deshalb "},{"seite":"anhang-loesungen.html","titel":"Selbsttest","anker":"selbsttest-loesung-dynamische-programmierung","text":""},{"seite":"anhang-loesungen.html","titel":"A.14 Lösungen zu Kapitel „Mehrere Ziele — Pareto-Fronten statt Gewichte“","anker":"sec:loesungen-mehrziel","text":"14.1 — Dominanz prüfen. P (14 000 €, 6 000 kg) und Q (13 800 €, 6 100 kg): keiner dominiert den anderen. Q ist billiger, P ist sauberer — beide sind pareto-optimal, die Wahl ist ei"},{"seite":"anhang-loesungen.html","titel":"Finde den Denkfehler — „Wir haben die Gewichte sauber kalibriert“","anker":"denkfehler-loesung-mehrziel","text":"Der Lösungsraum wurde nicht vollständig abgetastet — und zwar aus prinzipiellen Gründen."},{"seite":"anhang-loesungen.html","titel":"Micro-Quiz","anker":"quiz-loesung-mehrziel","text":"1. b) Geometrisch heißt „gewichtete Summe minimieren“: eine Gerade von links unten an die Punktwolke schieben. Sie berührt immer einen Eckpunkt der unteren konvexen Hülle; Punkte d"},{"seite":"anhang-loesungen.html","titel":"Selbsttest","anker":"selbsttest-loesung-mehrziel","text":""},{"seite":"anhang-loesungen.html","titel":"A.15 Lösungen zu Kapitel „Predict-then-Optimize“","anker":"sec:loesungen-prognose","text":"15.1 — Andere Preise. Der Überhang kostet nur noch 1,50 €, die Fehlmenge weiterhin 6 €. Das kritische Verhältnis steigt von 6/9 = 0{,}667 auf 6/7{,}5 = 0{,}80. Die Bestellmenge ver"},{"seite":"anhang-loesungen.html","titel":"Finde den Denkfehler — „Wir haben die Prognose um 18 % verbessert“","anker":"denkfehler-loesung-prognose","text":"Der Sicherheitszuschlag stammt aus den Residuen des alten Modells."},{"seite":"anhang-loesungen.html","titel":"Micro-Quiz","anker":"quiz-loesung-prognose","text":"1. b) Die Kostenasymmetrie verschiebt das Optimum vom Erwartungswert zum kritischen Quantil. (a) und (c) sind reale Probleme, aber nicht dieses: Selbst bei perfekt bekannter, norma"},{"seite":"anhang-loesungen.html","titel":"Selbsttest","anker":"selbsttest-loesung-prognose","text":""},{"seite":"anhang-loesungen.html","titel":"A.16 Lösungen zu Kapitel „Die Strukturbrücke — dieselbe Mathematik, zwei Welten“","anker":"sec:loesungen-bruecke","text":"16.1 — Die dritte Ressource. „Liquidität” — wie schnell sich eine Position ohne Kursabschlag verkaufen lässt — entspricht in der Werkstatt der Umrüstbarkeit oder der Vorlaufzeit: W"},{"seite":"anhang-loesungen.html","titel":"Finde den Denkfehler — „Das ist doch dasselbe Problem“","anker":"denkfehler-loesung-bruecke","text":"Fehler 1: Varianz ist hier das falsche Risikomaß — genau der Fall, für den es CVaR gibt."},{"seite":"anhang-loesungen.html","titel":"Micro-Quiz","anker":"quiz-loesung-bruecke","text":"1. b) Beide Probleme haben dieselbe Struktur: knappe Größen auf konkurrierende Verwendungen verteilen. (a) ist falsch — Produktionsproblem ist streng typisiert und validiert beim E"},{"seite":"anhang-loesungen.html","titel":"Selbsttest","anker":"selbsttest-loesung-bruecke","text":""},{"seite":"anhang-loesungen.html","titel":"A.17 Lösungen zu Kapitel „Supply-Chain und Energieeinsatz unter Unsicherheit“","anker":"sec:loesungen-supplychain","text":"17.1 — Der Umschlagpunkt. Bei 60 MW statt 120 MW halbiert sich die Grenzkostendifferenz je Stunde (83 €/MWh × 60 MW = 4 980 €/h). Der Umschlagpunkt verdoppelt sich auf 7,7 Stunden."},{"seite":"anhang-loesungen.html","titel":"Finde den Denkfehler — „Wir rechnen mit dem P50-Szenario“","anker":"denkfehler-loesung-supplychain","text":"Fehler 1: Der Median ist keine Absicherung, sondern eine Wette auf die Hälfte der Fälle."},{"seite":"anhang-loesungen.html","titel":"Micro-Quiz","anker":"quiz-loesung-supplychain","text":"1. b) Anfahrkosten und Mindestlaufzeiten koppeln die Stunden. Die Merit-Order ist eine Sortierung und kennt keine Kopplung über die Zeit; sie ist für einen einzelnen Zeitpunkt rich"},{"seite":"anhang-loesungen.html","titel":"Selbsttest","anker":"selbsttest-loesung-supplychain","text":""},{"seite":"anhang-loesungen.html","titel":"A.18 Lösungen zu Kapitel „Finanzdaten-Modellierung — Renditen, Kovarianz und Shrinkage“","anker":"sec:loesungen-finanzdaten","text":"18.1 — Renditeart. (a) diskret. (b) logarithmisch. (c) logarithmisch (bzw. diskret kumuliert über Produkt). (d) logarithmisch (statistische Eigenschaften)."},{"seite":"anhang-loesungen.html","titel":"Finde den Denkfehler — Das risikofreie Portfolio","anker":"finde-den-denkfehler-das-risikofreie-portfolio","text":""},{"seite":"anhang-loesungen.html","titel":"Micro-Quiz","anker":"quiz-loesung-finanzdaten","text":"1 — (b) bei 75 %. 1{,}0 \\cdot 0{,}5 \\cdot 1{,}5 = 0{,}75. Prozentuale Änderungen verknüpfen sich multiplikativ; ein Verlust wiegt schwerer als ein gleich großer Gewinn, weil er von"},{"seite":"anhang-loesungen.html","titel":"Selbsttest","anker":"selbsttest-loesung-finanzdaten","text":""},{"seite":"anhang-loesungen.html","titel":"A.19 Lösungen zu Kapitel „Die moderne Portfoliotheorie nach Markowitz“","anker":"sec:loesungen-markowitz","text":"19.1 — Diversifikationseffekt."},{"seite":"anhang-loesungen.html","titel":"Finde den Denkfehler — Zwölf gleiche Anlagen, ein sehr ungleiches Portfolio","anker":"finde-den-denkfehler-zwölf-gleiche-anlagen-ein-sehr-ungleiches-portfolio","text":""},{"seite":"anhang-loesungen.html","titel":"Micro-Quiz","anker":"quiz-loesung-markowitz","text":"1 — (b). Das renditestärkste Portfolio auf der Effizienzlinie hat notwendig das schlechteste Rendite-Risiko-Verhältnis (im Kapitelbeispiel 0,44 gegenüber 0,75 beim Optimum) und bes"},{"seite":"anhang-loesungen.html","titel":"Selbsttest","anker":"selbsttest-loesung-markowitz","text":""},{"seite":"anhang-loesungen.html","titel":"A.20 Lösungen zu Kapitel „Tail-Risiko, CVaR und Transaktionskosten“","anker":"sec:loesungen-cvar","text":"20.1 — VaR und CVaR von Hand. Sortierte Verluste: -2{,}0; -1{,}2; -0{,}8; -0{,}4; 0{,}3; 0{,}6; 1{,}1; 2{,}1; 5{,}4; 8{,}9. Das 80 %-Quantil ist der 8. Wert: \\text{VaR}_{80\\%} = 2{"},{"seite":"anhang-loesungen.html","titel":"Finde den Denkfehler — Das Risikobudget, das durch Diversifikation stieg","anker":"finde-den-denkfehler-das-risikobudget-das-durch-diversifikation-stieg","text":""},{"seite":"anhang-loesungen.html","titel":"Micro-Quiz","anker":"quiz-loesung-cvar","text":"1 — (b) nichts. Der VaR ist ein Quantil: Er markiert die Schwelle und sagt nichts über den Bereich dahinter. Genau das zeigt der Schnellstart dieses Kapitels — zwei Anlagen mit ide"},{"seite":"anhang-loesungen.html","titel":"Selbsttest","anker":"selbsttest-loesung-cvar","text":""},{"seite":"anhang-loesungen.html","titel":"A.21 Lösungen zu Kapitel „Die vollständige quantitative Handelsmaschine“","anker":"sec:loesungen-handelsmaschine","text":"21.1 — Lookahead erkennen. (a) sauber (:heute). (b) Lookahead — gesamter Zeitraum. (c) Lookahead — Volatilität über den ganzen Zeitraum enthält Zukunft. (d) sauber — Gewichte aus D"},{"seite":"anhang-loesungen.html","titel":"Finde den Denkfehler — Die Strategie mit dem hochsignifikanten Ergebnis","anker":"finde-den-denkfehler-die-strategie-mit-dem-hochsignifikanten-ergebnis","text":""},{"seite":"anhang-loesungen.html","titel":"Micro-Quiz","anker":"quiz-loesung-handelsmaschine","text":"1 — (b) nichts. Beide Kennzahlen sind Mittelwerte über die Zeit und blind für die Reihenfolge. Der Schnellstart dieses Kapitels zeigt es an denselben Tagesrenditen, nur anders ange"},{"seite":"anhang-loesungen.html","titel":"Selbsttest","anker":"selbsttest-loesung-handelsmaschine","text":""},{"seite":"anhang-loesungen.html","titel":"A.22 Lösungen zu Kapitel „Praxisfallen und der Weg zum produktiven Einsatz“","anker":"sec:loesungen-praxisfallen","text":"22.1 — Hart oder weich, revisited. (a) hart: gesetzliche Ruhezeit, Qualifikationspflicht. (b) weich: individuelle Wunschtage, Vermeidung von Freistunden. (c) diskutabel: Höchstzahl"},{"seite":"anhang-loesungen.html","titel":"Finde den Denkfehler — Das Modell, das seit einem Jahr nicht mehr optimiert","anker":"finde-den-denkfehler-das-modell-das-seit-einem-jahr-nicht-mehr-optimiert","text":""},{"seite":"anhang-loesungen.html","titel":"Micro-Quiz","anker":"quiz-loesung-praxisfallen","text":"1 — (b) das Zeitlimit greift. Eine Laufzeit, die exakt dem Limit entspricht und über Monate konstant bleibt, ist kein Stabilitätsbeleg, sondern zeigt, dass der Solver jedes Mal abg"},{"seite":"anhang-loesungen.html","titel":"Selbsttest","anker":"selbsttest-loesung-praxisfallen","text":""},{"seite":"anhang-loesungen.html","titel":"A.23 Lösungen zu Kapitel „Testen, Messen, Ausliefern“","anker":"sec:loesungen-testing","text":"23.1 — Den Schnellstart reparieren. Zwei Wege: (a) Abrunden statt runden — np.floor statt np.round. Das ist immer zulässig, weil weniger produzieren nie eine Kapazität sprengt, kos"},{"seite":"anhang-loesungen.html","titel":"Finde den Denkfehler — „Die Suite ist grün, das Modell stimmt”","anker":"denkfehler-loesung-testing","text":"Alle Prüfungen benutzen dieselbe falsche Zahl."},{"seite":"anhang-loesungen.html","titel":"Micro-Quiz","anker":"quiz-loesung-testing","text":"1. b) Es gibt keine unabhängige Quelle für die richtige Antwort — sonst bräuchte man den Solver nicht. (a) ist bei festgelegtem Seed und Zeitlimit meist beherrschbar; (c) löst man "},{"seite":"anhang-loesungen.html","titel":"Selbsttest","anker":"selbsttest-loesung-testing","text":""},{"seite":"anhang-modellierungsmuster.html","titel":"Anhang B: Katalog der Modellierungsmuster","anker":null,"text":""},{"seite":"anhang-modellierungsmuster.html","titel":"Übersicht","anker":"übersicht","text":""},{"seite":"anhang-modellierungsmuster.html","titel":"Logische Schalter","anker":"logische-schalter","text":""},{"seite":"anhang-modellierungsmuster.html","titel":"B1 — Aktivierungsschalter (Fixkosten)","anker":"b1-aktivierungsschalter-fixkosten","text":"Regel. „Wenn überhaupt etwas produziert wird, fallen Rüstkosten F an.“"},{"seite":"anhang-modellierungsmuster.html","titel":"B2 — Semikontinuierliche Variable","anker":"b2-semikontinuierliche-variable","text":"Regel. „Entweder gar nicht oder mindestens L (und höchstens U).“"},{"seite":"anhang-modellierungsmuster.html","titel":"B3 — Implikation","anker":"b3-implikation","text":"Regel. „Wenn A gewählt wird, muss auch B gewählt werden.“"},{"seite":"anhang-modellierungsmuster.html","titel":"B4 — Entweder-Oder (disjunktive Bedingung)","anker":"b4-entweder-oder-disjunktive-bedingung","text":"Regel. „Es muss f(\\mathbf{x}) \\le b_1 oder g(\\mathbf{x}) \\le b_2 gelten.“"},{"seite":"anhang-modellierungsmuster.html","titel":"B5 — Exklusiv-Oder","anker":"b5-exklusiv-oder","text":"Regel. „Genau eine der Optionen wird gewählt.“"},{"seite":"anhang-modellierungsmuster.html","titel":"B6 — Kardinalität","anker":"b6-kardinalität","text":"Regel. „Höchstens (mindestens, genau) K von N.“"},{"seite":"anhang-modellierungsmuster.html","titel":"B7 — Bedingte Kopplung (Konjunktion)","anker":"b7-bedingte-kopplung-konjunktion","text":"Regel. „Wenn A und B, dann auch C.“"},{"seite":"anhang-modellierungsmuster.html","titel":"Mengen und Grenzen","anker":"mengen-und-grenzen","text":""},{"seite":"anhang-modellierungsmuster.html","titel":"B8 — Weiche Grenze mit Strafkosten","anker":"b8-weiche-grenze-mit-strafkosten","text":"Regel. „Möglichst nicht über b — wenn doch, kostet es.“"},{"seite":"anhang-modellierungsmuster.html","titel":"B9 — Gestaffelte Preise (stückweise linear)","anker":"b9-gestaffelte-preise-stückweise-linear","text":"Regel. „Die ersten 100 Stück kosten 5 €, danach 8 €.“"},{"seite":"anhang-modellierungsmuster.html","titel":"B10 — Absolutbetrag / Abweichung","anker":"b10-absolutbetrag-abweichung","text":"Regel. „Die Abweichung vom Zielwert soll klein sein, egal in welche Richtung.“"},{"seite":"anhang-modellierungsmuster.html","titel":"B11 — Min/Max in der Zielfunktion","anker":"b11-minmax-in-der-zielfunktion","text":"Regel. „Der am schlechtesten gestellte Beteiligte soll möglichst gut dastehen“ (Maximin/Fairness)."},{"seite":"anhang-modellierungsmuster.html","titel":"B12 — Verhältnis-Bedingung","anker":"b12-verhältnis-bedingung","text":"Regel. „Der Anteil von Gruppe G soll mindestens 30 % betragen.“"},{"seite":"anhang-modellierungsmuster.html","titel":"B25 — Mindestabnahmemenge über einen Zeitraum","anker":"b25-mindestabnahmemenge-über-einen-zeitraum","text":"Regel. „Entweder wir arbeiten mit diesem Lieferanten gar nicht, oder wir nehmen ihm im Jahr mindestens 500 Einheiten ab.“"},{"seite":"anhang-modellierungsmuster.html","titel":"B27 — Budgetlimit","anker":"b27-budgetlimit","text":"Regel. „Alle Maßnahmen zusammen dürfen 2 Mio. € nicht überschreiten.“"},{"seite":"anhang-modellierungsmuster.html","titel":"Zeit und Reihenfolge","anker":"zeit-und-reihenfolge","text":""},{"seite":"anhang-modellierungsmuster.html","titel":"B13 — Vorrangbeziehung","anker":"b13-vorrangbeziehung","text":"Regel. „Arbeitsgang B darf erst beginnen, wenn A fertig ist.“"},{"seite":"anhang-modellierungsmuster.html","titel":"B14 — Nichtüberlappung","anker":"b14-nichtüberlappung","text":"Regel. „Eine Maschine bearbeitet nur einen Job gleichzeitig.“"},{"seite":"anhang-modellierungsmuster.html","titel":"B15 — Kumulative Ressource","anker":"b15-kumulative-ressource","text":"Regel. „Zu keinem Zeitpunkt dürfen mehr als 3 Arbeiten gleichzeitig laufen“ bzw. „die Stromlast darf 500 kW nie übersteigen“."},{"seite":"anhang-modellierungsmuster.html","titel":"B16 — Gleitendes Fenster","anker":"b16-gleitendes-fenster","text":"Regel. „Höchstens 5 Arbeitstage in Folge“ / „mindestens 2 freie Tage je Woche“."},{"seite":"anhang-modellierungsmuster.html","titel":"B17 — Umrüst- bzw. Wechselkosten","anker":"b17-umrüst--bzw.-wechselkosten","text":"Regel. „Ein Produktwechsel kostet Rüstzeit.“"},{"seite":"anhang-modellierungsmuster.html","titel":"B26 — Rüstzeit als Kapazitätsverbrauch","anker":"b26-rüstzeit-als-kapazitätsverbrauch","text":"Regel. „Das Umrüsten kostet nicht nur Geld, es kostet Maschinenstunden — und die fehlen dann für die Produktion.“"},{"seite":"anhang-modellierungsmuster.html","titel":"Robustheit und Diagnose","anker":"robustheit-und-diagnose","text":""},{"seite":"anhang-modellierungsmuster.html","titel":"B18 — Schlupfvariablen gegen Unlösbarkeit","anker":"b18-schlupfvariablen-gegen-unlösbarkeit","text":"Das wichtigste Muster für den Produktivbetrieb."},{"seite":"anhang-modellierungsmuster.html","titel":"B19 — Hierarchische Ziele (lexikografisch)","anker":"b19-hierarchische-ziele-lexikografisch","text":"Regel. „Erst die Besetzung sicherstellen, dann die Fairness optimieren.“"},{"seite":"anhang-modellierungsmuster.html","titel":"B20 — Symmetriebrechung","anker":"b20-symmetriebrechung","text":"Regel. „Drei identische Maschinen — der Solver soll nicht alle Vertauschungen durchprobieren.“"},{"seite":"anhang-modellierungsmuster.html","titel":"B21 — Worst-Case-Abzug (robuste Formulierung)","anker":"b21-worst-case-abzug-robuste-formulierung","text":"Regel. „Rechne nicht mit dem geschätzten Wert, sondern mit dem ungünstigsten plausiblen.“"},{"seite":"anhang-modellierungsmuster.html","titel":"Netzwerke","anker":"netzwerke","text":""},{"seite":"anhang-modellierungsmuster.html","titel":"B22 — Flusserhaltung","anker":"b22-flusserhaltung","text":"\\sum_{j:(i,j)\\in E} x_{ij} - \\sum_{k:(k,i)\\in E} x_{ki} = b_i \\qquad \\forall i"},{"seite":"anhang-modellierungsmuster.html","titel":"B23 — Zuordnung 1:1","anker":"b23-zuordnung-11","text":""},{"seite":"anhang-modellierungsmuster.html","titel":"B24 — Subtour-Eliminierung","anker":"b24-subtour-eliminierung","text":"MTZ (einfach, aber schwach): u_i - u_j + C x_{ij} \\le C - d_j \\qquad \\forall i\\ne j"},{"seite":"anhang-modellierungsmuster.html","titel":"Ein Wort zur Auswahl","anker":"ein-wort-zur-auswahl","text":"Wenn mehrere Muster passen, entscheiden Sie nach dieser Reihenfolge:"},{"seite":"anhang-fehlerdiagnose.html","titel":"Anhang C: Fehlerdiagnose-Handbuch","anker":null,"text":""},{"seite":"anhang-fehlerdiagnose.html","titel":"Symptom-Schnellübersicht","anker":"symptom-schnellübersicht","text":""},{"seite":"anhang-fehlerdiagnose.html","titel":"C1 — INFEASIBLE","anker":"c1-infeasible","text":"Bedeutung. Es gibt keinen einzigen Punkt, der alle Bedingungen gleichzeitig erfüllt. Das ist eine Aussage über Ihr Modell, nicht über den Solver."},{"seite":"anhang-fehlerdiagnose.html","titel":"Diagnose in fünf Schritten","anker":"diagnose-in-fünf-schritten","text":"Schritt 1 — Trivialprüfungen von Hand. Rechnen Sie die offensichtlichen Bilanzen nach, bevor Sie den Solver befragen:"},{"seite":"anhang-fehlerdiagnose.html","titel":"Wenn die fünf Schritte nicht reichen: den Konflikt einkreisen","anker":"wenn-die-fünf-schritte-nicht-reichen-den-konflikt-einkreisen","text":"Warum Schritt 2 so oft ins Leere läuft. Bedingungen einzeln abzuschalten funktioniert nur, solange es einen Schuldigen gibt. Überlagern sich zwei unabhängige Widersprüche, bleibt d"},{"seite":"anhang-fehlerdiagnose.html","titel":"C2 — UNBOUNDED","anker":"c2-unbounded","text":"Bedeutung. Die Zielfunktion lässt sich unbegrenzt verbessern."},{"seite":"anhang-fehlerdiagnose.html","titel":"C3 — Zu langsam","anker":"c3-zu-langsam","text":""},{"seite":"anhang-fehlerdiagnose.html","titel":"Diagnosereihenfolge","anker":"diagnosereihenfolge","text":"1. Ist es überhaupt das Lösen?"},{"seite":"anhang-fehlerdiagnose.html","titel":"C4 — Unsinniges Ergebnis","anker":"c4-unsinniges-ergebnis","text":"Der Solver hat immer recht — bezogen auf das Modell, das Sie ihm gegeben haben. Wenn das Ergebnis unsinnig ist, beschreibt Ihr Modell nicht das Problem, das Sie meinen."},{"seite":"anhang-fehlerdiagnose.html","titel":"Checkliste","anker":"checkliste","text":""},{"seite":"anhang-fehlerdiagnose.html","titel":"Die wirksamste Gegenmaßnahme","anker":"die-wirksamste-gegenmaßnahme","text":""},{"seite":"anhang-fehlerdiagnose.html","titel":"C5 — Instabile Lösung","anker":"c5-instabile-lösung","text":"Symptom. Ein zusätzlicher Handelstag, und das Portfolio sieht völlig anders aus."},{"seite":"anhang-fehlerdiagnose.html","titel":"Derselbe Fehler außerhalb der Finanzwelt","anker":"derselbe-fehler-außerhalb-der-finanzwelt","text":"Instabilität ist kein Portfolioproblem, sondern ein Skalierungsproblem — und es trifft jedes Modell, in dem Größen sehr verschiedener Ordnung nebeneinanderstehen. Euro-Beträge (10^"},{"seite":"anhang-fehlerdiagnose.html","titel":"C6 — Falsche Dualwerte","anker":"c6-falsche-dualwerte","text":"Symptom. Schattenpreise sind negativ, wo sie positiv sein sollten — oder null bei einer offensichtlich knappen Ressource."},{"seite":"anhang-fehlerdiagnose.html","titel":"Die drei Prüfungen","anker":"die-drei-prüfungen","text":"1. Vorzeichenkonvention. Haben Sie zur Maximierung negiert?"},{"seite":"anhang-fehlerdiagnose.html","titel":"C7 — Widersprüchliche Solver","anker":"c7-widersprüchliche-solver","text":"Symptom. linprog sagt 530, CVXPY sagt 529,8."},{"seite":"anhang-fehlerdiagnose.html","titel":"C8 — DCPError","anker":"c8-dcperror","text":""},{"seite":"anhang-fehlerdiagnose.html","titel":"C9 — Importfehler","anker":"c9-importfehler","text":""},{"seite":"anhang-fehlerdiagnose.html","titel":"C10 — Verdächtig guter Backtest","anker":"c10-verdächtig-guter-backtest","text":"Faustregel: Eine Sharpe Ratio über 2 bei einer einfachen Strategie ist fast immer ein Fehler, kein Fund."},{"seite":"anhang-fehlerdiagnose.html","titel":"Prüfreihenfolge","anker":"prüfreihenfolge","text":"1. Lookahead-Selbsttest."},{"seite":"anhang-fehlerdiagnose.html","titel":"C11 — Vertauschte Spalten","anker":"c11-vertauschte-spalten","text":"Symptom. Ergebnisse sind plausibel, aber falsch beschriftet — oder eine Sektorgrenze greift auf die falschen Titel."},{"seite":"anhang-fehlerdiagnose.html","titel":"Die goldene Diagnoseregel","anker":"die-goldene-diagnoseregel","text":""},{"seite":"anhang-spickzettel.html","titel":"Anhang D: Spickzettel der Solver","anker":null,"text":""},{"seite":"anhang-spickzettel.html","titel":"D1 — SciPy: linprog und milp","anker":"d1-scipy-linprog-und-milp","text":"Wofür. Die Einstiegsschicht: keine zusätzliche Installation, HiGHS als Unterbau, ideal für lineare und gemischt-ganzzahlige Probleme in Matrixform. Wofür nicht: alles, was sich nic"},{"seite":"anhang-spickzettel.html","titel":"Lineares Programm","anker":"lineares-programm","text":""},{"seite":"anhang-spickzettel.html","titel":"Ganzzahlig: milp","anker":"ganzzahlig-milp","text":""},{"seite":"anhang-spickzettel.html","titel":"Die drei häufigsten Stolpersteine","anker":"die-drei-häufigsten-stolpersteine","text":""},{"seite":"anhang-spickzettel.html","titel":"D2 — HiGHS über highspy","anker":"d2-highs-über-highspy","text":"Wofür. Derselbe Solver wie unter SciPy, aber direkt gesteuert: Optionen, Warm-Starts, inkrementelles Ändern eines bestehenden Modells. Wofür nicht: schnelles Hinschreiben — die CSR"},{"seite":"anhang-spickzettel.html","titel":"Die drei häufigsten Stolpersteine","anker":"die-drei-häufigsten-stolpersteine-1","text":""},{"seite":"anhang-spickzettel.html","titel":"D3 — OR-Tools: pywraplp","anker":"d3-or-tools-pywraplp","text":"Wofür. Bequeme algebraische Schreibweise für LP und MILP mit umschaltbarem Backend (GLOP, SCIP, CBC, SAT). Wofür nicht: Scheduling und kombinatorische Bedingungen — dafür ist CP-SA"},{"seite":"anhang-spickzettel.html","titel":"Die drei häufigsten Stolpersteine","anker":"die-drei-häufigsten-stolpersteine-2","text":""},{"seite":"anhang-spickzettel.html","titel":"D4 — CP-SAT: cp_model","anker":"d4-cp-sat-cp_model","text":"Wofür. Scheduling, Zuordnung, Reihenfolgen, alles Kombinatorische mit globalen Bedingungen. Wofür nicht: stetige Größen — CP-SAT rechnet ausschließlich ganzzahlig. Wer Nachkommaste"},{"seite":"anhang-spickzettel.html","titel":"Die drei häufigsten Stolpersteine","anker":"die-drei-häufigsten-stolpersteine-3","text":""},{"seite":"anhang-spickzettel.html","titel":"D5 — CVXPY","anker":"d5-cvxpy","text":"Wofür. Konvexe Probleme: quadratische Ziele, Normen, CVaR, alles mit Regularisierungstermen. Wofür nicht: große kombinatorische Modelle — der Aufbau der Ausdrücke wird dann selbst "},{"seite":"anhang-spickzettel.html","titel":"Die drei häufigsten Stolpersteine","anker":"die-drei-häufigsten-stolpersteine-4","text":""},{"seite":"anhang-spickzettel.html","titel":"D6 — Modellierungssprachen: Pyomo und Linopy","anker":"d6-modellierungssprachen-pyomo-und-linopy","text":"Wofür. Beide trennen Modell von Solver: dasselbe Modell läuft ohne Änderung unter HiGHS, CBC, Gurobi. Pyomo denkt in Mengen und Indizes wie eine mathematische Formulierung; Linopy "},{"seite":"anhang-spickzettel.html","titel":"Pyomo","anker":"pyomo","text":""},{"seite":"anhang-spickzettel.html","titel":"Linopy","anker":"linopy","text":""},{"seite":"anhang-spickzettel.html","titel":"Die drei häufigsten Stolpersteine","anker":"die-drei-häufigsten-stolpersteine-5","text":""},{"seite":"anhang-spickzettel.html","titel":"Die gemeinsame Regel","anker":"die-gemeinsame-regel","text":"Alle sechs Seiten haben denselben längsten Abschnitt: die Statusauswertung. Das ist kein Zufall. Ein Solveraufruf hat nie zwei Ausgänge, sondern mindestens fünf — optimal, zulässig"},{"seite":"anhang-glossar-literatur.html","titel":"Anhang E: Glossar und Literatur","anker":null,"text":""},{"seite":"anhang-glossar-literatur.html","titel":"Mathematische Optimierung — Grundlagen","anker":"mathematische-optimierung-grundlagen","text":""},{"seite":"anhang-glossar-literatur.html","titel":"Konvexe, nichtlineare und robuste Optimierung","anker":"konvexe-nichtlineare-und-robuste-optimierung","text":""},{"seite":"anhang-glossar-literatur.html","titel":"Constraint Programming und Scheduling","anker":"constraint-programming-und-scheduling","text":""},{"seite":"anhang-glossar-literatur.html","titel":"Quantitative Finanzmathematik","anker":"quantitative-finanzmathematik","text":""},{"seite":"anhang-glossar-literatur.html","titel":"Software und Dokumentation","anker":"software-und-dokumentation","text":""},{"seite":"anhang-glossar-literatur.html","titel":"Verbände und Normen","anker":"verbände-und-normen","text":""}];
diff --git a/OR_HTML_04/bilder_04/kap_supplychain_wirkung.png b/OR_HTML_04/bilder_04/kap_supplychain_wirkung.png
new file mode 100644
index 0000000..91c255f
Binary files /dev/null and b/OR_HTML_04/bilder_04/kap_supplychain_wirkung.png differ
diff --git a/OR_HTML_04/bilder_04/kap_supplychain_wirkung.svg b/OR_HTML_04/bilder_04/kap_supplychain_wirkung.svg
new file mode 100644
index 0000000..628d95b
--- /dev/null
+++ b/OR_HTML_04/bilder_04/kap_supplychain_wirkung.svg
@@ -0,0 +1,2093 @@
+<?xml version="1.0" encoding="utf-8" standalone="no"?>
+<!DOCTYPE svg PUBLIC "-//W3C//DTD SVG 1.1//EN"
+  "http://www.w3.org/Graphics/SVG/1.1/DTD/svg11.dtd">
+<svg xmlns:xlink="http://www.w3.org/1999/xlink" width="734.4pt" height="403.2pt" viewBox="0 0 734.4 403.2" xmlns="http://www.w3.org/2000/svg" version="1.1">
+ <metadata>
+  <rdf:RDF xmlns:dc="http://purl.org/dc/elements/1.1/" xmlns:cc="http://creativecommons.org/ns#" xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#">
+   <cc:Work>
+    <dc:type rdf:resource="http://purl.org/dc/dcmitype/StillImage"/>
+    <dc:format>image/svg+xml</dc:format>
+    <dc:creator>
+     <cc:Agent>
+      <dc:title>Matplotlib v3.10.8, https://matplotlib.org/</dc:title>
+     </cc:Agent>
+    </dc:creator>
+   </cc:Work>
+  </rdf:RDF>
+ </metadata>
+ <defs>
+  <style type="text/css">*{stroke-linejoin: round; stroke-linecap: butt}</style>
+ </defs>
+ <g id="figure_1">
+  <g id="patch_1">
+   <path d="M 0 403.2 
+L 734.4 403.2 
+L 734.4 0 
+L 0 0 
+z
+" style="fill: #ffffff"/>
+  </g>
+  <g id="axes_1">
+   <g id="patch_2">
+    <path d="M 75.89 342.11808 
+L 723.6 342.11808 
+L 723.6 49.856 
+L 75.89 49.856 
+z
+" style="fill: #ffffff"/>
+   </g>
+   <g id="matplotlib.axis_1">
+    <g id="xtick_1">
+     <g id="line2d_1">
+      <defs>
+       <path id="mf0a04b41f8" d="M 0 0 
+L 0 3.5 
+" style="stroke: #000000; stroke-width: 0.8"/>
+      </defs>
+      <g>
+       <use xlink:href="#mf0a04b41f8" x="144.841419" y="342.11808" style="stroke: #000000; stroke-width: 0.8"/>
+      </g>
+     </g>
+     <g id="text_1">
+      <!-- Zweistufiger -->
+      <g transform="translate(112.114231 357.096439) scale(0.105 -0.105)">
+       <defs>
+        <path id="DejaVuSans-5a" d="M 359 4666 
+L 4025 4666 
+L 4025 4184 
+L 1075 531 
+L 4097 531 
+L 4097 0 
+L 288 0 
+L 288 481 
+L 3238 4134 
+L 359 4134 
+L 359 4666 
+z
+" transform="scale(0.015625)"/>
+        <path id="DejaVuSans-77" d="M 269 3500 
+L 844 3500 
+L 1563 769 
+L 2278 3500 
+L 2956 3500 
+L 3675 769 
+L 4391 3500 
+L 4966 3500 
+L 4050 0 
+L 3372 0 
+L 2619 2869 
+L 1863 0 
+L 1184 0 
+L 269 3500 
+z
+" transform="scale(0.015625)"/>
+        <path id="DejaVuSans-65" d="M 3597 1894 
+L 3597 1613 
+L 953 1613 
+Q 991 1019 1311 708 
+Q 1631 397 2203 397 
+Q 2534 397 2845 478 
+Q 3156 559 3463 722 
+L 3463 178 
+Q 3153 47 2828 -22 
+Q 2503 -91 2169 -91 
+Q 1331 -91 842 396 
+Q 353 884 353 1716 
+Q 353 2575 817 3079 
+Q 1281 3584 2069 3584 
+Q 2775 3584 3186 3129 
+Q 3597 2675 3597 1894 
+z
+M 3022 2063 
+Q 3016 2534 2758 2815 
+Q 2500 3097 2075 3097 
+Q 1594 3097 1305 2825 
+Q 1016 2553 972 2059 
+L 3022 2063 
+z
+" transform="scale(0.015625)"/>
+        <path id="DejaVuSans-69" d="M 603 3500 
+L 1178 3500 
+L 1178 0 
+L 603 0 
+L 603 3500 
+z
+M 603 4863 
+L 1178 4863 
+L 1178 4134 
+L 603 4134 
+L 603 4863 
+z
+" transform="scale(0.015625)"/>
+        <path id="DejaVuSans-73" d="M 2834 3397 
+L 2834 2853 
+Q 2591 2978 2328 3040 
+Q 2066 3103 1784 3103 
+Q 1356 3103 1142 2972 
+Q 928 2841 928 2578 
+Q 928 2378 1081 2264 
+Q 1234 2150 1697 2047 
+L 1894 2003 
+Q 2506 1872 2764 1633 
+Q 3022 1394 3022 966 
+Q 3022 478 2636 193 
+Q 2250 -91 1575 -91 
+Q 1294 -91 989 -36 
+Q 684 19 347 128 
+L 347 722 
+Q 666 556 975 473 
+Q 1284 391 1588 391 
+Q 1994 391 2212 530 
+Q 2431 669 2431 922 
+Q 2431 1156 2273 1281 
+Q 2116 1406 1581 1522 
+L 1381 1569 
+Q 847 1681 609 1914 
+Q 372 2147 372 2553 
+Q 372 3047 722 3315 
+Q 1072 3584 1716 3584 
+Q 2034 3584 2315 3537 
+Q 2597 3491 2834 3397 
+z
+" transform="scale(0.015625)"/>
+        <path id="DejaVuSans-74" d="M 1172 4494 
+L 1172 3500 
+L 2356 3500 
+L 2356 3053 
+L 1172 3053 
+L 1172 1153 
+Q 1172 725 1289 603 
+Q 1406 481 1766 481 
+L 2356 481 
+L 2356 0 
+L 1766 0 
+Q 1100 0 847 248 
+Q 594 497 594 1153 
+L 594 3053 
+L 172 3053 
+L 172 3500 
+L 594 3500 
+L 594 4494 
+L 1172 4494 
+z
+" transform="scale(0.015625)"/>
+        <path id="DejaVuSans-75" d="M 544 1381 
+L 544 3500 
+L 1119 3500 
+L 1119 1403 
+Q 1119 906 1312 657 
+Q 1506 409 1894 409 
+Q 2359 409 2629 706 
+Q 2900 1003 2900 1516 
+L 2900 3500 
+L 3475 3500 
+L 3475 0 
+L 2900 0 
+L 2900 538 
+Q 2691 219 2414 64 
+Q 2138 -91 1772 -91 
+Q 1169 -91 856 284 
+Q 544 659 544 1381 
+z
+M 1991 3584 
+L 1991 3584 
+z
+" transform="scale(0.015625)"/>
+        <path id="DejaVuSans-66" d="M 2375 4863 
+L 2375 4384 
+L 1825 4384 
+Q 1516 4384 1395 4259 
+Q 1275 4134 1275 3809 
+L 1275 3500 
+L 2222 3500 
+L 2222 3053 
+L 1275 3053 
+L 1275 0 
+L 697 0 
+L 697 3053 
+L 147 3053 
+L 147 3500 
+L 697 3500 
+L 697 3744 
+Q 697 4328 969 4595 
+Q 1241 4863 1831 4863 
+L 2375 4863 
+z
+" transform="scale(0.015625)"/>
+        <path id="DejaVuSans-67" d="M 2906 1791 
+Q 2906 2416 2648 2759 
+Q 2391 3103 1925 3103 
+Q 1463 3103 1205 2759 
+Q 947 2416 947 1791 
+Q 947 1169 1205 825 
+Q 1463 481 1925 481 
+Q 2391 481 2648 825 
+Q 2906 1169 2906 1791 
+z
+M 3481 434 
+Q 3481 -459 3084 -895 
+Q 2688 -1331 1869 -1331 
+Q 1566 -1331 1297 -1286 
+Q 1028 -1241 775 -1147 
+L 775 -588 
+Q 1028 -725 1275 -790 
+Q 1522 -856 1778 -856 
+Q 2344 -856 2625 -561 
+Q 2906 -266 2906 331 
+L 2906 616 
+Q 2728 306 2450 153 
+Q 2172 0 1784 0 
+Q 1141 0 747 490 
+Q 353 981 353 1791 
+Q 353 2603 747 3093 
+Q 1141 3584 1784 3584 
+Q 2172 3584 2450 3431 
+Q 2728 3278 2906 2969 
+L 2906 3500 
+L 3481 3500 
+L 3481 434 
+z
+" transform="scale(0.015625)"/>
+        <path id="DejaVuSans-72" d="M 2631 2963 
+Q 2534 3019 2420 3045 
+Q 2306 3072 2169 3072 
+Q 1681 3072 1420 2755 
+Q 1159 2438 1159 1844 
+L 1159 0 
+L 581 0 
+L 581 3500 
+L 1159 3500 
+L 1159 2956 
+Q 1341 3275 1631 3429 
+Q 1922 3584 2338 3584 
+Q 2397 3584 2469 3576 
+Q 2541 3569 2628 3553 
+L 2631 2963 
+z
+" transform="scale(0.015625)"/>
+       </defs>
+       <use xlink:href="#DejaVuSans-5a"/>
+       <use xlink:href="#DejaVuSans-77" transform="translate(68.505859 0)"/>
+       <use xlink:href="#DejaVuSans-65" transform="translate(150.292969 0)"/>
+       <use xlink:href="#DejaVuSans-69" transform="translate(211.816406 0)"/>
+       <use xlink:href="#DejaVuSans-73" transform="translate(239.599609 0)"/>
+       <use xlink:href="#DejaVuSans-74" transform="translate(291.699219 0)"/>
+       <use xlink:href="#DejaVuSans-75" transform="translate(330.908203 0)"/>
+       <use xlink:href="#DejaVuSans-66" transform="translate(394.287109 0)"/>
+       <use xlink:href="#DejaVuSans-69" transform="translate(429.492188 0)"/>
+       <use xlink:href="#DejaVuSans-67" transform="translate(457.275391 0)"/>
+       <use xlink:href="#DejaVuSans-65" transform="translate(520.751953 0)"/>
+       <use xlink:href="#DejaVuSans-72" transform="translate(582.275391 0)"/>
+      </g>
+      <!-- Plan -->
+      <g transform="translate(133.672864 368.854142) scale(0.105 -0.105)">
+       <defs>
+        <path id="DejaVuSans-50" d="M 1259 4147 
+L 1259 2394 
+L 2053 2394 
+Q 2494 2394 2734 2622 
+Q 2975 2850 2975 3272 
+Q 2975 3691 2734 3919 
+Q 2494 4147 2053 4147 
+L 1259 4147 
+z
+M 628 4666 
+L 2053 4666 
+Q 2838 4666 3239 4311 
+Q 3641 3956 3641 3272 
+Q 3641 2581 3239 2228 
+Q 2838 1875 2053 1875 
+L 1259 1875 
+L 1259 0 
+L 628 0 
+L 628 4666 
+z
+" transform="scale(0.015625)"/>
+        <path id="DejaVuSans-6c" d="M 603 4863 
+L 1178 4863 
+L 1178 0 
+L 603 0 
+L 603 4863 
+z
+" transform="scale(0.015625)"/>
+        <path id="DejaVuSans-61" d="M 2194 1759 
+Q 1497 1759 1228 1600 
+Q 959 1441 959 1056 
+Q 959 750 1161 570 
+Q 1363 391 1709 391 
+Q 2188 391 2477 730 
+Q 2766 1069 2766 1631 
+L 2766 1759 
+L 2194 1759 
+z
+M 3341 1997 
+L 3341 0 
+L 2766 0 
+L 2766 531 
+Q 2569 213 2275 61 
+Q 1981 -91 1556 -91 
+Q 1019 -91 701 211 
+Q 384 513 384 1019 
+Q 384 1609 779 1909 
+Q 1175 2209 1959 2209 
+L 2766 2209 
+L 2766 2266 
+Q 2766 2663 2505 2880 
+Q 2244 3097 1772 3097 
+Q 1472 3097 1187 3025 
+Q 903 2953 641 2809 
+L 641 3341 
+Q 956 3463 1253 3523 
+Q 1550 3584 1831 3584 
+Q 2591 3584 2966 3190 
+Q 3341 2797 3341 1997 
+z
+" transform="scale(0.015625)"/>
+        <path id="DejaVuSans-6e" d="M 3513 2113 
+L 3513 0 
+L 2938 0 
+L 2938 2094 
+Q 2938 2591 2744 2837 
+Q 2550 3084 2163 3084 
+Q 1697 3084 1428 2787 
+Q 1159 2491 1159 1978 
+L 1159 0 
+L 581 0 
+L 581 3500 
+L 1159 3500 
+L 1159 2956 
+Q 1366 3272 1645 3428 
+Q 1925 3584 2291 3584 
+Q 2894 3584 3203 3211 
+Q 3513 2838 3513 2113 
+z
+" transform="scale(0.015625)"/>
+       </defs>
+       <use xlink:href="#DejaVuSans-50"/>
+       <use xlink:href="#DejaVuSans-6c" transform="translate(60.302734 0)"/>
+       <use xlink:href="#DejaVuSans-61" transform="translate(88.085938 0)"/>
+       <use xlink:href="#DejaVuSans-6e" transform="translate(149.365234 0)"/>
+      </g>
+     </g>
+    </g>
+    <g id="xtick_2">
+     <g id="line2d_2">
+      <g>
+       <use xlink:href="#mf0a04b41f8" x="272.293209" y="342.11808" style="stroke: #000000; stroke-width: 0.8"/>
+      </g>
+     </g>
+     <g id="text_2">
+      <!-- Brennstoff -->
+      <g transform="translate(245.064577 357.096439) scale(0.105 -0.105)">
+       <defs>
+        <path id="DejaVuSans-42" d="M 1259 2228 
+L 1259 519 
+L 2272 519 
+Q 2781 519 3026 730 
+Q 3272 941 3272 1375 
+Q 3272 1813 3026 2020 
+Q 2781 2228 2272 2228 
+L 1259 2228 
+z
+M 1259 4147 
+L 1259 2741 
+L 2194 2741 
+Q 2656 2741 2882 2914 
+Q 3109 3088 3109 3444 
+Q 3109 3797 2882 3972 
+Q 2656 4147 2194 4147 
+L 1259 4147 
+z
+M 628 4666 
+L 2241 4666 
+Q 2963 4666 3353 4366 
+Q 3744 4066 3744 3513 
+Q 3744 3084 3544 2831 
+Q 3344 2578 2956 2516 
+Q 3422 2416 3680 2098 
+Q 3938 1781 3938 1306 
+Q 3938 681 3513 340 
+Q 3088 0 2303 0 
+L 628 0 
+L 628 4666 
+z
+" transform="scale(0.015625)"/>
+        <path id="DejaVuSans-6f" d="M 1959 3097 
+Q 1497 3097 1228 2736 
+Q 959 2375 959 1747 
+Q 959 1119 1226 758 
+Q 1494 397 1959 397 
+Q 2419 397 2687 759 
+Q 2956 1122 2956 1747 
+Q 2956 2369 2687 2733 
+Q 2419 3097 1959 3097 
+z
+M 1959 3584 
+Q 2709 3584 3137 3096 
+Q 3566 2609 3566 1747 
+Q 3566 888 3137 398 
+Q 2709 -91 1959 -91 
+Q 1206 -91 779 398 
+Q 353 888 353 1747 
+Q 353 2609 779 3096 
+Q 1206 3584 1959 3584 
+z
+" transform="scale(0.015625)"/>
+       </defs>
+       <use xlink:href="#DejaVuSans-42"/>
+       <use xlink:href="#DejaVuSans-72" transform="translate(68.603516 0)"/>
+       <use xlink:href="#DejaVuSans-65" transform="translate(107.466797 0)"/>
+       <use xlink:href="#DejaVuSans-6e" transform="translate(168.990234 0)"/>
+       <use xlink:href="#DejaVuSans-6e" transform="translate(232.369141 0)"/>
+       <use xlink:href="#DejaVuSans-73" transform="translate(295.748047 0)"/>
+       <use xlink:href="#DejaVuSans-74" transform="translate(347.847656 0)"/>
+       <use xlink:href="#DejaVuSans-6f" transform="translate(387.056641 0)"/>
+       <use xlink:href="#DejaVuSans-66" transform="translate(448.238281 0)"/>
+       <use xlink:href="#DejaVuSans-66" transform="translate(483.443359 0)"/>
+      </g>
+     </g>
+    </g>
+    <g id="xtick_3">
+     <g id="line2d_3">
+      <g>
+       <use xlink:href="#mf0a04b41f8" x="399.745" y="342.11808" style="stroke: #000000; stroke-width: 0.8"/>
+      </g>
+     </g>
+     <g id="text_3">
+      <!-- Anfahren -->
+      <g transform="translate(375.836172 357.096439) scale(0.105 -0.105)">
+       <defs>
+        <path id="DejaVuSans-41" d="M 2188 4044 
+L 1331 1722 
+L 3047 1722 
+L 2188 4044 
+z
+M 1831 4666 
+L 2547 4666 
+L 4325 0 
+L 3669 0 
+L 3244 1197 
+L 1141 1197 
+L 716 0 
+L 50 0 
+L 1831 4666 
+z
+" transform="scale(0.015625)"/>
+        <path id="DejaVuSans-68" d="M 3513 2113 
+L 3513 0 
+L 2938 0 
+L 2938 2094 
+Q 2938 2591 2744 2837 
+Q 2550 3084 2163 3084 
+Q 1697 3084 1428 2787 
+Q 1159 2491 1159 1978 
+L 1159 0 
+L 581 0 
+L 581 4863 
+L 1159 4863 
+L 1159 2956 
+Q 1366 3272 1645 3428 
+Q 1925 3584 2291 3584 
+Q 2894 3584 3203 3211 
+Q 3513 2838 3513 2113 
+z
+" transform="scale(0.015625)"/>
+       </defs>
+       <use xlink:href="#DejaVuSans-41"/>
+       <use xlink:href="#DejaVuSans-6e" transform="translate(68.408203 0)"/>
+       <use xlink:href="#DejaVuSans-66" transform="translate(131.787109 0)"/>
+       <use xlink:href="#DejaVuSans-61" transform="translate(166.992188 0)"/>
+       <use xlink:href="#DejaVuSans-68" transform="translate(228.271484 0)"/>
+       <use xlink:href="#DejaVuSans-72" transform="translate(291.650391 0)"/>
+       <use xlink:href="#DejaVuSans-65" transform="translate(330.513672 0)"/>
+       <use xlink:href="#DejaVuSans-6e" transform="translate(392.037109 0)"/>
+      </g>
+     </g>
+    </g>
+    <g id="xtick_4">
+     <g id="line2d_4">
+      <g>
+       <use xlink:href="#mf0a04b41f8" x="527.196791" y="342.11808" style="stroke: #000000; stroke-width: 0.8"/>
+      </g>
+     </g>
+     <g id="text_4">
+      <!-- Lastabwurf -->
+      <g transform="translate(498.0839 357.096439) scale(0.105 -0.105)">
+       <defs>
+        <path id="DejaVuSans-4c" d="M 628 4666 
+L 1259 4666 
+L 1259 531 
+L 3531 531 
+L 3531 0 
+L 628 0 
+L 628 4666 
+z
+" transform="scale(0.015625)"/>
+        <path id="DejaVuSans-62" d="M 3116 1747 
+Q 3116 2381 2855 2742 
+Q 2594 3103 2138 3103 
+Q 1681 3103 1420 2742 
+Q 1159 2381 1159 1747 
+Q 1159 1113 1420 752 
+Q 1681 391 2138 391 
+Q 2594 391 2855 752 
+Q 3116 1113 3116 1747 
+z
+M 1159 2969 
+Q 1341 3281 1617 3432 
+Q 1894 3584 2278 3584 
+Q 2916 3584 3314 3078 
+Q 3713 2572 3713 1747 
+Q 3713 922 3314 415 
+Q 2916 -91 2278 -91 
+Q 1894 -91 1617 61 
+Q 1341 213 1159 525 
+L 1159 0 
+L 581 0 
+L 581 4863 
+L 1159 4863 
+L 1159 2969 
+z
+" transform="scale(0.015625)"/>
+       </defs>
+       <use xlink:href="#DejaVuSans-4c"/>
+       <use xlink:href="#DejaVuSans-61" transform="translate(55.712891 0)"/>
+       <use xlink:href="#DejaVuSans-73" transform="translate(116.992188 0)"/>
+       <use xlink:href="#DejaVuSans-74" transform="translate(169.091797 0)"/>
+       <use xlink:href="#DejaVuSans-61" transform="translate(208.300781 0)"/>
+       <use xlink:href="#DejaVuSans-62" transform="translate(269.580078 0)"/>
+       <use xlink:href="#DejaVuSans-77" transform="translate(333.056641 0)"/>
+       <use xlink:href="#DejaVuSans-75" transform="translate(414.84375 0)"/>
+       <use xlink:href="#DejaVuSans-72" transform="translate(478.222656 0)"/>
+       <use xlink:href="#DejaVuSans-66" transform="translate(519.335938 0)"/>
+      </g>
+     </g>
+    </g>
+    <g id="xtick_5">
+     <g id="line2d_5">
+      <g>
+       <use xlink:href="#mf0a04b41f8" x="654.648581" y="342.11808" style="stroke: #000000; stroke-width: 0.8"/>
+      </g>
+     </g>
+     <g id="text_5">
+      <!-- Erwartungswert- -->
+      <g transform="translate(611.089167 357.096439) scale(0.105 -0.105)">
+       <defs>
+        <path id="DejaVuSans-45" d="M 628 4666 
+L 3578 4666 
+L 3578 4134 
+L 1259 4134 
+L 1259 2753 
+L 3481 2753 
+L 3481 2222 
+L 1259 2222 
+L 1259 531 
+L 3634 531 
+L 3634 0 
+L 628 0 
+L 628 4666 
+z
+" transform="scale(0.015625)"/>
+        <path id="DejaVuSans-2d" d="M 313 2009 
+L 1997 2009 
+L 1997 1497 
+L 313 1497 
+L 313 2009 
+z
+" transform="scale(0.015625)"/>
+       </defs>
+       <use xlink:href="#DejaVuSans-45"/>
+       <use xlink:href="#DejaVuSans-72" transform="translate(63.183594 0)"/>
+       <use xlink:href="#DejaVuSans-77" transform="translate(104.296875 0)"/>
+       <use xlink:href="#DejaVuSans-61" transform="translate(186.083984 0)"/>
+       <use xlink:href="#DejaVuSans-72" transform="translate(247.363281 0)"/>
+       <use xlink:href="#DejaVuSans-74" transform="translate(288.476562 0)"/>
+       <use xlink:href="#DejaVuSans-75" transform="translate(327.685547 0)"/>
+       <use xlink:href="#DejaVuSans-6e" transform="translate(391.064453 0)"/>
+       <use xlink:href="#DejaVuSans-67" transform="translate(454.443359 0)"/>
+       <use xlink:href="#DejaVuSans-73" transform="translate(517.919922 0)"/>
+       <use xlink:href="#DejaVuSans-77" transform="translate(570.019531 0)"/>
+       <use xlink:href="#DejaVuSans-65" transform="translate(651.806641 0)"/>
+       <use xlink:href="#DejaVuSans-72" transform="translate(713.330078 0)"/>
+       <use xlink:href="#DejaVuSans-74" transform="translate(754.443359 0)"/>
+       <use xlink:href="#DejaVuSans-2d" transform="translate(793.652344 0)"/>
+      </g>
+      <!-- Plan -->
+      <g transform="translate(643.480027 368.854142) scale(0.105 -0.105)">
+       <use xlink:href="#DejaVuSans-50"/>
+       <use xlink:href="#DejaVuSans-6c" transform="translate(60.302734 0)"/>
+       <use xlink:href="#DejaVuSans-61" transform="translate(88.085938 0)"/>
+       <use xlink:href="#DejaVuSans-6e" transform="translate(149.365234 0)"/>
+      </g>
+     </g>
+    </g>
+   </g>
+   <g id="matplotlib.axis_2">
+    <g id="ytick_1">
+     <g id="line2d_6">
+      <path d="M 75.89 342.11808 
+L 723.6 342.11808 
+" clip-path="url(#p83a3789304)" style="fill: none; stroke-dasharray: 0.8,1.32; stroke-dashoffset: 0; stroke: #b0b0b0; stroke-opacity: 0.45; stroke-width: 0.8"/>
+     </g>
+     <g id="line2d_7">
+      <defs>
+       <path id="mc0b9ff744f" d="M 0 0 
+L -3.5 0 
+" style="stroke: #000000; stroke-width: 0.8"/>
+      </defs>
+      <g>
+       <use xlink:href="#mc0b9ff744f" x="75.89" y="342.11808" style="stroke: #000000; stroke-width: 0.8"/>
+      </g>
+     </g>
+     <g id="text_6">
+      <!-- 0k € -->
+      <g transform="translate(47.19625 345.917299) scale(0.1 -0.1)">
+       <defs>
+        <path id="DejaVuSans-30" d="M 2034 4250 
+Q 1547 4250 1301 3770 
+Q 1056 3291 1056 2328 
+Q 1056 1369 1301 889 
+Q 1547 409 2034 409 
+Q 2525 409 2770 889 
+Q 3016 1369 3016 2328 
+Q 3016 3291 2770 3770 
+Q 2525 4250 2034 4250 
+z
+M 2034 4750 
+Q 2819 4750 3233 4129 
+Q 3647 3509 3647 2328 
+Q 3647 1150 3233 529 
+Q 2819 -91 2034 -91 
+Q 1250 -91 836 529 
+Q 422 1150 422 2328 
+Q 422 3509 836 4129 
+Q 1250 4750 2034 4750 
+z
+" transform="scale(0.015625)"/>
+        <path id="DejaVuSans-6b" d="M 581 4863 
+L 1159 4863 
+L 1159 1991 
+L 2875 3500 
+L 3609 3500 
+L 1753 1863 
+L 3688 0 
+L 2938 0 
+L 1159 1709 
+L 1159 0 
+L 581 0 
+L 581 4863 
+z
+" transform="scale(0.015625)"/>
+        <path id="DejaVuSans-20" transform="scale(0.015625)"/>
+        <path id="DejaVuSans-20ac" d="M 3647 4306 
+L 3647 3641 
+Q 3363 3969 3098 4109 
+Q 2834 4250 2516 4250 
+Q 2025 4250 1709 3937 
+Q 1394 3625 1294 3041 
+L 3097 3041 
+L 2925 2656 
+L 1244 2656 
+Q 1238 2581 1236 2509 
+Q 1234 2438 1234 2328 
+Q 1234 2228 1236 2156 
+Q 1238 2084 1244 2009 
+L 2638 2009 
+L 2463 1625 
+L 1294 1625 
+Q 1394 1041 1709 725 
+Q 2025 409 2516 409 
+Q 2834 409 3098 550 
+Q 3363 691 3647 1019 
+L 3647 359 
+Q 3369 134 3080 21 
+Q 2791 -91 2491 -91 
+Q 1750 -91 1267 362 
+Q 784 816 659 1625 
+L 0 1625 
+L 172 2009 
+L 606 2009 
+Q 606 2081 604 2154 
+Q 603 2228 603 2328 
+Q 603 2438 604 2511 
+Q 606 2584 606 2656 
+L 0 2656 
+L 172 3041 
+L 659 3041 
+Q 784 3844 1268 4297 
+Q 1753 4750 2491 4750 
+Q 2797 4750 3086 4639 
+Q 3375 4528 3647 4306 
+z
+" transform="scale(0.015625)"/>
+       </defs>
+       <use xlink:href="#DejaVuSans-30"/>
+       <use xlink:href="#DejaVuSans-6b" transform="translate(63.623047 0)"/>
+       <use xlink:href="#DejaVuSans-20" transform="translate(121.533203 0)"/>
+       <use xlink:href="#DejaVuSans-20ac" transform="translate(153.320312 0)"/>
+      </g>
+     </g>
+    </g>
+    <g id="ytick_2">
+     <g id="line2d_8">
+      <path d="M 75.89 285.497151 
+L 723.6 285.497151 
+" clip-path="url(#p83a3789304)" style="fill: none; stroke-dasharray: 0.8,1.32; stroke-dashoffset: 0; stroke: #b0b0b0; stroke-opacity: 0.45; stroke-width: 0.8"/>
+     </g>
+     <g id="line2d_9">
+      <g>
+       <use xlink:href="#mc0b9ff744f" x="75.89" y="285.497151" style="stroke: #000000; stroke-width: 0.8"/>
+      </g>
+     </g>
+     <g id="text_7">
+      <!-- 200k € -->
+      <g transform="translate(34.47125 289.29637) scale(0.1 -0.1)">
+       <defs>
+        <path id="DejaVuSans-32" d="M 1228 531 
+L 3431 531 
+L 3431 0 
+L 469 0 
+L 469 531 
+Q 828 903 1448 1529 
+Q 2069 2156 2228 2338 
+Q 2531 2678 2651 2914 
+Q 2772 3150 2772 3378 
+Q 2772 3750 2511 3984 
+Q 2250 4219 1831 4219 
+Q 1534 4219 1204 4116 
+Q 875 4013 500 3803 
+L 500 4441 
+Q 881 4594 1212 4672 
+Q 1544 4750 1819 4750 
+Q 2544 4750 2975 4387 
+Q 3406 4025 3406 3419 
+Q 3406 3131 3298 2873 
+Q 3191 2616 2906 2266 
+Q 2828 2175 2409 1742 
+Q 1991 1309 1228 531 
+z
+" transform="scale(0.015625)"/>
+       </defs>
+       <use xlink:href="#DejaVuSans-32"/>
+       <use xlink:href="#DejaVuSans-30" transform="translate(63.623047 0)"/>
+       <use xlink:href="#DejaVuSans-30" transform="translate(127.246094 0)"/>
+       <use xlink:href="#DejaVuSans-6b" transform="translate(190.869141 0)"/>
+       <use xlink:href="#DejaVuSans-20" transform="translate(248.779297 0)"/>
+       <use xlink:href="#DejaVuSans-20ac" transform="translate(280.566406 0)"/>
+      </g>
+     </g>
+    </g>
+    <g id="ytick_3">
+     <g id="line2d_10">
+      <path d="M 75.89 228.876222 
+L 723.6 228.876222 
+" clip-path="url(#p83a3789304)" style="fill: none; stroke-dasharray: 0.8,1.32; stroke-dashoffset: 0; stroke: #b0b0b0; stroke-opacity: 0.45; stroke-width: 0.8"/>
+     </g>
+     <g id="line2d_11">
+      <g>
+       <use xlink:href="#mc0b9ff744f" x="75.89" y="228.876222" style="stroke: #000000; stroke-width: 0.8"/>
+      </g>
+     </g>
+     <g id="text_8">
+      <!-- 400k € -->
+      <g transform="translate(34.47125 232.675441) scale(0.1 -0.1)">
+       <defs>
+        <path id="DejaVuSans-34" d="M 2419 4116 
+L 825 1625 
+L 2419 1625 
+L 2419 4116 
+z
+M 2253 4666 
+L 3047 4666 
+L 3047 1625 
+L 3713 1625 
+L 3713 1100 
+L 3047 1100 
+L 3047 0 
+L 2419 0 
+L 2419 1100 
+L 313 1100 
+L 313 1709 
+L 2253 4666 
+z
+" transform="scale(0.015625)"/>
+       </defs>
+       <use xlink:href="#DejaVuSans-34"/>
+       <use xlink:href="#DejaVuSans-30" transform="translate(63.623047 0)"/>
+       <use xlink:href="#DejaVuSans-30" transform="translate(127.246094 0)"/>
+       <use xlink:href="#DejaVuSans-6b" transform="translate(190.869141 0)"/>
+       <use xlink:href="#DejaVuSans-20" transform="translate(248.779297 0)"/>
+       <use xlink:href="#DejaVuSans-20ac" transform="translate(280.566406 0)"/>
+      </g>
+     </g>
+    </g>
+    <g id="ytick_4">
+     <g id="line2d_12">
+      <path d="M 75.89 172.255294 
+L 723.6 172.255294 
+" clip-path="url(#p83a3789304)" style="fill: none; stroke-dasharray: 0.8,1.32; stroke-dashoffset: 0; stroke: #b0b0b0; stroke-opacity: 0.45; stroke-width: 0.8"/>
+     </g>
+     <g id="line2d_13">
+      <g>
+       <use xlink:href="#mc0b9ff744f" x="75.89" y="172.255294" style="stroke: #000000; stroke-width: 0.8"/>
+      </g>
+     </g>
+     <g id="text_9">
+      <!-- 600k € -->
+      <g transform="translate(34.47125 176.054512) scale(0.1 -0.1)">
+       <defs>
+        <path id="DejaVuSans-36" d="M 2113 2584 
+Q 1688 2584 1439 2293 
+Q 1191 2003 1191 1497 
+Q 1191 994 1439 701 
+Q 1688 409 2113 409 
+Q 2538 409 2786 701 
+Q 3034 994 3034 1497 
+Q 3034 2003 2786 2293 
+Q 2538 2584 2113 2584 
+z
+M 3366 4563 
+L 3366 3988 
+Q 3128 4100 2886 4159 
+Q 2644 4219 2406 4219 
+Q 1781 4219 1451 3797 
+Q 1122 3375 1075 2522 
+Q 1259 2794 1537 2939 
+Q 1816 3084 2150 3084 
+Q 2853 3084 3261 2657 
+Q 3669 2231 3669 1497 
+Q 3669 778 3244 343 
+Q 2819 -91 2113 -91 
+Q 1303 -91 875 529 
+Q 447 1150 447 2328 
+Q 447 3434 972 4092 
+Q 1497 4750 2381 4750 
+Q 2619 4750 2861 4703 
+Q 3103 4656 3366 4563 
+z
+" transform="scale(0.015625)"/>
+       </defs>
+       <use xlink:href="#DejaVuSans-36"/>
+       <use xlink:href="#DejaVuSans-30" transform="translate(63.623047 0)"/>
+       <use xlink:href="#DejaVuSans-30" transform="translate(127.246094 0)"/>
+       <use xlink:href="#DejaVuSans-6b" transform="translate(190.869141 0)"/>
+       <use xlink:href="#DejaVuSans-20" transform="translate(248.779297 0)"/>
+       <use xlink:href="#DejaVuSans-20ac" transform="translate(280.566406 0)"/>
+      </g>
+     </g>
+    </g>
+    <g id="ytick_5">
+     <g id="line2d_14">
+      <path d="M 75.89 115.634365 
+L 723.6 115.634365 
+" clip-path="url(#p83a3789304)" style="fill: none; stroke-dasharray: 0.8,1.32; stroke-dashoffset: 0; stroke: #b0b0b0; stroke-opacity: 0.45; stroke-width: 0.8"/>
+     </g>
+     <g id="line2d_15">
+      <g>
+       <use xlink:href="#mc0b9ff744f" x="75.89" y="115.634365" style="stroke: #000000; stroke-width: 0.8"/>
+      </g>
+     </g>
+     <g id="text_10">
+      <!-- 800k € -->
+      <g transform="translate(34.47125 119.433584) scale(0.1 -0.1)">
+       <defs>
+        <path id="DejaVuSans-38" d="M 2034 2216 
+Q 1584 2216 1326 1975 
+Q 1069 1734 1069 1313 
+Q 1069 891 1326 650 
+Q 1584 409 2034 409 
+Q 2484 409 2743 651 
+Q 3003 894 3003 1313 
+Q 3003 1734 2745 1975 
+Q 2488 2216 2034 2216 
+z
+M 1403 2484 
+Q 997 2584 770 2862 
+Q 544 3141 544 3541 
+Q 544 4100 942 4425 
+Q 1341 4750 2034 4750 
+Q 2731 4750 3128 4425 
+Q 3525 4100 3525 3541 
+Q 3525 3141 3298 2862 
+Q 3072 2584 2669 2484 
+Q 3125 2378 3379 2068 
+Q 3634 1759 3634 1313 
+Q 3634 634 3220 271 
+Q 2806 -91 2034 -91 
+Q 1263 -91 848 271 
+Q 434 634 434 1313 
+Q 434 1759 690 2068 
+Q 947 2378 1403 2484 
+z
+M 1172 3481 
+Q 1172 3119 1398 2916 
+Q 1625 2713 2034 2713 
+Q 2441 2713 2670 2916 
+Q 2900 3119 2900 3481 
+Q 2900 3844 2670 4047 
+Q 2441 4250 2034 4250 
+Q 1625 4250 1398 4047 
+Q 1172 3844 1172 3481 
+z
+" transform="scale(0.015625)"/>
+       </defs>
+       <use xlink:href="#DejaVuSans-38"/>
+       <use xlink:href="#DejaVuSans-30" transform="translate(63.623047 0)"/>
+       <use xlink:href="#DejaVuSans-30" transform="translate(127.246094 0)"/>
+       <use xlink:href="#DejaVuSans-6b" transform="translate(190.869141 0)"/>
+       <use xlink:href="#DejaVuSans-20" transform="translate(248.779297 0)"/>
+       <use xlink:href="#DejaVuSans-20ac" transform="translate(280.566406 0)"/>
+      </g>
+     </g>
+    </g>
+    <g id="ytick_6">
+     <g id="line2d_16">
+      <path d="M 75.89 59.013436 
+L 723.6 59.013436 
+" clip-path="url(#p83a3789304)" style="fill: none; stroke-dasharray: 0.8,1.32; stroke-dashoffset: 0; stroke: #b0b0b0; stroke-opacity: 0.45; stroke-width: 0.8"/>
+     </g>
+     <g id="line2d_17">
+      <g>
+       <use xlink:href="#mc0b9ff744f" x="75.89" y="59.013436" style="stroke: #000000; stroke-width: 0.8"/>
+      </g>
+     </g>
+     <g id="text_11">
+      <!-- 1.000k € -->
+      <g transform="translate(24.930625 62.812655) scale(0.1 -0.1)">
+       <defs>
+        <path id="DejaVuSans-31" d="M 794 531 
+L 1825 531 
+L 1825 4091 
+L 703 3866 
+L 703 4441 
+L 1819 4666 
+L 2450 4666 
+L 2450 531 
+L 3481 531 
+L 3481 0 
+L 794 0 
+L 794 531 
+z
+" transform="scale(0.015625)"/>
+        <path id="DejaVuSans-2e" d="M 684 794 
+L 1344 794 
+L 1344 0 
+L 684 0 
+L 684 794 
+z
+" transform="scale(0.015625)"/>
+       </defs>
+       <use xlink:href="#DejaVuSans-31"/>
+       <use xlink:href="#DejaVuSans-2e" transform="translate(63.623047 0)"/>
+       <use xlink:href="#DejaVuSans-30" transform="translate(95.410156 0)"/>
+       <use xlink:href="#DejaVuSans-30" transform="translate(159.033203 0)"/>
+       <use xlink:href="#DejaVuSans-30" transform="translate(222.65625 0)"/>
+       <use xlink:href="#DejaVuSans-6b" transform="translate(286.279297 0)"/>
+       <use xlink:href="#DejaVuSans-20" transform="translate(344.189453 0)"/>
+       <use xlink:href="#DejaVuSans-20ac" transform="translate(375.976562 0)"/>
+      </g>
+     </g>
+    </g>
+    <g id="text_12">
+     <!-- Erwartete Tageskosten -->
+     <g transform="translate(18.850938 252.805009) rotate(-90) scale(0.1 -0.1)">
+      <defs>
+       <path id="DejaVuSans-54" d="M -19 4666 
+L 3928 4666 
+L 3928 4134 
+L 2272 4134 
+L 2272 0 
+L 1638 0 
+L 1638 4134 
+L -19 4134 
+L -19 4666 
+z
+" transform="scale(0.015625)"/>
+      </defs>
+      <use xlink:href="#DejaVuSans-45"/>
+      <use xlink:href="#DejaVuSans-72" transform="translate(63.183594 0)"/>
+      <use xlink:href="#DejaVuSans-77" transform="translate(104.296875 0)"/>
+      <use xlink:href="#DejaVuSans-61" transform="translate(186.083984 0)"/>
+      <use xlink:href="#DejaVuSans-72" transform="translate(247.363281 0)"/>
+      <use xlink:href="#DejaVuSans-74" transform="translate(288.476562 0)"/>
+      <use xlink:href="#DejaVuSans-65" transform="translate(327.685547 0)"/>
+      <use xlink:href="#DejaVuSans-74" transform="translate(389.208984 0)"/>
+      <use xlink:href="#DejaVuSans-65" transform="translate(428.417969 0)"/>
+      <use xlink:href="#DejaVuSans-20" transform="translate(489.941406 0)"/>
+      <use xlink:href="#DejaVuSans-54" transform="translate(521.728516 0)"/>
+      <use xlink:href="#DejaVuSans-61" transform="translate(566.3125 0)"/>
+      <use xlink:href="#DejaVuSans-67" transform="translate(627.591797 0)"/>
+      <use xlink:href="#DejaVuSans-65" transform="translate(691.068359 0)"/>
+      <use xlink:href="#DejaVuSans-73" transform="translate(752.591797 0)"/>
+      <use xlink:href="#DejaVuSans-6b" transform="translate(804.691406 0)"/>
+      <use xlink:href="#DejaVuSans-6f" transform="translate(858.976562 0)"/>
+      <use xlink:href="#DejaVuSans-73" transform="translate(920.158203 0)"/>
+      <use xlink:href="#DejaVuSans-74" transform="translate(972.257812 0)"/>
+      <use xlink:href="#DejaVuSans-65" transform="translate(1011.466797 0)"/>
+      <use xlink:href="#DejaVuSans-6e" transform="translate(1072.990234 0)"/>
+     </g>
+    </g>
+   </g>
+   <g id="line2d_18">
+    <path d="M 232.783154 246.250134 
+L 360.234945 246.250134 
+" clip-path="url(#p83a3789304)" style="fill: none; stroke-dasharray: 0.9,1.485; stroke-dashoffset: 0; stroke: #64748b; stroke-width: 0.9"/>
+   </g>
+   <g id="line2d_19">
+    <path d="M 360.234945 246.250134 
+L 487.686736 246.250134 
+" clip-path="url(#p83a3789304)" style="fill: none; stroke-dasharray: 0.9,1.485; stroke-dashoffset: 0; stroke: #64748b; stroke-width: 0.9"/>
+   </g>
+   <g id="line2d_20">
+    <path d="M 487.686736 94.438351 
+L 615.138526 94.438351 
+" clip-path="url(#p83a3789304)" style="fill: none; stroke-dasharray: 0.9,1.485; stroke-dashoffset: 0; stroke: #64748b; stroke-width: 0.9"/>
+   </g>
+   <g id="patch_3">
+    <path d="M 75.89 342.11808 
+L 75.89 49.856 
+" style="fill: none; stroke: #000000; stroke-width: 0.8; stroke-linejoin: miter; stroke-linecap: square"/>
+   </g>
+   <g id="patch_4">
+    <path d="M 75.89 342.11808 
+L 723.6 342.11808 
+" style="fill: none; stroke: #000000; stroke-width: 0.8; stroke-linejoin: miter; stroke-linecap: square"/>
+   </g>
+   <g id="patch_5">
+    <path d="M 105.331364 342.11808 
+L 184.351474 342.11808 
+L 184.351474 242.64755 
+L 105.331364 242.64755 
+z
+" clip-path="url(#p83a3789304)" style="fill: #4338ca"/>
+   </g>
+   <g id="text_13">
+    <!-- 351.356 € -->
+    <g style="fill: #4338ca" transform="translate(114.050012 235.26401) scale(0.11 -0.11)">
+     <defs>
+      <path id="DejaVuSans-Bold-33" d="M 2981 2516 
+Q 3453 2394 3698 2092 
+Q 3944 1791 3944 1325 
+Q 3944 631 3412 270 
+Q 2881 -91 1863 -91 
+Q 1503 -91 1142 -33 
+Q 781 25 428 141 
+L 428 1069 
+Q 766 900 1098 814 
+Q 1431 728 1753 728 
+Q 2231 728 2486 893 
+Q 2741 1059 2741 1369 
+Q 2741 1688 2480 1852 
+Q 2219 2016 1709 2016 
+L 1228 2016 
+L 1228 2791 
+L 1734 2791 
+Q 2188 2791 2409 2933 
+Q 2631 3075 2631 3366 
+Q 2631 3634 2415 3781 
+Q 2200 3928 1806 3928 
+Q 1516 3928 1219 3862 
+Q 922 3797 628 3669 
+L 628 4550 
+Q 984 4650 1334 4700 
+Q 1684 4750 2022 4750 
+Q 2931 4750 3382 4451 
+Q 3834 4153 3834 3553 
+Q 3834 3144 3618 2883 
+Q 3403 2622 2981 2516 
+z
+" transform="scale(0.015625)"/>
+      <path id="DejaVuSans-Bold-35" d="M 678 4666 
+L 3669 4666 
+L 3669 3781 
+L 1638 3781 
+L 1638 3059 
+Q 1775 3097 1914 3117 
+Q 2053 3138 2203 3138 
+Q 3056 3138 3531 2711 
+Q 4006 2284 4006 1522 
+Q 4006 766 3489 337 
+Q 2972 -91 2053 -91 
+Q 1656 -91 1267 -14 
+Q 878 63 494 219 
+L 494 1166 
+Q 875 947 1217 837 
+Q 1559 728 1863 728 
+Q 2300 728 2551 942 
+Q 2803 1156 2803 1522 
+Q 2803 1891 2551 2103 
+Q 2300 2316 1863 2316 
+Q 1603 2316 1309 2248 
+Q 1016 2181 678 2041 
+L 678 4666 
+z
+" transform="scale(0.015625)"/>
+      <path id="DejaVuSans-Bold-31" d="M 750 831 
+L 1813 831 
+L 1813 3847 
+L 722 3622 
+L 722 4441 
+L 1806 4666 
+L 2950 4666 
+L 2950 831 
+L 4013 831 
+L 4013 0 
+L 750 0 
+L 750 831 
+z
+" transform="scale(0.015625)"/>
+      <path id="DejaVuSans-Bold-2e" d="M 653 1209 
+L 1778 1209 
+L 1778 0 
+L 653 0 
+L 653 1209 
+z
+" transform="scale(0.015625)"/>
+      <path id="DejaVuSans-Bold-36" d="M 2316 2303 
+Q 2000 2303 1842 2098 
+Q 1684 1894 1684 1484 
+Q 1684 1075 1842 870 
+Q 2000 666 2316 666 
+Q 2634 666 2792 870 
+Q 2950 1075 2950 1484 
+Q 2950 1894 2792 2098 
+Q 2634 2303 2316 2303 
+z
+M 3803 4544 
+L 3803 3681 
+Q 3506 3822 3243 3889 
+Q 2981 3956 2731 3956 
+Q 2194 3956 1894 3657 
+Q 1594 3359 1544 2772 
+Q 1750 2925 1990 3001 
+Q 2231 3078 2516 3078 
+Q 3231 3078 3670 2659 
+Q 4109 2241 4109 1563 
+Q 4109 813 3618 361 
+Q 3128 -91 2303 -91 
+Q 1394 -91 895 523 
+Q 397 1138 397 2266 
+Q 397 3422 980 4083 
+Q 1563 4744 2578 4744 
+Q 2900 4744 3203 4694 
+Q 3506 4644 3803 4544 
+z
+" transform="scale(0.015625)"/>
+      <path id="DejaVuSans-Bold-20" transform="scale(0.015625)"/>
+      <path id="DejaVuSans-Bold-20ac" d="M 4025 256 
+Q 3728 84 3404 -3 
+Q 3081 -91 2731 -91 
+Q 1913 -91 1352 317 
+Q 791 725 556 1491 
+L -122 1491 
+L 153 2100 
+L 459 2100 
+Q 456 2144 454 2192 
+Q 453 2241 453 2328 
+Q 453 2419 454 2469 
+Q 456 2519 459 2566 
+L -122 2566 
+L 153 3175 
+L 556 3175 
+Q 797 3944 1355 4347 
+Q 1913 4750 2731 4750 
+Q 3081 4750 3404 4662 
+Q 3728 4575 4025 4403 
+L 4025 3438 
+Q 3772 3681 3484 3804 
+Q 3197 3928 2888 3928 
+Q 2491 3928 2211 3736 
+Q 1931 3544 1791 3175 
+L 3475 3175 
+L 3206 2566 
+L 1666 2566 
+Q 1659 2516 1657 2459 
+Q 1656 2403 1656 2291 
+Q 1656 2250 1657 2201 
+Q 1659 2153 1663 2100 
+L 3003 2100 
+L 2725 1491 
+L 1791 1491 
+Q 1947 1109 2220 918 
+Q 2494 728 2888 728 
+Q 3197 728 3480 851 
+Q 3763 975 4025 1222 
+L 4025 256 
+z
+" transform="scale(0.015625)"/>
+     </defs>
+     <use xlink:href="#DejaVuSans-Bold-33"/>
+     <use xlink:href="#DejaVuSans-Bold-35" transform="translate(69.580078 0)"/>
+     <use xlink:href="#DejaVuSans-Bold-31" transform="translate(139.160156 0)"/>
+     <use xlink:href="#DejaVuSans-Bold-2e" transform="translate(208.740234 0)"/>
+     <use xlink:href="#DejaVuSans-Bold-33" transform="translate(246.728516 0)"/>
+     <use xlink:href="#DejaVuSans-Bold-35" transform="translate(316.308594 0)"/>
+     <use xlink:href="#DejaVuSans-Bold-36" transform="translate(385.888672 0)"/>
+     <use xlink:href="#DejaVuSans-Bold-20" transform="translate(455.46875 0)"/>
+     <use xlink:href="#DejaVuSans-Bold-20ac" transform="translate(490.283203 0)"/>
+    </g>
+   </g>
+   <g id="patch_6">
+    <path d="M 232.783154 246.250134 
+L 311.803264 246.250134 
+L 311.803264 242.64755 
+L 232.783154 242.64755 
+z
+" clip-path="url(#p83a3789304)" style="fill: #059669"/>
+   </g>
+   <g id="text_14">
+    <!-- -12.725 € -->
+    <g style="fill: #059669" transform="translate(244.375514 235.367995) scale(0.105 -0.105)">
+     <defs>
+      <path id="DejaVuSans-Bold-2d" d="M 347 2297 
+L 2309 2297 
+L 2309 1388 
+L 347 1388 
+L 347 2297 
+z
+" transform="scale(0.015625)"/>
+      <path id="DejaVuSans-Bold-32" d="M 1844 884 
+L 3897 884 
+L 3897 0 
+L 506 0 
+L 506 884 
+L 2209 2388 
+Q 2438 2594 2547 2791 
+Q 2656 2988 2656 3200 
+Q 2656 3528 2436 3728 
+Q 2216 3928 1850 3928 
+Q 1569 3928 1234 3808 
+Q 900 3688 519 3450 
+L 519 4475 
+Q 925 4609 1322 4679 
+Q 1719 4750 2100 4750 
+Q 2938 4750 3402 4381 
+Q 3866 4013 3866 3353 
+Q 3866 2972 3669 2642 
+Q 3472 2313 2841 1759 
+L 1844 884 
+z
+" transform="scale(0.015625)"/>
+      <path id="DejaVuSans-Bold-37" d="M 428 4666 
+L 3944 4666 
+L 3944 3988 
+L 2125 0 
+L 953 0 
+L 2675 3781 
+L 428 3781 
+L 428 4666 
+z
+" transform="scale(0.015625)"/>
+     </defs>
+     <use xlink:href="#DejaVuSans-Bold-2d"/>
+     <use xlink:href="#DejaVuSans-Bold-31" transform="translate(41.503906 0)"/>
+     <use xlink:href="#DejaVuSans-Bold-32" transform="translate(111.083984 0)"/>
+     <use xlink:href="#DejaVuSans-Bold-2e" transform="translate(180.664062 0)"/>
+     <use xlink:href="#DejaVuSans-Bold-37" transform="translate(218.652344 0)"/>
+     <use xlink:href="#DejaVuSans-Bold-32" transform="translate(288.232422 0)"/>
+     <use xlink:href="#DejaVuSans-Bold-35" transform="translate(357.8125 0)"/>
+     <use xlink:href="#DejaVuSans-Bold-20" transform="translate(427.392578 0)"/>
+     <use xlink:href="#DejaVuSans-Bold-20ac" transform="translate(462.207031 0)"/>
+    </g>
+   </g>
+   <g id="patch_7">
+    <path d="M 360.234945 246.250134 
+L 439.255055 246.250134 
+L 439.255055 246.250134 
+L 360.234945 246.250134 
+z
+" clip-path="url(#p83a3789304)" style="fill: #059669"/>
+   </g>
+   <g id="text_15">
+    <!-- +0 € -->
+    <g style="fill: #059669" transform="translate(386.212305 238.970578) scale(0.105 -0.105)">
+     <defs>
+      <path id="DejaVuSans-Bold-2b" d="M 3053 4013 
+L 3053 2375 
+L 4684 2375 
+L 4684 1638 
+L 3053 1638 
+L 3053 0 
+L 2309 0 
+L 2309 1638 
+L 678 1638 
+L 678 2375 
+L 2309 2375 
+L 2309 4013 
+L 3053 4013 
+z
+" transform="scale(0.015625)"/>
+      <path id="DejaVuSans-Bold-30" d="M 2944 2338 
+Q 2944 3213 2780 3570 
+Q 2616 3928 2228 3928 
+Q 1841 3928 1675 3570 
+Q 1509 3213 1509 2338 
+Q 1509 1453 1675 1090 
+Q 1841 728 2228 728 
+Q 2613 728 2778 1090 
+Q 2944 1453 2944 2338 
+z
+M 4147 2328 
+Q 4147 1169 3647 539 
+Q 3147 -91 2228 -91 
+Q 1306 -91 806 539 
+Q 306 1169 306 2328 
+Q 306 3491 806 4120 
+Q 1306 4750 2228 4750 
+Q 3147 4750 3647 4120 
+Q 4147 3491 4147 2328 
+z
+" transform="scale(0.015625)"/>
+     </defs>
+     <use xlink:href="#DejaVuSans-Bold-2b"/>
+     <use xlink:href="#DejaVuSans-Bold-30" transform="translate(83.789062 0)"/>
+     <use xlink:href="#DejaVuSans-Bold-20" transform="translate(153.369141 0)"/>
+     <use xlink:href="#DejaVuSans-Bold-20ac" transform="translate(188.183594 0)"/>
+    </g>
+   </g>
+   <g id="patch_8">
+    <path d="M 487.686736 246.250134 
+L 566.706846 246.250134 
+L 566.706846 94.438351 
+L 487.686736 94.438351 
+z
+" clip-path="url(#p83a3789304)" style="fill: #b45309"/>
+   </g>
+   <g id="text_16">
+    <!-- +536.239 € -->
+    <g style="fill: #b45309" transform="translate(493.405658 87.158796) scale(0.105 -0.105)">
+     <defs>
+      <path id="DejaVuSans-Bold-39" d="M 641 103 
+L 641 966 
+Q 928 831 1190 764 
+Q 1453 697 1709 697 
+Q 2247 697 2547 995 
+Q 2847 1294 2900 1881 
+Q 2688 1725 2447 1647 
+Q 2206 1569 1925 1569 
+Q 1209 1569 770 1986 
+Q 331 2403 331 3084 
+Q 331 3838 820 4291 
+Q 1309 4744 2131 4744 
+Q 3044 4744 3544 4128 
+Q 4044 3513 4044 2388 
+Q 4044 1231 3459 570 
+Q 2875 -91 1856 -91 
+Q 1528 -91 1228 -42 
+Q 928 6 641 103 
+z
+M 2125 2350 
+Q 2441 2350 2600 2554 
+Q 2759 2759 2759 3169 
+Q 2759 3575 2600 3781 
+Q 2441 3988 2125 3988 
+Q 1809 3988 1650 3781 
+Q 1491 3575 1491 3169 
+Q 1491 2759 1650 2554 
+Q 1809 2350 2125 2350 
+z
+" transform="scale(0.015625)"/>
+     </defs>
+     <use xlink:href="#DejaVuSans-Bold-2b"/>
+     <use xlink:href="#DejaVuSans-Bold-35" transform="translate(83.789062 0)"/>
+     <use xlink:href="#DejaVuSans-Bold-33" transform="translate(153.369141 0)"/>
+     <use xlink:href="#DejaVuSans-Bold-36" transform="translate(222.949219 0)"/>
+     <use xlink:href="#DejaVuSans-Bold-2e" transform="translate(292.529297 0)"/>
+     <use xlink:href="#DejaVuSans-Bold-32" transform="translate(330.517578 0)"/>
+     <use xlink:href="#DejaVuSans-Bold-33" transform="translate(400.097656 0)"/>
+     <use xlink:href="#DejaVuSans-Bold-39" transform="translate(469.677734 0)"/>
+     <use xlink:href="#DejaVuSans-Bold-20" transform="translate(539.257812 0)"/>
+     <use xlink:href="#DejaVuSans-Bold-20ac" transform="translate(574.072266 0)"/>
+    </g>
+   </g>
+   <g id="patch_9">
+    <path d="M 615.138526 342.11808 
+L 694.158636 342.11808 
+L 694.158636 94.438351 
+L 615.138526 94.438351 
+z
+" clip-path="url(#p83a3789304)" style="fill: #4338ca"/>
+   </g>
+   <g id="text_17">
+    <!-- 874.870 € -->
+    <g style="fill: #4338ca" transform="translate(623.857175 87.054811) scale(0.11 -0.11)">
+     <defs>
+      <path id="DejaVuSans-Bold-38" d="M 2228 2088 
+Q 1891 2088 1709 1903 
+Q 1528 1719 1528 1375 
+Q 1528 1031 1709 848 
+Q 1891 666 2228 666 
+Q 2563 666 2741 848 
+Q 2919 1031 2919 1375 
+Q 2919 1722 2741 1905 
+Q 2563 2088 2228 2088 
+z
+M 1350 2484 
+Q 925 2613 709 2878 
+Q 494 3144 494 3541 
+Q 494 4131 934 4440 
+Q 1375 4750 2228 4750 
+Q 3075 4750 3515 4442 
+Q 3956 4134 3956 3541 
+Q 3956 3144 3739 2878 
+Q 3522 2613 3097 2484 
+Q 3572 2353 3814 2058 
+Q 4056 1763 4056 1313 
+Q 4056 619 3595 264 
+Q 3134 -91 2228 -91 
+Q 1319 -91 855 264 
+Q 391 619 391 1313 
+Q 391 1763 633 2058 
+Q 875 2353 1350 2484 
+z
+M 1631 3419 
+Q 1631 3141 1786 2991 
+Q 1941 2841 2228 2841 
+Q 2509 2841 2662 2991 
+Q 2816 3141 2816 3419 
+Q 2816 3697 2662 3845 
+Q 2509 3994 2228 3994 
+Q 1941 3994 1786 3844 
+Q 1631 3694 1631 3419 
+z
+" transform="scale(0.015625)"/>
+      <path id="DejaVuSans-Bold-34" d="M 2356 3675 
+L 1038 1722 
+L 2356 1722 
+L 2356 3675 
+z
+M 2156 4666 
+L 3494 4666 
+L 3494 1722 
+L 4159 1722 
+L 4159 850 
+L 3494 850 
+L 3494 0 
+L 2356 0 
+L 2356 850 
+L 288 850 
+L 288 1881 
+L 2156 4666 
+z
+" transform="scale(0.015625)"/>
+     </defs>
+     <use xlink:href="#DejaVuSans-Bold-38"/>
+     <use xlink:href="#DejaVuSans-Bold-37" transform="translate(69.580078 0)"/>
+     <use xlink:href="#DejaVuSans-Bold-34" transform="translate(139.160156 0)"/>
+     <use xlink:href="#DejaVuSans-Bold-2e" transform="translate(208.740234 0)"/>
+     <use xlink:href="#DejaVuSans-Bold-38" transform="translate(246.728516 0)"/>
+     <use xlink:href="#DejaVuSans-Bold-37" transform="translate(316.308594 0)"/>
+     <use xlink:href="#DejaVuSans-Bold-30" transform="translate(385.888672 0)"/>
+     <use xlink:href="#DejaVuSans-Bold-20" transform="translate(455.46875 0)"/>
+     <use xlink:href="#DejaVuSans-Bold-20ac" transform="translate(490.283203 0)"/>
+    </g>
+   </g>
+   <g id="text_18">
+    <!-- Lastabwurf in 28 von 40 Szenarien statt in 0; Anfahrkosten in beiden Plänen gleich. -->
+    <g style="fill: #64748b" transform="translate(190.86375 387.418702) scale(0.1 -0.1)">
+     <defs>
+      <path id="DejaVuSans-76" d="M 191 3500 
+L 800 3500 
+L 1894 563 
+L 2988 3500 
+L 3597 3500 
+L 2284 0 
+L 1503 0 
+L 191 3500 
+z
+" transform="scale(0.015625)"/>
+      <path id="DejaVuSans-53" d="M 3425 4513 
+L 3425 3897 
+Q 3066 4069 2747 4153 
+Q 2428 4238 2131 4238 
+Q 1616 4238 1336 4038 
+Q 1056 3838 1056 3469 
+Q 1056 3159 1242 3001 
+Q 1428 2844 1947 2747 
+L 2328 2669 
+Q 3034 2534 3370 2195 
+Q 3706 1856 3706 1288 
+Q 3706 609 3251 259 
+Q 2797 -91 1919 -91 
+Q 1588 -91 1214 -16 
+Q 841 59 441 206 
+L 441 856 
+Q 825 641 1194 531 
+Q 1563 422 1919 422 
+Q 2459 422 2753 634 
+Q 3047 847 3047 1241 
+Q 3047 1584 2836 1778 
+Q 2625 1972 2144 2069 
+L 1759 2144 
+Q 1053 2284 737 2584 
+Q 422 2884 422 3419 
+Q 422 4038 858 4394 
+Q 1294 4750 2059 4750 
+Q 2388 4750 2728 4690 
+Q 3069 4631 3425 4513 
+z
+" transform="scale(0.015625)"/>
+      <path id="DejaVuSans-7a" d="M 353 3500 
+L 3084 3500 
+L 3084 2975 
+L 922 459 
+L 3084 459 
+L 3084 0 
+L 275 0 
+L 275 525 
+L 2438 3041 
+L 353 3041 
+L 353 3500 
+z
+" transform="scale(0.015625)"/>
+      <path id="DejaVuSans-3b" d="M 750 3309 
+L 1409 3309 
+L 1409 2516 
+L 750 2516 
+L 750 3309 
+z
+M 750 794 
+L 1409 794 
+L 1409 256 
+L 897 -744 
+L 494 -744 
+L 750 256 
+L 750 794 
+z
+" transform="scale(0.015625)"/>
+      <path id="DejaVuSans-64" d="M 2906 2969 
+L 2906 4863 
+L 3481 4863 
+L 3481 0 
+L 2906 0 
+L 2906 525 
+Q 2725 213 2448 61 
+Q 2172 -91 1784 -91 
+Q 1150 -91 751 415 
+Q 353 922 353 1747 
+Q 353 2572 751 3078 
+Q 1150 3584 1784 3584 
+Q 2172 3584 2448 3432 
+Q 2725 3281 2906 2969 
+z
+M 947 1747 
+Q 947 1113 1208 752 
+Q 1469 391 1925 391 
+Q 2381 391 2643 752 
+Q 2906 1113 2906 1747 
+Q 2906 2381 2643 2742 
+Q 2381 3103 1925 3103 
+Q 1469 3103 1208 2742 
+Q 947 2381 947 1747 
+z
+" transform="scale(0.015625)"/>
+      <path id="DejaVuSans-e4" d="M 2194 1759 
+Q 1497 1759 1228 1600 
+Q 959 1441 959 1056 
+Q 959 750 1161 570 
+Q 1363 391 1709 391 
+Q 2188 391 2477 730 
+Q 2766 1069 2766 1631 
+L 2766 1759 
+L 2194 1759 
+z
+M 3341 1997 
+L 3341 0 
+L 2766 0 
+L 2766 531 
+Q 2569 213 2275 61 
+Q 1981 -91 1556 -91 
+Q 1019 -91 701 211 
+Q 384 513 384 1019 
+Q 384 1609 779 1909 
+Q 1175 2209 1959 2209 
+L 2766 2209 
+L 2766 2266 
+Q 2766 2663 2505 2880 
+Q 2244 3097 1772 3097 
+Q 1472 3097 1187 3025 
+Q 903 2953 641 2809 
+L 641 3341 
+Q 956 3463 1253 3523 
+Q 1550 3584 1831 3584 
+Q 2591 3584 2966 3190 
+Q 3341 2797 3341 1997 
+z
+M 2150 4850 
+L 2784 4850 
+L 2784 4219 
+L 2150 4219 
+L 2150 4850 
+z
+M 928 4850 
+L 1563 4850 
+L 1563 4219 
+L 928 4219 
+L 928 4850 
+z
+" transform="scale(0.015625)"/>
+      <path id="DejaVuSans-63" d="M 3122 3366 
+L 3122 2828 
+Q 2878 2963 2633 3030 
+Q 2388 3097 2138 3097 
+Q 1578 3097 1268 2742 
+Q 959 2388 959 1747 
+Q 959 1106 1268 751 
+Q 1578 397 2138 397 
+Q 2388 397 2633 464 
+Q 2878 531 3122 666 
+L 3122 134 
+Q 2881 22 2623 -34 
+Q 2366 -91 2075 -91 
+Q 1284 -91 818 406 
+Q 353 903 353 1747 
+Q 353 2603 823 3093 
+Q 1294 3584 2113 3584 
+Q 2378 3584 2631 3529 
+Q 2884 3475 3122 3366 
+z
+" transform="scale(0.015625)"/>
+     </defs>
+     <use xlink:href="#DejaVuSans-4c"/>
+     <use xlink:href="#DejaVuSans-61" transform="translate(55.712891 0)"/>
+     <use xlink:href="#DejaVuSans-73" transform="translate(116.992188 0)"/>
+     <use xlink:href="#DejaVuSans-74" transform="translate(169.091797 0)"/>
+     <use xlink:href="#DejaVuSans-61" transform="translate(208.300781 0)"/>
+     <use xlink:href="#DejaVuSans-62" transform="translate(269.580078 0)"/>
+     <use xlink:href="#DejaVuSans-77" transform="translate(333.056641 0)"/>
+     <use xlink:href="#DejaVuSans-75" transform="translate(414.84375 0)"/>
+     <use xlink:href="#DejaVuSans-72" transform="translate(478.222656 0)"/>
+     <use xlink:href="#DejaVuSans-66" transform="translate(519.335938 0)"/>
+     <use xlink:href="#DejaVuSans-20" transform="translate(554.541016 0)"/>
+     <use xlink:href="#DejaVuSans-69" transform="translate(586.328125 0)"/>
+     <use xlink:href="#DejaVuSans-6e" transform="translate(614.111328 0)"/>
+     <use xlink:href="#DejaVuSans-20" transform="translate(677.490234 0)"/>
+     <use xlink:href="#DejaVuSans-32" transform="translate(709.277344 0)"/>
+     <use xlink:href="#DejaVuSans-38" transform="translate(772.900391 0)"/>
+     <use xlink:href="#DejaVuSans-20" transform="translate(836.523438 0)"/>
+     <use xlink:href="#DejaVuSans-76" transform="translate(868.310547 0)"/>
+     <use xlink:href="#DejaVuSans-6f" transform="translate(927.490234 0)"/>
+     <use xlink:href="#DejaVuSans-6e" transform="translate(988.671875 0)"/>
+     <use xlink:href="#DejaVuSans-20" transform="translate(1052.050781 0)"/>
+     <use xlink:href="#DejaVuSans-34" transform="translate(1083.837891 0)"/>
+     <use xlink:href="#DejaVuSans-30" transform="translate(1147.460938 0)"/>
+     <use xlink:href="#DejaVuSans-20" transform="translate(1211.083984 0)"/>
+     <use xlink:href="#DejaVuSans-53" transform="translate(1242.871094 0)"/>
+     <use xlink:href="#DejaVuSans-7a" transform="translate(1306.347656 0)"/>
+     <use xlink:href="#DejaVuSans-65" transform="translate(1358.837891 0)"/>
+     <use xlink:href="#DejaVuSans-6e" transform="translate(1420.361328 0)"/>
+     <use xlink:href="#DejaVuSans-61" transform="translate(1483.740234 0)"/>
+     <use xlink:href="#DejaVuSans-72" transform="translate(1545.019531 0)"/>
+     <use xlink:href="#DejaVuSans-69" transform="translate(1586.132812 0)"/>
+     <use xlink:href="#DejaVuSans-65" transform="translate(1613.916016 0)"/>
+     <use xlink:href="#DejaVuSans-6e" transform="translate(1675.439453 0)"/>
+     <use xlink:href="#DejaVuSans-20" transform="translate(1738.818359 0)"/>
+     <use xlink:href="#DejaVuSans-73" transform="translate(1770.605469 0)"/>
+     <use xlink:href="#DejaVuSans-74" transform="translate(1822.705078 0)"/>
+     <use xlink:href="#DejaVuSans-61" transform="translate(1861.914062 0)"/>
+     <use xlink:href="#DejaVuSans-74" transform="translate(1923.193359 0)"/>
+     <use xlink:href="#DejaVuSans-74" transform="translate(1962.402344 0)"/>
+     <use xlink:href="#DejaVuSans-20" transform="translate(2001.611328 0)"/>
+     <use xlink:href="#DejaVuSans-69" transform="translate(2033.398438 0)"/>
+     <use xlink:href="#DejaVuSans-6e" transform="translate(2061.181641 0)"/>
+     <use xlink:href="#DejaVuSans-20" transform="translate(2124.560547 0)"/>
+     <use xlink:href="#DejaVuSans-30" transform="translate(2156.347656 0)"/>
+     <use xlink:href="#DejaVuSans-3b" transform="translate(2219.970703 0)"/>
+     <use xlink:href="#DejaVuSans-20" transform="translate(2253.662109 0)"/>
+     <use xlink:href="#DejaVuSans-41" transform="translate(2285.449219 0)"/>
+     <use xlink:href="#DejaVuSans-6e" transform="translate(2353.857422 0)"/>
+     <use xlink:href="#DejaVuSans-66" transform="translate(2417.236328 0)"/>
+     <use xlink:href="#DejaVuSans-61" transform="translate(2452.441406 0)"/>
+     <use xlink:href="#DejaVuSans-68" transform="translate(2513.720703 0)"/>
+     <use xlink:href="#DejaVuSans-72" transform="translate(2577.099609 0)"/>
+     <use xlink:href="#DejaVuSans-6b" transform="translate(2618.212891 0)"/>
+     <use xlink:href="#DejaVuSans-6f" transform="translate(2672.498047 0)"/>
+     <use xlink:href="#DejaVuSans-73" transform="translate(2733.679688 0)"/>
+     <use xlink:href="#DejaVuSans-74" transform="translate(2785.779297 0)"/>
+     <use xlink:href="#DejaVuSans-65" transform="translate(2824.988281 0)"/>
+     <use xlink:href="#DejaVuSans-6e" transform="translate(2886.511719 0)"/>
+     <use xlink:href="#DejaVuSans-20" transform="translate(2949.890625 0)"/>
+     <use xlink:href="#DejaVuSans-69" transform="translate(2981.677734 0)"/>
+     <use xlink:href="#DejaVuSans-6e" transform="translate(3009.460938 0)"/>
+     <use xlink:href="#DejaVuSans-20" transform="translate(3072.839844 0)"/>
+     <use xlink:href="#DejaVuSans-62" transform="translate(3104.626953 0)"/>
+     <use xlink:href="#DejaVuSans-65" transform="translate(3168.103516 0)"/>
+     <use xlink:href="#DejaVuSans-69" transform="translate(3229.626953 0)"/>
+     <use xlink:href="#DejaVuSans-64" transform="translate(3257.410156 0)"/>
+     <use xlink:href="#DejaVuSans-65" transform="translate(3320.886719 0)"/>
+     <use xlink:href="#DejaVuSans-6e" transform="translate(3382.410156 0)"/>
+     <use xlink:href="#DejaVuSans-20" transform="translate(3445.789062 0)"/>
+     <use xlink:href="#DejaVuSans-50" transform="translate(3477.576172 0)"/>
+     <use xlink:href="#DejaVuSans-6c" transform="translate(3537.878906 0)"/>
+     <use xlink:href="#DejaVuSans-e4" transform="translate(3565.662109 0)"/>
+     <use xlink:href="#DejaVuSans-6e" transform="translate(3626.941406 0)"/>
+     <use xlink:href="#DejaVuSans-65" transform="translate(3690.320312 0)"/>
+     <use xlink:href="#DejaVuSans-6e" transform="translate(3751.84375 0)"/>
+     <use xlink:href="#DejaVuSans-20" transform="translate(3815.222656 0)"/>
+     <use xlink:href="#DejaVuSans-67" transform="translate(3847.009766 0)"/>
+     <use xlink:href="#DejaVuSans-6c" transform="translate(3910.486328 0)"/>
+     <use xlink:href="#DejaVuSans-65" transform="translate(3938.269531 0)"/>
+     <use xlink:href="#DejaVuSans-69" transform="translate(3999.792969 0)"/>
+     <use xlink:href="#DejaVuSans-63" transform="translate(4027.576172 0)"/>
+     <use xlink:href="#DejaVuSans-68" transform="translate(4082.556641 0)"/>
+     <use xlink:href="#DejaVuSans-2e" transform="translate(4145.935547 0)"/>
+    </g>
+   </g>
+   <g id="text_19">
+    <!-- Was der Erwartungswert-Plan spart — und was er dafür bezahlt -->
+    <g transform="translate(201.040898 21.858734) scale(0.125 -0.125)">
+     <defs>
+      <path id="DejaVuSans-57" d="M 213 4666 
+L 850 4666 
+L 1831 722 
+L 2809 4666 
+L 3519 4666 
+L 4500 722 
+L 5478 4666 
+L 6119 4666 
+L 4947 0 
+L 4153 0 
+L 3169 4050 
+L 2175 0 
+L 1381 0 
+L 213 4666 
+z
+" transform="scale(0.015625)"/>
+      <path id="DejaVuSans-70" d="M 1159 525 
+L 1159 -1331 
+L 581 -1331 
+L 581 3500 
+L 1159 3500 
+L 1159 2969 
+Q 1341 3281 1617 3432 
+Q 1894 3584 2278 3584 
+Q 2916 3584 3314 3078 
+Q 3713 2572 3713 1747 
+Q 3713 922 3314 415 
+Q 2916 -91 2278 -91 
+Q 1894 -91 1617 61 
+Q 1341 213 1159 525 
+z
+M 3116 1747 
+Q 3116 2381 2855 2742 
+Q 2594 3103 2138 3103 
+Q 1681 3103 1420 2742 
+Q 1159 2381 1159 1747 
+Q 1159 1113 1420 752 
+Q 1681 391 2138 391 
+Q 2594 391 2855 752 
+Q 3116 1113 3116 1747 
+z
+" transform="scale(0.015625)"/>
+      <path id="DejaVuSans-2014" d="M 313 1978 
+L 6088 1978 
+L 6088 1528 
+L 313 1528 
+L 313 1978 
+z
+" transform="scale(0.015625)"/>
+      <path id="DejaVuSans-fc" d="M 544 1381 
+L 544 3500 
+L 1119 3500 
+L 1119 1403 
+Q 1119 906 1312 657 
+Q 1506 409 1894 409 
+Q 2359 409 2629 706 
+Q 2900 1003 2900 1516 
+L 2900 3500 
+L 3475 3500 
+L 3475 0 
+L 2900 0 
+L 2900 538 
+Q 2691 219 2414 64 
+Q 2138 -91 1772 -91 
+Q 1169 -91 856 284 
+Q 544 659 544 1381 
+z
+M 1991 3584 
+L 1991 3584 
+z
+M 2278 4850 
+L 2913 4850 
+L 2913 4219 
+L 2278 4219 
+L 2278 4850 
+z
+M 1056 4850 
+L 1691 4850 
+L 1691 4219 
+L 1056 4219 
+L 1056 4850 
+z
+" transform="scale(0.015625)"/>
+     </defs>
+     <use xlink:href="#DejaVuSans-57"/>
+     <use xlink:href="#DejaVuSans-61" transform="translate(92.501953 0)"/>
+     <use xlink:href="#DejaVuSans-73" transform="translate(153.78125 0)"/>
+     <use xlink:href="#DejaVuSans-20" transform="translate(205.880859 0)"/>
+     <use xlink:href="#DejaVuSans-64" transform="translate(237.667969 0)"/>
+     <use xlink:href="#DejaVuSans-65" transform="translate(301.144531 0)"/>
+     <use xlink:href="#DejaVuSans-72" transform="translate(362.667969 0)"/>
+     <use xlink:href="#DejaVuSans-20" transform="translate(403.78125 0)"/>
+     <use xlink:href="#DejaVuSans-45" transform="translate(435.568359 0)"/>
+     <use xlink:href="#DejaVuSans-72" transform="translate(498.751953 0)"/>
+     <use xlink:href="#DejaVuSans-77" transform="translate(539.865234 0)"/>
+     <use xlink:href="#DejaVuSans-61" transform="translate(621.652344 0)"/>
+     <use xlink:href="#DejaVuSans-72" transform="translate(682.931641 0)"/>
+     <use xlink:href="#DejaVuSans-74" transform="translate(724.044922 0)"/>
+     <use xlink:href="#DejaVuSans-75" transform="translate(763.253906 0)"/>
+     <use xlink:href="#DejaVuSans-6e" transform="translate(826.632812 0)"/>
+     <use xlink:href="#DejaVuSans-67" transform="translate(890.011719 0)"/>
+     <use xlink:href="#DejaVuSans-73" transform="translate(953.488281 0)"/>
+     <use xlink:href="#DejaVuSans-77" transform="translate(1005.587891 0)"/>
+     <use xlink:href="#DejaVuSans-65" transform="translate(1087.375 0)"/>
+     <use xlink:href="#DejaVuSans-72" transform="translate(1148.898438 0)"/>
+     <use xlink:href="#DejaVuSans-74" transform="translate(1190.011719 0)"/>
+     <use xlink:href="#DejaVuSans-2d" transform="translate(1229.220703 0)"/>
+     <use xlink:href="#DejaVuSans-50" transform="translate(1265.304688 0)"/>
+     <use xlink:href="#DejaVuSans-6c" transform="translate(1325.607422 0)"/>
+     <use xlink:href="#DejaVuSans-61" transform="translate(1353.390625 0)"/>
+     <use xlink:href="#DejaVuSans-6e" transform="translate(1414.669922 0)"/>
+     <use xlink:href="#DejaVuSans-20" transform="translate(1478.048828 0)"/>
+     <use xlink:href="#DejaVuSans-73" transform="translate(1509.835938 0)"/>
+     <use xlink:href="#DejaVuSans-70" transform="translate(1561.935547 0)"/>
+     <use xlink:href="#DejaVuSans-61" transform="translate(1625.412109 0)"/>
+     <use xlink:href="#DejaVuSans-72" transform="translate(1686.691406 0)"/>
+     <use xlink:href="#DejaVuSans-74" transform="translate(1727.804688 0)"/>
+     <use xlink:href="#DejaVuSans-20" transform="translate(1767.013672 0)"/>
+     <use xlink:href="#DejaVuSans-2014" transform="translate(1798.800781 0)"/>
+     <use xlink:href="#DejaVuSans-20" transform="translate(1898.800781 0)"/>
+     <use xlink:href="#DejaVuSans-75" transform="translate(1930.587891 0)"/>
+     <use xlink:href="#DejaVuSans-6e" transform="translate(1993.966797 0)"/>
+     <use xlink:href="#DejaVuSans-64" transform="translate(2057.345703 0)"/>
+     <use xlink:href="#DejaVuSans-20" transform="translate(2120.822266 0)"/>
+     <use xlink:href="#DejaVuSans-77" transform="translate(2152.609375 0)"/>
+     <use xlink:href="#DejaVuSans-61" transform="translate(2234.396484 0)"/>
+     <use xlink:href="#DejaVuSans-73" transform="translate(2295.675781 0)"/>
+     <use xlink:href="#DejaVuSans-20" transform="translate(2347.775391 0)"/>
+     <use xlink:href="#DejaVuSans-65" transform="translate(2379.5625 0)"/>
+     <use xlink:href="#DejaVuSans-72" transform="translate(2441.085938 0)"/>
+     <use xlink:href="#DejaVuSans-20" transform="translate(2482.199219 0)"/>
+     <use xlink:href="#DejaVuSans-64" transform="translate(2513.986328 0)"/>
+     <use xlink:href="#DejaVuSans-61" transform="translate(2577.462891 0)"/>
+     <use xlink:href="#DejaVuSans-66" transform="translate(2638.742188 0)"/>
+     <use xlink:href="#DejaVuSans-fc" transform="translate(2673.947266 0)"/>
+     <use xlink:href="#DejaVuSans-72" transform="translate(2737.326172 0)"/>
+     <use xlink:href="#DejaVuSans-20" transform="translate(2778.439453 0)"/>
+     <use xlink:href="#DejaVuSans-62" transform="translate(2810.226562 0)"/>
+     <use xlink:href="#DejaVuSans-65" transform="translate(2873.703125 0)"/>
+     <use xlink:href="#DejaVuSans-7a" transform="translate(2935.226562 0)"/>
+     <use xlink:href="#DejaVuSans-61" transform="translate(2987.716797 0)"/>
+     <use xlink:href="#DejaVuSans-68" transform="translate(3048.996094 0)"/>
+     <use xlink:href="#DejaVuSans-6c" transform="translate(3112.375 0)"/>
+     <use xlink:href="#DejaVuSans-74" transform="translate(3140.158203 0)"/>
+    </g>
+    <!-- Ersparnis 12.725 € Brennstoff, Preis 536.239 € Lastabwurf: das 42-fache -->
+    <g transform="translate(172.815313 35.856) scale(0.125 -0.125)">
+     <defs>
+      <path id="DejaVuSans-37" d="M 525 4666 
+L 3525 4666 
+L 3525 4397 
+L 1831 0 
+L 1172 0 
+L 2766 4134 
+L 525 4134 
+L 525 4666 
+z
+" transform="scale(0.015625)"/>
+      <path id="DejaVuSans-35" d="M 691 4666 
+L 3169 4666 
+L 3169 4134 
+L 1269 4134 
+L 1269 2991 
+Q 1406 3038 1543 3061 
+Q 1681 3084 1819 3084 
+Q 2600 3084 3056 2656 
+Q 3513 2228 3513 1497 
+Q 3513 744 3044 326 
+Q 2575 -91 1722 -91 
+Q 1428 -91 1123 -41 
+Q 819 9 494 109 
+L 494 744 
+Q 775 591 1075 516 
+Q 1375 441 1709 441 
+Q 2250 441 2565 725 
+Q 2881 1009 2881 1497 
+Q 2881 1984 2565 2268 
+Q 2250 2553 1709 2553 
+Q 1456 2553 1204 2497 
+Q 953 2441 691 2322 
+L 691 4666 
+z
+" transform="scale(0.015625)"/>
+      <path id="DejaVuSans-2c" d="M 750 794 
+L 1409 794 
+L 1409 256 
+L 897 -744 
+L 494 -744 
+L 750 256 
+L 750 794 
+z
+" transform="scale(0.015625)"/>
+      <path id="DejaVuSans-33" d="M 2597 2516 
+Q 3050 2419 3304 2112 
+Q 3559 1806 3559 1356 
+Q 3559 666 3084 287 
+Q 2609 -91 1734 -91 
+Q 1441 -91 1130 -33 
+Q 819 25 488 141 
+L 488 750 
+Q 750 597 1062 519 
+Q 1375 441 1716 441 
+Q 2309 441 2620 675 
+Q 2931 909 2931 1356 
+Q 2931 1769 2642 2001 
+Q 2353 2234 1838 2234 
+L 1294 2234 
+L 1294 2753 
+L 1863 2753 
+Q 2328 2753 2575 2939 
+Q 2822 3125 2822 3475 
+Q 2822 3834 2567 4026 
+Q 2313 4219 1838 4219 
+Q 1578 4219 1281 4162 
+Q 984 4106 628 3988 
+L 628 4550 
+Q 988 4650 1302 4700 
+Q 1616 4750 1894 4750 
+Q 2613 4750 3031 4423 
+Q 3450 4097 3450 3541 
+Q 3450 3153 3228 2886 
+Q 3006 2619 2597 2516 
+z
+" transform="scale(0.015625)"/>
+      <path id="DejaVuSans-39" d="M 703 97 
+L 703 672 
+Q 941 559 1184 500 
+Q 1428 441 1663 441 
+Q 2288 441 2617 861 
+Q 2947 1281 2994 2138 
+Q 2813 1869 2534 1725 
+Q 2256 1581 1919 1581 
+Q 1219 1581 811 2004 
+Q 403 2428 403 3163 
+Q 403 3881 828 4315 
+Q 1253 4750 1959 4750 
+Q 2769 4750 3195 4129 
+Q 3622 3509 3622 2328 
+Q 3622 1225 3098 567 
+Q 2575 -91 1691 -91 
+Q 1453 -91 1209 -44 
+Q 966 3 703 97 
+z
+M 1959 2075 
+Q 2384 2075 2632 2365 
+Q 2881 2656 2881 3163 
+Q 2881 3666 2632 3958 
+Q 2384 4250 1959 4250 
+Q 1534 4250 1286 3958 
+Q 1038 3666 1038 3163 
+Q 1038 2656 1286 2365 
+Q 1534 2075 1959 2075 
+z
+" transform="scale(0.015625)"/>
+      <path id="DejaVuSans-3a" d="M 750 794 
+L 1409 794 
+L 1409 0 
+L 750 0 
+L 750 794 
+z
+M 750 3309 
+L 1409 3309 
+L 1409 2516 
+L 750 2516 
+L 750 3309 
+z
+" transform="scale(0.015625)"/>
+     </defs>
+     <use xlink:href="#DejaVuSans-45"/>
+     <use xlink:href="#DejaVuSans-72" transform="translate(63.183594 0)"/>
+     <use xlink:href="#DejaVuSans-73" transform="translate(104.296875 0)"/>
+     <use xlink:href="#DejaVuSans-70" transform="translate(156.396484 0)"/>
+     <use xlink:href="#DejaVuSans-61" transform="translate(219.873047 0)"/>
+     <use xlink:href="#DejaVuSans-72" transform="translate(281.152344 0)"/>
+     <use xlink:href="#DejaVuSans-6e" transform="translate(320.515625 0)"/>
+     <use xlink:href="#DejaVuSans-69" transform="translate(383.894531 0)"/>
+     <use xlink:href="#DejaVuSans-73" transform="translate(411.677734 0)"/>
+     <use xlink:href="#DejaVuSans-20" transform="translate(463.777344 0)"/>
+     <use xlink:href="#DejaVuSans-31" transform="translate(495.564453 0)"/>
+     <use xlink:href="#DejaVuSans-32" transform="translate(559.1875 0)"/>
+     <use xlink:href="#DejaVuSans-2e" transform="translate(622.810547 0)"/>
+     <use xlink:href="#DejaVuSans-37" transform="translate(654.597656 0)"/>
+     <use xlink:href="#DejaVuSans-32" transform="translate(718.220703 0)"/>
+     <use xlink:href="#DejaVuSans-35" transform="translate(781.84375 0)"/>
+     <use xlink:href="#DejaVuSans-20" transform="translate(845.466797 0)"/>
+     <use xlink:href="#DejaVuSans-20ac" transform="translate(877.253906 0)"/>
+     <use xlink:href="#DejaVuSans-20" transform="translate(940.876953 0)"/>
+     <use xlink:href="#DejaVuSans-42" transform="translate(972.664062 0)"/>
+     <use xlink:href="#DejaVuSans-72" transform="translate(1041.267578 0)"/>
+     <use xlink:href="#DejaVuSans-65" transform="translate(1080.130859 0)"/>
+     <use xlink:href="#DejaVuSans-6e" transform="translate(1141.654297 0)"/>
+     <use xlink:href="#DejaVuSans-6e" transform="translate(1205.033203 0)"/>
+     <use xlink:href="#DejaVuSans-73" transform="translate(1268.412109 0)"/>
+     <use xlink:href="#DejaVuSans-74" transform="translate(1320.511719 0)"/>
+     <use xlink:href="#DejaVuSans-6f" transform="translate(1359.720703 0)"/>
+     <use xlink:href="#DejaVuSans-66" transform="translate(1420.902344 0)"/>
+     <use xlink:href="#DejaVuSans-66" transform="translate(1456.107422 0)"/>
+     <use xlink:href="#DejaVuSans-2c" transform="translate(1491.3125 0)"/>
+     <use xlink:href="#DejaVuSans-20" transform="translate(1523.099609 0)"/>
+     <use xlink:href="#DejaVuSans-50" transform="translate(1554.886719 0)"/>
+     <use xlink:href="#DejaVuSans-72" transform="translate(1613.439453 0)"/>
+     <use xlink:href="#DejaVuSans-65" transform="translate(1652.302734 0)"/>
+     <use xlink:href="#DejaVuSans-69" transform="translate(1713.826172 0)"/>
+     <use xlink:href="#DejaVuSans-73" transform="translate(1741.609375 0)"/>
+     <use xlink:href="#DejaVuSans-20" transform="translate(1793.708984 0)"/>
+     <use xlink:href="#DejaVuSans-35" transform="translate(1825.496094 0)"/>
+     <use xlink:href="#DejaVuSans-33" transform="translate(1889.119141 0)"/>
+     <use xlink:href="#DejaVuSans-36" transform="translate(1952.742188 0)"/>
+     <use xlink:href="#DejaVuSans-2e" transform="translate(2016.365234 0)"/>
+     <use xlink:href="#DejaVuSans-32" transform="translate(2048.152344 0)"/>
+     <use xlink:href="#DejaVuSans-33" transform="translate(2111.775391 0)"/>
+     <use xlink:href="#DejaVuSans-39" transform="translate(2175.398438 0)"/>
+     <use xlink:href="#DejaVuSans-20" transform="translate(2239.021484 0)"/>
+     <use xlink:href="#DejaVuSans-20ac" transform="translate(2270.808594 0)"/>
+     <use xlink:href="#DejaVuSans-20" transform="translate(2334.431641 0)"/>
+     <use xlink:href="#DejaVuSans-4c" transform="translate(2366.21875 0)"/>
+     <use xlink:href="#DejaVuSans-61" transform="translate(2421.931641 0)"/>
+     <use xlink:href="#DejaVuSans-73" transform="translate(2483.210938 0)"/>
+     <use xlink:href="#DejaVuSans-74" transform="translate(2535.310547 0)"/>
+     <use xlink:href="#DejaVuSans-61" transform="translate(2574.519531 0)"/>
+     <use xlink:href="#DejaVuSans-62" transform="translate(2635.798828 0)"/>
+     <use xlink:href="#DejaVuSans-77" transform="translate(2699.275391 0)"/>
+     <use xlink:href="#DejaVuSans-75" transform="translate(2781.0625 0)"/>
+     <use xlink:href="#DejaVuSans-72" transform="translate(2844.441406 0)"/>
+     <use xlink:href="#DejaVuSans-66" transform="translate(2885.554688 0)"/>
+     <use xlink:href="#DejaVuSans-3a" transform="translate(2917.134766 0)"/>
+     <use xlink:href="#DejaVuSans-20" transform="translate(2950.826172 0)"/>
+     <use xlink:href="#DejaVuSans-64" transform="translate(2982.613281 0)"/>
+     <use xlink:href="#DejaVuSans-61" transform="translate(3046.089844 0)"/>
+     <use xlink:href="#DejaVuSans-73" transform="translate(3107.369141 0)"/>
+     <use xlink:href="#DejaVuSans-20" transform="translate(3159.46875 0)"/>
+     <use xlink:href="#DejaVuSans-34" transform="translate(3191.255859 0)"/>
+     <use xlink:href="#DejaVuSans-32" transform="translate(3254.878906 0)"/>
+     <use xlink:href="#DejaVuSans-2d" transform="translate(3318.501953 0)"/>
+     <use xlink:href="#DejaVuSans-66" transform="translate(3354.585938 0)"/>
+     <use xlink:href="#DejaVuSans-61" transform="translate(3389.791016 0)"/>
+     <use xlink:href="#DejaVuSans-63" transform="translate(3451.070312 0)"/>
+     <use xlink:href="#DejaVuSans-68" transform="translate(3506.050781 0)"/>
+     <use xlink:href="#DejaVuSans-65" transform="translate(3569.429688 0)"/>
+    </g>
+   </g>
+   <g id="line2d_21">
+    <path d="M 360.234945 246.250134 
+L 439.255055 246.250134 
+" clip-path="url(#p83a3789304)" style="fill: none; stroke: #64748b; stroke-width: 2.2; stroke-linecap: square"/>
+   </g>
+  </g>
+ </g>
+ <defs>
+  <clipPath id="p83a3789304">
+   <rect x="75.89" y="49.856" width="647.71" height="292.26208"/>
+  </clipPath>
+ </defs>
+</svg>
diff --git a/OR_HTML_04/bruecke.html b/OR_HTML_04/bruecke.html
index 4b1fdb0..9816a53 100644
--- a/OR_HTML_04/bruecke.html
+++ b/OR_HTML_04/bruecke.html
@@ -94,10 +94,10 @@
 </header>
 <div class="site-body">
   <div class="sidebar-overlay" id="sidebar-overlay" hidden></div>
-  <nav class="sidebar" id="sidebar" aria-label="Kapitelnavigation"><div class="sidebar-inhalt"><details class="sidebar-gruppe"><summary>Einstieg</summary><ul><li data-kapitel="vorwort.html"><a href="vorwort.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Vorwort & Lesehilfe</span></a></li><li data-kapitel="notation.html"><a href="notation.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Notation & Abkürzungen</span></a></li></ul></details><details class="sidebar-gruppe"><summary>Teil I: Grundlagen des Operations Research</summary><ul><li data-kapitel="einfuehrung.html"><a href="einfuehrung.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 1: Einführung in Operations Research — Vom Ursprung zur mathematischen Entscheidungsfindung</span></a></li><li data-kapitel="fundament.html"><a href="fundament.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 2: Das mathematische Fundament — Vektoren, Matrizen, Konvexität</span></a></li><li data-kapitel="oekosystem.html"><a href="oekosystem.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 3: Das Python-Ökosystem für OR — Solver, Bindings und Modellierungsschichten</span></a></li><li data-kapitel="modellierung.html"><a href="modellierung.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 4: Vom Management-Wunsch zum Modell</span></a></li></ul></details><details class="sidebar-gruppe"><summary>Teil II: Die Kernverfahren der deterministischen Optimierung</summary><ul><li data-kapitel="lp.html"><a href="lp.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 5: Lineare Programmierung — Simplex, Dualität und Schattenpreise</span></a></li><li data-kapitel="milp.html"><a href="milp.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 6: Gemischt-ganzzahlige Optimierung — Diskrete Entscheidungen und Branch-and-Bound</span></a></li><li data-kapitel="cpsat.html"><a href="cpsat.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 7: Constraint Programming mit CP-SAT — Logik, Scheduling und Zuweisung</span></a></li><li data-kapitel="graphen.html"><a href="graphen.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 8: Graphen, Flüsse und Touren — Min-Cost-Flow, Matching und VRP</span></a></li><li data-kapitel="metaheuristiken.html"><a href="metaheuristiken.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 9: Metaheuristiken — wenn der exakte Solver aussteigt</span></a></li><li data-kapitel="dekomposition.html"><a href="dekomposition.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 10: Spaltengenerierung — das Modell umbauen statt die Lösung raten</span></a></li></ul></details><details class="sidebar-gruppe"><summary>Teil III: Nichtlinearität, Unsicherheit und mehrperiodige Dynamik</summary><ul><li data-kapitel="qp-nlp.html"><a href="qp-nlp.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 11: Quadratische und nichtlineare Optimierung — KKT, Lagrange, Konvexität</span></a></li><li data-kapitel="unsicherheit.html"><a href="unsicherheit.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 12: Optimierung unter Unsicherheit — Monte-Carlo, Stochastik, Robustheit</span></a></li><li data-kapitel="dynamische-programmierung.html"><a href="dynamische-programmierung.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 13: Dynamische Programmierung — Die Bellman-Gleichung und Order-Execution</span></a></li><li data-kapitel="mehrziel.html"><a href="mehrziel.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 14: Mehrere Ziele — Pareto-Fronten statt Gewichte</span></a></li><li data-kapitel="prognose.html"><a href="prognose.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 15: Predict-then-Optimize — die bessere Prognose, die schlechtere Entscheidung</span></a></li></ul></details><details class="sidebar-gruppe" open><summary>Teil IV: Anwendungen — Energiewirtschaft und Finanzmärkte</summary><ul><li data-kapitel="bruecke.html" class="aktiv"><a href="bruecke.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 16: Die Strukturbrücke — dieselbe Mathematik, zwei Welten</span></a></li><li data-kapitel="supplychain.html"><a href="supplychain.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 17: Supply-Chain und Energieeinsatz unter Unsicherheit</span></a></li><li data-kapitel="finanzdaten.html"><a href="finanzdaten.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 18: Finanzdaten-Modellierung — Renditen, Kovarianz und Shrinkage</span></a></li><li data-kapitel="markowitz.html"><a href="markowitz.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 19: Die moderne Portfoliotheorie nach Markowitz</span></a></li><li data-kapitel="cvar.html"><a href="cvar.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 20: Tail-Risiko, CVaR und Transaktionskosten</span></a></li><li data-kapitel="handelsmaschine.html"><a href="handelsmaschine.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 21: Die vollständige quantitative Handelsmaschine</span></a></li></ul></details><details class="sidebar-gruppe"><summary>Teil V: Praxis</summary><ul><li data-kapitel="praxisfallen.html"><a href="praxisfallen.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 22: Praxisfallen und der Weg zum produktiven Einsatz</span></a></li><li data-kapitel="testing.html"><a href="testing.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 23: Testen, Messen, Ausliefern</span></a></li><li data-kapitel="projektwerkstatt.html"><a href="projektwerkstatt.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Projektwerkstatt</span></a></li></ul></details><details class="sidebar-gruppe"><summary>Anhänge</summary><ul><li data-kapitel="anhang-loesungen.html"><a href="anhang-loesungen.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Anhang A: Lösungen zu allen Übungsaufgaben</span></a></li><li data-kapitel="anhang-modellierungsmuster.html"><a href="anhang-modellierungsmuster.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Anhang B: Katalog der Modellierungsmuster</span></a></li><li data-kapitel="anhang-fehlerdiagnose.html"><a href="anhang-fehlerdiagnose.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Anhang C: Fehlerdiagnose-Handbuch</span></a></li><li data-kapitel="anhang-spickzettel.html"><a href="anhang-spickzettel.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Anhang D: Spickzettel der Solver</span></a></li><li data-kapitel="anhang-glossar-literatur.html"><a href="anhang-glossar-literatur.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Anhang E: Glossar und Literatur</span></a></li></ul></details><ul class="sidebar-extra"><li><a href="programme.html"><svg class="icon" aria-hidden="true"><use href="#icon-book"></use></svg> Beispielprogramme</a></li><li><a href="stichwortverzeichnis.html"><svg class="icon" aria-hidden="true"><use href="#icon-search"></use></svg> Stichwortverzeichnis</a></li><li><a href="gesamtdokument.html"><svg class="icon" aria-hidden="true"><use href="#icon-external-link"></use></svg> Gesamtdokument (eine Seite)</a></li><li><a href="Operations_Research_mit_Python_Version_04.pdf" download><svg class="icon" aria-hidden="true"><use href="#icon-download"></use></svg> Download als PDF</a></li></ul></div></nav>
+  <nav class="sidebar" id="sidebar" aria-label="Kapitelnavigation"><div class="sidebar-inhalt"><details class="sidebar-gruppe"><summary>Einstieg</summary><ul><li data-kapitel="vorwort.html"><a href="vorwort.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Vorwort & Lesehilfe</span></a></li><li data-kapitel="notation.html"><a href="notation.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Notation & Abkürzungen</span></a></li></ul></details><details class="sidebar-gruppe"><summary>Teil I: Grundlagen des Operations Research</summary><ul><li data-kapitel="einfuehrung.html"><a href="einfuehrung.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 1: Einführung in Operations Research — Vom Ursprung zur mathematischen Entscheidungsfindung</span></a></li><li data-kapitel="fundament.html"><a href="fundament.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 2: Das mathematische Fundament — Vektoren, Matrizen, Konvexität</span></a></li><li data-kapitel="oekosystem.html"><a href="oekosystem.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 3: Das Python-Ökosystem für OR — Solver, Bindings und Modellierungsschichten</span></a></li><li data-kapitel="modellierung.html"><a href="modellierung.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 4: Vom Management-Wunsch zum Modell</span></a></li><li data-kapitel="synthese-grundlagen.html"><a href="synthese-grundlagen.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Synthese Teil I</span></a></li></ul></details><details class="sidebar-gruppe"><summary>Teil II: Die Kernverfahren der deterministischen Optimierung</summary><ul><li data-kapitel="lp.html"><a href="lp.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 5: Lineare Programmierung — Simplex, Dualität und Schattenpreise</span></a></li><li data-kapitel="milp.html"><a href="milp.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 6: Gemischt-ganzzahlige Optimierung — Diskrete Entscheidungen und Branch-and-Bound</span></a></li><li data-kapitel="cpsat.html"><a href="cpsat.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 7: Constraint Programming mit CP-SAT — Logik, Scheduling und Zuweisung</span></a></li><li data-kapitel="graphen.html"><a href="graphen.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 8: Graphen, Flüsse und Touren — Min-Cost-Flow, Matching und VRP</span></a></li><li data-kapitel="metaheuristiken.html"><a href="metaheuristiken.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 9: Metaheuristiken — wenn der exakte Solver aussteigt</span></a></li><li data-kapitel="dekomposition.html"><a href="dekomposition.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 10: Spaltengenerierung — das Modell umbauen statt die Lösung raten</span></a></li><li data-kapitel="synthese-kernverfahren.html"><a href="synthese-kernverfahren.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Synthese Teil II</span></a></li></ul></details><details class="sidebar-gruppe"><summary>Teil III: Nichtlinearität, Unsicherheit und mehrperiodige Dynamik</summary><ul><li data-kapitel="qp-nlp.html"><a href="qp-nlp.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 11: Quadratische und nichtlineare Optimierung — KKT, Lagrange, Konvexität</span></a></li><li data-kapitel="unsicherheit.html"><a href="unsicherheit.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 12: Optimierung unter Unsicherheit — Monte-Carlo, Stochastik, Robustheit</span></a></li><li data-kapitel="dynamische-programmierung.html"><a href="dynamische-programmierung.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 13: Dynamische Programmierung — Die Bellman-Gleichung und Order-Execution</span></a></li><li data-kapitel="mehrziel.html"><a href="mehrziel.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 14: Mehrere Ziele — Pareto-Fronten statt Gewichte</span></a></li><li data-kapitel="prognose.html"><a href="prognose.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 15: Predict-then-Optimize — die bessere Prognose, die schlechtere Entscheidung</span></a></li><li data-kapitel="synthese-nichtlinear.html"><a href="synthese-nichtlinear.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Synthese Teil III</span></a></li></ul></details><details class="sidebar-gruppe" open><summary>Teil IV: Anwendungen — Energiewirtschaft und Finanzmärkte</summary><ul><li data-kapitel="bruecke.html" class="aktiv"><a href="bruecke.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 16: Die Strukturbrücke — dieselbe Mathematik, zwei Welten</span></a></li><li data-kapitel="supplychain.html"><a href="supplychain.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 17: Supply-Chain und Energieeinsatz unter Unsicherheit</span></a></li><li data-kapitel="finanzdaten.html"><a href="finanzdaten.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 18: Finanzdaten-Modellierung — Renditen, Kovarianz und Shrinkage</span></a></li><li data-kapitel="markowitz.html"><a href="markowitz.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 19: Die moderne Portfoliotheorie nach Markowitz</span></a></li><li data-kapitel="cvar.html"><a href="cvar.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 20: Tail-Risiko, CVaR und Transaktionskosten</span></a></li><li data-kapitel="handelsmaschine.html"><a href="handelsmaschine.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 21: Die vollständige quantitative Handelsmaschine</span></a></li><li data-kapitel="synthese-anwendungen.html"><a href="synthese-anwendungen.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Synthese Teil IV</span></a></li></ul></details><details class="sidebar-gruppe"><summary>Teil V: Praxis</summary><ul><li data-kapitel="praxisfallen.html"><a href="praxisfallen.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 22: Praxisfallen und der Weg zum produktiven Einsatz</span></a></li><li data-kapitel="testing.html"><a href="testing.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 23: Testen, Messen, Ausliefern</span></a></li><li data-kapitel="synthese-praxis.html"><a href="synthese-praxis.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Synthese Teil V</span></a></li><li data-kapitel="projektwerkstatt.html"><a href="projektwerkstatt.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Projektwerkstatt</span></a></li></ul></details><details class="sidebar-gruppe"><summary>Anhänge</summary><ul><li data-kapitel="anhang-loesungen.html"><a href="anhang-loesungen.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Anhang A: Lösungen zu allen Übungsaufgaben</span></a></li><li data-kapitel="anhang-modellierungsmuster.html"><a href="anhang-modellierungsmuster.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Anhang B: Katalog der Modellierungsmuster</span></a></li><li data-kapitel="anhang-fehlerdiagnose.html"><a href="anhang-fehlerdiagnose.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Anhang C: Fehlerdiagnose-Handbuch</span></a></li><li data-kapitel="anhang-spickzettel.html"><a href="anhang-spickzettel.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Anhang D: Spickzettel der Solver</span></a></li><li data-kapitel="anhang-glossar-literatur.html"><a href="anhang-glossar-literatur.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Anhang E: Glossar und Literatur</span></a></li></ul></details><ul class="sidebar-extra"><li><a href="programme.html"><svg class="icon" aria-hidden="true"><use href="#icon-book"></use></svg> Beispielprogramme</a></li><li><a href="stichwortverzeichnis.html"><svg class="icon" aria-hidden="true"><use href="#icon-search"></use></svg> Stichwortverzeichnis</a></li><li><a href="gesamtdokument.html"><svg class="icon" aria-hidden="true"><use href="#icon-external-link"></use></svg> Gesamtdokument (eine Seite)</a></li><li><a href="Operations_Research_mit_Python_Version_04.pdf" download><svg class="icon" aria-hidden="true"><use href="#icon-download"></use></svg> Download als PDF</a></li></ul></div></nav>
   <main class="content">
     <nav class="breadcrumb" aria-label="Breadcrumb"><a href="index.html">Start</a> › <span>Teil IV</span> › <span>Kapitel 16: Die Strukturbrücke — dieselbe Mathematik, zwei Welten</span></nav>
-    <nav class="prev-next"><a class="prev-next-knopf prev-next-prev" href="prognose.html"><svg class="icon" aria-hidden="true"><use href="#icon-chevron-left"></use></svg><span><small>Zurück</small>Kapitel 15: Predict-then-Optimize — die bessere Prognose, die schlechtere Entscheidung</span></a><a class="prev-next-knopf prev-next-next" href="supplychain.html"><span><small>Weiter</small>Kapitel 17: Supply-Chain und Energieeinsatz unter Unsicherheit</span><svg class="icon" aria-hidden="true"><use href="#icon-chevron-right"></use></svg></a></nav>
+    <nav class="prev-next"><a class="prev-next-knopf prev-next-prev" href="synthese-nichtlinear.html"><svg class="icon" aria-hidden="true"><use href="#icon-chevron-left"></use></svg><span><small>Zurück</small>Synthese Teil III</span></a><a class="prev-next-knopf prev-next-next" href="supplychain.html"><span><small>Weiter</small>Kapitel 17: Supply-Chain und Energieeinsatz unter Unsicherheit</span><svg class="icon" aria-hidden="true"><use href="#icon-chevron-right"></use></svg></a></nav>
     <article>
     <h1 id="teil-anwendungen">Teil IV: Anwendungen — Energiewirtschaft und Finanzmärkte</h1>
 <p>Dieser Teil wechselt die Domäne — aber <strong>nicht</strong> die Methoden. Was hier folgt, ist die konsequente Anwendung dessen, was Sie in den Teilen II und III gelernt haben, auf zwei Gebiete, in denen viel Unsicherheit auf ein unmittelbar messbares Ergebnis trifft: die Energiewirtschaft und die Finanzmärkte.</p>
@@ -121,7 +121,7 @@
 <blockquote>
 <p><strong>📌 Kapitel auf einen Blick</strong></p>
 <p><strong>Worum geht es?</strong> Um den Nachweis, dass die Verfahren aus Teil II und III unverändert in der Finanzwelt funktionieren — und um die drei Stellen, an denen die Analogie endet.</p>
-<p><strong>Voraussetzungen:</strong> <a href="einfuehrung.html#kap-einfuehrung">Kapitel 1</a> (Allokation als LP), <a href="unsicherheit.html#kap-unsicherheit">Kapitel 12</a> (Szenarien) und <a href="praxisfallen.html#sec:praxisfallen-or-kern">Abschnitt 22.5</a> (<code>or_kern.py</code>).</p>
+<p><strong>Voraussetzungen:</strong> <a href="einfuehrung.html#kap-einfuehrung">Kapitel 1</a> (Allokation als LP), <a href="unsicherheit.html#kap-unsicherheit">Kapitel 12</a> (Szenarien) und <a href="praxisfallen.html#sec:praxisfallen-or-kern">Abschnitt 22.6</a> (<code>or_kern.py</code>).</p>
 <p><strong>Danach können Sie:</strong> ein betriebswirtschaftliches Modell in die andere Domäne übersetzen, ohne den Modellcode anzufassen; Schattenpreise in beiden Welten lesen; und benennen, welche Annahmen dabei <strong>nicht</strong> mitwandern.</p>
 <p><strong>Zeitbedarf:</strong> ca. 2,5 Stunden.</p>
 <p><strong>Programme:</strong><br />
@@ -799,7 +799,7 @@ u_s \ge \ell_s^\top w - \gamma, \quad u_s \ge 0
 
     </article>
     <button type="button" class="fortschritt-knopf" data-kapitel="bruecke.html"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg> <span>Als gelesen markieren</span></button>
-    <nav class="prev-next"><a class="prev-next-knopf prev-next-prev" href="prognose.html"><svg class="icon" aria-hidden="true"><use href="#icon-chevron-left"></use></svg><span><small>Zurück</small>Kapitel 15: Predict-then-Optimize — die bessere Prognose, die schlechtere Entscheidung</span></a><a class="prev-next-knopf prev-next-next" href="supplychain.html"><span><small>Weiter</small>Kapitel 17: Supply-Chain und Energieeinsatz unter Unsicherheit</span><svg class="icon" aria-hidden="true"><use href="#icon-chevron-right"></use></svg></a></nav>
+    <nav class="prev-next"><a class="prev-next-knopf prev-next-prev" href="synthese-nichtlinear.html"><svg class="icon" aria-hidden="true"><use href="#icon-chevron-left"></use></svg><span><small>Zurück</small>Synthese Teil III</span></a><a class="prev-next-knopf prev-next-next" href="supplychain.html"><span><small>Weiter</small>Kapitel 17: Supply-Chain und Energieeinsatz unter Unsicherheit</span><svg class="icon" aria-hidden="true"><use href="#icon-chevron-right"></use></svg></a></nav>
   </main>
 </div>
 <footer class="site-footer">
diff --git a/OR_HTML_04/cpsat.html b/OR_HTML_04/cpsat.html
index df62916..98c08c4 100644
--- a/OR_HTML_04/cpsat.html
+++ b/OR_HTML_04/cpsat.html
@@ -94,7 +94,7 @@
 </header>
 <div class="site-body">
   <div class="sidebar-overlay" id="sidebar-overlay" hidden></div>
-  <nav class="sidebar" id="sidebar" aria-label="Kapitelnavigation"><div class="sidebar-inhalt"><details class="sidebar-gruppe"><summary>Einstieg</summary><ul><li data-kapitel="vorwort.html"><a href="vorwort.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Vorwort & Lesehilfe</span></a></li><li data-kapitel="notation.html"><a href="notation.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Notation & Abkürzungen</span></a></li></ul></details><details class="sidebar-gruppe"><summary>Teil I: Grundlagen des Operations Research</summary><ul><li data-kapitel="einfuehrung.html"><a href="einfuehrung.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 1: Einführung in Operations Research — Vom Ursprung zur mathematischen Entscheidungsfindung</span></a></li><li data-kapitel="fundament.html"><a href="fundament.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 2: Das mathematische Fundament — Vektoren, Matrizen, Konvexität</span></a></li><li data-kapitel="oekosystem.html"><a href="oekosystem.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 3: Das Python-Ökosystem für OR — Solver, Bindings und Modellierungsschichten</span></a></li><li data-kapitel="modellierung.html"><a href="modellierung.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 4: Vom Management-Wunsch zum Modell</span></a></li></ul></details><details class="sidebar-gruppe" open><summary>Teil II: Die Kernverfahren der deterministischen Optimierung</summary><ul><li data-kapitel="lp.html"><a href="lp.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 5: Lineare Programmierung — Simplex, Dualität und Schattenpreise</span></a></li><li data-kapitel="milp.html"><a href="milp.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 6: Gemischt-ganzzahlige Optimierung — Diskrete Entscheidungen und Branch-and-Bound</span></a></li><li data-kapitel="cpsat.html" class="aktiv"><a href="cpsat.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 7: Constraint Programming mit CP-SAT — Logik, Scheduling und Zuweisung</span></a></li><li data-kapitel="graphen.html"><a href="graphen.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 8: Graphen, Flüsse und Touren — Min-Cost-Flow, Matching und VRP</span></a></li><li data-kapitel="metaheuristiken.html"><a href="metaheuristiken.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 9: Metaheuristiken — wenn der exakte Solver aussteigt</span></a></li><li data-kapitel="dekomposition.html"><a href="dekomposition.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 10: Spaltengenerierung — das Modell umbauen statt die Lösung raten</span></a></li></ul></details><details class="sidebar-gruppe"><summary>Teil III: Nichtlinearität, Unsicherheit und mehrperiodige Dynamik</summary><ul><li data-kapitel="qp-nlp.html"><a href="qp-nlp.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 11: Quadratische und nichtlineare Optimierung — KKT, Lagrange, Konvexität</span></a></li><li data-kapitel="unsicherheit.html"><a href="unsicherheit.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 12: Optimierung unter Unsicherheit — Monte-Carlo, Stochastik, Robustheit</span></a></li><li data-kapitel="dynamische-programmierung.html"><a href="dynamische-programmierung.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 13: Dynamische Programmierung — Die Bellman-Gleichung und Order-Execution</span></a></li><li data-kapitel="mehrziel.html"><a href="mehrziel.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 14: Mehrere Ziele — Pareto-Fronten statt Gewichte</span></a></li><li data-kapitel="prognose.html"><a href="prognose.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 15: Predict-then-Optimize — die bessere Prognose, die schlechtere Entscheidung</span></a></li></ul></details><details class="sidebar-gruppe"><summary>Teil IV: Anwendungen — Energiewirtschaft und Finanzmärkte</summary><ul><li data-kapitel="bruecke.html"><a href="bruecke.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 16: Die Strukturbrücke — dieselbe Mathematik, zwei Welten</span></a></li><li data-kapitel="supplychain.html"><a href="supplychain.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 17: Supply-Chain und Energieeinsatz unter Unsicherheit</span></a></li><li data-kapitel="finanzdaten.html"><a href="finanzdaten.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 18: Finanzdaten-Modellierung — Renditen, Kovarianz und Shrinkage</span></a></li><li data-kapitel="markowitz.html"><a href="markowitz.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 19: Die moderne Portfoliotheorie nach Markowitz</span></a></li><li data-kapitel="cvar.html"><a href="cvar.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 20: Tail-Risiko, CVaR und Transaktionskosten</span></a></li><li data-kapitel="handelsmaschine.html"><a href="handelsmaschine.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 21: Die vollständige quantitative Handelsmaschine</span></a></li></ul></details><details class="sidebar-gruppe"><summary>Teil V: Praxis</summary><ul><li data-kapitel="praxisfallen.html"><a href="praxisfallen.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 22: Praxisfallen und der Weg zum produktiven Einsatz</span></a></li><li data-kapitel="testing.html"><a href="testing.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 23: Testen, Messen, Ausliefern</span></a></li><li data-kapitel="projektwerkstatt.html"><a href="projektwerkstatt.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Projektwerkstatt</span></a></li></ul></details><details class="sidebar-gruppe"><summary>Anhänge</summary><ul><li data-kapitel="anhang-loesungen.html"><a href="anhang-loesungen.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Anhang A: Lösungen zu allen Übungsaufgaben</span></a></li><li data-kapitel="anhang-modellierungsmuster.html"><a href="anhang-modellierungsmuster.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Anhang B: Katalog der Modellierungsmuster</span></a></li><li data-kapitel="anhang-fehlerdiagnose.html"><a href="anhang-fehlerdiagnose.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Anhang C: Fehlerdiagnose-Handbuch</span></a></li><li data-kapitel="anhang-spickzettel.html"><a href="anhang-spickzettel.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Anhang D: Spickzettel der Solver</span></a></li><li data-kapitel="anhang-glossar-literatur.html"><a href="anhang-glossar-literatur.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Anhang E: Glossar und Literatur</span></a></li></ul></details><ul class="sidebar-extra"><li><a href="programme.html"><svg class="icon" aria-hidden="true"><use href="#icon-book"></use></svg> Beispielprogramme</a></li><li><a href="stichwortverzeichnis.html"><svg class="icon" aria-hidden="true"><use href="#icon-search"></use></svg> Stichwortverzeichnis</a></li><li><a href="gesamtdokument.html"><svg class="icon" aria-hidden="true"><use href="#icon-external-link"></use></svg> Gesamtdokument (eine Seite)</a></li><li><a href="Operations_Research_mit_Python_Version_04.pdf" download><svg class="icon" aria-hidden="true"><use href="#icon-download"></use></svg> Download als PDF</a></li></ul></div></nav>
+  <nav class="sidebar" id="sidebar" aria-label="Kapitelnavigation"><div class="sidebar-inhalt"><details class="sidebar-gruppe"><summary>Einstieg</summary><ul><li data-kapitel="vorwort.html"><a href="vorwort.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Vorwort & Lesehilfe</span></a></li><li data-kapitel="notation.html"><a href="notation.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Notation & Abkürzungen</span></a></li></ul></details><details class="sidebar-gruppe"><summary>Teil I: Grundlagen des Operations Research</summary><ul><li data-kapitel="einfuehrung.html"><a href="einfuehrung.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 1: Einführung in Operations Research — Vom Ursprung zur mathematischen Entscheidungsfindung</span></a></li><li data-kapitel="fundament.html"><a href="fundament.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 2: Das mathematische Fundament — Vektoren, Matrizen, Konvexität</span></a></li><li data-kapitel="oekosystem.html"><a href="oekosystem.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 3: Das Python-Ökosystem für OR — Solver, Bindings und Modellierungsschichten</span></a></li><li data-kapitel="modellierung.html"><a href="modellierung.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 4: Vom Management-Wunsch zum Modell</span></a></li><li data-kapitel="synthese-grundlagen.html"><a href="synthese-grundlagen.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Synthese Teil I</span></a></li></ul></details><details class="sidebar-gruppe" open><summary>Teil II: Die Kernverfahren der deterministischen Optimierung</summary><ul><li data-kapitel="lp.html"><a href="lp.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 5: Lineare Programmierung — Simplex, Dualität und Schattenpreise</span></a></li><li data-kapitel="milp.html"><a href="milp.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 6: Gemischt-ganzzahlige Optimierung — Diskrete Entscheidungen und Branch-and-Bound</span></a></li><li data-kapitel="cpsat.html" class="aktiv"><a href="cpsat.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 7: Constraint Programming mit CP-SAT — Logik, Scheduling und Zuweisung</span></a></li><li data-kapitel="graphen.html"><a href="graphen.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 8: Graphen, Flüsse und Touren — Min-Cost-Flow, Matching und VRP</span></a></li><li data-kapitel="metaheuristiken.html"><a href="metaheuristiken.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 9: Metaheuristiken — wenn der exakte Solver aussteigt</span></a></li><li data-kapitel="dekomposition.html"><a href="dekomposition.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 10: Spaltengenerierung — das Modell umbauen statt die Lösung raten</span></a></li><li data-kapitel="synthese-kernverfahren.html"><a href="synthese-kernverfahren.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Synthese Teil II</span></a></li></ul></details><details class="sidebar-gruppe"><summary>Teil III: Nichtlinearität, Unsicherheit und mehrperiodige Dynamik</summary><ul><li data-kapitel="qp-nlp.html"><a href="qp-nlp.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 11: Quadratische und nichtlineare Optimierung — KKT, Lagrange, Konvexität</span></a></li><li data-kapitel="unsicherheit.html"><a href="unsicherheit.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 12: Optimierung unter Unsicherheit — Monte-Carlo, Stochastik, Robustheit</span></a></li><li data-kapitel="dynamische-programmierung.html"><a href="dynamische-programmierung.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 13: Dynamische Programmierung — Die Bellman-Gleichung und Order-Execution</span></a></li><li data-kapitel="mehrziel.html"><a href="mehrziel.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 14: Mehrere Ziele — Pareto-Fronten statt Gewichte</span></a></li><li data-kapitel="prognose.html"><a href="prognose.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 15: Predict-then-Optimize — die bessere Prognose, die schlechtere Entscheidung</span></a></li><li data-kapitel="synthese-nichtlinear.html"><a href="synthese-nichtlinear.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Synthese Teil III</span></a></li></ul></details><details class="sidebar-gruppe"><summary>Teil IV: Anwendungen — Energiewirtschaft und Finanzmärkte</summary><ul><li data-kapitel="bruecke.html"><a href="bruecke.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 16: Die Strukturbrücke — dieselbe Mathematik, zwei Welten</span></a></li><li data-kapitel="supplychain.html"><a href="supplychain.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 17: Supply-Chain und Energieeinsatz unter Unsicherheit</span></a></li><li data-kapitel="finanzdaten.html"><a href="finanzdaten.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 18: Finanzdaten-Modellierung — Renditen, Kovarianz und Shrinkage</span></a></li><li data-kapitel="markowitz.html"><a href="markowitz.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 19: Die moderne Portfoliotheorie nach Markowitz</span></a></li><li data-kapitel="cvar.html"><a href="cvar.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 20: Tail-Risiko, CVaR und Transaktionskosten</span></a></li><li data-kapitel="handelsmaschine.html"><a href="handelsmaschine.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 21: Die vollständige quantitative Handelsmaschine</span></a></li><li data-kapitel="synthese-anwendungen.html"><a href="synthese-anwendungen.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Synthese Teil IV</span></a></li></ul></details><details class="sidebar-gruppe"><summary>Teil V: Praxis</summary><ul><li data-kapitel="praxisfallen.html"><a href="praxisfallen.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 22: Praxisfallen und der Weg zum produktiven Einsatz</span></a></li><li data-kapitel="testing.html"><a href="testing.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 23: Testen, Messen, Ausliefern</span></a></li><li data-kapitel="synthese-praxis.html"><a href="synthese-praxis.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Synthese Teil V</span></a></li><li data-kapitel="projektwerkstatt.html"><a href="projektwerkstatt.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Projektwerkstatt</span></a></li></ul></details><details class="sidebar-gruppe"><summary>Anhänge</summary><ul><li data-kapitel="anhang-loesungen.html"><a href="anhang-loesungen.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Anhang A: Lösungen zu allen Übungsaufgaben</span></a></li><li data-kapitel="anhang-modellierungsmuster.html"><a href="anhang-modellierungsmuster.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Anhang B: Katalog der Modellierungsmuster</span></a></li><li data-kapitel="anhang-fehlerdiagnose.html"><a href="anhang-fehlerdiagnose.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Anhang C: Fehlerdiagnose-Handbuch</span></a></li><li data-kapitel="anhang-spickzettel.html"><a href="anhang-spickzettel.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Anhang D: Spickzettel der Solver</span></a></li><li data-kapitel="anhang-glossar-literatur.html"><a href="anhang-glossar-literatur.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Anhang E: Glossar und Literatur</span></a></li></ul></details><ul class="sidebar-extra"><li><a href="programme.html"><svg class="icon" aria-hidden="true"><use href="#icon-book"></use></svg> Beispielprogramme</a></li><li><a href="stichwortverzeichnis.html"><svg class="icon" aria-hidden="true"><use href="#icon-search"></use></svg> Stichwortverzeichnis</a></li><li><a href="gesamtdokument.html"><svg class="icon" aria-hidden="true"><use href="#icon-external-link"></use></svg> Gesamtdokument (eine Seite)</a></li><li><a href="Operations_Research_mit_Python_Version_04.pdf" download><svg class="icon" aria-hidden="true"><use href="#icon-download"></use></svg> Download als PDF</a></li></ul></div></nav>
   <main class="content">
     <nav class="breadcrumb" aria-label="Breadcrumb"><a href="index.html">Start</a> › <span>Teil II</span> › <span>Kapitel 7: Constraint Programming mit CP-SAT — Logik, Scheduling und Zuweisung</span></nav>
     <nav class="prev-next"><a class="prev-next-knopf prev-next-prev" href="milp.html"><svg class="icon" aria-hidden="true"><use href="#icon-chevron-left"></use></svg><span><small>Zurück</small>Kapitel 6: Gemischt-ganzzahlige Optimierung — Diskrete Entscheidungen und Branch-and-Bound</span></a><a class="prev-next-knopf prev-next-next" href="graphen.html"><span><small>Weiter</small>Kapitel 8: Graphen, Flüsse und Touren — Min-Cost-Flow, Matching und VRP</span><svg class="icon" aria-hidden="true"><use href="#icon-chevron-right"></use></svg></a></nav>
@@ -111,6 +111,7 @@
 <code>Propagation_Demo.py</code><br />
 <code>CP_SAT_Vertretungssystem.py</code><br />
 <code>JobShop_Intervalle.py</code><br />
+<code>Parallele_Suche.py</code><br />
 <code>CP_SAT_Statusfaelle.py</code><br />
 <code>Strafgewichte.py</code></p>
 <p><strong>Notebook:</strong> <a href="Notebooks_04/cpsat.ipynb">cpsat.ipynb</a><br />
@@ -155,7 +156,7 @@ Fr -&gt; Abel</code></pre>
 <p><strong>Und jetzt sehen Sie sich das Ergebnis genau an.</strong> <em>Cor bekommt keinen einzigen Dienst.</em> Dane arbeitet Montag <strong>und</strong> Dienstag hintereinander. Ist das ein Fehler?</p>
 <p>Nein — und das ist die wichtigste Lektion dieses Kapitels. Der Plan erfüllt <strong>jede</strong> Regel, die wir aufgeschrieben haben. Wir haben nur nie nach Fairness gefragt, und wir haben nie gesagt, dass Dienste nicht aufeinanderfolgen sollen. Ein Solver liefert exakt das Bestellte — nicht das Gemeinte.</p>
 <blockquote>
-<p><strong>🎯 Merksatz</strong> Ein Modell, das durchläuft, ist noch kein richtiges Modell. Die eigentliche Arbeit im Constraint Programming ist nicht das Lösen, sondern das vollständige Aufschreiben dessen, was „ein guter Plan“ überhaupt heißt. Wie man Wünsche wie Fairness als <strong>weiche</strong> Bedingungen mit Strafkosten formuliert, zeigt <a href="#sec:cpsat-praxisfall-dynamisches-vertretungssystem">Abschnitt 7.5</a> — und <a href="#sec:cpsat-denkfehler">Abschnitt 7.9</a> zeigt, was passiert, wenn man ihr Gewicht falsch wählt.</p>
+<p><strong>🎯 Merksatz</strong> Ein Modell, das durchläuft, ist noch kein richtiges Modell. Die eigentliche Arbeit im Constraint Programming ist nicht das Lösen, sondern das vollständige Aufschreiben dessen, was „ein guter Plan“ überhaupt heißt. Wie man Wünsche wie Fairness als <strong>weiche</strong> Bedingungen mit Strafkosten formuliert, zeigt <a href="#sec:cpsat-praxisfall-dynamisches-vertretungssystem">Abschnitt 7.5</a> — und <a href="#sec:cpsat-denkfehler">Abschnitt 7.10</a> zeigt, was passiert, wenn man ihr Gewicht falsch wählt.</p>
 </blockquote>
 <hr />
 <h2 id="sec:cpsat-lernziele">7.2 Lernziele</h2>
@@ -167,6 +168,7 @@ Fr -&gt; Abel</code></pre>
 <li>… mit <strong>Intervallvariablen</strong> ein Maschinenbelegungsproblem modellieren.</li>
 <li>… harte Regeln und weiche Ziele in einem Modell kombinieren und gewichten.</li>
 <li>… die fünf CP-SAT-Statusfälle unterscheiden — insbesondere <code>INFEASIBLE</code> (es gibt keine Lösung) von <code>UNKNOWN</code> (es wurde keine gefunden) und <code>MODEL_INVALID</code> (Ihr Code ist fehlerhaft).</li>
+<li>… begründen, warum <code>num_workers = 1</code> für einen reproduzierbaren Lauf nötig ist und ein fester <code>random_seed</code> allein nicht genügt — und was ein Test deshalb prüfen darf.</li>
 <li>… begründen, warum ein Strafgewicht ein <strong>Wechselkurs</strong> ist, und welche Regeln deshalb niemals in die Zielfunktion gehören.</li>
 </ol>
 <hr />
@@ -721,7 +723,7 @@ Suchstatistik: 113 Verzweigungen, 3 Konflikte, 0.006 s
 <p><strong>3. Kostenzerlegung.</strong> Der Block „Woraus bestehen die Strafkosten?“ ist kein Beiwerk. In der Praxis ist die erste Frage jedes Anwenders: <em>„Warum bekomme <strong>ich</strong> die Stunde?“</em> Wer darauf keine Antwort hat, dessen System wird nicht benutzt (<a href="praxisfallen.html#kap-praxisfallen">Kapitel 22</a>, <em>Explainable OR</em>).</p>
 <p><strong>4. Statusauswertung ohne CP-SAT-Vokabular.</strong> Nach <code>Solve()</code> steht nur eine einzige Zeile mit einer CP-SAT-Konstante darin:</p>
 <div class="sourceCode" id="cb7"><pre class="sourceCode python"><code class="sourceCode python"><span id="cb7-1"><a href="#cb7-1" aria-hidden="true" tabindex="-1"></a>status <span class="op">=</span> status_von_cpsat(rohstatus)</span></code></pre></div>
-<p>Danach heißen die Fälle <code>status.modellfehler</code> (die Regeln widersprechen sich — das Modell muss geändert werden) und <code>status.brauchbar</code> (es liegt etwas Ausführbares vor). Das ist <strong>dieselbe</strong> Fallunterscheidung wie bei HiGHS in <a href="milp.html#kap-milp">Kapitel 6</a> und bei GLOP in <a href="lp.html#kap-lp">Kapitel 5</a>; nur die eine Übersetzerzeile weiß, welcher Solver gerechnet hat. Wer den Auswertungscode direkt gegen <code>cp_model.INFEASIBLE</code> schreibt, kann ihn bei einem Solverwechsel wegwerfen — <a href="praxisfallen.html#sec:praxisfallen-solverwechsel">Abschnitt 22.6</a> führt genau diesen Wechsel vor.</p>
+<p>Danach heißen die Fälle <code>status.modellfehler</code> (die Regeln widersprechen sich — das Modell muss geändert werden) und <code>status.brauchbar</code> (es liegt etwas Ausführbares vor). Das ist <strong>dieselbe</strong> Fallunterscheidung wie bei HiGHS in <a href="milp.html#kap-milp">Kapitel 6</a> und bei GLOP in <a href="lp.html#kap-lp">Kapitel 5</a>; nur die eine Übersetzerzeile weiß, welcher Solver gerechnet hat. Wer den Auswertungscode direkt gegen <code>cp_model.INFEASIBLE</code> schreibt, kann ihn bei einem Solverwechsel wegwerfen — <a href="praxisfallen.html#sec:praxisfallen-solverwechsel">Abschnitt 22.7</a> führt genau diesen Wechsel vor.</p>
 </blockquote>
 <blockquote>
 <p><strong>⚠️ Typische Fehler</strong></p>
@@ -880,6 +882,7 @@ Erreichter Makespan: 11
 <p><strong>⚠️ Mehrere gleich gute Pläne — und was das für Ihre Tests bedeutet</strong></p>
 <p>Der kürzeste Makespan beträgt 11, aber es gibt <strong>mehrere verschiedene Pläne</strong>, die ihn erreichen. Welchen CP-SAT findet, hängt normalerweise davon ab, welcher seiner parallelen Suchstränge zuerst fertig wird — dasselbe Programm liefert dann von Lauf zu Lauf einen anderen (gleich guten) Plan.</p>
 <p>Deshalb setzt das Programm oben <code>num_workers = 1</code> und <code>random_seed = 1</code>: nur so ist die abgedruckte Ausgabe reproduzierbar. <strong>Im Produktivbetrieb lässt man beides weg</strong> — mehrere Arbeiter sind deutlich schneller.</p>
+<p>Wie viel schneller, und warum der Seed allein <strong>nicht</strong> genügt, misst <a href="#sec:cpsat-parallele-suche">Abschnitt 7.7</a> an genau diesem Modell.</p>
 <p>Die Lehre für Ihre eigenen Tests: Prüfen Sie bei mehrdeutigen Optima nie auf einen <strong>bestimmten Plan</strong>, sondern immer auf den <strong>Zielwert</strong> und auf die Einhaltung aller Regeln. Ein Test wie <code>assert plan == erwarteter_plan</code> besteht sonst mal und scheitert mal, ohne dass sich am Code etwas geändert hätte.</p>
 </blockquote>
 <p>Bemerkenswert ist die letzte Zeile: Die untere Schranke liegt bei 10, erreicht wurden 11. Die Schranke ist also <strong>nicht erreichbar</strong> — kein Plan kann 10 schaffen, obwohl weder ein einzelner Auftrag noch eine einzelne Maschine mehr als 10 Zeiteinheiten braucht. Der Grund sind die Wechselwirkungen. Das ist typisch für Scheduling: <strong>Einfache Schranken sind selten scharf.</strong> Trotzdem sind sie nützlich — sie sagten uns hier, dass wir höchstens 10 % vom theoretischen Ideal entfernt sein können, noch bevor der Solver fertig war.</p>
@@ -888,7 +891,305 @@ Erreichter Makespan: 11
 <p>Eine Intervallvariable bündelt drei Größen (Start, Dauer, Ende) und garantiert intern <code>start + dauer == ende</code>. Der eigentliche Gewinn ist aber <code>AddNoOverlap</code>: Diese eine Zeile ersetzt für <span class="math inline">k</span> Gänge auf einer Maschine <span class="math inline">\binom{k}{2}</span> Entweder-Oder-Konstruktionen mit je zwei Big-M-Ungleichungen und einer Binärvariablen. Bei 10 Gängen sind das 45 Disjunktionen — in MILP ein zäher Block, in CP-SAT eine Zeile mit einem spezialisierten Propagator.</p>
 </blockquote>
 <hr />
-<h2 id="sec:cpsat-statusfaelle">7.7 Die fünf Antworten von CP-SAT</h2>
+<h2 id="sec:cpsat-parallele-suche">7.7 Parallele Suche: was <code>num_workers</code> wirklich bewirkt</h2>
+<p>An mehreren Stellen dieses Buchs steht <code>loeser.parameters.num_workers = 1</code>, mit dem Kommentar „für eine reproduzierbare Ausgabe“. Darin stecken zwei Behauptungen: dass parallele Suche <strong>schneller</strong> ist, und dass sie <strong>von Lauf zu Lauf andere, gleich gute</strong> Lösungen liefert. Beides lässt sich messen — und beim Messen kommt mehr heraus als erwartet.</p>
+<p>Gerechnet wird auf demselben Modell wie <a href="#sec:cpsat-intervallvariablen-job-shop-scheduling">Abschnitt 7.6</a>, nur groß genug, dass die Suche wirklich arbeitet: 12 Aufträge auf 10 Maschinen, jeder Auftrag besucht jede Maschine. Entscheidend ist, dass <code>random_seed</code> in <strong>jedem</strong> Lauf denselben Wert hat.</p>
+<div class="sourceCode" id="cb10"><pre class="sourceCode python"><code class="sourceCode python"><span id="cb10-1"><a href="#cb10-1" aria-hidden="true" tabindex="-1"></a><span class="co">#!/usr/bin/env python3</span></span>
+<span id="cb10-2"><a href="#cb10-2" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb10-3"><a href="#cb10-3" aria-hidden="true" tabindex="-1"></a><span class="co"># Parallele_Suche.py</span></span>
+<span id="cb10-4"><a href="#cb10-4" aria-hidden="true" tabindex="-1"></a><span class="co">&quot;&quot;&quot;</span></span>
+<span id="cb10-5"><a href="#cb10-5" aria-hidden="true" tabindex="-1"></a><span class="co">Kapitel CP-SAT: Was mehrere Arbeiter wirklich bringen - und was sie kosten.</span></span>
+<span id="cb10-6"><a href="#cb10-6" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb10-7"><a href="#cb10-7" aria-hidden="true" tabindex="-1"></a><span class="co">Das Buch setzt an mehreren Stellen &#39;num_workers = 1&#39;, damit die abgedruckte</span></span>
+<span id="cb10-8"><a href="#cb10-8" aria-hidden="true" tabindex="-1"></a><span class="co">Ausgabe reproduzierbar ist. Behauptet wird dabei zweierlei: dass parallele</span></span>
+<span id="cb10-9"><a href="#cb10-9" aria-hidden="true" tabindex="-1"></a><span class="co">Suche schneller ist, und dass sie von Lauf zu Lauf verschiedene, gleich gute</span></span>
+<span id="cb10-10"><a href="#cb10-10" aria-hidden="true" tabindex="-1"></a><span class="co">Loesungen findet. Beides wird hier gemessen statt geglaubt.</span></span>
+<span id="cb10-11"><a href="#cb10-11" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb10-12"><a href="#cb10-12" aria-hidden="true" tabindex="-1"></a><span class="co">Gerechnet wird auf einem Job-Shop wie in JobShop_Intervalle.py, nur gross</span></span>
+<span id="cb10-13"><a href="#cb10-13" aria-hidden="true" tabindex="-1"></a><span class="co">genug, dass die Suche wirklich arbeitet: 12 Auftraege auf 10 Maschinen,</span></span>
+<span id="cb10-14"><a href="#cb10-14" aria-hidden="true" tabindex="-1"></a><span class="co">jeder Auftrag besucht jede Maschine.</span></span>
+<span id="cb10-15"><a href="#cb10-15" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb10-16"><a href="#cb10-16" aria-hidden="true" tabindex="-1"></a><span class="co">Zwei Messungen:</span></span>
+<span id="cb10-17"><a href="#cb10-17" aria-hidden="true" tabindex="-1"></a><span class="co">  1. Dieselbe Aufgabe mit 1, 2, 4 und 8 Arbeitern - Laufzeit und Ergebnis.</span></span>
+<span id="cb10-18"><a href="#cb10-18" aria-hidden="true" tabindex="-1"></a><span class="co">  2. Dieselbe Konfiguration mehrfach, bei FESTEM random_seed - wie oft kommt</span></span>
+<span id="cb10-19"><a href="#cb10-19" aria-hidden="true" tabindex="-1"></a><span class="co">     derselbe Plan heraus?</span></span>
+<span id="cb10-20"><a href="#cb10-20" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb10-21"><a href="#cb10-21" aria-hidden="true" tabindex="-1"></a><span class="co">Die zweite ist die wichtigere: Sie entscheidet, wie man Tests schreibt.</span></span>
+<span id="cb10-22"><a href="#cb10-22" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb10-23"><a href="#cb10-23" aria-hidden="true" tabindex="-1"></a><span class="co">Achtung, Laufzeiten sind hardwareabhaengig. Die ZAHL der verschiedenen</span></span>
+<span id="cb10-24"><a href="#cb10-24" aria-hidden="true" tabindex="-1"></a><span class="co">Plaene ist es auch - und genau das ist die Aussage.</span></span>
+<span id="cb10-25"><a href="#cb10-25" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb10-26"><a href="#cb10-26" aria-hidden="true" tabindex="-1"></a><span class="co">Benoetigt: numpy, ortools</span></span>
+<span id="cb10-27"><a href="#cb10-27" aria-hidden="true" tabindex="-1"></a><span class="co">&quot;&quot;&quot;</span></span>
+<span id="cb10-28"><a href="#cb10-28" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb10-29"><a href="#cb10-29" aria-hidden="true" tabindex="-1"></a><span class="im">from</span> __future__ <span class="im">import</span> annotations</span>
+<span id="cb10-30"><a href="#cb10-30" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb10-31"><a href="#cb10-31" aria-hidden="true" tabindex="-1"></a><span class="im">import</span> collections</span>
+<span id="cb10-32"><a href="#cb10-32" aria-hidden="true" tabindex="-1"></a><span class="im">import</span> time</span>
+<span id="cb10-33"><a href="#cb10-33" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb10-34"><a href="#cb10-34" aria-hidden="true" tabindex="-1"></a><span class="im">import</span> numpy <span class="im">as</span> np</span>
+<span id="cb10-35"><a href="#cb10-35" aria-hidden="true" tabindex="-1"></a><span class="im">from</span> ortools.sat.python <span class="im">import</span> cp_model</span>
+<span id="cb10-36"><a href="#cb10-36" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb10-37"><a href="#cb10-37" aria-hidden="true" tabindex="-1"></a>AUFTRAEGE <span class="op">=</span> <span class="dv">12</span></span>
+<span id="cb10-38"><a href="#cb10-38" aria-hidden="true" tabindex="-1"></a>MASCHINEN <span class="op">=</span> <span class="dv">10</span></span>
+<span id="cb10-39"><a href="#cb10-39" aria-hidden="true" tabindex="-1"></a>INSTANZ_SEED <span class="op">=</span> <span class="dv">20260908</span></span>
+<span id="cb10-40"><a href="#cb10-40" aria-hidden="true" tabindex="-1"></a>SOLVER_SEED <span class="op">=</span> <span class="dv">1</span>          <span class="co"># bleibt ueber ALLE Laeufe gleich - das ist der Punkt</span></span>
+<span id="cb10-41"><a href="#cb10-41" aria-hidden="true" tabindex="-1"></a>ARBEITERZAHLEN <span class="op">=</span> (<span class="dv">1</span>, <span class="dv">2</span>, <span class="dv">4</span>, <span class="dv">8</span>)</span>
+<span id="cb10-42"><a href="#cb10-42" aria-hidden="true" tabindex="-1"></a>WIEDERHOLUNGEN <span class="op">=</span> <span class="dv">4</span></span>
+<span id="cb10-43"><a href="#cb10-43" aria-hidden="true" tabindex="-1"></a>ZEITLIMIT <span class="op">=</span> <span class="fl">120.0</span></span>
+<span id="cb10-44"><a href="#cb10-44" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb10-45"><a href="#cb10-45" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb10-46"><a href="#cb10-46" aria-hidden="true" tabindex="-1"></a><span class="kw">def</span> baue_instanz() <span class="op">-&gt;</span> <span class="bu">list</span>[<span class="bu">list</span>[<span class="bu">tuple</span>[<span class="bu">int</span>, <span class="bu">int</span>]]]:</span>
+<span id="cb10-47"><a href="#cb10-47" aria-hidden="true" tabindex="-1"></a>    <span class="co">&quot;&quot;&quot;Klassischer Job-Shop: Jeder Auftrag besucht jede Maschine genau einmal,</span></span>
+<span id="cb10-48"><a href="#cb10-48" aria-hidden="true" tabindex="-1"></a><span class="co">    in einer eigenen zufaelligen Reihenfolge.&quot;&quot;&quot;</span></span>
+<span id="cb10-49"><a href="#cb10-49" aria-hidden="true" tabindex="-1"></a>    rng <span class="op">=</span> np.random.default_rng(INSTANZ_SEED)</span>
+<span id="cb10-50"><a href="#cb10-50" aria-hidden="true" tabindex="-1"></a>    <span class="cf">return</span> [[(<span class="bu">int</span>(m), <span class="bu">int</span>(rng.integers(<span class="dv">2</span>, <span class="dv">20</span>))) <span class="cf">for</span> m <span class="kw">in</span> rng.permutation(MASCHINEN)]</span>
+<span id="cb10-51"><a href="#cb10-51" aria-hidden="true" tabindex="-1"></a>            <span class="cf">for</span> _ <span class="kw">in</span> <span class="bu">range</span>(AUFTRAEGE)]</span>
+<span id="cb10-52"><a href="#cb10-52" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb10-53"><a href="#cb10-53" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb10-54"><a href="#cb10-54" aria-hidden="true" tabindex="-1"></a><span class="kw">def</span> loese(auftraege, arbeiter: <span class="bu">int</span>):</span>
+<span id="cb10-55"><a href="#cb10-55" aria-hidden="true" tabindex="-1"></a>    <span class="co">&quot;&quot;&quot;Minimiert den Makespan. Gibt Status, Zielwert, Laufzeit und den Plan</span></span>
+<span id="cb10-56"><a href="#cb10-56" aria-hidden="true" tabindex="-1"></a><span class="co">    zurueck - den Plan als Tupel aller Startzeiten, damit sich zwei Laeufe</span></span>
+<span id="cb10-57"><a href="#cb10-57" aria-hidden="true" tabindex="-1"></a><span class="co">    vergleichen lassen.&quot;&quot;&quot;</span></span>
+<span id="cb10-58"><a href="#cb10-58" aria-hidden="true" tabindex="-1"></a>    horizont <span class="op">=</span> <span class="bu">sum</span>(dauer <span class="cf">for</span> auftrag <span class="kw">in</span> auftraege <span class="cf">for</span> _, dauer <span class="kw">in</span> auftrag)</span>
+<span id="cb10-59"><a href="#cb10-59" aria-hidden="true" tabindex="-1"></a>    modell <span class="op">=</span> cp_model.CpModel()</span>
+<span id="cb10-60"><a href="#cb10-60" aria-hidden="true" tabindex="-1"></a>    Gang <span class="op">=</span> collections.namedtuple(<span class="st">&quot;Gang&quot;</span>, <span class="st">&quot;start ende intervall&quot;</span>)</span>
+<span id="cb10-61"><a href="#cb10-61" aria-hidden="true" tabindex="-1"></a>    plaene: <span class="bu">dict</span>[<span class="bu">tuple</span>[<span class="bu">int</span>, <span class="bu">int</span>], Gang] <span class="op">=</span> {}</span>
+<span id="cb10-62"><a href="#cb10-62" aria-hidden="true" tabindex="-1"></a>    je_maschine <span class="op">=</span> collections.defaultdict(<span class="bu">list</span>)</span>
+<span id="cb10-63"><a href="#cb10-63" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb10-64"><a href="#cb10-64" aria-hidden="true" tabindex="-1"></a>    <span class="cf">for</span> a, auftrag <span class="kw">in</span> <span class="bu">enumerate</span>(auftraege):</span>
+<span id="cb10-65"><a href="#cb10-65" aria-hidden="true" tabindex="-1"></a>        <span class="cf">for</span> g, (maschine, dauer) <span class="kw">in</span> <span class="bu">enumerate</span>(auftrag):</span>
+<span id="cb10-66"><a href="#cb10-66" aria-hidden="true" tabindex="-1"></a>            start <span class="op">=</span> modell.NewIntVar(<span class="dv">0</span>, horizont, <span class="ss">f&quot;start_</span><span class="sc">{</span>a<span class="sc">}</span><span class="ss">_</span><span class="sc">{</span>g<span class="sc">}</span><span class="ss">&quot;</span>)</span>
+<span id="cb10-67"><a href="#cb10-67" aria-hidden="true" tabindex="-1"></a>            ende <span class="op">=</span> modell.NewIntVar(<span class="dv">0</span>, horizont, <span class="ss">f&quot;ende_</span><span class="sc">{</span>a<span class="sc">}</span><span class="ss">_</span><span class="sc">{</span>g<span class="sc">}</span><span class="ss">&quot;</span>)</span>
+<span id="cb10-68"><a href="#cb10-68" aria-hidden="true" tabindex="-1"></a>            intervall <span class="op">=</span> modell.NewIntervalVar(start, dauer, ende, <span class="ss">f&quot;iv_</span><span class="sc">{</span>a<span class="sc">}</span><span class="ss">_</span><span class="sc">{</span>g<span class="sc">}</span><span class="ss">&quot;</span>)</span>
+<span id="cb10-69"><a href="#cb10-69" aria-hidden="true" tabindex="-1"></a>            plaene[a, g] <span class="op">=</span> Gang(start, ende, intervall)</span>
+<span id="cb10-70"><a href="#cb10-70" aria-hidden="true" tabindex="-1"></a>            je_maschine[maschine].append(intervall)</span>
+<span id="cb10-71"><a href="#cb10-71" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb10-72"><a href="#cb10-72" aria-hidden="true" tabindex="-1"></a>    <span class="cf">for</span> maschine <span class="kw">in</span> <span class="bu">range</span>(MASCHINEN):</span>
+<span id="cb10-73"><a href="#cb10-73" aria-hidden="true" tabindex="-1"></a>        modell.AddNoOverlap(je_maschine[maschine])</span>
+<span id="cb10-74"><a href="#cb10-74" aria-hidden="true" tabindex="-1"></a>    <span class="cf">for</span> a, auftrag <span class="kw">in</span> <span class="bu">enumerate</span>(auftraege):</span>
+<span id="cb10-75"><a href="#cb10-75" aria-hidden="true" tabindex="-1"></a>        <span class="cf">for</span> g <span class="kw">in</span> <span class="bu">range</span>(<span class="bu">len</span>(auftrag) <span class="op">-</span> <span class="dv">1</span>):</span>
+<span id="cb10-76"><a href="#cb10-76" aria-hidden="true" tabindex="-1"></a>            modell.Add(plaene[a, g <span class="op">+</span> <span class="dv">1</span>].start <span class="op">&gt;=</span> plaene[a, g].ende)</span>
+<span id="cb10-77"><a href="#cb10-77" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb10-78"><a href="#cb10-78" aria-hidden="true" tabindex="-1"></a>    makespan <span class="op">=</span> modell.NewIntVar(<span class="dv">0</span>, horizont, <span class="st">&quot;makespan&quot;</span>)</span>
+<span id="cb10-79"><a href="#cb10-79" aria-hidden="true" tabindex="-1"></a>    modell.AddMaxEquality(</span>
+<span id="cb10-80"><a href="#cb10-80" aria-hidden="true" tabindex="-1"></a>        makespan, [plaene[a, <span class="bu">len</span>(auftrag) <span class="op">-</span> <span class="dv">1</span>].ende</span>
+<span id="cb10-81"><a href="#cb10-81" aria-hidden="true" tabindex="-1"></a>                   <span class="cf">for</span> a, auftrag <span class="kw">in</span> <span class="bu">enumerate</span>(auftraege)])</span>
+<span id="cb10-82"><a href="#cb10-82" aria-hidden="true" tabindex="-1"></a>    modell.Minimize(makespan)</span>
+<span id="cb10-83"><a href="#cb10-83" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb10-84"><a href="#cb10-84" aria-hidden="true" tabindex="-1"></a>    loeser <span class="op">=</span> cp_model.CpSolver()</span>
+<span id="cb10-85"><a href="#cb10-85" aria-hidden="true" tabindex="-1"></a>    loeser.parameters.num_workers <span class="op">=</span> arbeiter</span>
+<span id="cb10-86"><a href="#cb10-86" aria-hidden="true" tabindex="-1"></a>    loeser.parameters.random_seed <span class="op">=</span> SOLVER_SEED</span>
+<span id="cb10-87"><a href="#cb10-87" aria-hidden="true" tabindex="-1"></a>    loeser.parameters.max_time_in_seconds <span class="op">=</span> ZEITLIMIT</span>
+<span id="cb10-88"><a href="#cb10-88" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb10-89"><a href="#cb10-89" aria-hidden="true" tabindex="-1"></a>    beginn <span class="op">=</span> time.perf_counter()</span>
+<span id="cb10-90"><a href="#cb10-90" aria-hidden="true" tabindex="-1"></a>    status <span class="op">=</span> loeser.Solve(modell)</span>
+<span id="cb10-91"><a href="#cb10-91" aria-hidden="true" tabindex="-1"></a>    dauer <span class="op">=</span> time.perf_counter() <span class="op">-</span> beginn</span>
+<span id="cb10-92"><a href="#cb10-92" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb10-93"><a href="#cb10-93" aria-hidden="true" tabindex="-1"></a>    <span class="cf">if</span> status <span class="kw">not</span> <span class="kw">in</span> (cp_model.OPTIMAL, cp_model.FEASIBLE):</span>
+<span id="cb10-94"><a href="#cb10-94" aria-hidden="true" tabindex="-1"></a>        <span class="cf">return</span> loeser.StatusName(status), <span class="va">None</span>, dauer, <span class="va">None</span></span>
+<span id="cb10-95"><a href="#cb10-95" aria-hidden="true" tabindex="-1"></a>    plan <span class="op">=</span> <span class="bu">tuple</span>(loeser.Value(plaene[a, g].start)</span>
+<span id="cb10-96"><a href="#cb10-96" aria-hidden="true" tabindex="-1"></a>                 <span class="cf">for</span> a, auftrag <span class="kw">in</span> <span class="bu">enumerate</span>(auftraege)</span>
+<span id="cb10-97"><a href="#cb10-97" aria-hidden="true" tabindex="-1"></a>                 <span class="cf">for</span> g <span class="kw">in</span> <span class="bu">range</span>(<span class="bu">len</span>(auftrag)))</span>
+<span id="cb10-98"><a href="#cb10-98" aria-hidden="true" tabindex="-1"></a>    <span class="cf">return</span> loeser.StatusName(status), <span class="bu">int</span>(loeser.ObjectiveValue()), dauer, plan</span>
+<span id="cb10-99"><a href="#cb10-99" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb10-100"><a href="#cb10-100" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb10-101"><a href="#cb10-101" aria-hidden="true" tabindex="-1"></a><span class="cf">if</span> <span class="va">__name__</span> <span class="op">==</span> <span class="st">&quot;__main__&quot;</span>:</span>
+<span id="cb10-102"><a href="#cb10-102" aria-hidden="true" tabindex="-1"></a>    auftraege <span class="op">=</span> baue_instanz()</span>
+<span id="cb10-103"><a href="#cb10-103" aria-hidden="true" tabindex="-1"></a>    gaenge <span class="op">=</span> <span class="bu">sum</span>(<span class="bu">len</span>(a) <span class="cf">for</span> a <span class="kw">in</span> auftraege)</span>
+<span id="cb10-104"><a href="#cb10-104" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb10-105"><a href="#cb10-105" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;=&quot;</span> <span class="op">*</span> <span class="dv">78</span>)</span>
+<span id="cb10-106"><a href="#cb10-106" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;  WAS MEHRERE ARBEITER WIRKLICH BRINGEN&quot;</span>)</span>
+<span id="cb10-107"><a href="#cb10-107" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;=&quot;</span> <span class="op">*</span> <span class="dv">78</span>)</span>
+<span id="cb10-108"><a href="#cb10-108" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;Job-Shop: </span><span class="sc">{</span>AUFTRAEGE<span class="sc">}</span><span class="ss"> Auftraege, </span><span class="sc">{</span>MASCHINEN<span class="sc">}</span><span class="ss"> Maschinen, &quot;</span></span>
+<span id="cb10-109"><a href="#cb10-109" aria-hidden="true" tabindex="-1"></a>          <span class="ss">f&quot;</span><span class="sc">{</span>gaenge<span class="sc">}</span><span class="ss"> Arbeitsgaenge.&quot;</span>)</span>
+<span id="cb10-110"><a href="#cb10-110" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;random_seed = </span><span class="sc">{</span>SOLVER_SEED<span class="sc">}</span><span class="ss"> in JEDEM Lauf, &quot;</span></span>
+<span id="cb10-111"><a href="#cb10-111" aria-hidden="true" tabindex="-1"></a>          <span class="ss">f&quot;</span><span class="sc">{</span>WIEDERHOLUNGEN<span class="sc">}</span><span class="ss"> Wiederholungen je Arbeiterzahl.</span><span class="ch">\n</span><span class="ss">&quot;</span>)</span>
+<span id="cb10-112"><a href="#cb10-112" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb10-113"><a href="#cb10-113" aria-hidden="true" tabindex="-1"></a>    <span class="co"># Jede Konfiguration mehrfach - ein einzelner Zeitwert sagt nichts.</span></span>
+<span id="cb10-114"><a href="#cb10-114" aria-hidden="true" tabindex="-1"></a>    ergebnisse: <span class="bu">dict</span>[<span class="bu">int</span>, <span class="bu">list</span>[<span class="bu">tuple</span>]] <span class="op">=</span> {}</span>
+<span id="cb10-115"><a href="#cb10-115" aria-hidden="true" tabindex="-1"></a>    <span class="cf">for</span> arbeiter <span class="kw">in</span> ARBEITERZAHLEN:</span>
+<span id="cb10-116"><a href="#cb10-116" aria-hidden="true" tabindex="-1"></a>        ergebnisse[arbeiter] <span class="op">=</span> [loese(auftraege, arbeiter)</span>
+<span id="cb10-117"><a href="#cb10-117" aria-hidden="true" tabindex="-1"></a>                                <span class="cf">for</span> _ <span class="kw">in</span> <span class="bu">range</span>(WIEDERHOLUNGEN)]</span>
+<span id="cb10-118"><a href="#cb10-118" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb10-119"><a href="#cb10-119" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;=&quot;</span> <span class="op">*</span> <span class="dv">78</span>)</span>
+<span id="cb10-120"><a href="#cb10-120" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;  (1) Laufzeit: was die Arbeiter bringen&quot;</span>)</span>
+<span id="cb10-121"><a href="#cb10-121" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;=&quot;</span> <span class="op">*</span> <span class="dv">78</span>)</span>
+<span id="cb10-122"><a href="#cb10-122" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;</span><span class="sc">{</span><span class="st">&#39;Arbeiter&#39;</span><span class="sc">:&gt;9}</span><span class="ss"> </span><span class="sc">{</span><span class="st">&#39;Status&#39;</span><span class="sc">:&gt;9}</span><span class="ss"> </span><span class="sc">{</span><span class="st">&#39;Makespan&#39;</span><span class="sc">:&gt;9}</span><span class="ss"> &quot;</span></span>
+<span id="cb10-123"><a href="#cb10-123" aria-hidden="true" tabindex="-1"></a>          <span class="ss">f&quot;</span><span class="sc">{</span><span class="st">&#39;schnellste&#39;</span><span class="sc">:&gt;11}</span><span class="ss"> </span><span class="sc">{</span><span class="st">&#39;langsamste&#39;</span><span class="sc">:&gt;11}</span><span class="ss"> </span><span class="sc">{</span><span class="st">&#39;Beschleunigung&#39;</span><span class="sc">:&gt;15}</span><span class="ss">&quot;</span>)</span>
+<span id="cb10-124"><a href="#cb10-124" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;-&quot;</span> <span class="op">*</span> <span class="dv">78</span>)</span>
+<span id="cb10-125"><a href="#cb10-125" aria-hidden="true" tabindex="-1"></a>    basis_zeit <span class="op">=</span> <span class="bu">min</span>(d <span class="cf">for</span> _, _, d, _ <span class="kw">in</span> ergebnisse[<span class="dv">1</span>])</span>
+<span id="cb10-126"><a href="#cb10-126" aria-hidden="true" tabindex="-1"></a>    <span class="cf">for</span> arbeiter <span class="kw">in</span> ARBEITERZAHLEN:</span>
+<span id="cb10-127"><a href="#cb10-127" aria-hidden="true" tabindex="-1"></a>        laeufe <span class="op">=</span> ergebnisse[arbeiter]</span>
+<span id="cb10-128"><a href="#cb10-128" aria-hidden="true" tabindex="-1"></a>        zeiten <span class="op">=</span> [d <span class="cf">for</span> _, _, d, _ <span class="kw">in</span> laeufe]</span>
+<span id="cb10-129"><a href="#cb10-129" aria-hidden="true" tabindex="-1"></a>        ziele <span class="op">=</span> {o <span class="cf">for</span> _, o, _, _ <span class="kw">in</span> laeufe}</span>
+<span id="cb10-130"><a href="#cb10-130" aria-hidden="true" tabindex="-1"></a>        status <span class="op">=</span> {s <span class="cf">for</span> s, _, _, _ <span class="kw">in</span> laeufe}</span>
+<span id="cb10-131"><a href="#cb10-131" aria-hidden="true" tabindex="-1"></a>        <span class="bu">print</span>(<span class="ss">f&quot;</span><span class="sc">{</span>arbeiter<span class="sc">:&gt;9}</span><span class="ss"> </span><span class="sc">{</span><span class="st">&#39;/&#39;</span><span class="sc">.</span>join(<span class="bu">sorted</span>(status))<span class="sc">:&gt;9}</span><span class="ss"> &quot;</span></span>
+<span id="cb10-132"><a href="#cb10-132" aria-hidden="true" tabindex="-1"></a>              <span class="ss">f&quot;</span><span class="sc">{</span><span class="st">&#39;/&#39;</span><span class="sc">.</span>join(<span class="bu">str</span>(z) <span class="cf">for</span> z <span class="kw">in</span> <span class="bu">sorted</span>(ziele))<span class="sc">:&gt;9}</span><span class="ss"> &quot;</span></span>
+<span id="cb10-133"><a href="#cb10-133" aria-hidden="true" tabindex="-1"></a>              <span class="ss">f&quot;</span><span class="sc">{</span><span class="bu">min</span>(zeiten)<span class="sc">:&gt;10.2f}</span><span class="ss">s </span><span class="sc">{</span><span class="bu">max</span>(zeiten)<span class="sc">:&gt;10.2f}</span><span class="ss">s &quot;</span></span>
+<span id="cb10-134"><a href="#cb10-134" aria-hidden="true" tabindex="-1"></a>              <span class="ss">f&quot;</span><span class="sc">{</span>basis_zeit <span class="op">/</span> <span class="bu">min</span>(zeiten)<span class="sc">:&gt;14.1f}</span><span class="ss">x&quot;</span>)</span>
+<span id="cb10-135"><a href="#cb10-135" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb10-136"><a href="#cb10-136" aria-hidden="true" tabindex="-1"></a>    beste <span class="op">=</span> <span class="bu">min</span>(ARBEITERZAHLEN, key<span class="op">=</span><span class="kw">lambda</span> w: <span class="bu">min</span>(d <span class="cf">for</span> _, _, d, _ <span class="kw">in</span> ergebnisse[w]))</span>
+<span id="cb10-137"><a href="#cb10-137" aria-hidden="true" tabindex="-1"></a>    faktor <span class="op">=</span> basis_zeit <span class="op">/</span> <span class="bu">min</span>(d <span class="cf">for</span> _, _, d, _ <span class="kw">in</span> ergebnisse[beste])</span>
+<span id="cb10-138"><a href="#cb10-138" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;</span><span class="ch">\n</span><span class="ss">  Am schnellsten sind </span><span class="sc">{</span>beste<span class="sc">}</span><span class="ss"> Arbeiter: Faktor </span><span class="sc">{</span>faktor<span class="sc">:.1f}</span><span class="ss"> gegenueber&quot;</span>)</span>
+<span id="cb10-139"><a href="#cb10-139" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;  einem einzigen - also MEHR, als </span><span class="sc">{</span>beste<span class="sc">}</span><span class="ss"> Kerne hergeben sollten.&quot;</span>)</span>
+<span id="cb10-140"><a href="#cb10-140" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;  Das ist kein Messfehler. CP-SAT laesst nicht </span><span class="sc">{</span>beste<span class="sc">}</span><span class="ss">-mal dieselbe Suche&quot;</span>)</span>
+<span id="cb10-141"><a href="#cb10-141" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;  laufen, sondern verschiedene Strategien nebeneinander, die einander&quot;</span>)</span>
+<span id="cb10-142"><a href="#cb10-142" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;  ihre Schranken zurufen. Der zweite Arbeiter ist deshalb nicht der&quot;</span>)</span>
+<span id="cb10-143"><a href="#cb10-143" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;  &#39;zweite Kern&#39;, sondern ein anderes Verfahren.&quot;</span>)</span>
+<span id="cb10-144"><a href="#cb10-144" aria-hidden="true" tabindex="-1"></a>    letzte <span class="op">=</span> ARBEITERZAHLEN[<span class="op">-</span><span class="dv">1</span>]</span>
+<span id="cb10-145"><a href="#cb10-145" aria-hidden="true" tabindex="-1"></a>    <span class="cf">if</span> beste <span class="op">!=</span> letzte:</span>
+<span id="cb10-146"><a href="#cb10-146" aria-hidden="true" tabindex="-1"></a>        zeit_letzte <span class="op">=</span> <span class="bu">min</span>(d <span class="cf">for</span> _, _, d, _ <span class="kw">in</span> ergebnisse[letzte])</span>
+<span id="cb10-147"><a href="#cb10-147" aria-hidden="true" tabindex="-1"></a>        <span class="bu">print</span>(<span class="ss">f&quot;</span><span class="ch">\n</span><span class="ss">  Und mehr ist nicht immer besser: </span><span class="sc">{</span>letzte<span class="sc">}</span><span class="ss"> Arbeiter brauchen &quot;</span></span>
+<span id="cb10-148"><a href="#cb10-148" aria-hidden="true" tabindex="-1"></a>              <span class="ss">f&quot;</span><span class="sc">{</span>zeit_letzte<span class="sc">:.2f}</span><span class="ss">s&quot;</span>)</span>
+<span id="cb10-149"><a href="#cb10-149" aria-hidden="true" tabindex="-1"></a>        <span class="bu">print</span>(<span class="ss">f&quot;  gegenueber </span><span class="sc">{</span><span class="bu">min</span>(d <span class="cf">for</span> _, _, d, _ <span class="kw">in</span> ergebnisse[beste])<span class="sc">:.2f}</span><span class="ss">s bei &quot;</span></span>
+<span id="cb10-150"><a href="#cb10-150" aria-hidden="true" tabindex="-1"></a>              <span class="ss">f&quot;</span><span class="sc">{</span>beste<span class="sc">}</span><span class="ss">. Ab einer gewissen Zahl kosten Abstimmung&quot;</span>)</span>
+<span id="cb10-151"><a href="#cb10-151" aria-hidden="true" tabindex="-1"></a>        <span class="bu">print</span>(<span class="st">&quot;  und Speicherbandbreite mehr, als ein weiterer Suchstrang einbringt.&quot;</span>)</span>
+<span id="cb10-152"><a href="#cb10-152" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb10-153"><a href="#cb10-153" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;</span><span class="ch">\n</span><span class="st">&quot;</span> <span class="op">+</span> <span class="st">&quot;=&quot;</span> <span class="op">*</span> <span class="dv">78</span>)</span>
+<span id="cb10-154"><a href="#cb10-154" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;  (2) Reproduzierbarkeit: derselbe Seed, derselbe Plan?&quot;</span>)</span>
+<span id="cb10-155"><a href="#cb10-155" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;=&quot;</span> <span class="op">*</span> <span class="dv">78</span>)</span>
+<span id="cb10-156"><a href="#cb10-156" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;</span><span class="sc">{</span><span class="st">&#39;Arbeiter&#39;</span><span class="sc">:&gt;9}</span><span class="ss"> </span><span class="sc">{</span><span class="st">&#39;Laeufe&#39;</span><span class="sc">:&gt;7}</span><span class="ss"> </span><span class="sc">{</span><span class="st">&#39;verschiedene Plaene&#39;</span><span class="sc">:&gt;21}</span><span class="ss"> &quot;</span></span>
+<span id="cb10-157"><a href="#cb10-157" aria-hidden="true" tabindex="-1"></a>          <span class="ss">f&quot;</span><span class="sc">{</span><span class="st">&#39;Makespan&#39;</span><span class="sc">:&gt;10}</span><span class="ss">&quot;</span>)</span>
+<span id="cb10-158"><a href="#cb10-158" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;-&quot;</span> <span class="op">*</span> <span class="dv">78</span>)</span>
+<span id="cb10-159"><a href="#cb10-159" aria-hidden="true" tabindex="-1"></a>    <span class="cf">for</span> arbeiter <span class="kw">in</span> ARBEITERZAHLEN:</span>
+<span id="cb10-160"><a href="#cb10-160" aria-hidden="true" tabindex="-1"></a>        plaene <span class="op">=</span> {p <span class="cf">for</span> _, _, _, p <span class="kw">in</span> ergebnisse[arbeiter] <span class="cf">if</span> p <span class="kw">is</span> <span class="kw">not</span> <span class="va">None</span>}</span>
+<span id="cb10-161"><a href="#cb10-161" aria-hidden="true" tabindex="-1"></a>        ziele <span class="op">=</span> {o <span class="cf">for</span> _, o, _, _ <span class="kw">in</span> ergebnisse[arbeiter]}</span>
+<span id="cb10-162"><a href="#cb10-162" aria-hidden="true" tabindex="-1"></a>        <span class="bu">print</span>(<span class="ss">f&quot;</span><span class="sc">{</span>arbeiter<span class="sc">:&gt;9}</span><span class="ss"> </span><span class="sc">{</span>WIEDERHOLUNGEN<span class="sc">:&gt;7}</span><span class="ss"> </span><span class="sc">{</span><span class="bu">len</span>(plaene)<span class="sc">:&gt;21}</span><span class="ss"> &quot;</span></span>
+<span id="cb10-163"><a href="#cb10-163" aria-hidden="true" tabindex="-1"></a>              <span class="ss">f&quot;</span><span class="sc">{</span><span class="st">&#39;/&#39;</span><span class="sc">.</span>join(<span class="bu">str</span>(z) <span class="cf">for</span> z <span class="kw">in</span> <span class="bu">sorted</span>(ziele))<span class="sc">:&gt;10}</span><span class="ss">&quot;</span>)</span>
+<span id="cb10-164"><a href="#cb10-164" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb10-165"><a href="#cb10-165" aria-hidden="true" tabindex="-1"></a>    einer <span class="op">=</span> <span class="bu">len</span>({p <span class="cf">for</span> _, _, _, p <span class="kw">in</span> ergebnisse[<span class="dv">1</span>]})</span>
+<span id="cb10-166"><a href="#cb10-166" aria-hidden="true" tabindex="-1"></a>    <span class="co"># Ab welcher Arbeiterzahl bricht die Reproduzierbarkeit? Das ist die</span></span>
+<span id="cb10-167"><a href="#cb10-167" aria-hidden="true" tabindex="-1"></a>    <span class="co"># eigentliche Zahl - nicht, was acht Arbeiter anrichten.</span></span>
+<span id="cb10-168"><a href="#cb10-168" aria-hidden="true" tabindex="-1"></a>    ab <span class="op">=</span> <span class="bu">next</span>((w <span class="cf">for</span> w <span class="kw">in</span> ARBEITERZAHLEN</span>
+<span id="cb10-169"><a href="#cb10-169" aria-hidden="true" tabindex="-1"></a>               <span class="cf">if</span> <span class="bu">len</span>({p <span class="cf">for</span> _, _, _, p <span class="kw">in</span> ergebnisse[w]}) <span class="op">&gt;</span> <span class="dv">1</span>), <span class="va">None</span>)</span>
+<span id="cb10-170"><a href="#cb10-170" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;</span><span class="ch">\n</span><span class="ss">  Mit einem Arbeiter: </span><span class="sc">{</span>einer<span class="sc">}</span><span class="ss"> Plan aus </span><span class="sc">{</span>WIEDERHOLUNGEN<span class="sc">}</span><span class="ss"> Laeufen.&quot;</span>)</span>
+<span id="cb10-171"><a href="#cb10-171" aria-hidden="true" tabindex="-1"></a>    <span class="cf">if</span> ab <span class="kw">is</span> <span class="kw">not</span> <span class="va">None</span>:</span>
+<span id="cb10-172"><a href="#cb10-172" aria-hidden="true" tabindex="-1"></a>        viele <span class="op">=</span> <span class="bu">len</span>({p <span class="cf">for</span> _, _, _, p <span class="kw">in</span> ergebnisse[ab]})</span>
+<span id="cb10-173"><a href="#cb10-173" aria-hidden="true" tabindex="-1"></a>        <span class="bu">print</span>(<span class="ss">f&quot;  Schon mit </span><span class="sc">{</span>ab<span class="sc">}</span><span class="ss"> Arbeitern: </span><span class="sc">{</span>viele<span class="sc">}</span><span class="ss"> verschiedene Plaene aus &quot;</span></span>
+<span id="cb10-174"><a href="#cb10-174" aria-hidden="true" tabindex="-1"></a>              <span class="ss">f&quot;</span><span class="sc">{</span>WIEDERHOLUNGEN<span class="sc">}</span><span class="ss"> Laeufen -&quot;</span>)</span>
+<span id="cb10-175"><a href="#cb10-175" aria-hidden="true" tabindex="-1"></a>        <span class="bu">print</span>(<span class="st">&quot;  bei identischem random_seed und identischem Zielwert.&quot;</span>)</span>
+<span id="cb10-176"><a href="#cb10-176" aria-hidden="true" tabindex="-1"></a>        <span class="bu">print</span>(<span class="ss">f&quot;  Es braucht also keine acht Arbeiter, um die Reproduzierbarkeit&quot;</span>)</span>
+<span id="cb10-177"><a href="#cb10-177" aria-hidden="true" tabindex="-1"></a>        <span class="bu">print</span>(<span class="ss">f&quot;  zu verlieren. </span><span class="sc">{</span>ab<span class="sc">}</span><span class="ss"> genuegen.&quot;</span>)</span>
+<span id="cb10-178"><a href="#cb10-178" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;</span><span class="ch">\n</span><span class="st">  Der Seed allein macht einen Lauf also NICHT reproduzierbar. Er legt&quot;</span>)</span>
+<span id="cb10-179"><a href="#cb10-179" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;  fest, wie ein einzelner Suchstrang wuerfelt - nicht, welcher von&quot;</span>)</span>
+<span id="cb10-180"><a href="#cb10-180" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;  mehreren zuerst fertig wird. Das entscheidet die Uhr.&quot;</span>)</span>
+<span id="cb10-181"><a href="#cb10-181" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb10-182"><a href="#cb10-182" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;</span><span class="ch">\n</span><span class="st">&quot;</span> <span class="op">+</span> <span class="st">&quot;=&quot;</span> <span class="op">*</span> <span class="dv">78</span>)</span>
+<span id="cb10-183"><a href="#cb10-183" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;  (3) Was daraus fuer Tests folgt&quot;</span>)</span>
+<span id="cb10-184"><a href="#cb10-184" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;=&quot;</span> <span class="op">*</span> <span class="dv">78</span>)</span>
+<span id="cb10-185"><a href="#cb10-185" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;  Ein Test der Form  assert plan == erwarteter_plan  besteht mal und&quot;</span>)</span>
+<span id="cb10-186"><a href="#cb10-186" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;  scheitert mal, ohne dass sich am Code etwas geaendert haette.&quot;</span>)</span>
+<span id="cb10-187"><a href="#cb10-187" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;  Zu pruefen sind stattdessen:&quot;</span>)</span>
+<span id="cb10-188"><a href="#cb10-188" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;    * der ZIELWERT (hier in allen Laeufen gleich),&quot;</span>)</span>
+<span id="cb10-189"><a href="#cb10-189" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;    * die Einhaltung aller Regeln (Abnahmepruefung, Kapitel Praxisfallen),&quot;</span>)</span>
+<span id="cb10-190"><a href="#cb10-190" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;    * und der Status - nicht die Gestalt der Loesung.&quot;</span>)</span>
+<span id="cb10-191"><a href="#cb10-191" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;</span><span class="ch">\n</span><span class="st">  Wer doch einen bestimmten Plan braucht - fuer eine abgedruckte&quot;</span>)</span>
+<span id="cb10-192"><a href="#cb10-192" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;  Ausgabe, fuer einen Regressionstest -, setzt num_workers = 1.&quot;</span>)</span>
+<span id="cb10-193"><a href="#cb10-193" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;  Das kostet hier den Faktor </span><span class="sc">{</span>faktor<span class="sc">:.1f}</span><span class="ss"> an Laufzeit und ist genau&quot;</span>)</span>
+<span id="cb10-194"><a href="#cb10-194" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;  deshalb eine Entscheidung fuer den Test, nicht fuer den Betrieb.&quot;</span>)</span>
+<span id="cb10-195"><a href="#cb10-195" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;=&quot;</span> <span class="op">*</span> <span class="dv">78</span>)</span></code></pre></div>
+<p><strong>Erwartete Ausgabe</strong> (Laufzeiten <em>und</em> die Zahl der verschiedenen Pläne sind hardwareabhängig — genau das ist die Aussage; der Zielwert ist es nicht):</p>
+<pre><code>==============================================================================
+  WAS MEHRERE ARBEITER WIRKLICH BRINGEN
+==============================================================================
+Job-Shop: 12 Auftraege, 10 Maschinen, 120 Arbeitsgaenge.
+random_seed = 1 in JEDEM Lauf, 4 Wiederholungen je Arbeiterzahl.
+
+==============================================================================
+  (1) Laufzeit: was die Arbeiter bringen
+==============================================================================
+ Arbeiter    Status  Makespan  schnellste  langsamste  Beschleunigung
+------------------------------------------------------------------------------
+        1   OPTIMAL       183       5.62s       5.82s            1.0x
+        2   OPTIMAL       183       1.43s       2.04s            3.9x
+        4   OPTIMAL       183       0.60s       0.66s            9.4x
+        8   OPTIMAL       183       0.46s       0.65s           12.3x
+
+  Am schnellsten sind 8 Arbeiter: Faktor 12.3 gegenueber
+  einem einzigen - also MEHR, als 8 Kerne hergeben sollten.
+  Das ist kein Messfehler. CP-SAT laesst nicht 8-mal dieselbe Suche
+  laufen, sondern verschiedene Strategien nebeneinander, die einander
+  ihre Schranken zurufen. Der zweite Arbeiter ist deshalb nicht der
+  &#39;zweite Kern&#39;, sondern ein anderes Verfahren.
+
+==============================================================================
+  (2) Reproduzierbarkeit: derselbe Seed, derselbe Plan?
+==============================================================================
+ Arbeiter  Laeufe   verschiedene Plaene   Makespan
+------------------------------------------------------------------------------
+        1       4                     1        183
+        2       4                     3        183
+        4       4                     3        183
+        8       4                     4        183
+
+  Mit einem Arbeiter: 1 Plan aus 4 Laeufen.
+  Schon mit 2 Arbeitern: 3 verschiedene Plaene aus 4 Laeufen -
+  bei identischem random_seed und identischem Zielwert.
+  Es braucht also keine acht Arbeiter, um die Reproduzierbarkeit
+  zu verlieren. 2 genuegen.
+
+  Der Seed allein macht einen Lauf also NICHT reproduzierbar. Er legt
+  fest, wie ein einzelner Suchstrang wuerfelt - nicht, welcher von
+  mehreren zuerst fertig wird. Das entscheidet die Uhr.
+
+==============================================================================
+  (3) Was daraus fuer Tests folgt
+==============================================================================
+  Ein Test der Form  assert plan == erwarteter_plan  besteht mal und
+  scheitert mal, ohne dass sich am Code etwas geaendert haette.
+  Zu pruefen sind stattdessen:
+    * der ZIELWERT (hier in allen Laeufen gleich),
+    * die Einhaltung aller Regeln (Abnahmepruefung, Kapitel Praxisfallen),
+    * und der Status - nicht die Gestalt der Loesung.
+
+  Wer doch einen bestimmten Plan braucht - fuer eine abgedruckte
+  Ausgabe, fuer einen Regressionstest -, setzt num_workers = 1.
+  Das kostet hier den Faktor 12.3 an Laufzeit und ist genau
+  deshalb eine Entscheidung fuer den Test, nicht fuer den Betrieb.
+==============================================================================</code></pre>
+<h3 id="was-die-messung-zeigt">Was die Messung zeigt</h3>
+<p><strong>Erstens: Die Beschleunigung ist überlinear.</strong> Acht Arbeiter sind im abgedruckten Lauf nicht achtmal, sondern <strong>gut zwölfmal</strong> schneller als einer. Das sieht nach Messfehler aus, ist aber die korrekte Beschreibung dessen, was CP-SAT tut: Es lässt <strong>nicht</strong> achtmal dieselbe Suche auf verschiedenen Kernen laufen, sondern <strong>verschiedene Strategien nebeneinander</strong> — Suche mit LP-Relaxation, Suche mit anderen Verzweigungsregeln, lokale Suche —, und die teilen einander ihre Schranken mit. Der zweite Arbeiter ist deshalb nicht „der zweite Kern“, sondern ein anderes Verfahren, das zufällig auch rechnet.</p>
+<p>Daraus folgt zweierlei. Ein Speedup über der Kernzahl ist bei CP-SAT normal und kein Grund zum Misstrauen. Und der Zugewinn flacht ab: Zwischen vier und acht Arbeitern lag in unseren Wiederholungen mal das eine, mal das andere vorn — ab einer gewissen Zahl kosten Abstimmung und Speicherbandbreite mehr, als ein weiterer Suchstrang einbringt. Auch hier gilt: messen, nicht schätzen.</p>
+<p><strong>Zweitens — und das ist der Befund, der die Testpraxis bestimmt: Der Seed genügt nicht.</strong> Bei einem Arbeiter liefern vier Läufe <strong>einen</strong> Plan. Schon bei <strong>zwei</strong> Arbeitern liefern vier Läufe <strong>drei verschiedene</strong> — bei identischem <code>random_seed</code> und identischem Zielwert 183.</p>
+<p>Es braucht also keine acht Arbeiter, um die Reproduzierbarkeit zu verlieren. Zwei genügen. Der Grund ist einfach, sobald man ihn ausspricht: Der Seed legt fest, wie ein <strong>einzelner</strong> Suchstrang würfelt. Er legt nicht fest, <strong>welcher von mehreren zuerst fertig wird</strong> — das entscheidet die Uhr, und die ist bei jedem Lauf anders.</p>
+<blockquote>
+<p><strong>⚠️ <code>random_seed</code> allein macht nichts reproduzierbar</strong> Ein häufiger Irrtum: „Ich habe doch einen Seed gesetzt.“ Für einen Zufallsgenerator stimmt das. Für einen <strong>parallelen</strong> Solver nicht — dort ist die zweite Zufallsquelle die Ausführungsreihenfolge, und die lässt sich nicht mit einem Parameter festnageln. Reproduzierbar wird der Lauf erst mit <code>num_workers = 1</code> <strong>und</strong> Seed. Wer nur eines von beidem setzt, hat einen Test, der gelegentlich grundlos rot wird.</p>
+</blockquote>
+<h3 id="was-daraus-für-tests-folgt">Was daraus für Tests folgt</h3>
+<p>Der Zielwert war in <strong>allen</strong> sechzehn Läufen derselbe: 183. Die Gestalt der Lösung war es nicht. Genau daran entscheidet sich, was ein Test prüfen darf:</p>
+<table>
+<colgroup>
+<col style="width: 50%" />
+<col style="width: 50%" />
+</colgroup>
+<thead>
+<tr class="header">
+<th>Prüfen</th>
+<th>Nicht prüfen</th>
+</tr>
+</thead>
+<tbody>
+<tr class="odd">
+<td>den <strong>Zielwert</strong> — er ist eindeutig, wenn das Modell optimal gelöst wurde</td>
+<td>die <strong>Gestalt</strong> des Plans (<code>assert plan == erwarteter_plan</code>)</td>
+</tr>
+<tr class="even">
+<td>die <strong>Einhaltung aller Regeln</strong> über eine Abnahmeprüfung (<a href="praxisfallen.html#sec:praxisfallen-or-kern">Abschnitt 22.6</a>)</td>
+<td>die Reihenfolge, in der gleichwertige Aufträge zugewiesen wurden</td>
+</tr>
+<tr class="odd">
+<td>den <strong>Status</strong> (<code>OPTIMAL</code>, <code>FEASIBLE</code>, <code>INFEASIBLE</code>)</td>
+<td>die Laufzeit als feste Zahl</td>
+</tr>
+</tbody>
+</table>
+<p>Wer doch einen bestimmten Plan braucht — für eine abgedruckte Ausgabe, für einen Regressionstest —, setzt <code>num_workers = 1</code>. Das kostet hier den Faktor 12 an Laufzeit, und genau deshalb ist es eine Entscheidung <strong>für den Test</strong>, nicht für den Betrieb. In Produktion lässt man beide Parameter auf ihren Standardwerten.</p>
+<blockquote>
+<p><strong>🎯 Merksatz</strong> Ein paralleler Solver hat zwei Zufallsquellen: den Seed und die Uhr. Nur die erste lässt sich setzen. Wer Reproduzierbarkeit braucht, muss die zweite abschalten — und das heißt <code>num_workers = 1</code>.</p>
+</blockquote>
+<hr />
+<h2 id="sec:cpsat-statusfaelle">7.8 Die fünf Antworten von CP-SAT</h2>
 <p><a href="milp.html#sec:milp-gap">Abschnitt 6.8</a> hat gezeigt, warum <code>OPTIMAL</code> bei ganzzahligen Problemen nicht der Normalfall ist. Bei CP-SAT kommt eine Besonderheit hinzu: Es gibt <strong>fünf</strong> verschiedene Antworten, und drei davon werden regelmäßig verwechselt.</p>
 <table>
 <colgroup>
@@ -936,229 +1237,229 @@ Erreichter Makespan: 11
 </blockquote>
 <p>Und <code>MODEL_INVALID</code> ist von beiden nochmals verschieden: Es ist immer ein <strong>Programmierfehler</strong>, kein fachliches Problem. Der klassische Fall ist eine Variable mit leerem Wertebereich — <code>NewIntVar(mindestbesetzung, kapazitaet, ...)</code>, wobei die Daten vertauscht ankamen und die untere Schranke über der oberen liegt.</p>
 <p>Das folgende Programm erzeugt jeden Fall absichtlich und zeigt die passende Auswertung.</p>
-<div class="sourceCode" id="cb10"><pre class="sourceCode python"><code class="sourceCode python"><span id="cb10-1"><a href="#cb10-1" aria-hidden="true" tabindex="-1"></a><span class="co">#!/usr/bin/env python3</span></span>
-<span id="cb10-2"><a href="#cb10-2" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb10-3"><a href="#cb10-3" aria-hidden="true" tabindex="-1"></a><span class="co"># CP_SAT_Statusfaelle.py</span></span>
-<span id="cb10-4"><a href="#cb10-4" aria-hidden="true" tabindex="-1"></a><span class="co">&quot;&quot;&quot;</span></span>
-<span id="cb10-5"><a href="#cb10-5" aria-hidden="true" tabindex="-1"></a><span class="co">Kapitel CP-SAT: Alle fuenf Antworten von CP-SAT - und was jede bedeutet.</span></span>
-<span id="cb10-6"><a href="#cb10-6" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb10-7"><a href="#cb10-7" aria-hidden="true" tabindex="-1"></a><span class="co">Der haeufigste Fehler beim Einsatz von CP-SAT im Betrieb ist eine Zeile wie</span></span>
-<span id="cb10-8"><a href="#cb10-8" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb10-9"><a href="#cb10-9" aria-hidden="true" tabindex="-1"></a><span class="co">    if status == cp_model.OPTIMAL:</span></span>
-<span id="cb10-10"><a href="#cb10-10" aria-hidden="true" tabindex="-1"></a><span class="co">        ...verwerte die Loesung...</span></span>
-<span id="cb10-11"><a href="#cb10-11" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb10-12"><a href="#cb10-12" aria-hidden="true" tabindex="-1"></a><span class="co">Sie wirft in drei von fuenf Faellen etwas weg, das man haette gebrauchen</span></span>
-<span id="cb10-13"><a href="#cb10-13" aria-hidden="true" tabindex="-1"></a><span class="co">koennen, und verschweigt in einem weiteren Fall einen Modellierungsfehler.</span></span>
-<span id="cb10-14"><a href="#cb10-14" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb10-15"><a href="#cb10-15" aria-hidden="true" tabindex="-1"></a><span class="co">Dieses Programm erzeugt jeden Statusfall absichtlich und zeigt die passende</span></span>
-<span id="cb10-16"><a href="#cb10-16" aria-hidden="true" tabindex="-1"></a><span class="co">Reaktion:</span></span>
-<span id="cb10-17"><a href="#cb10-17" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb10-18"><a href="#cb10-18" aria-hidden="true" tabindex="-1"></a><span class="co">    OPTIMAL        beweisbar bestmoeglich          -&gt; ausfuehren</span></span>
-<span id="cb10-19"><a href="#cb10-19" aria-hidden="true" tabindex="-1"></a><span class="co">    FEASIBLE       zulaessig, Zeit war um          -&gt; Gap pruefen, dann entscheiden</span></span>
-<span id="cb10-20"><a href="#cb10-20" aria-hidden="true" tabindex="-1"></a><span class="co">    INFEASIBLE     kein Plan existiert             -&gt; harte Regeln lockern</span></span>
-<span id="cb10-21"><a href="#cb10-21" aria-hidden="true" tabindex="-1"></a><span class="co">    MODEL_INVALID  das Modell ist fehlerhaft       -&gt; Programmierfehler beheben</span></span>
-<span id="cb10-22"><a href="#cb10-22" aria-hidden="true" tabindex="-1"></a><span class="co">    UNKNOWN        nichts gefunden, Zeit war um    -&gt; mehr Zeit oder Heuristik</span></span>
-<span id="cb10-23"><a href="#cb10-23" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb10-24"><a href="#cb10-24" aria-hidden="true" tabindex="-1"></a><span class="co">Benoetigt: numpy, ortools</span></span>
-<span id="cb10-25"><a href="#cb10-25" aria-hidden="true" tabindex="-1"></a><span class="co">&quot;&quot;&quot;</span></span>
-<span id="cb10-26"><a href="#cb10-26" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb10-27"><a href="#cb10-27" aria-hidden="true" tabindex="-1"></a><span class="im">from</span> __future__ <span class="im">import</span> annotations</span>
-<span id="cb10-28"><a href="#cb10-28" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb10-29"><a href="#cb10-29" aria-hidden="true" tabindex="-1"></a><span class="im">from</span> dataclasses <span class="im">import</span> dataclass</span>
-<span id="cb10-30"><a href="#cb10-30" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb10-31"><a href="#cb10-31" aria-hidden="true" tabindex="-1"></a><span class="im">import</span> numpy <span class="im">as</span> np</span>
-<span id="cb10-32"><a href="#cb10-32" aria-hidden="true" tabindex="-1"></a><span class="im">from</span> ortools.sat.python <span class="im">import</span> cp_model</span>
-<span id="cb10-33"><a href="#cb10-33" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb10-34"><a href="#cb10-34" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb10-35"><a href="#cb10-35" aria-hidden="true" tabindex="-1"></a><span class="at">@dataclass</span></span>
-<span id="cb10-36"><a href="#cb10-36" aria-hidden="true" tabindex="-1"></a><span class="kw">class</span> Auswertung:</span>
-<span id="cb10-37"><a href="#cb10-37" aria-hidden="true" tabindex="-1"></a>    <span class="co">&quot;&quot;&quot;Was nach einem CP-SAT-Lauf tatsaechlich feststeht.&quot;&quot;&quot;</span></span>
-<span id="cb10-38"><a href="#cb10-38" aria-hidden="true" tabindex="-1"></a>    status: <span class="bu">str</span></span>
-<span id="cb10-39"><a href="#cb10-39" aria-hidden="true" tabindex="-1"></a>    hat_loesung: <span class="bu">bool</span></span>
-<span id="cb10-40"><a href="#cb10-40" aria-hidden="true" tabindex="-1"></a>    beweisbar_optimal: <span class="bu">bool</span></span>
-<span id="cb10-41"><a href="#cb10-41" aria-hidden="true" tabindex="-1"></a>    zielwert: <span class="bu">float</span> <span class="op">|</span> <span class="va">None</span></span>
-<span id="cb10-42"><a href="#cb10-42" aria-hidden="true" tabindex="-1"></a>    schranke: <span class="bu">float</span> <span class="op">|</span> <span class="va">None</span></span>
-<span id="cb10-43"><a href="#cb10-43" aria-hidden="true" tabindex="-1"></a>    gap: <span class="bu">float</span> <span class="op">|</span> <span class="va">None</span></span>
-<span id="cb10-44"><a href="#cb10-44" aria-hidden="true" tabindex="-1"></a>    empfehlung: <span class="bu">str</span></span>
-<span id="cb10-45"><a href="#cb10-45" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb10-46"><a href="#cb10-46" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb10-47"><a href="#cb10-47" aria-hidden="true" tabindex="-1"></a><span class="kw">def</span> werte_aus(loeser: cp_model.CpSolver, status: <span class="bu">int</span>,</span>
-<span id="cb10-48"><a href="#cb10-48" aria-hidden="true" tabindex="-1"></a>              mit_zielfunktion: <span class="bu">bool</span>) <span class="op">-&gt;</span> Auswertung:</span>
-<span id="cb10-49"><a href="#cb10-49" aria-hidden="true" tabindex="-1"></a>    <span class="co">&quot;&quot;&quot;Uebersetzt einen CP-SAT-Status in eine Handlungsempfehlung.</span></span>
-<span id="cb10-50"><a href="#cb10-50" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb10-51"><a href="#cb10-51" aria-hidden="true" tabindex="-1"></a><span class="co">    Genau diese Funktion fehlt in den meisten Projekten. Sie ist kurz, aber</span></span>
-<span id="cb10-52"><a href="#cb10-52" aria-hidden="true" tabindex="-1"></a><span class="co">    sie ist der Unterschied zwischen einem Prototyp und einem System, das</span></span>
-<span id="cb10-53"><a href="#cb10-53" aria-hidden="true" tabindex="-1"></a><span class="co">    nachts ohne Aufsicht laeuft.</span></span>
-<span id="cb10-54"><a href="#cb10-54" aria-hidden="true" tabindex="-1"></a><span class="co">    &quot;&quot;&quot;</span></span>
-<span id="cb10-55"><a href="#cb10-55" aria-hidden="true" tabindex="-1"></a>    name <span class="op">=</span> loeser.StatusName(status)</span>
-<span id="cb10-56"><a href="#cb10-56" aria-hidden="true" tabindex="-1"></a>    hat_loesung <span class="op">=</span> status <span class="kw">in</span> (cp_model.OPTIMAL, cp_model.FEASIBLE)</span>
-<span id="cb10-57"><a href="#cb10-57" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb10-58"><a href="#cb10-58" aria-hidden="true" tabindex="-1"></a>    zielwert <span class="op">=</span> schranke <span class="op">=</span> gap <span class="op">=</span> <span class="va">None</span></span>
-<span id="cb10-59"><a href="#cb10-59" aria-hidden="true" tabindex="-1"></a>    <span class="cf">if</span> hat_loesung <span class="kw">and</span> mit_zielfunktion:</span>
-<span id="cb10-60"><a href="#cb10-60" aria-hidden="true" tabindex="-1"></a>        zielwert <span class="op">=</span> loeser.ObjectiveValue()</span>
-<span id="cb10-61"><a href="#cb10-61" aria-hidden="true" tabindex="-1"></a>        schranke <span class="op">=</span> loeser.BestObjectiveBound()</span>
-<span id="cb10-62"><a href="#cb10-62" aria-hidden="true" tabindex="-1"></a>        nenner <span class="op">=</span> <span class="bu">max</span>(<span class="bu">abs</span>(zielwert), <span class="fl">1e-9</span>)</span>
-<span id="cb10-63"><a href="#cb10-63" aria-hidden="true" tabindex="-1"></a>        gap <span class="op">=</span> <span class="bu">abs</span>(zielwert <span class="op">-</span> schranke) <span class="op">/</span> nenner</span>
-<span id="cb10-64"><a href="#cb10-64" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb10-65"><a href="#cb10-65" aria-hidden="true" tabindex="-1"></a>    <span class="cf">if</span> status <span class="op">==</span> cp_model.OPTIMAL:</span>
-<span id="cb10-66"><a href="#cb10-66" aria-hidden="true" tabindex="-1"></a>        empfehlung <span class="op">=</span> <span class="st">&quot;Ausfuehren. Besser geht es nachweislich nicht.&quot;</span></span>
-<span id="cb10-67"><a href="#cb10-67" aria-hidden="true" tabindex="-1"></a>    <span class="cf">elif</span> status <span class="op">==</span> cp_model.FEASIBLE:</span>
-<span id="cb10-68"><a href="#cb10-68" aria-hidden="true" tabindex="-1"></a>        empfehlung <span class="op">=</span> (<span class="ss">f&quot;Brauchbar. Der Plan ist hoechstens </span><span class="sc">{</span>gap <span class="op">*</span> <span class="dv">100</span><span class="sc">:.2f}</span><span class="ss"> % &quot;</span></span>
-<span id="cb10-69"><a href="#cb10-69" aria-hidden="true" tabindex="-1"></a>                      <span class="ss">f&quot;schlechter als das theoretisch Bestmoegliche.&quot;</span></span>
-<span id="cb10-70"><a href="#cb10-70" aria-hidden="true" tabindex="-1"></a>                      <span class="cf">if</span> gap <span class="kw">is</span> <span class="kw">not</span> <span class="va">None</span> <span class="cf">else</span></span>
-<span id="cb10-71"><a href="#cb10-71" aria-hidden="true" tabindex="-1"></a>                      <span class="st">&quot;Brauchbar, aber nicht als optimal bewiesen.&quot;</span>)</span>
-<span id="cb10-72"><a href="#cb10-72" aria-hidden="true" tabindex="-1"></a>    <span class="cf">elif</span> status <span class="op">==</span> cp_model.INFEASIBLE:</span>
-<span id="cb10-73"><a href="#cb10-73" aria-hidden="true" tabindex="-1"></a>        empfehlung <span class="op">=</span> (<span class="st">&quot;KEIN Plan existiert. Das ist eine Aussage ueber Ihre &quot;</span></span>
-<span id="cb10-74"><a href="#cb10-74" aria-hidden="true" tabindex="-1"></a>                      <span class="st">&quot;harten Regeln, nicht ueber die Rechenzeit: Auch &quot;</span></span>
-<span id="cb10-75"><a href="#cb10-75" aria-hidden="true" tabindex="-1"></a>                      <span class="st">&quot;unendlich viel Zeit wuerde nichts aendern. Regeln &quot;</span></span>
-<span id="cb10-76"><a href="#cb10-76" aria-hidden="true" tabindex="-1"></a>                      <span class="st">&quot;lockern oder weich machen (Anhang C).&quot;</span>)</span>
-<span id="cb10-77"><a href="#cb10-77" aria-hidden="true" tabindex="-1"></a>    <span class="cf">elif</span> status <span class="op">==</span> cp_model.MODEL_INVALID:</span>
-<span id="cb10-78"><a href="#cb10-78" aria-hidden="true" tabindex="-1"></a>        empfehlung <span class="op">=</span> (<span class="st">&quot;Das MODELL ist fehlerhaft, nicht das Problem. &quot;</span></span>
-<span id="cb10-79"><a href="#cb10-79" aria-hidden="true" tabindex="-1"></a>                      <span class="st">&quot;Typisch: eine Variable mit leerem Wertebereich. &quot;</span></span>
-<span id="cb10-80"><a href="#cb10-80" aria-hidden="true" tabindex="-1"></a>                      <span class="st">&quot;model.Validate() nennt die Ursache.&quot;</span>)</span>
-<span id="cb10-81"><a href="#cb10-81" aria-hidden="true" tabindex="-1"></a>    <span class="cf">else</span>:                                    <span class="co"># UNKNOWN</span></span>
-<span id="cb10-82"><a href="#cb10-82" aria-hidden="true" tabindex="-1"></a>        empfehlung <span class="op">=</span> (<span class="st">&quot;Nichts gefunden - aber auch nicht widerlegt. Mehr Zeit &quot;</span></span>
-<span id="cb10-83"><a href="#cb10-83" aria-hidden="true" tabindex="-1"></a>                      <span class="st">&quot;geben, das Modell vereinfachen oder mit einer &quot;</span></span>
-<span id="cb10-84"><a href="#cb10-84" aria-hidden="true" tabindex="-1"></a>                      <span class="st">&quot;Heuristik vorbelegen (AddHint).&quot;</span>)</span>
-<span id="cb10-85"><a href="#cb10-85" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb10-86"><a href="#cb10-86" aria-hidden="true" tabindex="-1"></a>    <span class="cf">return</span> Auswertung(</span>
-<span id="cb10-87"><a href="#cb10-87" aria-hidden="true" tabindex="-1"></a>        status<span class="op">=</span>name,</span>
-<span id="cb10-88"><a href="#cb10-88" aria-hidden="true" tabindex="-1"></a>        hat_loesung<span class="op">=</span>hat_loesung,</span>
-<span id="cb10-89"><a href="#cb10-89" aria-hidden="true" tabindex="-1"></a>        beweisbar_optimal<span class="op">=</span>status <span class="op">==</span> cp_model.OPTIMAL,</span>
-<span id="cb10-90"><a href="#cb10-90" aria-hidden="true" tabindex="-1"></a>        zielwert<span class="op">=</span>zielwert, schranke<span class="op">=</span>schranke, gap<span class="op">=</span>gap,</span>
-<span id="cb10-91"><a href="#cb10-91" aria-hidden="true" tabindex="-1"></a>        empfehlung<span class="op">=</span>empfehlung,</span>
-<span id="cb10-92"><a href="#cb10-92" aria-hidden="true" tabindex="-1"></a>    )</span>
-<span id="cb10-93"><a href="#cb10-93" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb10-94"><a href="#cb10-94" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb10-95"><a href="#cb10-95" aria-hidden="true" tabindex="-1"></a><span class="kw">def</span> loese(baue, zeitlimit: <span class="bu">float</span>, mit_zielfunktion: <span class="bu">bool</span>) <span class="op">-&gt;</span> Auswertung:</span>
-<span id="cb10-96"><a href="#cb10-96" aria-hidden="true" tabindex="-1"></a>    modell <span class="op">=</span> cp_model.CpModel()</span>
-<span id="cb10-97"><a href="#cb10-97" aria-hidden="true" tabindex="-1"></a>    baue(modell)</span>
-<span id="cb10-98"><a href="#cb10-98" aria-hidden="true" tabindex="-1"></a>    loeser <span class="op">=</span> cp_model.CpSolver()</span>
-<span id="cb10-99"><a href="#cb10-99" aria-hidden="true" tabindex="-1"></a>    loeser.parameters.max_time_in_seconds <span class="op">=</span> zeitlimit</span>
-<span id="cb10-100"><a href="#cb10-100" aria-hidden="true" tabindex="-1"></a>    <span class="co"># Fuer reproduzierbare Buchausgaben; im Betrieb weglassen.</span></span>
-<span id="cb10-101"><a href="#cb10-101" aria-hidden="true" tabindex="-1"></a>    loeser.parameters.num_workers <span class="op">=</span> <span class="dv">1</span></span>
-<span id="cb10-102"><a href="#cb10-102" aria-hidden="true" tabindex="-1"></a>    loeser.parameters.random_seed <span class="op">=</span> <span class="dv">1</span></span>
-<span id="cb10-103"><a href="#cb10-103" aria-hidden="true" tabindex="-1"></a>    status <span class="op">=</span> loeser.Solve(modell)</span>
-<span id="cb10-104"><a href="#cb10-104" aria-hidden="true" tabindex="-1"></a>    <span class="cf">return</span> werte_aus(loeser, status, mit_zielfunktion)</span>
-<span id="cb10-105"><a href="#cb10-105" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb10-106"><a href="#cb10-106" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb10-107"><a href="#cb10-107" aria-hidden="true" tabindex="-1"></a><span class="co"># --- Die fuenf Faelle --------------------------------------------------------</span></span>
-<span id="cb10-108"><a href="#cb10-108" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb10-109"><a href="#cb10-109" aria-hidden="true" tabindex="-1"></a><span class="kw">def</span> dienstplan_loesbar(modell: cp_model.CpModel) <span class="op">-&gt;</span> <span class="va">None</span>:</span>
-<span id="cb10-110"><a href="#cb10-110" aria-hidden="true" tabindex="-1"></a>    <span class="co">&quot;&quot;&quot;Vier Personen, fuenf Dienste, hoechstens zwei je Person - loesbar.&quot;&quot;&quot;</span></span>
-<span id="cb10-111"><a href="#cb10-111" aria-hidden="true" tabindex="-1"></a>    personen, dienste <span class="op">=</span> <span class="dv">4</span>, <span class="dv">5</span></span>
-<span id="cb10-112"><a href="#cb10-112" aria-hidden="true" tabindex="-1"></a>    x <span class="op">=</span> [[modell.NewBoolVar(<span class="ss">f&quot;x_</span><span class="sc">{</span>i<span class="sc">}</span><span class="ss">_</span><span class="sc">{</span>j<span class="sc">}</span><span class="ss">&quot;</span>) <span class="cf">for</span> j <span class="kw">in</span> <span class="bu">range</span>(dienste)]</span>
-<span id="cb10-113"><a href="#cb10-113" aria-hidden="true" tabindex="-1"></a>         <span class="cf">for</span> i <span class="kw">in</span> <span class="bu">range</span>(personen)]</span>
-<span id="cb10-114"><a href="#cb10-114" aria-hidden="true" tabindex="-1"></a>    <span class="cf">for</span> j <span class="kw">in</span> <span class="bu">range</span>(dienste):</span>
-<span id="cb10-115"><a href="#cb10-115" aria-hidden="true" tabindex="-1"></a>        modell.AddExactlyOne(x[i][j] <span class="cf">for</span> i <span class="kw">in</span> <span class="bu">range</span>(personen))</span>
-<span id="cb10-116"><a href="#cb10-116" aria-hidden="true" tabindex="-1"></a>    <span class="cf">for</span> i <span class="kw">in</span> <span class="bu">range</span>(personen):</span>
-<span id="cb10-117"><a href="#cb10-117" aria-hidden="true" tabindex="-1"></a>        modell.Add(<span class="bu">sum</span>(x[i]) <span class="op">&lt;=</span> <span class="dv">2</span>)</span>
-<span id="cb10-118"><a href="#cb10-118" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb10-119"><a href="#cb10-119" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb10-120"><a href="#cb10-120" aria-hidden="true" tabindex="-1"></a><span class="kw">def</span> dienstplan_unloesbar(modell: cp_model.CpModel) <span class="op">-&gt;</span> <span class="va">None</span>:</span>
-<span id="cb10-121"><a href="#cb10-121" aria-hidden="true" tabindex="-1"></a>    <span class="co">&quot;&quot;&quot;Dieselben fuenf Dienste, aber hoechstens EIN Dienst je Person.</span></span>
-<span id="cb10-122"><a href="#cb10-122" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb10-123"><a href="#cb10-123" aria-hidden="true" tabindex="-1"></a><span class="co">    Vier Personen koennen zusammen hoechstens vier Dienste uebernehmen - fuer</span></span>
-<span id="cb10-124"><a href="#cb10-124" aria-hidden="true" tabindex="-1"></a><span class="co">    fuenf Dienste reicht das nicht. Kein Solver der Welt findet hier etwas.</span></span>
-<span id="cb10-125"><a href="#cb10-125" aria-hidden="true" tabindex="-1"></a><span class="co">    &quot;&quot;&quot;</span></span>
-<span id="cb10-126"><a href="#cb10-126" aria-hidden="true" tabindex="-1"></a>    personen, dienste <span class="op">=</span> <span class="dv">4</span>, <span class="dv">5</span></span>
-<span id="cb10-127"><a href="#cb10-127" aria-hidden="true" tabindex="-1"></a>    x <span class="op">=</span> [[modell.NewBoolVar(<span class="ss">f&quot;x_</span><span class="sc">{</span>i<span class="sc">}</span><span class="ss">_</span><span class="sc">{</span>j<span class="sc">}</span><span class="ss">&quot;</span>) <span class="cf">for</span> j <span class="kw">in</span> <span class="bu">range</span>(dienste)]</span>
-<span id="cb10-128"><a href="#cb10-128" aria-hidden="true" tabindex="-1"></a>         <span class="cf">for</span> i <span class="kw">in</span> <span class="bu">range</span>(personen)]</span>
-<span id="cb10-129"><a href="#cb10-129" aria-hidden="true" tabindex="-1"></a>    <span class="cf">for</span> j <span class="kw">in</span> <span class="bu">range</span>(dienste):</span>
-<span id="cb10-130"><a href="#cb10-130" aria-hidden="true" tabindex="-1"></a>        modell.AddExactlyOne(x[i][j] <span class="cf">for</span> i <span class="kw">in</span> <span class="bu">range</span>(personen))</span>
-<span id="cb10-131"><a href="#cb10-131" aria-hidden="true" tabindex="-1"></a>    <span class="cf">for</span> i <span class="kw">in</span> <span class="bu">range</span>(personen):</span>
-<span id="cb10-132"><a href="#cb10-132" aria-hidden="true" tabindex="-1"></a>        modell.Add(<span class="bu">sum</span>(x[i]) <span class="op">&lt;=</span> <span class="dv">1</span>)</span>
-<span id="cb10-133"><a href="#cb10-133" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb10-134"><a href="#cb10-134" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb10-135"><a href="#cb10-135" aria-hidden="true" tabindex="-1"></a><span class="kw">def</span> modell_fehlerhaft(modell: cp_model.CpModel) <span class="op">-&gt;</span> <span class="va">None</span>:</span>
-<span id="cb10-136"><a href="#cb10-136" aria-hidden="true" tabindex="-1"></a>    <span class="co">&quot;&quot;&quot;Eine Variable mit leerem Wertebereich: untere Schranke &gt; obere.</span></span>
-<span id="cb10-137"><a href="#cb10-137" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb10-138"><a href="#cb10-138" aria-hidden="true" tabindex="-1"></a><span class="co">    Im Alltag entsteht das durch einen Rechenfehler in den Grenzen, etwa</span></span>
-<span id="cb10-139"><a href="#cb10-139" aria-hidden="true" tabindex="-1"></a><span class="co">    NewIntVar(mindestbesetzung, kapazitaet, ...) bei falsch sortierten Daten.</span></span>
-<span id="cb10-140"><a href="#cb10-140" aria-hidden="true" tabindex="-1"></a><span class="co">    &quot;&quot;&quot;</span></span>
-<span id="cb10-141"><a href="#cb10-141" aria-hidden="true" tabindex="-1"></a>    kaputt <span class="op">=</span> modell.NewIntVar(<span class="dv">5</span>, <span class="dv">2</span>, <span class="st">&quot;leerer_bereich&quot;</span>)</span>
-<span id="cb10-142"><a href="#cb10-142" aria-hidden="true" tabindex="-1"></a>    modell.Add(kaputt <span class="op">&gt;=</span> <span class="dv">0</span>)</span>
-<span id="cb10-143"><a href="#cb10-143" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb10-144"><a href="#cb10-144" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb10-145"><a href="#cb10-145" aria-hidden="true" tabindex="-1"></a><span class="kw">def</span> lastverteilung(modell: cp_model.CpModel) <span class="op">-&gt;</span> <span class="va">None</span>:</span>
-<span id="cb10-146"><a href="#cb10-146" aria-hidden="true" tabindex="-1"></a>    <span class="co">&quot;&quot;&quot;120 Auftraege auf 11 Maschinen - gross genug, dass der Optimalitaets-</span></span>
-<span id="cb10-147"><a href="#cb10-147" aria-hidden="true" tabindex="-1"></a><span class="co">    beweis laenger dauert als das Finden einer sehr guten Loesung.&quot;&quot;&quot;</span></span>
-<span id="cb10-148"><a href="#cb10-148" aria-hidden="true" tabindex="-1"></a>    rng <span class="op">=</span> np.random.default_rng(<span class="dv">3</span>)</span>
-<span id="cb10-149"><a href="#cb10-149" aria-hidden="true" tabindex="-1"></a>    dauer <span class="op">=</span> rng.integers(<span class="dv">100</span>, <span class="dv">9000</span>, <span class="dv">120</span>)</span>
-<span id="cb10-150"><a href="#cb10-150" aria-hidden="true" tabindex="-1"></a>    n, maschinen <span class="op">=</span> <span class="bu">len</span>(dauer), <span class="dv">11</span></span>
-<span id="cb10-151"><a href="#cb10-151" aria-hidden="true" tabindex="-1"></a>    obergrenze <span class="op">=</span> <span class="bu">int</span>(dauer.<span class="bu">sum</span>())</span>
-<span id="cb10-152"><a href="#cb10-152" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb10-153"><a href="#cb10-153" aria-hidden="true" tabindex="-1"></a>    x <span class="op">=</span> [[modell.NewBoolVar(<span class="ss">f&quot;x_</span><span class="sc">{</span>i<span class="sc">}</span><span class="ss">_</span><span class="sc">{</span>k<span class="sc">}</span><span class="ss">&quot;</span>) <span class="cf">for</span> k <span class="kw">in</span> <span class="bu">range</span>(maschinen)]</span>
-<span id="cb10-154"><a href="#cb10-154" aria-hidden="true" tabindex="-1"></a>         <span class="cf">for</span> i <span class="kw">in</span> <span class="bu">range</span>(n)]</span>
-<span id="cb10-155"><a href="#cb10-155" aria-hidden="true" tabindex="-1"></a>    <span class="cf">for</span> i <span class="kw">in</span> <span class="bu">range</span>(n):</span>
-<span id="cb10-156"><a href="#cb10-156" aria-hidden="true" tabindex="-1"></a>        modell.AddExactlyOne(x[i])</span>
-<span id="cb10-157"><a href="#cb10-157" aria-hidden="true" tabindex="-1"></a>    belegung <span class="op">=</span> [modell.NewIntVar(<span class="dv">0</span>, obergrenze, <span class="ss">f&quot;l_</span><span class="sc">{</span>k<span class="sc">}</span><span class="ss">&quot;</span>) <span class="cf">for</span> k <span class="kw">in</span> <span class="bu">range</span>(maschinen)]</span>
-<span id="cb10-158"><a href="#cb10-158" aria-hidden="true" tabindex="-1"></a>    <span class="cf">for</span> k <span class="kw">in</span> <span class="bu">range</span>(maschinen):</span>
-<span id="cb10-159"><a href="#cb10-159" aria-hidden="true" tabindex="-1"></a>        modell.Add(belegung[k] <span class="op">==</span> <span class="bu">sum</span>(<span class="bu">int</span>(dauer[i]) <span class="op">*</span> x[i][k] <span class="cf">for</span> i <span class="kw">in</span> <span class="bu">range</span>(n)))</span>
-<span id="cb10-160"><a href="#cb10-160" aria-hidden="true" tabindex="-1"></a>    makespan <span class="op">=</span> modell.NewIntVar(<span class="dv">0</span>, obergrenze, <span class="st">&quot;makespan&quot;</span>)</span>
-<span id="cb10-161"><a href="#cb10-161" aria-hidden="true" tabindex="-1"></a>    modell.AddMaxEquality(makespan, belegung)</span>
-<span id="cb10-162"><a href="#cb10-162" aria-hidden="true" tabindex="-1"></a>    modell.Minimize(makespan)</span>
-<span id="cb10-163"><a href="#cb10-163" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb10-164"><a href="#cb10-164" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb10-165"><a href="#cb10-165" aria-hidden="true" tabindex="-1"></a><span class="kw">def</span> zahlpartition(modell: cp_model.CpModel) <span class="op">-&gt;</span> <span class="va">None</span>:</span>
-<span id="cb10-166"><a href="#cb10-166" aria-hidden="true" tabindex="-1"></a>    <span class="co">&quot;&quot;&quot;46 grosse Zahlen exakt in zwei gleich schwere Haelften teilen.</span></span>
-<span id="cb10-167"><a href="#cb10-167" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb10-168"><a href="#cb10-168" aria-hidden="true" tabindex="-1"></a><span class="co">    Ein beruehmt schweres Problem: Es gibt keine Zielfunktion, entweder es</span></span>
-<span id="cb10-169"><a href="#cb10-169" aria-hidden="true" tabindex="-1"></a><span class="co">    geht auf oder nicht - und beides zu entscheiden dauert lange.</span></span>
-<span id="cb10-170"><a href="#cb10-170" aria-hidden="true" tabindex="-1"></a><span class="co">    &quot;&quot;&quot;</span></span>
-<span id="cb10-171"><a href="#cb10-171" aria-hidden="true" tabindex="-1"></a>    rng <span class="op">=</span> np.random.default_rng(<span class="dv">1</span>)</span>
-<span id="cb10-172"><a href="#cb10-172" aria-hidden="true" tabindex="-1"></a>    gewichte <span class="op">=</span> rng.integers(<span class="dv">10</span><span class="op">**</span><span class="dv">6</span>, <span class="dv">2</span> <span class="op">*</span> <span class="dv">10</span><span class="op">**</span><span class="dv">6</span>, <span class="dv">46</span>)</span>
-<span id="cb10-173"><a href="#cb10-173" aria-hidden="true" tabindex="-1"></a>    x <span class="op">=</span> [modell.NewBoolVar(<span class="ss">f&quot;x_</span><span class="sc">{</span>i<span class="sc">}</span><span class="ss">&quot;</span>) <span class="cf">for</span> i <span class="kw">in</span> <span class="bu">range</span>(<span class="bu">len</span>(gewichte))]</span>
-<span id="cb10-174"><a href="#cb10-174" aria-hidden="true" tabindex="-1"></a>    modell.Add(<span class="bu">sum</span>(<span class="bu">int</span>(gewichte[i]) <span class="op">*</span> x[i] <span class="cf">for</span> i <span class="kw">in</span> <span class="bu">range</span>(<span class="bu">len</span>(gewichte)))</span>
-<span id="cb10-175"><a href="#cb10-175" aria-hidden="true" tabindex="-1"></a>               <span class="op">==</span> <span class="bu">int</span>(gewichte.<span class="bu">sum</span>() <span class="op">//</span> <span class="dv">2</span>))</span>
-<span id="cb10-176"><a href="#cb10-176" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb10-177"><a href="#cb10-177" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb10-178"><a href="#cb10-178" aria-hidden="true" tabindex="-1"></a><span class="kw">def</span> zeige(titel: <span class="bu">str</span>, a: Auswertung) <span class="op">-&gt;</span> <span class="va">None</span>:</span>
-<span id="cb10-179"><a href="#cb10-179" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;</span><span class="ch">\n</span><span class="sc">{</span>titel<span class="sc">}</span><span class="ss">&quot;</span>)</span>
-<span id="cb10-180"><a href="#cb10-180" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;  Status               </span><span class="sc">{</span>a<span class="sc">.</span>status<span class="sc">}</span><span class="ss">&quot;</span>)</span>
-<span id="cb10-181"><a href="#cb10-181" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;  Loesung vorhanden    </span><span class="sc">{</span><span class="st">&#39;ja&#39;</span> <span class="cf">if</span> a<span class="sc">.</span>hat_loesung <span class="cf">else</span> <span class="st">&#39;nein&#39;</span><span class="sc">}</span><span class="ss">&quot;</span>)</span>
-<span id="cb10-182"><a href="#cb10-182" aria-hidden="true" tabindex="-1"></a>    <span class="cf">if</span> a.zielwert <span class="kw">is</span> <span class="kw">not</span> <span class="va">None</span>:</span>
-<span id="cb10-183"><a href="#cb10-183" aria-hidden="true" tabindex="-1"></a>        <span class="bu">print</span>(<span class="ss">f&quot;  Zielwert / Schranke  </span><span class="sc">{</span>a<span class="sc">.</span>zielwert<span class="sc">:,.0f}</span><span class="ss"> / </span><span class="sc">{</span>a<span class="sc">.</span>schranke<span class="sc">:,.0f}</span><span class="ss">&quot;</span></span>
-<span id="cb10-184"><a href="#cb10-184" aria-hidden="true" tabindex="-1"></a>              <span class="ss">f&quot;   (Gap </span><span class="sc">{</span>a<span class="sc">.</span>gap <span class="op">*</span> <span class="dv">100</span><span class="sc">:.3f}</span><span class="ss"> %)&quot;</span>)</span>
-<span id="cb10-185"><a href="#cb10-185" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;  -&gt; </span><span class="sc">{</span>a<span class="sc">.</span>empfehlung<span class="sc">}</span><span class="ss">&quot;</span>)</span>
-<span id="cb10-186"><a href="#cb10-186" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb10-187"><a href="#cb10-187" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb10-188"><a href="#cb10-188" aria-hidden="true" tabindex="-1"></a><span class="cf">if</span> <span class="va">__name__</span> <span class="op">==</span> <span class="st">&quot;__main__&quot;</span>:</span>
-<span id="cb10-189"><a href="#cb10-189" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;=&quot;</span> <span class="op">*</span> <span class="dv">78</span>)</span>
-<span id="cb10-190"><a href="#cb10-190" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;  DIE FUENF ANTWORTEN VON CP-SAT&quot;</span>)</span>
-<span id="cb10-191"><a href="#cb10-191" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;=&quot;</span> <span class="op">*</span> <span class="dv">78</span>)</span>
-<span id="cb10-192"><a href="#cb10-192" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb10-193"><a href="#cb10-193" aria-hidden="true" tabindex="-1"></a>    zeige(<span class="st">&quot;[1] Dienstplan, hoechstens 2 Dienste je Person&quot;</span>,</span>
-<span id="cb10-194"><a href="#cb10-194" aria-hidden="true" tabindex="-1"></a>          loese(dienstplan_loesbar, <span class="fl">10.0</span>, mit_zielfunktion<span class="op">=</span><span class="va">False</span>))</span>
-<span id="cb10-195"><a href="#cb10-195" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb10-196"><a href="#cb10-196" aria-hidden="true" tabindex="-1"></a>    zeige(<span class="st">&quot;[2] Lastverteilung 120 Auftraege / 11 Maschinen, 0,5 s Limit&quot;</span>,</span>
-<span id="cb10-197"><a href="#cb10-197" aria-hidden="true" tabindex="-1"></a>          loese(lastverteilung, <span class="fl">0.5</span>, mit_zielfunktion<span class="op">=</span><span class="va">True</span>))</span>
-<span id="cb10-198"><a href="#cb10-198" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb10-199"><a href="#cb10-199" aria-hidden="true" tabindex="-1"></a>    zeige(<span class="st">&quot;[3] Derselbe Fall mit 10 s Limit&quot;</span>,</span>
-<span id="cb10-200"><a href="#cb10-200" aria-hidden="true" tabindex="-1"></a>          loese(lastverteilung, <span class="fl">10.0</span>, mit_zielfunktion<span class="op">=</span><span class="va">True</span>))</span>
-<span id="cb10-201"><a href="#cb10-201" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb10-202"><a href="#cb10-202" aria-hidden="true" tabindex="-1"></a>    zeige(<span class="st">&quot;[4] Dienstplan, hoechstens 1 Dienst je Person&quot;</span>,</span>
-<span id="cb10-203"><a href="#cb10-203" aria-hidden="true" tabindex="-1"></a>          loese(dienstplan_unloesbar, <span class="fl">10.0</span>, mit_zielfunktion<span class="op">=</span><span class="va">False</span>))</span>
-<span id="cb10-204"><a href="#cb10-204" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb10-205"><a href="#cb10-205" aria-hidden="true" tabindex="-1"></a>    zeige(<span class="st">&quot;[5] Variable mit leerem Wertebereich&quot;</span>,</span>
-<span id="cb10-206"><a href="#cb10-206" aria-hidden="true" tabindex="-1"></a>          loese(modell_fehlerhaft, <span class="fl">10.0</span>, mit_zielfunktion<span class="op">=</span><span class="va">False</span>))</span>
-<span id="cb10-207"><a href="#cb10-207" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb10-208"><a href="#cb10-208" aria-hidden="true" tabindex="-1"></a>    zeige(<span class="st">&quot;[6] Zahlpartition mit 46 grossen Zahlen, 2 s Limit&quot;</span>,</span>
-<span id="cb10-209"><a href="#cb10-209" aria-hidden="true" tabindex="-1"></a>          loese(zahlpartition, <span class="fl">2.0</span>, mit_zielfunktion<span class="op">=</span><span class="va">False</span>))</span>
-<span id="cb10-210"><a href="#cb10-210" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb10-211"><a href="#cb10-211" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;</span><span class="ch">\n</span><span class="st">&quot;</span> <span class="op">+</span> <span class="st">&quot;=&quot;</span> <span class="op">*</span> <span class="dv">78</span>)</span>
-<span id="cb10-212"><a href="#cb10-212" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;  DIE DREI, DIE MAN NICHT VERWECHSELN DARF&quot;</span>)</span>
-<span id="cb10-213"><a href="#cb10-213" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;=&quot;</span> <span class="op">*</span> <span class="dv">78</span>)</span>
-<span id="cb10-214"><a href="#cb10-214" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;INFEASIBLE  Es gibt keine Loesung. Eine Aussage ueber Ihr MODELL.&quot;</span>)</span>
-<span id="cb10-215"><a href="#cb10-215" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;            Mehr Rechenzeit aendert daran nichts.&quot;</span>)</span>
-<span id="cb10-216"><a href="#cb10-216" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;UNKNOWN     Es wurde keine gefunden. Eine Aussage ueber die ZEIT.&quot;</span>)</span>
-<span id="cb10-217"><a href="#cb10-217" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;            Ob es eine gibt, ist offen.&quot;</span>)</span>
-<span id="cb10-218"><a href="#cb10-218" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;MODEL_INVALID  Das Modell ist gar kein gueltiges Modell. Eine&quot;</span>)</span>
-<span id="cb10-219"><a href="#cb10-219" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;            Aussage ueber Ihren CODE - immer ein Programmierfehler.&quot;</span>)</span>
-<span id="cb10-220"><a href="#cb10-220" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>()</span>
-<span id="cb10-221"><a href="#cb10-221" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;Wer diese drei in einem &#39;else: return None&#39; zusammenfasst, verliert&quot;</span>)</span>
-<span id="cb10-222"><a href="#cb10-222" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;genau die Information, die zur Fehlersuche noetig waere.&quot;</span>)</span>
-<span id="cb10-223"><a href="#cb10-223" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;=&quot;</span> <span class="op">*</span> <span class="dv">78</span>)</span></code></pre></div>
+<div class="sourceCode" id="cb12"><pre class="sourceCode python"><code class="sourceCode python"><span id="cb12-1"><a href="#cb12-1" aria-hidden="true" tabindex="-1"></a><span class="co">#!/usr/bin/env python3</span></span>
+<span id="cb12-2"><a href="#cb12-2" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb12-3"><a href="#cb12-3" aria-hidden="true" tabindex="-1"></a><span class="co"># CP_SAT_Statusfaelle.py</span></span>
+<span id="cb12-4"><a href="#cb12-4" aria-hidden="true" tabindex="-1"></a><span class="co">&quot;&quot;&quot;</span></span>
+<span id="cb12-5"><a href="#cb12-5" aria-hidden="true" tabindex="-1"></a><span class="co">Kapitel CP-SAT: Alle fuenf Antworten von CP-SAT - und was jede bedeutet.</span></span>
+<span id="cb12-6"><a href="#cb12-6" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb12-7"><a href="#cb12-7" aria-hidden="true" tabindex="-1"></a><span class="co">Der haeufigste Fehler beim Einsatz von CP-SAT im Betrieb ist eine Zeile wie</span></span>
+<span id="cb12-8"><a href="#cb12-8" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb12-9"><a href="#cb12-9" aria-hidden="true" tabindex="-1"></a><span class="co">    if status == cp_model.OPTIMAL:</span></span>
+<span id="cb12-10"><a href="#cb12-10" aria-hidden="true" tabindex="-1"></a><span class="co">        ...verwerte die Loesung...</span></span>
+<span id="cb12-11"><a href="#cb12-11" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb12-12"><a href="#cb12-12" aria-hidden="true" tabindex="-1"></a><span class="co">Sie wirft in drei von fuenf Faellen etwas weg, das man haette gebrauchen</span></span>
+<span id="cb12-13"><a href="#cb12-13" aria-hidden="true" tabindex="-1"></a><span class="co">koennen, und verschweigt in einem weiteren Fall einen Modellierungsfehler.</span></span>
+<span id="cb12-14"><a href="#cb12-14" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb12-15"><a href="#cb12-15" aria-hidden="true" tabindex="-1"></a><span class="co">Dieses Programm erzeugt jeden Statusfall absichtlich und zeigt die passende</span></span>
+<span id="cb12-16"><a href="#cb12-16" aria-hidden="true" tabindex="-1"></a><span class="co">Reaktion:</span></span>
+<span id="cb12-17"><a href="#cb12-17" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb12-18"><a href="#cb12-18" aria-hidden="true" tabindex="-1"></a><span class="co">    OPTIMAL        beweisbar bestmoeglich          -&gt; ausfuehren</span></span>
+<span id="cb12-19"><a href="#cb12-19" aria-hidden="true" tabindex="-1"></a><span class="co">    FEASIBLE       zulaessig, Zeit war um          -&gt; Gap pruefen, dann entscheiden</span></span>
+<span id="cb12-20"><a href="#cb12-20" aria-hidden="true" tabindex="-1"></a><span class="co">    INFEASIBLE     kein Plan existiert             -&gt; harte Regeln lockern</span></span>
+<span id="cb12-21"><a href="#cb12-21" aria-hidden="true" tabindex="-1"></a><span class="co">    MODEL_INVALID  das Modell ist fehlerhaft       -&gt; Programmierfehler beheben</span></span>
+<span id="cb12-22"><a href="#cb12-22" aria-hidden="true" tabindex="-1"></a><span class="co">    UNKNOWN        nichts gefunden, Zeit war um    -&gt; mehr Zeit oder Heuristik</span></span>
+<span id="cb12-23"><a href="#cb12-23" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb12-24"><a href="#cb12-24" aria-hidden="true" tabindex="-1"></a><span class="co">Benoetigt: numpy, ortools</span></span>
+<span id="cb12-25"><a href="#cb12-25" aria-hidden="true" tabindex="-1"></a><span class="co">&quot;&quot;&quot;</span></span>
+<span id="cb12-26"><a href="#cb12-26" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb12-27"><a href="#cb12-27" aria-hidden="true" tabindex="-1"></a><span class="im">from</span> __future__ <span class="im">import</span> annotations</span>
+<span id="cb12-28"><a href="#cb12-28" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb12-29"><a href="#cb12-29" aria-hidden="true" tabindex="-1"></a><span class="im">from</span> dataclasses <span class="im">import</span> dataclass</span>
+<span id="cb12-30"><a href="#cb12-30" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb12-31"><a href="#cb12-31" aria-hidden="true" tabindex="-1"></a><span class="im">import</span> numpy <span class="im">as</span> np</span>
+<span id="cb12-32"><a href="#cb12-32" aria-hidden="true" tabindex="-1"></a><span class="im">from</span> ortools.sat.python <span class="im">import</span> cp_model</span>
+<span id="cb12-33"><a href="#cb12-33" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb12-34"><a href="#cb12-34" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb12-35"><a href="#cb12-35" aria-hidden="true" tabindex="-1"></a><span class="at">@dataclass</span></span>
+<span id="cb12-36"><a href="#cb12-36" aria-hidden="true" tabindex="-1"></a><span class="kw">class</span> Auswertung:</span>
+<span id="cb12-37"><a href="#cb12-37" aria-hidden="true" tabindex="-1"></a>    <span class="co">&quot;&quot;&quot;Was nach einem CP-SAT-Lauf tatsaechlich feststeht.&quot;&quot;&quot;</span></span>
+<span id="cb12-38"><a href="#cb12-38" aria-hidden="true" tabindex="-1"></a>    status: <span class="bu">str</span></span>
+<span id="cb12-39"><a href="#cb12-39" aria-hidden="true" tabindex="-1"></a>    hat_loesung: <span class="bu">bool</span></span>
+<span id="cb12-40"><a href="#cb12-40" aria-hidden="true" tabindex="-1"></a>    beweisbar_optimal: <span class="bu">bool</span></span>
+<span id="cb12-41"><a href="#cb12-41" aria-hidden="true" tabindex="-1"></a>    zielwert: <span class="bu">float</span> <span class="op">|</span> <span class="va">None</span></span>
+<span id="cb12-42"><a href="#cb12-42" aria-hidden="true" tabindex="-1"></a>    schranke: <span class="bu">float</span> <span class="op">|</span> <span class="va">None</span></span>
+<span id="cb12-43"><a href="#cb12-43" aria-hidden="true" tabindex="-1"></a>    gap: <span class="bu">float</span> <span class="op">|</span> <span class="va">None</span></span>
+<span id="cb12-44"><a href="#cb12-44" aria-hidden="true" tabindex="-1"></a>    empfehlung: <span class="bu">str</span></span>
+<span id="cb12-45"><a href="#cb12-45" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb12-46"><a href="#cb12-46" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb12-47"><a href="#cb12-47" aria-hidden="true" tabindex="-1"></a><span class="kw">def</span> werte_aus(loeser: cp_model.CpSolver, status: <span class="bu">int</span>,</span>
+<span id="cb12-48"><a href="#cb12-48" aria-hidden="true" tabindex="-1"></a>              mit_zielfunktion: <span class="bu">bool</span>) <span class="op">-&gt;</span> Auswertung:</span>
+<span id="cb12-49"><a href="#cb12-49" aria-hidden="true" tabindex="-1"></a>    <span class="co">&quot;&quot;&quot;Uebersetzt einen CP-SAT-Status in eine Handlungsempfehlung.</span></span>
+<span id="cb12-50"><a href="#cb12-50" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb12-51"><a href="#cb12-51" aria-hidden="true" tabindex="-1"></a><span class="co">    Genau diese Funktion fehlt in den meisten Projekten. Sie ist kurz, aber</span></span>
+<span id="cb12-52"><a href="#cb12-52" aria-hidden="true" tabindex="-1"></a><span class="co">    sie ist der Unterschied zwischen einem Prototyp und einem System, das</span></span>
+<span id="cb12-53"><a href="#cb12-53" aria-hidden="true" tabindex="-1"></a><span class="co">    nachts ohne Aufsicht laeuft.</span></span>
+<span id="cb12-54"><a href="#cb12-54" aria-hidden="true" tabindex="-1"></a><span class="co">    &quot;&quot;&quot;</span></span>
+<span id="cb12-55"><a href="#cb12-55" aria-hidden="true" tabindex="-1"></a>    name <span class="op">=</span> loeser.StatusName(status)</span>
+<span id="cb12-56"><a href="#cb12-56" aria-hidden="true" tabindex="-1"></a>    hat_loesung <span class="op">=</span> status <span class="kw">in</span> (cp_model.OPTIMAL, cp_model.FEASIBLE)</span>
+<span id="cb12-57"><a href="#cb12-57" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb12-58"><a href="#cb12-58" aria-hidden="true" tabindex="-1"></a>    zielwert <span class="op">=</span> schranke <span class="op">=</span> gap <span class="op">=</span> <span class="va">None</span></span>
+<span id="cb12-59"><a href="#cb12-59" aria-hidden="true" tabindex="-1"></a>    <span class="cf">if</span> hat_loesung <span class="kw">and</span> mit_zielfunktion:</span>
+<span id="cb12-60"><a href="#cb12-60" aria-hidden="true" tabindex="-1"></a>        zielwert <span class="op">=</span> loeser.ObjectiveValue()</span>
+<span id="cb12-61"><a href="#cb12-61" aria-hidden="true" tabindex="-1"></a>        schranke <span class="op">=</span> loeser.BestObjectiveBound()</span>
+<span id="cb12-62"><a href="#cb12-62" aria-hidden="true" tabindex="-1"></a>        nenner <span class="op">=</span> <span class="bu">max</span>(<span class="bu">abs</span>(zielwert), <span class="fl">1e-9</span>)</span>
+<span id="cb12-63"><a href="#cb12-63" aria-hidden="true" tabindex="-1"></a>        gap <span class="op">=</span> <span class="bu">abs</span>(zielwert <span class="op">-</span> schranke) <span class="op">/</span> nenner</span>
+<span id="cb12-64"><a href="#cb12-64" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb12-65"><a href="#cb12-65" aria-hidden="true" tabindex="-1"></a>    <span class="cf">if</span> status <span class="op">==</span> cp_model.OPTIMAL:</span>
+<span id="cb12-66"><a href="#cb12-66" aria-hidden="true" tabindex="-1"></a>        empfehlung <span class="op">=</span> <span class="st">&quot;Ausfuehren. Besser geht es nachweislich nicht.&quot;</span></span>
+<span id="cb12-67"><a href="#cb12-67" aria-hidden="true" tabindex="-1"></a>    <span class="cf">elif</span> status <span class="op">==</span> cp_model.FEASIBLE:</span>
+<span id="cb12-68"><a href="#cb12-68" aria-hidden="true" tabindex="-1"></a>        empfehlung <span class="op">=</span> (<span class="ss">f&quot;Brauchbar. Der Plan ist hoechstens </span><span class="sc">{</span>gap <span class="op">*</span> <span class="dv">100</span><span class="sc">:.2f}</span><span class="ss"> % &quot;</span></span>
+<span id="cb12-69"><a href="#cb12-69" aria-hidden="true" tabindex="-1"></a>                      <span class="ss">f&quot;schlechter als das theoretisch Bestmoegliche.&quot;</span></span>
+<span id="cb12-70"><a href="#cb12-70" aria-hidden="true" tabindex="-1"></a>                      <span class="cf">if</span> gap <span class="kw">is</span> <span class="kw">not</span> <span class="va">None</span> <span class="cf">else</span></span>
+<span id="cb12-71"><a href="#cb12-71" aria-hidden="true" tabindex="-1"></a>                      <span class="st">&quot;Brauchbar, aber nicht als optimal bewiesen.&quot;</span>)</span>
+<span id="cb12-72"><a href="#cb12-72" aria-hidden="true" tabindex="-1"></a>    <span class="cf">elif</span> status <span class="op">==</span> cp_model.INFEASIBLE:</span>
+<span id="cb12-73"><a href="#cb12-73" aria-hidden="true" tabindex="-1"></a>        empfehlung <span class="op">=</span> (<span class="st">&quot;KEIN Plan existiert. Das ist eine Aussage ueber Ihre &quot;</span></span>
+<span id="cb12-74"><a href="#cb12-74" aria-hidden="true" tabindex="-1"></a>                      <span class="st">&quot;harten Regeln, nicht ueber die Rechenzeit: Auch &quot;</span></span>
+<span id="cb12-75"><a href="#cb12-75" aria-hidden="true" tabindex="-1"></a>                      <span class="st">&quot;unendlich viel Zeit wuerde nichts aendern. Regeln &quot;</span></span>
+<span id="cb12-76"><a href="#cb12-76" aria-hidden="true" tabindex="-1"></a>                      <span class="st">&quot;lockern oder weich machen (Anhang C).&quot;</span>)</span>
+<span id="cb12-77"><a href="#cb12-77" aria-hidden="true" tabindex="-1"></a>    <span class="cf">elif</span> status <span class="op">==</span> cp_model.MODEL_INVALID:</span>
+<span id="cb12-78"><a href="#cb12-78" aria-hidden="true" tabindex="-1"></a>        empfehlung <span class="op">=</span> (<span class="st">&quot;Das MODELL ist fehlerhaft, nicht das Problem. &quot;</span></span>
+<span id="cb12-79"><a href="#cb12-79" aria-hidden="true" tabindex="-1"></a>                      <span class="st">&quot;Typisch: eine Variable mit leerem Wertebereich. &quot;</span></span>
+<span id="cb12-80"><a href="#cb12-80" aria-hidden="true" tabindex="-1"></a>                      <span class="st">&quot;model.Validate() nennt die Ursache.&quot;</span>)</span>
+<span id="cb12-81"><a href="#cb12-81" aria-hidden="true" tabindex="-1"></a>    <span class="cf">else</span>:                                    <span class="co"># UNKNOWN</span></span>
+<span id="cb12-82"><a href="#cb12-82" aria-hidden="true" tabindex="-1"></a>        empfehlung <span class="op">=</span> (<span class="st">&quot;Nichts gefunden - aber auch nicht widerlegt. Mehr Zeit &quot;</span></span>
+<span id="cb12-83"><a href="#cb12-83" aria-hidden="true" tabindex="-1"></a>                      <span class="st">&quot;geben, das Modell vereinfachen oder mit einer &quot;</span></span>
+<span id="cb12-84"><a href="#cb12-84" aria-hidden="true" tabindex="-1"></a>                      <span class="st">&quot;Heuristik vorbelegen (AddHint).&quot;</span>)</span>
+<span id="cb12-85"><a href="#cb12-85" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb12-86"><a href="#cb12-86" aria-hidden="true" tabindex="-1"></a>    <span class="cf">return</span> Auswertung(</span>
+<span id="cb12-87"><a href="#cb12-87" aria-hidden="true" tabindex="-1"></a>        status<span class="op">=</span>name,</span>
+<span id="cb12-88"><a href="#cb12-88" aria-hidden="true" tabindex="-1"></a>        hat_loesung<span class="op">=</span>hat_loesung,</span>
+<span id="cb12-89"><a href="#cb12-89" aria-hidden="true" tabindex="-1"></a>        beweisbar_optimal<span class="op">=</span>status <span class="op">==</span> cp_model.OPTIMAL,</span>
+<span id="cb12-90"><a href="#cb12-90" aria-hidden="true" tabindex="-1"></a>        zielwert<span class="op">=</span>zielwert, schranke<span class="op">=</span>schranke, gap<span class="op">=</span>gap,</span>
+<span id="cb12-91"><a href="#cb12-91" aria-hidden="true" tabindex="-1"></a>        empfehlung<span class="op">=</span>empfehlung,</span>
+<span id="cb12-92"><a href="#cb12-92" aria-hidden="true" tabindex="-1"></a>    )</span>
+<span id="cb12-93"><a href="#cb12-93" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb12-94"><a href="#cb12-94" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb12-95"><a href="#cb12-95" aria-hidden="true" tabindex="-1"></a><span class="kw">def</span> loese(baue, zeitlimit: <span class="bu">float</span>, mit_zielfunktion: <span class="bu">bool</span>) <span class="op">-&gt;</span> Auswertung:</span>
+<span id="cb12-96"><a href="#cb12-96" aria-hidden="true" tabindex="-1"></a>    modell <span class="op">=</span> cp_model.CpModel()</span>
+<span id="cb12-97"><a href="#cb12-97" aria-hidden="true" tabindex="-1"></a>    baue(modell)</span>
+<span id="cb12-98"><a href="#cb12-98" aria-hidden="true" tabindex="-1"></a>    loeser <span class="op">=</span> cp_model.CpSolver()</span>
+<span id="cb12-99"><a href="#cb12-99" aria-hidden="true" tabindex="-1"></a>    loeser.parameters.max_time_in_seconds <span class="op">=</span> zeitlimit</span>
+<span id="cb12-100"><a href="#cb12-100" aria-hidden="true" tabindex="-1"></a>    <span class="co"># Fuer reproduzierbare Buchausgaben; im Betrieb weglassen.</span></span>
+<span id="cb12-101"><a href="#cb12-101" aria-hidden="true" tabindex="-1"></a>    loeser.parameters.num_workers <span class="op">=</span> <span class="dv">1</span></span>
+<span id="cb12-102"><a href="#cb12-102" aria-hidden="true" tabindex="-1"></a>    loeser.parameters.random_seed <span class="op">=</span> <span class="dv">1</span></span>
+<span id="cb12-103"><a href="#cb12-103" aria-hidden="true" tabindex="-1"></a>    status <span class="op">=</span> loeser.Solve(modell)</span>
+<span id="cb12-104"><a href="#cb12-104" aria-hidden="true" tabindex="-1"></a>    <span class="cf">return</span> werte_aus(loeser, status, mit_zielfunktion)</span>
+<span id="cb12-105"><a href="#cb12-105" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb12-106"><a href="#cb12-106" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb12-107"><a href="#cb12-107" aria-hidden="true" tabindex="-1"></a><span class="co"># --- Die fuenf Faelle --------------------------------------------------------</span></span>
+<span id="cb12-108"><a href="#cb12-108" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb12-109"><a href="#cb12-109" aria-hidden="true" tabindex="-1"></a><span class="kw">def</span> dienstplan_loesbar(modell: cp_model.CpModel) <span class="op">-&gt;</span> <span class="va">None</span>:</span>
+<span id="cb12-110"><a href="#cb12-110" aria-hidden="true" tabindex="-1"></a>    <span class="co">&quot;&quot;&quot;Vier Personen, fuenf Dienste, hoechstens zwei je Person - loesbar.&quot;&quot;&quot;</span></span>
+<span id="cb12-111"><a href="#cb12-111" aria-hidden="true" tabindex="-1"></a>    personen, dienste <span class="op">=</span> <span class="dv">4</span>, <span class="dv">5</span></span>
+<span id="cb12-112"><a href="#cb12-112" aria-hidden="true" tabindex="-1"></a>    x <span class="op">=</span> [[modell.NewBoolVar(<span class="ss">f&quot;x_</span><span class="sc">{</span>i<span class="sc">}</span><span class="ss">_</span><span class="sc">{</span>j<span class="sc">}</span><span class="ss">&quot;</span>) <span class="cf">for</span> j <span class="kw">in</span> <span class="bu">range</span>(dienste)]</span>
+<span id="cb12-113"><a href="#cb12-113" aria-hidden="true" tabindex="-1"></a>         <span class="cf">for</span> i <span class="kw">in</span> <span class="bu">range</span>(personen)]</span>
+<span id="cb12-114"><a href="#cb12-114" aria-hidden="true" tabindex="-1"></a>    <span class="cf">for</span> j <span class="kw">in</span> <span class="bu">range</span>(dienste):</span>
+<span id="cb12-115"><a href="#cb12-115" aria-hidden="true" tabindex="-1"></a>        modell.AddExactlyOne(x[i][j] <span class="cf">for</span> i <span class="kw">in</span> <span class="bu">range</span>(personen))</span>
+<span id="cb12-116"><a href="#cb12-116" aria-hidden="true" tabindex="-1"></a>    <span class="cf">for</span> i <span class="kw">in</span> <span class="bu">range</span>(personen):</span>
+<span id="cb12-117"><a href="#cb12-117" aria-hidden="true" tabindex="-1"></a>        modell.Add(<span class="bu">sum</span>(x[i]) <span class="op">&lt;=</span> <span class="dv">2</span>)</span>
+<span id="cb12-118"><a href="#cb12-118" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb12-119"><a href="#cb12-119" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb12-120"><a href="#cb12-120" aria-hidden="true" tabindex="-1"></a><span class="kw">def</span> dienstplan_unloesbar(modell: cp_model.CpModel) <span class="op">-&gt;</span> <span class="va">None</span>:</span>
+<span id="cb12-121"><a href="#cb12-121" aria-hidden="true" tabindex="-1"></a>    <span class="co">&quot;&quot;&quot;Dieselben fuenf Dienste, aber hoechstens EIN Dienst je Person.</span></span>
+<span id="cb12-122"><a href="#cb12-122" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb12-123"><a href="#cb12-123" aria-hidden="true" tabindex="-1"></a><span class="co">    Vier Personen koennen zusammen hoechstens vier Dienste uebernehmen - fuer</span></span>
+<span id="cb12-124"><a href="#cb12-124" aria-hidden="true" tabindex="-1"></a><span class="co">    fuenf Dienste reicht das nicht. Kein Solver der Welt findet hier etwas.</span></span>
+<span id="cb12-125"><a href="#cb12-125" aria-hidden="true" tabindex="-1"></a><span class="co">    &quot;&quot;&quot;</span></span>
+<span id="cb12-126"><a href="#cb12-126" aria-hidden="true" tabindex="-1"></a>    personen, dienste <span class="op">=</span> <span class="dv">4</span>, <span class="dv">5</span></span>
+<span id="cb12-127"><a href="#cb12-127" aria-hidden="true" tabindex="-1"></a>    x <span class="op">=</span> [[modell.NewBoolVar(<span class="ss">f&quot;x_</span><span class="sc">{</span>i<span class="sc">}</span><span class="ss">_</span><span class="sc">{</span>j<span class="sc">}</span><span class="ss">&quot;</span>) <span class="cf">for</span> j <span class="kw">in</span> <span class="bu">range</span>(dienste)]</span>
+<span id="cb12-128"><a href="#cb12-128" aria-hidden="true" tabindex="-1"></a>         <span class="cf">for</span> i <span class="kw">in</span> <span class="bu">range</span>(personen)]</span>
+<span id="cb12-129"><a href="#cb12-129" aria-hidden="true" tabindex="-1"></a>    <span class="cf">for</span> j <span class="kw">in</span> <span class="bu">range</span>(dienste):</span>
+<span id="cb12-130"><a href="#cb12-130" aria-hidden="true" tabindex="-1"></a>        modell.AddExactlyOne(x[i][j] <span class="cf">for</span> i <span class="kw">in</span> <span class="bu">range</span>(personen))</span>
+<span id="cb12-131"><a href="#cb12-131" aria-hidden="true" tabindex="-1"></a>    <span class="cf">for</span> i <span class="kw">in</span> <span class="bu">range</span>(personen):</span>
+<span id="cb12-132"><a href="#cb12-132" aria-hidden="true" tabindex="-1"></a>        modell.Add(<span class="bu">sum</span>(x[i]) <span class="op">&lt;=</span> <span class="dv">1</span>)</span>
+<span id="cb12-133"><a href="#cb12-133" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb12-134"><a href="#cb12-134" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb12-135"><a href="#cb12-135" aria-hidden="true" tabindex="-1"></a><span class="kw">def</span> modell_fehlerhaft(modell: cp_model.CpModel) <span class="op">-&gt;</span> <span class="va">None</span>:</span>
+<span id="cb12-136"><a href="#cb12-136" aria-hidden="true" tabindex="-1"></a>    <span class="co">&quot;&quot;&quot;Eine Variable mit leerem Wertebereich: untere Schranke &gt; obere.</span></span>
+<span id="cb12-137"><a href="#cb12-137" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb12-138"><a href="#cb12-138" aria-hidden="true" tabindex="-1"></a><span class="co">    Im Alltag entsteht das durch einen Rechenfehler in den Grenzen, etwa</span></span>
+<span id="cb12-139"><a href="#cb12-139" aria-hidden="true" tabindex="-1"></a><span class="co">    NewIntVar(mindestbesetzung, kapazitaet, ...) bei falsch sortierten Daten.</span></span>
+<span id="cb12-140"><a href="#cb12-140" aria-hidden="true" tabindex="-1"></a><span class="co">    &quot;&quot;&quot;</span></span>
+<span id="cb12-141"><a href="#cb12-141" aria-hidden="true" tabindex="-1"></a>    kaputt <span class="op">=</span> modell.NewIntVar(<span class="dv">5</span>, <span class="dv">2</span>, <span class="st">&quot;leerer_bereich&quot;</span>)</span>
+<span id="cb12-142"><a href="#cb12-142" aria-hidden="true" tabindex="-1"></a>    modell.Add(kaputt <span class="op">&gt;=</span> <span class="dv">0</span>)</span>
+<span id="cb12-143"><a href="#cb12-143" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb12-144"><a href="#cb12-144" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb12-145"><a href="#cb12-145" aria-hidden="true" tabindex="-1"></a><span class="kw">def</span> lastverteilung(modell: cp_model.CpModel) <span class="op">-&gt;</span> <span class="va">None</span>:</span>
+<span id="cb12-146"><a href="#cb12-146" aria-hidden="true" tabindex="-1"></a>    <span class="co">&quot;&quot;&quot;120 Auftraege auf 11 Maschinen - gross genug, dass der Optimalitaets-</span></span>
+<span id="cb12-147"><a href="#cb12-147" aria-hidden="true" tabindex="-1"></a><span class="co">    beweis laenger dauert als das Finden einer sehr guten Loesung.&quot;&quot;&quot;</span></span>
+<span id="cb12-148"><a href="#cb12-148" aria-hidden="true" tabindex="-1"></a>    rng <span class="op">=</span> np.random.default_rng(<span class="dv">3</span>)</span>
+<span id="cb12-149"><a href="#cb12-149" aria-hidden="true" tabindex="-1"></a>    dauer <span class="op">=</span> rng.integers(<span class="dv">100</span>, <span class="dv">9000</span>, <span class="dv">120</span>)</span>
+<span id="cb12-150"><a href="#cb12-150" aria-hidden="true" tabindex="-1"></a>    n, maschinen <span class="op">=</span> <span class="bu">len</span>(dauer), <span class="dv">11</span></span>
+<span id="cb12-151"><a href="#cb12-151" aria-hidden="true" tabindex="-1"></a>    obergrenze <span class="op">=</span> <span class="bu">int</span>(dauer.<span class="bu">sum</span>())</span>
+<span id="cb12-152"><a href="#cb12-152" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb12-153"><a href="#cb12-153" aria-hidden="true" tabindex="-1"></a>    x <span class="op">=</span> [[modell.NewBoolVar(<span class="ss">f&quot;x_</span><span class="sc">{</span>i<span class="sc">}</span><span class="ss">_</span><span class="sc">{</span>k<span class="sc">}</span><span class="ss">&quot;</span>) <span class="cf">for</span> k <span class="kw">in</span> <span class="bu">range</span>(maschinen)]</span>
+<span id="cb12-154"><a href="#cb12-154" aria-hidden="true" tabindex="-1"></a>         <span class="cf">for</span> i <span class="kw">in</span> <span class="bu">range</span>(n)]</span>
+<span id="cb12-155"><a href="#cb12-155" aria-hidden="true" tabindex="-1"></a>    <span class="cf">for</span> i <span class="kw">in</span> <span class="bu">range</span>(n):</span>
+<span id="cb12-156"><a href="#cb12-156" aria-hidden="true" tabindex="-1"></a>        modell.AddExactlyOne(x[i])</span>
+<span id="cb12-157"><a href="#cb12-157" aria-hidden="true" tabindex="-1"></a>    belegung <span class="op">=</span> [modell.NewIntVar(<span class="dv">0</span>, obergrenze, <span class="ss">f&quot;l_</span><span class="sc">{</span>k<span class="sc">}</span><span class="ss">&quot;</span>) <span class="cf">for</span> k <span class="kw">in</span> <span class="bu">range</span>(maschinen)]</span>
+<span id="cb12-158"><a href="#cb12-158" aria-hidden="true" tabindex="-1"></a>    <span class="cf">for</span> k <span class="kw">in</span> <span class="bu">range</span>(maschinen):</span>
+<span id="cb12-159"><a href="#cb12-159" aria-hidden="true" tabindex="-1"></a>        modell.Add(belegung[k] <span class="op">==</span> <span class="bu">sum</span>(<span class="bu">int</span>(dauer[i]) <span class="op">*</span> x[i][k] <span class="cf">for</span> i <span class="kw">in</span> <span class="bu">range</span>(n)))</span>
+<span id="cb12-160"><a href="#cb12-160" aria-hidden="true" tabindex="-1"></a>    makespan <span class="op">=</span> modell.NewIntVar(<span class="dv">0</span>, obergrenze, <span class="st">&quot;makespan&quot;</span>)</span>
+<span id="cb12-161"><a href="#cb12-161" aria-hidden="true" tabindex="-1"></a>    modell.AddMaxEquality(makespan, belegung)</span>
+<span id="cb12-162"><a href="#cb12-162" aria-hidden="true" tabindex="-1"></a>    modell.Minimize(makespan)</span>
+<span id="cb12-163"><a href="#cb12-163" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb12-164"><a href="#cb12-164" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb12-165"><a href="#cb12-165" aria-hidden="true" tabindex="-1"></a><span class="kw">def</span> zahlpartition(modell: cp_model.CpModel) <span class="op">-&gt;</span> <span class="va">None</span>:</span>
+<span id="cb12-166"><a href="#cb12-166" aria-hidden="true" tabindex="-1"></a>    <span class="co">&quot;&quot;&quot;46 grosse Zahlen exakt in zwei gleich schwere Haelften teilen.</span></span>
+<span id="cb12-167"><a href="#cb12-167" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb12-168"><a href="#cb12-168" aria-hidden="true" tabindex="-1"></a><span class="co">    Ein beruehmt schweres Problem: Es gibt keine Zielfunktion, entweder es</span></span>
+<span id="cb12-169"><a href="#cb12-169" aria-hidden="true" tabindex="-1"></a><span class="co">    geht auf oder nicht - und beides zu entscheiden dauert lange.</span></span>
+<span id="cb12-170"><a href="#cb12-170" aria-hidden="true" tabindex="-1"></a><span class="co">    &quot;&quot;&quot;</span></span>
+<span id="cb12-171"><a href="#cb12-171" aria-hidden="true" tabindex="-1"></a>    rng <span class="op">=</span> np.random.default_rng(<span class="dv">1</span>)</span>
+<span id="cb12-172"><a href="#cb12-172" aria-hidden="true" tabindex="-1"></a>    gewichte <span class="op">=</span> rng.integers(<span class="dv">10</span><span class="op">**</span><span class="dv">6</span>, <span class="dv">2</span> <span class="op">*</span> <span class="dv">10</span><span class="op">**</span><span class="dv">6</span>, <span class="dv">46</span>)</span>
+<span id="cb12-173"><a href="#cb12-173" aria-hidden="true" tabindex="-1"></a>    x <span class="op">=</span> [modell.NewBoolVar(<span class="ss">f&quot;x_</span><span class="sc">{</span>i<span class="sc">}</span><span class="ss">&quot;</span>) <span class="cf">for</span> i <span class="kw">in</span> <span class="bu">range</span>(<span class="bu">len</span>(gewichte))]</span>
+<span id="cb12-174"><a href="#cb12-174" aria-hidden="true" tabindex="-1"></a>    modell.Add(<span class="bu">sum</span>(<span class="bu">int</span>(gewichte[i]) <span class="op">*</span> x[i] <span class="cf">for</span> i <span class="kw">in</span> <span class="bu">range</span>(<span class="bu">len</span>(gewichte)))</span>
+<span id="cb12-175"><a href="#cb12-175" aria-hidden="true" tabindex="-1"></a>               <span class="op">==</span> <span class="bu">int</span>(gewichte.<span class="bu">sum</span>() <span class="op">//</span> <span class="dv">2</span>))</span>
+<span id="cb12-176"><a href="#cb12-176" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb12-177"><a href="#cb12-177" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb12-178"><a href="#cb12-178" aria-hidden="true" tabindex="-1"></a><span class="kw">def</span> zeige(titel: <span class="bu">str</span>, a: Auswertung) <span class="op">-&gt;</span> <span class="va">None</span>:</span>
+<span id="cb12-179"><a href="#cb12-179" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;</span><span class="ch">\n</span><span class="sc">{</span>titel<span class="sc">}</span><span class="ss">&quot;</span>)</span>
+<span id="cb12-180"><a href="#cb12-180" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;  Status               </span><span class="sc">{</span>a<span class="sc">.</span>status<span class="sc">}</span><span class="ss">&quot;</span>)</span>
+<span id="cb12-181"><a href="#cb12-181" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;  Loesung vorhanden    </span><span class="sc">{</span><span class="st">&#39;ja&#39;</span> <span class="cf">if</span> a<span class="sc">.</span>hat_loesung <span class="cf">else</span> <span class="st">&#39;nein&#39;</span><span class="sc">}</span><span class="ss">&quot;</span>)</span>
+<span id="cb12-182"><a href="#cb12-182" aria-hidden="true" tabindex="-1"></a>    <span class="cf">if</span> a.zielwert <span class="kw">is</span> <span class="kw">not</span> <span class="va">None</span>:</span>
+<span id="cb12-183"><a href="#cb12-183" aria-hidden="true" tabindex="-1"></a>        <span class="bu">print</span>(<span class="ss">f&quot;  Zielwert / Schranke  </span><span class="sc">{</span>a<span class="sc">.</span>zielwert<span class="sc">:,.0f}</span><span class="ss"> / </span><span class="sc">{</span>a<span class="sc">.</span>schranke<span class="sc">:,.0f}</span><span class="ss">&quot;</span></span>
+<span id="cb12-184"><a href="#cb12-184" aria-hidden="true" tabindex="-1"></a>              <span class="ss">f&quot;   (Gap </span><span class="sc">{</span>a<span class="sc">.</span>gap <span class="op">*</span> <span class="dv">100</span><span class="sc">:.3f}</span><span class="ss"> %)&quot;</span>)</span>
+<span id="cb12-185"><a href="#cb12-185" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;  -&gt; </span><span class="sc">{</span>a<span class="sc">.</span>empfehlung<span class="sc">}</span><span class="ss">&quot;</span>)</span>
+<span id="cb12-186"><a href="#cb12-186" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb12-187"><a href="#cb12-187" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb12-188"><a href="#cb12-188" aria-hidden="true" tabindex="-1"></a><span class="cf">if</span> <span class="va">__name__</span> <span class="op">==</span> <span class="st">&quot;__main__&quot;</span>:</span>
+<span id="cb12-189"><a href="#cb12-189" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;=&quot;</span> <span class="op">*</span> <span class="dv">78</span>)</span>
+<span id="cb12-190"><a href="#cb12-190" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;  DIE FUENF ANTWORTEN VON CP-SAT&quot;</span>)</span>
+<span id="cb12-191"><a href="#cb12-191" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;=&quot;</span> <span class="op">*</span> <span class="dv">78</span>)</span>
+<span id="cb12-192"><a href="#cb12-192" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb12-193"><a href="#cb12-193" aria-hidden="true" tabindex="-1"></a>    zeige(<span class="st">&quot;[1] Dienstplan, hoechstens 2 Dienste je Person&quot;</span>,</span>
+<span id="cb12-194"><a href="#cb12-194" aria-hidden="true" tabindex="-1"></a>          loese(dienstplan_loesbar, <span class="fl">10.0</span>, mit_zielfunktion<span class="op">=</span><span class="va">False</span>))</span>
+<span id="cb12-195"><a href="#cb12-195" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb12-196"><a href="#cb12-196" aria-hidden="true" tabindex="-1"></a>    zeige(<span class="st">&quot;[2] Lastverteilung 120 Auftraege / 11 Maschinen, 0,5 s Limit&quot;</span>,</span>
+<span id="cb12-197"><a href="#cb12-197" aria-hidden="true" tabindex="-1"></a>          loese(lastverteilung, <span class="fl">0.5</span>, mit_zielfunktion<span class="op">=</span><span class="va">True</span>))</span>
+<span id="cb12-198"><a href="#cb12-198" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb12-199"><a href="#cb12-199" aria-hidden="true" tabindex="-1"></a>    zeige(<span class="st">&quot;[3] Derselbe Fall mit 10 s Limit&quot;</span>,</span>
+<span id="cb12-200"><a href="#cb12-200" aria-hidden="true" tabindex="-1"></a>          loese(lastverteilung, <span class="fl">10.0</span>, mit_zielfunktion<span class="op">=</span><span class="va">True</span>))</span>
+<span id="cb12-201"><a href="#cb12-201" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb12-202"><a href="#cb12-202" aria-hidden="true" tabindex="-1"></a>    zeige(<span class="st">&quot;[4] Dienstplan, hoechstens 1 Dienst je Person&quot;</span>,</span>
+<span id="cb12-203"><a href="#cb12-203" aria-hidden="true" tabindex="-1"></a>          loese(dienstplan_unloesbar, <span class="fl">10.0</span>, mit_zielfunktion<span class="op">=</span><span class="va">False</span>))</span>
+<span id="cb12-204"><a href="#cb12-204" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb12-205"><a href="#cb12-205" aria-hidden="true" tabindex="-1"></a>    zeige(<span class="st">&quot;[5] Variable mit leerem Wertebereich&quot;</span>,</span>
+<span id="cb12-206"><a href="#cb12-206" aria-hidden="true" tabindex="-1"></a>          loese(modell_fehlerhaft, <span class="fl">10.0</span>, mit_zielfunktion<span class="op">=</span><span class="va">False</span>))</span>
+<span id="cb12-207"><a href="#cb12-207" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb12-208"><a href="#cb12-208" aria-hidden="true" tabindex="-1"></a>    zeige(<span class="st">&quot;[6] Zahlpartition mit 46 grossen Zahlen, 2 s Limit&quot;</span>,</span>
+<span id="cb12-209"><a href="#cb12-209" aria-hidden="true" tabindex="-1"></a>          loese(zahlpartition, <span class="fl">2.0</span>, mit_zielfunktion<span class="op">=</span><span class="va">False</span>))</span>
+<span id="cb12-210"><a href="#cb12-210" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb12-211"><a href="#cb12-211" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;</span><span class="ch">\n</span><span class="st">&quot;</span> <span class="op">+</span> <span class="st">&quot;=&quot;</span> <span class="op">*</span> <span class="dv">78</span>)</span>
+<span id="cb12-212"><a href="#cb12-212" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;  DIE DREI, DIE MAN NICHT VERWECHSELN DARF&quot;</span>)</span>
+<span id="cb12-213"><a href="#cb12-213" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;=&quot;</span> <span class="op">*</span> <span class="dv">78</span>)</span>
+<span id="cb12-214"><a href="#cb12-214" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;INFEASIBLE  Es gibt keine Loesung. Eine Aussage ueber Ihr MODELL.&quot;</span>)</span>
+<span id="cb12-215"><a href="#cb12-215" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;            Mehr Rechenzeit aendert daran nichts.&quot;</span>)</span>
+<span id="cb12-216"><a href="#cb12-216" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;UNKNOWN     Es wurde keine gefunden. Eine Aussage ueber die ZEIT.&quot;</span>)</span>
+<span id="cb12-217"><a href="#cb12-217" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;            Ob es eine gibt, ist offen.&quot;</span>)</span>
+<span id="cb12-218"><a href="#cb12-218" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;MODEL_INVALID  Das Modell ist gar kein gueltiges Modell. Eine&quot;</span>)</span>
+<span id="cb12-219"><a href="#cb12-219" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;            Aussage ueber Ihren CODE - immer ein Programmierfehler.&quot;</span>)</span>
+<span id="cb12-220"><a href="#cb12-220" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>()</span>
+<span id="cb12-221"><a href="#cb12-221" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;Wer diese drei in einem &#39;else: return None&#39; zusammenfasst, verliert&quot;</span>)</span>
+<span id="cb12-222"><a href="#cb12-222" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;genau die Information, die zur Fehlersuche noetig waere.&quot;</span>)</span>
+<span id="cb12-223"><a href="#cb12-223" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;=&quot;</span> <span class="op">*</span> <span class="dv">78</span>)</span></code></pre></div>
 <p><strong>Erwartete Ausgabe (Zielwerte in Lauf [2] hardwareabhängig):</strong></p>
 <pre><code>==============================================================================
   DIE FUENF ANTWORTEN VON CP-SAT
@@ -1263,7 +1564,7 @@ genau die Information, die zur Fehlersuche noetig waere.
 </ul>
 </blockquote>
 <hr />
-<h2 id="sec:cpsat-uebungsaufgaben">7.8 Übungsaufgaben</h2>
+<h2 id="sec:cpsat-uebungsaufgaben">7.9 Übungsaufgaben</h2>
 <blockquote>
 <p>Lösungen: <a href="anhang-loesungen.html#sec:loesungen-cpsat">Abschnitt A.7</a>.</p>
 </blockquote>
@@ -1272,13 +1573,14 @@ genau die Information, die zur Fehlersuche noetig waere.
 <p><strong>Aufgabe 7.3 ⭐⭐ — Regeln ergänzen.</strong> Erweitern Sie das Vertretungssystem um: (a) Frau Albrecht ist ab Slot 3 nicht mehr verfügbar. (b) Herr Bauer und Frau Koch sollen nicht beide am selben Tag eingesetzt werden. (c) Wer Slot 1 übernimmt, soll bevorzugt auch Slot 2 bekommen (Belohnung statt Strafe).</p>
 <p><strong>Aufgabe 7.4 ⭐⭐ — Infeasibility erzeugen und diagnostizieren.</strong> Setzen Sie <code>MAX_VERTRETUNGEN = 0</code>. Was meldet das Programm? Bauen Sie anschließend eine <strong>Schlupfvariable</strong> je Slot ein („Stunde fällt aus“, Strafe 10 000) und beobachten Sie, wie der Solver statt einer Fehlermeldung einen Notfallplan liefert. Welche Stunde lässt er ausfallen und warum?</p>
 <p><strong>Aufgabe 7.5 ⭐⭐ — Sudoku.</strong> Lösen Sie ein 9×9-Sudoku mit CP-SAT. Sie brauchen nur <code>NewIntVar(1, 9, ...)</code> und <code>AddAllDifferent</code> für Zeilen, Spalten und die neun 3×3-Blöcke. Wie viele Zeilen Modellcode benötigen Sie?</p>
-<p><strong>Aufgabe 7.6 ⭐⭐⭐ — Job-Shop erweitern.</strong> Ergänzen Sie <code>JobShop_Intervalle.py</code> um: (a) Rüstzeiten von 1 Zeiteinheit zwischen zwei Aufträgen auf derselben Maschine. (b) Fälligkeitstermine je Auftrag mit Strafkosten für Verspätung. (c) Eine zweite Fräse (Kapazität 2 statt 1) mit <code>AddCumulative</code>.</p>
-<p><strong>Aufgabe 7.7 ⭐⭐⭐ — Eigener Dienstplan.</strong> Modellieren Sie einen Wochendienstplan: 7 Tage, 3 Schichten (früh/spät/nacht), 8 Mitarbeitende. Regeln: Jede Schicht 2 Personen; nach Nachtschicht mindestens 2 Tage frei; höchstens 5 Arbeitstage in Folge; jede Person mindestens 2 freie Tage pro Woche; Wünsche als weiche Ziele. Geben Sie den Plan als Wochentabelle aus.</p>
+<p><strong>Aufgabe 7.6 ⭐⭐ — Die Grenze der Parallelität finden.</strong> <code>Parallele_Suche.py</code> misst 1, 2, 4 und 8 Arbeiter. (a) Ergänzen Sie 16 und 24 (bzw. die Kernzahl Ihres Rechners). Ab wo bringt ein weiterer Arbeiter nichts mehr — und wird es irgendwann wieder schlechter? (b) Setzen Sie <code>random_seed</code> bei jedem Lauf auf einen <strong>anderen</strong> Wert, aber <code>num_workers = 1</code>. Wie viele verschiedene Pläne kommen jetzt heraus? Was folgt daraus für die Frage, welcher der beiden Parameter die Reproduzierbarkeit sichert? (c) Vergrößern Sie die Instanz auf 15 Aufträge. Ab welcher Größe erreicht der Lauf mit einem Arbeiter das Zeitlimit, während acht noch <code>OPTIMAL</code> melden?</p>
+<p><strong>Aufgabe 7.7 ⭐⭐⭐ — Job-Shop erweitern.</strong> Ergänzen Sie <code>JobShop_Intervalle.py</code> um: (a) Rüstzeiten von 1 Zeiteinheit zwischen zwei Aufträgen auf derselben Maschine. (b) Fälligkeitstermine je Auftrag mit Strafkosten für Verspätung. (c) Eine zweite Fräse (Kapazität 2 statt 1) mit <code>AddCumulative</code>.</p>
+<p><strong>Aufgabe 7.8 ⭐⭐⭐ — Eigener Dienstplan.</strong> Modellieren Sie einen Wochendienstplan: 7 Tage, 3 Schichten (früh/spät/nacht), 8 Mitarbeitende. Regeln: Jede Schicht 2 Personen; nach Nachtschicht mindestens 2 Tage frei; höchstens 5 Arbeitstage in Folge; jede Person mindestens 2 freie Tage pro Woche; Wünsche als weiche Ziele. Geben Sie den Plan als Wochentabelle aus.</p>
 <hr />
-<h2 id="sec:cpsat-denkfehler">7.9 Finde den Denkfehler</h2>
+<h2 id="sec:cpsat-denkfehler">7.10 Finde den Denkfehler</h2>
 <div class="card card-denkfehler">
 <blockquote>
-<p><strong>🐛 Finde den Denkfehler 6.1: Die Betriebsvereinbarung, die niemanden interessiert</strong></p>
+<p><strong>🐛 Finde den Denkfehler: Die Betriebsvereinbarung, die niemanden interessiert</strong></p>
 <p>Ein Klinikteam lässt seinen Schichtplan optimieren. Zwei Wünsche kommen aus dem Betrieb:</p>
 <ul>
 <li><strong>Betriebsvereinbarung:</strong> niemand mehr als zwei Dienste in Folge.</li>
@@ -1291,138 +1593,138 @@ genau die Information, die zur Fehlersuche noetig waere.
 </blockquote>
 </div>
 <p>Das folgende Programm rechnet den Plan für sechs verschiedene Gewichte durch. Es ist damit zugleich die Antwort auf (c) — und die Tabelle, die man in so einem Fall dem Auftraggeber vorlegt, statt ein Gewicht zu raten.</p>
-<div class="sourceCode" id="cb12"><pre class="sourceCode python"><code class="sourceCode python"><span id="cb12-1"><a href="#cb12-1" aria-hidden="true" tabindex="-1"></a><span class="co">#!/usr/bin/env python3</span></span>
-<span id="cb12-2"><a href="#cb12-2" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb12-3"><a href="#cb12-3" aria-hidden="true" tabindex="-1"></a><span class="co"># Strafgewichte.py</span></span>
-<span id="cb12-4"><a href="#cb12-4" aria-hidden="true" tabindex="-1"></a><span class="co">&quot;&quot;&quot;</span></span>
-<span id="cb12-5"><a href="#cb12-5" aria-hidden="true" tabindex="-1"></a><span class="co">Kapitel CP-SAT: Warum ein Strafgewicht keine Wichtigkeit ausdrueckt, sondern</span></span>
-<span id="cb12-6"><a href="#cb12-6" aria-hidden="true" tabindex="-1"></a><span class="co">einen Wechselkurs.</span></span>
-<span id="cb12-7"><a href="#cb12-7" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb12-8"><a href="#cb12-8" aria-hidden="true" tabindex="-1"></a><span class="co">Weiche Regeln kommen als Strafterm in die Zielfunktion. Die Frage, die dabei</span></span>
-<span id="cb12-9"><a href="#cb12-9" aria-hidden="true" tabindex="-1"></a><span class="co">regelmaessig falsch beantwortet wird, lautet: &quot;Wie gross muss die Strafe sein?&quot;</span></span>
-<span id="cb12-10"><a href="#cb12-10" aria-hidden="true" tabindex="-1"></a><span class="co">Die uebliche Antwort - &quot;je wichtiger, desto groesser&quot; - klingt vernuenftig und</span></span>
-<span id="cb12-11"><a href="#cb12-11" aria-hidden="true" tabindex="-1"></a><span class="co">fuehrt zuverlaessig zu Plaenen, die niemand unterschreiben will.</span></span>
-<span id="cb12-12"><a href="#cb12-12" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb12-13"><a href="#cb12-13" aria-hidden="true" tabindex="-1"></a><span class="co">Der Grund: Zwei Strafgewichte legen nicht Wichtigkeiten fest, sondern einen</span></span>
-<span id="cb12-14"><a href="#cb12-14" aria-hidden="true" tabindex="-1"></a><span class="co">UMRECHNUNGSKURS. Steht die Serienregel bei 1 und der Wunschfrei-Tag bei 10,</span></span>
-<span id="cb12-15"><a href="#cb12-15" aria-hidden="true" tabindex="-1"></a><span class="co">dann hat man dem Solver woertlich gesagt: &quot;Zehn Verstoesse gegen die</span></span>
-<span id="cb12-16"><a href="#cb12-16" aria-hidden="true" tabindex="-1"></a><span class="co">Serienregel sind so schlimm wie ein abgelehnter Wunsch.&quot; Er nimmt das</span></span>
-<span id="cb12-17"><a href="#cb12-17" aria-hidden="true" tabindex="-1"></a><span class="co">ernst - und handelt danach.</span></span>
-<span id="cb12-18"><a href="#cb12-18" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb12-19"><a href="#cb12-19" aria-hidden="true" tabindex="-1"></a><span class="co">Szenario: Schichtplan, 6 Personen, 14 Tage, 4 Besetzungen pro Tag.</span></span>
-<span id="cb12-20"><a href="#cb12-20" aria-hidden="true" tabindex="-1"></a><span class="co">  HART   jeder Tag genau 4 Personen; hoechstens 11 Dienste je Person</span></span>
-<span id="cb12-21"><a href="#cb12-21" aria-hidden="true" tabindex="-1"></a><span class="co">  WEICH  keine drei Dienste in Folge (Betriebsvereinbarung)</span></span>
-<span id="cb12-22"><a href="#cb12-22" aria-hidden="true" tabindex="-1"></a><span class="co">  WEICH  Wunschfrei-Tage einhalten (26 Antraege)</span></span>
-<span id="cb12-23"><a href="#cb12-23" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb12-24"><a href="#cb12-24" aria-hidden="true" tabindex="-1"></a><span class="co">Benoetigt: numpy, ortools</span></span>
-<span id="cb12-25"><a href="#cb12-25" aria-hidden="true" tabindex="-1"></a><span class="co">&quot;&quot;&quot;</span></span>
-<span id="cb12-26"><a href="#cb12-26" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb12-27"><a href="#cb12-27" aria-hidden="true" tabindex="-1"></a><span class="im">from</span> __future__ <span class="im">import</span> annotations</span>
-<span id="cb12-28"><a href="#cb12-28" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb12-29"><a href="#cb12-29" aria-hidden="true" tabindex="-1"></a><span class="im">import</span> numpy <span class="im">as</span> np</span>
-<span id="cb12-30"><a href="#cb12-30" aria-hidden="true" tabindex="-1"></a><span class="im">from</span> ortools.sat.python <span class="im">import</span> cp_model</span>
-<span id="cb12-31"><a href="#cb12-31" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb12-32"><a href="#cb12-32" aria-hidden="true" tabindex="-1"></a>PERSONEN, TAGE, PRO_TAG <span class="op">=</span> <span class="dv">6</span>, <span class="dv">14</span>, <span class="dv">4</span></span>
-<span id="cb12-33"><a href="#cb12-33" aria-hidden="true" tabindex="-1"></a>MAX_DIENSTE <span class="op">=</span> <span class="dv">11</span></span>
-<span id="cb12-34"><a href="#cb12-34" aria-hidden="true" tabindex="-1"></a>STRAFE_WUNSCH <span class="op">=</span> <span class="dv">10</span>                    <span class="co"># bleibt fest - variiert wird die Serienstrafe</span></span>
-<span id="cb12-35"><a href="#cb12-35" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb12-36"><a href="#cb12-36" aria-hidden="true" tabindex="-1"></a>RNG <span class="op">=</span> np.random.default_rng(<span class="dv">2</span>)</span>
-<span id="cb12-37"><a href="#cb12-37" aria-hidden="true" tabindex="-1"></a>WUNSCHFREI <span class="op">=</span> <span class="bu">sorted</span>({(p, t) <span class="cf">for</span> p <span class="kw">in</span> <span class="bu">range</span>(PERSONEN) <span class="cf">for</span> t <span class="kw">in</span> <span class="bu">range</span>(TAGE)</span>
-<span id="cb12-38"><a href="#cb12-38" aria-hidden="true" tabindex="-1"></a>                     <span class="cf">if</span> RNG.random() <span class="op">&lt;</span> <span class="fl">0.35</span>})</span>
-<span id="cb12-39"><a href="#cb12-39" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb12-40"><a href="#cb12-40" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb12-41"><a href="#cb12-41" aria-hidden="true" tabindex="-1"></a><span class="kw">def</span> plane(strafe_serie: <span class="bu">int</span>, zeitlimit: <span class="bu">float</span> <span class="op">=</span> <span class="fl">25.0</span>) <span class="op">-&gt;</span> <span class="bu">dict</span>:</span>
-<span id="cb12-42"><a href="#cb12-42" aria-hidden="true" tabindex="-1"></a>    <span class="co">&quot;&quot;&quot;Baut den Schichtplan mit dem angegebenen Gewicht fuer die Serienregel.&quot;&quot;&quot;</span></span>
-<span id="cb12-43"><a href="#cb12-43" aria-hidden="true" tabindex="-1"></a>    modell <span class="op">=</span> cp_model.CpModel()</span>
-<span id="cb12-44"><a href="#cb12-44" aria-hidden="true" tabindex="-1"></a>    x <span class="op">=</span> {(p, t): modell.NewBoolVar(<span class="ss">f&quot;x_</span><span class="sc">{</span>p<span class="sc">}</span><span class="ss">_</span><span class="sc">{</span>t<span class="sc">}</span><span class="ss">&quot;</span>)</span>
-<span id="cb12-45"><a href="#cb12-45" aria-hidden="true" tabindex="-1"></a>         <span class="cf">for</span> p <span class="kw">in</span> <span class="bu">range</span>(PERSONEN) <span class="cf">for</span> t <span class="kw">in</span> <span class="bu">range</span>(TAGE)}</span>
-<span id="cb12-46"><a href="#cb12-46" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb12-47"><a href="#cb12-47" aria-hidden="true" tabindex="-1"></a>    <span class="co"># --- harte Regeln --------------------------------------------------</span></span>
-<span id="cb12-48"><a href="#cb12-48" aria-hidden="true" tabindex="-1"></a>    <span class="cf">for</span> t <span class="kw">in</span> <span class="bu">range</span>(TAGE):</span>
-<span id="cb12-49"><a href="#cb12-49" aria-hidden="true" tabindex="-1"></a>        modell.Add(<span class="bu">sum</span>(x[p, t] <span class="cf">for</span> p <span class="kw">in</span> <span class="bu">range</span>(PERSONEN)) <span class="op">==</span> PRO_TAG)</span>
-<span id="cb12-50"><a href="#cb12-50" aria-hidden="true" tabindex="-1"></a>    <span class="cf">for</span> p <span class="kw">in</span> <span class="bu">range</span>(PERSONEN):</span>
-<span id="cb12-51"><a href="#cb12-51" aria-hidden="true" tabindex="-1"></a>        modell.Add(<span class="bu">sum</span>(x[p, t] <span class="cf">for</span> t <span class="kw">in</span> <span class="bu">range</span>(TAGE)) <span class="op">&lt;=</span> MAX_DIENSTE)</span>
-<span id="cb12-52"><a href="#cb12-52" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb12-53"><a href="#cb12-53" aria-hidden="true" tabindex="-1"></a>    <span class="co"># --- weiche Regel 1: keine drei Dienste in Folge --------------------</span></span>
-<span id="cb12-54"><a href="#cb12-54" aria-hidden="true" tabindex="-1"></a>    <span class="co"># serie[p, t] = 1  &lt;=&gt;  Person p arbeitet an t, t+1 UND t+2.</span></span>
-<span id="cb12-55"><a href="#cb12-55" aria-hidden="true" tabindex="-1"></a>    <span class="co"># Die Ungleichung erzwingt das nur in eine Richtung; das genuegt, weil</span></span>
-<span id="cb12-56"><a href="#cb12-56" aria-hidden="true" tabindex="-1"></a>    <span class="co"># der Solver serie minimiert - er wuerde die Variable nie freiwillig</span></span>
-<span id="cb12-57"><a href="#cb12-57" aria-hidden="true" tabindex="-1"></a>    <span class="co"># auf 1 setzen.</span></span>
-<span id="cb12-58"><a href="#cb12-58" aria-hidden="true" tabindex="-1"></a>    strafterme <span class="op">=</span> []</span>
-<span id="cb12-59"><a href="#cb12-59" aria-hidden="true" tabindex="-1"></a>    serien <span class="op">=</span> []</span>
-<span id="cb12-60"><a href="#cb12-60" aria-hidden="true" tabindex="-1"></a>    <span class="cf">for</span> p <span class="kw">in</span> <span class="bu">range</span>(PERSONEN):</span>
-<span id="cb12-61"><a href="#cb12-61" aria-hidden="true" tabindex="-1"></a>        <span class="cf">for</span> t <span class="kw">in</span> <span class="bu">range</span>(TAGE <span class="op">-</span> <span class="dv">2</span>):</span>
-<span id="cb12-62"><a href="#cb12-62" aria-hidden="true" tabindex="-1"></a>            serie <span class="op">=</span> modell.NewBoolVar(<span class="ss">f&quot;serie_</span><span class="sc">{</span>p<span class="sc">}</span><span class="ss">_</span><span class="sc">{</span>t<span class="sc">}</span><span class="ss">&quot;</span>)</span>
-<span id="cb12-63"><a href="#cb12-63" aria-hidden="true" tabindex="-1"></a>            modell.Add(x[p, t] <span class="op">+</span> x[p, t <span class="op">+</span> <span class="dv">1</span>] <span class="op">+</span> x[p, t <span class="op">+</span> <span class="dv">2</span>] <span class="op">&lt;=</span> <span class="dv">2</span> <span class="op">+</span> serie)</span>
-<span id="cb12-64"><a href="#cb12-64" aria-hidden="true" tabindex="-1"></a>            serien.append(serie)</span>
-<span id="cb12-65"><a href="#cb12-65" aria-hidden="true" tabindex="-1"></a>            strafterme.append(serie <span class="op">*</span> strafe_serie)</span>
-<span id="cb12-66"><a href="#cb12-66" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb12-67"><a href="#cb12-67" aria-hidden="true" tabindex="-1"></a>    <span class="co"># --- weiche Regel 2: Wunschfrei ------------------------------------</span></span>
-<span id="cb12-68"><a href="#cb12-68" aria-hidden="true" tabindex="-1"></a>    wunschverstoesse <span class="op">=</span> []</span>
-<span id="cb12-69"><a href="#cb12-69" aria-hidden="true" tabindex="-1"></a>    <span class="cf">for</span> p, t <span class="kw">in</span> WUNSCHFREI:</span>
-<span id="cb12-70"><a href="#cb12-70" aria-hidden="true" tabindex="-1"></a>        wunschverstoesse.append(x[p, t])</span>
-<span id="cb12-71"><a href="#cb12-71" aria-hidden="true" tabindex="-1"></a>        strafterme.append(x[p, t] <span class="op">*</span> STRAFE_WUNSCH)</span>
-<span id="cb12-72"><a href="#cb12-72" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb12-73"><a href="#cb12-73" aria-hidden="true" tabindex="-1"></a>    modell.Minimize(<span class="bu">sum</span>(strafterme))</span>
-<span id="cb12-74"><a href="#cb12-74" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb12-75"><a href="#cb12-75" aria-hidden="true" tabindex="-1"></a>    loeser <span class="op">=</span> cp_model.CpSolver()</span>
-<span id="cb12-76"><a href="#cb12-76" aria-hidden="true" tabindex="-1"></a>    loeser.parameters.max_time_in_seconds <span class="op">=</span> zeitlimit</span>
-<span id="cb12-77"><a href="#cb12-77" aria-hidden="true" tabindex="-1"></a>    loeser.parameters.num_workers <span class="op">=</span> <span class="dv">1</span>          <span class="co"># reproduzierbare Buchausgabe</span></span>
-<span id="cb12-78"><a href="#cb12-78" aria-hidden="true" tabindex="-1"></a>    loeser.parameters.random_seed <span class="op">=</span> <span class="dv">1</span></span>
-<span id="cb12-79"><a href="#cb12-79" aria-hidden="true" tabindex="-1"></a>    status <span class="op">=</span> loeser.Solve(modell)</span>
-<span id="cb12-80"><a href="#cb12-80" aria-hidden="true" tabindex="-1"></a>    <span class="cf">if</span> status <span class="kw">not</span> <span class="kw">in</span> (cp_model.OPTIMAL, cp_model.FEASIBLE):</span>
-<span id="cb12-81"><a href="#cb12-81" aria-hidden="true" tabindex="-1"></a>        <span class="cf">raise</span> <span class="pp">RuntimeError</span>(<span class="ss">f&quot;Kein Plan: </span><span class="sc">{</span>loeser<span class="sc">.</span>StatusName(status)<span class="sc">}</span><span class="ss">&quot;</span>)</span>
-<span id="cb12-82"><a href="#cb12-82" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb12-83"><a href="#cb12-83" aria-hidden="true" tabindex="-1"></a>    <span class="cf">return</span> {</span>
-<span id="cb12-84"><a href="#cb12-84" aria-hidden="true" tabindex="-1"></a>        <span class="st">&quot;status&quot;</span>: loeser.StatusName(status),</span>
-<span id="cb12-85"><a href="#cb12-85" aria-hidden="true" tabindex="-1"></a>        <span class="st">&quot;zielwert&quot;</span>: loeser.ObjectiveValue(),</span>
-<span id="cb12-86"><a href="#cb12-86" aria-hidden="true" tabindex="-1"></a>        <span class="st">&quot;serien&quot;</span>: <span class="bu">sum</span>(loeser.Value(v) <span class="cf">for</span> v <span class="kw">in</span> serien),</span>
-<span id="cb12-87"><a href="#cb12-87" aria-hidden="true" tabindex="-1"></a>        <span class="st">&quot;wunsch_verletzt&quot;</span>: <span class="bu">sum</span>(loeser.Value(v) <span class="cf">for</span> v <span class="kw">in</span> wunschverstoesse),</span>
-<span id="cb12-88"><a href="#cb12-88" aria-hidden="true" tabindex="-1"></a>    }</span>
-<span id="cb12-89"><a href="#cb12-89" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb12-90"><a href="#cb12-90" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb12-91"><a href="#cb12-91" aria-hidden="true" tabindex="-1"></a><span class="cf">if</span> <span class="va">__name__</span> <span class="op">==</span> <span class="st">&quot;__main__&quot;</span>:</span>
-<span id="cb12-92"><a href="#cb12-92" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;=&quot;</span> <span class="op">*</span> <span class="dv">78</span>)</span>
-<span id="cb12-93"><a href="#cb12-93" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;  STRAFGEWICHTE SIND WECHSELKURSE, KEINE WICHTIGKEITEN&quot;</span>)</span>
-<span id="cb12-94"><a href="#cb12-94" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;=&quot;</span> <span class="op">*</span> <span class="dv">78</span>)</span>
-<span id="cb12-95"><a href="#cb12-95" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;</span><span class="sc">{</span>PERSONEN<span class="sc">}</span><span class="ss"> Personen, </span><span class="sc">{</span>TAGE<span class="sc">}</span><span class="ss"> Tage, </span><span class="sc">{</span>PRO_TAG<span class="sc">}</span><span class="ss"> Besetzungen pro Tag &quot;</span></span>
-<span id="cb12-96"><a href="#cb12-96" aria-hidden="true" tabindex="-1"></a>          <span class="ss">f&quot;= </span><span class="sc">{</span>TAGE <span class="op">*</span> PRO_TAG<span class="sc">}</span><span class="ss"> Dienste&quot;</span>)</span>
-<span id="cb12-97"><a href="#cb12-97" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;Das sind </span><span class="sc">{</span>TAGE <span class="op">*</span> PRO_TAG <span class="op">/</span> PERSONEN<span class="sc">:.1f}</span><span class="ss"> Dienste je Person - der Plan ist eng.&quot;</span>)</span>
-<span id="cb12-98"><a href="#cb12-98" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;</span><span class="sc">{</span><span class="bu">len</span>(WUNSCHFREI)<span class="sc">}</span><span class="ss"> Wunschfrei-Antraege, Strafe je abgelehntem Wunsch: &quot;</span></span>
-<span id="cb12-99"><a href="#cb12-99" aria-hidden="true" tabindex="-1"></a>          <span class="ss">f&quot;</span><span class="sc">{</span>STRAFE_WUNSCH<span class="sc">}</span><span class="ch">\n</span><span class="ss">&quot;</span>)</span>
-<span id="cb12-100"><a href="#cb12-100" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb12-101"><a href="#cb12-101" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;</span><span class="sc">{</span><span class="st">&#39;Strafe je 3er-Serie&#39;</span><span class="sc">:&gt;20}</span><span class="ss"> </span><span class="sc">{</span><span class="st">&#39;3er-Serien&#39;</span><span class="sc">:&gt;12}</span><span class="ss"> </span><span class="sc">{</span><span class="st">&#39;Wunsch verletzt&#39;</span><span class="sc">:&gt;17}</span><span class="ss"> &quot;</span></span>
-<span id="cb12-102"><a href="#cb12-102" aria-hidden="true" tabindex="-1"></a>          <span class="ss">f&quot;</span><span class="sc">{</span><span class="st">&#39;Zielwert&#39;</span><span class="sc">:&gt;10}</span><span class="ss">&quot;</span>)</span>
-<span id="cb12-103"><a href="#cb12-103" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;-&quot;</span> <span class="op">*</span> <span class="dv">78</span>)</span>
-<span id="cb12-104"><a href="#cb12-104" aria-hidden="true" tabindex="-1"></a>    ergebnisse <span class="op">=</span> {}</span>
-<span id="cb12-105"><a href="#cb12-105" aria-hidden="true" tabindex="-1"></a>    <span class="cf">for</span> strafe <span class="kw">in</span> (<span class="dv">1</span>, <span class="dv">2</span>, <span class="dv">5</span>, <span class="dv">10</span>, <span class="dv">30</span>, <span class="dv">100</span>):</span>
-<span id="cb12-106"><a href="#cb12-106" aria-hidden="true" tabindex="-1"></a>        e <span class="op">=</span> plane(strafe)</span>
-<span id="cb12-107"><a href="#cb12-107" aria-hidden="true" tabindex="-1"></a>        ergebnisse[strafe] <span class="op">=</span> e</span>
-<span id="cb12-108"><a href="#cb12-108" aria-hidden="true" tabindex="-1"></a>        <span class="bu">print</span>(<span class="ss">f&quot;</span><span class="sc">{</span>strafe<span class="sc">:&gt;20}</span><span class="ss"> </span><span class="sc">{</span>e[<span class="st">&#39;serien&#39;</span>]<span class="sc">:&gt;12}</span><span class="ss"> </span><span class="sc">{</span>e[<span class="st">&#39;wunsch_verletzt&#39;</span>]<span class="sc">:&gt;17}</span><span class="ss"> &quot;</span></span>
-<span id="cb12-109"><a href="#cb12-109" aria-hidden="true" tabindex="-1"></a>              <span class="ss">f&quot;</span><span class="sc">{</span>e[<span class="st">&#39;zielwert&#39;</span>]<span class="sc">:&gt;10.0f}</span><span class="ss">&quot;</span>)</span>
-<span id="cb12-110"><a href="#cb12-110" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;-&quot;</span> <span class="op">*</span> <span class="dv">78</span>)</span>
-<span id="cb12-111"><a href="#cb12-111" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb12-112"><a href="#cb12-112" aria-hidden="true" tabindex="-1"></a>    niedrig, hoch <span class="op">=</span> ergebnisse[<span class="dv">1</span>], ergebnisse[<span class="dv">30</span>]</span>
-<span id="cb12-113"><a href="#cb12-113" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;</span><span class="ch">\n</span><span class="ss">Bei Strafe 1 baut der Solver </span><span class="sc">{</span>niedrig[<span class="st">&#39;serien&#39;</span>]<span class="sc">}</span><span class="ss"> Drei-Tage-Serien ein.&quot;</span>)</span>
-<span id="cb12-114"><a href="#cb12-114" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;Die Betriebsvereinbarung steht im Modell - und wird trotzdem&quot;</span>)</span>
-<span id="cb12-115"><a href="#cb12-115" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;systematisch verletzt. Das ist kein Fehler des Solvers: Bei einem&quot;</span>)</span>
-<span id="cb12-116"><a href="#cb12-116" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;Gewicht von 1 gegen </span><span class="sc">{</span>STRAFE_WUNSCH<span class="sc">}</span><span class="ss"> lohnt sich jede Serie, solange sie&quot;</span>)</span>
-<span id="cb12-117"><a href="#cb12-117" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;auch nur einen Zehntel-Wunsch rettet.&quot;</span>)</span>
-<span id="cb12-118"><a href="#cb12-118" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;</span><span class="ch">\n</span><span class="ss">Bei Strafe 30 sind es </span><span class="sc">{</span>hoch[<span class="st">&#39;serien&#39;</span>]<span class="sc">}</span><span class="ss"> Serien - dafuer werden&quot;</span>)</span>
-<span id="cb12-119"><a href="#cb12-119" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;</span><span class="sc">{</span>hoch[<span class="st">&#39;wunsch_verletzt&#39;</span>]<span class="sc">}</span><span class="ss"> statt </span><span class="sc">{</span>niedrig[<span class="st">&#39;wunsch_verletzt&#39;</span>]<span class="sc">}</span><span class="ss"> Wuensche abgelehnt.&quot;</span>)</span>
-<span id="cb12-120"><a href="#cb12-120" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;Beide Plaene sind optimal. Sie beantworten nur verschiedene Fragen.&quot;</span>)</span>
-<span id="cb12-121"><a href="#cb12-121" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>()</span>
-<span id="cb12-122"><a href="#cb12-122" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;Die Frage lautet also nie &#39;wie wichtig ist mir diese Regel?&#39;, sondern:&quot;</span>)</span>
-<span id="cb12-123"><a href="#cb12-123" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;  &#39;Wie viele abgelehnte Wuensche bin ich bereit zu akzeptieren,&quot;</span>)</span>
-<span id="cb12-124"><a href="#cb12-124" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;   um eine Drei-Tage-Serie zu vermeiden?&#39;&quot;</span>)</span>
-<span id="cb12-125"><a href="#cb12-125" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;Wer darauf keine Zahl nennen kann, hat das Problem noch nicht&quot;</span>)</span>
-<span id="cb12-126"><a href="#cb12-126" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;verstanden - und sollte diese Tabelle dem Auftraggeber vorlegen,&quot;</span>)</span>
-<span id="cb12-127"><a href="#cb12-127" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;statt ein Gewicht zu raten.&quot;</span>)</span>
-<span id="cb12-128"><a href="#cb12-128" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>()</span>
-<span id="cb12-129"><a href="#cb12-129" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;Und die wichtigste Konsequenz: Eine Regel, die NIE gebrochen werden&quot;</span>)</span>
-<span id="cb12-130"><a href="#cb12-130" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;darf, gehoert nicht in die Zielfunktion, sondern unter die harten&quot;</span>)</span>
-<span id="cb12-131"><a href="#cb12-131" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;Nebenbedingungen. Alles, was einen Preis hat, wird irgendwann gekauft.&quot;</span>)</span>
-<span id="cb12-132"><a href="#cb12-132" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;=&quot;</span> <span class="op">*</span> <span class="dv">78</span>)</span></code></pre></div>
+<div class="sourceCode" id="cb14"><pre class="sourceCode python"><code class="sourceCode python"><span id="cb14-1"><a href="#cb14-1" aria-hidden="true" tabindex="-1"></a><span class="co">#!/usr/bin/env python3</span></span>
+<span id="cb14-2"><a href="#cb14-2" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb14-3"><a href="#cb14-3" aria-hidden="true" tabindex="-1"></a><span class="co"># Strafgewichte.py</span></span>
+<span id="cb14-4"><a href="#cb14-4" aria-hidden="true" tabindex="-1"></a><span class="co">&quot;&quot;&quot;</span></span>
+<span id="cb14-5"><a href="#cb14-5" aria-hidden="true" tabindex="-1"></a><span class="co">Kapitel CP-SAT: Warum ein Strafgewicht keine Wichtigkeit ausdrueckt, sondern</span></span>
+<span id="cb14-6"><a href="#cb14-6" aria-hidden="true" tabindex="-1"></a><span class="co">einen Wechselkurs.</span></span>
+<span id="cb14-7"><a href="#cb14-7" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb14-8"><a href="#cb14-8" aria-hidden="true" tabindex="-1"></a><span class="co">Weiche Regeln kommen als Strafterm in die Zielfunktion. Die Frage, die dabei</span></span>
+<span id="cb14-9"><a href="#cb14-9" aria-hidden="true" tabindex="-1"></a><span class="co">regelmaessig falsch beantwortet wird, lautet: &quot;Wie gross muss die Strafe sein?&quot;</span></span>
+<span id="cb14-10"><a href="#cb14-10" aria-hidden="true" tabindex="-1"></a><span class="co">Die uebliche Antwort - &quot;je wichtiger, desto groesser&quot; - klingt vernuenftig und</span></span>
+<span id="cb14-11"><a href="#cb14-11" aria-hidden="true" tabindex="-1"></a><span class="co">fuehrt zuverlaessig zu Plaenen, die niemand unterschreiben will.</span></span>
+<span id="cb14-12"><a href="#cb14-12" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb14-13"><a href="#cb14-13" aria-hidden="true" tabindex="-1"></a><span class="co">Der Grund: Zwei Strafgewichte legen nicht Wichtigkeiten fest, sondern einen</span></span>
+<span id="cb14-14"><a href="#cb14-14" aria-hidden="true" tabindex="-1"></a><span class="co">UMRECHNUNGSKURS. Steht die Serienregel bei 1 und der Wunschfrei-Tag bei 10,</span></span>
+<span id="cb14-15"><a href="#cb14-15" aria-hidden="true" tabindex="-1"></a><span class="co">dann hat man dem Solver woertlich gesagt: &quot;Zehn Verstoesse gegen die</span></span>
+<span id="cb14-16"><a href="#cb14-16" aria-hidden="true" tabindex="-1"></a><span class="co">Serienregel sind so schlimm wie ein abgelehnter Wunsch.&quot; Er nimmt das</span></span>
+<span id="cb14-17"><a href="#cb14-17" aria-hidden="true" tabindex="-1"></a><span class="co">ernst - und handelt danach.</span></span>
+<span id="cb14-18"><a href="#cb14-18" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb14-19"><a href="#cb14-19" aria-hidden="true" tabindex="-1"></a><span class="co">Szenario: Schichtplan, 6 Personen, 14 Tage, 4 Besetzungen pro Tag.</span></span>
+<span id="cb14-20"><a href="#cb14-20" aria-hidden="true" tabindex="-1"></a><span class="co">  HART   jeder Tag genau 4 Personen; hoechstens 11 Dienste je Person</span></span>
+<span id="cb14-21"><a href="#cb14-21" aria-hidden="true" tabindex="-1"></a><span class="co">  WEICH  keine drei Dienste in Folge (Betriebsvereinbarung)</span></span>
+<span id="cb14-22"><a href="#cb14-22" aria-hidden="true" tabindex="-1"></a><span class="co">  WEICH  Wunschfrei-Tage einhalten (26 Antraege)</span></span>
+<span id="cb14-23"><a href="#cb14-23" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb14-24"><a href="#cb14-24" aria-hidden="true" tabindex="-1"></a><span class="co">Benoetigt: numpy, ortools</span></span>
+<span id="cb14-25"><a href="#cb14-25" aria-hidden="true" tabindex="-1"></a><span class="co">&quot;&quot;&quot;</span></span>
+<span id="cb14-26"><a href="#cb14-26" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb14-27"><a href="#cb14-27" aria-hidden="true" tabindex="-1"></a><span class="im">from</span> __future__ <span class="im">import</span> annotations</span>
+<span id="cb14-28"><a href="#cb14-28" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb14-29"><a href="#cb14-29" aria-hidden="true" tabindex="-1"></a><span class="im">import</span> numpy <span class="im">as</span> np</span>
+<span id="cb14-30"><a href="#cb14-30" aria-hidden="true" tabindex="-1"></a><span class="im">from</span> ortools.sat.python <span class="im">import</span> cp_model</span>
+<span id="cb14-31"><a href="#cb14-31" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb14-32"><a href="#cb14-32" aria-hidden="true" tabindex="-1"></a>PERSONEN, TAGE, PRO_TAG <span class="op">=</span> <span class="dv">6</span>, <span class="dv">14</span>, <span class="dv">4</span></span>
+<span id="cb14-33"><a href="#cb14-33" aria-hidden="true" tabindex="-1"></a>MAX_DIENSTE <span class="op">=</span> <span class="dv">11</span></span>
+<span id="cb14-34"><a href="#cb14-34" aria-hidden="true" tabindex="-1"></a>STRAFE_WUNSCH <span class="op">=</span> <span class="dv">10</span>                    <span class="co"># bleibt fest - variiert wird die Serienstrafe</span></span>
+<span id="cb14-35"><a href="#cb14-35" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb14-36"><a href="#cb14-36" aria-hidden="true" tabindex="-1"></a>RNG <span class="op">=</span> np.random.default_rng(<span class="dv">2</span>)</span>
+<span id="cb14-37"><a href="#cb14-37" aria-hidden="true" tabindex="-1"></a>WUNSCHFREI <span class="op">=</span> <span class="bu">sorted</span>({(p, t) <span class="cf">for</span> p <span class="kw">in</span> <span class="bu">range</span>(PERSONEN) <span class="cf">for</span> t <span class="kw">in</span> <span class="bu">range</span>(TAGE)</span>
+<span id="cb14-38"><a href="#cb14-38" aria-hidden="true" tabindex="-1"></a>                     <span class="cf">if</span> RNG.random() <span class="op">&lt;</span> <span class="fl">0.35</span>})</span>
+<span id="cb14-39"><a href="#cb14-39" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb14-40"><a href="#cb14-40" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb14-41"><a href="#cb14-41" aria-hidden="true" tabindex="-1"></a><span class="kw">def</span> plane(strafe_serie: <span class="bu">int</span>, zeitlimit: <span class="bu">float</span> <span class="op">=</span> <span class="fl">25.0</span>) <span class="op">-&gt;</span> <span class="bu">dict</span>:</span>
+<span id="cb14-42"><a href="#cb14-42" aria-hidden="true" tabindex="-1"></a>    <span class="co">&quot;&quot;&quot;Baut den Schichtplan mit dem angegebenen Gewicht fuer die Serienregel.&quot;&quot;&quot;</span></span>
+<span id="cb14-43"><a href="#cb14-43" aria-hidden="true" tabindex="-1"></a>    modell <span class="op">=</span> cp_model.CpModel()</span>
+<span id="cb14-44"><a href="#cb14-44" aria-hidden="true" tabindex="-1"></a>    x <span class="op">=</span> {(p, t): modell.NewBoolVar(<span class="ss">f&quot;x_</span><span class="sc">{</span>p<span class="sc">}</span><span class="ss">_</span><span class="sc">{</span>t<span class="sc">}</span><span class="ss">&quot;</span>)</span>
+<span id="cb14-45"><a href="#cb14-45" aria-hidden="true" tabindex="-1"></a>         <span class="cf">for</span> p <span class="kw">in</span> <span class="bu">range</span>(PERSONEN) <span class="cf">for</span> t <span class="kw">in</span> <span class="bu">range</span>(TAGE)}</span>
+<span id="cb14-46"><a href="#cb14-46" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb14-47"><a href="#cb14-47" aria-hidden="true" tabindex="-1"></a>    <span class="co"># --- harte Regeln --------------------------------------------------</span></span>
+<span id="cb14-48"><a href="#cb14-48" aria-hidden="true" tabindex="-1"></a>    <span class="cf">for</span> t <span class="kw">in</span> <span class="bu">range</span>(TAGE):</span>
+<span id="cb14-49"><a href="#cb14-49" aria-hidden="true" tabindex="-1"></a>        modell.Add(<span class="bu">sum</span>(x[p, t] <span class="cf">for</span> p <span class="kw">in</span> <span class="bu">range</span>(PERSONEN)) <span class="op">==</span> PRO_TAG)</span>
+<span id="cb14-50"><a href="#cb14-50" aria-hidden="true" tabindex="-1"></a>    <span class="cf">for</span> p <span class="kw">in</span> <span class="bu">range</span>(PERSONEN):</span>
+<span id="cb14-51"><a href="#cb14-51" aria-hidden="true" tabindex="-1"></a>        modell.Add(<span class="bu">sum</span>(x[p, t] <span class="cf">for</span> t <span class="kw">in</span> <span class="bu">range</span>(TAGE)) <span class="op">&lt;=</span> MAX_DIENSTE)</span>
+<span id="cb14-52"><a href="#cb14-52" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb14-53"><a href="#cb14-53" aria-hidden="true" tabindex="-1"></a>    <span class="co"># --- weiche Regel 1: keine drei Dienste in Folge --------------------</span></span>
+<span id="cb14-54"><a href="#cb14-54" aria-hidden="true" tabindex="-1"></a>    <span class="co"># serie[p, t] = 1  &lt;=&gt;  Person p arbeitet an t, t+1 UND t+2.</span></span>
+<span id="cb14-55"><a href="#cb14-55" aria-hidden="true" tabindex="-1"></a>    <span class="co"># Die Ungleichung erzwingt das nur in eine Richtung; das genuegt, weil</span></span>
+<span id="cb14-56"><a href="#cb14-56" aria-hidden="true" tabindex="-1"></a>    <span class="co"># der Solver serie minimiert - er wuerde die Variable nie freiwillig</span></span>
+<span id="cb14-57"><a href="#cb14-57" aria-hidden="true" tabindex="-1"></a>    <span class="co"># auf 1 setzen.</span></span>
+<span id="cb14-58"><a href="#cb14-58" aria-hidden="true" tabindex="-1"></a>    strafterme <span class="op">=</span> []</span>
+<span id="cb14-59"><a href="#cb14-59" aria-hidden="true" tabindex="-1"></a>    serien <span class="op">=</span> []</span>
+<span id="cb14-60"><a href="#cb14-60" aria-hidden="true" tabindex="-1"></a>    <span class="cf">for</span> p <span class="kw">in</span> <span class="bu">range</span>(PERSONEN):</span>
+<span id="cb14-61"><a href="#cb14-61" aria-hidden="true" tabindex="-1"></a>        <span class="cf">for</span> t <span class="kw">in</span> <span class="bu">range</span>(TAGE <span class="op">-</span> <span class="dv">2</span>):</span>
+<span id="cb14-62"><a href="#cb14-62" aria-hidden="true" tabindex="-1"></a>            serie <span class="op">=</span> modell.NewBoolVar(<span class="ss">f&quot;serie_</span><span class="sc">{</span>p<span class="sc">}</span><span class="ss">_</span><span class="sc">{</span>t<span class="sc">}</span><span class="ss">&quot;</span>)</span>
+<span id="cb14-63"><a href="#cb14-63" aria-hidden="true" tabindex="-1"></a>            modell.Add(x[p, t] <span class="op">+</span> x[p, t <span class="op">+</span> <span class="dv">1</span>] <span class="op">+</span> x[p, t <span class="op">+</span> <span class="dv">2</span>] <span class="op">&lt;=</span> <span class="dv">2</span> <span class="op">+</span> serie)</span>
+<span id="cb14-64"><a href="#cb14-64" aria-hidden="true" tabindex="-1"></a>            serien.append(serie)</span>
+<span id="cb14-65"><a href="#cb14-65" aria-hidden="true" tabindex="-1"></a>            strafterme.append(serie <span class="op">*</span> strafe_serie)</span>
+<span id="cb14-66"><a href="#cb14-66" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb14-67"><a href="#cb14-67" aria-hidden="true" tabindex="-1"></a>    <span class="co"># --- weiche Regel 2: Wunschfrei ------------------------------------</span></span>
+<span id="cb14-68"><a href="#cb14-68" aria-hidden="true" tabindex="-1"></a>    wunschverstoesse <span class="op">=</span> []</span>
+<span id="cb14-69"><a href="#cb14-69" aria-hidden="true" tabindex="-1"></a>    <span class="cf">for</span> p, t <span class="kw">in</span> WUNSCHFREI:</span>
+<span id="cb14-70"><a href="#cb14-70" aria-hidden="true" tabindex="-1"></a>        wunschverstoesse.append(x[p, t])</span>
+<span id="cb14-71"><a href="#cb14-71" aria-hidden="true" tabindex="-1"></a>        strafterme.append(x[p, t] <span class="op">*</span> STRAFE_WUNSCH)</span>
+<span id="cb14-72"><a href="#cb14-72" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb14-73"><a href="#cb14-73" aria-hidden="true" tabindex="-1"></a>    modell.Minimize(<span class="bu">sum</span>(strafterme))</span>
+<span id="cb14-74"><a href="#cb14-74" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb14-75"><a href="#cb14-75" aria-hidden="true" tabindex="-1"></a>    loeser <span class="op">=</span> cp_model.CpSolver()</span>
+<span id="cb14-76"><a href="#cb14-76" aria-hidden="true" tabindex="-1"></a>    loeser.parameters.max_time_in_seconds <span class="op">=</span> zeitlimit</span>
+<span id="cb14-77"><a href="#cb14-77" aria-hidden="true" tabindex="-1"></a>    loeser.parameters.num_workers <span class="op">=</span> <span class="dv">1</span>          <span class="co"># reproduzierbare Buchausgabe</span></span>
+<span id="cb14-78"><a href="#cb14-78" aria-hidden="true" tabindex="-1"></a>    loeser.parameters.random_seed <span class="op">=</span> <span class="dv">1</span></span>
+<span id="cb14-79"><a href="#cb14-79" aria-hidden="true" tabindex="-1"></a>    status <span class="op">=</span> loeser.Solve(modell)</span>
+<span id="cb14-80"><a href="#cb14-80" aria-hidden="true" tabindex="-1"></a>    <span class="cf">if</span> status <span class="kw">not</span> <span class="kw">in</span> (cp_model.OPTIMAL, cp_model.FEASIBLE):</span>
+<span id="cb14-81"><a href="#cb14-81" aria-hidden="true" tabindex="-1"></a>        <span class="cf">raise</span> <span class="pp">RuntimeError</span>(<span class="ss">f&quot;Kein Plan: </span><span class="sc">{</span>loeser<span class="sc">.</span>StatusName(status)<span class="sc">}</span><span class="ss">&quot;</span>)</span>
+<span id="cb14-82"><a href="#cb14-82" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb14-83"><a href="#cb14-83" aria-hidden="true" tabindex="-1"></a>    <span class="cf">return</span> {</span>
+<span id="cb14-84"><a href="#cb14-84" aria-hidden="true" tabindex="-1"></a>        <span class="st">&quot;status&quot;</span>: loeser.StatusName(status),</span>
+<span id="cb14-85"><a href="#cb14-85" aria-hidden="true" tabindex="-1"></a>        <span class="st">&quot;zielwert&quot;</span>: loeser.ObjectiveValue(),</span>
+<span id="cb14-86"><a href="#cb14-86" aria-hidden="true" tabindex="-1"></a>        <span class="st">&quot;serien&quot;</span>: <span class="bu">sum</span>(loeser.Value(v) <span class="cf">for</span> v <span class="kw">in</span> serien),</span>
+<span id="cb14-87"><a href="#cb14-87" aria-hidden="true" tabindex="-1"></a>        <span class="st">&quot;wunsch_verletzt&quot;</span>: <span class="bu">sum</span>(loeser.Value(v) <span class="cf">for</span> v <span class="kw">in</span> wunschverstoesse),</span>
+<span id="cb14-88"><a href="#cb14-88" aria-hidden="true" tabindex="-1"></a>    }</span>
+<span id="cb14-89"><a href="#cb14-89" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb14-90"><a href="#cb14-90" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb14-91"><a href="#cb14-91" aria-hidden="true" tabindex="-1"></a><span class="cf">if</span> <span class="va">__name__</span> <span class="op">==</span> <span class="st">&quot;__main__&quot;</span>:</span>
+<span id="cb14-92"><a href="#cb14-92" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;=&quot;</span> <span class="op">*</span> <span class="dv">78</span>)</span>
+<span id="cb14-93"><a href="#cb14-93" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;  STRAFGEWICHTE SIND WECHSELKURSE, KEINE WICHTIGKEITEN&quot;</span>)</span>
+<span id="cb14-94"><a href="#cb14-94" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;=&quot;</span> <span class="op">*</span> <span class="dv">78</span>)</span>
+<span id="cb14-95"><a href="#cb14-95" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;</span><span class="sc">{</span>PERSONEN<span class="sc">}</span><span class="ss"> Personen, </span><span class="sc">{</span>TAGE<span class="sc">}</span><span class="ss"> Tage, </span><span class="sc">{</span>PRO_TAG<span class="sc">}</span><span class="ss"> Besetzungen pro Tag &quot;</span></span>
+<span id="cb14-96"><a href="#cb14-96" aria-hidden="true" tabindex="-1"></a>          <span class="ss">f&quot;= </span><span class="sc">{</span>TAGE <span class="op">*</span> PRO_TAG<span class="sc">}</span><span class="ss"> Dienste&quot;</span>)</span>
+<span id="cb14-97"><a href="#cb14-97" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;Das sind </span><span class="sc">{</span>TAGE <span class="op">*</span> PRO_TAG <span class="op">/</span> PERSONEN<span class="sc">:.1f}</span><span class="ss"> Dienste je Person - der Plan ist eng.&quot;</span>)</span>
+<span id="cb14-98"><a href="#cb14-98" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;</span><span class="sc">{</span><span class="bu">len</span>(WUNSCHFREI)<span class="sc">}</span><span class="ss"> Wunschfrei-Antraege, Strafe je abgelehntem Wunsch: &quot;</span></span>
+<span id="cb14-99"><a href="#cb14-99" aria-hidden="true" tabindex="-1"></a>          <span class="ss">f&quot;</span><span class="sc">{</span>STRAFE_WUNSCH<span class="sc">}</span><span class="ch">\n</span><span class="ss">&quot;</span>)</span>
+<span id="cb14-100"><a href="#cb14-100" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb14-101"><a href="#cb14-101" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;</span><span class="sc">{</span><span class="st">&#39;Strafe je 3er-Serie&#39;</span><span class="sc">:&gt;20}</span><span class="ss"> </span><span class="sc">{</span><span class="st">&#39;3er-Serien&#39;</span><span class="sc">:&gt;12}</span><span class="ss"> </span><span class="sc">{</span><span class="st">&#39;Wunsch verletzt&#39;</span><span class="sc">:&gt;17}</span><span class="ss"> &quot;</span></span>
+<span id="cb14-102"><a href="#cb14-102" aria-hidden="true" tabindex="-1"></a>          <span class="ss">f&quot;</span><span class="sc">{</span><span class="st">&#39;Zielwert&#39;</span><span class="sc">:&gt;10}</span><span class="ss">&quot;</span>)</span>
+<span id="cb14-103"><a href="#cb14-103" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;-&quot;</span> <span class="op">*</span> <span class="dv">78</span>)</span>
+<span id="cb14-104"><a href="#cb14-104" aria-hidden="true" tabindex="-1"></a>    ergebnisse <span class="op">=</span> {}</span>
+<span id="cb14-105"><a href="#cb14-105" aria-hidden="true" tabindex="-1"></a>    <span class="cf">for</span> strafe <span class="kw">in</span> (<span class="dv">1</span>, <span class="dv">2</span>, <span class="dv">5</span>, <span class="dv">10</span>, <span class="dv">30</span>, <span class="dv">100</span>):</span>
+<span id="cb14-106"><a href="#cb14-106" aria-hidden="true" tabindex="-1"></a>        e <span class="op">=</span> plane(strafe)</span>
+<span id="cb14-107"><a href="#cb14-107" aria-hidden="true" tabindex="-1"></a>        ergebnisse[strafe] <span class="op">=</span> e</span>
+<span id="cb14-108"><a href="#cb14-108" aria-hidden="true" tabindex="-1"></a>        <span class="bu">print</span>(<span class="ss">f&quot;</span><span class="sc">{</span>strafe<span class="sc">:&gt;20}</span><span class="ss"> </span><span class="sc">{</span>e[<span class="st">&#39;serien&#39;</span>]<span class="sc">:&gt;12}</span><span class="ss"> </span><span class="sc">{</span>e[<span class="st">&#39;wunsch_verletzt&#39;</span>]<span class="sc">:&gt;17}</span><span class="ss"> &quot;</span></span>
+<span id="cb14-109"><a href="#cb14-109" aria-hidden="true" tabindex="-1"></a>              <span class="ss">f&quot;</span><span class="sc">{</span>e[<span class="st">&#39;zielwert&#39;</span>]<span class="sc">:&gt;10.0f}</span><span class="ss">&quot;</span>)</span>
+<span id="cb14-110"><a href="#cb14-110" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;-&quot;</span> <span class="op">*</span> <span class="dv">78</span>)</span>
+<span id="cb14-111"><a href="#cb14-111" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb14-112"><a href="#cb14-112" aria-hidden="true" tabindex="-1"></a>    niedrig, hoch <span class="op">=</span> ergebnisse[<span class="dv">1</span>], ergebnisse[<span class="dv">30</span>]</span>
+<span id="cb14-113"><a href="#cb14-113" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;</span><span class="ch">\n</span><span class="ss">Bei Strafe 1 baut der Solver </span><span class="sc">{</span>niedrig[<span class="st">&#39;serien&#39;</span>]<span class="sc">}</span><span class="ss"> Drei-Tage-Serien ein.&quot;</span>)</span>
+<span id="cb14-114"><a href="#cb14-114" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;Die Betriebsvereinbarung steht im Modell - und wird trotzdem&quot;</span>)</span>
+<span id="cb14-115"><a href="#cb14-115" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;systematisch verletzt. Das ist kein Fehler des Solvers: Bei einem&quot;</span>)</span>
+<span id="cb14-116"><a href="#cb14-116" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;Gewicht von 1 gegen </span><span class="sc">{</span>STRAFE_WUNSCH<span class="sc">}</span><span class="ss"> lohnt sich jede Serie, solange sie&quot;</span>)</span>
+<span id="cb14-117"><a href="#cb14-117" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;auch nur einen Zehntel-Wunsch rettet.&quot;</span>)</span>
+<span id="cb14-118"><a href="#cb14-118" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;</span><span class="ch">\n</span><span class="ss">Bei Strafe 30 sind es </span><span class="sc">{</span>hoch[<span class="st">&#39;serien&#39;</span>]<span class="sc">}</span><span class="ss"> Serien - dafuer werden&quot;</span>)</span>
+<span id="cb14-119"><a href="#cb14-119" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;</span><span class="sc">{</span>hoch[<span class="st">&#39;wunsch_verletzt&#39;</span>]<span class="sc">}</span><span class="ss"> statt </span><span class="sc">{</span>niedrig[<span class="st">&#39;wunsch_verletzt&#39;</span>]<span class="sc">}</span><span class="ss"> Wuensche abgelehnt.&quot;</span>)</span>
+<span id="cb14-120"><a href="#cb14-120" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;Beide Plaene sind optimal. Sie beantworten nur verschiedene Fragen.&quot;</span>)</span>
+<span id="cb14-121"><a href="#cb14-121" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>()</span>
+<span id="cb14-122"><a href="#cb14-122" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;Die Frage lautet also nie &#39;wie wichtig ist mir diese Regel?&#39;, sondern:&quot;</span>)</span>
+<span id="cb14-123"><a href="#cb14-123" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;  &#39;Wie viele abgelehnte Wuensche bin ich bereit zu akzeptieren,&quot;</span>)</span>
+<span id="cb14-124"><a href="#cb14-124" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;   um eine Drei-Tage-Serie zu vermeiden?&#39;&quot;</span>)</span>
+<span id="cb14-125"><a href="#cb14-125" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;Wer darauf keine Zahl nennen kann, hat das Problem noch nicht&quot;</span>)</span>
+<span id="cb14-126"><a href="#cb14-126" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;verstanden - und sollte diese Tabelle dem Auftraggeber vorlegen,&quot;</span>)</span>
+<span id="cb14-127"><a href="#cb14-127" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;statt ein Gewicht zu raten.&quot;</span>)</span>
+<span id="cb14-128"><a href="#cb14-128" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>()</span>
+<span id="cb14-129"><a href="#cb14-129" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;Und die wichtigste Konsequenz: Eine Regel, die NIE gebrochen werden&quot;</span>)</span>
+<span id="cb14-130"><a href="#cb14-130" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;darf, gehoert nicht in die Zielfunktion, sondern unter die harten&quot;</span>)</span>
+<span id="cb14-131"><a href="#cb14-131" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;Nebenbedingungen. Alles, was einen Preis hat, wird irgendwann gekauft.&quot;</span>)</span>
+<span id="cb14-132"><a href="#cb14-132" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;=&quot;</span> <span class="op">*</span> <span class="dv">78</span>)</span></code></pre></div>
 <p><strong>Erwartete Ausgabe:</strong></p>
 <pre><code>==============================================================================
   STRAFGEWICHTE SIND WECHSELKURSE, KEINE WICHTIGKEITEN
@@ -1475,10 +1777,10 @@ Nebenbedingungen. Alles, was einen Preis hat, wird irgendwann gekauft.
 </ul>
 </blockquote>
 <hr />
-<h2 id="sec:cpsat-quiz">7.10 Micro-Quiz</h2>
+<h2 id="sec:cpsat-quiz">7.11 Micro-Quiz</h2>
 <div class="card card-quiz">
 <blockquote>
-<p><strong>❓ Micro-Quiz 6: Drei Fragen zum Selbstcheck</strong></p>
+<p><strong>❓ Micro-Quiz 7: Drei Fragen zum Selbstcheck</strong></p>
 <p>Genau eine Antwort ist jeweils richtig. Auflösung in <a href="anhang-loesungen.html#quiz-loesung-cpsat">Anhang A</a>.</p>
 <p><strong>1. Ihr Dienstplanmodell meldet <code>INFEASIBLE</code>. Ein Kollege schlägt vor, das Zeitlimit von 10 auf 300 Sekunden zu erhöhen. Was halten Sie davon?</strong> (a) Sinnvoll — bei schweren Instanzen braucht CP-SAT einfach länger. (b) Wirkungslos: <code>INFEASIBLE</code> ist ein <strong>Beweis</strong>, dass keine zulässige Lösung existiert. Die Ursache liegt in den harten Regeln, nicht in der Rechenzeit. (c) Sinnvoll, aber nur zusammen mit mehr Arbeitern (<code>num_workers</code>).</p>
 <p><strong>2. Sie modellieren „auf einer Maschine läuft immer nur ein Auftrag“. Was ist der Vorteil von <code>AddNoOverlap</code> gegenüber der MILP-Formulierung mit Big-M?</strong> (a) <code>AddNoOverlap</code> findet grundsätzlich bessere Lösungen. (b) Eine Zeile ersetzt bei <span class="math inline">k</span> Aufträgen <span class="math inline">\binom{k}{2}</span> Entweder-Oder-Konstruktionen mit je zwei Ungleichungen und einer Binärvariablen — und propagiert stärker, weil der Propagator die Struktur als Ganzes betrachtet. (c) <code>AddNoOverlap</code> funktioniert auch mit kontinuierlichen Zeiten, Big-M nicht.</p>
@@ -1486,7 +1788,7 @@ Nebenbedingungen. Alles, was einen Preis hat, wird irgendwann gekauft.
 </blockquote>
 </div>
 <hr />
-<h2 id="sec:cpsat-selbsttest">7.11 Selbsttest</h2>
+<h2 id="sec:cpsat-selbsttest">7.12 Selbsttest</h2>
 <blockquote>
 <p>Antworten: <a href="anhang-loesungen.html#selbsttest-loesung-cpsat">Anhang A</a>.</p>
 </blockquote>
@@ -1495,21 +1797,24 @@ Nebenbedingungen. Alles, was einen Preis hat, wird irgendwann gekauft.
 <li>Welchen Vorteil hat <code>AddAllDifferent(x)</code> gegenüber <span class="math inline">\binom{n}{2}</span> Einzelbedingungen?</li>
 <li>Was ist eine Intervallvariable, und welche Bedingung garantiert sie automatisch?</li>
 <li>Warum sollten möglichst wenige Bedingungen hart formuliert werden?</li>
-<li>Warum ist die Aufschlüsselung der Strafkosten in der Praxis wichtiger als der Zielwert selbst?</li>
+<li>Warum ist die Aufschlüsselung der Strafkosten in der Praxis wichtiger als der Zielwert</li>
+<li>Sie setzen <code>random_seed = 1</code>, bekommen aber trotzdem bei jedem Lauf einen anderen Plan. Woran liegt das, und was hilft?</li>
+<li>Warum kann ein CP-SAT-Lauf mit acht Arbeitern <strong>mehr</strong> als achtmal schneller sein als mit einem? selbst?</li>
 </ol>
 <hr />
-<h2 id="sec:cpsat-zusammenfassung">7.12 Zusammenfassung</h2>
+<h2 id="sec:cpsat-zusammenfassung">7.13 Zusammenfassung</h2>
 <ul>
-<li><strong>CP denkt in Wertebereichen und Regeln</strong>, nicht in Ungleichungen und Schranken.</li>
-<li><strong>Propagation</strong> streicht unmögliche Werte, bevor gesucht wird; <strong>Conflict Learning</strong> verhindert, dieselbe Sackgasse zweimal zu betreten.</li>
-<li><strong>Globale Constraints</strong> wie ,  und  ersetzen ganze Blöcke von Big-M-Ungleichungen und propagieren stärker.</li>
-<li><strong>Intervallvariablen</strong> sind das Werkzeug für Zeitplanung; <code>AddNoOverlap</code> erledigt in einer Zeile, was in MILP dutzende Disjunktionen kostet.</li>
-<li><strong>Weiche Ziele mit Strafkosten</strong> machen Modelle robust gegen <code>INFEASIBLE</code> — und die <strong>Kostenzerlegung</strong> macht sie erklärbar.</li>
-<li><strong>Strafgewichte sind Wechselkurse, keine Wichtigkeiten.</strong> Rechnen Sie mehrere Gewichte durch und lassen Sie den Auftraggeber eine Zeile der Tabelle wählen. Und was nie gebrochen werden darf, gehört unter die harten Nebenbedingungen: Alles, was einen Preis hat, wird irgendwann gekauft.</li>
-<li><strong>Fünf Antworten, nicht zwei.</strong> <code>INFEASIBLE</code> (es gibt keine Lösung), <code>UNKNOWN</code> (es wurde keine gefunden) und <code>MODEL_INVALID</code> (Ihr Code ist fehlerhaft) bedeuten Grundverschiedenes. Wer sie in ein <code>else</code> zusammenfasst, verliert die Information zur Fehlersuche.</li>
-<li><strong>Bei mehrdeutigen Optima nie auf einen bestimmten Plan testen</strong> — nur auf den Zielwert und die Einhaltung aller Regeln.</li>
+<li><p><strong>CP denkt in Wertebereichen und Regeln</strong>, nicht in Ungleichungen und Schranken.</p></li>
+<li><p><strong>Propagation</strong> streicht unmögliche Werte, bevor gesucht wird; <strong>Conflict Learning</strong> verhindert, dieselbe Sackgasse zweimal zu betreten.</p></li>
+<li><p><strong>Globale Constraints</strong> wie ,  und  ersetzen ganze Blöcke von Big-M-Ungleichungen und propagieren stärker.</p></li>
+<li><p><strong>Intervallvariablen</strong> sind das Werkzeug für Zeitplanung; <code>AddNoOverlap</code> erledigt in einer Zeile, was in MILP dutzende Disjunktionen kostet.</p></li>
+<li><p><strong>Weiche Ziele mit Strafkosten</strong> machen Modelle robust gegen <code>INFEASIBLE</code> — und die <strong>Kostenzerlegung</strong> macht sie erklärbar.</p></li>
+<li><p><strong>Strafgewichte sind Wechselkurse, keine Wichtigkeiten.</strong> Rechnen Sie mehrere Gewichte durch und lassen Sie den Auftraggeber eine Zeile der Tabelle wählen. Und was nie gebrochen werden darf, gehört unter die harten Nebenbedingungen: Alles, was einen Preis hat, wird irgendwann gekauft.</p></li>
+<li><p><strong>Fünf Antworten, nicht zwei.</strong> <code>INFEASIBLE</code> (es gibt keine Lösung), <code>UNKNOWN</code> (es wurde keine gefunden) und <code>MODEL_INVALID</code> (Ihr Code ist fehlerhaft) bedeuten Grundverschiedenes. Wer sie in ein <code>else</code> zusammenfasst, verliert die Information zur Fehlersuche.</p></li>
+<li><p><strong>Bei mehrdeutigen Optima nie auf einen bestimmten Plan testen</strong> — nur auf den Zielwert und die Einhaltung aller Regeln.</p></li>
+<li><p><strong>Ein paralleler Solver hat zwei Zufallsquellen: den Seed und die Uhr.</strong> Nur die erste lässt sich setzen. Reproduzierbar wird ein Lauf erst mit <code>num_workers = 1</code> <strong>und</strong> Seed — gemessen in <a href="#sec:cpsat-parallele-suche">Abschnitt 7.7</a>: schon zwei Arbeiter liefern bei identischem Seed drei verschiedene Pläne zum selben Zielwert.</p></li>
+<li><p><strong>Parallele Suche kann überlinear beschleunigen</strong>, weil CP-SAT nicht dieselbe Suche vervielfacht, sondern verschiedene Strategien nebeneinander laufen lässt, die einander ihre Schranken mitteilen. <strong>Ausblick.</strong> <a href="graphen.html#kap-graphen">Kapitel 8</a> behandelt Probleme, die sich am besten als <strong>Graph</strong> begreifen lassen: Flüsse durch Netzwerke, Zuordnungen und die Tourenplanung mit Fahrzeugen und Zeitfenstern.</p></li>
 </ul>
-<p><strong>Ausblick.</strong> <a href="graphen.html#kap-graphen">Kapitel 8</a> behandelt Probleme, die sich am besten als <strong>Graph</strong> begreifen lassen: Flüsse durch Netzwerke, Zuordnungen und die Tourenplanung mit Fahrzeugen und Zeitfenstern.</p>
 
     </article>
     <button type="button" class="fortschritt-knopf" data-kapitel="cpsat.html"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg> <span>Als gelesen markieren</span></button>
diff --git a/OR_HTML_04/cvar.html b/OR_HTML_04/cvar.html
index 67209b1..cdae5e8 100644
--- a/OR_HTML_04/cvar.html
+++ b/OR_HTML_04/cvar.html
@@ -94,7 +94,7 @@
 </header>
 <div class="site-body">
   <div class="sidebar-overlay" id="sidebar-overlay" hidden></div>
-  <nav class="sidebar" id="sidebar" aria-label="Kapitelnavigation"><div class="sidebar-inhalt"><details class="sidebar-gruppe"><summary>Einstieg</summary><ul><li data-kapitel="vorwort.html"><a href="vorwort.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Vorwort & Lesehilfe</span></a></li><li data-kapitel="notation.html"><a href="notation.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Notation & Abkürzungen</span></a></li></ul></details><details class="sidebar-gruppe"><summary>Teil I: Grundlagen des Operations Research</summary><ul><li data-kapitel="einfuehrung.html"><a href="einfuehrung.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 1: Einführung in Operations Research — Vom Ursprung zur mathematischen Entscheidungsfindung</span></a></li><li data-kapitel="fundament.html"><a href="fundament.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 2: Das mathematische Fundament — Vektoren, Matrizen, Konvexität</span></a></li><li data-kapitel="oekosystem.html"><a href="oekosystem.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 3: Das Python-Ökosystem für OR — Solver, Bindings und Modellierungsschichten</span></a></li><li data-kapitel="modellierung.html"><a href="modellierung.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 4: Vom Management-Wunsch zum Modell</span></a></li></ul></details><details class="sidebar-gruppe"><summary>Teil II: Die Kernverfahren der deterministischen Optimierung</summary><ul><li data-kapitel="lp.html"><a href="lp.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 5: Lineare Programmierung — Simplex, Dualität und Schattenpreise</span></a></li><li data-kapitel="milp.html"><a href="milp.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 6: Gemischt-ganzzahlige Optimierung — Diskrete Entscheidungen und Branch-and-Bound</span></a></li><li data-kapitel="cpsat.html"><a href="cpsat.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 7: Constraint Programming mit CP-SAT — Logik, Scheduling und Zuweisung</span></a></li><li data-kapitel="graphen.html"><a href="graphen.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 8: Graphen, Flüsse und Touren — Min-Cost-Flow, Matching und VRP</span></a></li><li data-kapitel="metaheuristiken.html"><a href="metaheuristiken.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 9: Metaheuristiken — wenn der exakte Solver aussteigt</span></a></li><li data-kapitel="dekomposition.html"><a href="dekomposition.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 10: Spaltengenerierung — das Modell umbauen statt die Lösung raten</span></a></li></ul></details><details class="sidebar-gruppe"><summary>Teil III: Nichtlinearität, Unsicherheit und mehrperiodige Dynamik</summary><ul><li data-kapitel="qp-nlp.html"><a href="qp-nlp.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 11: Quadratische und nichtlineare Optimierung — KKT, Lagrange, Konvexität</span></a></li><li data-kapitel="unsicherheit.html"><a href="unsicherheit.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 12: Optimierung unter Unsicherheit — Monte-Carlo, Stochastik, Robustheit</span></a></li><li data-kapitel="dynamische-programmierung.html"><a href="dynamische-programmierung.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 13: Dynamische Programmierung — Die Bellman-Gleichung und Order-Execution</span></a></li><li data-kapitel="mehrziel.html"><a href="mehrziel.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 14: Mehrere Ziele — Pareto-Fronten statt Gewichte</span></a></li><li data-kapitel="prognose.html"><a href="prognose.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 15: Predict-then-Optimize — die bessere Prognose, die schlechtere Entscheidung</span></a></li></ul></details><details class="sidebar-gruppe" open><summary>Teil IV: Anwendungen — Energiewirtschaft und Finanzmärkte</summary><ul><li data-kapitel="bruecke.html"><a href="bruecke.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 16: Die Strukturbrücke — dieselbe Mathematik, zwei Welten</span></a></li><li data-kapitel="supplychain.html"><a href="supplychain.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 17: Supply-Chain und Energieeinsatz unter Unsicherheit</span></a></li><li data-kapitel="finanzdaten.html"><a href="finanzdaten.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 18: Finanzdaten-Modellierung — Renditen, Kovarianz und Shrinkage</span></a></li><li data-kapitel="markowitz.html"><a href="markowitz.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 19: Die moderne Portfoliotheorie nach Markowitz</span></a></li><li data-kapitel="cvar.html" class="aktiv"><a href="cvar.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 20: Tail-Risiko, CVaR und Transaktionskosten</span></a></li><li data-kapitel="handelsmaschine.html"><a href="handelsmaschine.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 21: Die vollständige quantitative Handelsmaschine</span></a></li></ul></details><details class="sidebar-gruppe"><summary>Teil V: Praxis</summary><ul><li data-kapitel="praxisfallen.html"><a href="praxisfallen.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 22: Praxisfallen und der Weg zum produktiven Einsatz</span></a></li><li data-kapitel="testing.html"><a href="testing.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 23: Testen, Messen, Ausliefern</span></a></li><li data-kapitel="projektwerkstatt.html"><a href="projektwerkstatt.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Projektwerkstatt</span></a></li></ul></details><details class="sidebar-gruppe"><summary>Anhänge</summary><ul><li data-kapitel="anhang-loesungen.html"><a href="anhang-loesungen.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Anhang A: Lösungen zu allen Übungsaufgaben</span></a></li><li data-kapitel="anhang-modellierungsmuster.html"><a href="anhang-modellierungsmuster.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Anhang B: Katalog der Modellierungsmuster</span></a></li><li data-kapitel="anhang-fehlerdiagnose.html"><a href="anhang-fehlerdiagnose.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Anhang C: Fehlerdiagnose-Handbuch</span></a></li><li data-kapitel="anhang-spickzettel.html"><a href="anhang-spickzettel.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Anhang D: Spickzettel der Solver</span></a></li><li data-kapitel="anhang-glossar-literatur.html"><a href="anhang-glossar-literatur.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Anhang E: Glossar und Literatur</span></a></li></ul></details><ul class="sidebar-extra"><li><a href="programme.html"><svg class="icon" aria-hidden="true"><use href="#icon-book"></use></svg> Beispielprogramme</a></li><li><a href="stichwortverzeichnis.html"><svg class="icon" aria-hidden="true"><use href="#icon-search"></use></svg> Stichwortverzeichnis</a></li><li><a href="gesamtdokument.html"><svg class="icon" aria-hidden="true"><use href="#icon-external-link"></use></svg> Gesamtdokument (eine Seite)</a></li><li><a href="Operations_Research_mit_Python_Version_04.pdf" download><svg class="icon" aria-hidden="true"><use href="#icon-download"></use></svg> Download als PDF</a></li></ul></div></nav>
+  <nav class="sidebar" id="sidebar" aria-label="Kapitelnavigation"><div class="sidebar-inhalt"><details class="sidebar-gruppe"><summary>Einstieg</summary><ul><li data-kapitel="vorwort.html"><a href="vorwort.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Vorwort & Lesehilfe</span></a></li><li data-kapitel="notation.html"><a href="notation.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Notation & Abkürzungen</span></a></li></ul></details><details class="sidebar-gruppe"><summary>Teil I: Grundlagen des Operations Research</summary><ul><li data-kapitel="einfuehrung.html"><a href="einfuehrung.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 1: Einführung in Operations Research — Vom Ursprung zur mathematischen Entscheidungsfindung</span></a></li><li data-kapitel="fundament.html"><a href="fundament.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 2: Das mathematische Fundament — Vektoren, Matrizen, Konvexität</span></a></li><li data-kapitel="oekosystem.html"><a href="oekosystem.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 3: Das Python-Ökosystem für OR — Solver, Bindings und Modellierungsschichten</span></a></li><li data-kapitel="modellierung.html"><a href="modellierung.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 4: Vom Management-Wunsch zum Modell</span></a></li><li data-kapitel="synthese-grundlagen.html"><a href="synthese-grundlagen.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Synthese Teil I</span></a></li></ul></details><details class="sidebar-gruppe"><summary>Teil II: Die Kernverfahren der deterministischen Optimierung</summary><ul><li data-kapitel="lp.html"><a href="lp.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 5: Lineare Programmierung — Simplex, Dualität und Schattenpreise</span></a></li><li data-kapitel="milp.html"><a href="milp.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 6: Gemischt-ganzzahlige Optimierung — Diskrete Entscheidungen und Branch-and-Bound</span></a></li><li data-kapitel="cpsat.html"><a href="cpsat.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 7: Constraint Programming mit CP-SAT — Logik, Scheduling und Zuweisung</span></a></li><li data-kapitel="graphen.html"><a href="graphen.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 8: Graphen, Flüsse und Touren — Min-Cost-Flow, Matching und VRP</span></a></li><li data-kapitel="metaheuristiken.html"><a href="metaheuristiken.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 9: Metaheuristiken — wenn der exakte Solver aussteigt</span></a></li><li data-kapitel="dekomposition.html"><a href="dekomposition.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 10: Spaltengenerierung — das Modell umbauen statt die Lösung raten</span></a></li><li data-kapitel="synthese-kernverfahren.html"><a href="synthese-kernverfahren.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Synthese Teil II</span></a></li></ul></details><details class="sidebar-gruppe"><summary>Teil III: Nichtlinearität, Unsicherheit und mehrperiodige Dynamik</summary><ul><li data-kapitel="qp-nlp.html"><a href="qp-nlp.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 11: Quadratische und nichtlineare Optimierung — KKT, Lagrange, Konvexität</span></a></li><li data-kapitel="unsicherheit.html"><a href="unsicherheit.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 12: Optimierung unter Unsicherheit — Monte-Carlo, Stochastik, Robustheit</span></a></li><li data-kapitel="dynamische-programmierung.html"><a href="dynamische-programmierung.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 13: Dynamische Programmierung — Die Bellman-Gleichung und Order-Execution</span></a></li><li data-kapitel="mehrziel.html"><a href="mehrziel.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 14: Mehrere Ziele — Pareto-Fronten statt Gewichte</span></a></li><li data-kapitel="prognose.html"><a href="prognose.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 15: Predict-then-Optimize — die bessere Prognose, die schlechtere Entscheidung</span></a></li><li data-kapitel="synthese-nichtlinear.html"><a href="synthese-nichtlinear.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Synthese Teil III</span></a></li></ul></details><details class="sidebar-gruppe" open><summary>Teil IV: Anwendungen — Energiewirtschaft und Finanzmärkte</summary><ul><li data-kapitel="bruecke.html"><a href="bruecke.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 16: Die Strukturbrücke — dieselbe Mathematik, zwei Welten</span></a></li><li data-kapitel="supplychain.html"><a href="supplychain.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 17: Supply-Chain und Energieeinsatz unter Unsicherheit</span></a></li><li data-kapitel="finanzdaten.html"><a href="finanzdaten.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 18: Finanzdaten-Modellierung — Renditen, Kovarianz und Shrinkage</span></a></li><li data-kapitel="markowitz.html"><a href="markowitz.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 19: Die moderne Portfoliotheorie nach Markowitz</span></a></li><li data-kapitel="cvar.html" class="aktiv"><a href="cvar.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 20: Tail-Risiko, CVaR und Transaktionskosten</span></a></li><li data-kapitel="handelsmaschine.html"><a href="handelsmaschine.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 21: Die vollständige quantitative Handelsmaschine</span></a></li><li data-kapitel="synthese-anwendungen.html"><a href="synthese-anwendungen.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Synthese Teil IV</span></a></li></ul></details><details class="sidebar-gruppe"><summary>Teil V: Praxis</summary><ul><li data-kapitel="praxisfallen.html"><a href="praxisfallen.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 22: Praxisfallen und der Weg zum produktiven Einsatz</span></a></li><li data-kapitel="testing.html"><a href="testing.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 23: Testen, Messen, Ausliefern</span></a></li><li data-kapitel="synthese-praxis.html"><a href="synthese-praxis.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Synthese Teil V</span></a></li><li data-kapitel="projektwerkstatt.html"><a href="projektwerkstatt.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Projektwerkstatt</span></a></li></ul></details><details class="sidebar-gruppe"><summary>Anhänge</summary><ul><li data-kapitel="anhang-loesungen.html"><a href="anhang-loesungen.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Anhang A: Lösungen zu allen Übungsaufgaben</span></a></li><li data-kapitel="anhang-modellierungsmuster.html"><a href="anhang-modellierungsmuster.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Anhang B: Katalog der Modellierungsmuster</span></a></li><li data-kapitel="anhang-fehlerdiagnose.html"><a href="anhang-fehlerdiagnose.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Anhang C: Fehlerdiagnose-Handbuch</span></a></li><li data-kapitel="anhang-spickzettel.html"><a href="anhang-spickzettel.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Anhang D: Spickzettel der Solver</span></a></li><li data-kapitel="anhang-glossar-literatur.html"><a href="anhang-glossar-literatur.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Anhang E: Glossar und Literatur</span></a></li></ul></details><ul class="sidebar-extra"><li><a href="programme.html"><svg class="icon" aria-hidden="true"><use href="#icon-book"></use></svg> Beispielprogramme</a></li><li><a href="stichwortverzeichnis.html"><svg class="icon" aria-hidden="true"><use href="#icon-search"></use></svg> Stichwortverzeichnis</a></li><li><a href="gesamtdokument.html"><svg class="icon" aria-hidden="true"><use href="#icon-external-link"></use></svg> Gesamtdokument (eine Seite)</a></li><li><a href="Operations_Research_mit_Python_Version_04.pdf" download><svg class="icon" aria-hidden="true"><use href="#icon-download"></use></svg> Download als PDF</a></li></ul></div></nav>
   <main class="content">
     <nav class="breadcrumb" aria-label="Breadcrumb"><a href="index.html">Start</a> › <span>Teil IV</span> › <span>Kapitel 20: Tail-Risiko, CVaR und Transaktionskosten</span></nav>
     <nav class="prev-next"><a class="prev-next-knopf prev-next-prev" href="markowitz.html"><svg class="icon" aria-hidden="true"><use href="#icon-chevron-left"></use></svg><span><small>Zurück</small>Kapitel 19: Die moderne Portfoliotheorie nach Markowitz</span></a><a class="prev-next-knopf prev-next-next" href="handelsmaschine.html"><span><small>Weiter</small>Kapitel 21: Die vollständige quantitative Handelsmaschine</span><svg class="icon" aria-hidden="true"><use href="#icon-chevron-right"></use></svg></a></nav>
@@ -703,7 +703,7 @@ CVaR: Portfolio  101.33  vs. Summe  159.24  -&gt; subadditiv (kohaerent)
 <h2 id="sec:cvar-denkfehler">20.8 Finde den Denkfehler</h2>
 <div class="card card-denkfehler">
 <blockquote>
-<p><strong>🐛 Finde den Denkfehler 13.1: Das Risikobudget, das durch Diversifikation stieg</strong></p>
+<p><strong>🐛 Finde den Denkfehler: Das Risikobudget, das durch Diversifikation stieg</strong></p>
 <p>Eine Bank vergibt Risikobudgets je Abteilung. Zwei Kreditabteilungen halten je eine Unternehmensanleihe über 100 € Nominal mit <strong>4 % Ausfallwahrscheinlichkeit</strong> (bei Ausfall Totalverlust, sonst 2 € Kupon). Der Risikocontroller misst für jede einzeln:</p>
 <p><span class="math display">\text{VaR}_{95}(\text{A}) = -2{,}00\,€, \qquad \text{VaR}_{95}(\text{B}) = -2{,}00\,€</span></p>
 <p>Ein <em>negativer</em> Verlust, also ein Gewinn. Auf dem 95-%-Niveau erscheint jede Anleihe risikolos, beide Abteilungen bekommen grünes Licht. Der Controller notiert als Gesamtrisiko die Summe: <span class="math inline">-4{,}00\,€</span>.</p>
@@ -731,7 +731,7 @@ CVaR: Portfolio  101.33  vs. Summe  159.24  -&gt; subadditiv (kohaerent)
 <h2 id="sec:cvar-quiz">20.9 Micro-Quiz</h2>
 <div class="card card-quiz">
 <blockquote>
-<p><strong>❓ Micro-Quiz 13: Drei Fragen zum Selbstcheck</strong></p>
+<p><strong>❓ Micro-Quiz 20: Drei Fragen zum Selbstcheck</strong></p>
 <p>Genau eine Antwort ist jeweils richtig. Auflösung in <a href="anhang-loesungen.html#quiz-loesung-cvar">Anhang A</a>.</p>
 <p><strong>1. Zwei Anlagen haben denselben VaR(95) von 3 %. Was wissen Sie über ihre Extremverluste?</strong> (a) Sie sind gleich hoch — der VaR misst genau das. (b) <strong>Nichts.</strong> Der VaR ist ein Quantil: Er markiert die Schwelle und sagt nichts darüber, was dahinter liegt. Die eine kann dort −3 %, die andere −40 % haben. (c) Die Anlage mit der höheren Schwankung hat auch die höheren Extremverluste.</p>
 <p><strong>2. Warum lässt sich der CVaR als lineares Programm minimieren, der VaR aber nicht?</strong> (a) Der VaR ist nicht differenzierbar. (b) Der CVaR lässt sich nach Rockafellar/Uryasev über eine Hilfsvariable und Schlupfterme als konvexes — sogar lineares — Problem schreiben. Die VaR-Minimierung ist dagegen nicht konvex und hat viele lokale Optima. (c) Der CVaR ist immer größer als der VaR.</p>
diff --git a/OR_HTML_04/dekomposition.html b/OR_HTML_04/dekomposition.html
index 42139f4..a59870b 100644
--- a/OR_HTML_04/dekomposition.html
+++ b/OR_HTML_04/dekomposition.html
@@ -94,10 +94,10 @@
 </header>
 <div class="site-body">
   <div class="sidebar-overlay" id="sidebar-overlay" hidden></div>
-  <nav class="sidebar" id="sidebar" aria-label="Kapitelnavigation"><div class="sidebar-inhalt"><details class="sidebar-gruppe"><summary>Einstieg</summary><ul><li data-kapitel="vorwort.html"><a href="vorwort.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Vorwort & Lesehilfe</span></a></li><li data-kapitel="notation.html"><a href="notation.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Notation & Abkürzungen</span></a></li></ul></details><details class="sidebar-gruppe"><summary>Teil I: Grundlagen des Operations Research</summary><ul><li data-kapitel="einfuehrung.html"><a href="einfuehrung.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 1: Einführung in Operations Research — Vom Ursprung zur mathematischen Entscheidungsfindung</span></a></li><li data-kapitel="fundament.html"><a href="fundament.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 2: Das mathematische Fundament — Vektoren, Matrizen, Konvexität</span></a></li><li data-kapitel="oekosystem.html"><a href="oekosystem.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 3: Das Python-Ökosystem für OR — Solver, Bindings und Modellierungsschichten</span></a></li><li data-kapitel="modellierung.html"><a href="modellierung.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 4: Vom Management-Wunsch zum Modell</span></a></li></ul></details><details class="sidebar-gruppe" open><summary>Teil II: Die Kernverfahren der deterministischen Optimierung</summary><ul><li data-kapitel="lp.html"><a href="lp.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 5: Lineare Programmierung — Simplex, Dualität und Schattenpreise</span></a></li><li data-kapitel="milp.html"><a href="milp.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 6: Gemischt-ganzzahlige Optimierung — Diskrete Entscheidungen und Branch-and-Bound</span></a></li><li data-kapitel="cpsat.html"><a href="cpsat.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 7: Constraint Programming mit CP-SAT — Logik, Scheduling und Zuweisung</span></a></li><li data-kapitel="graphen.html"><a href="graphen.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 8: Graphen, Flüsse und Touren — Min-Cost-Flow, Matching und VRP</span></a></li><li data-kapitel="metaheuristiken.html"><a href="metaheuristiken.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 9: Metaheuristiken — wenn der exakte Solver aussteigt</span></a></li><li data-kapitel="dekomposition.html" class="aktiv"><a href="dekomposition.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 10: Spaltengenerierung — das Modell umbauen statt die Lösung raten</span></a></li></ul></details><details class="sidebar-gruppe"><summary>Teil III: Nichtlinearität, Unsicherheit und mehrperiodige Dynamik</summary><ul><li data-kapitel="qp-nlp.html"><a href="qp-nlp.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 11: Quadratische und nichtlineare Optimierung — KKT, Lagrange, Konvexität</span></a></li><li data-kapitel="unsicherheit.html"><a href="unsicherheit.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 12: Optimierung unter Unsicherheit — Monte-Carlo, Stochastik, Robustheit</span></a></li><li data-kapitel="dynamische-programmierung.html"><a href="dynamische-programmierung.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 13: Dynamische Programmierung — Die Bellman-Gleichung und Order-Execution</span></a></li><li data-kapitel="mehrziel.html"><a href="mehrziel.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 14: Mehrere Ziele — Pareto-Fronten statt Gewichte</span></a></li><li data-kapitel="prognose.html"><a href="prognose.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 15: Predict-then-Optimize — die bessere Prognose, die schlechtere Entscheidung</span></a></li></ul></details><details class="sidebar-gruppe"><summary>Teil IV: Anwendungen — Energiewirtschaft und Finanzmärkte</summary><ul><li data-kapitel="bruecke.html"><a href="bruecke.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 16: Die Strukturbrücke — dieselbe Mathematik, zwei Welten</span></a></li><li data-kapitel="supplychain.html"><a href="supplychain.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 17: Supply-Chain und Energieeinsatz unter Unsicherheit</span></a></li><li data-kapitel="finanzdaten.html"><a href="finanzdaten.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 18: Finanzdaten-Modellierung — Renditen, Kovarianz und Shrinkage</span></a></li><li data-kapitel="markowitz.html"><a href="markowitz.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 19: Die moderne Portfoliotheorie nach Markowitz</span></a></li><li data-kapitel="cvar.html"><a href="cvar.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 20: Tail-Risiko, CVaR und Transaktionskosten</span></a></li><li data-kapitel="handelsmaschine.html"><a href="handelsmaschine.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 21: Die vollständige quantitative Handelsmaschine</span></a></li></ul></details><details class="sidebar-gruppe"><summary>Teil V: Praxis</summary><ul><li data-kapitel="praxisfallen.html"><a href="praxisfallen.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 22: Praxisfallen und der Weg zum produktiven Einsatz</span></a></li><li data-kapitel="testing.html"><a href="testing.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 23: Testen, Messen, Ausliefern</span></a></li><li data-kapitel="projektwerkstatt.html"><a href="projektwerkstatt.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Projektwerkstatt</span></a></li></ul></details><details class="sidebar-gruppe"><summary>Anhänge</summary><ul><li data-kapitel="anhang-loesungen.html"><a href="anhang-loesungen.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Anhang A: Lösungen zu allen Übungsaufgaben</span></a></li><li data-kapitel="anhang-modellierungsmuster.html"><a href="anhang-modellierungsmuster.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Anhang B: Katalog der Modellierungsmuster</span></a></li><li data-kapitel="anhang-fehlerdiagnose.html"><a href="anhang-fehlerdiagnose.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Anhang C: Fehlerdiagnose-Handbuch</span></a></li><li data-kapitel="anhang-spickzettel.html"><a href="anhang-spickzettel.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Anhang D: Spickzettel der Solver</span></a></li><li data-kapitel="anhang-glossar-literatur.html"><a href="anhang-glossar-literatur.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Anhang E: Glossar und Literatur</span></a></li></ul></details><ul class="sidebar-extra"><li><a href="programme.html"><svg class="icon" aria-hidden="true"><use href="#icon-book"></use></svg> Beispielprogramme</a></li><li><a href="stichwortverzeichnis.html"><svg class="icon" aria-hidden="true"><use href="#icon-search"></use></svg> Stichwortverzeichnis</a></li><li><a href="gesamtdokument.html"><svg class="icon" aria-hidden="true"><use href="#icon-external-link"></use></svg> Gesamtdokument (eine Seite)</a></li><li><a href="Operations_Research_mit_Python_Version_04.pdf" download><svg class="icon" aria-hidden="true"><use href="#icon-download"></use></svg> Download als PDF</a></li></ul></div></nav>
+  <nav class="sidebar" id="sidebar" aria-label="Kapitelnavigation"><div class="sidebar-inhalt"><details class="sidebar-gruppe"><summary>Einstieg</summary><ul><li data-kapitel="vorwort.html"><a href="vorwort.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Vorwort & Lesehilfe</span></a></li><li data-kapitel="notation.html"><a href="notation.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Notation & Abkürzungen</span></a></li></ul></details><details class="sidebar-gruppe"><summary>Teil I: Grundlagen des Operations Research</summary><ul><li data-kapitel="einfuehrung.html"><a href="einfuehrung.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 1: Einführung in Operations Research — Vom Ursprung zur mathematischen Entscheidungsfindung</span></a></li><li data-kapitel="fundament.html"><a href="fundament.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 2: Das mathematische Fundament — Vektoren, Matrizen, Konvexität</span></a></li><li data-kapitel="oekosystem.html"><a href="oekosystem.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 3: Das Python-Ökosystem für OR — Solver, Bindings und Modellierungsschichten</span></a></li><li data-kapitel="modellierung.html"><a href="modellierung.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 4: Vom Management-Wunsch zum Modell</span></a></li><li data-kapitel="synthese-grundlagen.html"><a href="synthese-grundlagen.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Synthese Teil I</span></a></li></ul></details><details class="sidebar-gruppe" open><summary>Teil II: Die Kernverfahren der deterministischen Optimierung</summary><ul><li data-kapitel="lp.html"><a href="lp.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 5: Lineare Programmierung — Simplex, Dualität und Schattenpreise</span></a></li><li data-kapitel="milp.html"><a href="milp.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 6: Gemischt-ganzzahlige Optimierung — Diskrete Entscheidungen und Branch-and-Bound</span></a></li><li data-kapitel="cpsat.html"><a href="cpsat.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 7: Constraint Programming mit CP-SAT — Logik, Scheduling und Zuweisung</span></a></li><li data-kapitel="graphen.html"><a href="graphen.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 8: Graphen, Flüsse und Touren — Min-Cost-Flow, Matching und VRP</span></a></li><li data-kapitel="metaheuristiken.html"><a href="metaheuristiken.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 9: Metaheuristiken — wenn der exakte Solver aussteigt</span></a></li><li data-kapitel="dekomposition.html" class="aktiv"><a href="dekomposition.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 10: Spaltengenerierung — das Modell umbauen statt die Lösung raten</span></a></li><li data-kapitel="synthese-kernverfahren.html"><a href="synthese-kernverfahren.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Synthese Teil II</span></a></li></ul></details><details class="sidebar-gruppe"><summary>Teil III: Nichtlinearität, Unsicherheit und mehrperiodige Dynamik</summary><ul><li data-kapitel="qp-nlp.html"><a href="qp-nlp.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 11: Quadratische und nichtlineare Optimierung — KKT, Lagrange, Konvexität</span></a></li><li data-kapitel="unsicherheit.html"><a href="unsicherheit.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 12: Optimierung unter Unsicherheit — Monte-Carlo, Stochastik, Robustheit</span></a></li><li data-kapitel="dynamische-programmierung.html"><a href="dynamische-programmierung.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 13: Dynamische Programmierung — Die Bellman-Gleichung und Order-Execution</span></a></li><li data-kapitel="mehrziel.html"><a href="mehrziel.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 14: Mehrere Ziele — Pareto-Fronten statt Gewichte</span></a></li><li data-kapitel="prognose.html"><a href="prognose.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 15: Predict-then-Optimize — die bessere Prognose, die schlechtere Entscheidung</span></a></li><li data-kapitel="synthese-nichtlinear.html"><a href="synthese-nichtlinear.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Synthese Teil III</span></a></li></ul></details><details class="sidebar-gruppe"><summary>Teil IV: Anwendungen — Energiewirtschaft und Finanzmärkte</summary><ul><li data-kapitel="bruecke.html"><a href="bruecke.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 16: Die Strukturbrücke — dieselbe Mathematik, zwei Welten</span></a></li><li data-kapitel="supplychain.html"><a href="supplychain.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 17: Supply-Chain und Energieeinsatz unter Unsicherheit</span></a></li><li data-kapitel="finanzdaten.html"><a href="finanzdaten.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 18: Finanzdaten-Modellierung — Renditen, Kovarianz und Shrinkage</span></a></li><li data-kapitel="markowitz.html"><a href="markowitz.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 19: Die moderne Portfoliotheorie nach Markowitz</span></a></li><li data-kapitel="cvar.html"><a href="cvar.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 20: Tail-Risiko, CVaR und Transaktionskosten</span></a></li><li data-kapitel="handelsmaschine.html"><a href="handelsmaschine.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 21: Die vollständige quantitative Handelsmaschine</span></a></li><li data-kapitel="synthese-anwendungen.html"><a href="synthese-anwendungen.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Synthese Teil IV</span></a></li></ul></details><details class="sidebar-gruppe"><summary>Teil V: Praxis</summary><ul><li data-kapitel="praxisfallen.html"><a href="praxisfallen.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 22: Praxisfallen und der Weg zum produktiven Einsatz</span></a></li><li data-kapitel="testing.html"><a href="testing.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 23: Testen, Messen, Ausliefern</span></a></li><li data-kapitel="synthese-praxis.html"><a href="synthese-praxis.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Synthese Teil V</span></a></li><li data-kapitel="projektwerkstatt.html"><a href="projektwerkstatt.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Projektwerkstatt</span></a></li></ul></details><details class="sidebar-gruppe"><summary>Anhänge</summary><ul><li data-kapitel="anhang-loesungen.html"><a href="anhang-loesungen.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Anhang A: Lösungen zu allen Übungsaufgaben</span></a></li><li data-kapitel="anhang-modellierungsmuster.html"><a href="anhang-modellierungsmuster.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Anhang B: Katalog der Modellierungsmuster</span></a></li><li data-kapitel="anhang-fehlerdiagnose.html"><a href="anhang-fehlerdiagnose.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Anhang C: Fehlerdiagnose-Handbuch</span></a></li><li data-kapitel="anhang-spickzettel.html"><a href="anhang-spickzettel.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Anhang D: Spickzettel der Solver</span></a></li><li data-kapitel="anhang-glossar-literatur.html"><a href="anhang-glossar-literatur.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Anhang E: Glossar und Literatur</span></a></li></ul></details><ul class="sidebar-extra"><li><a href="programme.html"><svg class="icon" aria-hidden="true"><use href="#icon-book"></use></svg> Beispielprogramme</a></li><li><a href="stichwortverzeichnis.html"><svg class="icon" aria-hidden="true"><use href="#icon-search"></use></svg> Stichwortverzeichnis</a></li><li><a href="gesamtdokument.html"><svg class="icon" aria-hidden="true"><use href="#icon-external-link"></use></svg> Gesamtdokument (eine Seite)</a></li><li><a href="Operations_Research_mit_Python_Version_04.pdf" download><svg class="icon" aria-hidden="true"><use href="#icon-download"></use></svg> Download als PDF</a></li></ul></div></nav>
   <main class="content">
     <nav class="breadcrumb" aria-label="Breadcrumb"><a href="index.html">Start</a> › <span>Teil II</span> › <span>Kapitel 10: Spaltengenerierung — das Modell umbauen statt die Lösung raten</span></nav>
-    <nav class="prev-next"><a class="prev-next-knopf prev-next-prev" href="metaheuristiken.html"><svg class="icon" aria-hidden="true"><use href="#icon-chevron-left"></use></svg><span><small>Zurück</small>Kapitel 9: Metaheuristiken — wenn der exakte Solver aussteigt</span></a><a class="prev-next-knopf prev-next-next" href="qp-nlp.html"><span><small>Weiter</small>Kapitel 11: Quadratische und nichtlineare Optimierung — KKT, Lagrange, Konvexität</span><svg class="icon" aria-hidden="true"><use href="#icon-chevron-right"></use></svg></a></nav>
+    <nav class="prev-next"><a class="prev-next-knopf prev-next-prev" href="metaheuristiken.html"><svg class="icon" aria-hidden="true"><use href="#icon-chevron-left"></use></svg><span><small>Zurück</small>Kapitel 9: Metaheuristiken — wenn der exakte Solver aussteigt</span></a><a class="prev-next-knopf prev-next-next" href="synthese-kernverfahren.html"><span><small>Weiter</small>Synthese Teil II</span><svg class="icon" aria-hidden="true"><use href="#icon-chevron-right"></use></svg></a></nav>
     <article>
     <h1 id="kap-dekomposition">Kapitel 10: Spaltengenerierung — das Modell umbauen statt die Lösung raten</h1>
 <div class="card card-blick">
@@ -826,7 +826,7 @@ Mutterrolle 5,600 mm, 13 bestellte Breiten, 219 Zuschnitte.
 
     </article>
     <button type="button" class="fortschritt-knopf" data-kapitel="dekomposition.html"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg> <span>Als gelesen markieren</span></button>
-    <nav class="prev-next"><a class="prev-next-knopf prev-next-prev" href="metaheuristiken.html"><svg class="icon" aria-hidden="true"><use href="#icon-chevron-left"></use></svg><span><small>Zurück</small>Kapitel 9: Metaheuristiken — wenn der exakte Solver aussteigt</span></a><a class="prev-next-knopf prev-next-next" href="qp-nlp.html"><span><small>Weiter</small>Kapitel 11: Quadratische und nichtlineare Optimierung — KKT, Lagrange, Konvexität</span><svg class="icon" aria-hidden="true"><use href="#icon-chevron-right"></use></svg></a></nav>
+    <nav class="prev-next"><a class="prev-next-knopf prev-next-prev" href="metaheuristiken.html"><svg class="icon" aria-hidden="true"><use href="#icon-chevron-left"></use></svg><span><small>Zurück</small>Kapitel 9: Metaheuristiken — wenn der exakte Solver aussteigt</span></a><a class="prev-next-knopf prev-next-next" href="synthese-kernverfahren.html"><span><small>Weiter</small>Synthese Teil II</span><svg class="icon" aria-hidden="true"><use href="#icon-chevron-right"></use></svg></a></nav>
   </main>
 </div>
 <footer class="site-footer">
diff --git a/OR_HTML_04/dynamische-programmierung.html b/OR_HTML_04/dynamische-programmierung.html
index a340a51..59a34c0 100644
--- a/OR_HTML_04/dynamische-programmierung.html
+++ b/OR_HTML_04/dynamische-programmierung.html
@@ -94,7 +94,7 @@
 </header>
 <div class="site-body">
   <div class="sidebar-overlay" id="sidebar-overlay" hidden></div>
-  <nav class="sidebar" id="sidebar" aria-label="Kapitelnavigation"><div class="sidebar-inhalt"><details class="sidebar-gruppe"><summary>Einstieg</summary><ul><li data-kapitel="vorwort.html"><a href="vorwort.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Vorwort & Lesehilfe</span></a></li><li data-kapitel="notation.html"><a href="notation.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Notation & Abkürzungen</span></a></li></ul></details><details class="sidebar-gruppe"><summary>Teil I: Grundlagen des Operations Research</summary><ul><li data-kapitel="einfuehrung.html"><a href="einfuehrung.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 1: Einführung in Operations Research — Vom Ursprung zur mathematischen Entscheidungsfindung</span></a></li><li data-kapitel="fundament.html"><a href="fundament.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 2: Das mathematische Fundament — Vektoren, Matrizen, Konvexität</span></a></li><li data-kapitel="oekosystem.html"><a href="oekosystem.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 3: Das Python-Ökosystem für OR — Solver, Bindings und Modellierungsschichten</span></a></li><li data-kapitel="modellierung.html"><a href="modellierung.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 4: Vom Management-Wunsch zum Modell</span></a></li></ul></details><details class="sidebar-gruppe"><summary>Teil II: Die Kernverfahren der deterministischen Optimierung</summary><ul><li data-kapitel="lp.html"><a href="lp.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 5: Lineare Programmierung — Simplex, Dualität und Schattenpreise</span></a></li><li data-kapitel="milp.html"><a href="milp.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 6: Gemischt-ganzzahlige Optimierung — Diskrete Entscheidungen und Branch-and-Bound</span></a></li><li data-kapitel="cpsat.html"><a href="cpsat.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 7: Constraint Programming mit CP-SAT — Logik, Scheduling und Zuweisung</span></a></li><li data-kapitel="graphen.html"><a href="graphen.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 8: Graphen, Flüsse und Touren — Min-Cost-Flow, Matching und VRP</span></a></li><li data-kapitel="metaheuristiken.html"><a href="metaheuristiken.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 9: Metaheuristiken — wenn der exakte Solver aussteigt</span></a></li><li data-kapitel="dekomposition.html"><a href="dekomposition.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 10: Spaltengenerierung — das Modell umbauen statt die Lösung raten</span></a></li></ul></details><details class="sidebar-gruppe" open><summary>Teil III: Nichtlinearität, Unsicherheit und mehrperiodige Dynamik</summary><ul><li data-kapitel="qp-nlp.html"><a href="qp-nlp.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 11: Quadratische und nichtlineare Optimierung — KKT, Lagrange, Konvexität</span></a></li><li data-kapitel="unsicherheit.html"><a href="unsicherheit.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 12: Optimierung unter Unsicherheit — Monte-Carlo, Stochastik, Robustheit</span></a></li><li data-kapitel="dynamische-programmierung.html" class="aktiv"><a href="dynamische-programmierung.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 13: Dynamische Programmierung — Die Bellman-Gleichung und Order-Execution</span></a></li><li data-kapitel="mehrziel.html"><a href="mehrziel.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 14: Mehrere Ziele — Pareto-Fronten statt Gewichte</span></a></li><li data-kapitel="prognose.html"><a href="prognose.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 15: Predict-then-Optimize — die bessere Prognose, die schlechtere Entscheidung</span></a></li></ul></details><details class="sidebar-gruppe"><summary>Teil IV: Anwendungen — Energiewirtschaft und Finanzmärkte</summary><ul><li data-kapitel="bruecke.html"><a href="bruecke.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 16: Die Strukturbrücke — dieselbe Mathematik, zwei Welten</span></a></li><li data-kapitel="supplychain.html"><a href="supplychain.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 17: Supply-Chain und Energieeinsatz unter Unsicherheit</span></a></li><li data-kapitel="finanzdaten.html"><a href="finanzdaten.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 18: Finanzdaten-Modellierung — Renditen, Kovarianz und Shrinkage</span></a></li><li data-kapitel="markowitz.html"><a href="markowitz.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 19: Die moderne Portfoliotheorie nach Markowitz</span></a></li><li data-kapitel="cvar.html"><a href="cvar.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 20: Tail-Risiko, CVaR und Transaktionskosten</span></a></li><li data-kapitel="handelsmaschine.html"><a href="handelsmaschine.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 21: Die vollständige quantitative Handelsmaschine</span></a></li></ul></details><details class="sidebar-gruppe"><summary>Teil V: Praxis</summary><ul><li data-kapitel="praxisfallen.html"><a href="praxisfallen.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 22: Praxisfallen und der Weg zum produktiven Einsatz</span></a></li><li data-kapitel="testing.html"><a href="testing.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 23: Testen, Messen, Ausliefern</span></a></li><li data-kapitel="projektwerkstatt.html"><a href="projektwerkstatt.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Projektwerkstatt</span></a></li></ul></details><details class="sidebar-gruppe"><summary>Anhänge</summary><ul><li data-kapitel="anhang-loesungen.html"><a href="anhang-loesungen.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Anhang A: Lösungen zu allen Übungsaufgaben</span></a></li><li data-kapitel="anhang-modellierungsmuster.html"><a href="anhang-modellierungsmuster.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Anhang B: Katalog der Modellierungsmuster</span></a></li><li data-kapitel="anhang-fehlerdiagnose.html"><a href="anhang-fehlerdiagnose.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Anhang C: Fehlerdiagnose-Handbuch</span></a></li><li data-kapitel="anhang-spickzettel.html"><a href="anhang-spickzettel.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Anhang D: Spickzettel der Solver</span></a></li><li data-kapitel="anhang-glossar-literatur.html"><a href="anhang-glossar-literatur.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Anhang E: Glossar und Literatur</span></a></li></ul></details><ul class="sidebar-extra"><li><a href="programme.html"><svg class="icon" aria-hidden="true"><use href="#icon-book"></use></svg> Beispielprogramme</a></li><li><a href="stichwortverzeichnis.html"><svg class="icon" aria-hidden="true"><use href="#icon-search"></use></svg> Stichwortverzeichnis</a></li><li><a href="gesamtdokument.html"><svg class="icon" aria-hidden="true"><use href="#icon-external-link"></use></svg> Gesamtdokument (eine Seite)</a></li><li><a href="Operations_Research_mit_Python_Version_04.pdf" download><svg class="icon" aria-hidden="true"><use href="#icon-download"></use></svg> Download als PDF</a></li></ul></div></nav>
+  <nav class="sidebar" id="sidebar" aria-label="Kapitelnavigation"><div class="sidebar-inhalt"><details class="sidebar-gruppe"><summary>Einstieg</summary><ul><li data-kapitel="vorwort.html"><a href="vorwort.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Vorwort & Lesehilfe</span></a></li><li data-kapitel="notation.html"><a href="notation.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Notation & Abkürzungen</span></a></li></ul></details><details class="sidebar-gruppe"><summary>Teil I: Grundlagen des Operations Research</summary><ul><li data-kapitel="einfuehrung.html"><a href="einfuehrung.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 1: Einführung in Operations Research — Vom Ursprung zur mathematischen Entscheidungsfindung</span></a></li><li data-kapitel="fundament.html"><a href="fundament.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 2: Das mathematische Fundament — Vektoren, Matrizen, Konvexität</span></a></li><li data-kapitel="oekosystem.html"><a href="oekosystem.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 3: Das Python-Ökosystem für OR — Solver, Bindings und Modellierungsschichten</span></a></li><li data-kapitel="modellierung.html"><a href="modellierung.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 4: Vom Management-Wunsch zum Modell</span></a></li><li data-kapitel="synthese-grundlagen.html"><a href="synthese-grundlagen.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Synthese Teil I</span></a></li></ul></details><details class="sidebar-gruppe"><summary>Teil II: Die Kernverfahren der deterministischen Optimierung</summary><ul><li data-kapitel="lp.html"><a href="lp.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 5: Lineare Programmierung — Simplex, Dualität und Schattenpreise</span></a></li><li data-kapitel="milp.html"><a href="milp.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 6: Gemischt-ganzzahlige Optimierung — Diskrete Entscheidungen und Branch-and-Bound</span></a></li><li data-kapitel="cpsat.html"><a href="cpsat.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 7: Constraint Programming mit CP-SAT — Logik, Scheduling und Zuweisung</span></a></li><li data-kapitel="graphen.html"><a href="graphen.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 8: Graphen, Flüsse und Touren — Min-Cost-Flow, Matching und VRP</span></a></li><li data-kapitel="metaheuristiken.html"><a href="metaheuristiken.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 9: Metaheuristiken — wenn der exakte Solver aussteigt</span></a></li><li data-kapitel="dekomposition.html"><a href="dekomposition.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 10: Spaltengenerierung — das Modell umbauen statt die Lösung raten</span></a></li><li data-kapitel="synthese-kernverfahren.html"><a href="synthese-kernverfahren.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Synthese Teil II</span></a></li></ul></details><details class="sidebar-gruppe" open><summary>Teil III: Nichtlinearität, Unsicherheit und mehrperiodige Dynamik</summary><ul><li data-kapitel="qp-nlp.html"><a href="qp-nlp.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 11: Quadratische und nichtlineare Optimierung — KKT, Lagrange, Konvexität</span></a></li><li data-kapitel="unsicherheit.html"><a href="unsicherheit.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 12: Optimierung unter Unsicherheit — Monte-Carlo, Stochastik, Robustheit</span></a></li><li data-kapitel="dynamische-programmierung.html" class="aktiv"><a href="dynamische-programmierung.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 13: Dynamische Programmierung — Die Bellman-Gleichung und Order-Execution</span></a></li><li data-kapitel="mehrziel.html"><a href="mehrziel.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 14: Mehrere Ziele — Pareto-Fronten statt Gewichte</span></a></li><li data-kapitel="prognose.html"><a href="prognose.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 15: Predict-then-Optimize — die bessere Prognose, die schlechtere Entscheidung</span></a></li><li data-kapitel="synthese-nichtlinear.html"><a href="synthese-nichtlinear.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Synthese Teil III</span></a></li></ul></details><details class="sidebar-gruppe"><summary>Teil IV: Anwendungen — Energiewirtschaft und Finanzmärkte</summary><ul><li data-kapitel="bruecke.html"><a href="bruecke.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 16: Die Strukturbrücke — dieselbe Mathematik, zwei Welten</span></a></li><li data-kapitel="supplychain.html"><a href="supplychain.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 17: Supply-Chain und Energieeinsatz unter Unsicherheit</span></a></li><li data-kapitel="finanzdaten.html"><a href="finanzdaten.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 18: Finanzdaten-Modellierung — Renditen, Kovarianz und Shrinkage</span></a></li><li data-kapitel="markowitz.html"><a href="markowitz.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 19: Die moderne Portfoliotheorie nach Markowitz</span></a></li><li data-kapitel="cvar.html"><a href="cvar.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 20: Tail-Risiko, CVaR und Transaktionskosten</span></a></li><li data-kapitel="handelsmaschine.html"><a href="handelsmaschine.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 21: Die vollständige quantitative Handelsmaschine</span></a></li><li data-kapitel="synthese-anwendungen.html"><a href="synthese-anwendungen.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Synthese Teil IV</span></a></li></ul></details><details class="sidebar-gruppe"><summary>Teil V: Praxis</summary><ul><li data-kapitel="praxisfallen.html"><a href="praxisfallen.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 22: Praxisfallen und der Weg zum produktiven Einsatz</span></a></li><li data-kapitel="testing.html"><a href="testing.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 23: Testen, Messen, Ausliefern</span></a></li><li data-kapitel="synthese-praxis.html"><a href="synthese-praxis.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Synthese Teil V</span></a></li><li data-kapitel="projektwerkstatt.html"><a href="projektwerkstatt.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Projektwerkstatt</span></a></li></ul></details><details class="sidebar-gruppe"><summary>Anhänge</summary><ul><li data-kapitel="anhang-loesungen.html"><a href="anhang-loesungen.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Anhang A: Lösungen zu allen Übungsaufgaben</span></a></li><li data-kapitel="anhang-modellierungsmuster.html"><a href="anhang-modellierungsmuster.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Anhang B: Katalog der Modellierungsmuster</span></a></li><li data-kapitel="anhang-fehlerdiagnose.html"><a href="anhang-fehlerdiagnose.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Anhang C: Fehlerdiagnose-Handbuch</span></a></li><li data-kapitel="anhang-spickzettel.html"><a href="anhang-spickzettel.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Anhang D: Spickzettel der Solver</span></a></li><li data-kapitel="anhang-glossar-literatur.html"><a href="anhang-glossar-literatur.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Anhang E: Glossar und Literatur</span></a></li></ul></details><ul class="sidebar-extra"><li><a href="programme.html"><svg class="icon" aria-hidden="true"><use href="#icon-book"></use></svg> Beispielprogramme</a></li><li><a href="stichwortverzeichnis.html"><svg class="icon" aria-hidden="true"><use href="#icon-search"></use></svg> Stichwortverzeichnis</a></li><li><a href="gesamtdokument.html"><svg class="icon" aria-hidden="true"><use href="#icon-external-link"></use></svg> Gesamtdokument (eine Seite)</a></li><li><a href="Operations_Research_mit_Python_Version_04.pdf" download><svg class="icon" aria-hidden="true"><use href="#icon-download"></use></svg> Download als PDF</a></li></ul></div></nav>
   <main class="content">
     <nav class="breadcrumb" aria-label="Breadcrumb"><a href="index.html">Start</a> › <span>Teil III</span> › <span>Kapitel 13: Dynamische Programmierung — Die Bellman-Gleichung und Order-Execution</span></nav>
     <nav class="prev-next"><a class="prev-next-knopf prev-next-prev" href="unsicherheit.html"><svg class="icon" aria-hidden="true"><use href="#icon-chevron-left"></use></svg><span><small>Zurück</small>Kapitel 12: Optimierung unter Unsicherheit — Monte-Carlo, Stochastik, Robustheit</span></a><a class="prev-next-knopf prev-next-next" href="mehrziel.html"><span><small>Weiter</small>Kapitel 14: Mehrere Ziele — Pareto-Fronten statt Gewichte</span><svg class="icon" aria-hidden="true"><use href="#icon-chevron-right"></use></svg></a></nav>
@@ -889,7 +889,7 @@ Abweichung DP zur analytischen Loesung: 5.788 % (Diskretisierung: 1000 Stueck)
 <p>Bei dynamischer Programmierung entscheidet eine einzige Frage über Erfolg oder Misserfolg: <strong>Was gehört in den Zustand?</strong> Ist er zu klein, rechnet das Verfahren völlig korrekt — nur eben an einem anderen Problem.</p>
 <div class="card card-denkfehler">
 <blockquote>
-<p><strong>🐛 Finde den Denkfehler 10.1: Der Zustand, der zu wenig weiß</strong></p>
+<p><strong>🐛 Finde den Denkfehler: Der Zustand, der zu wenig weiß</strong></p>
 <p>Eine Werkstatt plant vier Perioden. Der Bedarf beträgt 3, 1, 4, 2 Stück; produziert werden können höchstens 5 je Periode, gelagert höchstens 6 Stück.</p>
 <table>
 <colgroup>
@@ -946,7 +946,7 @@ Abweichung DP zur analytischen Loesung: 5.788 % (Diskretisierung: 1000 Stueck)
 <h2 id="sec:dynamische-programmierung-quiz">13.8 Micro-Quiz</h2>
 <div class="card card-quiz">
 <blockquote>
-<p><strong>❓ Micro-Quiz 10: Drei Fragen zum Selbstcheck</strong></p>
+<p><strong>❓ Micro-Quiz 13: Drei Fragen zum Selbstcheck</strong></p>
 <p>Genau eine Antwort ist jeweils richtig. Auflösung in <a href="anhang-loesungen.html#quiz-loesung-dynamische-programmierung">Anhang A</a>.</p>
 <p><strong>1. Warum rechnet dynamische Programmierung rückwärts?</strong> (a) Weil Rekursion in Python rückwärts effizienter ist. (b) Weil <span class="math inline">V_t</span> den Wert <span class="math inline">V_{t+1}</span> voraussetzt: Man kann eine Entscheidung erst bewerten, wenn man weiß, was sie für die Zukunft bedeutet. Am Ende ist dieser Wert bekannt — dort beginnt man. (c) Weil die Kosten in späteren Perioden höher sind.</p>
 <p><strong>2. Was besagt das Bellmansche Optimalitätsprinzip?</strong> (a) Jede optimale Lösung besteht aus lauter einzeln optimalen Schritten — man kann also gierig vorgehen. (b) Ist ein Weg insgesamt optimal, so ist auch sein <strong>Reststück</strong> ab jedem Zwischenzustand optimal. Deshalb genügt es, je Zustand einen einzigen Wert zu speichern. (c) Bei genügend Rechenzeit findet man das Optimum immer.</p>
diff --git a/OR_HTML_04/einfuehrung.html b/OR_HTML_04/einfuehrung.html
index ca001b8..7498719 100644
--- a/OR_HTML_04/einfuehrung.html
+++ b/OR_HTML_04/einfuehrung.html
@@ -94,7 +94,7 @@
 </header>
 <div class="site-body">
   <div class="sidebar-overlay" id="sidebar-overlay" hidden></div>
-  <nav class="sidebar" id="sidebar" aria-label="Kapitelnavigation"><div class="sidebar-inhalt"><details class="sidebar-gruppe"><summary>Einstieg</summary><ul><li data-kapitel="vorwort.html"><a href="vorwort.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Vorwort & Lesehilfe</span></a></li><li data-kapitel="notation.html"><a href="notation.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Notation & Abkürzungen</span></a></li></ul></details><details class="sidebar-gruppe" open><summary>Teil I: Grundlagen des Operations Research</summary><ul><li data-kapitel="einfuehrung.html" class="aktiv"><a href="einfuehrung.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 1: Einführung in Operations Research — Vom Ursprung zur mathematischen Entscheidungsfindung</span></a></li><li data-kapitel="fundament.html"><a href="fundament.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 2: Das mathematische Fundament — Vektoren, Matrizen, Konvexität</span></a></li><li data-kapitel="oekosystem.html"><a href="oekosystem.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 3: Das Python-Ökosystem für OR — Solver, Bindings und Modellierungsschichten</span></a></li><li data-kapitel="modellierung.html"><a href="modellierung.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 4: Vom Management-Wunsch zum Modell</span></a></li></ul></details><details class="sidebar-gruppe"><summary>Teil II: Die Kernverfahren der deterministischen Optimierung</summary><ul><li data-kapitel="lp.html"><a href="lp.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 5: Lineare Programmierung — Simplex, Dualität und Schattenpreise</span></a></li><li data-kapitel="milp.html"><a href="milp.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 6: Gemischt-ganzzahlige Optimierung — Diskrete Entscheidungen und Branch-and-Bound</span></a></li><li data-kapitel="cpsat.html"><a href="cpsat.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 7: Constraint Programming mit CP-SAT — Logik, Scheduling und Zuweisung</span></a></li><li data-kapitel="graphen.html"><a href="graphen.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 8: Graphen, Flüsse und Touren — Min-Cost-Flow, Matching und VRP</span></a></li><li data-kapitel="metaheuristiken.html"><a href="metaheuristiken.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 9: Metaheuristiken — wenn der exakte Solver aussteigt</span></a></li><li data-kapitel="dekomposition.html"><a href="dekomposition.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 10: Spaltengenerierung — das Modell umbauen statt die Lösung raten</span></a></li></ul></details><details class="sidebar-gruppe"><summary>Teil III: Nichtlinearität, Unsicherheit und mehrperiodige Dynamik</summary><ul><li data-kapitel="qp-nlp.html"><a href="qp-nlp.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 11: Quadratische und nichtlineare Optimierung — KKT, Lagrange, Konvexität</span></a></li><li data-kapitel="unsicherheit.html"><a href="unsicherheit.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 12: Optimierung unter Unsicherheit — Monte-Carlo, Stochastik, Robustheit</span></a></li><li data-kapitel="dynamische-programmierung.html"><a href="dynamische-programmierung.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 13: Dynamische Programmierung — Die Bellman-Gleichung und Order-Execution</span></a></li><li data-kapitel="mehrziel.html"><a href="mehrziel.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 14: Mehrere Ziele — Pareto-Fronten statt Gewichte</span></a></li><li data-kapitel="prognose.html"><a href="prognose.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 15: Predict-then-Optimize — die bessere Prognose, die schlechtere Entscheidung</span></a></li></ul></details><details class="sidebar-gruppe"><summary>Teil IV: Anwendungen — Energiewirtschaft und Finanzmärkte</summary><ul><li data-kapitel="bruecke.html"><a href="bruecke.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 16: Die Strukturbrücke — dieselbe Mathematik, zwei Welten</span></a></li><li data-kapitel="supplychain.html"><a href="supplychain.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 17: Supply-Chain und Energieeinsatz unter Unsicherheit</span></a></li><li data-kapitel="finanzdaten.html"><a href="finanzdaten.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 18: Finanzdaten-Modellierung — Renditen, Kovarianz und Shrinkage</span></a></li><li data-kapitel="markowitz.html"><a href="markowitz.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 19: Die moderne Portfoliotheorie nach Markowitz</span></a></li><li data-kapitel="cvar.html"><a href="cvar.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 20: Tail-Risiko, CVaR und Transaktionskosten</span></a></li><li data-kapitel="handelsmaschine.html"><a href="handelsmaschine.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 21: Die vollständige quantitative Handelsmaschine</span></a></li></ul></details><details class="sidebar-gruppe"><summary>Teil V: Praxis</summary><ul><li data-kapitel="praxisfallen.html"><a href="praxisfallen.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 22: Praxisfallen und der Weg zum produktiven Einsatz</span></a></li><li data-kapitel="testing.html"><a href="testing.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 23: Testen, Messen, Ausliefern</span></a></li><li data-kapitel="projektwerkstatt.html"><a href="projektwerkstatt.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Projektwerkstatt</span></a></li></ul></details><details class="sidebar-gruppe"><summary>Anhänge</summary><ul><li data-kapitel="anhang-loesungen.html"><a href="anhang-loesungen.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Anhang A: Lösungen zu allen Übungsaufgaben</span></a></li><li data-kapitel="anhang-modellierungsmuster.html"><a href="anhang-modellierungsmuster.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Anhang B: Katalog der Modellierungsmuster</span></a></li><li data-kapitel="anhang-fehlerdiagnose.html"><a href="anhang-fehlerdiagnose.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Anhang C: Fehlerdiagnose-Handbuch</span></a></li><li data-kapitel="anhang-spickzettel.html"><a href="anhang-spickzettel.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Anhang D: Spickzettel der Solver</span></a></li><li data-kapitel="anhang-glossar-literatur.html"><a href="anhang-glossar-literatur.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Anhang E: Glossar und Literatur</span></a></li></ul></details><ul class="sidebar-extra"><li><a href="programme.html"><svg class="icon" aria-hidden="true"><use href="#icon-book"></use></svg> Beispielprogramme</a></li><li><a href="stichwortverzeichnis.html"><svg class="icon" aria-hidden="true"><use href="#icon-search"></use></svg> Stichwortverzeichnis</a></li><li><a href="gesamtdokument.html"><svg class="icon" aria-hidden="true"><use href="#icon-external-link"></use></svg> Gesamtdokument (eine Seite)</a></li><li><a href="Operations_Research_mit_Python_Version_04.pdf" download><svg class="icon" aria-hidden="true"><use href="#icon-download"></use></svg> Download als PDF</a></li></ul></div></nav>
+  <nav class="sidebar" id="sidebar" aria-label="Kapitelnavigation"><div class="sidebar-inhalt"><details class="sidebar-gruppe"><summary>Einstieg</summary><ul><li data-kapitel="vorwort.html"><a href="vorwort.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Vorwort & Lesehilfe</span></a></li><li data-kapitel="notation.html"><a href="notation.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Notation & Abkürzungen</span></a></li></ul></details><details class="sidebar-gruppe" open><summary>Teil I: Grundlagen des Operations Research</summary><ul><li data-kapitel="einfuehrung.html" class="aktiv"><a href="einfuehrung.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 1: Einführung in Operations Research — Vom Ursprung zur mathematischen Entscheidungsfindung</span></a></li><li data-kapitel="fundament.html"><a href="fundament.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 2: Das mathematische Fundament — Vektoren, Matrizen, Konvexität</span></a></li><li data-kapitel="oekosystem.html"><a href="oekosystem.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 3: Das Python-Ökosystem für OR — Solver, Bindings und Modellierungsschichten</span></a></li><li data-kapitel="modellierung.html"><a href="modellierung.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 4: Vom Management-Wunsch zum Modell</span></a></li><li data-kapitel="synthese-grundlagen.html"><a href="synthese-grundlagen.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Synthese Teil I</span></a></li></ul></details><details class="sidebar-gruppe"><summary>Teil II: Die Kernverfahren der deterministischen Optimierung</summary><ul><li data-kapitel="lp.html"><a href="lp.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 5: Lineare Programmierung — Simplex, Dualität und Schattenpreise</span></a></li><li data-kapitel="milp.html"><a href="milp.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 6: Gemischt-ganzzahlige Optimierung — Diskrete Entscheidungen und Branch-and-Bound</span></a></li><li data-kapitel="cpsat.html"><a href="cpsat.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 7: Constraint Programming mit CP-SAT — Logik, Scheduling und Zuweisung</span></a></li><li data-kapitel="graphen.html"><a href="graphen.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 8: Graphen, Flüsse und Touren — Min-Cost-Flow, Matching und VRP</span></a></li><li data-kapitel="metaheuristiken.html"><a href="metaheuristiken.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 9: Metaheuristiken — wenn der exakte Solver aussteigt</span></a></li><li data-kapitel="dekomposition.html"><a href="dekomposition.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 10: Spaltengenerierung — das Modell umbauen statt die Lösung raten</span></a></li><li data-kapitel="synthese-kernverfahren.html"><a href="synthese-kernverfahren.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Synthese Teil II</span></a></li></ul></details><details class="sidebar-gruppe"><summary>Teil III: Nichtlinearität, Unsicherheit und mehrperiodige Dynamik</summary><ul><li data-kapitel="qp-nlp.html"><a href="qp-nlp.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 11: Quadratische und nichtlineare Optimierung — KKT, Lagrange, Konvexität</span></a></li><li data-kapitel="unsicherheit.html"><a href="unsicherheit.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 12: Optimierung unter Unsicherheit — Monte-Carlo, Stochastik, Robustheit</span></a></li><li data-kapitel="dynamische-programmierung.html"><a href="dynamische-programmierung.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 13: Dynamische Programmierung — Die Bellman-Gleichung und Order-Execution</span></a></li><li data-kapitel="mehrziel.html"><a href="mehrziel.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 14: Mehrere Ziele — Pareto-Fronten statt Gewichte</span></a></li><li data-kapitel="prognose.html"><a href="prognose.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 15: Predict-then-Optimize — die bessere Prognose, die schlechtere Entscheidung</span></a></li><li data-kapitel="synthese-nichtlinear.html"><a href="synthese-nichtlinear.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Synthese Teil III</span></a></li></ul></details><details class="sidebar-gruppe"><summary>Teil IV: Anwendungen — Energiewirtschaft und Finanzmärkte</summary><ul><li data-kapitel="bruecke.html"><a href="bruecke.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 16: Die Strukturbrücke — dieselbe Mathematik, zwei Welten</span></a></li><li data-kapitel="supplychain.html"><a href="supplychain.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 17: Supply-Chain und Energieeinsatz unter Unsicherheit</span></a></li><li data-kapitel="finanzdaten.html"><a href="finanzdaten.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 18: Finanzdaten-Modellierung — Renditen, Kovarianz und Shrinkage</span></a></li><li data-kapitel="markowitz.html"><a href="markowitz.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 19: Die moderne Portfoliotheorie nach Markowitz</span></a></li><li data-kapitel="cvar.html"><a href="cvar.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 20: Tail-Risiko, CVaR und Transaktionskosten</span></a></li><li data-kapitel="handelsmaschine.html"><a href="handelsmaschine.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 21: Die vollständige quantitative Handelsmaschine</span></a></li><li data-kapitel="synthese-anwendungen.html"><a href="synthese-anwendungen.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Synthese Teil IV</span></a></li></ul></details><details class="sidebar-gruppe"><summary>Teil V: Praxis</summary><ul><li data-kapitel="praxisfallen.html"><a href="praxisfallen.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 22: Praxisfallen und der Weg zum produktiven Einsatz</span></a></li><li data-kapitel="testing.html"><a href="testing.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 23: Testen, Messen, Ausliefern</span></a></li><li data-kapitel="synthese-praxis.html"><a href="synthese-praxis.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Synthese Teil V</span></a></li><li data-kapitel="projektwerkstatt.html"><a href="projektwerkstatt.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Projektwerkstatt</span></a></li></ul></details><details class="sidebar-gruppe"><summary>Anhänge</summary><ul><li data-kapitel="anhang-loesungen.html"><a href="anhang-loesungen.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Anhang A: Lösungen zu allen Übungsaufgaben</span></a></li><li data-kapitel="anhang-modellierungsmuster.html"><a href="anhang-modellierungsmuster.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Anhang B: Katalog der Modellierungsmuster</span></a></li><li data-kapitel="anhang-fehlerdiagnose.html"><a href="anhang-fehlerdiagnose.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Anhang C: Fehlerdiagnose-Handbuch</span></a></li><li data-kapitel="anhang-spickzettel.html"><a href="anhang-spickzettel.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Anhang D: Spickzettel der Solver</span></a></li><li data-kapitel="anhang-glossar-literatur.html"><a href="anhang-glossar-literatur.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Anhang E: Glossar und Literatur</span></a></li></ul></details><ul class="sidebar-extra"><li><a href="programme.html"><svg class="icon" aria-hidden="true"><use href="#icon-book"></use></svg> Beispielprogramme</a></li><li><a href="stichwortverzeichnis.html"><svg class="icon" aria-hidden="true"><use href="#icon-search"></use></svg> Stichwortverzeichnis</a></li><li><a href="gesamtdokument.html"><svg class="icon" aria-hidden="true"><use href="#icon-external-link"></use></svg> Gesamtdokument (eine Seite)</a></li><li><a href="Operations_Research_mit_Python_Version_04.pdf" download><svg class="icon" aria-hidden="true"><use href="#icon-download"></use></svg> Download als PDF</a></li></ul></div></nav>
   <main class="content">
     <nav class="breadcrumb" aria-label="Breadcrumb"><a href="index.html">Start</a> › <span>Teil I</span> › <span>Kapitel 1: Einführung in Operations Research — Vom Ursprung zur mathematischen Entscheidungsfindung</span></nav>
     <nav class="prev-next"><a class="prev-next-knopf prev-next-prev" href="notation.html"><svg class="icon" aria-hidden="true"><use href="#icon-chevron-left"></use></svg><span><small>Zurück</small>Notation & Abkürzungen</span></a><a class="prev-next-knopf prev-next-next" href="fundament.html"><span><small>Weiter</small>Kapitel 2: Das mathematische Fundament — Vektoren, Matrizen, Konvexität</span><svg class="icon" aria-hidden="true"><use href="#icon-chevron-right"></use></svg></a></nav>
@@ -718,7 +718,7 @@ g_i(\mathbf{x}) \le b_i \qquad \text{bzw.} \qquad h_j(\mathbf{x}) = 0
 <li><strong>Harte Bedingungen:</strong> <span class="math inline">0{,}5x_1 + 0{,}6x_2 \le 90</span> (Mehl); <span class="math inline">4x_1 + 3x_2 \le 600</span> (Ofen); <span class="math inline">x_1 \ge 40</span> (Vertrag).</li>
 <li><strong>Weiche Bedingungen:</strong> keine.</li>
 </ul>
-<p>Dieses Problem lösen Sie in Übung 1.5 selbst.</p>
+<p>Dieses Problem lösen Sie in der Aufgabe <em>Die Bäckerei programmieren</em> (<a href="#sec:einfuehrung-uebungsaufgaben">Abschnitt 1.9</a>) selbst.</p>
 </blockquote>
 <p>Die Vorlage lässt sich fast wörtlich in Code übersetzen — wer die fünf Zeilen ausgefüllt hat, hat den größten Teil der Modellierungsarbeit schon erledigt:</p>
 <div class="sourceCode" id="cb5"><pre class="sourceCode python"><code class="sourceCode python"><span id="cb5-1"><a href="#cb5-1" aria-hidden="true" tabindex="-1"></a><span class="co">#!/usr/bin/env python3</span></span>
@@ -1099,7 +1099,7 @@ Vorteil der Optimierung:          300.00 EUR pro Tag (15.0 %)
 </blockquote>
 <blockquote>
 <p><strong>📎 Warum dieses Programm alles selbst macht</strong></p>
-<p>Wenige Seiten weiter, in der Excel-Brücke, steht ein Programm, das mit 96 Zeilen auskommt, weil es die immer gleichen Arbeitsschritte aus dem gemeinsamen Modul <code>or_kern.py</code> bezieht (<a href="praxisfallen.html#sec:praxisfallen-or-kern">Abschnitt 22.5</a>). Warum tut <code>Bot_Allokation.py</code> das nicht auch?</p>
+<p>Wenige Seiten weiter, in der Excel-Brücke, steht ein Programm, das mit 96 Zeilen auskommt, weil es die immer gleichen Arbeitsschritte aus dem gemeinsamen Modul <code>or_kern.py</code> bezieht (<a href="praxisfallen.html#sec:praxisfallen-or-kern">Abschnitt 22.6</a>). Warum tut <code>Bot_Allokation.py</code> das nicht auch?</p>
 <p>Weil es hier nicht darum geht, <strong>wenig Code</strong> zu schreiben, sondern darum zu sehen, wie ein Modell <strong>entsteht</strong>: Variablen, Nebenbedingungen, Zielfunktion, Status, Prüfung — jeder Schritt einzeln und sichtbar. Eine Abstraktion, die diese Schritte zusammenfasst, ist genau dann ein Gewinn, wenn man sie schon einmal von Hand gegangen ist; vorher versteckt sie nur, was man verstehen will.</p>
 <p>Das ist eine allgemeine Regel für eigene Projekte: <strong>Erst die Wiederholung rechtfertigt die Abstraktion.</strong> Wer sein erstes Modell gleich als Framework baut, hat ein Framework für einen Fall — und die Erfahrung, welche Fälle es tragen müsste, hat er noch nicht gemacht.</p>
 </blockquote>
@@ -1166,7 +1166,7 @@ Vorteil der Optimierung:          300.00 EUR pro Tag (15.0 %)
 <p>Das folgende Programm zeigt den ganzen Weg an einem Stück. Es legt die Eingabemappe beim ersten Start selbst an, damit Sie es sofort ausführen können; danach ersetzen Sie die Datei durch Ihre eigene. Solange die Spalten gleich heißen, ändert sich am Code nichts.</p>
 <blockquote>
 <p><strong>📎 Zum Modul <code>or_kern.py</code></strong></p>
-<p>Die vier Arbeitsschritte — lesen, lösen, prüfen, schreiben — stehen nicht in diesem Programm, sondern in <code>or_kern.py</code>. Das ist ein gemeinsamer Unterbau, den alle Programme dieses Buchs benutzen können; er liegt im selben Verzeichnis und ist in <a href="praxisfallen.html#sec:praxisfallen-or-kern">Abschnitt 22.5</a> vollständig abgedruckt und erklärt.</p>
+<p>Die vier Arbeitsschritte — lesen, lösen, prüfen, schreiben — stehen nicht in diesem Programm, sondern in <code>or_kern.py</code>. Das ist ein gemeinsamer Unterbau, den alle Programme dieses Buchs benutzen können; er liegt im selben Verzeichnis und ist in <a href="praxisfallen.html#sec:praxisfallen-or-kern">Abschnitt 22.6</a> vollständig abgedruckt und erklärt.</p>
 <p>Sie müssen ihn jetzt noch nicht verstehen. Wichtig ist nur die Aufteilung: <strong>Hier</strong> steht, was diesen Fall ausmacht — dort steht, was jedes Optimierungsprogramm braucht. Genau deshalb ist der Code unten so kurz.</p>
 </blockquote>
 <div class="sourceCode" id="cb9"><pre class="sourceCode python"><code class="sourceCode python"><span id="cb9-1"><a href="#cb9-1" aria-hidden="true" tabindex="-1"></a><span class="co">#!/usr/bin/env python3</span></span>
@@ -1351,7 +1351,7 @@ Ergebnis geschrieben nach: produktionsmix_ergebnis.xlsx</code></pre>
 <p>Ein Programm, das abstürzt, ist harmlos — Sie sehen sofort, dass etwas nicht stimmt. Gefährlich sind Programme, die fehlerfrei durchlaufen, einen Status <code>OPTIMAL</code> melden und eine Zahl liefern, die betriebswirtschaftlich Unsinn ist. Genau solche Fälle üben wir hier.</p>
 <div class="card card-denkfehler">
 <blockquote>
-<p><strong>🐛 Finde den Denkfehler 1.1: Die Schreinerei verdoppelt ihren Gewinn</strong></p>
+<p><strong>🐛 Finde den Denkfehler: Die Schreinerei verdoppelt ihren Gewinn</strong></p>
 <p>Eine Kollegin hat das Schreinerei-Modell aus dem Kapitelanfang leicht umgebaut — sie fand die Schleife übersichtlicher als zwei einzelne <code>Add</code>-Aufrufe. Das Programm läuft, der Solver meldet <code>OPTIMAL</code>, und der Deckungsbeitrag ist plötzlich <strong>18 600 €</strong> statt 10 800 €. Der Chef ist begeistert. Sollte er das sein?</p>
 <div class="sourceCode" id="cb11"><pre class="sourceCode python"><code class="sourceCode python"><span id="cb11-1"><a href="#cb11-1" aria-hidden="true" tabindex="-1"></a><span class="im">from</span> ortools.linear_solver <span class="im">import</span> pywraplp</span>
 <span id="cb11-2"><a href="#cb11-2" aria-hidden="true" tabindex="-1"></a></span>
diff --git a/OR_HTML_04/finanzdaten.html b/OR_HTML_04/finanzdaten.html
index 57e33e8..2645caa 100644
--- a/OR_HTML_04/finanzdaten.html
+++ b/OR_HTML_04/finanzdaten.html
@@ -94,7 +94,7 @@
 </header>
 <div class="site-body">
   <div class="sidebar-overlay" id="sidebar-overlay" hidden></div>
-  <nav class="sidebar" id="sidebar" aria-label="Kapitelnavigation"><div class="sidebar-inhalt"><details class="sidebar-gruppe"><summary>Einstieg</summary><ul><li data-kapitel="vorwort.html"><a href="vorwort.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Vorwort & Lesehilfe</span></a></li><li data-kapitel="notation.html"><a href="notation.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Notation & Abkürzungen</span></a></li></ul></details><details class="sidebar-gruppe"><summary>Teil I: Grundlagen des Operations Research</summary><ul><li data-kapitel="einfuehrung.html"><a href="einfuehrung.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 1: Einführung in Operations Research — Vom Ursprung zur mathematischen Entscheidungsfindung</span></a></li><li data-kapitel="fundament.html"><a href="fundament.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 2: Das mathematische Fundament — Vektoren, Matrizen, Konvexität</span></a></li><li data-kapitel="oekosystem.html"><a href="oekosystem.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 3: Das Python-Ökosystem für OR — Solver, Bindings und Modellierungsschichten</span></a></li><li data-kapitel="modellierung.html"><a href="modellierung.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 4: Vom Management-Wunsch zum Modell</span></a></li></ul></details><details class="sidebar-gruppe"><summary>Teil II: Die Kernverfahren der deterministischen Optimierung</summary><ul><li data-kapitel="lp.html"><a href="lp.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 5: Lineare Programmierung — Simplex, Dualität und Schattenpreise</span></a></li><li data-kapitel="milp.html"><a href="milp.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 6: Gemischt-ganzzahlige Optimierung — Diskrete Entscheidungen und Branch-and-Bound</span></a></li><li data-kapitel="cpsat.html"><a href="cpsat.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 7: Constraint Programming mit CP-SAT — Logik, Scheduling und Zuweisung</span></a></li><li data-kapitel="graphen.html"><a href="graphen.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 8: Graphen, Flüsse und Touren — Min-Cost-Flow, Matching und VRP</span></a></li><li data-kapitel="metaheuristiken.html"><a href="metaheuristiken.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 9: Metaheuristiken — wenn der exakte Solver aussteigt</span></a></li><li data-kapitel="dekomposition.html"><a href="dekomposition.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 10: Spaltengenerierung — das Modell umbauen statt die Lösung raten</span></a></li></ul></details><details class="sidebar-gruppe"><summary>Teil III: Nichtlinearität, Unsicherheit und mehrperiodige Dynamik</summary><ul><li data-kapitel="qp-nlp.html"><a href="qp-nlp.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 11: Quadratische und nichtlineare Optimierung — KKT, Lagrange, Konvexität</span></a></li><li data-kapitel="unsicherheit.html"><a href="unsicherheit.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 12: Optimierung unter Unsicherheit — Monte-Carlo, Stochastik, Robustheit</span></a></li><li data-kapitel="dynamische-programmierung.html"><a href="dynamische-programmierung.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 13: Dynamische Programmierung — Die Bellman-Gleichung und Order-Execution</span></a></li><li data-kapitel="mehrziel.html"><a href="mehrziel.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 14: Mehrere Ziele — Pareto-Fronten statt Gewichte</span></a></li><li data-kapitel="prognose.html"><a href="prognose.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 15: Predict-then-Optimize — die bessere Prognose, die schlechtere Entscheidung</span></a></li></ul></details><details class="sidebar-gruppe" open><summary>Teil IV: Anwendungen — Energiewirtschaft und Finanzmärkte</summary><ul><li data-kapitel="bruecke.html"><a href="bruecke.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 16: Die Strukturbrücke — dieselbe Mathematik, zwei Welten</span></a></li><li data-kapitel="supplychain.html"><a href="supplychain.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 17: Supply-Chain und Energieeinsatz unter Unsicherheit</span></a></li><li data-kapitel="finanzdaten.html" class="aktiv"><a href="finanzdaten.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 18: Finanzdaten-Modellierung — Renditen, Kovarianz und Shrinkage</span></a></li><li data-kapitel="markowitz.html"><a href="markowitz.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 19: Die moderne Portfoliotheorie nach Markowitz</span></a></li><li data-kapitel="cvar.html"><a href="cvar.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 20: Tail-Risiko, CVaR und Transaktionskosten</span></a></li><li data-kapitel="handelsmaschine.html"><a href="handelsmaschine.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 21: Die vollständige quantitative Handelsmaschine</span></a></li></ul></details><details class="sidebar-gruppe"><summary>Teil V: Praxis</summary><ul><li data-kapitel="praxisfallen.html"><a href="praxisfallen.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 22: Praxisfallen und der Weg zum produktiven Einsatz</span></a></li><li data-kapitel="testing.html"><a href="testing.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 23: Testen, Messen, Ausliefern</span></a></li><li data-kapitel="projektwerkstatt.html"><a href="projektwerkstatt.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Projektwerkstatt</span></a></li></ul></details><details class="sidebar-gruppe"><summary>Anhänge</summary><ul><li data-kapitel="anhang-loesungen.html"><a href="anhang-loesungen.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Anhang A: Lösungen zu allen Übungsaufgaben</span></a></li><li data-kapitel="anhang-modellierungsmuster.html"><a href="anhang-modellierungsmuster.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Anhang B: Katalog der Modellierungsmuster</span></a></li><li data-kapitel="anhang-fehlerdiagnose.html"><a href="anhang-fehlerdiagnose.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Anhang C: Fehlerdiagnose-Handbuch</span></a></li><li data-kapitel="anhang-spickzettel.html"><a href="anhang-spickzettel.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Anhang D: Spickzettel der Solver</span></a></li><li data-kapitel="anhang-glossar-literatur.html"><a href="anhang-glossar-literatur.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Anhang E: Glossar und Literatur</span></a></li></ul></details><ul class="sidebar-extra"><li><a href="programme.html"><svg class="icon" aria-hidden="true"><use href="#icon-book"></use></svg> Beispielprogramme</a></li><li><a href="stichwortverzeichnis.html"><svg class="icon" aria-hidden="true"><use href="#icon-search"></use></svg> Stichwortverzeichnis</a></li><li><a href="gesamtdokument.html"><svg class="icon" aria-hidden="true"><use href="#icon-external-link"></use></svg> Gesamtdokument (eine Seite)</a></li><li><a href="Operations_Research_mit_Python_Version_04.pdf" download><svg class="icon" aria-hidden="true"><use href="#icon-download"></use></svg> Download als PDF</a></li></ul></div></nav>
+  <nav class="sidebar" id="sidebar" aria-label="Kapitelnavigation"><div class="sidebar-inhalt"><details class="sidebar-gruppe"><summary>Einstieg</summary><ul><li data-kapitel="vorwort.html"><a href="vorwort.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Vorwort & Lesehilfe</span></a></li><li data-kapitel="notation.html"><a href="notation.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Notation & Abkürzungen</span></a></li></ul></details><details class="sidebar-gruppe"><summary>Teil I: Grundlagen des Operations Research</summary><ul><li data-kapitel="einfuehrung.html"><a href="einfuehrung.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 1: Einführung in Operations Research — Vom Ursprung zur mathematischen Entscheidungsfindung</span></a></li><li data-kapitel="fundament.html"><a href="fundament.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 2: Das mathematische Fundament — Vektoren, Matrizen, Konvexität</span></a></li><li data-kapitel="oekosystem.html"><a href="oekosystem.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 3: Das Python-Ökosystem für OR — Solver, Bindings und Modellierungsschichten</span></a></li><li data-kapitel="modellierung.html"><a href="modellierung.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 4: Vom Management-Wunsch zum Modell</span></a></li><li data-kapitel="synthese-grundlagen.html"><a href="synthese-grundlagen.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Synthese Teil I</span></a></li></ul></details><details class="sidebar-gruppe"><summary>Teil II: Die Kernverfahren der deterministischen Optimierung</summary><ul><li data-kapitel="lp.html"><a href="lp.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 5: Lineare Programmierung — Simplex, Dualität und Schattenpreise</span></a></li><li data-kapitel="milp.html"><a href="milp.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 6: Gemischt-ganzzahlige Optimierung — Diskrete Entscheidungen und Branch-and-Bound</span></a></li><li data-kapitel="cpsat.html"><a href="cpsat.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 7: Constraint Programming mit CP-SAT — Logik, Scheduling und Zuweisung</span></a></li><li data-kapitel="graphen.html"><a href="graphen.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 8: Graphen, Flüsse und Touren — Min-Cost-Flow, Matching und VRP</span></a></li><li data-kapitel="metaheuristiken.html"><a href="metaheuristiken.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 9: Metaheuristiken — wenn der exakte Solver aussteigt</span></a></li><li data-kapitel="dekomposition.html"><a href="dekomposition.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 10: Spaltengenerierung — das Modell umbauen statt die Lösung raten</span></a></li><li data-kapitel="synthese-kernverfahren.html"><a href="synthese-kernverfahren.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Synthese Teil II</span></a></li></ul></details><details class="sidebar-gruppe"><summary>Teil III: Nichtlinearität, Unsicherheit und mehrperiodige Dynamik</summary><ul><li data-kapitel="qp-nlp.html"><a href="qp-nlp.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 11: Quadratische und nichtlineare Optimierung — KKT, Lagrange, Konvexität</span></a></li><li data-kapitel="unsicherheit.html"><a href="unsicherheit.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 12: Optimierung unter Unsicherheit — Monte-Carlo, Stochastik, Robustheit</span></a></li><li data-kapitel="dynamische-programmierung.html"><a href="dynamische-programmierung.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 13: Dynamische Programmierung — Die Bellman-Gleichung und Order-Execution</span></a></li><li data-kapitel="mehrziel.html"><a href="mehrziel.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 14: Mehrere Ziele — Pareto-Fronten statt Gewichte</span></a></li><li data-kapitel="prognose.html"><a href="prognose.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 15: Predict-then-Optimize — die bessere Prognose, die schlechtere Entscheidung</span></a></li><li data-kapitel="synthese-nichtlinear.html"><a href="synthese-nichtlinear.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Synthese Teil III</span></a></li></ul></details><details class="sidebar-gruppe" open><summary>Teil IV: Anwendungen — Energiewirtschaft und Finanzmärkte</summary><ul><li data-kapitel="bruecke.html"><a href="bruecke.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 16: Die Strukturbrücke — dieselbe Mathematik, zwei Welten</span></a></li><li data-kapitel="supplychain.html"><a href="supplychain.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 17: Supply-Chain und Energieeinsatz unter Unsicherheit</span></a></li><li data-kapitel="finanzdaten.html" class="aktiv"><a href="finanzdaten.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 18: Finanzdaten-Modellierung — Renditen, Kovarianz und Shrinkage</span></a></li><li data-kapitel="markowitz.html"><a href="markowitz.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 19: Die moderne Portfoliotheorie nach Markowitz</span></a></li><li data-kapitel="cvar.html"><a href="cvar.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 20: Tail-Risiko, CVaR und Transaktionskosten</span></a></li><li data-kapitel="handelsmaschine.html"><a href="handelsmaschine.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 21: Die vollständige quantitative Handelsmaschine</span></a></li><li data-kapitel="synthese-anwendungen.html"><a href="synthese-anwendungen.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Synthese Teil IV</span></a></li></ul></details><details class="sidebar-gruppe"><summary>Teil V: Praxis</summary><ul><li data-kapitel="praxisfallen.html"><a href="praxisfallen.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 22: Praxisfallen und der Weg zum produktiven Einsatz</span></a></li><li data-kapitel="testing.html"><a href="testing.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 23: Testen, Messen, Ausliefern</span></a></li><li data-kapitel="synthese-praxis.html"><a href="synthese-praxis.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Synthese Teil V</span></a></li><li data-kapitel="projektwerkstatt.html"><a href="projektwerkstatt.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Projektwerkstatt</span></a></li></ul></details><details class="sidebar-gruppe"><summary>Anhänge</summary><ul><li data-kapitel="anhang-loesungen.html"><a href="anhang-loesungen.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Anhang A: Lösungen zu allen Übungsaufgaben</span></a></li><li data-kapitel="anhang-modellierungsmuster.html"><a href="anhang-modellierungsmuster.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Anhang B: Katalog der Modellierungsmuster</span></a></li><li data-kapitel="anhang-fehlerdiagnose.html"><a href="anhang-fehlerdiagnose.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Anhang C: Fehlerdiagnose-Handbuch</span></a></li><li data-kapitel="anhang-spickzettel.html"><a href="anhang-spickzettel.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Anhang D: Spickzettel der Solver</span></a></li><li data-kapitel="anhang-glossar-literatur.html"><a href="anhang-glossar-literatur.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Anhang E: Glossar und Literatur</span></a></li></ul></details><ul class="sidebar-extra"><li><a href="programme.html"><svg class="icon" aria-hidden="true"><use href="#icon-book"></use></svg> Beispielprogramme</a></li><li><a href="stichwortverzeichnis.html"><svg class="icon" aria-hidden="true"><use href="#icon-search"></use></svg> Stichwortverzeichnis</a></li><li><a href="gesamtdokument.html"><svg class="icon" aria-hidden="true"><use href="#icon-external-link"></use></svg> Gesamtdokument (eine Seite)</a></li><li><a href="Operations_Research_mit_Python_Version_04.pdf" download><svg class="icon" aria-hidden="true"><use href="#icon-download"></use></svg> Download als PDF</a></li></ul></div></nav>
   <main class="content">
     <nav class="breadcrumb" aria-label="Breadcrumb"><a href="index.html">Start</a> › <span>Teil IV</span> › <span>Kapitel 18: Finanzdaten-Modellierung — Renditen, Kovarianz und Shrinkage</span></nav>
     <nav class="prev-next"><a class="prev-next-knopf prev-next-prev" href="supplychain.html"><svg class="icon" aria-hidden="true"><use href="#icon-chevron-left"></use></svg><span><small>Zurück</small>Kapitel 17: Supply-Chain und Energieeinsatz unter Unsicherheit</span></a><a class="prev-next-knopf prev-next-next" href="markowitz.html"><span><small>Weiter</small>Kapitel 19: Die moderne Portfoliotheorie nach Markowitz</span><svg class="icon" aria-hidden="true"><use href="#icon-chevron-right"></use></svg></a></nav>
@@ -541,7 +541,7 @@ Bestmoegliche Volatilitaet bei perfektem Wissen: 11.84 % p.a.
 </table>
 <p><strong>Wichtig ist, Text und Code konsistent auf dieselbe Variante zu beziehen</strong> — zum Beispiel <code>sklearn.covariance.LedoitWolf</code>, das die skalierte Einheitsmatrix verwendet, versus eine manuelle Implementierung des Konstant-Korrelations-Ziels. Dieses Buch nennt beide und macht transparent, welches wo zum Einsatz kommt.</p>
 <blockquote>
-<p><strong>💡 Welches Ziel ist besser?</strong> Es kommt darauf an. Die <strong>Einheitsmatrix</strong> unterstellt, dass alle Titel gleich riskant und unkorreliert sind — eine starke, aber sehr stabile Annahme. Das <strong>Konstant-Korrelations-Ziel</strong> behält die geschätzten Einzelvarianzen und glättet nur die Korrelationen; das ist bei Aktien meist realistischer, weil Titel tatsächlich sehr unterschiedliche Volatilitäten haben. In Übung 11.5 implementieren Sie es selbst und vergleichen.</p>
+<p><strong>💡 Welches Ziel ist besser?</strong> Es kommt darauf an. Die <strong>Einheitsmatrix</strong> unterstellt, dass alle Titel gleich riskant und unkorreliert sind — eine starke, aber sehr stabile Annahme. Das <strong>Konstant-Korrelations-Ziel</strong> behält die geschätzten Einzelvarianzen und glättet nur die Korrelationen; das ist bei Aktien meist realistischer, weil Titel tatsächlich sehr unterschiedliche Volatilitäten haben. In der Aufgabe <em>Beide Shrinkage-Ziele vergleichen</em> (<a href="#sec:finanzdaten-uebungsaufgaben">Abschnitt 18.7</a>) implementieren Sie es selbst und vergleichen.</p>
 </blockquote>
 <p>Das Ergebnis ist in jedem Fall garantiert <strong>positiv definit</strong>, wohlkonditioniert und stabil invertierbar.</p>
 <hr />
@@ -720,7 +720,7 @@ prices.columns:  [&#39;AAPL&#39;, &#39;AMZN&#39;, &#39;CVX&#39;, &#39;GS&#39;, &
 <h2 id="sec:finanzdaten-denkfehler">18.8 Finde den Denkfehler</h2>
 <div class="card card-denkfehler">
 <blockquote>
-<p><strong>🐛 Finde den Denkfehler 11.1: Das risikofreie Portfolio</strong></p>
+<p><strong>🐛 Finde den Denkfehler: Das risikofreie Portfolio</strong></p>
 <p>Ein Analyst stellt ein Portfolio aus <strong>30 Titeln</strong> zusammen. Für die Kovarianzmatrix nimmt er das letzte Quartal — bei Wochendaten sind das <strong>20 Beobachtungen</strong>. Dann minimiert er die Varianz.</p>
 <p>Das Ergebnis begeistert ihn: Das Portfolio hat ein Risiko von <strong>0,000 %</strong>. Er hat ein risikofreies Aktienportfolio gefunden.</p>
 <p><strong>Ihre Aufgabe:</strong> (a) Wie hoch ist der Rang einer Kovarianzmatrix, die aus <span class="math inline">T</span> Beobachtungen für <span class="math inline">N &gt; T</span> Anlagen geschätzt wurde — und was folgt daraus geometrisch? (b) Warum findet ausgerechnet ein <strong>Minimum</strong>-Varianz-Optimierer diese Stelle so zuverlässig? (c) Sehen Sie sich unten die Spalte „Hebel“ an. Was sagt ein Wert von 3,8 über das Portfolio aus? (d) Warum schlägt die simple Gleichgewichtung den Optimierer — und was folgt daraus für Ihre eigenen Modelle, auch außerhalb der Finanzwelt?</p>
@@ -785,72 +785,73 @@ prices.columns:  [&#39;AAPL&#39;, &#39;AMZN&#39;, &#39;CVX&#39;, &#39;GS&#39;, &
 <span id="cb9-55"><a href="#cb9-55" aria-hidden="true" tabindex="-1"></a><span class="co">    exakt positiv semidefinit ist - rechne trotzdem.&#39; Das ist hier bewusst so</span></span>
 <span id="cb9-56"><a href="#cb9-56" aria-hidden="true" tabindex="-1"></a><span class="co">    gewaehlt, denn genau diese Eigenschaft wollen wir vorfuehren. Im</span></span>
 <span id="cb9-57"><a href="#cb9-57" aria-hidden="true" tabindex="-1"></a><span class="co">    Produktivbetrieb waere die DCP-Fehlermeldung das Warnsignal, dem man</span></span>
-<span id="cb9-58"><a href="#cb9-58" aria-hidden="true" tabindex="-1"></a><span class="co">    nachgehen muss (siehe Denkfehler 8.1).</span></span>
-<span id="cb9-59"><a href="#cb9-59" aria-hidden="true" tabindex="-1"></a><span class="co">    &quot;&quot;&quot;</span></span>
-<span id="cb9-60"><a href="#cb9-60" aria-hidden="true" tabindex="-1"></a>    gewichte <span class="op">=</span> cp.Variable(ANZAHL_ANLAGEN)</span>
-<span id="cb9-61"><a href="#cb9-61" aria-hidden="true" tabindex="-1"></a>    problem <span class="op">=</span> cp.Problem(cp.Minimize(cp.quad_form(gewichte, cp.psd_wrap(kovarianz))),</span>
-<span id="cb9-62"><a href="#cb9-62" aria-hidden="true" tabindex="-1"></a>                         [cp.<span class="bu">sum</span>(gewichte) <span class="op">==</span> <span class="dv">1</span>])</span>
-<span id="cb9-63"><a href="#cb9-63" aria-hidden="true" tabindex="-1"></a>    problem.solve()</span>
-<span id="cb9-64"><a href="#cb9-64" aria-hidden="true" tabindex="-1"></a>    <span class="cf">return</span> np.array(gewichte.value).ravel(), <span class="bu">max</span>(problem.value, <span class="fl">0.0</span>)</span>
-<span id="cb9-65"><a href="#cb9-65" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb9-58"><a href="#cb9-58" aria-hidden="true" tabindex="-1"></a><span class="co">    nachgehen muss (siehe den Denkfehler im Kapitel Quadratische und</span></span>
+<span id="cb9-59"><a href="#cb9-59" aria-hidden="true" tabindex="-1"></a><span class="co">    nichtlineare Optimierung).</span></span>
+<span id="cb9-60"><a href="#cb9-60" aria-hidden="true" tabindex="-1"></a><span class="co">    &quot;&quot;&quot;</span></span>
+<span id="cb9-61"><a href="#cb9-61" aria-hidden="true" tabindex="-1"></a>    gewichte <span class="op">=</span> cp.Variable(ANZAHL_ANLAGEN)</span>
+<span id="cb9-62"><a href="#cb9-62" aria-hidden="true" tabindex="-1"></a>    problem <span class="op">=</span> cp.Problem(cp.Minimize(cp.quad_form(gewichte, cp.psd_wrap(kovarianz))),</span>
+<span id="cb9-63"><a href="#cb9-63" aria-hidden="true" tabindex="-1"></a>                         [cp.<span class="bu">sum</span>(gewichte) <span class="op">==</span> <span class="dv">1</span>])</span>
+<span id="cb9-64"><a href="#cb9-64" aria-hidden="true" tabindex="-1"></a>    problem.solve()</span>
+<span id="cb9-65"><a href="#cb9-65" aria-hidden="true" tabindex="-1"></a>    <span class="cf">return</span> np.array(gewichte.value).ravel(), <span class="bu">max</span>(problem.value, <span class="fl">0.0</span>)</span>
 <span id="cb9-66"><a href="#cb9-66" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb9-67"><a href="#cb9-67" aria-hidden="true" tabindex="-1"></a><span class="cf">if</span> <span class="va">__name__</span> <span class="op">==</span> <span class="st">&quot;__main__&quot;</span>:</span>
-<span id="cb9-68"><a href="#cb9-68" aria-hidden="true" tabindex="-1"></a>    schaetzzeitraum <span class="op">=</span> erzeuge_renditen(BEOBACHTUNGEN_SCHAETZUNG)</span>
-<span id="cb9-69"><a href="#cb9-69" aria-hidden="true" tabindex="-1"></a>    spaeterer_verlauf <span class="op">=</span> erzeuge_renditen(BEOBACHTUNGEN_TEST)</span>
-<span id="cb9-70"><a href="#cb9-70" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb9-71"><a href="#cb9-71" aria-hidden="true" tabindex="-1"></a>    stichprobe <span class="op">=</span> np.cov(schaetzzeitraum, rowvar<span class="op">=</span><span class="va">False</span>)</span>
-<span id="cb9-72"><a href="#cb9-72" aria-hidden="true" tabindex="-1"></a>    ledoit_wolf <span class="op">=</span> LedoitWolf().fit(schaetzzeitraum)</span>
-<span id="cb9-73"><a href="#cb9-73" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb9-74"><a href="#cb9-74" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;=&quot;</span> <span class="op">*</span> <span class="dv">78</span>)</span>
-<span id="cb9-75"><a href="#cb9-75" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;  DIE KOVARIANZ-FALLE&quot;</span>)</span>
-<span id="cb9-76"><a href="#cb9-76" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;=&quot;</span> <span class="op">*</span> <span class="dv">78</span>)</span>
-<span id="cb9-77"><a href="#cb9-77" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;</span><span class="sc">{</span>ANZAHL_ANLAGEN<span class="sc">}</span><span class="ss"> Anlagen, geschaetzt aus </span><span class="sc">{</span>BEOBACHTUNGEN_SCHAETZUNG<span class="sc">}</span><span class="ss"> &quot;</span></span>
-<span id="cb9-78"><a href="#cb9-78" aria-hidden="true" tabindex="-1"></a>          <span class="ss">f&quot;Beobachtungen.&quot;</span>)</span>
-<span id="cb9-79"><a href="#cb9-79" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;Rang der Stichprobenmatrix: &quot;</span></span>
-<span id="cb9-80"><a href="#cb9-80" aria-hidden="true" tabindex="-1"></a>          <span class="ss">f&quot;</span><span class="sc">{</span>np<span class="sc">.</span>linalg<span class="sc">.</span>matrix_rank(stichprobe)<span class="sc">}</span><span class="ss"> - noetig waeren </span><span class="sc">{</span>ANZAHL_ANLAGEN<span class="sc">}</span><span class="ss">.&quot;</span>)</span>
-<span id="cb9-81"><a href="#cb9-81" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;Kleinster Eigenwert: </span><span class="sc">{</span>np<span class="sc">.</span>linalg<span class="sc">.</span>eigvalsh(stichprobe)<span class="sc">.</span><span class="bu">min</span>()<span class="sc">:.2e}</span><span class="ss">&quot;</span>)</span>
-<span id="cb9-82"><a href="#cb9-82" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>()</span>
-<span id="cb9-83"><a href="#cb9-83" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;Es gibt also Richtungen, in denen diese Matrix EXAKT null Varianz&quot;</span>)</span>
-<span id="cb9-84"><a href="#cb9-84" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;misst. Genau dort sucht ein Minimum-Varianz-Optimierer.&quot;</span>)</span>
-<span id="cb9-85"><a href="#cb9-85" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>()</span>
-<span id="cb9-86"><a href="#cb9-86" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb9-87"><a href="#cb9-87" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;</span><span class="sc">{</span><span class="st">&#39;Schaetzer&#39;</span><span class="sc">:&lt;26}</span><span class="ss"> </span><span class="sc">{</span><span class="st">&#39;Risiko im Zeitraum&#39;</span><span class="sc">:&gt;19}</span><span class="ss"> &quot;</span></span>
-<span id="cb9-88"><a href="#cb9-88" aria-hidden="true" tabindex="-1"></a>          <span class="ss">f&quot;</span><span class="sc">{</span><span class="st">&#39;Risiko spaeter&#39;</span><span class="sc">:&gt;16}</span><span class="ss"> </span><span class="sc">{</span><span class="st">&#39;Hebel&#39;</span><span class="sc">:&gt;7}</span><span class="ss">&quot;</span>)</span>
-<span id="cb9-89"><a href="#cb9-89" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;-&quot;</span> <span class="op">*</span> <span class="dv">78</span>)</span>
-<span id="cb9-90"><a href="#cb9-90" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb9-91"><a href="#cb9-91" aria-hidden="true" tabindex="-1"></a>    ergebnisse <span class="op">=</span> {}</span>
-<span id="cb9-92"><a href="#cb9-92" aria-hidden="true" tabindex="-1"></a>    <span class="cf">for</span> name, matrix <span class="kw">in</span> [</span>
-<span id="cb9-93"><a href="#cb9-93" aria-hidden="true" tabindex="-1"></a>            (<span class="st">&quot;Stichprobe (roh)&quot;</span>, stichprobe),</span>
-<span id="cb9-94"><a href="#cb9-94" aria-hidden="true" tabindex="-1"></a>            (<span class="ss">f&quot;Ledoit-Wolf (d=</span><span class="sc">{</span>ledoit_wolf<span class="sc">.</span>shrinkage_<span class="sc">:.2f}</span><span class="ss">)&quot;</span>, ledoit_wolf.covariance_)]:</span>
-<span id="cb9-95"><a href="#cb9-95" aria-hidden="true" tabindex="-1"></a>        gewichte, varianz_intern <span class="op">=</span> minimales_risiko(matrix)</span>
-<span id="cb9-96"><a href="#cb9-96" aria-hidden="true" tabindex="-1"></a>        risiko_spaeter <span class="op">=</span> <span class="bu">float</span>(np.std(spaeterer_verlauf <span class="op">@</span> gewichte))</span>
-<span id="cb9-97"><a href="#cb9-97" aria-hidden="true" tabindex="-1"></a>        hebel <span class="op">=</span> <span class="bu">float</span>(np.<span class="bu">abs</span>(gewichte).<span class="bu">sum</span>())</span>
-<span id="cb9-98"><a href="#cb9-98" aria-hidden="true" tabindex="-1"></a>        ergebnisse[name] <span class="op">=</span> (risiko_spaeter, gewichte)</span>
-<span id="cb9-99"><a href="#cb9-99" aria-hidden="true" tabindex="-1"></a>        <span class="bu">print</span>(<span class="ss">f&quot;</span><span class="sc">{</span>name<span class="sc">:&lt;26}</span><span class="ss"> </span><span class="sc">{</span>np<span class="sc">.</span>sqrt(varianz_intern) <span class="op">*</span> <span class="dv">100</span><span class="sc">:&gt;18.3f}</span><span class="ss"> % &quot;</span></span>
-<span id="cb9-100"><a href="#cb9-100" aria-hidden="true" tabindex="-1"></a>              <span class="ss">f&quot;</span><span class="sc">{</span>risiko_spaeter <span class="op">*</span> <span class="dv">100</span><span class="sc">:&gt;15.3f}</span><span class="ss"> % </span><span class="sc">{</span>hebel<span class="sc">:&gt;7.1f}</span><span class="ss">&quot;</span>)</span>
-<span id="cb9-101"><a href="#cb9-101" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb9-102"><a href="#cb9-102" aria-hidden="true" tabindex="-1"></a>    gleich <span class="op">=</span> np.full(ANZAHL_ANLAGEN, <span class="fl">1.0</span> <span class="op">/</span> ANZAHL_ANLAGEN)</span>
-<span id="cb9-103"><a href="#cb9-103" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;</span><span class="sc">{</span><span class="st">&#39;Gleichgewichtung 1/N&#39;</span><span class="sc">:&lt;26}</span><span class="ss"> &quot;</span></span>
-<span id="cb9-104"><a href="#cb9-104" aria-hidden="true" tabindex="-1"></a>          <span class="ss">f&quot;</span><span class="sc">{</span><span class="bu">float</span>(np.std(schaetzzeitraum <span class="op">@</span> gleich)) <span class="op">*</span> <span class="dv">100</span><span class="sc">:&gt;18.3f}</span><span class="ss"> % &quot;</span></span>
-<span id="cb9-105"><a href="#cb9-105" aria-hidden="true" tabindex="-1"></a>          <span class="ss">f&quot;</span><span class="sc">{</span><span class="bu">float</span>(np.std(spaeterer_verlauf <span class="op">@</span> gleich)) <span class="op">*</span> <span class="dv">100</span><span class="sc">:&gt;15.3f}</span><span class="ss"> % </span><span class="sc">{</span><span class="fl">1.0</span><span class="sc">:&gt;7.1f}</span><span class="ss">&quot;</span>)</span>
-<span id="cb9-106"><a href="#cb9-106" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;-&quot;</span> <span class="op">*</span> <span class="dv">78</span>)</span>
-<span id="cb9-107"><a href="#cb9-107" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb9-108"><a href="#cb9-108" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;</span><span class="ch">\n</span><span class="st">Drei Beobachtungen:&quot;</span>)</span>
-<span id="cb9-109"><a href="#cb9-109" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;1. Die rohe Schaetzung meldet 0,000 % Risiko - und liefert spaeter das&quot;</span>)</span>
-<span id="cb9-110"><a href="#cb9-110" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;   SCHLECHTESTE Ergebnis der drei. Sie hat kein Portfolio optimiert,&quot;</span>)</span>
-<span id="cb9-111"><a href="#cb9-111" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;   sondern eine Luecke in den eigenen Daten gefunden.&quot;</span>)</span>
-<span id="cb9-112"><a href="#cb9-112" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;2. Die Gleichgewichtung, die gar nicht optimiert, schlaegt den rohen&quot;</span>)</span>
-<span id="cb9-113"><a href="#cb9-113" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;   Optimierer deutlich. Das ist kein Zufallsbefund, sondern in der&quot;</span>)</span>
-<span id="cb9-114"><a href="#cb9-114" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;   Literatur breit belegt.&quot;</span>)</span>
-<span id="cb9-115"><a href="#cb9-115" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;3. Ledoit-Wolf ist im Schaetzzeitraum EHRLICHER (0,441 statt 0,000 %)&quot;</span>)</span>
-<span id="cb9-116"><a href="#cb9-116" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;   und spaeter am besten. Der Hebel faellt von 3,8 auf 1,8 - das&quot;</span>)</span>
-<span id="cb9-117"><a href="#cb9-117" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;   Portfolio wird auch praktisch handelbarer.&quot;</span>)</span>
-<span id="cb9-118"><a href="#cb9-118" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>()</span>
-<span id="cb9-119"><a href="#cb9-119" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;Merksatz: Ein Optimierer glaubt seinen Eingabedaten vollstaendig.&quot;</span>)</span>
-<span id="cb9-120"><a href="#cb9-120" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;Je mehr Freiheit Sie ihm geben, desto gruendlicher findet er deren&quot;</span>)</span>
-<span id="cb9-121"><a href="#cb9-121" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;Fehler. Das gilt fuer Kovarianzmatrizen wie fuer Lieferzeiten,&quot;</span>)</span>
-<span id="cb9-122"><a href="#cb9-122" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;Ausfallraten und jede andere geschaetzte Groesse.&quot;</span>)</span>
-<span id="cb9-123"><a href="#cb9-123" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;=&quot;</span> <span class="op">*</span> <span class="dv">78</span>)</span></code></pre></div>
+<span id="cb9-67"><a href="#cb9-67" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb9-68"><a href="#cb9-68" aria-hidden="true" tabindex="-1"></a><span class="cf">if</span> <span class="va">__name__</span> <span class="op">==</span> <span class="st">&quot;__main__&quot;</span>:</span>
+<span id="cb9-69"><a href="#cb9-69" aria-hidden="true" tabindex="-1"></a>    schaetzzeitraum <span class="op">=</span> erzeuge_renditen(BEOBACHTUNGEN_SCHAETZUNG)</span>
+<span id="cb9-70"><a href="#cb9-70" aria-hidden="true" tabindex="-1"></a>    spaeterer_verlauf <span class="op">=</span> erzeuge_renditen(BEOBACHTUNGEN_TEST)</span>
+<span id="cb9-71"><a href="#cb9-71" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb9-72"><a href="#cb9-72" aria-hidden="true" tabindex="-1"></a>    stichprobe <span class="op">=</span> np.cov(schaetzzeitraum, rowvar<span class="op">=</span><span class="va">False</span>)</span>
+<span id="cb9-73"><a href="#cb9-73" aria-hidden="true" tabindex="-1"></a>    ledoit_wolf <span class="op">=</span> LedoitWolf().fit(schaetzzeitraum)</span>
+<span id="cb9-74"><a href="#cb9-74" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb9-75"><a href="#cb9-75" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;=&quot;</span> <span class="op">*</span> <span class="dv">78</span>)</span>
+<span id="cb9-76"><a href="#cb9-76" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;  DIE KOVARIANZ-FALLE&quot;</span>)</span>
+<span id="cb9-77"><a href="#cb9-77" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;=&quot;</span> <span class="op">*</span> <span class="dv">78</span>)</span>
+<span id="cb9-78"><a href="#cb9-78" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;</span><span class="sc">{</span>ANZAHL_ANLAGEN<span class="sc">}</span><span class="ss"> Anlagen, geschaetzt aus </span><span class="sc">{</span>BEOBACHTUNGEN_SCHAETZUNG<span class="sc">}</span><span class="ss"> &quot;</span></span>
+<span id="cb9-79"><a href="#cb9-79" aria-hidden="true" tabindex="-1"></a>          <span class="ss">f&quot;Beobachtungen.&quot;</span>)</span>
+<span id="cb9-80"><a href="#cb9-80" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;Rang der Stichprobenmatrix: &quot;</span></span>
+<span id="cb9-81"><a href="#cb9-81" aria-hidden="true" tabindex="-1"></a>          <span class="ss">f&quot;</span><span class="sc">{</span>np<span class="sc">.</span>linalg<span class="sc">.</span>matrix_rank(stichprobe)<span class="sc">}</span><span class="ss"> - noetig waeren </span><span class="sc">{</span>ANZAHL_ANLAGEN<span class="sc">}</span><span class="ss">.&quot;</span>)</span>
+<span id="cb9-82"><a href="#cb9-82" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;Kleinster Eigenwert: </span><span class="sc">{</span>np<span class="sc">.</span>linalg<span class="sc">.</span>eigvalsh(stichprobe)<span class="sc">.</span><span class="bu">min</span>()<span class="sc">:.2e}</span><span class="ss">&quot;</span>)</span>
+<span id="cb9-83"><a href="#cb9-83" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>()</span>
+<span id="cb9-84"><a href="#cb9-84" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;Es gibt also Richtungen, in denen diese Matrix EXAKT null Varianz&quot;</span>)</span>
+<span id="cb9-85"><a href="#cb9-85" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;misst. Genau dort sucht ein Minimum-Varianz-Optimierer.&quot;</span>)</span>
+<span id="cb9-86"><a href="#cb9-86" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>()</span>
+<span id="cb9-87"><a href="#cb9-87" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb9-88"><a href="#cb9-88" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;</span><span class="sc">{</span><span class="st">&#39;Schaetzer&#39;</span><span class="sc">:&lt;26}</span><span class="ss"> </span><span class="sc">{</span><span class="st">&#39;Risiko im Zeitraum&#39;</span><span class="sc">:&gt;19}</span><span class="ss"> &quot;</span></span>
+<span id="cb9-89"><a href="#cb9-89" aria-hidden="true" tabindex="-1"></a>          <span class="ss">f&quot;</span><span class="sc">{</span><span class="st">&#39;Risiko spaeter&#39;</span><span class="sc">:&gt;16}</span><span class="ss"> </span><span class="sc">{</span><span class="st">&#39;Hebel&#39;</span><span class="sc">:&gt;7}</span><span class="ss">&quot;</span>)</span>
+<span id="cb9-90"><a href="#cb9-90" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;-&quot;</span> <span class="op">*</span> <span class="dv">78</span>)</span>
+<span id="cb9-91"><a href="#cb9-91" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb9-92"><a href="#cb9-92" aria-hidden="true" tabindex="-1"></a>    ergebnisse <span class="op">=</span> {}</span>
+<span id="cb9-93"><a href="#cb9-93" aria-hidden="true" tabindex="-1"></a>    <span class="cf">for</span> name, matrix <span class="kw">in</span> [</span>
+<span id="cb9-94"><a href="#cb9-94" aria-hidden="true" tabindex="-1"></a>            (<span class="st">&quot;Stichprobe (roh)&quot;</span>, stichprobe),</span>
+<span id="cb9-95"><a href="#cb9-95" aria-hidden="true" tabindex="-1"></a>            (<span class="ss">f&quot;Ledoit-Wolf (d=</span><span class="sc">{</span>ledoit_wolf<span class="sc">.</span>shrinkage_<span class="sc">:.2f}</span><span class="ss">)&quot;</span>, ledoit_wolf.covariance_)]:</span>
+<span id="cb9-96"><a href="#cb9-96" aria-hidden="true" tabindex="-1"></a>        gewichte, varianz_intern <span class="op">=</span> minimales_risiko(matrix)</span>
+<span id="cb9-97"><a href="#cb9-97" aria-hidden="true" tabindex="-1"></a>        risiko_spaeter <span class="op">=</span> <span class="bu">float</span>(np.std(spaeterer_verlauf <span class="op">@</span> gewichte))</span>
+<span id="cb9-98"><a href="#cb9-98" aria-hidden="true" tabindex="-1"></a>        hebel <span class="op">=</span> <span class="bu">float</span>(np.<span class="bu">abs</span>(gewichte).<span class="bu">sum</span>())</span>
+<span id="cb9-99"><a href="#cb9-99" aria-hidden="true" tabindex="-1"></a>        ergebnisse[name] <span class="op">=</span> (risiko_spaeter, gewichte)</span>
+<span id="cb9-100"><a href="#cb9-100" aria-hidden="true" tabindex="-1"></a>        <span class="bu">print</span>(<span class="ss">f&quot;</span><span class="sc">{</span>name<span class="sc">:&lt;26}</span><span class="ss"> </span><span class="sc">{</span>np<span class="sc">.</span>sqrt(varianz_intern) <span class="op">*</span> <span class="dv">100</span><span class="sc">:&gt;18.3f}</span><span class="ss"> % &quot;</span></span>
+<span id="cb9-101"><a href="#cb9-101" aria-hidden="true" tabindex="-1"></a>              <span class="ss">f&quot;</span><span class="sc">{</span>risiko_spaeter <span class="op">*</span> <span class="dv">100</span><span class="sc">:&gt;15.3f}</span><span class="ss"> % </span><span class="sc">{</span>hebel<span class="sc">:&gt;7.1f}</span><span class="ss">&quot;</span>)</span>
+<span id="cb9-102"><a href="#cb9-102" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb9-103"><a href="#cb9-103" aria-hidden="true" tabindex="-1"></a>    gleich <span class="op">=</span> np.full(ANZAHL_ANLAGEN, <span class="fl">1.0</span> <span class="op">/</span> ANZAHL_ANLAGEN)</span>
+<span id="cb9-104"><a href="#cb9-104" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;</span><span class="sc">{</span><span class="st">&#39;Gleichgewichtung 1/N&#39;</span><span class="sc">:&lt;26}</span><span class="ss"> &quot;</span></span>
+<span id="cb9-105"><a href="#cb9-105" aria-hidden="true" tabindex="-1"></a>          <span class="ss">f&quot;</span><span class="sc">{</span><span class="bu">float</span>(np.std(schaetzzeitraum <span class="op">@</span> gleich)) <span class="op">*</span> <span class="dv">100</span><span class="sc">:&gt;18.3f}</span><span class="ss"> % &quot;</span></span>
+<span id="cb9-106"><a href="#cb9-106" aria-hidden="true" tabindex="-1"></a>          <span class="ss">f&quot;</span><span class="sc">{</span><span class="bu">float</span>(np.std(spaeterer_verlauf <span class="op">@</span> gleich)) <span class="op">*</span> <span class="dv">100</span><span class="sc">:&gt;15.3f}</span><span class="ss"> % </span><span class="sc">{</span><span class="fl">1.0</span><span class="sc">:&gt;7.1f}</span><span class="ss">&quot;</span>)</span>
+<span id="cb9-107"><a href="#cb9-107" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;-&quot;</span> <span class="op">*</span> <span class="dv">78</span>)</span>
+<span id="cb9-108"><a href="#cb9-108" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb9-109"><a href="#cb9-109" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;</span><span class="ch">\n</span><span class="st">Drei Beobachtungen:&quot;</span>)</span>
+<span id="cb9-110"><a href="#cb9-110" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;1. Die rohe Schaetzung meldet 0,000 % Risiko - und liefert spaeter das&quot;</span>)</span>
+<span id="cb9-111"><a href="#cb9-111" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;   SCHLECHTESTE Ergebnis der drei. Sie hat kein Portfolio optimiert,&quot;</span>)</span>
+<span id="cb9-112"><a href="#cb9-112" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;   sondern eine Luecke in den eigenen Daten gefunden.&quot;</span>)</span>
+<span id="cb9-113"><a href="#cb9-113" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;2. Die Gleichgewichtung, die gar nicht optimiert, schlaegt den rohen&quot;</span>)</span>
+<span id="cb9-114"><a href="#cb9-114" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;   Optimierer deutlich. Das ist kein Zufallsbefund, sondern in der&quot;</span>)</span>
+<span id="cb9-115"><a href="#cb9-115" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;   Literatur breit belegt.&quot;</span>)</span>
+<span id="cb9-116"><a href="#cb9-116" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;3. Ledoit-Wolf ist im Schaetzzeitraum EHRLICHER (0,441 statt 0,000 %)&quot;</span>)</span>
+<span id="cb9-117"><a href="#cb9-117" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;   und spaeter am besten. Der Hebel faellt von 3,8 auf 1,8 - das&quot;</span>)</span>
+<span id="cb9-118"><a href="#cb9-118" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;   Portfolio wird auch praktisch handelbarer.&quot;</span>)</span>
+<span id="cb9-119"><a href="#cb9-119" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>()</span>
+<span id="cb9-120"><a href="#cb9-120" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;Merksatz: Ein Optimierer glaubt seinen Eingabedaten vollstaendig.&quot;</span>)</span>
+<span id="cb9-121"><a href="#cb9-121" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;Je mehr Freiheit Sie ihm geben, desto gruendlicher findet er deren&quot;</span>)</span>
+<span id="cb9-122"><a href="#cb9-122" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;Fehler. Das gilt fuer Kovarianzmatrizen wie fuer Lieferzeiten,&quot;</span>)</span>
+<span id="cb9-123"><a href="#cb9-123" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;Ausfallraten und jede andere geschaetzte Groesse.&quot;</span>)</span>
+<span id="cb9-124"><a href="#cb9-124" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;=&quot;</span> <span class="op">*</span> <span class="dv">78</span>)</span></code></pre></div>
 <p><strong>Erwartete Ausgabe:</strong></p>
 <pre><code>==============================================================================
   DIE KOVARIANZ-FALLE
@@ -925,7 +926,7 @@ Ausfallraten und jede andere geschaetzte Groesse.
 <h2 id="sec:finanzdaten-quiz">18.9 Micro-Quiz</h2>
 <div class="card card-quiz">
 <blockquote>
-<p><strong>❓ Micro-Quiz 11: Drei Fragen zum Selbstcheck</strong></p>
+<p><strong>❓ Micro-Quiz 18: Drei Fragen zum Selbstcheck</strong></p>
 <p>Genau eine Antwort ist jeweils richtig. Auflösung in <a href="anhang-loesungen.html#quiz-loesung-finanzdaten">Anhang A</a>.</p>
 <p><strong>1. Ein Kurs fällt um 50 % und steigt danach um 50 %. Wo steht er?</strong> (a) Wieder beim Ausgangswert — die Prozente heben sich auf. (b) Bei 75 % des Ausgangswerts. Diskrete Renditen verknüpfen sich multiplikativ, nicht additiv: <span class="math inline">1{,}0 \cdot 0{,}5 \cdot 1{,}5 = 0{,}75</span>. (c) Bei 25 % des Ausgangswerts.</p>
 <p><strong>2. Wofür nimmt man logarithmische Renditen, wofür diskrete?</strong> (a) Logarithmische sind grundsätzlich genauer und daher immer vorzuziehen. (b) Logarithmische addieren sich über die <strong>Zeit</strong>, diskrete über die <strong>Anlagen</strong> eines Portfolios. Man wählt nach der Richtung, in der summiert wird. (c) Diskrete für kurze, logarithmische für lange Zeiträume.</p>
diff --git a/OR_HTML_04/fundament.html b/OR_HTML_04/fundament.html
index ec66942..97bbb7c 100644
--- a/OR_HTML_04/fundament.html
+++ b/OR_HTML_04/fundament.html
@@ -94,7 +94,7 @@
 </header>
 <div class="site-body">
   <div class="sidebar-overlay" id="sidebar-overlay" hidden></div>
-  <nav class="sidebar" id="sidebar" aria-label="Kapitelnavigation"><div class="sidebar-inhalt"><details class="sidebar-gruppe"><summary>Einstieg</summary><ul><li data-kapitel="vorwort.html"><a href="vorwort.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Vorwort & Lesehilfe</span></a></li><li data-kapitel="notation.html"><a href="notation.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Notation & Abkürzungen</span></a></li></ul></details><details class="sidebar-gruppe" open><summary>Teil I: Grundlagen des Operations Research</summary><ul><li data-kapitel="einfuehrung.html"><a href="einfuehrung.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 1: Einführung in Operations Research — Vom Ursprung zur mathematischen Entscheidungsfindung</span></a></li><li data-kapitel="fundament.html" class="aktiv"><a href="fundament.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 2: Das mathematische Fundament — Vektoren, Matrizen, Konvexität</span></a></li><li data-kapitel="oekosystem.html"><a href="oekosystem.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 3: Das Python-Ökosystem für OR — Solver, Bindings und Modellierungsschichten</span></a></li><li data-kapitel="modellierung.html"><a href="modellierung.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 4: Vom Management-Wunsch zum Modell</span></a></li></ul></details><details class="sidebar-gruppe"><summary>Teil II: Die Kernverfahren der deterministischen Optimierung</summary><ul><li data-kapitel="lp.html"><a href="lp.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 5: Lineare Programmierung — Simplex, Dualität und Schattenpreise</span></a></li><li data-kapitel="milp.html"><a href="milp.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 6: Gemischt-ganzzahlige Optimierung — Diskrete Entscheidungen und Branch-and-Bound</span></a></li><li data-kapitel="cpsat.html"><a href="cpsat.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 7: Constraint Programming mit CP-SAT — Logik, Scheduling und Zuweisung</span></a></li><li data-kapitel="graphen.html"><a href="graphen.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 8: Graphen, Flüsse und Touren — Min-Cost-Flow, Matching und VRP</span></a></li><li data-kapitel="metaheuristiken.html"><a href="metaheuristiken.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 9: Metaheuristiken — wenn der exakte Solver aussteigt</span></a></li><li data-kapitel="dekomposition.html"><a href="dekomposition.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 10: Spaltengenerierung — das Modell umbauen statt die Lösung raten</span></a></li></ul></details><details class="sidebar-gruppe"><summary>Teil III: Nichtlinearität, Unsicherheit und mehrperiodige Dynamik</summary><ul><li data-kapitel="qp-nlp.html"><a href="qp-nlp.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 11: Quadratische und nichtlineare Optimierung — KKT, Lagrange, Konvexität</span></a></li><li data-kapitel="unsicherheit.html"><a href="unsicherheit.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 12: Optimierung unter Unsicherheit — Monte-Carlo, Stochastik, Robustheit</span></a></li><li data-kapitel="dynamische-programmierung.html"><a href="dynamische-programmierung.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 13: Dynamische Programmierung — Die Bellman-Gleichung und Order-Execution</span></a></li><li data-kapitel="mehrziel.html"><a href="mehrziel.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 14: Mehrere Ziele — Pareto-Fronten statt Gewichte</span></a></li><li data-kapitel="prognose.html"><a href="prognose.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 15: Predict-then-Optimize — die bessere Prognose, die schlechtere Entscheidung</span></a></li></ul></details><details class="sidebar-gruppe"><summary>Teil IV: Anwendungen — Energiewirtschaft und Finanzmärkte</summary><ul><li data-kapitel="bruecke.html"><a href="bruecke.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 16: Die Strukturbrücke — dieselbe Mathematik, zwei Welten</span></a></li><li data-kapitel="supplychain.html"><a href="supplychain.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 17: Supply-Chain und Energieeinsatz unter Unsicherheit</span></a></li><li data-kapitel="finanzdaten.html"><a href="finanzdaten.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 18: Finanzdaten-Modellierung — Renditen, Kovarianz und Shrinkage</span></a></li><li data-kapitel="markowitz.html"><a href="markowitz.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 19: Die moderne Portfoliotheorie nach Markowitz</span></a></li><li data-kapitel="cvar.html"><a href="cvar.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 20: Tail-Risiko, CVaR und Transaktionskosten</span></a></li><li data-kapitel="handelsmaschine.html"><a href="handelsmaschine.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 21: Die vollständige quantitative Handelsmaschine</span></a></li></ul></details><details class="sidebar-gruppe"><summary>Teil V: Praxis</summary><ul><li data-kapitel="praxisfallen.html"><a href="praxisfallen.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 22: Praxisfallen und der Weg zum produktiven Einsatz</span></a></li><li data-kapitel="testing.html"><a href="testing.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 23: Testen, Messen, Ausliefern</span></a></li><li data-kapitel="projektwerkstatt.html"><a href="projektwerkstatt.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Projektwerkstatt</span></a></li></ul></details><details class="sidebar-gruppe"><summary>Anhänge</summary><ul><li data-kapitel="anhang-loesungen.html"><a href="anhang-loesungen.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Anhang A: Lösungen zu allen Übungsaufgaben</span></a></li><li data-kapitel="anhang-modellierungsmuster.html"><a href="anhang-modellierungsmuster.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Anhang B: Katalog der Modellierungsmuster</span></a></li><li data-kapitel="anhang-fehlerdiagnose.html"><a href="anhang-fehlerdiagnose.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Anhang C: Fehlerdiagnose-Handbuch</span></a></li><li data-kapitel="anhang-spickzettel.html"><a href="anhang-spickzettel.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Anhang D: Spickzettel der Solver</span></a></li><li data-kapitel="anhang-glossar-literatur.html"><a href="anhang-glossar-literatur.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Anhang E: Glossar und Literatur</span></a></li></ul></details><ul class="sidebar-extra"><li><a href="programme.html"><svg class="icon" aria-hidden="true"><use href="#icon-book"></use></svg> Beispielprogramme</a></li><li><a href="stichwortverzeichnis.html"><svg class="icon" aria-hidden="true"><use href="#icon-search"></use></svg> Stichwortverzeichnis</a></li><li><a href="gesamtdokument.html"><svg class="icon" aria-hidden="true"><use href="#icon-external-link"></use></svg> Gesamtdokument (eine Seite)</a></li><li><a href="Operations_Research_mit_Python_Version_04.pdf" download><svg class="icon" aria-hidden="true"><use href="#icon-download"></use></svg> Download als PDF</a></li></ul></div></nav>
+  <nav class="sidebar" id="sidebar" aria-label="Kapitelnavigation"><div class="sidebar-inhalt"><details class="sidebar-gruppe"><summary>Einstieg</summary><ul><li data-kapitel="vorwort.html"><a href="vorwort.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Vorwort & Lesehilfe</span></a></li><li data-kapitel="notation.html"><a href="notation.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Notation & Abkürzungen</span></a></li></ul></details><details class="sidebar-gruppe" open><summary>Teil I: Grundlagen des Operations Research</summary><ul><li data-kapitel="einfuehrung.html"><a href="einfuehrung.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 1: Einführung in Operations Research — Vom Ursprung zur mathematischen Entscheidungsfindung</span></a></li><li data-kapitel="fundament.html" class="aktiv"><a href="fundament.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 2: Das mathematische Fundament — Vektoren, Matrizen, Konvexität</span></a></li><li data-kapitel="oekosystem.html"><a href="oekosystem.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 3: Das Python-Ökosystem für OR — Solver, Bindings und Modellierungsschichten</span></a></li><li data-kapitel="modellierung.html"><a href="modellierung.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 4: Vom Management-Wunsch zum Modell</span></a></li><li data-kapitel="synthese-grundlagen.html"><a href="synthese-grundlagen.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Synthese Teil I</span></a></li></ul></details><details class="sidebar-gruppe"><summary>Teil II: Die Kernverfahren der deterministischen Optimierung</summary><ul><li data-kapitel="lp.html"><a href="lp.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 5: Lineare Programmierung — Simplex, Dualität und Schattenpreise</span></a></li><li data-kapitel="milp.html"><a href="milp.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 6: Gemischt-ganzzahlige Optimierung — Diskrete Entscheidungen und Branch-and-Bound</span></a></li><li data-kapitel="cpsat.html"><a href="cpsat.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 7: Constraint Programming mit CP-SAT — Logik, Scheduling und Zuweisung</span></a></li><li data-kapitel="graphen.html"><a href="graphen.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 8: Graphen, Flüsse und Touren — Min-Cost-Flow, Matching und VRP</span></a></li><li data-kapitel="metaheuristiken.html"><a href="metaheuristiken.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 9: Metaheuristiken — wenn der exakte Solver aussteigt</span></a></li><li data-kapitel="dekomposition.html"><a href="dekomposition.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 10: Spaltengenerierung — das Modell umbauen statt die Lösung raten</span></a></li><li data-kapitel="synthese-kernverfahren.html"><a href="synthese-kernverfahren.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Synthese Teil II</span></a></li></ul></details><details class="sidebar-gruppe"><summary>Teil III: Nichtlinearität, Unsicherheit und mehrperiodige Dynamik</summary><ul><li data-kapitel="qp-nlp.html"><a href="qp-nlp.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 11: Quadratische und nichtlineare Optimierung — KKT, Lagrange, Konvexität</span></a></li><li data-kapitel="unsicherheit.html"><a href="unsicherheit.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 12: Optimierung unter Unsicherheit — Monte-Carlo, Stochastik, Robustheit</span></a></li><li data-kapitel="dynamische-programmierung.html"><a href="dynamische-programmierung.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 13: Dynamische Programmierung — Die Bellman-Gleichung und Order-Execution</span></a></li><li data-kapitel="mehrziel.html"><a href="mehrziel.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 14: Mehrere Ziele — Pareto-Fronten statt Gewichte</span></a></li><li data-kapitel="prognose.html"><a href="prognose.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 15: Predict-then-Optimize — die bessere Prognose, die schlechtere Entscheidung</span></a></li><li data-kapitel="synthese-nichtlinear.html"><a href="synthese-nichtlinear.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Synthese Teil III</span></a></li></ul></details><details class="sidebar-gruppe"><summary>Teil IV: Anwendungen — Energiewirtschaft und Finanzmärkte</summary><ul><li data-kapitel="bruecke.html"><a href="bruecke.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 16: Die Strukturbrücke — dieselbe Mathematik, zwei Welten</span></a></li><li data-kapitel="supplychain.html"><a href="supplychain.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 17: Supply-Chain und Energieeinsatz unter Unsicherheit</span></a></li><li data-kapitel="finanzdaten.html"><a href="finanzdaten.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 18: Finanzdaten-Modellierung — Renditen, Kovarianz und Shrinkage</span></a></li><li data-kapitel="markowitz.html"><a href="markowitz.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 19: Die moderne Portfoliotheorie nach Markowitz</span></a></li><li data-kapitel="cvar.html"><a href="cvar.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 20: Tail-Risiko, CVaR und Transaktionskosten</span></a></li><li data-kapitel="handelsmaschine.html"><a href="handelsmaschine.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 21: Die vollständige quantitative Handelsmaschine</span></a></li><li data-kapitel="synthese-anwendungen.html"><a href="synthese-anwendungen.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Synthese Teil IV</span></a></li></ul></details><details class="sidebar-gruppe"><summary>Teil V: Praxis</summary><ul><li data-kapitel="praxisfallen.html"><a href="praxisfallen.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 22: Praxisfallen und der Weg zum produktiven Einsatz</span></a></li><li data-kapitel="testing.html"><a href="testing.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 23: Testen, Messen, Ausliefern</span></a></li><li data-kapitel="synthese-praxis.html"><a href="synthese-praxis.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Synthese Teil V</span></a></li><li data-kapitel="projektwerkstatt.html"><a href="projektwerkstatt.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Projektwerkstatt</span></a></li></ul></details><details class="sidebar-gruppe"><summary>Anhänge</summary><ul><li data-kapitel="anhang-loesungen.html"><a href="anhang-loesungen.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Anhang A: Lösungen zu allen Übungsaufgaben</span></a></li><li data-kapitel="anhang-modellierungsmuster.html"><a href="anhang-modellierungsmuster.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Anhang B: Katalog der Modellierungsmuster</span></a></li><li data-kapitel="anhang-fehlerdiagnose.html"><a href="anhang-fehlerdiagnose.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Anhang C: Fehlerdiagnose-Handbuch</span></a></li><li data-kapitel="anhang-spickzettel.html"><a href="anhang-spickzettel.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Anhang D: Spickzettel der Solver</span></a></li><li data-kapitel="anhang-glossar-literatur.html"><a href="anhang-glossar-literatur.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Anhang E: Glossar und Literatur</span></a></li></ul></details><ul class="sidebar-extra"><li><a href="programme.html"><svg class="icon" aria-hidden="true"><use href="#icon-book"></use></svg> Beispielprogramme</a></li><li><a href="stichwortverzeichnis.html"><svg class="icon" aria-hidden="true"><use href="#icon-search"></use></svg> Stichwortverzeichnis</a></li><li><a href="gesamtdokument.html"><svg class="icon" aria-hidden="true"><use href="#icon-external-link"></use></svg> Gesamtdokument (eine Seite)</a></li><li><a href="Operations_Research_mit_Python_Version_04.pdf" download><svg class="icon" aria-hidden="true"><use href="#icon-download"></use></svg> Download als PDF</a></li></ul></div></nav>
   <main class="content">
     <nav class="breadcrumb" aria-label="Breadcrumb"><a href="index.html">Start</a> › <span>Teil I</span> › <span>Kapitel 2: Das mathematische Fundament — Vektoren, Matrizen, Konvexität</span></nav>
     <nav class="prev-next"><a class="prev-next-knopf prev-next-prev" href="einfuehrung.html"><svg class="icon" aria-hidden="true"><use href="#icon-chevron-left"></use></svg><span><small>Zurück</small>Kapitel 1: Einführung in Operations Research — Vom Ursprung zur mathematischen Entscheidungsfindung</span></a><a class="prev-next-knopf prev-next-next" href="oekosystem.html"><span><small>Weiter</small>Kapitel 3: Das Python-Ökosystem für OR — Solver, Bindings und Modellierungsschichten</span><svg class="icon" aria-hidden="true"><use href="#icon-chevron-right"></use></svg></a></nav>
@@ -1224,7 +1224,7 @@ und runden Sie Solver-Ergebnisse NIE ohne Toleranzpruefung.
 <h2 id="sec:fundament-denkfehler">2.9 Finde den Denkfehler</h2>
 <div class="card card-denkfehler">
 <blockquote>
-<p><strong>🐛 Finde den Denkfehler 2.1: Die unauffällige Transposition</strong></p>
+<p><strong>🐛 Finde den Denkfehler: Die unauffällige Transposition</strong></p>
 <p>Ein Kollege überträgt ein Produktionsmodell in Matrixform. Zwei Produkte, zwei Ressourcen — die Technologiematrix ist quadratisch:</p>
 <p><span class="math display">\max\ 3x_1 + 5x_2 \quad \text{u. d. N.}\quad \underbrace{\begin{pmatrix} 1 &amp; 2 \\ 3 &amp; 1 \end{pmatrix}}_{\mathbf{A}} \begin{pmatrix} x_1 \\ x_2\end{pmatrix} \le \begin{pmatrix} 8 \\ 12 \end{pmatrix}</span></p>
 <p>Beim Abtippen aus der Tabelle liest er sie spaltenweise statt zeilenweise ein:</p>
diff --git a/OR_HTML_04/gesamtdokument.html b/OR_HTML_04/gesamtdokument.html
index dca8759..738764b 100644
--- a/OR_HTML_04/gesamtdokument.html
+++ b/OR_HTML_04/gesamtdokument.html
@@ -403,6 +403,13 @@
 <li><a href="#die-lernelemente" id="toc-die-lernelemente">Die Lernelemente</a></li>
 <li><a href="#der-dreischritt-jedes-kapitels" id="toc-der-dreischritt-jedes-kapitels">Der Dreischritt jedes Kapitels</a></li>
 </ul></li>
+<li><a href="#für-wen-dieses-buch-geschrieben-ist" id="toc-für-wen-dieses-buch-geschrieben-ist">Für wen dieses Buch geschrieben ist</a>
+<ul>
+<li><a href="#für-entscheider-und-manager-der-geschäftsfall" id="toc-für-entscheider-und-manager-der-geschäftsfall">Für Entscheider und Manager — der Geschäftsfall</a></li>
+<li><a href="#für-ingenieure-und-produktionsplaner-die-physik-des-systems" id="toc-für-ingenieure-und-produktionsplaner-die-physik-des-systems">Für Ingenieure und Produktionsplaner — die Physik des Systems</a></li>
+<li><a href="#für-investoren-und-finanzanalysten-risiko-und-ertrag" id="toc-für-investoren-und-finanzanalysten-risiko-und-ertrag">Für Investoren und Finanzanalysten — Risiko und Ertrag</a></li>
+<li><a href="#für-studierende-und-data-scientists-die-methodik" id="toc-für-studierende-und-data-scientists-die-methodik">Für Studierende und Data Scientists — die Methodik</a></li>
+</ul></li>
 <li><a href="#lernpfade" id="toc-lernpfade">Lernpfade</a>
 <ul>
 <li><a href="#pfad-a-vollständiger-lehrgang-100140-stunden" id="toc-pfad-a-vollständiger-lehrgang-100140-stunden">Pfad A — Vollständiger Lehrgang (100–140 Stunden)</a></li>
@@ -516,6 +523,7 @@
 </ul></li>
 <li><a href="#sec:oekosystem-ein-system-vier-programmieransaetze" id="toc-sec:oekosystem-ein-system-vier-programmieransaetze">3.5 Ein System — vier Programmieransätze</a>
 <ul>
+<li><a href="#wie-die-isolation-aussieht-wenn-sie-tragen-soll" id="toc-wie-die-isolation-aussieht-wenn-sie-tragen-soll">Wie die Isolation aussieht, wenn sie tragen soll</a></li>
 <li><a href="#was-das-csr-format-bedeutet" id="toc-was-das-csr-format-bedeutet">Was das CSR-Format bedeutet</a></li>
 </ul></li>
 <li><a href="#sec:oekosystem-wann-lohnt-sich-welche-ebene" id="toc-sec:oekosystem-wann-lohnt-sich-welche-ebene">3.6 Wann lohnt sich welche Ebene?</a></li>
@@ -548,11 +556,22 @@
 <li><a href="#teil-4-ein-quartal-später" id="toc-teil-4-ein-quartal-später">Teil 4: Ein Quartal später</a></li>
 </ul></li>
 <li><a href="#sec:modellierung-leitfaden" id="toc-sec:modellierung-leitfaden">4.5 Der Gesprächsleitfaden</a></li>
-<li><a href="#sec:modellierung-uebungsaufgaben" id="toc-sec:modellierung-uebungsaufgaben">4.6 Übungsaufgaben</a></li>
-<li><a href="#sec:modellierung-denkfehler" id="toc-sec:modellierung-denkfehler">4.7 Finde den Denkfehler</a></li>
-<li><a href="#sec:modellierung-quiz" id="toc-sec:modellierung-quiz">4.8 Micro-Quiz</a></li>
-<li><a href="#sec:modellierung-selbsttest" id="toc-sec:modellierung-selbsttest">4.9 Selbsttest</a></li>
-<li><a href="#sec:modellierung-zusammenfassung" id="toc-sec:modellierung-zusammenfassung">4.10 Zusammenfassung</a></li>
+<li><a href="#sec:modellierung-glossar" id="toc-sec:modellierung-glossar">4.6 Deutsch — OR: ein Übersetzungslexikon</a>
+<ul>
+<li><a href="#fünf-wendungen-bei-denen-die-übersetzung-eine-entscheidung-erzwingt" id="toc-fünf-wendungen-bei-denen-die-übersetzung-eine-entscheidung-erzwingt">Fünf Wendungen, bei denen die Übersetzung eine Entscheidung erzwingt</a></li>
+<li><a href="#und-die-gegenrichtung-or-deutsch" id="toc-und-die-gegenrichtung-or-deutsch">Und die Gegenrichtung: OR — Deutsch</a></li>
+</ul></li>
+<li><a href="#sec:modellierung-uebungsaufgaben" id="toc-sec:modellierung-uebungsaufgaben">4.7 Übungsaufgaben</a></li>
+<li><a href="#sec:modellierung-denkfehler" id="toc-sec:modellierung-denkfehler">4.8 Finde den Denkfehler</a></li>
+<li><a href="#sec:modellierung-quiz" id="toc-sec:modellierung-quiz">4.9 Micro-Quiz</a></li>
+<li><a href="#sec:modellierung-selbsttest" id="toc-sec:modellierung-selbsttest">4.10 Selbsttest</a></li>
+<li><a href="#sec:modellierung-zusammenfassung" id="toc-sec:modellierung-zusammenfassung">4.11 Zusammenfassung</a></li>
+</ul></li>
+<li><a href="#synthese-teil-i-grundlagen-auf-einen-blick" id="toc-synthese-teil-i-grundlagen-auf-einen-blick">Synthese Teil I — Grundlagen auf einen Blick</a>
+<ul>
+<li><a href="#was-welches-kapitel-klärt" id="toc-was-welches-kapitel-klärt">Was welches Kapitel klärt</a></li>
+<li><a href="#die-reihenfolge-ist-die-aussage" id="toc-die-reihenfolge-ist-die-aussage">Die Reihenfolge ist die Aussage</a></li>
+<li><a href="#wenn-sie-nur-eines-mitnehmen" id="toc-wenn-sie-nur-eines-mitnehmen">Wenn Sie nur eines mitnehmen</a></li>
 </ul></li>
 <li><a href="#teil-kernverfahren" id="toc-teil-kernverfahren">Teil II: Die Kernverfahren der deterministischen Optimierung</a></li>
 <li><a href="#kap-lp" id="toc-kap-lp">Kapitel 5: Lineare Programmierung — Simplex, Dualität und Schattenpreise</a>
@@ -626,12 +645,17 @@
 <li><a href="#sec:cpsat-globale-constraints-die-bausteine-von-cp" id="toc-sec:cpsat-globale-constraints-die-bausteine-von-cp">7.4 Globale Constraints — die Bausteine von CP-SAT</a></li>
 <li><a href="#sec:cpsat-praxisfall-dynamisches-vertretungssystem" id="toc-sec:cpsat-praxisfall-dynamisches-vertretungssystem">7.5 Praxisfall: Dynamisches Vertretungssystem</a></li>
 <li><a href="#sec:cpsat-intervallvariablen-job-shop-scheduling" id="toc-sec:cpsat-intervallvariablen-job-shop-scheduling">7.6 Intervallvariablen: Job-Shop-Scheduling</a></li>
-<li><a href="#sec:cpsat-statusfaelle" id="toc-sec:cpsat-statusfaelle">7.7 Die fünf Antworten von CP-SAT</a></li>
-<li><a href="#sec:cpsat-uebungsaufgaben" id="toc-sec:cpsat-uebungsaufgaben">7.8 Übungsaufgaben</a></li>
-<li><a href="#sec:cpsat-denkfehler" id="toc-sec:cpsat-denkfehler">7.9 Finde den Denkfehler</a></li>
-<li><a href="#sec:cpsat-quiz" id="toc-sec:cpsat-quiz">7.10 Micro-Quiz</a></li>
-<li><a href="#sec:cpsat-selbsttest" id="toc-sec:cpsat-selbsttest">7.11 Selbsttest</a></li>
-<li><a href="#sec:cpsat-zusammenfassung" id="toc-sec:cpsat-zusammenfassung">7.12 Zusammenfassung</a></li>
+<li><a href="#sec:cpsat-parallele-suche" id="toc-sec:cpsat-parallele-suche">7.7 Parallele Suche: was <code>num_workers</code> wirklich bewirkt</a>
+<ul>
+<li><a href="#was-die-messung-zeigt" id="toc-was-die-messung-zeigt">Was die Messung zeigt</a></li>
+<li><a href="#was-daraus-für-tests-folgt" id="toc-was-daraus-für-tests-folgt">Was daraus für Tests folgt</a></li>
+</ul></li>
+<li><a href="#sec:cpsat-statusfaelle" id="toc-sec:cpsat-statusfaelle">7.8 Die fünf Antworten von CP-SAT</a></li>
+<li><a href="#sec:cpsat-uebungsaufgaben" id="toc-sec:cpsat-uebungsaufgaben">7.9 Übungsaufgaben</a></li>
+<li><a href="#sec:cpsat-denkfehler" id="toc-sec:cpsat-denkfehler">7.10 Finde den Denkfehler</a></li>
+<li><a href="#sec:cpsat-quiz" id="toc-sec:cpsat-quiz">7.11 Micro-Quiz</a></li>
+<li><a href="#sec:cpsat-selbsttest" id="toc-sec:cpsat-selbsttest">7.12 Selbsttest</a></li>
+<li><a href="#sec:cpsat-zusammenfassung" id="toc-sec:cpsat-zusammenfassung">7.13 Zusammenfassung</a></li>
 </ul></li>
 <li><a href="#kap-graphen" id="toc-kap-graphen">Kapitel 8: Graphen, Flüsse und Touren — Min-Cost-Flow, Matching und VRP</a>
 <ul>
@@ -703,6 +727,13 @@
 <li><a href="#sec:dekomposition-selbsttest" id="toc-sec:dekomposition-selbsttest">10.10 Selbsttest</a></li>
 <li><a href="#sec:dekomposition-zusammenfassung" id="toc-sec:dekomposition-zusammenfassung">10.11 Zusammenfassung</a></li>
 </ul></li>
+<li><a href="#synthese-teil-ii-die-kernverfahren-nebeneinander" id="toc-synthese-teil-ii-die-kernverfahren-nebeneinander">Synthese Teil II — Die Kernverfahren nebeneinander</a>
+<ul>
+<li><a href="#die-entscheidungsmatrix" id="toc-die-entscheidungsmatrix">Die Entscheidungsmatrix</a></li>
+<li><a href="#was-dieser-teil-gemessen-hat" id="toc-was-dieser-teil-gemessen-hat">Was dieser Teil gemessen hat</a></li>
+<li><a href="#drei-fehler-die-dieser-teil-verhindert" id="toc-drei-fehler-die-dieser-teil-verhindert">Drei Fehler, die dieser Teil verhindert</a></li>
+<li><a href="#wenn-sie-nur-eines-mitnehmen-1" id="toc-wenn-sie-nur-eines-mitnehmen-1">Wenn Sie nur eines mitnehmen</a></li>
+</ul></li>
 <li><a href="#teil-nichtlinear" id="toc-teil-nichtlinear">Teil III: Nichtlinearität, Unsicherheit und mehrperiodige Dynamik</a></li>
 <li><a href="#kap-qp-nlp" id="toc-kap-qp-nlp">Kapitel 11: Quadratische und nichtlineare Optimierung — KKT, Lagrange, Konvexität</a>
 <ul>
@@ -816,6 +847,13 @@
 <li><a href="#sec:prognose-selbsttest" id="toc-sec:prognose-selbsttest">15.11 Selbsttest</a></li>
 <li><a href="#sec:prognose-zusammenfassung" id="toc-sec:prognose-zusammenfassung">15.12 Zusammenfassung</a></li>
 </ul></li>
+<li><a href="#synthese-teil-iii-wenn-die-idealwelt-nicht-gilt" id="toc-synthese-teil-iii-wenn-die-idealwelt-nicht-gilt">Synthese Teil III — Wenn die Idealwelt nicht gilt</a>
+<ul>
+<li><a href="#welche-annahme-fällt-weg" id="toc-welche-annahme-fällt-weg">Welche Annahme fällt weg?</a></li>
+<li><a href="#was-dieser-teil-gemessen-hat-1" id="toc-was-dieser-teil-gemessen-hat-1">Was dieser Teil gemessen hat</a></li>
+<li><a href="#drei-fehler-die-dieser-teil-verhindert-1" id="toc-drei-fehler-die-dieser-teil-verhindert-1">Drei Fehler, die dieser Teil verhindert</a></li>
+<li><a href="#wenn-sie-nur-eines-mitnehmen-2" id="toc-wenn-sie-nur-eines-mitnehmen-2">Wenn Sie nur eines mitnehmen</a></li>
+</ul></li>
 <li><a href="#teil-anwendungen" id="toc-teil-anwendungen">Teil IV: Anwendungen — Energiewirtschaft und Finanzmärkte</a></li>
 <li><a href="#kap-bruecke" id="toc-kap-bruecke">Kapitel 16: Die Strukturbrücke — dieselbe Mathematik, zwei Welten</a>
 <ul>
@@ -926,6 +964,13 @@
 <li><a href="#sec:handelsmaschine-selbsttest" id="toc-sec:handelsmaschine-selbsttest">21.11 Selbsttest</a></li>
 <li><a href="#sec:handelsmaschine-zusammenfassung" id="toc-sec:handelsmaschine-zusammenfassung">21.12 Zusammenfassung</a></li>
 </ul></li>
+<li><a href="#synthese-teil-iv-zwei-domänen-dieselbe-mathematik" id="toc-synthese-teil-iv-zwei-domänen-dieselbe-mathematik">Synthese Teil IV — Zwei Domänen, dieselbe Mathematik</a>
+<ul>
+<li><a href="#dieselbe-struktur-andere-namen" id="toc-dieselbe-struktur-andere-namen">Dieselbe Struktur, andere Namen</a></li>
+<li><a href="#was-dieser-teil-gemessen-hat-2" id="toc-was-dieser-teil-gemessen-hat-2">Was dieser Teil gemessen hat</a></li>
+<li><a href="#drei-fehler-die-dieser-teil-verhindert-2" id="toc-drei-fehler-die-dieser-teil-verhindert-2">Drei Fehler, die dieser Teil verhindert</a></li>
+<li><a href="#wenn-sie-nur-eines-mitnehmen-3" id="toc-wenn-sie-nur-eines-mitnehmen-3">Wenn Sie nur eines mitnehmen</a></li>
+</ul></li>
 <li><a href="#teil-praxis" id="toc-teil-praxis">Teil V: Praxis</a></li>
 <li><a href="#kap-praxisfallen" id="toc-kap-praxisfallen">Kapitel 22: Praxisfallen und der Weg zum produktiven Einsatz</a>
 <ul>
@@ -939,20 +984,25 @@
 <li><a href="#falle-4-lookahead--und-survivorship-bias" id="toc-falle-4-lookahead--und-survivorship-bias">Falle 4 — Lookahead- und Survivorship-Bias</a></li>
 <li><a href="#falle-5-laufzeitexplosion" id="toc-falle-5-laufzeitexplosion">Falle 5 — Laufzeitexplosion</a></li>
 </ul></li>
-<li><a href="#sec:praxisfallen-architektur-einer-produktionsreifen-or-plattform" id="toc-sec:praxisfallen-architektur-einer-produktionsreifen-or-plattform">22.4 Architektur einer produktionsreifen OR-Plattform</a></li>
-<li><a href="#sec:praxisfallen-or-kern" id="toc-sec:praxisfallen-or-kern">22.5 Der gemeinsame Unterbau: <code>or_kern.py</code></a>
+<li><a href="#sec:praxisfallen-attribution" id="toc-sec:praxisfallen-attribution">22.4 Constraint Attribution: welche Bedingung kostet wie viel?</a>
+<ul>
+<li><a href="#drei-befunde-und-keiner-steht-im-solverergebnis" id="toc-drei-befunde-und-keiner-steht-im-solverergebnis">Drei Befunde, und keiner steht im Solverergebnis</a></li>
+<li><a href="#vom-zahlenwerk-zur-vorlage" id="toc-vom-zahlenwerk-zur-vorlage">Vom Zahlenwerk zur Vorlage</a></li>
+</ul></li>
+<li><a href="#sec:praxisfallen-architektur-einer-produktionsreifen-or-plattform" id="toc-sec:praxisfallen-architektur-einer-produktionsreifen-or-plattform">22.5 Architektur einer produktionsreifen OR-Plattform</a></li>
+<li><a href="#sec:praxisfallen-or-kern" id="toc-sec:praxisfallen-or-kern">22.6 Der gemeinsame Unterbau: <code>or_kern.py</code></a>
 <ul>
 <li><a href="#die-vier-schichten" id="toc-die-vier-schichten">Die vier Schichten</a></li>
 <li><a href="#ein-enum-für-fünf-bibliotheken" id="toc-ein-enum-für-fünf-bibliotheken">Ein Enum für fünf Bibliotheken</a></li>
 </ul></li>
-<li><a href="#sec:praxisfallen-solverwechsel" id="toc-sec:praxisfallen-solverwechsel">22.6 Der Solverwechsel in der Praxis</a></li>
-<li><a href="#sec:praxisfallen-eine-checkliste-vor-dem-produktivgang" id="toc-sec:praxisfallen-eine-checkliste-vor-dem-produktivgang">22.7 Eine Checkliste vor dem Produktivgang</a></li>
-<li><a href="#sec:praxisfallen-weiterfuehrende-literatur-und-roadmap" id="toc-sec:praxisfallen-weiterfuehrende-literatur-und-roadmap">22.8 Weiterführende Literatur und Roadmap</a></li>
-<li><a href="#sec:praxisfallen-uebungsaufgaben" id="toc-sec:praxisfallen-uebungsaufgaben">22.9 Übungsaufgaben</a></li>
-<li><a href="#sec:praxisfallen-denkfehler" id="toc-sec:praxisfallen-denkfehler">22.10 Finde den Denkfehler</a></li>
-<li><a href="#sec:praxisfallen-quiz" id="toc-sec:praxisfallen-quiz">22.11 Micro-Quiz</a></li>
-<li><a href="#sec:praxisfallen-selbsttest" id="toc-sec:praxisfallen-selbsttest">22.12 Selbsttest</a></li>
-<li><a href="#sec:praxisfallen-zusammenfassung" id="toc-sec:praxisfallen-zusammenfassung">22.13 Zusammenfassung</a></li>
+<li><a href="#sec:praxisfallen-solverwechsel" id="toc-sec:praxisfallen-solverwechsel">22.7 Der Solverwechsel in der Praxis</a></li>
+<li><a href="#sec:praxisfallen-eine-checkliste-vor-dem-produktivgang" id="toc-sec:praxisfallen-eine-checkliste-vor-dem-produktivgang">22.8 Eine Checkliste vor dem Produktivgang</a></li>
+<li><a href="#sec:praxisfallen-weiterfuehrende-literatur-und-roadmap" id="toc-sec:praxisfallen-weiterfuehrende-literatur-und-roadmap">22.9 Weiterführende Literatur und Roadmap</a></li>
+<li><a href="#sec:praxisfallen-uebungsaufgaben" id="toc-sec:praxisfallen-uebungsaufgaben">22.10 Übungsaufgaben</a></li>
+<li><a href="#sec:praxisfallen-denkfehler" id="toc-sec:praxisfallen-denkfehler">22.11 Finde den Denkfehler</a></li>
+<li><a href="#sec:praxisfallen-quiz" id="toc-sec:praxisfallen-quiz">22.12 Micro-Quiz</a></li>
+<li><a href="#sec:praxisfallen-selbsttest" id="toc-sec:praxisfallen-selbsttest">22.13 Selbsttest</a></li>
+<li><a href="#sec:praxisfallen-zusammenfassung" id="toc-sec:praxisfallen-zusammenfassung">22.14 Zusammenfassung</a></li>
 </ul></li>
 <li><a href="#kap-testing" id="toc-kap-testing">Kapitel 23: Testen, Messen, Ausliefern</a>
 <ul>
@@ -979,6 +1029,13 @@
 <li><a href="#sec:testing-selbsttest" id="toc-sec:testing-selbsttest">23.11 Selbsttest</a></li>
 <li><a href="#sec:testing-zusammenfassung" id="toc-sec:testing-zusammenfassung">23.12 Zusammenfassung</a></li>
 </ul></li>
+<li><a href="#synthese-teil-v-vom-rechnenden-modell-zum-benutzten-system" id="toc-synthese-teil-v-vom-rechnenden-modell-zum-benutzten-system">Synthese Teil V — Vom rechnenden Modell zum benutzten System</a>
+<ul>
+<li><a href="#was-schiefgeht-und-was-dagegen-hilft" id="toc-was-schiefgeht-und-was-dagegen-hilft">Was schiefgeht, und was dagegen hilft</a></li>
+<li><a href="#was-dieser-teil-gemessen-hat-3" id="toc-was-dieser-teil-gemessen-hat-3">Was dieser Teil gemessen hat</a></li>
+<li><a href="#drei-fehler-die-dieser-teil-verhindert-3" id="toc-drei-fehler-die-dieser-teil-verhindert-3">Drei Fehler, die dieser Teil verhindert</a></li>
+<li><a href="#wenn-sie-nur-eines-mitnehmen-4" id="toc-wenn-sie-nur-eines-mitnehmen-4">Wenn Sie nur eines mitnehmen</a></li>
+</ul></li>
 <li><a href="#projektwerkstatt-elf-eigene-anwendungen" id="toc-projektwerkstatt-elf-eigene-anwendungen">Projektwerkstatt — elf eigene Anwendungen</a>
 <ul>
 <li><a href="#wie-sie-ein-projekt-bearbeiten" id="toc-wie-sie-ein-projekt-bearbeiten">Wie Sie ein Projekt bearbeiten</a></li>
@@ -999,19 +1056,19 @@
 <ul>
 <li><a href="#sec:loesungen-einfuehrung" id="toc-sec:loesungen-einfuehrung">A.1 Lösungen zu Kapitel „Einführung in Operations Research — Vom Ursprung zur mathematischen Entscheidungsfindung“</a>
 <ul>
-<li><a href="#finde-den-denkfehler-1.1-die-schreinerei-verdoppelt-ihren-gewinn" id="toc-finde-den-denkfehler-1.1-die-schreinerei-verdoppelt-ihren-gewinn">Finde den Denkfehler 1.1 — Die Schreinerei verdoppelt ihren Gewinn</a></li>
+<li><a href="#finde-den-denkfehler-die-schreinerei-verdoppelt-ihren-gewinn" id="toc-finde-den-denkfehler-die-schreinerei-verdoppelt-ihren-gewinn">Finde den Denkfehler — Die Schreinerei verdoppelt ihren Gewinn</a></li>
 <li><a href="#quiz-loesung-einfuehrung" id="toc-quiz-loesung-einfuehrung">Micro-Quiz</a></li>
 <li><a href="#selbsttest-loesung-einfuehrung" id="toc-selbsttest-loesung-einfuehrung">Selbsttest</a></li>
 </ul></li>
 <li><a href="#sec:loesungen-fundament" id="toc-sec:loesungen-fundament">A.2 Lösungen zu Kapitel „Das mathematische Fundament — Vektoren, Matrizen, Konvexität“</a>
 <ul>
-<li><a href="#finde-den-denkfehler-2.1-die-unauffällige-transposition" id="toc-finde-den-denkfehler-2.1-die-unauffällige-transposition">Finde den Denkfehler 2.1 — Die unauffällige Transposition</a></li>
+<li><a href="#finde-den-denkfehler-die-unauffällige-transposition" id="toc-finde-den-denkfehler-die-unauffällige-transposition">Finde den Denkfehler — Die unauffällige Transposition</a></li>
 <li><a href="#quiz-loesung-fundament" id="toc-quiz-loesung-fundament">Micro-Quiz</a></li>
 <li><a href="#selbsttest-loesung-fundament" id="toc-selbsttest-loesung-fundament">Selbsttest</a></li>
 </ul></li>
 <li><a href="#sec:loesungen-oekosystem" id="toc-sec:loesungen-oekosystem">A.3 Lösungen zu Kapitel „Das Python-Ökosystem für OR — Solver, Bindings und Modellierungsschichten“</a>
 <ul>
-<li><a href="#finde-den-denkfehler-3.1-der-solver-der-angeblich-dreimal-schneller-ist" id="toc-finde-den-denkfehler-3.1-der-solver-der-angeblich-dreimal-schneller-ist">Finde den Denkfehler 3.1 — Der Solver, der angeblich dreimal schneller ist</a></li>
+<li><a href="#finde-den-denkfehler-der-solver-der-angeblich-dreimal-schneller-ist" id="toc-finde-den-denkfehler-der-solver-der-angeblich-dreimal-schneller-ist">Finde den Denkfehler — Der Solver, der angeblich dreimal schneller ist</a></li>
 <li><a href="#quiz-loesung-oekosystem" id="toc-quiz-loesung-oekosystem">Micro-Quiz</a></li>
 <li><a href="#selbsttest-loesung-oekosystem" id="toc-selbsttest-loesung-oekosystem">Selbsttest</a></li>
 </ul></li>
@@ -1023,25 +1080,25 @@
 </ul></li>
 <li><a href="#sec:loesungen-lp" id="toc-sec:loesungen-lp">A.5 Lösungen zu Kapitel „Lineare Programmierung — Simplex, Dualität und Schattenpreise“</a>
 <ul>
-<li><a href="#finde-den-denkfehler-4.1-die-380-000-euro-maschine" id="toc-finde-den-denkfehler-4.1-die-380-000-euro-maschine">Finde den Denkfehler 4.1 — Die 380 000-Euro-Maschine</a></li>
+<li><a href="#finde-den-denkfehler-die-380-000-euro-maschine" id="toc-finde-den-denkfehler-die-380-000-euro-maschine">Finde den Denkfehler — Die 380 000-Euro-Maschine</a></li>
 <li><a href="#quiz-loesung-lp" id="toc-quiz-loesung-lp">Micro-Quiz</a></li>
 <li><a href="#selbsttest-loesung-lp" id="toc-selbsttest-loesung-lp">Selbsttest</a></li>
 </ul></li>
 <li><a href="#sec:loesungen-milp" id="toc-sec:loesungen-milp">A.6 Lösungen zu Kapitel „Gemischt-ganzzahlige Optimierung — Diskrete Entscheidungen und Branch-and-Bound“</a>
 <ul>
-<li><a href="#finde-den-denkfehler-5.1-elf-lager-die-keine-fixkosten-kosten" id="toc-finde-den-denkfehler-5.1-elf-lager-die-keine-fixkosten-kosten">Finde den Denkfehler 5.1 — Elf Lager, die keine Fixkosten kosten</a></li>
+<li><a href="#finde-den-denkfehler-elf-lager-die-keine-fixkosten-kosten" id="toc-finde-den-denkfehler-elf-lager-die-keine-fixkosten-kosten">Finde den Denkfehler — Elf Lager, die keine Fixkosten kosten</a></li>
 <li><a href="#quiz-loesung-milp" id="toc-quiz-loesung-milp">Micro-Quiz</a></li>
 <li><a href="#selbsttest-loesung-milp" id="toc-selbsttest-loesung-milp">Selbsttest</a></li>
 </ul></li>
 <li><a href="#sec:loesungen-cpsat" id="toc-sec:loesungen-cpsat">A.7 Lösungen zu Kapitel „Constraint Programming mit CP-SAT — Logik, Scheduling und Zuweisung“</a>
 <ul>
-<li><a href="#finde-den-denkfehler-6.1-die-betriebsvereinbarung-die-niemanden-interessiert" id="toc-finde-den-denkfehler-6.1-die-betriebsvereinbarung-die-niemanden-interessiert">Finde den Denkfehler 6.1 — Die Betriebsvereinbarung, die niemanden interessiert</a></li>
+<li><a href="#finde-den-denkfehler-die-betriebsvereinbarung-die-niemanden-interessiert" id="toc-finde-den-denkfehler-die-betriebsvereinbarung-die-niemanden-interessiert">Finde den Denkfehler — Die Betriebsvereinbarung, die niemanden interessiert</a></li>
 <li><a href="#quiz-loesung-cpsat" id="toc-quiz-loesung-cpsat">Micro-Quiz</a></li>
 <li><a href="#selbsttest-loesung-cpsat" id="toc-selbsttest-loesung-cpsat">Selbsttest</a></li>
 </ul></li>
 <li><a href="#sec:loesungen-graphen" id="toc-sec:loesungen-graphen">A.8 Lösungen zu Kapitel „Graphen, Flüsse und Touren — Min-Cost-Flow, Matching und VRP“</a>
 <ul>
-<li><a href="#finde-den-denkfehler-7.1-die-vergessene-dimension" id="toc-finde-den-denkfehler-7.1-die-vergessene-dimension">Finde den Denkfehler 7.1 — Die vergessene Dimension</a></li>
+<li><a href="#finde-den-denkfehler-die-vergessene-dimension" id="toc-finde-den-denkfehler-die-vergessene-dimension">Finde den Denkfehler — Die vergessene Dimension</a></li>
 <li><a href="#quiz-loesung-graphen" id="toc-quiz-loesung-graphen">Micro-Quiz</a></li>
 <li><a href="#selbsttest-loesung-graphen" id="toc-selbsttest-loesung-graphen">Selbsttest</a></li>
 </ul></li>
@@ -1059,19 +1116,19 @@
 </ul></li>
 <li><a href="#sec:loesungen-qp-nlp" id="toc-sec:loesungen-qp-nlp">A.11 Lösungen zu Kapitel „Quadratische und nichtlineare Optimierung — KKT, Lagrange, Konvexität“</a>
 <ul>
-<li><a href="#finde-den-denkfehler-8.1-die-kovarianzmatrix-aus-dem-controlling" id="toc-finde-den-denkfehler-8.1-die-kovarianzmatrix-aus-dem-controlling">Finde den Denkfehler 8.1 — Die Kovarianzmatrix aus dem Controlling</a></li>
+<li><a href="#finde-den-denkfehler-die-kovarianzmatrix-aus-dem-controlling" id="toc-finde-den-denkfehler-die-kovarianzmatrix-aus-dem-controlling">Finde den Denkfehler — Die Kovarianzmatrix aus dem Controlling</a></li>
 <li><a href="#quiz-loesung-qp-nlp" id="toc-quiz-loesung-qp-nlp">Micro-Quiz</a></li>
 <li><a href="#selbsttest-loesung-qp-nlp" id="toc-selbsttest-loesung-qp-nlp">Selbsttest</a></li>
 </ul></li>
 <li><a href="#sec:loesungen-unsicherheit" id="toc-sec:loesungen-unsicherheit">A.12 Lösungen zu Kapitel „Optimierung unter Unsicherheit — Monte-Carlo, Stochastik, Robustheit“</a>
 <ul>
-<li><a href="#finde-den-denkfehler-9.1-warum-jedes-projekt-zu-spät-fertig-wird" id="toc-finde-den-denkfehler-9.1-warum-jedes-projekt-zu-spät-fertig-wird">Finde den Denkfehler 9.1 — Warum jedes Projekt zu spät fertig wird</a></li>
+<li><a href="#finde-den-denkfehler-warum-jedes-projekt-zu-spät-fertig-wird" id="toc-finde-den-denkfehler-warum-jedes-projekt-zu-spät-fertig-wird">Finde den Denkfehler — Warum jedes Projekt zu spät fertig wird</a></li>
 <li><a href="#quiz-loesung-unsicherheit" id="toc-quiz-loesung-unsicherheit">Micro-Quiz</a></li>
 <li><a href="#selbsttest-loesung-unsicherheit" id="toc-selbsttest-loesung-unsicherheit">Selbsttest</a></li>
 </ul></li>
 <li><a href="#sec:loesungen-dynamische-programmierung" id="toc-sec:loesungen-dynamische-programmierung">A.13 Lösungen zu Kapitel „Dynamische Programmierung — Die Bellman-Gleichung und Order-Execution“</a>
 <ul>
-<li><a href="#finde-den-denkfehler-10.1-der-zustand-der-zu-wenig-weiß" id="toc-finde-den-denkfehler-10.1-der-zustand-der-zu-wenig-weiß">Finde den Denkfehler 10.1 — Der Zustand, der zu wenig weiß</a></li>
+<li><a href="#finde-den-denkfehler-der-zustand-der-zu-wenig-weiß" id="toc-finde-den-denkfehler-der-zustand-der-zu-wenig-weiß">Finde den Denkfehler — Der Zustand, der zu wenig weiß</a></li>
 <li><a href="#quiz-loesung-dynamische-programmierung" id="toc-quiz-loesung-dynamische-programmierung">Micro-Quiz</a></li>
 <li><a href="#selbsttest-loesung-dynamische-programmierung" id="toc-selbsttest-loesung-dynamische-programmierung">Selbsttest</a></li>
 </ul></li>
@@ -1101,31 +1158,31 @@
 </ul></li>
 <li><a href="#sec:loesungen-finanzdaten" id="toc-sec:loesungen-finanzdaten">A.18 Lösungen zu Kapitel „Finanzdaten-Modellierung — Renditen, Kovarianz und Shrinkage“</a>
 <ul>
-<li><a href="#finde-den-denkfehler-11.1-das-risikofreie-portfolio" id="toc-finde-den-denkfehler-11.1-das-risikofreie-portfolio">Finde den Denkfehler 11.1 — Das risikofreie Portfolio</a></li>
+<li><a href="#finde-den-denkfehler-das-risikofreie-portfolio" id="toc-finde-den-denkfehler-das-risikofreie-portfolio">Finde den Denkfehler — Das risikofreie Portfolio</a></li>
 <li><a href="#quiz-loesung-finanzdaten" id="toc-quiz-loesung-finanzdaten">Micro-Quiz</a></li>
 <li><a href="#selbsttest-loesung-finanzdaten" id="toc-selbsttest-loesung-finanzdaten">Selbsttest</a></li>
 </ul></li>
 <li><a href="#sec:loesungen-markowitz" id="toc-sec:loesungen-markowitz">A.19 Lösungen zu Kapitel „Die moderne Portfoliotheorie nach Markowitz“</a>
 <ul>
-<li><a href="#finde-den-denkfehler-12.1-zwölf-gleiche-anlagen-ein-sehr-ungleiches-portfolio" id="toc-finde-den-denkfehler-12.1-zwölf-gleiche-anlagen-ein-sehr-ungleiches-portfolio">Finde den Denkfehler 12.1 — Zwölf gleiche Anlagen, ein sehr ungleiches Portfolio</a></li>
+<li><a href="#finde-den-denkfehler-zwölf-gleiche-anlagen-ein-sehr-ungleiches-portfolio" id="toc-finde-den-denkfehler-zwölf-gleiche-anlagen-ein-sehr-ungleiches-portfolio">Finde den Denkfehler — Zwölf gleiche Anlagen, ein sehr ungleiches Portfolio</a></li>
 <li><a href="#quiz-loesung-markowitz" id="toc-quiz-loesung-markowitz">Micro-Quiz</a></li>
 <li><a href="#selbsttest-loesung-markowitz" id="toc-selbsttest-loesung-markowitz">Selbsttest</a></li>
 </ul></li>
 <li><a href="#sec:loesungen-cvar" id="toc-sec:loesungen-cvar">A.20 Lösungen zu Kapitel „Tail-Risiko, CVaR und Transaktionskosten“</a>
 <ul>
-<li><a href="#finde-den-denkfehler-13.1-das-risikobudget-das-durch-diversifikation-stieg" id="toc-finde-den-denkfehler-13.1-das-risikobudget-das-durch-diversifikation-stieg">Finde den Denkfehler 13.1 — Das Risikobudget, das durch Diversifikation stieg</a></li>
+<li><a href="#finde-den-denkfehler-das-risikobudget-das-durch-diversifikation-stieg" id="toc-finde-den-denkfehler-das-risikobudget-das-durch-diversifikation-stieg">Finde den Denkfehler — Das Risikobudget, das durch Diversifikation stieg</a></li>
 <li><a href="#quiz-loesung-cvar" id="toc-quiz-loesung-cvar">Micro-Quiz</a></li>
 <li><a href="#selbsttest-loesung-cvar" id="toc-selbsttest-loesung-cvar">Selbsttest</a></li>
 </ul></li>
 <li><a href="#sec:loesungen-handelsmaschine" id="toc-sec:loesungen-handelsmaschine">A.21 Lösungen zu Kapitel „Die vollständige quantitative Handelsmaschine“</a>
 <ul>
-<li><a href="#finde-den-denkfehler-14.1-die-strategie-mit-dem-hochsignifikanten-ergebnis" id="toc-finde-den-denkfehler-14.1-die-strategie-mit-dem-hochsignifikanten-ergebnis">Finde den Denkfehler 14.1 — Die Strategie mit dem hochsignifikanten Ergebnis</a></li>
+<li><a href="#finde-den-denkfehler-die-strategie-mit-dem-hochsignifikanten-ergebnis" id="toc-finde-den-denkfehler-die-strategie-mit-dem-hochsignifikanten-ergebnis">Finde den Denkfehler — Die Strategie mit dem hochsignifikanten Ergebnis</a></li>
 <li><a href="#quiz-loesung-handelsmaschine" id="toc-quiz-loesung-handelsmaschine">Micro-Quiz</a></li>
 <li><a href="#selbsttest-loesung-handelsmaschine" id="toc-selbsttest-loesung-handelsmaschine">Selbsttest</a></li>
 </ul></li>
 <li><a href="#sec:loesungen-praxisfallen" id="toc-sec:loesungen-praxisfallen">A.22 Lösungen zu Kapitel „Praxisfallen und der Weg zum produktiven Einsatz“</a>
 <ul>
-<li><a href="#finde-den-denkfehler-15.1-das-modell-das-seit-einem-jahr-nicht-mehr-optimiert" id="toc-finde-den-denkfehler-15.1-das-modell-das-seit-einem-jahr-nicht-mehr-optimiert">Finde den Denkfehler 15.1 — Das Modell, das seit einem Jahr nicht mehr optimiert</a></li>
+<li><a href="#finde-den-denkfehler-das-modell-das-seit-einem-jahr-nicht-mehr-optimiert" id="toc-finde-den-denkfehler-das-modell-das-seit-einem-jahr-nicht-mehr-optimiert">Finde den Denkfehler — Das Modell, das seit einem Jahr nicht mehr optimiert</a></li>
 <li><a href="#quiz-loesung-praxisfallen" id="toc-quiz-loesung-praxisfallen">Micro-Quiz</a></li>
 <li><a href="#selbsttest-loesung-praxisfallen" id="toc-selbsttest-loesung-praxisfallen">Selbsttest</a></li>
 </ul></li>
@@ -1501,6 +1558,57 @@ Alles bereit — Sie können mit dem ersten Kapitel beginnen.</code></pre>
 <li><strong>Lauffähiges Python-Programm</strong> — vollständig abgedruckt, mit erwarteter Ausgabe.</li>
 </ol>
 <hr />
+<h2 class="unnumbered" id="für-wen-dieses-buch-geschrieben-ist">Für wen dieses Buch geschrieben ist</h2>
+<p>Die Lernpfade weiter unten sind nach <strong>Themen</strong> geschnitten. Dieser Abschnitt ist nach <strong>Rollen</strong> geschnitten: vier Einstiege für vier Arten, mit Optimierung zu tun zu haben. Jeder nennt den Schmerzpunkt, drei Dinge, die das Buch dafür wirklich liefert — mit den Zahlen, die es dazu misst —, den passenden Lernpfad und die Frage, an der es in dieser Rolle am häufigsten scheitert.</p>
+<p>Suchen Sie sich einen aus. Sie können auch alle vier überspringen; nötig sind sie nicht.</p>
+<h3 class="unnumbered" id="für-entscheider-und-manager-der-geschäftsfall">Für Entscheider und Manager — der Geschäftsfall</h3>
+<blockquote>
+<p><em>„Wir planen seit Jahren mit Erfahrungswerten, und es funktioniert. Warum sollte ein Modell das besser können — und was kostet mich der Irrtum, wenn ich es nicht tue?“</em></p>
+</blockquote>
+<ul>
+<li><strong>Was Planen mit Durchschnitten kostet, wird hier beziffert, nicht behauptet.</strong> Im Kraftwerkseinsatz aus <a href="#kap-supplychain">Kapitel 17</a> kostet ein Plan, der mit dem Wind-<strong>Erwartungswert</strong> rechnet, in der Wirklichkeit <strong>149 % mehr</strong> als einer, der 40 Szenarien berücksichtigt — 874 870 € statt 351 356 € — und führt in <strong>28 von 40 Szenarien</strong> zum Lastabwurf statt in keinem.</li>
+<li><strong>„Wie sicher soll es sein?“ wird eine Preisfrage.</strong> <a href="#sec:unsicherheit-chance-constraints">Abschnitt 12.7</a> rechnet aus, was ein Prozentpunkt Versorgungssicherheit kostet: rund 56 000 € auf dem Weg zu 80 %, rund 254 000 € zwischen 95 und 99 %. Das <strong>4,5-fache</strong>. Wer 99,9 % fordert, ohne diese Kurve gesehen zu haben, fordert ins Blaue.</li>
+<li><strong>Für die Sitzung gibt es einen Bericht, keine Tabelle.</strong> <a href="#sec:praxisfallen-attribution">Abschnitt 22.4</a> beziffert je Nebenbedingung, was sie den Plan kostet, und formuliert daraus Sätze in Alltagssprache. Für die Frage des Betriebsrats — <em>„warum ausgerechnet ich?“</em> — liefert <a href="#kap-praxisfallen">Kapitel 22</a> den Constraint-Trace, der die einzelne Zuweisung begründet.</li>
+</ul>
+<p><strong>Ihr Weg.</strong> Zuerst Pfad E (2–4 Stunden): <a href="#sec:einfuehrung-historischer-kontext-und-evolution">Abschnitt 1.5</a> und <a href="#anhang-modellierungsmuster">Anhang B</a>. Wenn Sie danach wissen wollen, was in Ihrem Betrieb geht, Pfad B und Projekt <strong>P1</strong> oder <strong>P2</strong>.</p>
+<p><strong>Woran es scheitert.</strong> Nicht am Modell, sondern an der Einführung — das ist der meistgenannte Befund in <a href="#kap-praxisfallen">Kapitel 22</a>. Und an einer Verwechslung, die dieses Buch Ihnen nicht abnehmen kann: Ein Bericht erklärt das <strong>Modell</strong>, nicht die <strong>Wirklichkeit</strong>. Ist ein Deckungsbeitrag falsch geschätzt, ist er überzeugend <strong>und</strong> falsch. Fragen Sie deshalb jedes Mal, worauf eine Zahl beruht.</p>
+<blockquote>
+<p><strong>Eine Erwartung, die dieses Buch enttäuscht:</strong> Es nennt keine ROI-Kennzahl und keine Amortisationsdauer. Beide hängen an Ihrem Betrieb, und jede Zahl hier wäre erfunden. Was es stattdessen liefert, ist das Werkzeug, Ihre eigene auszurechnen: den <strong>EVPI</strong> in <a href="#kap-unsicherheit">Kapitel 12</a> (was eine perfekte Prognose überhaupt wert wäre — eine Obergrenze für jedes Prognoseprojekt) und die Kostenzurechnung aus <a href="#sec:praxisfallen-attribution">Abschnitt 22.4</a>.</p>
+</blockquote>
+<h3 class="unnumbered" id="für-ingenieure-und-produktionsplaner-die-physik-des-systems">Für Ingenieure und Produktionsplaner — die Physik des Systems</h3>
+<blockquote>
+<p><em>„Der Engpass wandert. Kaum ist eine Maschine entlastet, steht die nächste — und niemand kann mir vorher sagen, welche.“</em></p>
+</blockquote>
+<ul>
+<li><strong>Der Engpass lässt sich benennen und bepreisen.</strong> <a href="#sec:praxisfallen-attribution">Abschnitt 22.4</a> rechnet für jede Kapazität aus, was die nächste Stunde wert ist — und wie weit dieser Wert trägt. Im Beispiel gilt der Schattenpreis der Lackiererei exakt bis <strong>+15 Stunden</strong>; eine ganze Sonderschicht von 30 Stunden bringt deshalb 60 € statt der rechnerischen 120 €. <strong>Die zweite Hälfte wäre bezahlt und wirkungslos.</strong></li>
+<li><strong>Rüstzeiten, Reihenfolgen, Taktzeiten sind der Kern, nicht die Ausnahme.</strong> <a href="#kap-cpsat">Kapitel 7</a> modelliert Maschinenbelegung mit Intervallvariablen, <a href="#kap-metaheuristiken">Kapitel 9</a> zeigt am selben Fall das Gesamtbild: Faustregel 2 497 Minuten Rüstzeit, CP-SAT allein 2 628, Simulated Annealing 2 343, Annealing plus LNS <strong>2 289</strong> — und die untere Schranke bei 1 768, damit sichtbar bleibt, wie viel Luft noch da ist.</li>
+<li><strong>Wenn der Solver zu lange braucht, gibt es Zahlen statt Ratschläge.</strong> <a href="#sec:cpsat-parallele-suche">Abschnitt 7.7</a> misst, was mehrere Suchstränge bringen (hier Faktor 12,3) — und ab wo mehr Arbeiter wieder schaden.</li>
+</ul>
+<p><strong>Ihr Weg.</strong> Pfad B bis <a href="#kap-cpsat">Kapitel 7</a>, dann Projekt <strong>P5</strong> (Produktionsplanung mit Rüstkosten). Wenn Ihre echten Instanzen den Solver stehen lassen: <a href="#kap-metaheuristiken">Kapitel 9</a> und Projekt <strong>P9</strong>.</p>
+<p><strong>Woran es scheitert.</strong> An der Verwechslung von <em>bindend</em> und <em>teuer</em>. Eine Bedingung kann den Plan berühren und trotzdem <strong>nichts</strong> kosten — im Beispiel von <a href="#sec:praxisfallen-attribution">Abschnitt 22.4</a> gilt das für eine von fünf bindenden. Wer sie nachverhandelt, gewinnt nichts und hält das Verfahren für nutzlos.</p>
+<h3 class="unnumbered" id="für-investoren-und-finanzanalysten-risiko-und-ertrag">Für Investoren und Finanzanalysten — Risiko und Ertrag</h3>
+<blockquote>
+<p><em>„Die Optimierung liefert mir Gewichte, die kein Mensch halten würde: 60 % in einem Titel, null in fünf anderen. Und im nächsten Quartal sieht sie völlig anders aus.“</em></p>
+</blockquote>
+<ul>
+<li><strong>Der Grund dafür steht in <a href="#kap-finanzdaten">Kapitel 18</a>, nicht in <a href="#kap-markowitz">Kapitel 19</a>.</strong> Eine aus kurzen Zeitreihen geschätzte Kovarianzmatrix ist schlecht konditioniert; der Optimierer setzt dann auf Schätzrauschen. Shrinkage nach Ledoit-Wolf ist das Gegenmittel; ihre Wirkung wird an <strong>Eigenwertspektrum und Konditionszahl</strong> gemessen, nicht behauptet.</li>
+<li><strong>Der VaR verschweigt genau das, worauf es ankommt.</strong> In der Stichprobe aus <a href="#kap-cvar">Kapitel 20</a> sagt der VaR: „an 95 % der Tage höchstens <strong>1,86 %</strong> Verlust“. Der CVaR sagt: „und wenn doch, dann im Mittel <strong>2,99 %</strong>“. Der schlechteste Tag der Stichprobe liegt bei <strong>−23,0 %</strong> — am VaR ändert dieser eine Tag <strong>nichts</strong>, am CVaR sehr wohl. Deshalb ist der CVaR die Größe, die man optimiert.</li>
+<li><strong>Transaktionskosten und Rebalancing sind Teil des Modells, nicht ein Abzug danach.</strong> <a href="#kap-cvar">Kapitel 20</a> nimmt sie in die Zielfunktion, <a href="#kap-handelsmaschine">Kapitel 21</a> setzt den Backtest daneben — samt der Fallen, die einen guten Backtest wertlos machen.</li>
+</ul>
+<p><strong>Ihr Weg.</strong> Pfad D, und zwar <strong>mit</strong> <a href="#kap-finanzdaten">Kapitel 18</a>. Danach Projekt <strong>P6</strong> (Portfolio-Rebalancer) oder <strong>P7</strong> (Risikoreport mit CVaR und Stresstests).</p>
+<p><strong>Woran es scheitert.</strong> An der Reihenfolge. Wer bei Markowitz einsteigt und die Datenkapitel überspringt, bekommt ein Modell, das seine eigenen Schätzfehler maximiert — und merkt es erst im Echtgeldbetrieb.</p>
+<h3 class="unnumbered" id="für-studierende-und-data-scientists-die-methodik">Für Studierende und Data Scientists — die Methodik</h3>
+<blockquote>
+<p><em>„Ich kann ein Modell trainieren und den Fehler senken. Aber wie wird aus einer Prognose eine Entscheidung — und woher weiß ich, dass sie gut ist?“</em></p>
+</blockquote>
+<ul>
+<li><strong>Die unbequemste Erkenntnis zuerst.</strong> <a href="#kap-prognose">Kapitel 15</a> zeigt an einem gerechneten Fall, dass das Modell mit dem <strong>schlechteren</strong> MSE die <strong>günstigere</strong> Entscheidung trifft. Prognosegüte und Entscheidungsqualität sind zwei verschiedene Größen; wer die eine optimiert, bekommt die andere nicht geschenkt.</li>
+<li><strong>Dieselbe Mathematik, zwei Welten.</strong> <a href="#kap-bruecke">Kapitel 16</a> lässt <strong>denselben Code</strong> einmal über eine Werkstatt und einmal über ein Depot laufen — und benennt die drei Stellen, an denen die Analogie endet. Struktur zu erkennen ist die eigentliche Fähigkeit, nicht Bibliothekskenntnis; zu wissen, wo eine Analogie aufhört, gehört dazu.</li>
+<li><strong>Es wird gerechnet, nicht nacherzählt.</strong> Zu jedem Kapitel gehören Aufgaben mit vollständigen Lösungen, Handrechnungen und ein „Finde den Denkfehler“ — und jedes abgedruckte Ergebnis stammt aus einem echten Lauf des danebenstehenden Programms.</li>
+</ul>
+<p><strong>Ihr Weg.</strong> Pfad A, wenn Sie Zeit haben. Sonst Pfad B oder D bis zum ersten Projekt und von dort zurück in die Grundlagen. Für eigene Fragestellungen: Projekt <strong>P8</strong>.</p>
+<p><strong>Woran es scheitert.</strong> An der Annahme, ein Solver sei eine Bibliothek wie jede andere. Die schwierige Arbeit steckt in der Formulierung — <a href="#kap-modellierung">Kapitel 4</a> ist deshalb kein Vorgeplänkel, sondern das Kapitel, auf das alle anderen aufbauen.</p>
+<hr />
 <h2 class="unnumbered" id="lernpfade">Lernpfade</h2>
 <p>Sie müssen nicht alles lesen, um etwas Nützliches bauen zu können.</p>
 <h3 class="unnumbered" id="pfad-a-vollständiger-lehrgang-100140-stunden">Pfad A — Vollständiger Lehrgang (100–140 Stunden)</h3>
@@ -1514,7 +1622,7 @@ Alles bereit — Sie können mit dem ersten Kapitel beginnen.</code></pre>
 <h3 class="unnumbered" id="pfad-d-quantitative-finance-ca.-30-stunden">Pfad D — Quantitative Finance (ca. 30 Stunden)</h3>
 <p><a href="#kap-einfuehrung">Kapitel 1</a> → <a href="#kap-fundament">Kapitel 2</a> → <a href="#kap-qp-nlp">Kapitel 11</a> (QP, KKT) → <a href="#kap-finanzdaten">Kapitel 18</a> (Daten, Shrinkage) → <a href="#kap-markowitz">Kapitel 19</a> (Markowitz) → <a href="#kap-cvar">Kapitel 20</a> (CVaR) → <a href="#kap-handelsmaschine">Kapitel 21</a> (Backtest) → Projekt <strong>P6</strong> (Portfolio-Rebalancer) oder <strong>P7</strong> (Risikoreport). <strong>Wichtig:</strong> Überspringen Sie <a href="#kap-finanzdaten">Kapitel 18</a> nicht. Wer direkt bei Markowitz einsteigt, optimiert Schätzrauschen und wundert sich über absurde Gewichte.</p>
 <h3 class="unnumbered" id="pfad-e-ich-habe-morgen-ein-konkretes-problem-24-stunden">Pfad E — Ich habe morgen ein konkretes Problem (2–4 Stunden)</h3>
-<p>Lesen Sie <a href="#sec:einfuehrung-historischer-kontext-und-evolution">Abschnitt 1.5</a> (die vier Bausteine), dann <a href="#anhang-modellierungsmuster">Anhang B</a> (<strong>Modellierungsmuster</strong>) und suchen Sie dort das Muster, das zu Ihrem Problem passt. Von jedem Muster führt ein Verweis in das zuständige Kapitel. Wie die gewählte Bibliothek es schreibt, steht in <a href="#anhang-spickzettel">Anhang D</a> (<strong>Spickzettel</strong>); wenn etwas nicht läuft, in <a href="#anhang-fehlerdiagnose">Anhang C</a> (<strong>Fehlerdiagnose</strong>).</p>
+<p>Lesen Sie <a href="#sec:einfuehrung-historischer-kontext-und-evolution">Abschnitt 1.5</a> (die vier Bausteine) und <a href="#sec:modellierung-glossar">Abschnitt 4.6</a> (welcher Satz welcher Baustein ist), dann <a href="#anhang-modellierungsmuster">Anhang B</a> (<strong>Modellierungsmuster</strong>) und suchen Sie dort das Muster, das zu Ihrem Problem passt. Von jedem Muster führt ein Verweis in das zuständige Kapitel. Wie die gewählte Bibliothek es schreibt, steht in <a href="#anhang-spickzettel">Anhang D</a> (<strong>Spickzettel</strong>); wenn etwas nicht läuft, in <a href="#anhang-fehlerdiagnose">Anhang C</a> (<strong>Fehlerdiagnose</strong>).</p>
 <h3 class="unnumbered" id="pfad-f-vom-prototyp-in-den-betrieb-ca.-15-stunden">Pfad F — Vom Prototyp in den Betrieb (ca. 15 Stunden)</h3>
 <p>Für alle, deren Modell <strong>rechnet</strong> und die es jetzt jemand anderem übergeben müssen: <a href="#kap-praxisfallen">Kapitel 22</a> (die fünf Praxisfallen, <code>or_kern.py</code>, Erklärbarkeit) → <a href="#kap-testing">Kapitel 23</a> (Testsuite, Mutationstest, Benchmark, HTTP-Dienst) → <a href="#anhang-fehlerdiagnose">Anhang C</a> als Nachschlagewerk für den Ernstfall, dann Projekt <strong>P11</strong> (Vom Skript zum Dienst). Setzt voraus, dass Sie mindestens einen der Pfade B, C oder D hinter sich haben — P11 baut auf einem Modell auf, das Sie schon haben.</p>
 <p><em>Der Kern in einem Satz:</em> Ein Modell, das nur auf Ihrem Rechner und nur mit Ihren Daten läuft, ist ein Prototyp — kein System.</p>
@@ -1671,200 +1779,210 @@ Alles bereit — Sie können mit dem ersten Kapitel beginnen.</code></pre>
 <td><a href="#kap-cpsat">Kapitel 7</a></td>
 </tr>
 <tr class="even">
+<td><code>Parallele_Suche.py</code></td>
+<td>num_workers: Tempo gegen Reproduzierbarkeit</td>
+<td><a href="#kap-cpsat">Kapitel 7</a></td>
+</tr>
+<tr class="odd">
 <td><code>CP_SAT_Statusfaelle.py</code></td>
 <td>Die fünf Solver-Antworten</td>
 <td><a href="#kap-cpsat">Kapitel 7</a></td>
 </tr>
-<tr class="odd">
+<tr class="even">
 <td><code>Strafgewichte.py</code></td>
 <td>Gewichte als Wechselkurse</td>
 <td><a href="#kap-cpsat">Kapitel 7</a></td>
 </tr>
-<tr class="even">
+<tr class="odd">
 <td><code>Min_Cost_Flow.py</code></td>
 <td>Netzwerkfluss</td>
 <td><a href="#kap-graphen">Kapitel 8</a></td>
 </tr>
-<tr class="odd">
+<tr class="even">
 <td><code>Zuordnung_Ungarisch.py</code></td>
 <td>Zuordnung, Unimodularität</td>
 <td><a href="#kap-graphen">Kapitel 8</a></td>
 </tr>
-<tr class="even">
+<tr class="odd">
 <td><code>VRP_Flotten_Routing.py</code></td>
 <td>CVRPTW</td>
 <td><a href="#kap-graphen">Kapitel 8</a></td>
 </tr>
-<tr class="odd">
+<tr class="even">
 <td><code>VRP_Kapazitaetsfalle.py</code></td>
 <td>Vergessene Dimension im Routing</td>
 <td><a href="#kap-graphen">Kapitel 8</a></td>
 </tr>
-<tr class="even">
+<tr class="odd">
 <td><code>Simulated_Annealing.py</code></td>
 <td>Lokale Suche, Temperatur kalibrieren</td>
 <td><a href="#kap-metaheuristiken">Kapitel 9</a></td>
 </tr>
-<tr class="odd">
+<tr class="even">
 <td><code>Metaheuristik_vs_Exakt.py</code></td>
 <td>Der Umschlagpunkt, und die Schranke</td>
 <td><a href="#kap-metaheuristiken">Kapitel 9</a></td>
 </tr>
-<tr class="even">
+<tr class="odd">
 <td><code>Large_Neighborhood_Search.py</code></td>
 <td>Zerstören und exakt reparieren</td>
 <td><a href="#kap-metaheuristiken">Kapitel 9</a></td>
 </tr>
-<tr class="odd">
+<tr class="even">
 <td><code>Spaltengenerierung.py</code></td>
 <td>Muster statt Stücke, Master und Pricing</td>
 <td><a href="#kap-dekomposition">Kapitel 10</a></td>
 </tr>
-<tr class="even">
+<tr class="odd">
 <td><code>QP_Grundlagen.py</code></td>
 <td>Konvexität, DCP-Check</td>
 <td><a href="#kap-qp-nlp">Kapitel 11</a></td>
 </tr>
-<tr class="odd">
+<tr class="even">
 <td><code>KKT_Nachweis.py</code></td>
 <td>KKT numerisch prüfen</td>
 <td><a href="#kap-qp-nlp">Kapitel 11</a></td>
 </tr>
-<tr class="even">
+<tr class="odd">
 <td><code>Entropie_Maximierte_Allokation.py</code></td>
 <td>NLP mit Entropie</td>
 <td><a href="#kap-qp-nlp">Kapitel 11</a></td>
 </tr>
-<tr class="odd">
+<tr class="even">
 <td><code>Lokale_Optima_Multistart.py</code></td>
 <td>Lokale Optima, Multistart</td>
 <td><a href="#kap-qp-nlp">Kapitel 11</a></td>
 </tr>
-<tr class="even">
+<tr class="odd">
 <td><code>Fluch_des_Durchschnitts.py</code></td>
 <td>Optimum ≠ Mittelwert</td>
 <td><a href="#kap-unsicherheit">Kapitel 12</a></td>
 </tr>
-<tr class="odd">
+<tr class="even">
 <td><code>Monte_Carlo.py</code></td>
 <td>Monte-Carlo-Bewertung</td>
 <td><a href="#kap-unsicherheit">Kapitel 12</a></td>
 </tr>
-<tr class="even">
+<tr class="odd">
 <td><code>Stochastische_Optimierung.py</code></td>
 <td>Two-Stage mit Recourse</td>
 <td><a href="#kap-unsicherheit">Kapitel 12</a></td>
 </tr>
-<tr class="odd">
+<tr class="even">
 <td><code>Robuste_Optimierung.py</code></td>
 <td>Worst-Case-Absicherung</td>
 <td><a href="#kap-unsicherheit">Kapitel 12</a></td>
 </tr>
-<tr class="even">
+<tr class="odd">
 <td><code>Chance_Constraints.py</code></td>
 <td>Zusage „mit 95 % Sicherheit“, SOC und Big-M</td>
 <td><a href="#kap-unsicherheit">Kapitel 12</a></td>
 </tr>
-<tr class="odd">
+<tr class="even">
 <td><code>Bellman_Minimalbeispiel.py</code></td>
 <td>Rückwärtsinduktion</td>
 <td><a href="#kap-dynamische-programmierung">Kapitel 13</a></td>
 </tr>
-<tr class="even">
+<tr class="odd">
 <td><code>Mehrziel_Pareto.py</code></td>
 <td>Pareto-Front, ε-Constraint, Gewichtslücke</td>
 <td><a href="#kap-mehrziel">Kapitel 14</a></td>
 </tr>
-<tr class="odd">
+<tr class="even">
 <td><code>Predict_then_Optimize.py</code></td>
 <td>MSE gegen Entscheidungskosten</td>
 <td><a href="#kap-prognose">Kapitel 15</a></td>
 </tr>
-<tr class="even">
+<tr class="odd">
 <td><code>Strukturbruecke.py</code></td>
 <td>Derselbe Code über Werkstatt und Depot</td>
 <td><a href="#kap-bruecke">Kapitel 16</a></td>
 </tr>
-<tr class="odd">
+<tr class="even">
 <td><code>Kraftwerkseinsatz.py</code></td>
 <td>Unit Commitment unter Windunsicherheit</td>
 <td><a href="#kap-supplychain">Kapitel 17</a></td>
 </tr>
-<tr class="even">
+<tr class="odd">
 <td><code>Mehrperiodige_Order_Execution.py</code></td>
 <td>Almgren-Chriss</td>
 <td><a href="#kap-dynamische-programmierung">Kapitel 13</a></td>
 </tr>
-<tr class="odd">
+<tr class="even">
 <td><code>Renditen_Vergleich.py</code></td>
 <td>Diskret vs. logarithmisch</td>
 <td><a href="#kap-finanzdaten">Kapitel 18</a></td>
 </tr>
-<tr class="even">
+<tr class="odd">
 <td><code>Schaetzrauschen_Demo.py</code></td>
 <td>Error-Maximizer messen</td>
 <td><a href="#kap-finanzdaten">Kapitel 18</a></td>
 </tr>
-<tr class="odd">
+<tr class="even">
 <td><code>Finanzdaten_Ledoit_Wolf.py</code></td>
 <td>Datenpipeline, Shrinkage</td>
 <td><a href="#kap-finanzdaten">Kapitel 18</a></td>
 </tr>
-<tr class="even">
+<tr class="odd">
 <td><code>Kovarianz_Falle.py</code></td>
 <td>Singuläre Kovarianz, Error-Maximizer</td>
 <td><a href="#kap-finanzdaten">Kapitel 18</a></td>
 </tr>
-<tr class="odd">
+<tr class="even">
 <td><code>Markowitz_CVXPY.py</code></td>
 <td>GMV, Max Sharpe, Frontier</td>
 <td><a href="#kap-markowitz">Kapitel 19</a></td>
 </tr>
-<tr class="even">
+<tr class="odd">
 <td><code>Diversifikation_Demo.py</code></td>
 <td>Korrelation und Portfoliorisiko</td>
 <td><a href="#kap-markowitz">Kapitel 19</a></td>
 </tr>
-<tr class="odd">
+<tr class="even">
 <td><code>Renditeschaetzung_Falle.py</code></td>
 <td>Schätzfehler in erwarteten Renditen</td>
 <td><a href="#kap-markowitz">Kapitel 19</a></td>
 </tr>
-<tr class="even">
+<tr class="odd">
 <td><code>VaR_CVaR_Demo.py</code></td>
 <td>Fat Tails, Subadditivität</td>
 <td><a href="#kap-cvar">Kapitel 20</a></td>
 </tr>
-<tr class="odd">
+<tr class="even">
 <td><code>CVaR_Portfolio.py</code></td>
 <td>CVaR mit Reibung</td>
 <td><a href="#kap-cvar">Kapitel 20</a></td>
 </tr>
-<tr class="even">
+<tr class="odd">
 <td><code>QuantitativeTradingEngine.py</code></td>
 <td>Walk-Forward-Backtest</td>
 <td><a href="#kap-handelsmaschine">Kapitel 21</a></td>
 </tr>
-<tr class="odd">
+<tr class="even">
 <td><code>Backtest_Fallen.py</code></td>
 <td>Fünf Selbsttäuschungen</td>
 <td><a href="#kap-handelsmaschine">Kapitel 21</a></td>
 </tr>
-<tr class="even">
+<tr class="odd">
 <td><code>Data_Snooping.py</code></td>
 <td>Bestes aus N Versuchen auf Rauschen</td>
 <td><a href="#kap-handelsmaschine">Kapitel 21</a></td>
 </tr>
-<tr class="odd">
+<tr class="even">
 <td><code>Infeasibility_Diagnose.py</code></td>
 <td>Notfallplan statt Fehler</td>
 <td><a href="#kap-praxisfallen">Kapitel 22</a></td>
 </tr>
-<tr class="even">
+<tr class="odd">
 <td><code>Erklaerbarkeit.py</code></td>
 <td>Constraint-Trace, Was-wäre-wenn</td>
 <td><a href="#kap-praxisfallen">Kapitel 22</a></td>
 </tr>
+<tr class="even">
+<td><code>Constraint_Attribution.py</code></td>
+<td>Was kostet welche Bedingung? Managementbericht</td>
+<td><a href="#kap-praxisfallen">Kapitel 22</a></td>
+</tr>
 <tr class="odd">
 <td><code>Betriebsueberwachung.py</code></td>
 <td>Status, Gap und Zeitausschöpfung</td>
@@ -3595,7 +3713,7 @@ g_i(\mathbf{x}) \le b_i \qquad \text{bzw.} \qquad h_j(\mathbf{x}) = 0
 <li><strong>Harte Bedingungen:</strong> <span class="math inline">0{,}5x_1 + 0{,}6x_2 \le 90</span> (Mehl); <span class="math inline">4x_1 + 3x_2 \le 600</span> (Ofen); <span class="math inline">x_1 \ge 40</span> (Vertrag).</li>
 <li><strong>Weiche Bedingungen:</strong> keine.</li>
 </ul>
-<p>Dieses Problem lösen Sie in Übung 1.5 selbst.</p>
+<p>Dieses Problem lösen Sie in der Aufgabe <em>Die Bäckerei programmieren</em> (<a href="#sec:einfuehrung-uebungsaufgaben">Abschnitt 1.9</a>) selbst.</p>
 </blockquote>
 <p>Die Vorlage lässt sich fast wörtlich in Code übersetzen — wer die fünf Zeilen ausgefüllt hat, hat den größten Teil der Modellierungsarbeit schon erledigt:</p>
 <div class="sourceCode" id="cb9"><pre class="sourceCode python"><code class="sourceCode python"><span id="cb9-1"><a href="#cb9-1" aria-hidden="true" tabindex="-1"></a><span class="co">#!/usr/bin/env python3</span></span>
@@ -3976,7 +4094,7 @@ Vorteil der Optimierung:          300.00 EUR pro Tag (15.0 %)
 </blockquote>
 <blockquote>
 <p><strong>📎 Warum dieses Programm alles selbst macht</strong></p>
-<p>Wenige Seiten weiter, in der Excel-Brücke, steht ein Programm, das mit 96 Zeilen auskommt, weil es die immer gleichen Arbeitsschritte aus dem gemeinsamen Modul <code>or_kern.py</code> bezieht (<a href="#sec:praxisfallen-or-kern">Abschnitt 22.5</a>). Warum tut <code>Bot_Allokation.py</code> das nicht auch?</p>
+<p>Wenige Seiten weiter, in der Excel-Brücke, steht ein Programm, das mit 96 Zeilen auskommt, weil es die immer gleichen Arbeitsschritte aus dem gemeinsamen Modul <code>or_kern.py</code> bezieht (<a href="#sec:praxisfallen-or-kern">Abschnitt 22.6</a>). Warum tut <code>Bot_Allokation.py</code> das nicht auch?</p>
 <p>Weil es hier nicht darum geht, <strong>wenig Code</strong> zu schreiben, sondern darum zu sehen, wie ein Modell <strong>entsteht</strong>: Variablen, Nebenbedingungen, Zielfunktion, Status, Prüfung — jeder Schritt einzeln und sichtbar. Eine Abstraktion, die diese Schritte zusammenfasst, ist genau dann ein Gewinn, wenn man sie schon einmal von Hand gegangen ist; vorher versteckt sie nur, was man verstehen will.</p>
 <p>Das ist eine allgemeine Regel für eigene Projekte: <strong>Erst die Wiederholung rechtfertigt die Abstraktion.</strong> Wer sein erstes Modell gleich als Framework baut, hat ein Framework für einen Fall — und die Erfahrung, welche Fälle es tragen müsste, hat er noch nicht gemacht.</p>
 </blockquote>
@@ -4041,7 +4159,7 @@ Vorteil der Optimierung:          300.00 EUR pro Tag (15.0 %)
 <p>Das folgende Programm zeigt den ganzen Weg an einem Stück. Es legt die Eingabemappe beim ersten Start selbst an, damit Sie es sofort ausführen können; danach ersetzen Sie die Datei durch Ihre eigene. Solange die Spalten gleich heißen, ändert sich am Code nichts.</p>
 <blockquote>
 <p><strong>📎 Zum Modul <code>or_kern.py</code></strong></p>
-<p>Die vier Arbeitsschritte — lesen, lösen, prüfen, schreiben — stehen nicht in diesem Programm, sondern in <code>or_kern.py</code>. Das ist ein gemeinsamer Unterbau, den alle Programme dieses Buchs benutzen können; er liegt im selben Verzeichnis und ist in <a href="#sec:praxisfallen-or-kern">Abschnitt 22.5</a> vollständig abgedruckt und erklärt.</p>
+<p>Die vier Arbeitsschritte — lesen, lösen, prüfen, schreiben — stehen nicht in diesem Programm, sondern in <code>or_kern.py</code>. Das ist ein gemeinsamer Unterbau, den alle Programme dieses Buchs benutzen können; er liegt im selben Verzeichnis und ist in <a href="#sec:praxisfallen-or-kern">Abschnitt 22.6</a> vollständig abgedruckt und erklärt.</p>
 <p>Sie müssen ihn jetzt noch nicht verstehen. Wichtig ist nur die Aufteilung: <strong>Hier</strong> steht, was diesen Fall ausmacht — dort steht, was jedes Optimierungsprogramm braucht. Genau deshalb ist der Code unten so kurz.</p>
 </blockquote>
 <div class="sourceCode" id="cb13"><pre class="sourceCode python"><code class="sourceCode python"><span id="cb13-1"><a href="#cb13-1" aria-hidden="true" tabindex="-1"></a><span class="co">#!/usr/bin/env python3</span></span>
@@ -4225,7 +4343,7 @@ Ergebnis geschrieben nach: produktionsmix_ergebnis.xlsx</code></pre>
 <h2 id="sec:einfuehrung-denkfehler">1.10 Finde den Denkfehler</h2>
 <p>Ein Programm, das abstürzt, ist harmlos — Sie sehen sofort, dass etwas nicht stimmt. Gefährlich sind Programme, die fehlerfrei durchlaufen, einen Status <code>OPTIMAL</code> melden und eine Zahl liefern, die betriebswirtschaftlich Unsinn ist. Genau solche Fälle üben wir hier.</p>
 <blockquote>
-<p><strong>🐛 Finde den Denkfehler 1.1: Die Schreinerei verdoppelt ihren Gewinn</strong></p>
+<p><strong>🐛 Finde den Denkfehler: Die Schreinerei verdoppelt ihren Gewinn</strong></p>
 <p>Eine Kollegin hat das Schreinerei-Modell aus dem Kapitelanfang leicht umgebaut — sie fand die Schleife übersichtlicher als zwei einzelne <code>Add</code>-Aufrufe. Das Programm läuft, der Solver meldet <code>OPTIMAL</code>, und der Deckungsbeitrag ist plötzlich <strong>18 600 €</strong> statt 10 800 €. Der Chef ist begeistert. Sollte er das sein?</p>
 <div class="sourceCode" id="cb15"><pre class="sourceCode python"><code class="sourceCode python"><span id="cb15-1"><a href="#cb15-1" aria-hidden="true" tabindex="-1"></a><span class="im">from</span> ortools.linear_solver <span class="im">import</span> pywraplp</span>
 <span id="cb15-2"><a href="#cb15-2" aria-hidden="true" tabindex="-1"></a></span>
@@ -5404,7 +5522,7 @@ und runden Sie Solver-Ergebnisse NIE ohne Toleranzpruefung.
 <hr />
 <h2 id="sec:fundament-denkfehler">2.9 Finde den Denkfehler</h2>
 <blockquote>
-<p><strong>🐛 Finde den Denkfehler 2.1: Die unauffällige Transposition</strong></p>
+<p><strong>🐛 Finde den Denkfehler: Die unauffällige Transposition</strong></p>
 <p>Ein Kollege überträgt ein Produktionsmodell in Matrixform. Zwei Produkte, zwei Ressourcen — die Technologiematrix ist quadratisch:</p>
 <p><span class="math display">\max\ 3x_1 + 5x_2 \quad \text{u. d. N.}\quad \underbrace{\begin{pmatrix} 1 &amp; 2 \\ 3 &amp; 1 \end{pmatrix}}_{\mathbf{A}} \begin{pmatrix} x_1 \\ x_2\end{pmatrix} \le \begin{pmatrix} 8 \\ 12 \end{pmatrix}</span></p>
 <p>Beim Abtippen aus der Tabelle liest er sie spaltenweise statt zeilenweise ein:</p>
@@ -5775,6 +5893,35 @@ Weizen 0.750 kg, Soja 0.250 kg -&gt; 0.5350 EUR/kg</code></pre>
 <p><strong>Abhilfe:</strong> Jeden Solver in einem <strong>eigenen Prozess</strong> ausführen — genau das tut das folgende Programm. Alternativ: getrennte virtuelle Umgebungen, oder auf <code>highspy</code> verzichten und HiGHS über <code>scipy.optimize.linprog</code> bzw. CVXPY ansprechen (dort ist es ohnehin als Backend verfügbar).</p>
 <p>Der Installationstest im Vorspann umgeht die Falle bereits: Er lädt <code>ortools</code> zuerst, prüft <code>highspy</code> und <code>cvxpy</code> in der Paketübersicht nur auf Anwesenheit (<code>importlib.util.find_spec</code>) und importiert CVXPY erst im Funktionstest.</p>
 </blockquote>
+<h3 id="wie-die-isolation-aussieht-wenn-sie-tragen-soll">Wie die Isolation aussieht, wenn sie tragen soll</h3>
+<p>„Eigener Prozess” ist schnell gesagt. Die naheliegende Umsetzung — ein Codeschnipsel als Zeichenkette an <code>python -c</code> übergeben — funktioniert und ist trotzdem die schlechteste: Der Schnipsel ist für Editor, Linter und Testwerkzeug unsichtbar, ein Tippfehler darin fällt erst zur Laufzeit auf, und übergeben lassen sich nur Zeichenketten.</p>
+<p>Tragfähig ist stattdessen: <strong>jeder Solver eine gewöhnliche Funktion mit lokalem Import</strong>, ausgeführt von einem <code>ProcessPoolExecutor</code> mit zwei Einstellungen, die zusammen die Garantie ergeben:</p>
+<table>
+<colgroup>
+<col style="width: 50%" />
+<col style="width: 50%" />
+</colgroup>
+<thead>
+<tr class="header">
+<th>Einstellung</th>
+<th>Wozu</th>
+</tr>
+</thead>
+<tbody>
+<tr class="odd">
+<td><code>mp_context=multiprocessing.get_context("spawn")</code></td>
+<td>Der Kindprozess startet mit einem <strong>frischen</strong> Interpreter, statt den Speicher des Elternprozesses zu erben. Unter Linux ist <code>fork</code> der Standard — und damit wäre alles, was hier schon importiert ist, auch dort importiert.</td>
+</tr>
+<tr class="even">
+<td><code>max_tasks_per_child=1</code></td>
+<td>Jede Aufgabe bekommt einen <strong>neuen</strong> Prozess. Ohne das verwendet der Pool seinen Arbeiter wieder, und beim zweiten Solver ist der Konflikt zurück. Genau dieser Fehler ist leicht zu machen und schwer zu finden.</td>
+</tr>
+</tbody>
+</table>
+<blockquote>
+<p><strong>⚠️ <code>max_tasks_per_child=1</code> ist nicht optional</strong> Ein Pool ohne diese Angabe ist der <strong>Normalfall</strong> — er soll seine Arbeiter ja wiederverwenden. Wer die Isolation über einen Pool herstellt und das vergisst, hat einen Prozesswechsel programmiert, aber keine Isolation gewonnen: Die zweite Aufgabe landet im selben Interpreter wie die erste. Der Absturz kommt dann nicht beim ersten Solver, sondern beim zweiten — und sieht aus wie ein Problem des zweiten.</p>
+</blockquote>
+<p>Denselben Aufbau verwenden <code>Solverwechsel_CPSAT_HiGHS.py</code> (<a href="#kap-praxisfallen">Kapitel 22</a>) und <code>Benchmark_Skalierung.py</code> (<a href="#kap-testing">Kapitel 23</a>). Dort wandern zusätzlich <strong>Datenobjekte</strong> über die Prozessgrenze statt Zeichenketten — möglich, weil Domänenmodell und Lösungs-DTO keinen Solver kennen (<a href="#sec:praxisfallen-or-kern">Abschnitt 22.6</a>).</p>
 <div class="sourceCode" id="cb34"><pre class="sourceCode python"><code class="sourceCode python"><span id="cb34-1"><a href="#cb34-1" aria-hidden="true" tabindex="-1"></a><span class="co">#!/usr/bin/env python3</span></span>
 <span id="cb34-2"><a href="#cb34-2" aria-hidden="true" tabindex="-1"></a></span>
 <span id="cb34-3"><a href="#cb34-3" aria-hidden="true" tabindex="-1"></a><span class="co"># Ein_System_Vier_Ansaetze.py</span></span>
@@ -5785,132 +5932,157 @@ Weizen 0.750 kg, Soja 0.250 kg -&gt; 0.5350 EUR/kg</code></pre>
 <span id="cb34-8"><a href="#cb34-8" aria-hidden="true" tabindex="-1"></a><span class="co">          2*x1 + 3*x2 + x3 &lt;= 50</span></span>
 <span id="cb34-9"><a href="#cb34-9" aria-hidden="true" tabindex="-1"></a><span class="co">          x &gt;= 0</span></span>
 <span id="cb34-10"><a href="#cb34-10" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb34-11"><a href="#cb34-11" aria-hidden="true" tabindex="-1"></a><span class="co">Deckt scipy.optimize, highspy, CVXPY und OR-Tools/GLOP ab, mit Kreuzvergleich am Ende.</span></span>
-<span id="cb34-12"><a href="#cb34-12" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb34-13"><a href="#cb34-13" aria-hidden="true" tabindex="-1"></a><span class="co">WICHTIG: Jeder Solver läuft in einem EIGENEN Prozess, weil sich ortools und</span></span>
-<span id="cb34-14"><a href="#cb34-14" aria-hidden="true" tabindex="-1"></a><span class="co">highspy auf vielen Systemen nicht gemeinsam importieren lassen (beide bringen</span></span>
-<span id="cb34-15"><a href="#cb34-15" aria-hidden="true" tabindex="-1"></a><span class="co">eine eigene HiGHS-Kopie mit -&gt; Symbolkonflikt).</span></span>
-<span id="cb34-16"><a href="#cb34-16" aria-hidden="true" tabindex="-1"></a><span class="co">&quot;&quot;&quot;</span></span>
+<span id="cb34-11"><a href="#cb34-11" aria-hidden="true" tabindex="-1"></a><span class="co">Deckt scipy.optimize, highspy, CVXPY und OR-Tools/GLOP ab, mit Kreuzvergleich</span></span>
+<span id="cb34-12"><a href="#cb34-12" aria-hidden="true" tabindex="-1"></a><span class="co">am Ende.</span></span>
+<span id="cb34-13"><a href="#cb34-13" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb34-14"><a href="#cb34-14" aria-hidden="true" tabindex="-1"></a><span class="co">WICHTIG: Jeder Solver laeuft in einem EIGENEN Prozess, weil sich ortools und</span></span>
+<span id="cb34-15"><a href="#cb34-15" aria-hidden="true" tabindex="-1"></a><span class="co">highspy auf vielen Systemen nicht gemeinsam importieren lassen (beide bringen</span></span>
+<span id="cb34-16"><a href="#cb34-16" aria-hidden="true" tabindex="-1"></a><span class="co">eine eigene HiGHS-Kopie mit -&gt; Symbolkonflikt).</span></span>
 <span id="cb34-17"><a href="#cb34-17" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb34-18"><a href="#cb34-18" aria-hidden="true" tabindex="-1"></a><span class="im">import</span> json</span>
-<span id="cb34-19"><a href="#cb34-19" aria-hidden="true" tabindex="-1"></a><span class="im">import</span> subprocess</span>
-<span id="cb34-20"><a href="#cb34-20" aria-hidden="true" tabindex="-1"></a><span class="im">import</span> sys</span>
-<span id="cb34-21"><a href="#cb34-21" aria-hidden="true" tabindex="-1"></a><span class="im">import</span> textwrap</span>
-<span id="cb34-22"><a href="#cb34-22" aria-hidden="true" tabindex="-1"></a><span class="im">import</span> time</span>
-<span id="cb34-23"><a href="#cb34-23" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb34-24"><a href="#cb34-24" aria-hidden="true" tabindex="-1"></a>ERWARTET <span class="op">=</span> <span class="fl">530.0</span>            <span class="co"># Ergebnis der Handrechnung zum Produktionsprogramm</span></span>
-<span id="cb34-25"><a href="#cb34-25" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb34-26"><a href="#cb34-26" aria-hidden="true" tabindex="-1"></a><span class="co"># Jeder Eintrag ist ein eigenständiges Miniprogramm, das sein Ergebnis als</span></span>
-<span id="cb34-27"><a href="#cb34-27" aria-hidden="true" tabindex="-1"></a><span class="co"># JSON auf stdout ausgibt. So bleibt jeder Import in seinem eigenen Prozess.</span></span>
-<span id="cb34-28"><a href="#cb34-28" aria-hidden="true" tabindex="-1"></a>ANSAETZE: <span class="bu">dict</span>[<span class="bu">str</span>, <span class="bu">str</span>] <span class="op">=</span> {</span>
-<span id="cb34-29"><a href="#cb34-29" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb34-30"><a href="#cb34-30" aria-hidden="true" tabindex="-1"></a>    <span class="st">&quot;scipy.optimize.linprog&quot;</span>: <span class="st">&quot;&quot;&quot;</span></span>
-<span id="cb34-31"><a href="#cb34-31" aria-hidden="true" tabindex="-1"></a><span class="st">        from scipy.optimize import linprog</span></span>
-<span id="cb34-32"><a href="#cb34-32" aria-hidden="true" tabindex="-1"></a><span class="st">        res = linprog(c=[-10.0, -15.0, -25.0],           # linprog MINIMIERT -&gt; negieren</span></span>
-<span id="cb34-33"><a href="#cb34-33" aria-hidden="true" tabindex="-1"></a><span class="st">                      A_ub=[[1, 1, 2], [2, 3, 1]], b_ub=[40, 50],</span></span>
-<span id="cb34-34"><a href="#cb34-34" aria-hidden="true" tabindex="-1"></a><span class="st">                      bounds=[(0, None)] * 3, method=&quot;highs&quot;)</span></span>
-<span id="cb34-35"><a href="#cb34-35" aria-hidden="true" tabindex="-1"></a><span class="st">        ausgabe = (-res.fun, list(res.x))</span></span>
-<span id="cb34-36"><a href="#cb34-36" aria-hidden="true" tabindex="-1"></a><span class="st">    &quot;&quot;&quot;</span>,</span>
+<span id="cb34-18"><a href="#cb34-18" aria-hidden="true" tabindex="-1"></a><span class="co">Die Isolation besorgt ein ProcessPoolExecutor. Drei Einstellungen ergeben</span></span>
+<span id="cb34-19"><a href="#cb34-19" aria-hidden="true" tabindex="-1"></a><span class="co">zusammen die Garantie:</span></span>
+<span id="cb34-20"><a href="#cb34-20" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb34-21"><a href="#cb34-21" aria-hidden="true" tabindex="-1"></a><span class="co">  mp_context &quot;spawn&quot;     Der Kindprozess startet mit einem FRISCHEN</span></span>
+<span id="cb34-22"><a href="#cb34-22" aria-hidden="true" tabindex="-1"></a><span class="co">                         Interpreter, statt den Speicher des Elternprozesses</span></span>
+<span id="cb34-23"><a href="#cb34-23" aria-hidden="true" tabindex="-1"></a><span class="co">                         zu erben. Was hier schon importiert ist, ist dort</span></span>
+<span id="cb34-24"><a href="#cb34-24" aria-hidden="true" tabindex="-1"></a><span class="co">                         nicht importiert. Mit dem Standard &quot;fork&quot; auf Linux</span></span>
+<span id="cb34-25"><a href="#cb34-25" aria-hidden="true" tabindex="-1"></a><span class="co">                         waere das nicht so.</span></span>
+<span id="cb34-26"><a href="#cb34-26" aria-hidden="true" tabindex="-1"></a><span class="co">  max_tasks_per_child=1  Jede Aufgabe bekommt einen NEUEN Prozess. Ohne das</span></span>
+<span id="cb34-27"><a href="#cb34-27" aria-hidden="true" tabindex="-1"></a><span class="co">                         wuerde der Pool seinen Arbeiter wiederverwenden - und</span></span>
+<span id="cb34-28"><a href="#cb34-28" aria-hidden="true" tabindex="-1"></a><span class="co">                         beim zweiten Solver waere der Konflikt zurueck.</span></span>
+<span id="cb34-29"><a href="#cb34-29" aria-hidden="true" tabindex="-1"></a><span class="co">  max_workers=1          Haelt die vier Laeufe nacheinander. Nicht aus</span></span>
+<span id="cb34-30"><a href="#cb34-30" aria-hidden="true" tabindex="-1"></a><span class="co">                         Vorsicht, sondern damit die gemessenen Zeiten</span></span>
+<span id="cb34-31"><a href="#cb34-31" aria-hidden="true" tabindex="-1"></a><span class="co">                         vergleichbar bleiben.</span></span>
+<span id="cb34-32"><a href="#cb34-32" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb34-33"><a href="#cb34-33" aria-hidden="true" tabindex="-1"></a><span class="co">Jeder Solver steht in einer eigenen Funktion mit LOKALEM Import. Das ist der</span></span>
+<span id="cb34-34"><a href="#cb34-34" aria-hidden="true" tabindex="-1"></a><span class="co">Unterschied zu einem Codestring, den man an &#39;python -c&#39; uebergibt: Die</span></span>
+<span id="cb34-35"><a href="#cb34-35" aria-hidden="true" tabindex="-1"></a><span class="co">Funktion laesst sich einzeln aufrufen, testen und vom Editor pruefen - ein</span></span>
+<span id="cb34-36"><a href="#cb34-36" aria-hidden="true" tabindex="-1"></a><span class="co">String nicht.</span></span>
 <span id="cb34-37"><a href="#cb34-37" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb34-38"><a href="#cb34-38" aria-hidden="true" tabindex="-1"></a>    <span class="st">&quot;highspy (natives HiGHS)&quot;</span>: <span class="st">&quot;&quot;&quot;</span></span>
-<span id="cb34-39"><a href="#cb34-39" aria-hidden="true" tabindex="-1"></a><span class="st">        import numpy as np, highspy</span></span>
-<span id="cb34-40"><a href="#cb34-40" aria-hidden="true" tabindex="-1"></a><span class="st">        h = highspy.Highs()</span></span>
-<span id="cb34-41"><a href="#cb34-41" aria-hidden="true" tabindex="-1"></a><span class="st">        h.setOptionValue(&quot;output_flag&quot;, False)</span></span>
-<span id="cb34-42"><a href="#cb34-42" aria-hidden="true" tabindex="-1"></a><span class="st">        h.addVars(3, np.zeros(3), np.full(3, highspy.kHighsInf))</span></span>
-<span id="cb34-43"><a href="#cb34-43" aria-hidden="true" tabindex="-1"></a><span class="st">        h.changeObjectiveSense(highspy.ObjSense.kMaximize)</span></span>
-<span id="cb34-44"><a href="#cb34-44" aria-hidden="true" tabindex="-1"></a><span class="st">        for j, wert in enumerate([10.0, 15.0, 25.0]):</span></span>
-<span id="cb34-45"><a href="#cb34-45" aria-hidden="true" tabindex="-1"></a><span class="st">            h.changeColCost(j, wert)</span></span>
-<span id="cb34-46"><a href="#cb34-46" aria-hidden="true" tabindex="-1"></a><span class="st">        # CSR-Format: starts[i] = Beginn von Zeile i in indices/values</span></span>
-<span id="cb34-47"><a href="#cb34-47" aria-hidden="true" tabindex="-1"></a><span class="st">        h.addRows(2, np.full(2, -highspy.kHighsInf), np.array([40.0, 50.0]), 6,</span></span>
-<span id="cb34-48"><a href="#cb34-48" aria-hidden="true" tabindex="-1"></a><span class="st">                  np.array([0, 3], dtype=np.int32),</span></span>
-<span id="cb34-49"><a href="#cb34-49" aria-hidden="true" tabindex="-1"></a><span class="st">                  np.array([0, 1, 2, 0, 1, 2], dtype=np.int32),</span></span>
-<span id="cb34-50"><a href="#cb34-50" aria-hidden="true" tabindex="-1"></a><span class="st">                  np.array([1.0, 1.0, 2.0, 2.0, 3.0, 1.0]))</span></span>
-<span id="cb34-51"><a href="#cb34-51" aria-hidden="true" tabindex="-1"></a><span class="st">        h.run()</span></span>
-<span id="cb34-52"><a href="#cb34-52" aria-hidden="true" tabindex="-1"></a><span class="st">        ausgabe = (h.getInfo().objective_function_value,</span></span>
-<span id="cb34-53"><a href="#cb34-53" aria-hidden="true" tabindex="-1"></a><span class="st">                   list(h.getSolution().col_value[:3]))</span></span>
-<span id="cb34-54"><a href="#cb34-54" aria-hidden="true" tabindex="-1"></a><span class="st">    &quot;&quot;&quot;</span>,</span>
-<span id="cb34-55"><a href="#cb34-55" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb34-56"><a href="#cb34-56" aria-hidden="true" tabindex="-1"></a>    <span class="st">&quot;cvxpy&quot;</span>: <span class="st">&quot;&quot;&quot;</span></span>
-<span id="cb34-57"><a href="#cb34-57" aria-hidden="true" tabindex="-1"></a><span class="st">        import numpy as np, cvxpy as cp</span></span>
-<span id="cb34-58"><a href="#cb34-58" aria-hidden="true" tabindex="-1"></a><span class="st">        x = cp.Variable(3, nonneg=True)</span></span>
-<span id="cb34-59"><a href="#cb34-59" aria-hidden="true" tabindex="-1"></a><span class="st">        problem = cp.Problem(cp.Maximize(np.array([10.0, 15.0, 25.0]) @ x),</span></span>
-<span id="cb34-60"><a href="#cb34-60" aria-hidden="true" tabindex="-1"></a><span class="st">                             [np.array([[1, 1, 2], [2, 3, 1]]) @ x &lt;= np.array([40, 50])])</span></span>
-<span id="cb34-61"><a href="#cb34-61" aria-hidden="true" tabindex="-1"></a><span class="st">        problem.solve()</span></span>
-<span id="cb34-62"><a href="#cb34-62" aria-hidden="true" tabindex="-1"></a><span class="st">        ausgabe = (float(problem.value), [float(v) for v in x.value])</span></span>
-<span id="cb34-63"><a href="#cb34-63" aria-hidden="true" tabindex="-1"></a><span class="st">    &quot;&quot;&quot;</span>,</span>
-<span id="cb34-64"><a href="#cb34-64" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb34-65"><a href="#cb34-65" aria-hidden="true" tabindex="-1"></a>    <span class="st">&quot;ortools / GLOP&quot;</span>: <span class="st">&quot;&quot;&quot;</span></span>
-<span id="cb34-66"><a href="#cb34-66" aria-hidden="true" tabindex="-1"></a><span class="st">        from ortools.linear_solver import pywraplp</span></span>
-<span id="cb34-67"><a href="#cb34-67" aria-hidden="true" tabindex="-1"></a><span class="st">        s = pywraplp.Solver.CreateSolver(&quot;GLOP&quot;)</span></span>
-<span id="cb34-68"><a href="#cb34-68" aria-hidden="true" tabindex="-1"></a><span class="st">        x = [s.NumVar(0, s.infinity(), f&quot;x{j+1}&quot;) for j in range(3)]</span></span>
-<span id="cb34-69"><a href="#cb34-69" aria-hidden="true" tabindex="-1"></a><span class="st">        A = [[1, 1, 2], [2, 3, 1]]</span></span>
-<span id="cb34-70"><a href="#cb34-70" aria-hidden="true" tabindex="-1"></a><span class="st">        for i, kap in enumerate([40, 50]):</span></span>
-<span id="cb34-71"><a href="#cb34-71" aria-hidden="true" tabindex="-1"></a><span class="st">            s.Add(sum(A[i][j] * x[j] for j in range(3)) &lt;= kap)</span></span>
-<span id="cb34-72"><a href="#cb34-72" aria-hidden="true" tabindex="-1"></a><span class="st">        s.Maximize(10 * x[0] + 15 * x[1] + 25 * x[2])</span></span>
-<span id="cb34-73"><a href="#cb34-73" aria-hidden="true" tabindex="-1"></a><span class="st">        s.Solve()</span></span>
-<span id="cb34-74"><a href="#cb34-74" aria-hidden="true" tabindex="-1"></a><span class="st">        ausgabe = (s.Objective().Value(), [v.solution_value() for v in x])</span></span>
-<span id="cb34-75"><a href="#cb34-75" aria-hidden="true" tabindex="-1"></a><span class="st">    &quot;&quot;&quot;</span>,</span>
-<span id="cb34-76"><a href="#cb34-76" aria-hidden="true" tabindex="-1"></a>}</span>
-<span id="cb34-77"><a href="#cb34-77" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb34-38"><a href="#cb34-38" aria-hidden="true" tabindex="-1"></a><span class="co">Benoetigt: scipy, highspy, cvxpy, ortools</span></span>
+<span id="cb34-39"><a href="#cb34-39" aria-hidden="true" tabindex="-1"></a><span class="co">&quot;&quot;&quot;</span></span>
+<span id="cb34-40"><a href="#cb34-40" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb34-41"><a href="#cb34-41" aria-hidden="true" tabindex="-1"></a><span class="im">import</span> multiprocessing</span>
+<span id="cb34-42"><a href="#cb34-42" aria-hidden="true" tabindex="-1"></a><span class="im">import</span> time</span>
+<span id="cb34-43"><a href="#cb34-43" aria-hidden="true" tabindex="-1"></a><span class="im">from</span> concurrent.futures <span class="im">import</span> ProcessPoolExecutor</span>
+<span id="cb34-44"><a href="#cb34-44" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb34-45"><a href="#cb34-45" aria-hidden="true" tabindex="-1"></a>ERWARTET <span class="op">=</span> <span class="fl">530.0</span>            <span class="co"># Ergebnis der Handrechnung zum Produktionsprogramm</span></span>
+<span id="cb34-46"><a href="#cb34-46" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb34-47"><a href="#cb34-47" aria-hidden="true" tabindex="-1"></a><span class="co"># Die Instanz - einmal notiert, von allen vier Funktionen benutzt.</span></span>
+<span id="cb34-48"><a href="#cb34-48" aria-hidden="true" tabindex="-1"></a>ZIEL <span class="op">=</span> [<span class="fl">10.0</span>, <span class="fl">15.0</span>, <span class="fl">25.0</span>]</span>
+<span id="cb34-49"><a href="#cb34-49" aria-hidden="true" tabindex="-1"></a>MATRIX <span class="op">=</span> [[<span class="dv">1</span>, <span class="dv">1</span>, <span class="dv">2</span>], [<span class="dv">2</span>, <span class="dv">3</span>, <span class="dv">1</span>]]</span>
+<span id="cb34-50"><a href="#cb34-50" aria-hidden="true" tabindex="-1"></a>KAPAZITAET <span class="op">=</span> [<span class="fl">40.0</span>, <span class="fl">50.0</span>]</span>
+<span id="cb34-51"><a href="#cb34-51" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb34-52"><a href="#cb34-52" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb34-53"><a href="#cb34-53" aria-hidden="true" tabindex="-1"></a><span class="kw">def</span> loese_mit_scipy() <span class="op">-&gt;</span> <span class="bu">tuple</span>[<span class="bu">float</span>, <span class="bu">list</span>[<span class="bu">float</span>]]:</span>
+<span id="cb34-54"><a href="#cb34-54" aria-hidden="true" tabindex="-1"></a>    <span class="im">from</span> scipy.optimize <span class="im">import</span> linprog</span>
+<span id="cb34-55"><a href="#cb34-55" aria-hidden="true" tabindex="-1"></a>    ergebnis <span class="op">=</span> linprog(c<span class="op">=</span>[<span class="op">-</span>w <span class="cf">for</span> w <span class="kw">in</span> ZIEL],          <span class="co"># linprog MINIMIERT -&gt; negieren</span></span>
+<span id="cb34-56"><a href="#cb34-56" aria-hidden="true" tabindex="-1"></a>                       A_ub<span class="op">=</span>MATRIX, b_ub<span class="op">=</span>KAPAZITAET,</span>
+<span id="cb34-57"><a href="#cb34-57" aria-hidden="true" tabindex="-1"></a>                       bounds<span class="op">=</span>[(<span class="dv">0</span>, <span class="va">None</span>)] <span class="op">*</span> <span class="dv">3</span>, method<span class="op">=</span><span class="st">&quot;highs&quot;</span>)</span>
+<span id="cb34-58"><a href="#cb34-58" aria-hidden="true" tabindex="-1"></a>    <span class="cf">return</span> <span class="op">-</span>ergebnis.fun, <span class="bu">list</span>(ergebnis.x)</span>
+<span id="cb34-59"><a href="#cb34-59" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb34-60"><a href="#cb34-60" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb34-61"><a href="#cb34-61" aria-hidden="true" tabindex="-1"></a><span class="kw">def</span> loese_mit_highspy() <span class="op">-&gt;</span> <span class="bu">tuple</span>[<span class="bu">float</span>, <span class="bu">list</span>[<span class="bu">float</span>]]:</span>
+<span id="cb34-62"><a href="#cb34-62" aria-hidden="true" tabindex="-1"></a>    <span class="im">import</span> highspy</span>
+<span id="cb34-63"><a href="#cb34-63" aria-hidden="true" tabindex="-1"></a>    <span class="im">import</span> numpy <span class="im">as</span> np</span>
+<span id="cb34-64"><a href="#cb34-64" aria-hidden="true" tabindex="-1"></a>    h <span class="op">=</span> highspy.Highs()</span>
+<span id="cb34-65"><a href="#cb34-65" aria-hidden="true" tabindex="-1"></a>    h.setOptionValue(<span class="st">&quot;output_flag&quot;</span>, <span class="va">False</span>)</span>
+<span id="cb34-66"><a href="#cb34-66" aria-hidden="true" tabindex="-1"></a>    h.addVars(<span class="dv">3</span>, np.zeros(<span class="dv">3</span>), np.full(<span class="dv">3</span>, highspy.kHighsInf))</span>
+<span id="cb34-67"><a href="#cb34-67" aria-hidden="true" tabindex="-1"></a>    h.changeObjectiveSense(highspy.ObjSense.kMaximize)</span>
+<span id="cb34-68"><a href="#cb34-68" aria-hidden="true" tabindex="-1"></a>    <span class="cf">for</span> j, wert <span class="kw">in</span> <span class="bu">enumerate</span>(ZIEL):</span>
+<span id="cb34-69"><a href="#cb34-69" aria-hidden="true" tabindex="-1"></a>        h.changeColCost(j, wert)</span>
+<span id="cb34-70"><a href="#cb34-70" aria-hidden="true" tabindex="-1"></a>    <span class="co"># CSR-Format: starts[i] = Beginn von Zeile i in indices/values</span></span>
+<span id="cb34-71"><a href="#cb34-71" aria-hidden="true" tabindex="-1"></a>    h.addRows(<span class="dv">2</span>, np.full(<span class="dv">2</span>, <span class="op">-</span>highspy.kHighsInf), np.array(KAPAZITAET), <span class="dv">6</span>,</span>
+<span id="cb34-72"><a href="#cb34-72" aria-hidden="true" tabindex="-1"></a>              np.array([<span class="dv">0</span>, <span class="dv">3</span>], dtype<span class="op">=</span>np.int32),</span>
+<span id="cb34-73"><a href="#cb34-73" aria-hidden="true" tabindex="-1"></a>              np.array([<span class="dv">0</span>, <span class="dv">1</span>, <span class="dv">2</span>, <span class="dv">0</span>, <span class="dv">1</span>, <span class="dv">2</span>], dtype<span class="op">=</span>np.int32),</span>
+<span id="cb34-74"><a href="#cb34-74" aria-hidden="true" tabindex="-1"></a>              np.array([<span class="bu">float</span>(w) <span class="cf">for</span> zeile <span class="kw">in</span> MATRIX <span class="cf">for</span> w <span class="kw">in</span> zeile]))</span>
+<span id="cb34-75"><a href="#cb34-75" aria-hidden="true" tabindex="-1"></a>    h.run()</span>
+<span id="cb34-76"><a href="#cb34-76" aria-hidden="true" tabindex="-1"></a>    <span class="cf">return</span> (h.getInfo().objective_function_value,</span>
+<span id="cb34-77"><a href="#cb34-77" aria-hidden="true" tabindex="-1"></a>            <span class="bu">list</span>(h.getSolution().col_value[:<span class="dv">3</span>]))</span>
 <span id="cb34-78"><a href="#cb34-78" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb34-79"><a href="#cb34-79" aria-hidden="true" tabindex="-1"></a><span class="kw">def</span> fuehre_in_eigenem_prozess_aus(quelltext: <span class="bu">str</span>) <span class="op">-&gt;</span> <span class="bu">tuple</span>[<span class="bu">float</span>, <span class="bu">list</span>[<span class="bu">float</span>]]:</span>
-<span id="cb34-80"><a href="#cb34-80" aria-hidden="true" tabindex="-1"></a>    <span class="co">&quot;&quot;&quot;Startet den Codeschnipsel als separaten Python-Prozess und liest das Ergebnis.&quot;&quot;&quot;</span></span>
-<span id="cb34-81"><a href="#cb34-81" aria-hidden="true" tabindex="-1"></a>    programm <span class="op">=</span> textwrap.dedent(quelltext) <span class="op">+</span> <span class="st">&quot;</span><span class="ch">\n</span><span class="st">import json; print(json.dumps(ausgabe))</span><span class="ch">\n</span><span class="st">&quot;</span></span>
-<span id="cb34-82"><a href="#cb34-82" aria-hidden="true" tabindex="-1"></a>    ergebnis <span class="op">=</span> subprocess.run([sys.executable, <span class="st">&quot;-c&quot;</span>, programm],</span>
-<span id="cb34-83"><a href="#cb34-83" aria-hidden="true" tabindex="-1"></a>                              capture_output<span class="op">=</span><span class="va">True</span>, text<span class="op">=</span><span class="va">True</span>, timeout<span class="op">=</span><span class="dv">120</span>)</span>
-<span id="cb34-84"><a href="#cb34-84" aria-hidden="true" tabindex="-1"></a>    <span class="cf">if</span> ergebnis.returncode <span class="op">!=</span> <span class="dv">0</span>:</span>
-<span id="cb34-85"><a href="#cb34-85" aria-hidden="true" tabindex="-1"></a>        <span class="cf">raise</span> <span class="pp">RuntimeError</span>(ergebnis.stderr.strip().splitlines()[<span class="op">-</span><span class="dv">1</span>])</span>
-<span id="cb34-86"><a href="#cb34-86" aria-hidden="true" tabindex="-1"></a>    wert, loesung <span class="op">=</span> json.loads(ergebnis.stdout.strip().splitlines()[<span class="op">-</span><span class="dv">1</span>])</span>
-<span id="cb34-87"><a href="#cb34-87" aria-hidden="true" tabindex="-1"></a>    <span class="cf">return</span> wert, loesung</span>
+<span id="cb34-79"><a href="#cb34-79" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb34-80"><a href="#cb34-80" aria-hidden="true" tabindex="-1"></a><span class="kw">def</span> loese_mit_cvxpy() <span class="op">-&gt;</span> <span class="bu">tuple</span>[<span class="bu">float</span>, <span class="bu">list</span>[<span class="bu">float</span>]]:</span>
+<span id="cb34-81"><a href="#cb34-81" aria-hidden="true" tabindex="-1"></a>    <span class="im">import</span> cvxpy <span class="im">as</span> cp</span>
+<span id="cb34-82"><a href="#cb34-82" aria-hidden="true" tabindex="-1"></a>    <span class="im">import</span> numpy <span class="im">as</span> np</span>
+<span id="cb34-83"><a href="#cb34-83" aria-hidden="true" tabindex="-1"></a>    x <span class="op">=</span> cp.Variable(<span class="dv">3</span>, nonneg<span class="op">=</span><span class="va">True</span>)</span>
+<span id="cb34-84"><a href="#cb34-84" aria-hidden="true" tabindex="-1"></a>    problem <span class="op">=</span> cp.Problem(cp.Maximize(np.array(ZIEL) <span class="op">@</span> x),</span>
+<span id="cb34-85"><a href="#cb34-85" aria-hidden="true" tabindex="-1"></a>                         [np.array(MATRIX) <span class="op">@</span> x <span class="op">&lt;=</span> np.array(KAPAZITAET)])</span>
+<span id="cb34-86"><a href="#cb34-86" aria-hidden="true" tabindex="-1"></a>    problem.solve()</span>
+<span id="cb34-87"><a href="#cb34-87" aria-hidden="true" tabindex="-1"></a>    <span class="cf">return</span> <span class="bu">float</span>(problem.value), [<span class="bu">float</span>(v) <span class="cf">for</span> v <span class="kw">in</span> x.value]</span>
 <span id="cb34-88"><a href="#cb34-88" aria-hidden="true" tabindex="-1"></a></span>
 <span id="cb34-89"><a href="#cb34-89" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb34-90"><a href="#cb34-90" aria-hidden="true" tabindex="-1"></a><span class="cf">if</span> <span class="va">__name__</span> <span class="op">==</span> <span class="st">&quot;__main__&quot;</span>:</span>
-<span id="cb34-91"><a href="#cb34-91" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;=&quot;</span> <span class="op">*</span> <span class="dv">78</span>)</span>
-<span id="cb34-92"><a href="#cb34-92" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;  EIN SYSTEM - VIER ANSAETZE (je eigener Prozess)&quot;</span>)</span>
-<span id="cb34-93"><a href="#cb34-93" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;=&quot;</span> <span class="op">*</span> <span class="dv">78</span>)</span>
-<span id="cb34-94"><a href="#cb34-94" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;</span><span class="sc">{</span><span class="st">&#39;Bibliothek&#39;</span><span class="sc">:&lt;26}</span><span class="ss"> </span><span class="sc">{</span><span class="st">&#39;Z*&#39;</span><span class="sc">:&gt;10}</span><span class="ss"> </span><span class="sc">{</span><span class="st">&#39;x1&#39;</span><span class="sc">:&gt;7}</span><span class="ss"> </span><span class="sc">{</span><span class="st">&#39;x2&#39;</span><span class="sc">:&gt;7}</span><span class="ss"> </span><span class="sc">{</span><span class="st">&#39;x3&#39;</span><span class="sc">:&gt;7}</span><span class="ss"> </span><span class="sc">{</span><span class="st">&#39;Zeit&#39;</span><span class="sc">:&gt;10}</span><span class="ss">&quot;</span>)</span>
-<span id="cb34-95"><a href="#cb34-95" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;-&quot;</span> <span class="op">*</span> <span class="dv">78</span>)</span>
-<span id="cb34-96"><a href="#cb34-96" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb34-97"><a href="#cb34-97" aria-hidden="true" tabindex="-1"></a>    werte <span class="op">=</span> []</span>
-<span id="cb34-98"><a href="#cb34-98" aria-hidden="true" tabindex="-1"></a>    <span class="cf">for</span> name, quelltext <span class="kw">in</span> ANSAETZE.items():</span>
-<span id="cb34-99"><a href="#cb34-99" aria-hidden="true" tabindex="-1"></a>        t0 <span class="op">=</span> time.perf_counter()</span>
-<span id="cb34-100"><a href="#cb34-100" aria-hidden="true" tabindex="-1"></a>        <span class="cf">try</span>:</span>
-<span id="cb34-101"><a href="#cb34-101" aria-hidden="true" tabindex="-1"></a>            wert, x <span class="op">=</span> fuehre_in_eigenem_prozess_aus(quelltext)</span>
-<span id="cb34-102"><a href="#cb34-102" aria-hidden="true" tabindex="-1"></a>        <span class="cf">except</span> <span class="pp">RuntimeError</span> <span class="im">as</span> fehler:</span>
-<span id="cb34-103"><a href="#cb34-103" aria-hidden="true" tabindex="-1"></a>            <span class="bu">print</span>(<span class="ss">f&quot;</span><span class="sc">{</span>name<span class="sc">:&lt;26}</span><span class="ss"> nicht verfuegbar: </span><span class="sc">{</span>fehler[:<span class="dv">40</span>]<span class="sc">}</span><span class="ss">&quot;</span>)</span>
-<span id="cb34-104"><a href="#cb34-104" aria-hidden="true" tabindex="-1"></a>            <span class="cf">continue</span></span>
-<span id="cb34-105"><a href="#cb34-105" aria-hidden="true" tabindex="-1"></a>        dauer <span class="op">=</span> time.perf_counter() <span class="op">-</span> t0</span>
-<span id="cb34-106"><a href="#cb34-106" aria-hidden="true" tabindex="-1"></a>        werte.append(wert)</span>
-<span id="cb34-107"><a href="#cb34-107" aria-hidden="true" tabindex="-1"></a>        <span class="bu">print</span>(<span class="ss">f&quot;</span><span class="sc">{</span>name<span class="sc">:&lt;26}</span><span class="ss"> </span><span class="sc">{</span>wert<span class="sc">:&gt;10.2f}</span><span class="ss"> </span><span class="sc">{</span>x[<span class="dv">0</span>]<span class="sc">:&gt;7.2f}</span><span class="ss"> </span><span class="sc">{</span>x[<span class="dv">1</span>]<span class="sc">:&gt;7.2f}</span><span class="ss"> </span><span class="sc">{</span>x[<span class="dv">2</span>]<span class="sc">:&gt;7.2f}</span><span class="ss"> &quot;</span></span>
-<span id="cb34-108"><a href="#cb34-108" aria-hidden="true" tabindex="-1"></a>              <span class="ss">f&quot;</span><span class="sc">{</span>dauer<span class="sc">:&gt;8.2f}</span><span class="ss"> s&quot;</span>)</span>
-<span id="cb34-109"><a href="#cb34-109" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb34-110"><a href="#cb34-110" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;-&quot;</span> <span class="op">*</span> <span class="dv">78</span>)</span>
-<span id="cb34-111"><a href="#cb34-111" aria-hidden="true" tabindex="-1"></a>    spanne <span class="op">=</span> <span class="bu">max</span>(werte) <span class="op">-</span> <span class="bu">min</span>(werte)</span>
-<span id="cb34-112"><a href="#cb34-112" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;Spannweite zwischen den Bibliotheken: </span><span class="sc">{</span>spanne<span class="sc">:.2e}</span><span class="ss">&quot;</span>)</span>
-<span id="cb34-113"><a href="#cb34-113" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;Abweichung zur Handrechnung (</span><span class="sc">{</span>ERWARTET<span class="sc">:.0f}</span><span class="ss">):        &quot;</span></span>
-<span id="cb34-114"><a href="#cb34-114" aria-hidden="true" tabindex="-1"></a>          <span class="ss">f&quot;</span><span class="sc">{</span><span class="bu">abs</span>(werte[<span class="dv">0</span>] <span class="op">-</span> ERWARTET)<span class="sc">:.2e}</span><span class="ss">&quot;</span>)</span>
-<span id="cb34-115"><a href="#cb34-115" aria-hidden="true" tabindex="-1"></a>    <span class="cf">assert</span> spanne <span class="op">&lt;</span> <span class="fl">1e-6</span>, <span class="st">&quot;Die Bibliotheken widersprechen sich!&quot;</span></span>
-<span id="cb34-116"><a href="#cb34-116" aria-hidden="true" tabindex="-1"></a>    <span class="cf">assert</span> <span class="bu">abs</span>(werte[<span class="dv">0</span>] <span class="op">-</span> ERWARTET) <span class="op">&lt;</span> <span class="fl">1e-6</span>, <span class="st">&quot;Ergebnis weicht von der Handrechnung ab!&quot;</span></span>
-<span id="cb34-117"><a href="#cb34-117" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;Alle Wege fuehren zum selben, von Hand bestaetigten Optimum.&quot;</span>)</span>
-<span id="cb34-118"><a href="#cb34-118" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;(Die Zeiten enthalten den Prozessstart und den Import - sie messen&quot;</span>)</span>
-<span id="cb34-119"><a href="#cb34-119" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot; NICHT die reine Solverleistung, siehe Uebung 3.5.)&quot;</span>)</span>
-<span id="cb34-120"><a href="#cb34-120" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;=&quot;</span> <span class="op">*</span> <span class="dv">78</span>)</span></code></pre></div>
+<span id="cb34-90"><a href="#cb34-90" aria-hidden="true" tabindex="-1"></a><span class="kw">def</span> loese_mit_ortools() <span class="op">-&gt;</span> <span class="bu">tuple</span>[<span class="bu">float</span>, <span class="bu">list</span>[<span class="bu">float</span>]]:</span>
+<span id="cb34-91"><a href="#cb34-91" aria-hidden="true" tabindex="-1"></a>    <span class="im">from</span> ortools.linear_solver <span class="im">import</span> pywraplp</span>
+<span id="cb34-92"><a href="#cb34-92" aria-hidden="true" tabindex="-1"></a>    s <span class="op">=</span> pywraplp.Solver.CreateSolver(<span class="st">&quot;GLOP&quot;</span>)</span>
+<span id="cb34-93"><a href="#cb34-93" aria-hidden="true" tabindex="-1"></a>    x <span class="op">=</span> [s.NumVar(<span class="dv">0</span>, s.infinity(), <span class="ss">f&quot;x</span><span class="sc">{</span>j<span class="op">+</span><span class="dv">1</span><span class="sc">}</span><span class="ss">&quot;</span>) <span class="cf">for</span> j <span class="kw">in</span> <span class="bu">range</span>(<span class="dv">3</span>)]</span>
+<span id="cb34-94"><a href="#cb34-94" aria-hidden="true" tabindex="-1"></a>    <span class="cf">for</span> i, kapazitaet <span class="kw">in</span> <span class="bu">enumerate</span>(KAPAZITAET):</span>
+<span id="cb34-95"><a href="#cb34-95" aria-hidden="true" tabindex="-1"></a>        s.Add(<span class="bu">sum</span>(MATRIX[i][j] <span class="op">*</span> x[j] <span class="cf">for</span> j <span class="kw">in</span> <span class="bu">range</span>(<span class="dv">3</span>)) <span class="op">&lt;=</span> kapazitaet)</span>
+<span id="cb34-96"><a href="#cb34-96" aria-hidden="true" tabindex="-1"></a>    s.Maximize(<span class="bu">sum</span>(ZIEL[j] <span class="op">*</span> x[j] <span class="cf">for</span> j <span class="kw">in</span> <span class="bu">range</span>(<span class="dv">3</span>)))</span>
+<span id="cb34-97"><a href="#cb34-97" aria-hidden="true" tabindex="-1"></a>    s.Solve()</span>
+<span id="cb34-98"><a href="#cb34-98" aria-hidden="true" tabindex="-1"></a>    <span class="cf">return</span> s.Objective().Value(), [v.solution_value() <span class="cf">for</span> v <span class="kw">in</span> x]</span>
+<span id="cb34-99"><a href="#cb34-99" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb34-100"><a href="#cb34-100" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb34-101"><a href="#cb34-101" aria-hidden="true" tabindex="-1"></a>ANSAETZE <span class="op">=</span> {</span>
+<span id="cb34-102"><a href="#cb34-102" aria-hidden="true" tabindex="-1"></a>    <span class="st">&quot;scipy.optimize.linprog&quot;</span>: loese_mit_scipy,</span>
+<span id="cb34-103"><a href="#cb34-103" aria-hidden="true" tabindex="-1"></a>    <span class="st">&quot;highspy (natives HiGHS)&quot;</span>: loese_mit_highspy,</span>
+<span id="cb34-104"><a href="#cb34-104" aria-hidden="true" tabindex="-1"></a>    <span class="st">&quot;cvxpy&quot;</span>: loese_mit_cvxpy,</span>
+<span id="cb34-105"><a href="#cb34-105" aria-hidden="true" tabindex="-1"></a>    <span class="st">&quot;ortools / GLOP&quot;</span>: loese_mit_ortools,</span>
+<span id="cb34-106"><a href="#cb34-106" aria-hidden="true" tabindex="-1"></a>}</span>
+<span id="cb34-107"><a href="#cb34-107" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb34-108"><a href="#cb34-108" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb34-109"><a href="#cb34-109" aria-hidden="true" tabindex="-1"></a><span class="cf">if</span> <span class="va">__name__</span> <span class="op">==</span> <span class="st">&quot;__main__&quot;</span>:</span>
+<span id="cb34-110"><a href="#cb34-110" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;=&quot;</span> <span class="op">*</span> <span class="dv">78</span>)</span>
+<span id="cb34-111"><a href="#cb34-111" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;  EIN SYSTEM - VIER ANSAETZE (je eigener Prozess)&quot;</span>)</span>
+<span id="cb34-112"><a href="#cb34-112" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;=&quot;</span> <span class="op">*</span> <span class="dv">78</span>)</span>
+<span id="cb34-113"><a href="#cb34-113" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;</span><span class="sc">{</span><span class="st">&#39;Bibliothek&#39;</span><span class="sc">:&lt;26}</span><span class="ss"> </span><span class="sc">{</span><span class="st">&#39;Z*&#39;</span><span class="sc">:&gt;10}</span><span class="ss"> </span><span class="sc">{</span><span class="st">&#39;x1&#39;</span><span class="sc">:&gt;7}</span><span class="ss"> </span><span class="sc">{</span><span class="st">&#39;x2&#39;</span><span class="sc">:&gt;7}</span><span class="ss"> </span><span class="sc">{</span><span class="st">&#39;x3&#39;</span><span class="sc">:&gt;7}</span><span class="ss"> </span><span class="sc">{</span><span class="st">&#39;Zeit&#39;</span><span class="sc">:&gt;10}</span><span class="ss">&quot;</span>)</span>
+<span id="cb34-114"><a href="#cb34-114" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;-&quot;</span> <span class="op">*</span> <span class="dv">78</span>)</span>
+<span id="cb34-115"><a href="#cb34-115" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb34-116"><a href="#cb34-116" aria-hidden="true" tabindex="-1"></a>    werte <span class="op">=</span> []</span>
+<span id="cb34-117"><a href="#cb34-117" aria-hidden="true" tabindex="-1"></a>    <span class="co"># Ein Pool, vier Aufgaben, vier frische Prozesse. Der Kontext muss</span></span>
+<span id="cb34-118"><a href="#cb34-118" aria-hidden="true" tabindex="-1"></a>    <span class="co"># &quot;spawn&quot; sein - siehe Modulkommentar.</span></span>
+<span id="cb34-119"><a href="#cb34-119" aria-hidden="true" tabindex="-1"></a>    <span class="cf">with</span> ProcessPoolExecutor(</span>
+<span id="cb34-120"><a href="#cb34-120" aria-hidden="true" tabindex="-1"></a>            max_workers<span class="op">=</span><span class="dv">1</span>,</span>
+<span id="cb34-121"><a href="#cb34-121" aria-hidden="true" tabindex="-1"></a>            mp_context<span class="op">=</span>multiprocessing.get_context(<span class="st">&quot;spawn&quot;</span>),</span>
+<span id="cb34-122"><a href="#cb34-122" aria-hidden="true" tabindex="-1"></a>            max_tasks_per_child<span class="op">=</span><span class="dv">1</span>) <span class="im">as</span> pool:</span>
+<span id="cb34-123"><a href="#cb34-123" aria-hidden="true" tabindex="-1"></a>        <span class="cf">for</span> name, funktion <span class="kw">in</span> ANSAETZE.items():</span>
+<span id="cb34-124"><a href="#cb34-124" aria-hidden="true" tabindex="-1"></a>            beginn <span class="op">=</span> time.perf_counter()</span>
+<span id="cb34-125"><a href="#cb34-125" aria-hidden="true" tabindex="-1"></a>            <span class="cf">try</span>:</span>
+<span id="cb34-126"><a href="#cb34-126" aria-hidden="true" tabindex="-1"></a>                wert, x <span class="op">=</span> pool.submit(funktion).result(timeout<span class="op">=</span><span class="dv">120</span>)</span>
+<span id="cb34-127"><a href="#cb34-127" aria-hidden="true" tabindex="-1"></a>            <span class="cf">except</span> <span class="pp">Exception</span> <span class="im">as</span> fehler:                     <span class="co"># Bibliothek fehlt o. Ae.</span></span>
+<span id="cb34-128"><a href="#cb34-128" aria-hidden="true" tabindex="-1"></a>                <span class="bu">print</span>(<span class="ss">f&quot;</span><span class="sc">{</span>name<span class="sc">:&lt;26}</span><span class="ss"> nicht verfuegbar: </span><span class="sc">{</span><span class="bu">str</span>(fehler)[:<span class="dv">40</span>]<span class="sc">}</span><span class="ss">&quot;</span>)</span>
+<span id="cb34-129"><a href="#cb34-129" aria-hidden="true" tabindex="-1"></a>                <span class="cf">continue</span></span>
+<span id="cb34-130"><a href="#cb34-130" aria-hidden="true" tabindex="-1"></a>            dauer <span class="op">=</span> time.perf_counter() <span class="op">-</span> beginn</span>
+<span id="cb34-131"><a href="#cb34-131" aria-hidden="true" tabindex="-1"></a>            werte.append(wert)</span>
+<span id="cb34-132"><a href="#cb34-132" aria-hidden="true" tabindex="-1"></a>            <span class="bu">print</span>(<span class="ss">f&quot;</span><span class="sc">{</span>name<span class="sc">:&lt;26}</span><span class="ss"> </span><span class="sc">{</span>wert<span class="sc">:&gt;10.2f}</span><span class="ss"> </span><span class="sc">{</span>x[<span class="dv">0</span>]<span class="sc">:&gt;7.2f}</span><span class="ss"> </span><span class="sc">{</span>x[<span class="dv">1</span>]<span class="sc">:&gt;7.2f}</span><span class="ss"> </span><span class="sc">{</span>x[<span class="dv">2</span>]<span class="sc">:&gt;7.2f}</span><span class="ss"> &quot;</span></span>
+<span id="cb34-133"><a href="#cb34-133" aria-hidden="true" tabindex="-1"></a>                  <span class="ss">f&quot;</span><span class="sc">{</span>dauer<span class="sc">:&gt;8.2f}</span><span class="ss"> s&quot;</span>)</span>
+<span id="cb34-134"><a href="#cb34-134" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb34-135"><a href="#cb34-135" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;-&quot;</span> <span class="op">*</span> <span class="dv">78</span>)</span>
+<span id="cb34-136"><a href="#cb34-136" aria-hidden="true" tabindex="-1"></a>    spanne <span class="op">=</span> <span class="bu">max</span>(werte) <span class="op">-</span> <span class="bu">min</span>(werte)</span>
+<span id="cb34-137"><a href="#cb34-137" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;Spannweite zwischen den Bibliotheken: </span><span class="sc">{</span>spanne<span class="sc">:.2e}</span><span class="ss">&quot;</span>)</span>
+<span id="cb34-138"><a href="#cb34-138" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;Abweichung zur Handrechnung (</span><span class="sc">{</span>ERWARTET<span class="sc">:.0f}</span><span class="ss">):        &quot;</span></span>
+<span id="cb34-139"><a href="#cb34-139" aria-hidden="true" tabindex="-1"></a>          <span class="ss">f&quot;</span><span class="sc">{</span><span class="bu">abs</span>(werte[<span class="dv">0</span>] <span class="op">-</span> ERWARTET)<span class="sc">:.2e}</span><span class="ss">&quot;</span>)</span>
+<span id="cb34-140"><a href="#cb34-140" aria-hidden="true" tabindex="-1"></a>    <span class="cf">assert</span> spanne <span class="op">&lt;</span> <span class="fl">1e-6</span>, <span class="st">&quot;Die Bibliotheken widersprechen sich!&quot;</span></span>
+<span id="cb34-141"><a href="#cb34-141" aria-hidden="true" tabindex="-1"></a>    <span class="cf">assert</span> <span class="bu">abs</span>(werte[<span class="dv">0</span>] <span class="op">-</span> ERWARTET) <span class="op">&lt;</span> <span class="fl">1e-6</span>, <span class="st">&quot;Ergebnis weicht von der Handrechnung ab!&quot;</span></span>
+<span id="cb34-142"><a href="#cb34-142" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;Alle Wege fuehren zum selben, von Hand bestaetigten Optimum.&quot;</span>)</span>
+<span id="cb34-143"><a href="#cb34-143" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;(Die Zeiten enthalten Prozessstart und Import - sie messen NICHT die&quot;</span>)</span>
+<span id="cb34-144"><a href="#cb34-144" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot; reine Solverleistung. Die Uebungsaufgabe &#39;Laufzeitvergleich&#39; trennt beides.)&quot;</span>)</span>
+<span id="cb34-145"><a href="#cb34-145" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;=&quot;</span> <span class="op">*</span> <span class="dv">78</span>)</span></code></pre></div>
 <p><strong>Erwartete Ausgabe (Zeiten hardwareabhängig):</strong></p>
 <pre><code>==============================================================================
   EIN SYSTEM - VIER ANSAETZE (je eigener Prozess)
 ==============================================================================
 Bibliothek                         Z*      x1      x2      x3       Zeit
 ------------------------------------------------------------------------------
-scipy.optimize.linprog         530.00    0.00   12.00   14.00     0.55 s
-highspy (natives HiGHS)        530.00    0.00   12.00   14.00     0.17 s
-cvxpy                          530.00    0.00   12.00   14.00     1.52 s
-ortools / GLOP                 530.00    0.00   12.00   14.00     0.09 s
+scipy.optimize.linprog         530.00    0.00   12.00   14.00     0.59 s
+highspy (natives HiGHS)        530.00    0.00   12.00   14.00     0.12 s
+cvxpy                          530.00    0.00   12.00   14.00     1.24 s
+ortools / GLOP                 530.00    0.00   12.00   14.00     0.33 s
 ------------------------------------------------------------------------------
 Spannweite zwischen den Bibliotheken: 2.41e-08
 Abweichung zur Handrechnung (530):        0.00e+00
 Alle Wege fuehren zum selben, von Hand bestaetigten Optimum.
-(Die Zeiten enthalten den Prozessstart und den Import - sie messen
- NICHT die reine Solverleistung, siehe Uebung 3.5.)
+(Die Zeiten enthalten Prozessstart und Import - sie messen NICHT die
+ reine Solverleistung. Die Uebungsaufgabe &#39;Laufzeitvergleich&#39; trennt beides.)
 ==============================================================================</code></pre>
 <blockquote>
 <p><strong>🎯 Merksatz zur Spannweite</strong> Die vier Bibliotheken stimmen <strong>nicht auf die letzte Stelle</strong> überein, sondern nur bis auf <span class="math inline">2{,}4 \times 10^{-8}</span>. Das ist normal: Solver arbeiten mit endlicher Genauigkeit und brechen ab, sobald ihre eigene Toleranz erreicht ist. <strong>Vergleichen Sie Solver-Ergebnisse deshalb nie mit <code>==</code></strong>, sondern immer mit einer Toleranz — <code>abs(a - b) &lt; 1e-6</code> oder <code>np.isclose()</code>. Wer auf exakte Gleichheit prüft, baut sich Tests, die zufällig mal bestehen und mal nicht.</p>
@@ -6694,7 +6866,7 @@ Groesse                    Variante                      Aufbau    Loesen  Aufba
 <hr />
 <h2 id="sec:oekosystem-denkfehler">3.10 Finde den Denkfehler</h2>
 <blockquote>
-<p><strong>🐛 Finde den Denkfehler 3.1: Der Solver, der angeblich dreimal schneller ist</strong></p>
+<p><strong>🐛 Finde den Denkfehler: Der Solver, der angeblich dreimal schneller ist</strong></p>
 <p>Ein Team vergleicht zwei Bibliotheken für sein Zuordnungsproblem und schreibt ins Protokoll: <em>„CVXPY braucht 1,9 s, SciPy nur 0,6 s — wir setzen auf SciPy.“</em> Gemessen wurde so:</p>
 <div class="sourceCode" id="cb42"><pre class="sourceCode python"><code class="sourceCode python"><span id="cb42-1"><a href="#cb42-1" aria-hidden="true" tabindex="-1"></a><span class="im">import</span> time</span>
 <span id="cb42-2"><a href="#cb42-2" aria-hidden="true" tabindex="-1"></a></span>
@@ -6850,6 +7022,7 @@ Deckungsbeitrag maximieren  -&gt; BD     Umsatz  40,000   DB 19,000</code></pre>
 <li>… erkennen, dass ein Satz wie „Stammkunden dürfen wir nicht verlieren” mehrere Lesarten hat, und den Unterschied in Euro beziffern.</li>
 <li>… begründen, wann eine Regel hart und wann sie weich sein muss — und was eine harte Regel im Betrieb anrichtet, wenn sie einmal nicht erfüllbar ist.</li>
 <li>… einen Kennzahlen-Fehlanreiz benennen, bevor er in die Zielfunktion gerät.</li>
+<li>… einen Satz aus einer Besprechung in den passenden Modellierungsbaustein übersetzen — und die fünf Wendungen erkennen, bei denen genau das nicht geht, ohne vorher nachzufragen.</li>
 </ol>
 <hr />
 <h2 id="sec:modellierung-vier-fragen">4.3 Ein Satz ist noch kein Modell</h2>
@@ -7350,7 +7523,7 @@ Drei Dinge, die deshalb vor dem ersten Modell geklaert gehoeren:
 </tbody>
 </table>
 <p>Bei 3 000 € ändert sich <strong>nichts</strong>: Die Strafe liegt unter dem Deckungsbeitrag, den die Stammkundenaufträge verdrängen würden. Bei 10 000 € kommt genau Lesart A heraus.</p>
-<p>Daraus folgt eine Einsicht, die das Modellieren erleichtert: <strong>Eine harte Regel ist eine weiche mit hinreichend großer Strafe.</strong> Man kann also immer weich anfangen und die Strafe hochdrehen, bis die Regel greift — und sieht dabei, was sie kostet. Was ein Strafgewicht darüber hinaus bedeutet und warum zwei Gewichte einen <em>Wechselkurs</em> festlegen und keine Wichtigkeiten, steht in <a href="#sec:cpsat-denkfehler">Abschnitt 7.9</a>.</p>
+<p>Daraus folgt eine Einsicht, die das Modellieren erleichtert: <strong>Eine harte Regel ist eine weiche mit hinreichend großer Strafe.</strong> Man kann also immer weich anfangen und die Strafe hochdrehen, bis die Regel greift — und sieht dabei, was sie kostet. Was ein Strafgewicht darüber hinaus bedeutet und warum zwei Gewichte einen <em>Wechselkurs</em> festlegen und keine Wichtigkeiten, steht in <a href="#sec:cpsat-denkfehler">Abschnitt 7.10</a>.</p>
 <h3 id="teil-4-ein-quartal-später">Teil 4: Ein Quartal später</h3>
 <p>Die harte Lesart A wurde eingebaut, alles lief drei Monate lang. Dann fragt Weber einen Auftrag über 320 Maschinenstunden an — mehr, als der ganze Zeitraum hergibt.</p>
 <pre><code>Lesart A (hart):  UNZULAESSIG - der Nachtlauf bricht ab
@@ -7372,7 +7545,219 @@ Lesart C (weich): loesbar - 66,000 EUR Deckungsbeitrag, 1 Stammauftrag abgelehnt
 <p>Frage 5 ist die wichtigste. Sie verwandelt eine abstrakte Zielangabe in einen konkreten Plan, den man ablehnen kann — und Ablehnung ist die einzige Form von Anforderungsklärung, die zuverlässig funktioniert.</p>
 </blockquote>
 <hr />
-<h2 id="sec:modellierung-uebungsaufgaben">4.6 Übungsaufgaben</h2>
+<h2 id="sec:modellierung-glossar">4.6 Deutsch — OR: ein Übersetzungslexikon</h2>
+<p>Die zwölf Fragen liefern Sätze. Sätze sind noch kein Modell — aber die meisten von ihnen haben eine <strong>Standardübersetzung</strong>, und wer sie kennt, spart sich das Nachdenken für die Fälle, in denen es keine gibt.</p>
+<p>Die Tabelle liest sich von links nach rechts: Was in der Besprechung <strong>gesagt</strong> wird, was es <strong>bedeutet</strong>, und welcher <strong>Baustein</strong> daraus wird. Die B-Nummern verweisen auf <a href="#anhang-modellierungsmuster">Anhang B</a>, wo jedes Muster mit Formulierung und Code steht.</p>
+<table>
+<colgroup>
+<col style="width: 33%" />
+<col style="width: 33%" />
+<col style="width: 33%" />
+</colgroup>
+<thead>
+<tr class="header">
+<th>Was gesagt wird</th>
+<th>Was gemeint ist</th>
+<th>Baustein</th>
+</tr>
+</thead>
+<tbody>
+<tr class="odd">
+<td>„Wir haben nur 400 Stunden.”</td>
+<td>eine Obergrenze, die nicht überschritten werden darf</td>
+<td>harte Kapazitätsgrenze <span class="math inline">\le b</span> (<a href="#kap-lp">Kapitel 5</a>)</td>
+</tr>
+<tr class="even">
+<td>„Mehr als zwei Millionen gibt es nicht.”</td>
+<td>dasselbe, auf Geld</td>
+<td>Budgetlimit (B27)</td>
+</tr>
+<tr class="odd">
+<td>„Möglichst nicht über 40 Stunden.”</td>
+<td>eine Grenze, die im Notfall gebrochen werden darf</td>
+<td>weiche Grenze mit Strafkosten (B8)</td>
+</tr>
+<tr class="even">
+<td>„Wir können nur ganze Kisten liefern.”</td>
+<td>die Menge ist nicht teilbar</td>
+<td>Ganzzahligkeitsbedingung (<a href="#kap-milp">Kapitel 6</a>)</td>
+</tr>
+<tr class="odd">
+<td>„Wenn wir die Anlage nutzen, fallen Fixkosten an.”</td>
+<td>Kosten, die erst ab der ersten Einheit anfallen</td>
+<td>Aktivierungsschalter (B1)</td>
+</tr>
+<tr class="even">
+<td>„Entweder gar nicht oder mindestens 50.”</td>
+<td>kein Betrieb im Kleinen</td>
+<td>semikontinuierliche Variable (B2)</td>
+</tr>
+<tr class="odd">
+<td>„Wenn wir A bauen, brauchen wir auch B.”</td>
+<td>eine Folgeverpflichtung</td>
+<td>Implikation (B3)</td>
+</tr>
+<tr class="even">
+<td>„Höchstens drei Positionen im Depot.”</td>
+<td>eine Obergrenze auf die <strong>Anzahl</strong>, nicht die Menge</td>
+<td>Kardinalität (B6)</td>
+</tr>
+<tr class="odd">
+<td>„Der Anteil muss mindestens 30 % betragen.”</td>
+<td>eine Bedingung auf ein <strong>Verhältnis</strong></td>
+<td>Verhältnis-Bedingung (B12)</td>
+</tr>
+<tr class="even">
+<td>„Jeder Auftrag genau einem Mitarbeiter.”</td>
+<td>eine vollständige, eindeutige Zuordnung</td>
+<td>Zuordnung 1:1 (B23)</td>
+</tr>
+<tr class="odd">
+<td>„Eine Maschine kann nur eines gleichzeitig.”</td>
+<td>zeitliche Ausschließlichkeit</td>
+<td>Nichtüberlappung (B14)</td>
+</tr>
+<tr class="even">
+<td>„B kann erst nach A.”</td>
+<td>eine Reihenfolge</td>
+<td>Vorrangbeziehung (B13)</td>
+</tr>
+<tr class="odd">
+<td>„Höchstens fünf Tage am Stück.”</td>
+<td>eine Bedingung über ein <strong>gleitendes Fenster</strong></td>
+<td>gleitendes Fenster (B16)</td>
+</tr>
+<tr class="even">
+<td>„Umstellen kostet uns eine halbe Stunde.”</td>
+<td>reihenfolgeabhängige Kosten</td>
+<td>Umrüstkosten (B17), Rüstzeit als Kapazität (B26)</td>
+</tr>
+<tr class="odd">
+<td>„Was reinkommt, muss auch wieder raus.”</td>
+<td>Erhaltung an jedem Knoten</td>
+<td>Flusserhaltung (B22)</td>
+</tr>
+<tr class="even">
+<td>„Notfalls brechen wir die Regel.”</td>
+<td>die Bedingung ist weich, aber teuer</td>
+<td>Schlupfvariablen (B18)</td>
+</tr>
+<tr class="odd">
+<td>„Erst Termintreue, dann Kosten.”</td>
+<td>eine Rangfolge zwischen Zielen</td>
+<td>hierarchische Ziele (B19)</td>
+</tr>
+<tr class="even">
+<td>„Es soll gerecht zugehen.”</td>
+<td>den Schlechtestgestellten verbessern</td>
+<td>Min/Max in der Zielfunktion (B11)</td>
+</tr>
+<tr class="odd">
+<td>„Was brächte uns eine zusätzliche Stunde?”</td>
+<td>die Frage nach dem Grenzwert einer Ressource</td>
+<td>Schattenpreis (<a href="#kap-lp">Kapitel 5</a>, <a href="#sec:praxisfallen-attribution">Abschnitt 22.4</a>)</td>
+</tr>
+<tr class="even">
+<td>„Mit 95 % Sicherheit muss es halten.”</td>
+<td>eine Zusage auf eine <strong>Quote</strong>, nicht auf einen Mittelwert</td>
+<td>Chance Constraint (<a href="#sec:unsicherheit-chance-constraints">Abschnitt 12.7</a>)</td>
+</tr>
+<tr class="odd">
+<td>„Wir sichern uns gegen Schätzfehler ab.”</td>
+<td>gegen die ungünstigste Parameterlage planen</td>
+<td>Worst-Case-Abzug (B21)</td>
+</tr>
+</tbody>
+</table>
+<h3 id="fünf-wendungen-bei-denen-die-übersetzung-eine-entscheidung-erzwingt">Fünf Wendungen, bei denen die Übersetzung eine Entscheidung erzwingt</h3>
+<p>Die Tabelle oben tut so, als sei die Zuordnung eindeutig. Bei den folgenden fünf ist sie es nicht — und <strong>das Nachfragen ist die eigentliche Modellierungsarbeit</strong>:</p>
+<table>
+<colgroup>
+<col style="width: 50%" />
+<col style="width: 50%" />
+</colgroup>
+<thead>
+<tr class="header">
+<th>Wendung</th>
+<th>Die Frage, die dahinter steckt</th>
+</tr>
+</thead>
+<tbody>
+<tr class="odd">
+<td><strong>„möglichst”</strong></td>
+<td>Hart oder weich? Und wenn weich: Was darf ein Verstoß kosten? Ohne Zahl ist „möglichst” keine Bedingung, sondern eine Stimmung.</td>
+</tr>
+<tr class="even">
+<td><strong>„nicht mehr als drei pro Woche”</strong></td>
+<td>Je Person oder über alle zusammen? Kalenderwoche oder gleitende sieben Tage? Beide Lesarten sind vertretbar und ergeben verschiedene Modelle.</td>
+</tr>
+<tr class="odd">
+<td><strong>„im Durchschnitt”</strong></td>
+<td>Fast immer eine Falle. Der Durchschnittskunde kauft nie — siehe <a href="#sec:unsicherheit-der-fluch-des-durchschnitts">Abschnitt 12.3</a>. Gemeint ist meist ein Quantil („in 9 von 10 Fällen”).</td>
+</tr>
+<tr class="even">
+<td><strong>„so schnell wie möglich”</strong></td>
+<td>Welche Zahl? Ende des letzten Auftrags, Summe aller Fertigstellungszeiten oder größte Verspätung? Drei Zielfunktionen, drei verschiedene Pläne.</td>
+</tr>
+<tr class="odd">
+<td><strong>„fair”</strong></td>
+<td>Den Schlechtesten verbessern, die Spannweite verkleinern oder gleiche Anteile erzwingen? Erst die Wahl macht daraus ein Modell — und sie gehört dem Betrieb, nicht dem Modellierer.</td>
+</tr>
+</tbody>
+</table>
+<blockquote>
+<p><strong>🎯 Der Nutzen dieser Liste</strong> Sie ersetzt kein Nachdenken. Sie sorgt dafür, dass das Nachdenken an den <strong>richtigen</strong> vier oder fünf Stellen stattfindet, statt an allen zwanzig gleichzeitig.</p>
+</blockquote>
+<h3 id="und-die-gegenrichtung-or-deutsch">Und die Gegenrichtung: OR — Deutsch</h3>
+<p>Dieselbe Barriere gibt es rückwärts. Diese Sätze haben sich bewährt, wenn ein Ergebnis jemandem erklärt werden muss, der das Modell nicht kennt:</p>
+<table>
+<colgroup>
+<col style="width: 50%" />
+<col style="width: 50%" />
+</colgroup>
+<thead>
+<tr class="header">
+<th>Fachbegriff</th>
+<th>Was Sie in der Besprechung sagen</th>
+</tr>
+</thead>
+<tbody>
+<tr class="odd">
+<td>Schattenpreis / Dualwert</td>
+<td>„Die nächste Stunde auf dieser Maschine wäre uns 9 € wert.”</td>
+</tr>
+<tr class="even">
+<td>bindende Bedingung mit Dualwert 0</td>
+<td>„Die Regel berührt den Plan, kostet uns aber nichts — dort zu verhandeln bringt nichts.”</td>
+</tr>
+<tr class="odd">
+<td><code>INFEASIBLE</code></td>
+<td>„Ihre Regeln widersprechen sich.” <strong>Nicht:</strong> „Der Computer schafft es nicht.”</td>
+</tr>
+<tr class="even">
+<td>Optimalitätslücke von 2 %</td>
+<td>„Besser als das hier geht es höchstens um 2 % — und die liegen unter unserer Datenungenauigkeit.”</td>
+</tr>
+<tr class="odd">
+<td>CVaR</td>
+<td>„Wenn es schiefgeht, verlieren wir im Mittel so viel.” (Der VaR sagt nur, <strong>ob</strong> es schiefgeht.)</td>
+</tr>
+<tr class="even">
+<td>EVPI</td>
+<td>„Selbst eine perfekte Prognose wäre uns höchstens so viel wert.”</td>
+</tr>
+<tr class="odd">
+<td>Relaxation</td>
+<td>„Wir haben die Regel probeweise gelockert, um zu sehen, was sie kostet.”</td>
+</tr>
+<tr class="even">
+<td>Chance Constraint</td>
+<td>„Der Plan hält in 95 von 100 Fällen — und der nächste Prozentpunkt kostet …”</td>
+</tr>
+</tbody>
+</table>
+<hr />
+<h2 id="sec:modellierung-uebungsaufgaben">4.7 Übungsaufgaben</h2>
 <blockquote>
 <p>Lösungen: <a href="#sec:loesungen-modellierung">Abschnitt A.4</a>.</p>
 </blockquote>
@@ -7380,9 +7765,10 @@ Lesart C (weich): loesbar - 66,000 EUR Deckungsbeitrag, 1 Stammauftrag abgelehnt
 <p><strong>Aufgabe 4.2 ⭐ — Frage 5 anwenden.</strong> Ein Krankenhaus möchte „die Wartezeiten in der Notaufnahme senken”. Wenden Sie Frage 5 an: Welcher Plan käme heraus, wenn genau die durchschnittliche Wartezeit minimiert würde — und was wäre daran nicht akzeptabel?</p>
 <p><strong>Aufgabe 4.3 ⭐⭐ — Der Kompromiss dazwischen.</strong> Zwischen Lesart A (12 500 €) und Lesart B (3 500 €) liegt Spielraum. Bauen Sie eine Variante, in der jeder Stammkunde <strong>mindestens die Hälfte</strong> seiner Auftragsstunden zugeteilt bekommt. Was kostet sie?</p>
 <p><strong>Aufgabe 4.4 ⭐⭐ — Zwei Ziele gleichzeitig.</strong> Maximieren Sie <span class="math inline">\text{DB} + \lambda \cdot \text{Umsatz}</span> für <span class="math inline">\lambda \in \{0; 0{,}1; 0{,}3; 1\}</span> und tragen Sie die Ergebnisse als Tabelle auf. Ab welchem <span class="math inline">\lambda</span> kippt der Plan von der DB- in die Umsatzlösung? Was sagt dieser Wert dem Betrieb?</p>
-<p><strong>Aufgabe 4.5 ⭐⭐⭐ — Die Anforderung schreiben.</strong> Formulieren Sie für den Fall dieses Kapitels eine vollständige, prüfbare Anforderung: Ziel, harte Regeln, weiche Regeln mit Strafgewichten, Verhalten bei Unlösbarkeit, auszuweisende Kennzahlen. Zwei Seiten genügen — sie sind mehr wert als zwei Wochen Programmierung.</p>
+<p><strong>Aufgabe 4.5 ⭐⭐ — Übersetzen, wo es nicht eindeutig ist.</strong> Übersetzen Sie mit <a href="#sec:modellierung-glossar">Abschnitt 4.6</a>: (a) „Die Monteure sollen möglichst gleichmäßig ausgelastet sein.” Nennen Sie <strong>drei</strong> Zielfunktionen, die alle „gleichmäßig” bedeuten können, und je einen Fall, in dem die Wahl den Plan sichtbar ändert. (b) „Kein Kunde darf länger als drei Tage warten.” Formulieren Sie die Bedingung einmal hart und einmal weich. Welche Frage müssen Sie dem Betrieb stellen, um zu entscheiden? (c) Suchen Sie in einer echten Anforderung aus Ihrem Umfeld einen Satz, der nach der Tabelle eindeutig aussieht, es aber nicht ist.</p>
+<p><strong>Aufgabe 4.6 ⭐⭐⭐ — Die Anforderung schreiben.</strong> Formulieren Sie für den Fall dieses Kapitels eine vollständige, prüfbare Anforderung: Ziel, harte Regeln, weiche Regeln mit Strafgewichten, Verhalten bei Unlösbarkeit, auszuweisende Kennzahlen. Zwei Seiten genügen — sie sind mehr wert als zwei Wochen Programmierung.</p>
 <hr />
-<h2 id="sec:modellierung-denkfehler">4.7 Finde den Denkfehler</h2>
+<h2 id="sec:modellierung-denkfehler">4.8 Finde den Denkfehler</h2>
 <blockquote>
 <p><strong>🐛 „Die Engpassmaschine soll zu mindestens 92 % ausgelastet sein”</strong></p>
 <p>Der Werkleiter formuliert eine klare, messbare, prüfbare Anforderung:</p>
@@ -7394,7 +7780,7 @@ Lesart C (weich): loesbar - 66,000 EUR Deckungsbeitrag, 1 Stammauftrag abgelehnt
 <p>Ein Hinweis für den zweiten: Sehen Sie sich an, was das Modell im Abnahmetest <em>tatsächlich</em> geprüft hat — und rechnen Sie einen Monat durch, in dem weniger Anfragen hereinkommen.</p>
 </blockquote>
 <hr />
-<h2 id="sec:modellierung-quiz">4.8 Micro-Quiz</h2>
+<h2 id="sec:modellierung-quiz">4.9 Micro-Quiz</h2>
 <blockquote>
 <p><strong>❓ Drei Fragen</strong></p>
 <p><strong>1. Warum liefert „Umsatz maximieren” hier einen schlechteren Plan als „Deckungsbeitrag maximieren”, obwohl beide Modelle korrekt sind?</strong> a) Weil der Solver bei Umsatzzielen ungenauer rechnet. b) Weil alles, was nicht in der Zielfunktion steht, für das Modell wertlos ist — nicht weniger wichtig. c) Weil Umsatzdaten in der Praxis unzuverlässiger sind als Kostendaten.</p>
@@ -7402,7 +7788,7 @@ Lesart C (weich): loesbar - 66,000 EUR Deckungsbeitrag, 1 Stammauftrag abgelehnt
 <p><strong>3. Alle drei Zielgrößen erreichen 100 % Auslastung. Was folgt daraus?</strong> a) Die Auslastung war schon vorher optimal, das Projekt ist überflüssig. b) Bei knapper Kapazität ist volle Auslastung die Voreinstellung; zu entscheiden ist nur, <em>womit</em> die Maschine voll wird. c) Die Kapazitätsdaten sind vermutlich falsch erfasst.</p>
 </blockquote>
 <hr />
-<h2 id="sec:modellierung-selbsttest">4.9 Selbsttest</h2>
+<h2 id="sec:modellierung-selbsttest">4.10 Selbsttest</h2>
 <ol type="1">
 <li>Warum ist „Was ist Ihnen wichtig?” eine schlechte Frage und „Welche Zahl steht im Jahresbericht?” eine gute?</li>
 <li>Nennen Sie zwei Kennzahlen aus Ihrem eigenen Arbeitsumfeld, deren Maximierung schaden würde.</li>
@@ -7411,16 +7797,69 @@ Lesart C (weich): loesbar - 66,000 EUR Deckungsbeitrag, 1 Stammauftrag abgelehnt
 <li>Was antworten Sie auf die Frage „Was soll passieren, wenn es keine zulässige Lösung gibt?” — und warum ist „das kommt nicht vor” keine Antwort?</li>
 </ol>
 <hr />
-<h2 id="sec:modellierung-zusammenfassung">4.10 Zusammenfassung</h2>
+<h2 id="sec:modellierung-zusammenfassung">4.11 Zusammenfassung</h2>
 <ul>
 <li>Ein Modell rechnet aus, was <strong>aufgeschrieben</strong> wurde, nicht was gemeint war. Die Zielfunktion ist eine vollständige Aussage: Was nicht darin steht, ist wertlos.</li>
 <li>Die <strong>Zielgröße</strong> ist die folgenreichste Entscheidung eines OR-Projekts. Umsatz, Auslastung und Deckungsbeitrag führten hier auf demselben Datensatz zu drei verschiedenen Plänen mit 24 500 € Unterschied.</li>
 <li><strong>Auslastung ist ein Ergebnis, kein Ziel.</strong> Bei knapper Kapazität ist die Maschine ohnehin voll; entscheidend ist, womit.</li>
 <li>Ein Satz aus einer Besprechung hat meist <strong>mehrere Lesarten</strong>. „Stammkunden nicht verlieren” kostete je nach Lesart 3 500 € oder 12 500 € — bei identischem Ergebnis für die Kunden.</li>
 <li><strong>Hart ist nur, was rechtlich oder physikalisch unmöglich ist.</strong> Eine harte Regel ist eine weiche mit hinreichend großer Strafe; der Unterschied zeigt sich erst, wenn sie einmal nicht erfüllbar ist — dann liefert die harte Variante gar nichts mehr.</li>
+<li><strong>Die meisten Sätze haben eine Standardübersetzung</strong> — das Lexikon in <a href="#sec:modellierung-glossar">Abschnitt 4.6</a> nennt sie. Sein Wert liegt aber in den fünf Wendungen, bei denen es keine gibt: „möglichst”, „nicht mehr als”, „im Durchschnitt”, „so schnell wie möglich”, „fair”. Dort ist Nachfragen die Modellierungsarbeit.</li>
 <li>Die vier Fragen — worüber wird entschieden, woran gemessen, was ist unverhandelbar, was bei Unlösbarkeit — gehören in die erste Besprechung. Der Leitfaden in <a href="#sec:modellierung-leitfaden">Abschnitt 4.5</a> macht zwölf daraus.</li>
 </ul>
 <hr />
+<h1 id="synthese-teil-i-grundlagen-auf-einen-blick">Synthese Teil I — Grundlagen auf einen Blick</h1>
+<p>Vier Kapitel, eine Frage: <strong>Was muss vorliegen, bevor ein Solver überhaupt sinnvoll gestartet werden kann?</strong> Die Antwort ist unbequem, weil das meiste davon nichts mit Programmieren zu tun hat.</p>
+<h2 id="was-welches-kapitel-klärt">Was welches Kapitel klärt</h2>
+<table>
+<colgroup>
+<col style="width: 33%" />
+<col style="width: 33%" />
+<col style="width: 33%" />
+</colgroup>
+<thead>
+<tr class="header">
+<th>Frage</th>
+<th>Kapitel</th>
+<th>Was Sie danach können</th>
+</tr>
+</thead>
+<tbody>
+<tr class="odd">
+<td>Was ist überhaupt ein Optimierungsmodell?</td>
+<td><a href="#kap-einfuehrung">Kapitel 1</a></td>
+<td>Die vier Bausteine benennen — Variablen, Zielfunktion, Nebenbedingungen, Daten — und sie in einem fremden Problem wiedererkennen</td>
+</tr>
+<tr class="even">
+<td>Warum rechnet der Solver falsch, obwohl das Modell stimmt?</td>
+<td><a href="#kap-fundament">Kapitel 2</a></td>
+<td>Konvexität beurteilen, den zulässigen Bereich als Polyeder sehen, schlechte Konditionierung erkennen und beheben</td>
+</tr>
+<tr class="odd">
+<td>Welche Bibliothek, und warum vertragen sie sich nicht?</td>
+<td><a href="#kap-oekosystem">Kapitel 3</a></td>
+<td>Solver, Bindings und Modellierungsschichten unterscheiden — und den HiGHS-Symbolkonflikt zwischen <code>ortools</code> und <code>highspy</code> umgehen</td>
+</tr>
+<tr class="even">
+<td>Wie wird aus einem Satz ein Modell?</td>
+<td><a href="#kap-modellierung">Kapitel 4</a></td>
+<td>Die vier Fragen stellen, harte von weichen Regeln trennen, einen Besprechungssatz übersetzen (<a href="#sec:modellierung-glossar">Abschnitt 4.6</a>)</td>
+</tr>
+</tbody>
+</table>
+<h2 id="die-reihenfolge-ist-die-aussage">Die Reihenfolge ist die Aussage</h2>
+<p>Dieser Teil steht bewusst <strong>vor</strong> den Verfahren. Die drei häufigsten Gründe, aus denen ein OR-Projekt scheitert, liegen alle hier — und keiner davon ist ein Solverproblem:</p>
+<ol type="1">
+<li><strong>Die falsche Zielgröße.</strong> Sie ist die folgenreichste Entscheidung des ganzen Projekts, und sie wird meist in den ersten zehn Minuten nebenbei getroffen. Auslastung ist ein Ergebnis, kein Ziel; „Umsatz” wird gesagt, wenn „Deckungsbeitrag” gemeint ist.</li>
+<li><strong>Zu viele harte Regeln.</strong> Jede unnötig harte Bedingung ist eine Zeitbombe: Irgendwann ist sie nicht erfüllbar, und das System antwortet gar nicht mehr. Hart ist nur, was rechtlich oder physikalisch unmöglich ist.</li>
+<li><strong>Ein Satz, der mehrere Lesarten hat.</strong> „Stammkunden dürfen wir nicht verlieren” lässt sich auf mindestens drei Arten modellieren, und keine ist aus dem Satz ableitbar. Die Wahl trifft man — im Zweifel unbewusst.</li>
+</ol>
+<h2 id="wenn-sie-nur-eines-mitnehmen">Wenn Sie nur eines mitnehmen</h2>
+<blockquote>
+<p><strong>🎯</strong> Ein Modell rechnet aus, was <strong>aufgeschrieben</strong> wurde, nicht was gemeint war. Die Arbeit, die darüber entscheidet, ob am Ende etwas Brauchbares herauskommt, findet vor der ersten Zeile Code statt — und sie besteht aus Fragen an andere Menschen, nicht aus Mathematik.</p>
+</blockquote>
+<p><strong>Vor <a href="#teil-kernverfahren">Teil II</a></strong> sollten Sie an einem eigenen Beispiel die vier Fragen aus <a href="#sec:modellierung-vier-fragen">Abschnitt 4.3</a> durchgespielt haben. Ohne das bleiben die Verfahren Technik ohne Anwendung.</p>
+<hr />
 <h1 id="teil-kernverfahren">Teil II: Die Kernverfahren der deterministischen Optimierung</h1>
 <p>Die nächsten vier Kapitel behandeln Probleme, bei denen <strong>alle Daten bekannt</strong> sind: Kosten, Kapazitäten, Zeiten stehen fest. Das klingt nach einer starken Vereinfachung, deckt aber den größten Teil der betrieblichen Planung ab — und ist die Grundlage für alles Weitere.</p>
 <p>Vier Kapitel, vier Werkzeugkästen. Welcher zu Ihrem Problem passt, entscheiden Sie mit vier Fragen:</p>
@@ -8437,7 +8876,7 @@ Pruefung: komplementaerer Schlupf fuer alle Ressourcen erfuellt.
 </blockquote>
 <blockquote>
 <p><strong>⚠️ Grenzen der Schattenpreis-Aussage</strong></p>
-<p>Der Schattenpreis gilt nur <strong>lokal</strong>, in einem begrenzten Intervall um die aktuelle Kapazität. Kauft man 200 Prüfstunden zu, wird irgendwann eine andere Ressource zum Engpass, und der Schattenpreis springt auf einen neuen Wert (oder auf null). Wer große Kapazitätsänderungen bewerten will, muss das Modell <strong>neu rechnen</strong> — nicht linear hochrechnen. Übung 4.6 macht diesen Effekt sichtbar.</p>
+<p>Der Schattenpreis gilt nur <strong>lokal</strong>, in einem begrenzten Intervall um die aktuelle Kapazität. Kauft man 200 Prüfstunden zu, wird irgendwann eine andere Ressource zum Engpass, und der Schattenpreis springt auf einen neuen Wert (oder auf null). Wer große Kapazitätsänderungen bewerten will, muss das Modell <strong>neu rechnen</strong> — nicht linear hochrechnen. Die Aufgabe <em>Gültigkeitsbereich des Schattenpreises</em> (<a href="#sec:lp-uebungsaufgaben">Abschnitt 5.10</a>) macht diesen Effekt sichtbar.</p>
 </blockquote>
 <hr />
 <h2 id="sec:lp-entartung">5.9 Wann Schattenpreise lügen: Entartung und Toleranzen</h2>
@@ -8845,7 +9284,7 @@ brauchbare Aussage. Ein erfundener Einzelwert ist es nicht.</code></pre>
 <hr />
 <h2 id="sec:lp-denkfehler">5.11 Finde den Denkfehler</h2>
 <blockquote>
-<p><strong>🐛 Finde den Denkfehler 4.1: Die 380 000-Euro-Maschine</strong></p>
+<p><strong>🐛 Finde den Denkfehler: Die 380 000-Euro-Maschine</strong></p>
 <p>Ein Werksleiter lässt die Engpässe seiner Fertigung analysieren. Das Skript liefert für den Lackierofen einen Schattenpreis von <strong>50 €/Stunde</strong>. Er rechnet:</p>
 <blockquote>
 <p><em>„Ein zweiter Lackierofen bringt 2 000 zusätzliche Stunden im Jahr. Bei 50 € &gt; je Stunde sind das 100 000 € Deckungsbeitrag pro Jahr. Die Maschine kostet 380 000 € &gt; und amortisiert sich in 3,8 Jahren. Wir kaufen.“</em></p>
@@ -8867,7 +9306,7 @@ brauchbare Aussage. Ein erfundener Einzelwert ist es nicht.</code></pre>
 <hr />
 <h2 id="sec:lp-quiz">5.12 Micro-Quiz</h2>
 <blockquote>
-<p><strong>❓ Micro-Quiz 4: Drei Fragen zum Selbstcheck</strong></p>
+<p><strong>❓ Micro-Quiz 5: Drei Fragen zum Selbstcheck</strong></p>
 <p>Genau eine Antwort ist jeweils richtig. Auflösung in <a href="#quiz-loesung-lp">Anhang A</a>.</p>
 <p><strong>1. Eine Nebenbedingung hat den Schlupf <span class="math inline">s_i = 12</span> und den Schattenpreis <span class="math inline">y_i = 0</span>. Was folgt daraus?</strong> (a) Der Solver hat einen Fehler gemacht — bei positivem Schlupf muss der Dualwert ebenfalls positiv sein. (b) Von dieser Ressource sind 12 Einheiten übrig; sie ist kein Engpass, und Zukauf bringt nichts. Das ist genau der komplementäre Schlupf. (c) Die Ressource ist voll ausgelastet, wird aber nicht benötigt.</p>
 <p><strong>2. Ihr Modell hat 5 Variablen. In der optimalen Ecke sind 7 Nebenbedingungen aktiv. Was bedeutet das für Ihren Bericht ans Management?</strong> (a) Nichts Besonderes — mehr aktive Bedingungen heißt nur, dass das Modell gut ausgelastet ist. (b) Das Modell ist entartet: Der Plan ist eindeutig, die Schattenpreise sind es nicht. Statt Einzelwerten gehören Spannen in den Bericht. (c) Das Modell ist unlösbar, weil mehr Bedingungen als Variablen aktiv sind.</p>
@@ -9385,7 +9824,7 @@ L\,y_i \le x_i &amp;\le U\,y_i &amp;&amp; \forall i \quad \text{(semikontinuierl
 </blockquote>
 <blockquote>
 <p><strong>📎 Zwei Bausteine aus <code>or_kern.py</code></strong></p>
-<p>Das Programm wertet den Solver nicht über <code>ergebnis.success</code> aus, sondern über <code>status_von_scipy()</code> und das <code>Loesung</code>-Objekt aus dem gemeinsamen Unterbau (<a href="#sec:praxisfallen-or-kern">Abschnitt 22.5</a>). Der Unterschied ist kein Schönheitsfehler:</p>
+<p>Das Programm wertet den Solver nicht über <code>ergebnis.success</code> aus, sondern über <code>status_von_scipy()</code> und das <code>Loesung</code>-Objekt aus dem gemeinsamen Unterbau (<a href="#sec:praxisfallen-or-kern">Abschnitt 22.6</a>). Der Unterschied ist kein Schönheitsfehler:</p>
 <ul>
 <li><code>success</code> ist <strong>ein Bit</strong>. Es unterscheidet nicht zwischen „es gibt keine Lösung“ (Modellfehler — das Modell muss geändert werden) und „die Zeit war um“ (Rechenproblem — mehr Zeit oder ein besserer Startwert hilft). Das sind zwei völlig verschiedene Nachrichten an völlig verschiedene Adressaten.</li>
 <li>Das <code>Loesung</code>-Objekt führt neben dem Zielwert die <strong>Schranke</strong> mit und rechnet daraus den Gap aus. Erst dadurch steht in der Ausgabe <code>Gap: 0.00%</code> — die Zusage, dass hier wirklich das Optimum gefunden <em>und bewiesen</em> wurde und nicht bloß irgendetwas.</li>
@@ -9656,7 +10095,7 @@ Abnahmepruefung: alle Nebenbedingungen geprueft und eingehalten.
 </tr>
 <tr class="even">
 <td><code>status = status_von_scipy(ergebnis)</code></td>
-<td>übersetzt den SciPy-Rückgabewert in die gemeinsame Sprache aus <a href="#sec:praxisfallen-or-kern">Abschnitt 22.5</a> — die drei <code>if</code>-Zweige darunter behandeln Modellfehler, Abbruch ohne Lösung und „zulässig, aber unbewiesen“ getrennt</td>
+<td>übersetzt den SciPy-Rückgabewert in die gemeinsame Sprache aus <a href="#sec:praxisfallen-or-kern">Abschnitt 22.6</a> — die drei <code>if</code>-Zweige darunter behandeln Modellfehler, Abbruch ohne Lösung und „zulässig, aber unbewiesen“ getrennt</td>
 </tr>
 <tr class="odd">
 <td><code>schranke=-ergebnis.mip_dual_bound</code></td>
@@ -10133,68 +10572,69 @@ mit Warm-Start                 8.44s       150     69,134.14</code></pre>
 <span id="cb71-83"><a href="#cb71-83" aria-hidden="true" tabindex="-1"></a></span>
 <span id="cb71-84"><a href="#cb71-84" aria-hidden="true" tabindex="-1"></a>    loeser <span class="op">=</span> cp_model.CpSolver()</span>
 <span id="cb71-85"><a href="#cb71-85" aria-hidden="true" tabindex="-1"></a>    loeser.parameters.max_time_in_seconds <span class="op">=</span> zeitlimit</span>
-<span id="cb71-86"><a href="#cb71-86" aria-hidden="true" tabindex="-1"></a>    <span class="co"># Ein Arbeiter und fester Startwert, damit die Messung reproduzierbar ist.</span></span>
-<span id="cb71-87"><a href="#cb71-87" aria-hidden="true" tabindex="-1"></a>    <span class="co"># Im Produktivbetrieb laesst man beides auf den Standardwerten.</span></span>
-<span id="cb71-88"><a href="#cb71-88" aria-hidden="true" tabindex="-1"></a>    loeser.parameters.num_workers <span class="op">=</span> <span class="dv">1</span></span>
-<span id="cb71-89"><a href="#cb71-89" aria-hidden="true" tabindex="-1"></a>    loeser.parameters.random_seed <span class="op">=</span> <span class="dv">1</span></span>
-<span id="cb71-90"><a href="#cb71-90" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb71-91"><a href="#cb71-91" aria-hidden="true" tabindex="-1"></a>    t0 <span class="op">=</span> time.perf_counter()</span>
-<span id="cb71-92"><a href="#cb71-92" aria-hidden="true" tabindex="-1"></a>    status <span class="op">=</span> loeser.Solve(modell)</span>
-<span id="cb71-93"><a href="#cb71-93" aria-hidden="true" tabindex="-1"></a>    dauer_s <span class="op">=</span> time.perf_counter() <span class="op">-</span> t0</span>
-<span id="cb71-94"><a href="#cb71-94" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb71-95"><a href="#cb71-95" aria-hidden="true" tabindex="-1"></a>    <span class="cf">if</span> status <span class="kw">not</span> <span class="kw">in</span> (cp_model.OPTIMAL, cp_model.FEASIBLE):</span>
-<span id="cb71-96"><a href="#cb71-96" aria-hidden="true" tabindex="-1"></a>        <span class="cf">raise</span> <span class="pp">RuntimeError</span>(<span class="ss">f&quot;Kein Plan gefunden: </span><span class="sc">{</span>loeser<span class="sc">.</span>StatusName(status)<span class="sc">}</span><span class="ss">&quot;</span>)</span>
-<span id="cb71-97"><a href="#cb71-97" aria-hidden="true" tabindex="-1"></a>    <span class="cf">return</span> loeser.StatusName(status), <span class="bu">int</span>(loeser.ObjectiveValue()), dauer_s</span>
-<span id="cb71-98"><a href="#cb71-98" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb71-86"><a href="#cb71-86" aria-hidden="true" tabindex="-1"></a>    <span class="co"># Ein Arbeiter und fester Startwert, damit die Messung reproduzierbar ist -</span></span>
+<span id="cb71-87"><a href="#cb71-87" aria-hidden="true" tabindex="-1"></a>    <span class="co"># der Seed allein genuegt dafuer NICHT (Kapitel Constraint Programming).</span></span>
+<span id="cb71-88"><a href="#cb71-88" aria-hidden="true" tabindex="-1"></a>    <span class="co"># Im Produktivbetrieb laesst man beides auf den Standardwerten.</span></span>
+<span id="cb71-89"><a href="#cb71-89" aria-hidden="true" tabindex="-1"></a>    loeser.parameters.num_workers <span class="op">=</span> <span class="dv">1</span></span>
+<span id="cb71-90"><a href="#cb71-90" aria-hidden="true" tabindex="-1"></a>    loeser.parameters.random_seed <span class="op">=</span> <span class="dv">1</span></span>
+<span id="cb71-91"><a href="#cb71-91" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb71-92"><a href="#cb71-92" aria-hidden="true" tabindex="-1"></a>    t0 <span class="op">=</span> time.perf_counter()</span>
+<span id="cb71-93"><a href="#cb71-93" aria-hidden="true" tabindex="-1"></a>    status <span class="op">=</span> loeser.Solve(modell)</span>
+<span id="cb71-94"><a href="#cb71-94" aria-hidden="true" tabindex="-1"></a>    dauer_s <span class="op">=</span> time.perf_counter() <span class="op">-</span> t0</span>
+<span id="cb71-95"><a href="#cb71-95" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb71-96"><a href="#cb71-96" aria-hidden="true" tabindex="-1"></a>    <span class="cf">if</span> status <span class="kw">not</span> <span class="kw">in</span> (cp_model.OPTIMAL, cp_model.FEASIBLE):</span>
+<span id="cb71-97"><a href="#cb71-97" aria-hidden="true" tabindex="-1"></a>        <span class="cf">raise</span> <span class="pp">RuntimeError</span>(<span class="ss">f&quot;Kein Plan gefunden: </span><span class="sc">{</span>loeser<span class="sc">.</span>StatusName(status)<span class="sc">}</span><span class="ss">&quot;</span>)</span>
+<span id="cb71-98"><a href="#cb71-98" aria-hidden="true" tabindex="-1"></a>    <span class="cf">return</span> loeser.StatusName(status), <span class="bu">int</span>(loeser.ObjectiveValue()), dauer_s</span>
 <span id="cb71-99"><a href="#cb71-99" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb71-100"><a href="#cb71-100" aria-hidden="true" tabindex="-1"></a><span class="cf">if</span> <span class="va">__name__</span> <span class="op">==</span> <span class="st">&quot;__main__&quot;</span>:</span>
-<span id="cb71-101"><a href="#cb71-101" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;=&quot;</span> <span class="op">*</span> <span class="dv">78</span>)</span>
-<span id="cb71-102"><a href="#cb71-102" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;  WARM-START: WENN DIE HEURISTIK MEHR WEISS ALS DER SOLVER&quot;</span>)</span>
-<span id="cb71-103"><a href="#cb71-103" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;=&quot;</span> <span class="op">*</span> <span class="dv">78</span>)</span>
-<span id="cb71-104"><a href="#cb71-104" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;Lastverteilung: Auftraege auf gleichartige Maschinen verteilen,&quot;</span>)</span>
-<span id="cb71-105"><a href="#cb71-105" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;sodass die letzte Maschine so frueh wie moeglich fertig wird.</span><span class="ch">\n</span><span class="st">&quot;</span>)</span>
-<span id="cb71-106"><a href="#cb71-106" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb71-107"><a href="#cb71-107" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;</span><span class="sc">{</span><span class="st">&#39;Instanz&#39;</span><span class="sc">:&lt;22}</span><span class="ss"> </span><span class="sc">{</span><span class="st">&#39;Variante&#39;</span><span class="sc">:&lt;22}</span><span class="ss"> </span><span class="sc">{</span><span class="st">&#39;Makespan&#39;</span><span class="sc">:&gt;9}</span><span class="ss"> </span><span class="sc">{</span><span class="st">&#39;Zeit&#39;</span><span class="sc">:&gt;9}</span><span class="ss"> &quot;</span></span>
-<span id="cb71-108"><a href="#cb71-108" aria-hidden="true" tabindex="-1"></a>          <span class="ss">f&quot;</span><span class="sc">{</span><span class="st">&#39;Faktor&#39;</span><span class="sc">:&gt;8}</span><span class="ss">&quot;</span>)</span>
-<span id="cb71-109"><a href="#cb71-109" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;-&quot;</span> <span class="op">*</span> <span class="dv">78</span>)</span>
-<span id="cb71-110"><a href="#cb71-110" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb71-111"><a href="#cb71-111" aria-hidden="true" tabindex="-1"></a>    <span class="cf">for</span> n_auftraege, n_maschinen <span class="kw">in</span> [(<span class="dv">60</span>, <span class="dv">7</span>), (<span class="dv">80</span>, <span class="dv">9</span>)]:</span>
-<span id="cb71-112"><a href="#cb71-112" aria-hidden="true" tabindex="-1"></a>        dauer <span class="op">=</span> RNG.integers(<span class="dv">10</span>, <span class="dv">90</span>, n_auftraege)</span>
-<span id="cb71-113"><a href="#cb71-113" aria-hidden="true" tabindex="-1"></a>        start, lpt_wert <span class="op">=</span> lpt_heuristik(dauer, n_maschinen)</span>
-<span id="cb71-114"><a href="#cb71-114" aria-hidden="true" tabindex="-1"></a>        untere_schranke <span class="op">=</span> dauer.<span class="bu">sum</span>() <span class="op">/</span> n_maschinen</span>
-<span id="cb71-115"><a href="#cb71-115" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb71-116"><a href="#cb71-116" aria-hidden="true" tabindex="-1"></a>        instanz <span class="op">=</span> <span class="ss">f&quot;</span><span class="sc">{</span>n_auftraege<span class="sc">}</span><span class="ss"> Auftr., </span><span class="sc">{</span>n_maschinen<span class="sc">}</span><span class="ss"> Masch.&quot;</span></span>
-<span id="cb71-117"><a href="#cb71-117" aria-hidden="true" tabindex="-1"></a>        <span class="bu">print</span>(<span class="ss">f&quot;</span><span class="sc">{</span>instanz<span class="sc">:&lt;22}</span><span class="ss"> </span><span class="sc">{</span><span class="st">&#39;LPT-Heuristik&#39;</span><span class="sc">:&lt;22}</span><span class="ss"> </span><span class="sc">{</span>lpt_wert<span class="sc">:&gt;9}</span><span class="ss"> &quot;</span></span>
-<span id="cb71-118"><a href="#cb71-118" aria-hidden="true" tabindex="-1"></a>              <span class="ss">f&quot;</span><span class="sc">{</span><span class="st">&#39;&lt; 0.001s&#39;</span><span class="sc">:&gt;9}</span><span class="ss"> </span><span class="sc">{</span><span class="st">&#39;&#39;</span><span class="sc">:&gt;8}</span><span class="ss">&quot;</span>)</span>
-<span id="cb71-119"><a href="#cb71-119" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb71-120"><a href="#cb71-120" aria-hidden="true" tabindex="-1"></a>        _, ziel_kalt, zeit_kalt <span class="op">=</span> loese(dauer, n_maschinen, <span class="fl">60.0</span>)</span>
-<span id="cb71-121"><a href="#cb71-121" aria-hidden="true" tabindex="-1"></a>        <span class="bu">print</span>(<span class="ss">f&quot;</span><span class="sc">{</span><span class="st">&#39;&#39;</span><span class="sc">:&lt;22}</span><span class="ss"> </span><span class="sc">{</span><span class="st">&#39;CP-SAT kalt&#39;</span><span class="sc">:&lt;22}</span><span class="ss"> </span><span class="sc">{</span>ziel_kalt<span class="sc">:&gt;9}</span><span class="ss"> &quot;</span></span>
-<span id="cb71-122"><a href="#cb71-122" aria-hidden="true" tabindex="-1"></a>              <span class="ss">f&quot;</span><span class="sc">{</span>zeit_kalt<span class="sc">:&gt;8.3f}</span><span class="ss">s </span><span class="sc">{</span><span class="st">&#39;1,0x&#39;</span><span class="sc">:&gt;8}</span><span class="ss">&quot;</span>)</span>
-<span id="cb71-123"><a href="#cb71-123" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb71-124"><a href="#cb71-124" aria-hidden="true" tabindex="-1"></a>        _, ziel_warm, zeit_warm <span class="op">=</span> loese(dauer, n_maschinen, <span class="fl">60.0</span>, hinweis<span class="op">=</span>start)</span>
-<span id="cb71-125"><a href="#cb71-125" aria-hidden="true" tabindex="-1"></a>        <span class="bu">print</span>(<span class="ss">f&quot;</span><span class="sc">{</span><span class="st">&#39;&#39;</span><span class="sc">:&lt;22}</span><span class="ss"> </span><span class="sc">{</span><span class="st">&#39;CP-SAT + LPT-Hinweis&#39;</span><span class="sc">:&lt;22}</span><span class="ss"> </span><span class="sc">{</span>ziel_warm<span class="sc">:&gt;9}</span><span class="ss"> &quot;</span></span>
-<span id="cb71-126"><a href="#cb71-126" aria-hidden="true" tabindex="-1"></a>              <span class="ss">f&quot;</span><span class="sc">{</span>zeit_warm<span class="sc">:&gt;8.3f}</span><span class="ss">s </span><span class="sc">{</span>zeit_kalt <span class="op">/</span> zeit_warm<span class="sc">:&gt;7.1f}</span><span class="ss">x&quot;</span>)</span>
-<span id="cb71-127"><a href="#cb71-127" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb71-128"><a href="#cb71-128" aria-hidden="true" tabindex="-1"></a>        <span class="cf">assert</span> ziel_kalt <span class="op">==</span> ziel_warm, <span class="op">\</span></span>
-<span id="cb71-129"><a href="#cb71-129" aria-hidden="true" tabindex="-1"></a>            <span class="st">&quot;Der Hinweis darf das Optimum nicht veraendern - nur den Weg dorthin!&quot;</span></span>
-<span id="cb71-130"><a href="#cb71-130" aria-hidden="true" tabindex="-1"></a>        <span class="bu">print</span>(<span class="ss">f&quot;</span><span class="sc">{</span><span class="st">&#39;&#39;</span><span class="sc">:&lt;22}</span><span class="ss"> </span><span class="sc">{</span><span class="st">&#39;untere Schranke&#39;</span><span class="sc">:&lt;22}</span><span class="ss"> </span><span class="sc">{</span>untere_schranke<span class="sc">:&gt;9.1f}</span><span class="ss">&quot;</span>)</span>
-<span id="cb71-131"><a href="#cb71-131" aria-hidden="true" tabindex="-1"></a>        <span class="bu">print</span>(<span class="st">&quot;-&quot;</span> <span class="op">*</span> <span class="dv">78</span>)</span>
-<span id="cb71-132"><a href="#cb71-132" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb71-133"><a href="#cb71-133" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;</span><span class="ch">\n</span><span class="st">Drei Beobachtungen:&quot;</span>)</span>
-<span id="cb71-134"><a href="#cb71-134" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;1. Der Hinweis aendert das ERGEBNIS nicht - beide Laeufe finden&quot;</span>)</span>
-<span id="cb71-135"><a href="#cb71-135" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;   dasselbe Optimum. Er aendert nur, wie lange der Beweis dauert.&quot;</span>)</span>
-<span id="cb71-136"><a href="#cb71-136" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;   Genau deshalb ist ein Warm-Start ungefaehrlich: Ein schlechter&quot;</span>)</span>
-<span id="cb71-137"><a href="#cb71-137" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;   Hinweis kostet Zeit, er verfaelscht aber nie die Loesung.&quot;</span>)</span>
-<span id="cb71-138"><a href="#cb71-138" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;2. Die LPT-Heuristik liegt schon sehr nah am Optimum. Ihr Wert fuer&quot;</span>)</span>
-<span id="cb71-139"><a href="#cb71-139" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;   den Solver liegt weniger in der Qualitaet als darin, dass sie&quot;</span>)</span>
-<span id="cb71-140"><a href="#cb71-140" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;   SOFORT da ist - der Solver kann von Beginn an alles verwerfen,&quot;</span>)</span>
-<span id="cb71-141"><a href="#cb71-141" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;   was schlechter ist.&quot;</span>)</span>
-<span id="cb71-142"><a href="#cb71-142" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;3. Der Faktor schwankt von Instanz zu Instanz - oben 2,2x und 1,4x -&quot;</span>)</span>
-<span id="cb71-143"><a href="#cb71-143" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;   und laesst sich NICHT aus der Problemgroesse ableiten. Er haengt&quot;</span>)</span>
-<span id="cb71-144"><a href="#cb71-144" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;   davon ab, wie schnell der Solver von allein eine vergleichbar gute&quot;</span>)</span>
-<span id="cb71-145"><a href="#cb71-145" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;   Loesung findet. Das ist die eigentliche Lehre: Ein Warm-Start ist&quot;</span>)</span>
-<span id="cb71-146"><a href="#cb71-146" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;   eine Messung wert, keine Glaubensfrage.&quot;</span>)</span>
-<span id="cb71-147"><a href="#cb71-147" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;=&quot;</span> <span class="op">*</span> <span class="dv">78</span>)</span></code></pre></div>
+<span id="cb71-100"><a href="#cb71-100" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb71-101"><a href="#cb71-101" aria-hidden="true" tabindex="-1"></a><span class="cf">if</span> <span class="va">__name__</span> <span class="op">==</span> <span class="st">&quot;__main__&quot;</span>:</span>
+<span id="cb71-102"><a href="#cb71-102" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;=&quot;</span> <span class="op">*</span> <span class="dv">78</span>)</span>
+<span id="cb71-103"><a href="#cb71-103" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;  WARM-START: WENN DIE HEURISTIK MEHR WEISS ALS DER SOLVER&quot;</span>)</span>
+<span id="cb71-104"><a href="#cb71-104" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;=&quot;</span> <span class="op">*</span> <span class="dv">78</span>)</span>
+<span id="cb71-105"><a href="#cb71-105" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;Lastverteilung: Auftraege auf gleichartige Maschinen verteilen,&quot;</span>)</span>
+<span id="cb71-106"><a href="#cb71-106" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;sodass die letzte Maschine so frueh wie moeglich fertig wird.</span><span class="ch">\n</span><span class="st">&quot;</span>)</span>
+<span id="cb71-107"><a href="#cb71-107" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb71-108"><a href="#cb71-108" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;</span><span class="sc">{</span><span class="st">&#39;Instanz&#39;</span><span class="sc">:&lt;22}</span><span class="ss"> </span><span class="sc">{</span><span class="st">&#39;Variante&#39;</span><span class="sc">:&lt;22}</span><span class="ss"> </span><span class="sc">{</span><span class="st">&#39;Makespan&#39;</span><span class="sc">:&gt;9}</span><span class="ss"> </span><span class="sc">{</span><span class="st">&#39;Zeit&#39;</span><span class="sc">:&gt;9}</span><span class="ss"> &quot;</span></span>
+<span id="cb71-109"><a href="#cb71-109" aria-hidden="true" tabindex="-1"></a>          <span class="ss">f&quot;</span><span class="sc">{</span><span class="st">&#39;Faktor&#39;</span><span class="sc">:&gt;8}</span><span class="ss">&quot;</span>)</span>
+<span id="cb71-110"><a href="#cb71-110" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;-&quot;</span> <span class="op">*</span> <span class="dv">78</span>)</span>
+<span id="cb71-111"><a href="#cb71-111" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb71-112"><a href="#cb71-112" aria-hidden="true" tabindex="-1"></a>    <span class="cf">for</span> n_auftraege, n_maschinen <span class="kw">in</span> [(<span class="dv">60</span>, <span class="dv">7</span>), (<span class="dv">80</span>, <span class="dv">9</span>)]:</span>
+<span id="cb71-113"><a href="#cb71-113" aria-hidden="true" tabindex="-1"></a>        dauer <span class="op">=</span> RNG.integers(<span class="dv">10</span>, <span class="dv">90</span>, n_auftraege)</span>
+<span id="cb71-114"><a href="#cb71-114" aria-hidden="true" tabindex="-1"></a>        start, lpt_wert <span class="op">=</span> lpt_heuristik(dauer, n_maschinen)</span>
+<span id="cb71-115"><a href="#cb71-115" aria-hidden="true" tabindex="-1"></a>        untere_schranke <span class="op">=</span> dauer.<span class="bu">sum</span>() <span class="op">/</span> n_maschinen</span>
+<span id="cb71-116"><a href="#cb71-116" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb71-117"><a href="#cb71-117" aria-hidden="true" tabindex="-1"></a>        instanz <span class="op">=</span> <span class="ss">f&quot;</span><span class="sc">{</span>n_auftraege<span class="sc">}</span><span class="ss"> Auftr., </span><span class="sc">{</span>n_maschinen<span class="sc">}</span><span class="ss"> Masch.&quot;</span></span>
+<span id="cb71-118"><a href="#cb71-118" aria-hidden="true" tabindex="-1"></a>        <span class="bu">print</span>(<span class="ss">f&quot;</span><span class="sc">{</span>instanz<span class="sc">:&lt;22}</span><span class="ss"> </span><span class="sc">{</span><span class="st">&#39;LPT-Heuristik&#39;</span><span class="sc">:&lt;22}</span><span class="ss"> </span><span class="sc">{</span>lpt_wert<span class="sc">:&gt;9}</span><span class="ss"> &quot;</span></span>
+<span id="cb71-119"><a href="#cb71-119" aria-hidden="true" tabindex="-1"></a>              <span class="ss">f&quot;</span><span class="sc">{</span><span class="st">&#39;&lt; 0.001s&#39;</span><span class="sc">:&gt;9}</span><span class="ss"> </span><span class="sc">{</span><span class="st">&#39;&#39;</span><span class="sc">:&gt;8}</span><span class="ss">&quot;</span>)</span>
+<span id="cb71-120"><a href="#cb71-120" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb71-121"><a href="#cb71-121" aria-hidden="true" tabindex="-1"></a>        _, ziel_kalt, zeit_kalt <span class="op">=</span> loese(dauer, n_maschinen, <span class="fl">60.0</span>)</span>
+<span id="cb71-122"><a href="#cb71-122" aria-hidden="true" tabindex="-1"></a>        <span class="bu">print</span>(<span class="ss">f&quot;</span><span class="sc">{</span><span class="st">&#39;&#39;</span><span class="sc">:&lt;22}</span><span class="ss"> </span><span class="sc">{</span><span class="st">&#39;CP-SAT kalt&#39;</span><span class="sc">:&lt;22}</span><span class="ss"> </span><span class="sc">{</span>ziel_kalt<span class="sc">:&gt;9}</span><span class="ss"> &quot;</span></span>
+<span id="cb71-123"><a href="#cb71-123" aria-hidden="true" tabindex="-1"></a>              <span class="ss">f&quot;</span><span class="sc">{</span>zeit_kalt<span class="sc">:&gt;8.3f}</span><span class="ss">s </span><span class="sc">{</span><span class="st">&#39;1,0x&#39;</span><span class="sc">:&gt;8}</span><span class="ss">&quot;</span>)</span>
+<span id="cb71-124"><a href="#cb71-124" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb71-125"><a href="#cb71-125" aria-hidden="true" tabindex="-1"></a>        _, ziel_warm, zeit_warm <span class="op">=</span> loese(dauer, n_maschinen, <span class="fl">60.0</span>, hinweis<span class="op">=</span>start)</span>
+<span id="cb71-126"><a href="#cb71-126" aria-hidden="true" tabindex="-1"></a>        <span class="bu">print</span>(<span class="ss">f&quot;</span><span class="sc">{</span><span class="st">&#39;&#39;</span><span class="sc">:&lt;22}</span><span class="ss"> </span><span class="sc">{</span><span class="st">&#39;CP-SAT + LPT-Hinweis&#39;</span><span class="sc">:&lt;22}</span><span class="ss"> </span><span class="sc">{</span>ziel_warm<span class="sc">:&gt;9}</span><span class="ss"> &quot;</span></span>
+<span id="cb71-127"><a href="#cb71-127" aria-hidden="true" tabindex="-1"></a>              <span class="ss">f&quot;</span><span class="sc">{</span>zeit_warm<span class="sc">:&gt;8.3f}</span><span class="ss">s </span><span class="sc">{</span>zeit_kalt <span class="op">/</span> zeit_warm<span class="sc">:&gt;7.1f}</span><span class="ss">x&quot;</span>)</span>
+<span id="cb71-128"><a href="#cb71-128" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb71-129"><a href="#cb71-129" aria-hidden="true" tabindex="-1"></a>        <span class="cf">assert</span> ziel_kalt <span class="op">==</span> ziel_warm, <span class="op">\</span></span>
+<span id="cb71-130"><a href="#cb71-130" aria-hidden="true" tabindex="-1"></a>            <span class="st">&quot;Der Hinweis darf das Optimum nicht veraendern - nur den Weg dorthin!&quot;</span></span>
+<span id="cb71-131"><a href="#cb71-131" aria-hidden="true" tabindex="-1"></a>        <span class="bu">print</span>(<span class="ss">f&quot;</span><span class="sc">{</span><span class="st">&#39;&#39;</span><span class="sc">:&lt;22}</span><span class="ss"> </span><span class="sc">{</span><span class="st">&#39;untere Schranke&#39;</span><span class="sc">:&lt;22}</span><span class="ss"> </span><span class="sc">{</span>untere_schranke<span class="sc">:&gt;9.1f}</span><span class="ss">&quot;</span>)</span>
+<span id="cb71-132"><a href="#cb71-132" aria-hidden="true" tabindex="-1"></a>        <span class="bu">print</span>(<span class="st">&quot;-&quot;</span> <span class="op">*</span> <span class="dv">78</span>)</span>
+<span id="cb71-133"><a href="#cb71-133" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb71-134"><a href="#cb71-134" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;</span><span class="ch">\n</span><span class="st">Drei Beobachtungen:&quot;</span>)</span>
+<span id="cb71-135"><a href="#cb71-135" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;1. Der Hinweis aendert das ERGEBNIS nicht - beide Laeufe finden&quot;</span>)</span>
+<span id="cb71-136"><a href="#cb71-136" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;   dasselbe Optimum. Er aendert nur, wie lange der Beweis dauert.&quot;</span>)</span>
+<span id="cb71-137"><a href="#cb71-137" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;   Genau deshalb ist ein Warm-Start ungefaehrlich: Ein schlechter&quot;</span>)</span>
+<span id="cb71-138"><a href="#cb71-138" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;   Hinweis kostet Zeit, er verfaelscht aber nie die Loesung.&quot;</span>)</span>
+<span id="cb71-139"><a href="#cb71-139" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;2. Die LPT-Heuristik liegt schon sehr nah am Optimum. Ihr Wert fuer&quot;</span>)</span>
+<span id="cb71-140"><a href="#cb71-140" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;   den Solver liegt weniger in der Qualitaet als darin, dass sie&quot;</span>)</span>
+<span id="cb71-141"><a href="#cb71-141" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;   SOFORT da ist - der Solver kann von Beginn an alles verwerfen,&quot;</span>)</span>
+<span id="cb71-142"><a href="#cb71-142" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;   was schlechter ist.&quot;</span>)</span>
+<span id="cb71-143"><a href="#cb71-143" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;3. Der Faktor schwankt von Instanz zu Instanz - oben 2,2x und 1,4x -&quot;</span>)</span>
+<span id="cb71-144"><a href="#cb71-144" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;   und laesst sich NICHT aus der Problemgroesse ableiten. Er haengt&quot;</span>)</span>
+<span id="cb71-145"><a href="#cb71-145" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;   davon ab, wie schnell der Solver von allein eine vergleichbar gute&quot;</span>)</span>
+<span id="cb71-146"><a href="#cb71-146" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;   Loesung findet. Das ist die eigentliche Lehre: Ein Warm-Start ist&quot;</span>)</span>
+<span id="cb71-147"><a href="#cb71-147" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;   eine Messung wert, keine Glaubensfrage.&quot;</span>)</span>
+<span id="cb71-148"><a href="#cb71-148" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;=&quot;</span> <span class="op">*</span> <span class="dv">78</span>)</span></code></pre></div>
 <p><strong>Erwartete Ausgabe (Zeiten hardwareabhängig):</strong></p>
 <pre><code>==============================================================================
   WARM-START: WENN DIE HEURISTIK MEHR WEISS ALS DER SOLVER
@@ -10243,7 +10683,7 @@ Instanz                Variante                Makespan      Zeit   Faktor
 <h2 id="sec:milp-denkfehler">6.10 Finde den Denkfehler</h2>
 <p>Die Warnung „<span class="math inline">M</span> so klein wie möglich“ wird meist mit der Laufzeit begründet: schwache Relaxation, mehr Knoten. Das stimmt — und ist die <strong>harmlosere</strong> Hälfte der Wahrheit.</p>
 <blockquote>
-<p><strong>🐛 Finde den Denkfehler 5.1: Elf Lager, die keine Fixkosten kosten</strong></p>
+<p><strong>🐛 Finde den Denkfehler: Elf Lager, die keine Fixkosten kosten</strong></p>
 <p>Ein Team plant Standorte: 12 mögliche Lager, 40 Kunden, Fixkosten je eröffnetem Lager. Für das Big-M in der Kopplung</p>
 <p><span class="math display">\sum_j x_{ij} \le M \cdot y_i</span></p>
 <p>setzt jemand „sicherheitshalber“ eine sehr große Zahl ein. Das Modell läuft durch und meldet Gesamtkosten von <strong>12 441,96 €</strong>. Mit einem knapp gewählten <span class="math inline">M</span> hatte dasselbe Modell zuvor 26 525,28 € gemeldet. Das Team freut sich über die Einsparung.</p>
@@ -10537,7 +10977,7 @@ funktioniert immer.
 <hr />
 <h2 id="sec:milp-quiz">6.11 Micro-Quiz</h2>
 <blockquote>
-<p><strong>❓ Micro-Quiz 5: Drei Fragen zum Selbstcheck</strong></p>
+<p><strong>❓ Micro-Quiz 6: Drei Fragen zum Selbstcheck</strong></p>
 <p>Genau eine Antwort ist jeweils richtig. Auflösung in <a href="#quiz-loesung-milp">Anhang A</a>.</p>
 <p><strong>1. Ihr Solver meldet nach dem Zeitlimit: Incumbent 48 200 €, Schranke 47 100 €. Was berichten Sie dem Auftraggeber?</strong> (a) „Der Solver ist nicht fertig geworden, das Ergebnis ist unbrauchbar.“ (b) „Wir haben einen Plan für 48 200 €. Er ist garantiert höchstens 2,3 % teurer als das theoretisch bestmögliche.“ (c) „Der optimale Wert liegt bei 47 100 €, wir müssen den Plan nur noch dorthin verbessern.“</p>
 <p><strong>2. In Ihrem Fixkostenmodell ist <span class="math inline">M = 10^9</span>, die tatsächliche Anlagenkapazität beträgt 500. Welche Gefahr ist die größere?</strong> (a) Der Solver braucht mehr Knoten und wird langsamer. (b) Binärvariablen können bei Werten um <span class="math inline">10^{-8}</span> hängenbleiben, gelten dem Solver als 0 — und Anlagen produzieren, ohne dass ihre Fixkosten je verbucht werden. (c) Die Zielfunktion wird numerisch instabil und liefert negative Kosten.</p>
@@ -10579,6 +11019,7 @@ funktioniert immer.
 <code>Propagation_Demo.py</code><br />
 <code>CP_SAT_Vertretungssystem.py</code><br />
 <code>JobShop_Intervalle.py</code><br />
+<code>Parallele_Suche.py</code><br />
 <code>CP_SAT_Statusfaelle.py</code><br />
 <code>Strafgewichte.py</code></p>
 <p><strong>Notebook:</strong> <code>Notebooks_04/cpsat.ipynb</code><br />
@@ -10620,7 +11061,7 @@ Fr -&gt; Abel</code></pre>
 <p><strong>Und jetzt sehen Sie sich das Ergebnis genau an.</strong> <em>Cor bekommt keinen einzigen Dienst.</em> Dane arbeitet Montag <strong>und</strong> Dienstag hintereinander. Ist das ein Fehler?</p>
 <p>Nein — und das ist die wichtigste Lektion dieses Kapitels. Der Plan erfüllt <strong>jede</strong> Regel, die wir aufgeschrieben haben. Wir haben nur nie nach Fairness gefragt, und wir haben nie gesagt, dass Dienste nicht aufeinanderfolgen sollen. Ein Solver liefert exakt das Bestellte — nicht das Gemeinte.</p>
 <blockquote>
-<p><strong>🎯 Merksatz</strong> Ein Modell, das durchläuft, ist noch kein richtiges Modell. Die eigentliche Arbeit im Constraint Programming ist nicht das Lösen, sondern das vollständige Aufschreiben dessen, was „ein guter Plan“ überhaupt heißt. Wie man Wünsche wie Fairness als <strong>weiche</strong> Bedingungen mit Strafkosten formuliert, zeigt <a href="#sec:cpsat-praxisfall-dynamisches-vertretungssystem">Abschnitt 7.5</a> — und <a href="#sec:cpsat-denkfehler">Abschnitt 7.9</a> zeigt, was passiert, wenn man ihr Gewicht falsch wählt.</p>
+<p><strong>🎯 Merksatz</strong> Ein Modell, das durchläuft, ist noch kein richtiges Modell. Die eigentliche Arbeit im Constraint Programming ist nicht das Lösen, sondern das vollständige Aufschreiben dessen, was „ein guter Plan“ überhaupt heißt. Wie man Wünsche wie Fairness als <strong>weiche</strong> Bedingungen mit Strafkosten formuliert, zeigt <a href="#sec:cpsat-praxisfall-dynamisches-vertretungssystem">Abschnitt 7.5</a> — und <a href="#sec:cpsat-denkfehler">Abschnitt 7.10</a> zeigt, was passiert, wenn man ihr Gewicht falsch wählt.</p>
 </blockquote>
 <hr />
 <h2 id="sec:cpsat-lernziele">7.2 Lernziele</h2>
@@ -10632,6 +11073,7 @@ Fr -&gt; Abel</code></pre>
 <li>… mit <strong>Intervallvariablen</strong> ein Maschinenbelegungsproblem modellieren.</li>
 <li>… harte Regeln und weiche Ziele in einem Modell kombinieren und gewichten.</li>
 <li>… die fünf CP-SAT-Statusfälle unterscheiden — insbesondere <code>INFEASIBLE</code> (es gibt keine Lösung) von <code>UNKNOWN</code> (es wurde keine gefunden) und <code>MODEL_INVALID</code> (Ihr Code ist fehlerhaft).</li>
+<li>… begründen, warum <code>num_workers = 1</code> für einen reproduzierbaren Lauf nötig ist und ein fester <code>random_seed</code> allein nicht genügt — und was ein Test deshalb prüfen darf.</li>
 <li>… begründen, warum ein Strafgewicht ein <strong>Wechselkurs</strong> ist, und welche Regeln deshalb niemals in die Zielfunktion gehören.</li>
 </ol>
 <hr />
@@ -11184,7 +11626,7 @@ Suchstatistik: 113 Verzweigungen, 3 Konflikte, 0.006 s
 <p><strong>3. Kostenzerlegung.</strong> Der Block „Woraus bestehen die Strafkosten?“ ist kein Beiwerk. In der Praxis ist die erste Frage jedes Anwenders: <em>„Warum bekomme <strong>ich</strong> die Stunde?“</em> Wer darauf keine Antwort hat, dessen System wird nicht benutzt (<a href="#kap-praxisfallen">Kapitel 22</a>, <em>Explainable OR</em>).</p>
 <p><strong>4. Statusauswertung ohne CP-SAT-Vokabular.</strong> Nach <code>Solve()</code> steht nur eine einzige Zeile mit einer CP-SAT-Konstante darin:</p>
 <div class="sourceCode" id="cb81"><pre class="sourceCode python"><code class="sourceCode python"><span id="cb81-1"><a href="#cb81-1" aria-hidden="true" tabindex="-1"></a>status <span class="op">=</span> status_von_cpsat(rohstatus)</span></code></pre></div>
-<p>Danach heißen die Fälle <code>status.modellfehler</code> (die Regeln widersprechen sich — das Modell muss geändert werden) und <code>status.brauchbar</code> (es liegt etwas Ausführbares vor). Das ist <strong>dieselbe</strong> Fallunterscheidung wie bei HiGHS in <a href="#kap-milp">Kapitel 6</a> und bei GLOP in <a href="#kap-lp">Kapitel 5</a>; nur die eine Übersetzerzeile weiß, welcher Solver gerechnet hat. Wer den Auswertungscode direkt gegen <code>cp_model.INFEASIBLE</code> schreibt, kann ihn bei einem Solverwechsel wegwerfen — <a href="#sec:praxisfallen-solverwechsel">Abschnitt 22.6</a> führt genau diesen Wechsel vor.</p>
+<p>Danach heißen die Fälle <code>status.modellfehler</code> (die Regeln widersprechen sich — das Modell muss geändert werden) und <code>status.brauchbar</code> (es liegt etwas Ausführbares vor). Das ist <strong>dieselbe</strong> Fallunterscheidung wie bei HiGHS in <a href="#kap-milp">Kapitel 6</a> und bei GLOP in <a href="#kap-lp">Kapitel 5</a>; nur die eine Übersetzerzeile weiß, welcher Solver gerechnet hat. Wer den Auswertungscode direkt gegen <code>cp_model.INFEASIBLE</code> schreibt, kann ihn bei einem Solverwechsel wegwerfen — <a href="#sec:praxisfallen-solverwechsel">Abschnitt 22.7</a> führt genau diesen Wechsel vor.</p>
 </blockquote>
 <blockquote>
 <p><strong>⚠️ Typische Fehler</strong></p>
@@ -11341,6 +11783,7 @@ Erreichter Makespan: 11
 <p><strong>⚠️ Mehrere gleich gute Pläne — und was das für Ihre Tests bedeutet</strong></p>
 <p>Der kürzeste Makespan beträgt 11, aber es gibt <strong>mehrere verschiedene Pläne</strong>, die ihn erreichen. Welchen CP-SAT findet, hängt normalerweise davon ab, welcher seiner parallelen Suchstränge zuerst fertig wird — dasselbe Programm liefert dann von Lauf zu Lauf einen anderen (gleich guten) Plan.</p>
 <p>Deshalb setzt das Programm oben <code>num_workers = 1</code> und <code>random_seed = 1</code>: nur so ist die abgedruckte Ausgabe reproduzierbar. <strong>Im Produktivbetrieb lässt man beides weg</strong> — mehrere Arbeiter sind deutlich schneller.</p>
+<p>Wie viel schneller, und warum der Seed allein <strong>nicht</strong> genügt, misst <a href="#sec:cpsat-parallele-suche">Abschnitt 7.7</a> an genau diesem Modell.</p>
 <p>Die Lehre für Ihre eigenen Tests: Prüfen Sie bei mehrdeutigen Optima nie auf einen <strong>bestimmten Plan</strong>, sondern immer auf den <strong>Zielwert</strong> und auf die Einhaltung aller Regeln. Ein Test wie <code>assert plan == erwarteter_plan</code> besteht sonst mal und scheitert mal, ohne dass sich am Code etwas geändert hätte.</p>
 </blockquote>
 <p>Bemerkenswert ist die letzte Zeile: Die untere Schranke liegt bei 10, erreicht wurden 11. Die Schranke ist also <strong>nicht erreichbar</strong> — kein Plan kann 10 schaffen, obwohl weder ein einzelner Auftrag noch eine einzelne Maschine mehr als 10 Zeiteinheiten braucht. Der Grund sind die Wechselwirkungen. Das ist typisch für Scheduling: <strong>Einfache Schranken sind selten scharf.</strong> Trotzdem sind sie nützlich — sie sagten uns hier, dass wir höchstens 10 % vom theoretischen Ideal entfernt sein können, noch bevor der Solver fertig war.</p>
@@ -11349,7 +11792,305 @@ Erreichter Makespan: 11
 <p>Eine Intervallvariable bündelt drei Größen (Start, Dauer, Ende) und garantiert intern <code>start + dauer == ende</code>. Der eigentliche Gewinn ist aber <code>AddNoOverlap</code>: Diese eine Zeile ersetzt für <span class="math inline">k</span> Gänge auf einer Maschine <span class="math inline">\binom{k}{2}</span> Entweder-Oder-Konstruktionen mit je zwei Big-M-Ungleichungen und einer Binärvariablen. Bei 10 Gängen sind das 45 Disjunktionen — in MILP ein zäher Block, in CP-SAT eine Zeile mit einem spezialisierten Propagator.</p>
 </blockquote>
 <hr />
-<h2 id="sec:cpsat-statusfaelle">7.7 Die fünf Antworten von CP-SAT</h2>
+<h2 id="sec:cpsat-parallele-suche">7.7 Parallele Suche: was <code>num_workers</code> wirklich bewirkt</h2>
+<p>An mehreren Stellen dieses Buchs steht <code>loeser.parameters.num_workers = 1</code>, mit dem Kommentar „für eine reproduzierbare Ausgabe“. Darin stecken zwei Behauptungen: dass parallele Suche <strong>schneller</strong> ist, und dass sie <strong>von Lauf zu Lauf andere, gleich gute</strong> Lösungen liefert. Beides lässt sich messen — und beim Messen kommt mehr heraus als erwartet.</p>
+<p>Gerechnet wird auf demselben Modell wie <a href="#sec:cpsat-intervallvariablen-job-shop-scheduling">Abschnitt 7.6</a>, nur groß genug, dass die Suche wirklich arbeitet: 12 Aufträge auf 10 Maschinen, jeder Auftrag besucht jede Maschine. Entscheidend ist, dass <code>random_seed</code> in <strong>jedem</strong> Lauf denselben Wert hat.</p>
+<div class="sourceCode" id="cb84"><pre class="sourceCode python"><code class="sourceCode python"><span id="cb84-1"><a href="#cb84-1" aria-hidden="true" tabindex="-1"></a><span class="co">#!/usr/bin/env python3</span></span>
+<span id="cb84-2"><a href="#cb84-2" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb84-3"><a href="#cb84-3" aria-hidden="true" tabindex="-1"></a><span class="co"># Parallele_Suche.py</span></span>
+<span id="cb84-4"><a href="#cb84-4" aria-hidden="true" tabindex="-1"></a><span class="co">&quot;&quot;&quot;</span></span>
+<span id="cb84-5"><a href="#cb84-5" aria-hidden="true" tabindex="-1"></a><span class="co">Kapitel CP-SAT: Was mehrere Arbeiter wirklich bringen - und was sie kosten.</span></span>
+<span id="cb84-6"><a href="#cb84-6" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb84-7"><a href="#cb84-7" aria-hidden="true" tabindex="-1"></a><span class="co">Das Buch setzt an mehreren Stellen &#39;num_workers = 1&#39;, damit die abgedruckte</span></span>
+<span id="cb84-8"><a href="#cb84-8" aria-hidden="true" tabindex="-1"></a><span class="co">Ausgabe reproduzierbar ist. Behauptet wird dabei zweierlei: dass parallele</span></span>
+<span id="cb84-9"><a href="#cb84-9" aria-hidden="true" tabindex="-1"></a><span class="co">Suche schneller ist, und dass sie von Lauf zu Lauf verschiedene, gleich gute</span></span>
+<span id="cb84-10"><a href="#cb84-10" aria-hidden="true" tabindex="-1"></a><span class="co">Loesungen findet. Beides wird hier gemessen statt geglaubt.</span></span>
+<span id="cb84-11"><a href="#cb84-11" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb84-12"><a href="#cb84-12" aria-hidden="true" tabindex="-1"></a><span class="co">Gerechnet wird auf einem Job-Shop wie in JobShop_Intervalle.py, nur gross</span></span>
+<span id="cb84-13"><a href="#cb84-13" aria-hidden="true" tabindex="-1"></a><span class="co">genug, dass die Suche wirklich arbeitet: 12 Auftraege auf 10 Maschinen,</span></span>
+<span id="cb84-14"><a href="#cb84-14" aria-hidden="true" tabindex="-1"></a><span class="co">jeder Auftrag besucht jede Maschine.</span></span>
+<span id="cb84-15"><a href="#cb84-15" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb84-16"><a href="#cb84-16" aria-hidden="true" tabindex="-1"></a><span class="co">Zwei Messungen:</span></span>
+<span id="cb84-17"><a href="#cb84-17" aria-hidden="true" tabindex="-1"></a><span class="co">  1. Dieselbe Aufgabe mit 1, 2, 4 und 8 Arbeitern - Laufzeit und Ergebnis.</span></span>
+<span id="cb84-18"><a href="#cb84-18" aria-hidden="true" tabindex="-1"></a><span class="co">  2. Dieselbe Konfiguration mehrfach, bei FESTEM random_seed - wie oft kommt</span></span>
+<span id="cb84-19"><a href="#cb84-19" aria-hidden="true" tabindex="-1"></a><span class="co">     derselbe Plan heraus?</span></span>
+<span id="cb84-20"><a href="#cb84-20" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb84-21"><a href="#cb84-21" aria-hidden="true" tabindex="-1"></a><span class="co">Die zweite ist die wichtigere: Sie entscheidet, wie man Tests schreibt.</span></span>
+<span id="cb84-22"><a href="#cb84-22" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb84-23"><a href="#cb84-23" aria-hidden="true" tabindex="-1"></a><span class="co">Achtung, Laufzeiten sind hardwareabhaengig. Die ZAHL der verschiedenen</span></span>
+<span id="cb84-24"><a href="#cb84-24" aria-hidden="true" tabindex="-1"></a><span class="co">Plaene ist es auch - und genau das ist die Aussage.</span></span>
+<span id="cb84-25"><a href="#cb84-25" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb84-26"><a href="#cb84-26" aria-hidden="true" tabindex="-1"></a><span class="co">Benoetigt: numpy, ortools</span></span>
+<span id="cb84-27"><a href="#cb84-27" aria-hidden="true" tabindex="-1"></a><span class="co">&quot;&quot;&quot;</span></span>
+<span id="cb84-28"><a href="#cb84-28" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb84-29"><a href="#cb84-29" aria-hidden="true" tabindex="-1"></a><span class="im">from</span> __future__ <span class="im">import</span> annotations</span>
+<span id="cb84-30"><a href="#cb84-30" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb84-31"><a href="#cb84-31" aria-hidden="true" tabindex="-1"></a><span class="im">import</span> collections</span>
+<span id="cb84-32"><a href="#cb84-32" aria-hidden="true" tabindex="-1"></a><span class="im">import</span> time</span>
+<span id="cb84-33"><a href="#cb84-33" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb84-34"><a href="#cb84-34" aria-hidden="true" tabindex="-1"></a><span class="im">import</span> numpy <span class="im">as</span> np</span>
+<span id="cb84-35"><a href="#cb84-35" aria-hidden="true" tabindex="-1"></a><span class="im">from</span> ortools.sat.python <span class="im">import</span> cp_model</span>
+<span id="cb84-36"><a href="#cb84-36" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb84-37"><a href="#cb84-37" aria-hidden="true" tabindex="-1"></a>AUFTRAEGE <span class="op">=</span> <span class="dv">12</span></span>
+<span id="cb84-38"><a href="#cb84-38" aria-hidden="true" tabindex="-1"></a>MASCHINEN <span class="op">=</span> <span class="dv">10</span></span>
+<span id="cb84-39"><a href="#cb84-39" aria-hidden="true" tabindex="-1"></a>INSTANZ_SEED <span class="op">=</span> <span class="dv">20260908</span></span>
+<span id="cb84-40"><a href="#cb84-40" aria-hidden="true" tabindex="-1"></a>SOLVER_SEED <span class="op">=</span> <span class="dv">1</span>          <span class="co"># bleibt ueber ALLE Laeufe gleich - das ist der Punkt</span></span>
+<span id="cb84-41"><a href="#cb84-41" aria-hidden="true" tabindex="-1"></a>ARBEITERZAHLEN <span class="op">=</span> (<span class="dv">1</span>, <span class="dv">2</span>, <span class="dv">4</span>, <span class="dv">8</span>)</span>
+<span id="cb84-42"><a href="#cb84-42" aria-hidden="true" tabindex="-1"></a>WIEDERHOLUNGEN <span class="op">=</span> <span class="dv">4</span></span>
+<span id="cb84-43"><a href="#cb84-43" aria-hidden="true" tabindex="-1"></a>ZEITLIMIT <span class="op">=</span> <span class="fl">120.0</span></span>
+<span id="cb84-44"><a href="#cb84-44" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb84-45"><a href="#cb84-45" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb84-46"><a href="#cb84-46" aria-hidden="true" tabindex="-1"></a><span class="kw">def</span> baue_instanz() <span class="op">-&gt;</span> <span class="bu">list</span>[<span class="bu">list</span>[<span class="bu">tuple</span>[<span class="bu">int</span>, <span class="bu">int</span>]]]:</span>
+<span id="cb84-47"><a href="#cb84-47" aria-hidden="true" tabindex="-1"></a>    <span class="co">&quot;&quot;&quot;Klassischer Job-Shop: Jeder Auftrag besucht jede Maschine genau einmal,</span></span>
+<span id="cb84-48"><a href="#cb84-48" aria-hidden="true" tabindex="-1"></a><span class="co">    in einer eigenen zufaelligen Reihenfolge.&quot;&quot;&quot;</span></span>
+<span id="cb84-49"><a href="#cb84-49" aria-hidden="true" tabindex="-1"></a>    rng <span class="op">=</span> np.random.default_rng(INSTANZ_SEED)</span>
+<span id="cb84-50"><a href="#cb84-50" aria-hidden="true" tabindex="-1"></a>    <span class="cf">return</span> [[(<span class="bu">int</span>(m), <span class="bu">int</span>(rng.integers(<span class="dv">2</span>, <span class="dv">20</span>))) <span class="cf">for</span> m <span class="kw">in</span> rng.permutation(MASCHINEN)]</span>
+<span id="cb84-51"><a href="#cb84-51" aria-hidden="true" tabindex="-1"></a>            <span class="cf">for</span> _ <span class="kw">in</span> <span class="bu">range</span>(AUFTRAEGE)]</span>
+<span id="cb84-52"><a href="#cb84-52" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb84-53"><a href="#cb84-53" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb84-54"><a href="#cb84-54" aria-hidden="true" tabindex="-1"></a><span class="kw">def</span> loese(auftraege, arbeiter: <span class="bu">int</span>):</span>
+<span id="cb84-55"><a href="#cb84-55" aria-hidden="true" tabindex="-1"></a>    <span class="co">&quot;&quot;&quot;Minimiert den Makespan. Gibt Status, Zielwert, Laufzeit und den Plan</span></span>
+<span id="cb84-56"><a href="#cb84-56" aria-hidden="true" tabindex="-1"></a><span class="co">    zurueck - den Plan als Tupel aller Startzeiten, damit sich zwei Laeufe</span></span>
+<span id="cb84-57"><a href="#cb84-57" aria-hidden="true" tabindex="-1"></a><span class="co">    vergleichen lassen.&quot;&quot;&quot;</span></span>
+<span id="cb84-58"><a href="#cb84-58" aria-hidden="true" tabindex="-1"></a>    horizont <span class="op">=</span> <span class="bu">sum</span>(dauer <span class="cf">for</span> auftrag <span class="kw">in</span> auftraege <span class="cf">for</span> _, dauer <span class="kw">in</span> auftrag)</span>
+<span id="cb84-59"><a href="#cb84-59" aria-hidden="true" tabindex="-1"></a>    modell <span class="op">=</span> cp_model.CpModel()</span>
+<span id="cb84-60"><a href="#cb84-60" aria-hidden="true" tabindex="-1"></a>    Gang <span class="op">=</span> collections.namedtuple(<span class="st">&quot;Gang&quot;</span>, <span class="st">&quot;start ende intervall&quot;</span>)</span>
+<span id="cb84-61"><a href="#cb84-61" aria-hidden="true" tabindex="-1"></a>    plaene: <span class="bu">dict</span>[<span class="bu">tuple</span>[<span class="bu">int</span>, <span class="bu">int</span>], Gang] <span class="op">=</span> {}</span>
+<span id="cb84-62"><a href="#cb84-62" aria-hidden="true" tabindex="-1"></a>    je_maschine <span class="op">=</span> collections.defaultdict(<span class="bu">list</span>)</span>
+<span id="cb84-63"><a href="#cb84-63" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb84-64"><a href="#cb84-64" aria-hidden="true" tabindex="-1"></a>    <span class="cf">for</span> a, auftrag <span class="kw">in</span> <span class="bu">enumerate</span>(auftraege):</span>
+<span id="cb84-65"><a href="#cb84-65" aria-hidden="true" tabindex="-1"></a>        <span class="cf">for</span> g, (maschine, dauer) <span class="kw">in</span> <span class="bu">enumerate</span>(auftrag):</span>
+<span id="cb84-66"><a href="#cb84-66" aria-hidden="true" tabindex="-1"></a>            start <span class="op">=</span> modell.NewIntVar(<span class="dv">0</span>, horizont, <span class="ss">f&quot;start_</span><span class="sc">{</span>a<span class="sc">}</span><span class="ss">_</span><span class="sc">{</span>g<span class="sc">}</span><span class="ss">&quot;</span>)</span>
+<span id="cb84-67"><a href="#cb84-67" aria-hidden="true" tabindex="-1"></a>            ende <span class="op">=</span> modell.NewIntVar(<span class="dv">0</span>, horizont, <span class="ss">f&quot;ende_</span><span class="sc">{</span>a<span class="sc">}</span><span class="ss">_</span><span class="sc">{</span>g<span class="sc">}</span><span class="ss">&quot;</span>)</span>
+<span id="cb84-68"><a href="#cb84-68" aria-hidden="true" tabindex="-1"></a>            intervall <span class="op">=</span> modell.NewIntervalVar(start, dauer, ende, <span class="ss">f&quot;iv_</span><span class="sc">{</span>a<span class="sc">}</span><span class="ss">_</span><span class="sc">{</span>g<span class="sc">}</span><span class="ss">&quot;</span>)</span>
+<span id="cb84-69"><a href="#cb84-69" aria-hidden="true" tabindex="-1"></a>            plaene[a, g] <span class="op">=</span> Gang(start, ende, intervall)</span>
+<span id="cb84-70"><a href="#cb84-70" aria-hidden="true" tabindex="-1"></a>            je_maschine[maschine].append(intervall)</span>
+<span id="cb84-71"><a href="#cb84-71" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb84-72"><a href="#cb84-72" aria-hidden="true" tabindex="-1"></a>    <span class="cf">for</span> maschine <span class="kw">in</span> <span class="bu">range</span>(MASCHINEN):</span>
+<span id="cb84-73"><a href="#cb84-73" aria-hidden="true" tabindex="-1"></a>        modell.AddNoOverlap(je_maschine[maschine])</span>
+<span id="cb84-74"><a href="#cb84-74" aria-hidden="true" tabindex="-1"></a>    <span class="cf">for</span> a, auftrag <span class="kw">in</span> <span class="bu">enumerate</span>(auftraege):</span>
+<span id="cb84-75"><a href="#cb84-75" aria-hidden="true" tabindex="-1"></a>        <span class="cf">for</span> g <span class="kw">in</span> <span class="bu">range</span>(<span class="bu">len</span>(auftrag) <span class="op">-</span> <span class="dv">1</span>):</span>
+<span id="cb84-76"><a href="#cb84-76" aria-hidden="true" tabindex="-1"></a>            modell.Add(plaene[a, g <span class="op">+</span> <span class="dv">1</span>].start <span class="op">&gt;=</span> plaene[a, g].ende)</span>
+<span id="cb84-77"><a href="#cb84-77" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb84-78"><a href="#cb84-78" aria-hidden="true" tabindex="-1"></a>    makespan <span class="op">=</span> modell.NewIntVar(<span class="dv">0</span>, horizont, <span class="st">&quot;makespan&quot;</span>)</span>
+<span id="cb84-79"><a href="#cb84-79" aria-hidden="true" tabindex="-1"></a>    modell.AddMaxEquality(</span>
+<span id="cb84-80"><a href="#cb84-80" aria-hidden="true" tabindex="-1"></a>        makespan, [plaene[a, <span class="bu">len</span>(auftrag) <span class="op">-</span> <span class="dv">1</span>].ende</span>
+<span id="cb84-81"><a href="#cb84-81" aria-hidden="true" tabindex="-1"></a>                   <span class="cf">for</span> a, auftrag <span class="kw">in</span> <span class="bu">enumerate</span>(auftraege)])</span>
+<span id="cb84-82"><a href="#cb84-82" aria-hidden="true" tabindex="-1"></a>    modell.Minimize(makespan)</span>
+<span id="cb84-83"><a href="#cb84-83" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb84-84"><a href="#cb84-84" aria-hidden="true" tabindex="-1"></a>    loeser <span class="op">=</span> cp_model.CpSolver()</span>
+<span id="cb84-85"><a href="#cb84-85" aria-hidden="true" tabindex="-1"></a>    loeser.parameters.num_workers <span class="op">=</span> arbeiter</span>
+<span id="cb84-86"><a href="#cb84-86" aria-hidden="true" tabindex="-1"></a>    loeser.parameters.random_seed <span class="op">=</span> SOLVER_SEED</span>
+<span id="cb84-87"><a href="#cb84-87" aria-hidden="true" tabindex="-1"></a>    loeser.parameters.max_time_in_seconds <span class="op">=</span> ZEITLIMIT</span>
+<span id="cb84-88"><a href="#cb84-88" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb84-89"><a href="#cb84-89" aria-hidden="true" tabindex="-1"></a>    beginn <span class="op">=</span> time.perf_counter()</span>
+<span id="cb84-90"><a href="#cb84-90" aria-hidden="true" tabindex="-1"></a>    status <span class="op">=</span> loeser.Solve(modell)</span>
+<span id="cb84-91"><a href="#cb84-91" aria-hidden="true" tabindex="-1"></a>    dauer <span class="op">=</span> time.perf_counter() <span class="op">-</span> beginn</span>
+<span id="cb84-92"><a href="#cb84-92" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb84-93"><a href="#cb84-93" aria-hidden="true" tabindex="-1"></a>    <span class="cf">if</span> status <span class="kw">not</span> <span class="kw">in</span> (cp_model.OPTIMAL, cp_model.FEASIBLE):</span>
+<span id="cb84-94"><a href="#cb84-94" aria-hidden="true" tabindex="-1"></a>        <span class="cf">return</span> loeser.StatusName(status), <span class="va">None</span>, dauer, <span class="va">None</span></span>
+<span id="cb84-95"><a href="#cb84-95" aria-hidden="true" tabindex="-1"></a>    plan <span class="op">=</span> <span class="bu">tuple</span>(loeser.Value(plaene[a, g].start)</span>
+<span id="cb84-96"><a href="#cb84-96" aria-hidden="true" tabindex="-1"></a>                 <span class="cf">for</span> a, auftrag <span class="kw">in</span> <span class="bu">enumerate</span>(auftraege)</span>
+<span id="cb84-97"><a href="#cb84-97" aria-hidden="true" tabindex="-1"></a>                 <span class="cf">for</span> g <span class="kw">in</span> <span class="bu">range</span>(<span class="bu">len</span>(auftrag)))</span>
+<span id="cb84-98"><a href="#cb84-98" aria-hidden="true" tabindex="-1"></a>    <span class="cf">return</span> loeser.StatusName(status), <span class="bu">int</span>(loeser.ObjectiveValue()), dauer, plan</span>
+<span id="cb84-99"><a href="#cb84-99" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb84-100"><a href="#cb84-100" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb84-101"><a href="#cb84-101" aria-hidden="true" tabindex="-1"></a><span class="cf">if</span> <span class="va">__name__</span> <span class="op">==</span> <span class="st">&quot;__main__&quot;</span>:</span>
+<span id="cb84-102"><a href="#cb84-102" aria-hidden="true" tabindex="-1"></a>    auftraege <span class="op">=</span> baue_instanz()</span>
+<span id="cb84-103"><a href="#cb84-103" aria-hidden="true" tabindex="-1"></a>    gaenge <span class="op">=</span> <span class="bu">sum</span>(<span class="bu">len</span>(a) <span class="cf">for</span> a <span class="kw">in</span> auftraege)</span>
+<span id="cb84-104"><a href="#cb84-104" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb84-105"><a href="#cb84-105" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;=&quot;</span> <span class="op">*</span> <span class="dv">78</span>)</span>
+<span id="cb84-106"><a href="#cb84-106" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;  WAS MEHRERE ARBEITER WIRKLICH BRINGEN&quot;</span>)</span>
+<span id="cb84-107"><a href="#cb84-107" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;=&quot;</span> <span class="op">*</span> <span class="dv">78</span>)</span>
+<span id="cb84-108"><a href="#cb84-108" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;Job-Shop: </span><span class="sc">{</span>AUFTRAEGE<span class="sc">}</span><span class="ss"> Auftraege, </span><span class="sc">{</span>MASCHINEN<span class="sc">}</span><span class="ss"> Maschinen, &quot;</span></span>
+<span id="cb84-109"><a href="#cb84-109" aria-hidden="true" tabindex="-1"></a>          <span class="ss">f&quot;</span><span class="sc">{</span>gaenge<span class="sc">}</span><span class="ss"> Arbeitsgaenge.&quot;</span>)</span>
+<span id="cb84-110"><a href="#cb84-110" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;random_seed = </span><span class="sc">{</span>SOLVER_SEED<span class="sc">}</span><span class="ss"> in JEDEM Lauf, &quot;</span></span>
+<span id="cb84-111"><a href="#cb84-111" aria-hidden="true" tabindex="-1"></a>          <span class="ss">f&quot;</span><span class="sc">{</span>WIEDERHOLUNGEN<span class="sc">}</span><span class="ss"> Wiederholungen je Arbeiterzahl.</span><span class="ch">\n</span><span class="ss">&quot;</span>)</span>
+<span id="cb84-112"><a href="#cb84-112" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb84-113"><a href="#cb84-113" aria-hidden="true" tabindex="-1"></a>    <span class="co"># Jede Konfiguration mehrfach - ein einzelner Zeitwert sagt nichts.</span></span>
+<span id="cb84-114"><a href="#cb84-114" aria-hidden="true" tabindex="-1"></a>    ergebnisse: <span class="bu">dict</span>[<span class="bu">int</span>, <span class="bu">list</span>[<span class="bu">tuple</span>]] <span class="op">=</span> {}</span>
+<span id="cb84-115"><a href="#cb84-115" aria-hidden="true" tabindex="-1"></a>    <span class="cf">for</span> arbeiter <span class="kw">in</span> ARBEITERZAHLEN:</span>
+<span id="cb84-116"><a href="#cb84-116" aria-hidden="true" tabindex="-1"></a>        ergebnisse[arbeiter] <span class="op">=</span> [loese(auftraege, arbeiter)</span>
+<span id="cb84-117"><a href="#cb84-117" aria-hidden="true" tabindex="-1"></a>                                <span class="cf">for</span> _ <span class="kw">in</span> <span class="bu">range</span>(WIEDERHOLUNGEN)]</span>
+<span id="cb84-118"><a href="#cb84-118" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb84-119"><a href="#cb84-119" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;=&quot;</span> <span class="op">*</span> <span class="dv">78</span>)</span>
+<span id="cb84-120"><a href="#cb84-120" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;  (1) Laufzeit: was die Arbeiter bringen&quot;</span>)</span>
+<span id="cb84-121"><a href="#cb84-121" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;=&quot;</span> <span class="op">*</span> <span class="dv">78</span>)</span>
+<span id="cb84-122"><a href="#cb84-122" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;</span><span class="sc">{</span><span class="st">&#39;Arbeiter&#39;</span><span class="sc">:&gt;9}</span><span class="ss"> </span><span class="sc">{</span><span class="st">&#39;Status&#39;</span><span class="sc">:&gt;9}</span><span class="ss"> </span><span class="sc">{</span><span class="st">&#39;Makespan&#39;</span><span class="sc">:&gt;9}</span><span class="ss"> &quot;</span></span>
+<span id="cb84-123"><a href="#cb84-123" aria-hidden="true" tabindex="-1"></a>          <span class="ss">f&quot;</span><span class="sc">{</span><span class="st">&#39;schnellste&#39;</span><span class="sc">:&gt;11}</span><span class="ss"> </span><span class="sc">{</span><span class="st">&#39;langsamste&#39;</span><span class="sc">:&gt;11}</span><span class="ss"> </span><span class="sc">{</span><span class="st">&#39;Beschleunigung&#39;</span><span class="sc">:&gt;15}</span><span class="ss">&quot;</span>)</span>
+<span id="cb84-124"><a href="#cb84-124" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;-&quot;</span> <span class="op">*</span> <span class="dv">78</span>)</span>
+<span id="cb84-125"><a href="#cb84-125" aria-hidden="true" tabindex="-1"></a>    basis_zeit <span class="op">=</span> <span class="bu">min</span>(d <span class="cf">for</span> _, _, d, _ <span class="kw">in</span> ergebnisse[<span class="dv">1</span>])</span>
+<span id="cb84-126"><a href="#cb84-126" aria-hidden="true" tabindex="-1"></a>    <span class="cf">for</span> arbeiter <span class="kw">in</span> ARBEITERZAHLEN:</span>
+<span id="cb84-127"><a href="#cb84-127" aria-hidden="true" tabindex="-1"></a>        laeufe <span class="op">=</span> ergebnisse[arbeiter]</span>
+<span id="cb84-128"><a href="#cb84-128" aria-hidden="true" tabindex="-1"></a>        zeiten <span class="op">=</span> [d <span class="cf">for</span> _, _, d, _ <span class="kw">in</span> laeufe]</span>
+<span id="cb84-129"><a href="#cb84-129" aria-hidden="true" tabindex="-1"></a>        ziele <span class="op">=</span> {o <span class="cf">for</span> _, o, _, _ <span class="kw">in</span> laeufe}</span>
+<span id="cb84-130"><a href="#cb84-130" aria-hidden="true" tabindex="-1"></a>        status <span class="op">=</span> {s <span class="cf">for</span> s, _, _, _ <span class="kw">in</span> laeufe}</span>
+<span id="cb84-131"><a href="#cb84-131" aria-hidden="true" tabindex="-1"></a>        <span class="bu">print</span>(<span class="ss">f&quot;</span><span class="sc">{</span>arbeiter<span class="sc">:&gt;9}</span><span class="ss"> </span><span class="sc">{</span><span class="st">&#39;/&#39;</span><span class="sc">.</span>join(<span class="bu">sorted</span>(status))<span class="sc">:&gt;9}</span><span class="ss"> &quot;</span></span>
+<span id="cb84-132"><a href="#cb84-132" aria-hidden="true" tabindex="-1"></a>              <span class="ss">f&quot;</span><span class="sc">{</span><span class="st">&#39;/&#39;</span><span class="sc">.</span>join(<span class="bu">str</span>(z) <span class="cf">for</span> z <span class="kw">in</span> <span class="bu">sorted</span>(ziele))<span class="sc">:&gt;9}</span><span class="ss"> &quot;</span></span>
+<span id="cb84-133"><a href="#cb84-133" aria-hidden="true" tabindex="-1"></a>              <span class="ss">f&quot;</span><span class="sc">{</span><span class="bu">min</span>(zeiten)<span class="sc">:&gt;10.2f}</span><span class="ss">s </span><span class="sc">{</span><span class="bu">max</span>(zeiten)<span class="sc">:&gt;10.2f}</span><span class="ss">s &quot;</span></span>
+<span id="cb84-134"><a href="#cb84-134" aria-hidden="true" tabindex="-1"></a>              <span class="ss">f&quot;</span><span class="sc">{</span>basis_zeit <span class="op">/</span> <span class="bu">min</span>(zeiten)<span class="sc">:&gt;14.1f}</span><span class="ss">x&quot;</span>)</span>
+<span id="cb84-135"><a href="#cb84-135" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb84-136"><a href="#cb84-136" aria-hidden="true" tabindex="-1"></a>    beste <span class="op">=</span> <span class="bu">min</span>(ARBEITERZAHLEN, key<span class="op">=</span><span class="kw">lambda</span> w: <span class="bu">min</span>(d <span class="cf">for</span> _, _, d, _ <span class="kw">in</span> ergebnisse[w]))</span>
+<span id="cb84-137"><a href="#cb84-137" aria-hidden="true" tabindex="-1"></a>    faktor <span class="op">=</span> basis_zeit <span class="op">/</span> <span class="bu">min</span>(d <span class="cf">for</span> _, _, d, _ <span class="kw">in</span> ergebnisse[beste])</span>
+<span id="cb84-138"><a href="#cb84-138" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;</span><span class="ch">\n</span><span class="ss">  Am schnellsten sind </span><span class="sc">{</span>beste<span class="sc">}</span><span class="ss"> Arbeiter: Faktor </span><span class="sc">{</span>faktor<span class="sc">:.1f}</span><span class="ss"> gegenueber&quot;</span>)</span>
+<span id="cb84-139"><a href="#cb84-139" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;  einem einzigen - also MEHR, als </span><span class="sc">{</span>beste<span class="sc">}</span><span class="ss"> Kerne hergeben sollten.&quot;</span>)</span>
+<span id="cb84-140"><a href="#cb84-140" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;  Das ist kein Messfehler. CP-SAT laesst nicht </span><span class="sc">{</span>beste<span class="sc">}</span><span class="ss">-mal dieselbe Suche&quot;</span>)</span>
+<span id="cb84-141"><a href="#cb84-141" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;  laufen, sondern verschiedene Strategien nebeneinander, die einander&quot;</span>)</span>
+<span id="cb84-142"><a href="#cb84-142" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;  ihre Schranken zurufen. Der zweite Arbeiter ist deshalb nicht der&quot;</span>)</span>
+<span id="cb84-143"><a href="#cb84-143" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;  &#39;zweite Kern&#39;, sondern ein anderes Verfahren.&quot;</span>)</span>
+<span id="cb84-144"><a href="#cb84-144" aria-hidden="true" tabindex="-1"></a>    letzte <span class="op">=</span> ARBEITERZAHLEN[<span class="op">-</span><span class="dv">1</span>]</span>
+<span id="cb84-145"><a href="#cb84-145" aria-hidden="true" tabindex="-1"></a>    <span class="cf">if</span> beste <span class="op">!=</span> letzte:</span>
+<span id="cb84-146"><a href="#cb84-146" aria-hidden="true" tabindex="-1"></a>        zeit_letzte <span class="op">=</span> <span class="bu">min</span>(d <span class="cf">for</span> _, _, d, _ <span class="kw">in</span> ergebnisse[letzte])</span>
+<span id="cb84-147"><a href="#cb84-147" aria-hidden="true" tabindex="-1"></a>        <span class="bu">print</span>(<span class="ss">f&quot;</span><span class="ch">\n</span><span class="ss">  Und mehr ist nicht immer besser: </span><span class="sc">{</span>letzte<span class="sc">}</span><span class="ss"> Arbeiter brauchen &quot;</span></span>
+<span id="cb84-148"><a href="#cb84-148" aria-hidden="true" tabindex="-1"></a>              <span class="ss">f&quot;</span><span class="sc">{</span>zeit_letzte<span class="sc">:.2f}</span><span class="ss">s&quot;</span>)</span>
+<span id="cb84-149"><a href="#cb84-149" aria-hidden="true" tabindex="-1"></a>        <span class="bu">print</span>(<span class="ss">f&quot;  gegenueber </span><span class="sc">{</span><span class="bu">min</span>(d <span class="cf">for</span> _, _, d, _ <span class="kw">in</span> ergebnisse[beste])<span class="sc">:.2f}</span><span class="ss">s bei &quot;</span></span>
+<span id="cb84-150"><a href="#cb84-150" aria-hidden="true" tabindex="-1"></a>              <span class="ss">f&quot;</span><span class="sc">{</span>beste<span class="sc">}</span><span class="ss">. Ab einer gewissen Zahl kosten Abstimmung&quot;</span>)</span>
+<span id="cb84-151"><a href="#cb84-151" aria-hidden="true" tabindex="-1"></a>        <span class="bu">print</span>(<span class="st">&quot;  und Speicherbandbreite mehr, als ein weiterer Suchstrang einbringt.&quot;</span>)</span>
+<span id="cb84-152"><a href="#cb84-152" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb84-153"><a href="#cb84-153" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;</span><span class="ch">\n</span><span class="st">&quot;</span> <span class="op">+</span> <span class="st">&quot;=&quot;</span> <span class="op">*</span> <span class="dv">78</span>)</span>
+<span id="cb84-154"><a href="#cb84-154" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;  (2) Reproduzierbarkeit: derselbe Seed, derselbe Plan?&quot;</span>)</span>
+<span id="cb84-155"><a href="#cb84-155" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;=&quot;</span> <span class="op">*</span> <span class="dv">78</span>)</span>
+<span id="cb84-156"><a href="#cb84-156" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;</span><span class="sc">{</span><span class="st">&#39;Arbeiter&#39;</span><span class="sc">:&gt;9}</span><span class="ss"> </span><span class="sc">{</span><span class="st">&#39;Laeufe&#39;</span><span class="sc">:&gt;7}</span><span class="ss"> </span><span class="sc">{</span><span class="st">&#39;verschiedene Plaene&#39;</span><span class="sc">:&gt;21}</span><span class="ss"> &quot;</span></span>
+<span id="cb84-157"><a href="#cb84-157" aria-hidden="true" tabindex="-1"></a>          <span class="ss">f&quot;</span><span class="sc">{</span><span class="st">&#39;Makespan&#39;</span><span class="sc">:&gt;10}</span><span class="ss">&quot;</span>)</span>
+<span id="cb84-158"><a href="#cb84-158" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;-&quot;</span> <span class="op">*</span> <span class="dv">78</span>)</span>
+<span id="cb84-159"><a href="#cb84-159" aria-hidden="true" tabindex="-1"></a>    <span class="cf">for</span> arbeiter <span class="kw">in</span> ARBEITERZAHLEN:</span>
+<span id="cb84-160"><a href="#cb84-160" aria-hidden="true" tabindex="-1"></a>        plaene <span class="op">=</span> {p <span class="cf">for</span> _, _, _, p <span class="kw">in</span> ergebnisse[arbeiter] <span class="cf">if</span> p <span class="kw">is</span> <span class="kw">not</span> <span class="va">None</span>}</span>
+<span id="cb84-161"><a href="#cb84-161" aria-hidden="true" tabindex="-1"></a>        ziele <span class="op">=</span> {o <span class="cf">for</span> _, o, _, _ <span class="kw">in</span> ergebnisse[arbeiter]}</span>
+<span id="cb84-162"><a href="#cb84-162" aria-hidden="true" tabindex="-1"></a>        <span class="bu">print</span>(<span class="ss">f&quot;</span><span class="sc">{</span>arbeiter<span class="sc">:&gt;9}</span><span class="ss"> </span><span class="sc">{</span>WIEDERHOLUNGEN<span class="sc">:&gt;7}</span><span class="ss"> </span><span class="sc">{</span><span class="bu">len</span>(plaene)<span class="sc">:&gt;21}</span><span class="ss"> &quot;</span></span>
+<span id="cb84-163"><a href="#cb84-163" aria-hidden="true" tabindex="-1"></a>              <span class="ss">f&quot;</span><span class="sc">{</span><span class="st">&#39;/&#39;</span><span class="sc">.</span>join(<span class="bu">str</span>(z) <span class="cf">for</span> z <span class="kw">in</span> <span class="bu">sorted</span>(ziele))<span class="sc">:&gt;10}</span><span class="ss">&quot;</span>)</span>
+<span id="cb84-164"><a href="#cb84-164" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb84-165"><a href="#cb84-165" aria-hidden="true" tabindex="-1"></a>    einer <span class="op">=</span> <span class="bu">len</span>({p <span class="cf">for</span> _, _, _, p <span class="kw">in</span> ergebnisse[<span class="dv">1</span>]})</span>
+<span id="cb84-166"><a href="#cb84-166" aria-hidden="true" tabindex="-1"></a>    <span class="co"># Ab welcher Arbeiterzahl bricht die Reproduzierbarkeit? Das ist die</span></span>
+<span id="cb84-167"><a href="#cb84-167" aria-hidden="true" tabindex="-1"></a>    <span class="co"># eigentliche Zahl - nicht, was acht Arbeiter anrichten.</span></span>
+<span id="cb84-168"><a href="#cb84-168" aria-hidden="true" tabindex="-1"></a>    ab <span class="op">=</span> <span class="bu">next</span>((w <span class="cf">for</span> w <span class="kw">in</span> ARBEITERZAHLEN</span>
+<span id="cb84-169"><a href="#cb84-169" aria-hidden="true" tabindex="-1"></a>               <span class="cf">if</span> <span class="bu">len</span>({p <span class="cf">for</span> _, _, _, p <span class="kw">in</span> ergebnisse[w]}) <span class="op">&gt;</span> <span class="dv">1</span>), <span class="va">None</span>)</span>
+<span id="cb84-170"><a href="#cb84-170" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;</span><span class="ch">\n</span><span class="ss">  Mit einem Arbeiter: </span><span class="sc">{</span>einer<span class="sc">}</span><span class="ss"> Plan aus </span><span class="sc">{</span>WIEDERHOLUNGEN<span class="sc">}</span><span class="ss"> Laeufen.&quot;</span>)</span>
+<span id="cb84-171"><a href="#cb84-171" aria-hidden="true" tabindex="-1"></a>    <span class="cf">if</span> ab <span class="kw">is</span> <span class="kw">not</span> <span class="va">None</span>:</span>
+<span id="cb84-172"><a href="#cb84-172" aria-hidden="true" tabindex="-1"></a>        viele <span class="op">=</span> <span class="bu">len</span>({p <span class="cf">for</span> _, _, _, p <span class="kw">in</span> ergebnisse[ab]})</span>
+<span id="cb84-173"><a href="#cb84-173" aria-hidden="true" tabindex="-1"></a>        <span class="bu">print</span>(<span class="ss">f&quot;  Schon mit </span><span class="sc">{</span>ab<span class="sc">}</span><span class="ss"> Arbeitern: </span><span class="sc">{</span>viele<span class="sc">}</span><span class="ss"> verschiedene Plaene aus &quot;</span></span>
+<span id="cb84-174"><a href="#cb84-174" aria-hidden="true" tabindex="-1"></a>              <span class="ss">f&quot;</span><span class="sc">{</span>WIEDERHOLUNGEN<span class="sc">}</span><span class="ss"> Laeufen -&quot;</span>)</span>
+<span id="cb84-175"><a href="#cb84-175" aria-hidden="true" tabindex="-1"></a>        <span class="bu">print</span>(<span class="st">&quot;  bei identischem random_seed und identischem Zielwert.&quot;</span>)</span>
+<span id="cb84-176"><a href="#cb84-176" aria-hidden="true" tabindex="-1"></a>        <span class="bu">print</span>(<span class="ss">f&quot;  Es braucht also keine acht Arbeiter, um die Reproduzierbarkeit&quot;</span>)</span>
+<span id="cb84-177"><a href="#cb84-177" aria-hidden="true" tabindex="-1"></a>        <span class="bu">print</span>(<span class="ss">f&quot;  zu verlieren. </span><span class="sc">{</span>ab<span class="sc">}</span><span class="ss"> genuegen.&quot;</span>)</span>
+<span id="cb84-178"><a href="#cb84-178" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;</span><span class="ch">\n</span><span class="st">  Der Seed allein macht einen Lauf also NICHT reproduzierbar. Er legt&quot;</span>)</span>
+<span id="cb84-179"><a href="#cb84-179" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;  fest, wie ein einzelner Suchstrang wuerfelt - nicht, welcher von&quot;</span>)</span>
+<span id="cb84-180"><a href="#cb84-180" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;  mehreren zuerst fertig wird. Das entscheidet die Uhr.&quot;</span>)</span>
+<span id="cb84-181"><a href="#cb84-181" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb84-182"><a href="#cb84-182" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;</span><span class="ch">\n</span><span class="st">&quot;</span> <span class="op">+</span> <span class="st">&quot;=&quot;</span> <span class="op">*</span> <span class="dv">78</span>)</span>
+<span id="cb84-183"><a href="#cb84-183" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;  (3) Was daraus fuer Tests folgt&quot;</span>)</span>
+<span id="cb84-184"><a href="#cb84-184" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;=&quot;</span> <span class="op">*</span> <span class="dv">78</span>)</span>
+<span id="cb84-185"><a href="#cb84-185" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;  Ein Test der Form  assert plan == erwarteter_plan  besteht mal und&quot;</span>)</span>
+<span id="cb84-186"><a href="#cb84-186" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;  scheitert mal, ohne dass sich am Code etwas geaendert haette.&quot;</span>)</span>
+<span id="cb84-187"><a href="#cb84-187" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;  Zu pruefen sind stattdessen:&quot;</span>)</span>
+<span id="cb84-188"><a href="#cb84-188" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;    * der ZIELWERT (hier in allen Laeufen gleich),&quot;</span>)</span>
+<span id="cb84-189"><a href="#cb84-189" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;    * die Einhaltung aller Regeln (Abnahmepruefung, Kapitel Praxisfallen),&quot;</span>)</span>
+<span id="cb84-190"><a href="#cb84-190" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;    * und der Status - nicht die Gestalt der Loesung.&quot;</span>)</span>
+<span id="cb84-191"><a href="#cb84-191" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;</span><span class="ch">\n</span><span class="st">  Wer doch einen bestimmten Plan braucht - fuer eine abgedruckte&quot;</span>)</span>
+<span id="cb84-192"><a href="#cb84-192" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;  Ausgabe, fuer einen Regressionstest -, setzt num_workers = 1.&quot;</span>)</span>
+<span id="cb84-193"><a href="#cb84-193" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;  Das kostet hier den Faktor </span><span class="sc">{</span>faktor<span class="sc">:.1f}</span><span class="ss"> an Laufzeit und ist genau&quot;</span>)</span>
+<span id="cb84-194"><a href="#cb84-194" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;  deshalb eine Entscheidung fuer den Test, nicht fuer den Betrieb.&quot;</span>)</span>
+<span id="cb84-195"><a href="#cb84-195" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;=&quot;</span> <span class="op">*</span> <span class="dv">78</span>)</span></code></pre></div>
+<p><strong>Erwartete Ausgabe</strong> (Laufzeiten <em>und</em> die Zahl der verschiedenen Pläne sind hardwareabhängig — genau das ist die Aussage; der Zielwert ist es nicht):</p>
+<pre><code>==============================================================================
+  WAS MEHRERE ARBEITER WIRKLICH BRINGEN
+==============================================================================
+Job-Shop: 12 Auftraege, 10 Maschinen, 120 Arbeitsgaenge.
+random_seed = 1 in JEDEM Lauf, 4 Wiederholungen je Arbeiterzahl.
+
+==============================================================================
+  (1) Laufzeit: was die Arbeiter bringen
+==============================================================================
+ Arbeiter    Status  Makespan  schnellste  langsamste  Beschleunigung
+------------------------------------------------------------------------------
+        1   OPTIMAL       183       5.62s       5.82s            1.0x
+        2   OPTIMAL       183       1.43s       2.04s            3.9x
+        4   OPTIMAL       183       0.60s       0.66s            9.4x
+        8   OPTIMAL       183       0.46s       0.65s           12.3x
+
+  Am schnellsten sind 8 Arbeiter: Faktor 12.3 gegenueber
+  einem einzigen - also MEHR, als 8 Kerne hergeben sollten.
+  Das ist kein Messfehler. CP-SAT laesst nicht 8-mal dieselbe Suche
+  laufen, sondern verschiedene Strategien nebeneinander, die einander
+  ihre Schranken zurufen. Der zweite Arbeiter ist deshalb nicht der
+  &#39;zweite Kern&#39;, sondern ein anderes Verfahren.
+
+==============================================================================
+  (2) Reproduzierbarkeit: derselbe Seed, derselbe Plan?
+==============================================================================
+ Arbeiter  Laeufe   verschiedene Plaene   Makespan
+------------------------------------------------------------------------------
+        1       4                     1        183
+        2       4                     3        183
+        4       4                     3        183
+        8       4                     4        183
+
+  Mit einem Arbeiter: 1 Plan aus 4 Laeufen.
+  Schon mit 2 Arbeitern: 3 verschiedene Plaene aus 4 Laeufen -
+  bei identischem random_seed und identischem Zielwert.
+  Es braucht also keine acht Arbeiter, um die Reproduzierbarkeit
+  zu verlieren. 2 genuegen.
+
+  Der Seed allein macht einen Lauf also NICHT reproduzierbar. Er legt
+  fest, wie ein einzelner Suchstrang wuerfelt - nicht, welcher von
+  mehreren zuerst fertig wird. Das entscheidet die Uhr.
+
+==============================================================================
+  (3) Was daraus fuer Tests folgt
+==============================================================================
+  Ein Test der Form  assert plan == erwarteter_plan  besteht mal und
+  scheitert mal, ohne dass sich am Code etwas geaendert haette.
+  Zu pruefen sind stattdessen:
+    * der ZIELWERT (hier in allen Laeufen gleich),
+    * die Einhaltung aller Regeln (Abnahmepruefung, Kapitel Praxisfallen),
+    * und der Status - nicht die Gestalt der Loesung.
+
+  Wer doch einen bestimmten Plan braucht - fuer eine abgedruckte
+  Ausgabe, fuer einen Regressionstest -, setzt num_workers = 1.
+  Das kostet hier den Faktor 12.3 an Laufzeit und ist genau
+  deshalb eine Entscheidung fuer den Test, nicht fuer den Betrieb.
+==============================================================================</code></pre>
+<h3 id="was-die-messung-zeigt">Was die Messung zeigt</h3>
+<p><strong>Erstens: Die Beschleunigung ist überlinear.</strong> Acht Arbeiter sind im abgedruckten Lauf nicht achtmal, sondern <strong>gut zwölfmal</strong> schneller als einer. Das sieht nach Messfehler aus, ist aber die korrekte Beschreibung dessen, was CP-SAT tut: Es lässt <strong>nicht</strong> achtmal dieselbe Suche auf verschiedenen Kernen laufen, sondern <strong>verschiedene Strategien nebeneinander</strong> — Suche mit LP-Relaxation, Suche mit anderen Verzweigungsregeln, lokale Suche —, und die teilen einander ihre Schranken mit. Der zweite Arbeiter ist deshalb nicht „der zweite Kern“, sondern ein anderes Verfahren, das zufällig auch rechnet.</p>
+<p>Daraus folgt zweierlei. Ein Speedup über der Kernzahl ist bei CP-SAT normal und kein Grund zum Misstrauen. Und der Zugewinn flacht ab: Zwischen vier und acht Arbeitern lag in unseren Wiederholungen mal das eine, mal das andere vorn — ab einer gewissen Zahl kosten Abstimmung und Speicherbandbreite mehr, als ein weiterer Suchstrang einbringt. Auch hier gilt: messen, nicht schätzen.</p>
+<p><strong>Zweitens — und das ist der Befund, der die Testpraxis bestimmt: Der Seed genügt nicht.</strong> Bei einem Arbeiter liefern vier Läufe <strong>einen</strong> Plan. Schon bei <strong>zwei</strong> Arbeitern liefern vier Läufe <strong>drei verschiedene</strong> — bei identischem <code>random_seed</code> und identischem Zielwert 183.</p>
+<p>Es braucht also keine acht Arbeiter, um die Reproduzierbarkeit zu verlieren. Zwei genügen. Der Grund ist einfach, sobald man ihn ausspricht: Der Seed legt fest, wie ein <strong>einzelner</strong> Suchstrang würfelt. Er legt nicht fest, <strong>welcher von mehreren zuerst fertig wird</strong> — das entscheidet die Uhr, und die ist bei jedem Lauf anders.</p>
+<blockquote>
+<p><strong>⚠️ <code>random_seed</code> allein macht nichts reproduzierbar</strong> Ein häufiger Irrtum: „Ich habe doch einen Seed gesetzt.“ Für einen Zufallsgenerator stimmt das. Für einen <strong>parallelen</strong> Solver nicht — dort ist die zweite Zufallsquelle die Ausführungsreihenfolge, und die lässt sich nicht mit einem Parameter festnageln. Reproduzierbar wird der Lauf erst mit <code>num_workers = 1</code> <strong>und</strong> Seed. Wer nur eines von beidem setzt, hat einen Test, der gelegentlich grundlos rot wird.</p>
+</blockquote>
+<h3 id="was-daraus-für-tests-folgt">Was daraus für Tests folgt</h3>
+<p>Der Zielwert war in <strong>allen</strong> sechzehn Läufen derselbe: 183. Die Gestalt der Lösung war es nicht. Genau daran entscheidet sich, was ein Test prüfen darf:</p>
+<table>
+<colgroup>
+<col style="width: 50%" />
+<col style="width: 50%" />
+</colgroup>
+<thead>
+<tr class="header">
+<th>Prüfen</th>
+<th>Nicht prüfen</th>
+</tr>
+</thead>
+<tbody>
+<tr class="odd">
+<td>den <strong>Zielwert</strong> — er ist eindeutig, wenn das Modell optimal gelöst wurde</td>
+<td>die <strong>Gestalt</strong> des Plans (<code>assert plan == erwarteter_plan</code>)</td>
+</tr>
+<tr class="even">
+<td>die <strong>Einhaltung aller Regeln</strong> über eine Abnahmeprüfung (<a href="#sec:praxisfallen-or-kern">Abschnitt 22.6</a>)</td>
+<td>die Reihenfolge, in der gleichwertige Aufträge zugewiesen wurden</td>
+</tr>
+<tr class="odd">
+<td>den <strong>Status</strong> (<code>OPTIMAL</code>, <code>FEASIBLE</code>, <code>INFEASIBLE</code>)</td>
+<td>die Laufzeit als feste Zahl</td>
+</tr>
+</tbody>
+</table>
+<p>Wer doch einen bestimmten Plan braucht — für eine abgedruckte Ausgabe, für einen Regressionstest —, setzt <code>num_workers = 1</code>. Das kostet hier den Faktor 12 an Laufzeit, und genau deshalb ist es eine Entscheidung <strong>für den Test</strong>, nicht für den Betrieb. In Produktion lässt man beide Parameter auf ihren Standardwerten.</p>
+<blockquote>
+<p><strong>🎯 Merksatz</strong> Ein paralleler Solver hat zwei Zufallsquellen: den Seed und die Uhr. Nur die erste lässt sich setzen. Wer Reproduzierbarkeit braucht, muss die zweite abschalten — und das heißt <code>num_workers = 1</code>.</p>
+</blockquote>
+<hr />
+<h2 id="sec:cpsat-statusfaelle">7.8 Die fünf Antworten von CP-SAT</h2>
 <p><a href="#sec:milp-gap">Abschnitt 6.8</a> hat gezeigt, warum <code>OPTIMAL</code> bei ganzzahligen Problemen nicht der Normalfall ist. Bei CP-SAT kommt eine Besonderheit hinzu: Es gibt <strong>fünf</strong> verschiedene Antworten, und drei davon werden regelmäßig verwechselt.</p>
 <table>
 <colgroup>
@@ -11397,229 +12138,229 @@ Erreichter Makespan: 11
 </blockquote>
 <p>Und <code>MODEL_INVALID</code> ist von beiden nochmals verschieden: Es ist immer ein <strong>Programmierfehler</strong>, kein fachliches Problem. Der klassische Fall ist eine Variable mit leerem Wertebereich — <code>NewIntVar(mindestbesetzung, kapazitaet, ...)</code>, wobei die Daten vertauscht ankamen und die untere Schranke über der oberen liegt.</p>
 <p>Das folgende Programm erzeugt jeden Fall absichtlich und zeigt die passende Auswertung.</p>
-<div class="sourceCode" id="cb84"><pre class="sourceCode python"><code class="sourceCode python"><span id="cb84-1"><a href="#cb84-1" aria-hidden="true" tabindex="-1"></a><span class="co">#!/usr/bin/env python3</span></span>
-<span id="cb84-2"><a href="#cb84-2" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb84-3"><a href="#cb84-3" aria-hidden="true" tabindex="-1"></a><span class="co"># CP_SAT_Statusfaelle.py</span></span>
-<span id="cb84-4"><a href="#cb84-4" aria-hidden="true" tabindex="-1"></a><span class="co">&quot;&quot;&quot;</span></span>
-<span id="cb84-5"><a href="#cb84-5" aria-hidden="true" tabindex="-1"></a><span class="co">Kapitel CP-SAT: Alle fuenf Antworten von CP-SAT - und was jede bedeutet.</span></span>
-<span id="cb84-6"><a href="#cb84-6" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb84-7"><a href="#cb84-7" aria-hidden="true" tabindex="-1"></a><span class="co">Der haeufigste Fehler beim Einsatz von CP-SAT im Betrieb ist eine Zeile wie</span></span>
-<span id="cb84-8"><a href="#cb84-8" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb84-9"><a href="#cb84-9" aria-hidden="true" tabindex="-1"></a><span class="co">    if status == cp_model.OPTIMAL:</span></span>
-<span id="cb84-10"><a href="#cb84-10" aria-hidden="true" tabindex="-1"></a><span class="co">        ...verwerte die Loesung...</span></span>
-<span id="cb84-11"><a href="#cb84-11" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb84-12"><a href="#cb84-12" aria-hidden="true" tabindex="-1"></a><span class="co">Sie wirft in drei von fuenf Faellen etwas weg, das man haette gebrauchen</span></span>
-<span id="cb84-13"><a href="#cb84-13" aria-hidden="true" tabindex="-1"></a><span class="co">koennen, und verschweigt in einem weiteren Fall einen Modellierungsfehler.</span></span>
-<span id="cb84-14"><a href="#cb84-14" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb84-15"><a href="#cb84-15" aria-hidden="true" tabindex="-1"></a><span class="co">Dieses Programm erzeugt jeden Statusfall absichtlich und zeigt die passende</span></span>
-<span id="cb84-16"><a href="#cb84-16" aria-hidden="true" tabindex="-1"></a><span class="co">Reaktion:</span></span>
-<span id="cb84-17"><a href="#cb84-17" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb84-18"><a href="#cb84-18" aria-hidden="true" tabindex="-1"></a><span class="co">    OPTIMAL        beweisbar bestmoeglich          -&gt; ausfuehren</span></span>
-<span id="cb84-19"><a href="#cb84-19" aria-hidden="true" tabindex="-1"></a><span class="co">    FEASIBLE       zulaessig, Zeit war um          -&gt; Gap pruefen, dann entscheiden</span></span>
-<span id="cb84-20"><a href="#cb84-20" aria-hidden="true" tabindex="-1"></a><span class="co">    INFEASIBLE     kein Plan existiert             -&gt; harte Regeln lockern</span></span>
-<span id="cb84-21"><a href="#cb84-21" aria-hidden="true" tabindex="-1"></a><span class="co">    MODEL_INVALID  das Modell ist fehlerhaft       -&gt; Programmierfehler beheben</span></span>
-<span id="cb84-22"><a href="#cb84-22" aria-hidden="true" tabindex="-1"></a><span class="co">    UNKNOWN        nichts gefunden, Zeit war um    -&gt; mehr Zeit oder Heuristik</span></span>
-<span id="cb84-23"><a href="#cb84-23" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb84-24"><a href="#cb84-24" aria-hidden="true" tabindex="-1"></a><span class="co">Benoetigt: numpy, ortools</span></span>
-<span id="cb84-25"><a href="#cb84-25" aria-hidden="true" tabindex="-1"></a><span class="co">&quot;&quot;&quot;</span></span>
-<span id="cb84-26"><a href="#cb84-26" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb84-27"><a href="#cb84-27" aria-hidden="true" tabindex="-1"></a><span class="im">from</span> __future__ <span class="im">import</span> annotations</span>
-<span id="cb84-28"><a href="#cb84-28" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb84-29"><a href="#cb84-29" aria-hidden="true" tabindex="-1"></a><span class="im">from</span> dataclasses <span class="im">import</span> dataclass</span>
-<span id="cb84-30"><a href="#cb84-30" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb84-31"><a href="#cb84-31" aria-hidden="true" tabindex="-1"></a><span class="im">import</span> numpy <span class="im">as</span> np</span>
-<span id="cb84-32"><a href="#cb84-32" aria-hidden="true" tabindex="-1"></a><span class="im">from</span> ortools.sat.python <span class="im">import</span> cp_model</span>
-<span id="cb84-33"><a href="#cb84-33" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb84-34"><a href="#cb84-34" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb84-35"><a href="#cb84-35" aria-hidden="true" tabindex="-1"></a><span class="at">@dataclass</span></span>
-<span id="cb84-36"><a href="#cb84-36" aria-hidden="true" tabindex="-1"></a><span class="kw">class</span> Auswertung:</span>
-<span id="cb84-37"><a href="#cb84-37" aria-hidden="true" tabindex="-1"></a>    <span class="co">&quot;&quot;&quot;Was nach einem CP-SAT-Lauf tatsaechlich feststeht.&quot;&quot;&quot;</span></span>
-<span id="cb84-38"><a href="#cb84-38" aria-hidden="true" tabindex="-1"></a>    status: <span class="bu">str</span></span>
-<span id="cb84-39"><a href="#cb84-39" aria-hidden="true" tabindex="-1"></a>    hat_loesung: <span class="bu">bool</span></span>
-<span id="cb84-40"><a href="#cb84-40" aria-hidden="true" tabindex="-1"></a>    beweisbar_optimal: <span class="bu">bool</span></span>
-<span id="cb84-41"><a href="#cb84-41" aria-hidden="true" tabindex="-1"></a>    zielwert: <span class="bu">float</span> <span class="op">|</span> <span class="va">None</span></span>
-<span id="cb84-42"><a href="#cb84-42" aria-hidden="true" tabindex="-1"></a>    schranke: <span class="bu">float</span> <span class="op">|</span> <span class="va">None</span></span>
-<span id="cb84-43"><a href="#cb84-43" aria-hidden="true" tabindex="-1"></a>    gap: <span class="bu">float</span> <span class="op">|</span> <span class="va">None</span></span>
-<span id="cb84-44"><a href="#cb84-44" aria-hidden="true" tabindex="-1"></a>    empfehlung: <span class="bu">str</span></span>
-<span id="cb84-45"><a href="#cb84-45" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb84-46"><a href="#cb84-46" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb84-47"><a href="#cb84-47" aria-hidden="true" tabindex="-1"></a><span class="kw">def</span> werte_aus(loeser: cp_model.CpSolver, status: <span class="bu">int</span>,</span>
-<span id="cb84-48"><a href="#cb84-48" aria-hidden="true" tabindex="-1"></a>              mit_zielfunktion: <span class="bu">bool</span>) <span class="op">-&gt;</span> Auswertung:</span>
-<span id="cb84-49"><a href="#cb84-49" aria-hidden="true" tabindex="-1"></a>    <span class="co">&quot;&quot;&quot;Uebersetzt einen CP-SAT-Status in eine Handlungsempfehlung.</span></span>
-<span id="cb84-50"><a href="#cb84-50" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb84-51"><a href="#cb84-51" aria-hidden="true" tabindex="-1"></a><span class="co">    Genau diese Funktion fehlt in den meisten Projekten. Sie ist kurz, aber</span></span>
-<span id="cb84-52"><a href="#cb84-52" aria-hidden="true" tabindex="-1"></a><span class="co">    sie ist der Unterschied zwischen einem Prototyp und einem System, das</span></span>
-<span id="cb84-53"><a href="#cb84-53" aria-hidden="true" tabindex="-1"></a><span class="co">    nachts ohne Aufsicht laeuft.</span></span>
-<span id="cb84-54"><a href="#cb84-54" aria-hidden="true" tabindex="-1"></a><span class="co">    &quot;&quot;&quot;</span></span>
-<span id="cb84-55"><a href="#cb84-55" aria-hidden="true" tabindex="-1"></a>    name <span class="op">=</span> loeser.StatusName(status)</span>
-<span id="cb84-56"><a href="#cb84-56" aria-hidden="true" tabindex="-1"></a>    hat_loesung <span class="op">=</span> status <span class="kw">in</span> (cp_model.OPTIMAL, cp_model.FEASIBLE)</span>
-<span id="cb84-57"><a href="#cb84-57" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb84-58"><a href="#cb84-58" aria-hidden="true" tabindex="-1"></a>    zielwert <span class="op">=</span> schranke <span class="op">=</span> gap <span class="op">=</span> <span class="va">None</span></span>
-<span id="cb84-59"><a href="#cb84-59" aria-hidden="true" tabindex="-1"></a>    <span class="cf">if</span> hat_loesung <span class="kw">and</span> mit_zielfunktion:</span>
-<span id="cb84-60"><a href="#cb84-60" aria-hidden="true" tabindex="-1"></a>        zielwert <span class="op">=</span> loeser.ObjectiveValue()</span>
-<span id="cb84-61"><a href="#cb84-61" aria-hidden="true" tabindex="-1"></a>        schranke <span class="op">=</span> loeser.BestObjectiveBound()</span>
-<span id="cb84-62"><a href="#cb84-62" aria-hidden="true" tabindex="-1"></a>        nenner <span class="op">=</span> <span class="bu">max</span>(<span class="bu">abs</span>(zielwert), <span class="fl">1e-9</span>)</span>
-<span id="cb84-63"><a href="#cb84-63" aria-hidden="true" tabindex="-1"></a>        gap <span class="op">=</span> <span class="bu">abs</span>(zielwert <span class="op">-</span> schranke) <span class="op">/</span> nenner</span>
-<span id="cb84-64"><a href="#cb84-64" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb84-65"><a href="#cb84-65" aria-hidden="true" tabindex="-1"></a>    <span class="cf">if</span> status <span class="op">==</span> cp_model.OPTIMAL:</span>
-<span id="cb84-66"><a href="#cb84-66" aria-hidden="true" tabindex="-1"></a>        empfehlung <span class="op">=</span> <span class="st">&quot;Ausfuehren. Besser geht es nachweislich nicht.&quot;</span></span>
-<span id="cb84-67"><a href="#cb84-67" aria-hidden="true" tabindex="-1"></a>    <span class="cf">elif</span> status <span class="op">==</span> cp_model.FEASIBLE:</span>
-<span id="cb84-68"><a href="#cb84-68" aria-hidden="true" tabindex="-1"></a>        empfehlung <span class="op">=</span> (<span class="ss">f&quot;Brauchbar. Der Plan ist hoechstens </span><span class="sc">{</span>gap <span class="op">*</span> <span class="dv">100</span><span class="sc">:.2f}</span><span class="ss"> % &quot;</span></span>
-<span id="cb84-69"><a href="#cb84-69" aria-hidden="true" tabindex="-1"></a>                      <span class="ss">f&quot;schlechter als das theoretisch Bestmoegliche.&quot;</span></span>
-<span id="cb84-70"><a href="#cb84-70" aria-hidden="true" tabindex="-1"></a>                      <span class="cf">if</span> gap <span class="kw">is</span> <span class="kw">not</span> <span class="va">None</span> <span class="cf">else</span></span>
-<span id="cb84-71"><a href="#cb84-71" aria-hidden="true" tabindex="-1"></a>                      <span class="st">&quot;Brauchbar, aber nicht als optimal bewiesen.&quot;</span>)</span>
-<span id="cb84-72"><a href="#cb84-72" aria-hidden="true" tabindex="-1"></a>    <span class="cf">elif</span> status <span class="op">==</span> cp_model.INFEASIBLE:</span>
-<span id="cb84-73"><a href="#cb84-73" aria-hidden="true" tabindex="-1"></a>        empfehlung <span class="op">=</span> (<span class="st">&quot;KEIN Plan existiert. Das ist eine Aussage ueber Ihre &quot;</span></span>
-<span id="cb84-74"><a href="#cb84-74" aria-hidden="true" tabindex="-1"></a>                      <span class="st">&quot;harten Regeln, nicht ueber die Rechenzeit: Auch &quot;</span></span>
-<span id="cb84-75"><a href="#cb84-75" aria-hidden="true" tabindex="-1"></a>                      <span class="st">&quot;unendlich viel Zeit wuerde nichts aendern. Regeln &quot;</span></span>
-<span id="cb84-76"><a href="#cb84-76" aria-hidden="true" tabindex="-1"></a>                      <span class="st">&quot;lockern oder weich machen (Anhang C).&quot;</span>)</span>
-<span id="cb84-77"><a href="#cb84-77" aria-hidden="true" tabindex="-1"></a>    <span class="cf">elif</span> status <span class="op">==</span> cp_model.MODEL_INVALID:</span>
-<span id="cb84-78"><a href="#cb84-78" aria-hidden="true" tabindex="-1"></a>        empfehlung <span class="op">=</span> (<span class="st">&quot;Das MODELL ist fehlerhaft, nicht das Problem. &quot;</span></span>
-<span id="cb84-79"><a href="#cb84-79" aria-hidden="true" tabindex="-1"></a>                      <span class="st">&quot;Typisch: eine Variable mit leerem Wertebereich. &quot;</span></span>
-<span id="cb84-80"><a href="#cb84-80" aria-hidden="true" tabindex="-1"></a>                      <span class="st">&quot;model.Validate() nennt die Ursache.&quot;</span>)</span>
-<span id="cb84-81"><a href="#cb84-81" aria-hidden="true" tabindex="-1"></a>    <span class="cf">else</span>:                                    <span class="co"># UNKNOWN</span></span>
-<span id="cb84-82"><a href="#cb84-82" aria-hidden="true" tabindex="-1"></a>        empfehlung <span class="op">=</span> (<span class="st">&quot;Nichts gefunden - aber auch nicht widerlegt. Mehr Zeit &quot;</span></span>
-<span id="cb84-83"><a href="#cb84-83" aria-hidden="true" tabindex="-1"></a>                      <span class="st">&quot;geben, das Modell vereinfachen oder mit einer &quot;</span></span>
-<span id="cb84-84"><a href="#cb84-84" aria-hidden="true" tabindex="-1"></a>                      <span class="st">&quot;Heuristik vorbelegen (AddHint).&quot;</span>)</span>
-<span id="cb84-85"><a href="#cb84-85" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb84-86"><a href="#cb84-86" aria-hidden="true" tabindex="-1"></a>    <span class="cf">return</span> Auswertung(</span>
-<span id="cb84-87"><a href="#cb84-87" aria-hidden="true" tabindex="-1"></a>        status<span class="op">=</span>name,</span>
-<span id="cb84-88"><a href="#cb84-88" aria-hidden="true" tabindex="-1"></a>        hat_loesung<span class="op">=</span>hat_loesung,</span>
-<span id="cb84-89"><a href="#cb84-89" aria-hidden="true" tabindex="-1"></a>        beweisbar_optimal<span class="op">=</span>status <span class="op">==</span> cp_model.OPTIMAL,</span>
-<span id="cb84-90"><a href="#cb84-90" aria-hidden="true" tabindex="-1"></a>        zielwert<span class="op">=</span>zielwert, schranke<span class="op">=</span>schranke, gap<span class="op">=</span>gap,</span>
-<span id="cb84-91"><a href="#cb84-91" aria-hidden="true" tabindex="-1"></a>        empfehlung<span class="op">=</span>empfehlung,</span>
-<span id="cb84-92"><a href="#cb84-92" aria-hidden="true" tabindex="-1"></a>    )</span>
-<span id="cb84-93"><a href="#cb84-93" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb84-94"><a href="#cb84-94" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb84-95"><a href="#cb84-95" aria-hidden="true" tabindex="-1"></a><span class="kw">def</span> loese(baue, zeitlimit: <span class="bu">float</span>, mit_zielfunktion: <span class="bu">bool</span>) <span class="op">-&gt;</span> Auswertung:</span>
-<span id="cb84-96"><a href="#cb84-96" aria-hidden="true" tabindex="-1"></a>    modell <span class="op">=</span> cp_model.CpModel()</span>
-<span id="cb84-97"><a href="#cb84-97" aria-hidden="true" tabindex="-1"></a>    baue(modell)</span>
-<span id="cb84-98"><a href="#cb84-98" aria-hidden="true" tabindex="-1"></a>    loeser <span class="op">=</span> cp_model.CpSolver()</span>
-<span id="cb84-99"><a href="#cb84-99" aria-hidden="true" tabindex="-1"></a>    loeser.parameters.max_time_in_seconds <span class="op">=</span> zeitlimit</span>
-<span id="cb84-100"><a href="#cb84-100" aria-hidden="true" tabindex="-1"></a>    <span class="co"># Fuer reproduzierbare Buchausgaben; im Betrieb weglassen.</span></span>
-<span id="cb84-101"><a href="#cb84-101" aria-hidden="true" tabindex="-1"></a>    loeser.parameters.num_workers <span class="op">=</span> <span class="dv">1</span></span>
-<span id="cb84-102"><a href="#cb84-102" aria-hidden="true" tabindex="-1"></a>    loeser.parameters.random_seed <span class="op">=</span> <span class="dv">1</span></span>
-<span id="cb84-103"><a href="#cb84-103" aria-hidden="true" tabindex="-1"></a>    status <span class="op">=</span> loeser.Solve(modell)</span>
-<span id="cb84-104"><a href="#cb84-104" aria-hidden="true" tabindex="-1"></a>    <span class="cf">return</span> werte_aus(loeser, status, mit_zielfunktion)</span>
-<span id="cb84-105"><a href="#cb84-105" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb84-106"><a href="#cb84-106" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb84-107"><a href="#cb84-107" aria-hidden="true" tabindex="-1"></a><span class="co"># --- Die fuenf Faelle --------------------------------------------------------</span></span>
-<span id="cb84-108"><a href="#cb84-108" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb84-109"><a href="#cb84-109" aria-hidden="true" tabindex="-1"></a><span class="kw">def</span> dienstplan_loesbar(modell: cp_model.CpModel) <span class="op">-&gt;</span> <span class="va">None</span>:</span>
-<span id="cb84-110"><a href="#cb84-110" aria-hidden="true" tabindex="-1"></a>    <span class="co">&quot;&quot;&quot;Vier Personen, fuenf Dienste, hoechstens zwei je Person - loesbar.&quot;&quot;&quot;</span></span>
-<span id="cb84-111"><a href="#cb84-111" aria-hidden="true" tabindex="-1"></a>    personen, dienste <span class="op">=</span> <span class="dv">4</span>, <span class="dv">5</span></span>
-<span id="cb84-112"><a href="#cb84-112" aria-hidden="true" tabindex="-1"></a>    x <span class="op">=</span> [[modell.NewBoolVar(<span class="ss">f&quot;x_</span><span class="sc">{</span>i<span class="sc">}</span><span class="ss">_</span><span class="sc">{</span>j<span class="sc">}</span><span class="ss">&quot;</span>) <span class="cf">for</span> j <span class="kw">in</span> <span class="bu">range</span>(dienste)]</span>
-<span id="cb84-113"><a href="#cb84-113" aria-hidden="true" tabindex="-1"></a>         <span class="cf">for</span> i <span class="kw">in</span> <span class="bu">range</span>(personen)]</span>
-<span id="cb84-114"><a href="#cb84-114" aria-hidden="true" tabindex="-1"></a>    <span class="cf">for</span> j <span class="kw">in</span> <span class="bu">range</span>(dienste):</span>
-<span id="cb84-115"><a href="#cb84-115" aria-hidden="true" tabindex="-1"></a>        modell.AddExactlyOne(x[i][j] <span class="cf">for</span> i <span class="kw">in</span> <span class="bu">range</span>(personen))</span>
-<span id="cb84-116"><a href="#cb84-116" aria-hidden="true" tabindex="-1"></a>    <span class="cf">for</span> i <span class="kw">in</span> <span class="bu">range</span>(personen):</span>
-<span id="cb84-117"><a href="#cb84-117" aria-hidden="true" tabindex="-1"></a>        modell.Add(<span class="bu">sum</span>(x[i]) <span class="op">&lt;=</span> <span class="dv">2</span>)</span>
-<span id="cb84-118"><a href="#cb84-118" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb84-119"><a href="#cb84-119" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb84-120"><a href="#cb84-120" aria-hidden="true" tabindex="-1"></a><span class="kw">def</span> dienstplan_unloesbar(modell: cp_model.CpModel) <span class="op">-&gt;</span> <span class="va">None</span>:</span>
-<span id="cb84-121"><a href="#cb84-121" aria-hidden="true" tabindex="-1"></a>    <span class="co">&quot;&quot;&quot;Dieselben fuenf Dienste, aber hoechstens EIN Dienst je Person.</span></span>
-<span id="cb84-122"><a href="#cb84-122" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb84-123"><a href="#cb84-123" aria-hidden="true" tabindex="-1"></a><span class="co">    Vier Personen koennen zusammen hoechstens vier Dienste uebernehmen - fuer</span></span>
-<span id="cb84-124"><a href="#cb84-124" aria-hidden="true" tabindex="-1"></a><span class="co">    fuenf Dienste reicht das nicht. Kein Solver der Welt findet hier etwas.</span></span>
-<span id="cb84-125"><a href="#cb84-125" aria-hidden="true" tabindex="-1"></a><span class="co">    &quot;&quot;&quot;</span></span>
-<span id="cb84-126"><a href="#cb84-126" aria-hidden="true" tabindex="-1"></a>    personen, dienste <span class="op">=</span> <span class="dv">4</span>, <span class="dv">5</span></span>
-<span id="cb84-127"><a href="#cb84-127" aria-hidden="true" tabindex="-1"></a>    x <span class="op">=</span> [[modell.NewBoolVar(<span class="ss">f&quot;x_</span><span class="sc">{</span>i<span class="sc">}</span><span class="ss">_</span><span class="sc">{</span>j<span class="sc">}</span><span class="ss">&quot;</span>) <span class="cf">for</span> j <span class="kw">in</span> <span class="bu">range</span>(dienste)]</span>
-<span id="cb84-128"><a href="#cb84-128" aria-hidden="true" tabindex="-1"></a>         <span class="cf">for</span> i <span class="kw">in</span> <span class="bu">range</span>(personen)]</span>
-<span id="cb84-129"><a href="#cb84-129" aria-hidden="true" tabindex="-1"></a>    <span class="cf">for</span> j <span class="kw">in</span> <span class="bu">range</span>(dienste):</span>
-<span id="cb84-130"><a href="#cb84-130" aria-hidden="true" tabindex="-1"></a>        modell.AddExactlyOne(x[i][j] <span class="cf">for</span> i <span class="kw">in</span> <span class="bu">range</span>(personen))</span>
-<span id="cb84-131"><a href="#cb84-131" aria-hidden="true" tabindex="-1"></a>    <span class="cf">for</span> i <span class="kw">in</span> <span class="bu">range</span>(personen):</span>
-<span id="cb84-132"><a href="#cb84-132" aria-hidden="true" tabindex="-1"></a>        modell.Add(<span class="bu">sum</span>(x[i]) <span class="op">&lt;=</span> <span class="dv">1</span>)</span>
-<span id="cb84-133"><a href="#cb84-133" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb84-134"><a href="#cb84-134" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb84-135"><a href="#cb84-135" aria-hidden="true" tabindex="-1"></a><span class="kw">def</span> modell_fehlerhaft(modell: cp_model.CpModel) <span class="op">-&gt;</span> <span class="va">None</span>:</span>
-<span id="cb84-136"><a href="#cb84-136" aria-hidden="true" tabindex="-1"></a>    <span class="co">&quot;&quot;&quot;Eine Variable mit leerem Wertebereich: untere Schranke &gt; obere.</span></span>
-<span id="cb84-137"><a href="#cb84-137" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb84-138"><a href="#cb84-138" aria-hidden="true" tabindex="-1"></a><span class="co">    Im Alltag entsteht das durch einen Rechenfehler in den Grenzen, etwa</span></span>
-<span id="cb84-139"><a href="#cb84-139" aria-hidden="true" tabindex="-1"></a><span class="co">    NewIntVar(mindestbesetzung, kapazitaet, ...) bei falsch sortierten Daten.</span></span>
-<span id="cb84-140"><a href="#cb84-140" aria-hidden="true" tabindex="-1"></a><span class="co">    &quot;&quot;&quot;</span></span>
-<span id="cb84-141"><a href="#cb84-141" aria-hidden="true" tabindex="-1"></a>    kaputt <span class="op">=</span> modell.NewIntVar(<span class="dv">5</span>, <span class="dv">2</span>, <span class="st">&quot;leerer_bereich&quot;</span>)</span>
-<span id="cb84-142"><a href="#cb84-142" aria-hidden="true" tabindex="-1"></a>    modell.Add(kaputt <span class="op">&gt;=</span> <span class="dv">0</span>)</span>
-<span id="cb84-143"><a href="#cb84-143" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb84-144"><a href="#cb84-144" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb84-145"><a href="#cb84-145" aria-hidden="true" tabindex="-1"></a><span class="kw">def</span> lastverteilung(modell: cp_model.CpModel) <span class="op">-&gt;</span> <span class="va">None</span>:</span>
-<span id="cb84-146"><a href="#cb84-146" aria-hidden="true" tabindex="-1"></a>    <span class="co">&quot;&quot;&quot;120 Auftraege auf 11 Maschinen - gross genug, dass der Optimalitaets-</span></span>
-<span id="cb84-147"><a href="#cb84-147" aria-hidden="true" tabindex="-1"></a><span class="co">    beweis laenger dauert als das Finden einer sehr guten Loesung.&quot;&quot;&quot;</span></span>
-<span id="cb84-148"><a href="#cb84-148" aria-hidden="true" tabindex="-1"></a>    rng <span class="op">=</span> np.random.default_rng(<span class="dv">3</span>)</span>
-<span id="cb84-149"><a href="#cb84-149" aria-hidden="true" tabindex="-1"></a>    dauer <span class="op">=</span> rng.integers(<span class="dv">100</span>, <span class="dv">9000</span>, <span class="dv">120</span>)</span>
-<span id="cb84-150"><a href="#cb84-150" aria-hidden="true" tabindex="-1"></a>    n, maschinen <span class="op">=</span> <span class="bu">len</span>(dauer), <span class="dv">11</span></span>
-<span id="cb84-151"><a href="#cb84-151" aria-hidden="true" tabindex="-1"></a>    obergrenze <span class="op">=</span> <span class="bu">int</span>(dauer.<span class="bu">sum</span>())</span>
-<span id="cb84-152"><a href="#cb84-152" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb84-153"><a href="#cb84-153" aria-hidden="true" tabindex="-1"></a>    x <span class="op">=</span> [[modell.NewBoolVar(<span class="ss">f&quot;x_</span><span class="sc">{</span>i<span class="sc">}</span><span class="ss">_</span><span class="sc">{</span>k<span class="sc">}</span><span class="ss">&quot;</span>) <span class="cf">for</span> k <span class="kw">in</span> <span class="bu">range</span>(maschinen)]</span>
-<span id="cb84-154"><a href="#cb84-154" aria-hidden="true" tabindex="-1"></a>         <span class="cf">for</span> i <span class="kw">in</span> <span class="bu">range</span>(n)]</span>
-<span id="cb84-155"><a href="#cb84-155" aria-hidden="true" tabindex="-1"></a>    <span class="cf">for</span> i <span class="kw">in</span> <span class="bu">range</span>(n):</span>
-<span id="cb84-156"><a href="#cb84-156" aria-hidden="true" tabindex="-1"></a>        modell.AddExactlyOne(x[i])</span>
-<span id="cb84-157"><a href="#cb84-157" aria-hidden="true" tabindex="-1"></a>    belegung <span class="op">=</span> [modell.NewIntVar(<span class="dv">0</span>, obergrenze, <span class="ss">f&quot;l_</span><span class="sc">{</span>k<span class="sc">}</span><span class="ss">&quot;</span>) <span class="cf">for</span> k <span class="kw">in</span> <span class="bu">range</span>(maschinen)]</span>
-<span id="cb84-158"><a href="#cb84-158" aria-hidden="true" tabindex="-1"></a>    <span class="cf">for</span> k <span class="kw">in</span> <span class="bu">range</span>(maschinen):</span>
-<span id="cb84-159"><a href="#cb84-159" aria-hidden="true" tabindex="-1"></a>        modell.Add(belegung[k] <span class="op">==</span> <span class="bu">sum</span>(<span class="bu">int</span>(dauer[i]) <span class="op">*</span> x[i][k] <span class="cf">for</span> i <span class="kw">in</span> <span class="bu">range</span>(n)))</span>
-<span id="cb84-160"><a href="#cb84-160" aria-hidden="true" tabindex="-1"></a>    makespan <span class="op">=</span> modell.NewIntVar(<span class="dv">0</span>, obergrenze, <span class="st">&quot;makespan&quot;</span>)</span>
-<span id="cb84-161"><a href="#cb84-161" aria-hidden="true" tabindex="-1"></a>    modell.AddMaxEquality(makespan, belegung)</span>
-<span id="cb84-162"><a href="#cb84-162" aria-hidden="true" tabindex="-1"></a>    modell.Minimize(makespan)</span>
-<span id="cb84-163"><a href="#cb84-163" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb84-164"><a href="#cb84-164" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb84-165"><a href="#cb84-165" aria-hidden="true" tabindex="-1"></a><span class="kw">def</span> zahlpartition(modell: cp_model.CpModel) <span class="op">-&gt;</span> <span class="va">None</span>:</span>
-<span id="cb84-166"><a href="#cb84-166" aria-hidden="true" tabindex="-1"></a>    <span class="co">&quot;&quot;&quot;46 grosse Zahlen exakt in zwei gleich schwere Haelften teilen.</span></span>
-<span id="cb84-167"><a href="#cb84-167" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb84-168"><a href="#cb84-168" aria-hidden="true" tabindex="-1"></a><span class="co">    Ein beruehmt schweres Problem: Es gibt keine Zielfunktion, entweder es</span></span>
-<span id="cb84-169"><a href="#cb84-169" aria-hidden="true" tabindex="-1"></a><span class="co">    geht auf oder nicht - und beides zu entscheiden dauert lange.</span></span>
-<span id="cb84-170"><a href="#cb84-170" aria-hidden="true" tabindex="-1"></a><span class="co">    &quot;&quot;&quot;</span></span>
-<span id="cb84-171"><a href="#cb84-171" aria-hidden="true" tabindex="-1"></a>    rng <span class="op">=</span> np.random.default_rng(<span class="dv">1</span>)</span>
-<span id="cb84-172"><a href="#cb84-172" aria-hidden="true" tabindex="-1"></a>    gewichte <span class="op">=</span> rng.integers(<span class="dv">10</span><span class="op">**</span><span class="dv">6</span>, <span class="dv">2</span> <span class="op">*</span> <span class="dv">10</span><span class="op">**</span><span class="dv">6</span>, <span class="dv">46</span>)</span>
-<span id="cb84-173"><a href="#cb84-173" aria-hidden="true" tabindex="-1"></a>    x <span class="op">=</span> [modell.NewBoolVar(<span class="ss">f&quot;x_</span><span class="sc">{</span>i<span class="sc">}</span><span class="ss">&quot;</span>) <span class="cf">for</span> i <span class="kw">in</span> <span class="bu">range</span>(<span class="bu">len</span>(gewichte))]</span>
-<span id="cb84-174"><a href="#cb84-174" aria-hidden="true" tabindex="-1"></a>    modell.Add(<span class="bu">sum</span>(<span class="bu">int</span>(gewichte[i]) <span class="op">*</span> x[i] <span class="cf">for</span> i <span class="kw">in</span> <span class="bu">range</span>(<span class="bu">len</span>(gewichte)))</span>
-<span id="cb84-175"><a href="#cb84-175" aria-hidden="true" tabindex="-1"></a>               <span class="op">==</span> <span class="bu">int</span>(gewichte.<span class="bu">sum</span>() <span class="op">//</span> <span class="dv">2</span>))</span>
-<span id="cb84-176"><a href="#cb84-176" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb84-177"><a href="#cb84-177" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb84-178"><a href="#cb84-178" aria-hidden="true" tabindex="-1"></a><span class="kw">def</span> zeige(titel: <span class="bu">str</span>, a: Auswertung) <span class="op">-&gt;</span> <span class="va">None</span>:</span>
-<span id="cb84-179"><a href="#cb84-179" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;</span><span class="ch">\n</span><span class="sc">{</span>titel<span class="sc">}</span><span class="ss">&quot;</span>)</span>
-<span id="cb84-180"><a href="#cb84-180" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;  Status               </span><span class="sc">{</span>a<span class="sc">.</span>status<span class="sc">}</span><span class="ss">&quot;</span>)</span>
-<span id="cb84-181"><a href="#cb84-181" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;  Loesung vorhanden    </span><span class="sc">{</span><span class="st">&#39;ja&#39;</span> <span class="cf">if</span> a<span class="sc">.</span>hat_loesung <span class="cf">else</span> <span class="st">&#39;nein&#39;</span><span class="sc">}</span><span class="ss">&quot;</span>)</span>
-<span id="cb84-182"><a href="#cb84-182" aria-hidden="true" tabindex="-1"></a>    <span class="cf">if</span> a.zielwert <span class="kw">is</span> <span class="kw">not</span> <span class="va">None</span>:</span>
-<span id="cb84-183"><a href="#cb84-183" aria-hidden="true" tabindex="-1"></a>        <span class="bu">print</span>(<span class="ss">f&quot;  Zielwert / Schranke  </span><span class="sc">{</span>a<span class="sc">.</span>zielwert<span class="sc">:,.0f}</span><span class="ss"> / </span><span class="sc">{</span>a<span class="sc">.</span>schranke<span class="sc">:,.0f}</span><span class="ss">&quot;</span></span>
-<span id="cb84-184"><a href="#cb84-184" aria-hidden="true" tabindex="-1"></a>              <span class="ss">f&quot;   (Gap </span><span class="sc">{</span>a<span class="sc">.</span>gap <span class="op">*</span> <span class="dv">100</span><span class="sc">:.3f}</span><span class="ss"> %)&quot;</span>)</span>
-<span id="cb84-185"><a href="#cb84-185" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;  -&gt; </span><span class="sc">{</span>a<span class="sc">.</span>empfehlung<span class="sc">}</span><span class="ss">&quot;</span>)</span>
-<span id="cb84-186"><a href="#cb84-186" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb84-187"><a href="#cb84-187" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb84-188"><a href="#cb84-188" aria-hidden="true" tabindex="-1"></a><span class="cf">if</span> <span class="va">__name__</span> <span class="op">==</span> <span class="st">&quot;__main__&quot;</span>:</span>
-<span id="cb84-189"><a href="#cb84-189" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;=&quot;</span> <span class="op">*</span> <span class="dv">78</span>)</span>
-<span id="cb84-190"><a href="#cb84-190" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;  DIE FUENF ANTWORTEN VON CP-SAT&quot;</span>)</span>
-<span id="cb84-191"><a href="#cb84-191" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;=&quot;</span> <span class="op">*</span> <span class="dv">78</span>)</span>
-<span id="cb84-192"><a href="#cb84-192" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb84-193"><a href="#cb84-193" aria-hidden="true" tabindex="-1"></a>    zeige(<span class="st">&quot;[1] Dienstplan, hoechstens 2 Dienste je Person&quot;</span>,</span>
-<span id="cb84-194"><a href="#cb84-194" aria-hidden="true" tabindex="-1"></a>          loese(dienstplan_loesbar, <span class="fl">10.0</span>, mit_zielfunktion<span class="op">=</span><span class="va">False</span>))</span>
-<span id="cb84-195"><a href="#cb84-195" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb84-196"><a href="#cb84-196" aria-hidden="true" tabindex="-1"></a>    zeige(<span class="st">&quot;[2] Lastverteilung 120 Auftraege / 11 Maschinen, 0,5 s Limit&quot;</span>,</span>
-<span id="cb84-197"><a href="#cb84-197" aria-hidden="true" tabindex="-1"></a>          loese(lastverteilung, <span class="fl">0.5</span>, mit_zielfunktion<span class="op">=</span><span class="va">True</span>))</span>
-<span id="cb84-198"><a href="#cb84-198" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb84-199"><a href="#cb84-199" aria-hidden="true" tabindex="-1"></a>    zeige(<span class="st">&quot;[3] Derselbe Fall mit 10 s Limit&quot;</span>,</span>
-<span id="cb84-200"><a href="#cb84-200" aria-hidden="true" tabindex="-1"></a>          loese(lastverteilung, <span class="fl">10.0</span>, mit_zielfunktion<span class="op">=</span><span class="va">True</span>))</span>
-<span id="cb84-201"><a href="#cb84-201" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb84-202"><a href="#cb84-202" aria-hidden="true" tabindex="-1"></a>    zeige(<span class="st">&quot;[4] Dienstplan, hoechstens 1 Dienst je Person&quot;</span>,</span>
-<span id="cb84-203"><a href="#cb84-203" aria-hidden="true" tabindex="-1"></a>          loese(dienstplan_unloesbar, <span class="fl">10.0</span>, mit_zielfunktion<span class="op">=</span><span class="va">False</span>))</span>
-<span id="cb84-204"><a href="#cb84-204" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb84-205"><a href="#cb84-205" aria-hidden="true" tabindex="-1"></a>    zeige(<span class="st">&quot;[5] Variable mit leerem Wertebereich&quot;</span>,</span>
-<span id="cb84-206"><a href="#cb84-206" aria-hidden="true" tabindex="-1"></a>          loese(modell_fehlerhaft, <span class="fl">10.0</span>, mit_zielfunktion<span class="op">=</span><span class="va">False</span>))</span>
-<span id="cb84-207"><a href="#cb84-207" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb84-208"><a href="#cb84-208" aria-hidden="true" tabindex="-1"></a>    zeige(<span class="st">&quot;[6] Zahlpartition mit 46 grossen Zahlen, 2 s Limit&quot;</span>,</span>
-<span id="cb84-209"><a href="#cb84-209" aria-hidden="true" tabindex="-1"></a>          loese(zahlpartition, <span class="fl">2.0</span>, mit_zielfunktion<span class="op">=</span><span class="va">False</span>))</span>
-<span id="cb84-210"><a href="#cb84-210" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb84-211"><a href="#cb84-211" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;</span><span class="ch">\n</span><span class="st">&quot;</span> <span class="op">+</span> <span class="st">&quot;=&quot;</span> <span class="op">*</span> <span class="dv">78</span>)</span>
-<span id="cb84-212"><a href="#cb84-212" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;  DIE DREI, DIE MAN NICHT VERWECHSELN DARF&quot;</span>)</span>
-<span id="cb84-213"><a href="#cb84-213" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;=&quot;</span> <span class="op">*</span> <span class="dv">78</span>)</span>
-<span id="cb84-214"><a href="#cb84-214" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;INFEASIBLE  Es gibt keine Loesung. Eine Aussage ueber Ihr MODELL.&quot;</span>)</span>
-<span id="cb84-215"><a href="#cb84-215" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;            Mehr Rechenzeit aendert daran nichts.&quot;</span>)</span>
-<span id="cb84-216"><a href="#cb84-216" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;UNKNOWN     Es wurde keine gefunden. Eine Aussage ueber die ZEIT.&quot;</span>)</span>
-<span id="cb84-217"><a href="#cb84-217" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;            Ob es eine gibt, ist offen.&quot;</span>)</span>
-<span id="cb84-218"><a href="#cb84-218" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;MODEL_INVALID  Das Modell ist gar kein gueltiges Modell. Eine&quot;</span>)</span>
-<span id="cb84-219"><a href="#cb84-219" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;            Aussage ueber Ihren CODE - immer ein Programmierfehler.&quot;</span>)</span>
-<span id="cb84-220"><a href="#cb84-220" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>()</span>
-<span id="cb84-221"><a href="#cb84-221" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;Wer diese drei in einem &#39;else: return None&#39; zusammenfasst, verliert&quot;</span>)</span>
-<span id="cb84-222"><a href="#cb84-222" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;genau die Information, die zur Fehlersuche noetig waere.&quot;</span>)</span>
-<span id="cb84-223"><a href="#cb84-223" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;=&quot;</span> <span class="op">*</span> <span class="dv">78</span>)</span></code></pre></div>
+<div class="sourceCode" id="cb86"><pre class="sourceCode python"><code class="sourceCode python"><span id="cb86-1"><a href="#cb86-1" aria-hidden="true" tabindex="-1"></a><span class="co">#!/usr/bin/env python3</span></span>
+<span id="cb86-2"><a href="#cb86-2" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb86-3"><a href="#cb86-3" aria-hidden="true" tabindex="-1"></a><span class="co"># CP_SAT_Statusfaelle.py</span></span>
+<span id="cb86-4"><a href="#cb86-4" aria-hidden="true" tabindex="-1"></a><span class="co">&quot;&quot;&quot;</span></span>
+<span id="cb86-5"><a href="#cb86-5" aria-hidden="true" tabindex="-1"></a><span class="co">Kapitel CP-SAT: Alle fuenf Antworten von CP-SAT - und was jede bedeutet.</span></span>
+<span id="cb86-6"><a href="#cb86-6" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb86-7"><a href="#cb86-7" aria-hidden="true" tabindex="-1"></a><span class="co">Der haeufigste Fehler beim Einsatz von CP-SAT im Betrieb ist eine Zeile wie</span></span>
+<span id="cb86-8"><a href="#cb86-8" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb86-9"><a href="#cb86-9" aria-hidden="true" tabindex="-1"></a><span class="co">    if status == cp_model.OPTIMAL:</span></span>
+<span id="cb86-10"><a href="#cb86-10" aria-hidden="true" tabindex="-1"></a><span class="co">        ...verwerte die Loesung...</span></span>
+<span id="cb86-11"><a href="#cb86-11" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb86-12"><a href="#cb86-12" aria-hidden="true" tabindex="-1"></a><span class="co">Sie wirft in drei von fuenf Faellen etwas weg, das man haette gebrauchen</span></span>
+<span id="cb86-13"><a href="#cb86-13" aria-hidden="true" tabindex="-1"></a><span class="co">koennen, und verschweigt in einem weiteren Fall einen Modellierungsfehler.</span></span>
+<span id="cb86-14"><a href="#cb86-14" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb86-15"><a href="#cb86-15" aria-hidden="true" tabindex="-1"></a><span class="co">Dieses Programm erzeugt jeden Statusfall absichtlich und zeigt die passende</span></span>
+<span id="cb86-16"><a href="#cb86-16" aria-hidden="true" tabindex="-1"></a><span class="co">Reaktion:</span></span>
+<span id="cb86-17"><a href="#cb86-17" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb86-18"><a href="#cb86-18" aria-hidden="true" tabindex="-1"></a><span class="co">    OPTIMAL        beweisbar bestmoeglich          -&gt; ausfuehren</span></span>
+<span id="cb86-19"><a href="#cb86-19" aria-hidden="true" tabindex="-1"></a><span class="co">    FEASIBLE       zulaessig, Zeit war um          -&gt; Gap pruefen, dann entscheiden</span></span>
+<span id="cb86-20"><a href="#cb86-20" aria-hidden="true" tabindex="-1"></a><span class="co">    INFEASIBLE     kein Plan existiert             -&gt; harte Regeln lockern</span></span>
+<span id="cb86-21"><a href="#cb86-21" aria-hidden="true" tabindex="-1"></a><span class="co">    MODEL_INVALID  das Modell ist fehlerhaft       -&gt; Programmierfehler beheben</span></span>
+<span id="cb86-22"><a href="#cb86-22" aria-hidden="true" tabindex="-1"></a><span class="co">    UNKNOWN        nichts gefunden, Zeit war um    -&gt; mehr Zeit oder Heuristik</span></span>
+<span id="cb86-23"><a href="#cb86-23" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb86-24"><a href="#cb86-24" aria-hidden="true" tabindex="-1"></a><span class="co">Benoetigt: numpy, ortools</span></span>
+<span id="cb86-25"><a href="#cb86-25" aria-hidden="true" tabindex="-1"></a><span class="co">&quot;&quot;&quot;</span></span>
+<span id="cb86-26"><a href="#cb86-26" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb86-27"><a href="#cb86-27" aria-hidden="true" tabindex="-1"></a><span class="im">from</span> __future__ <span class="im">import</span> annotations</span>
+<span id="cb86-28"><a href="#cb86-28" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb86-29"><a href="#cb86-29" aria-hidden="true" tabindex="-1"></a><span class="im">from</span> dataclasses <span class="im">import</span> dataclass</span>
+<span id="cb86-30"><a href="#cb86-30" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb86-31"><a href="#cb86-31" aria-hidden="true" tabindex="-1"></a><span class="im">import</span> numpy <span class="im">as</span> np</span>
+<span id="cb86-32"><a href="#cb86-32" aria-hidden="true" tabindex="-1"></a><span class="im">from</span> ortools.sat.python <span class="im">import</span> cp_model</span>
+<span id="cb86-33"><a href="#cb86-33" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb86-34"><a href="#cb86-34" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb86-35"><a href="#cb86-35" aria-hidden="true" tabindex="-1"></a><span class="at">@dataclass</span></span>
+<span id="cb86-36"><a href="#cb86-36" aria-hidden="true" tabindex="-1"></a><span class="kw">class</span> Auswertung:</span>
+<span id="cb86-37"><a href="#cb86-37" aria-hidden="true" tabindex="-1"></a>    <span class="co">&quot;&quot;&quot;Was nach einem CP-SAT-Lauf tatsaechlich feststeht.&quot;&quot;&quot;</span></span>
+<span id="cb86-38"><a href="#cb86-38" aria-hidden="true" tabindex="-1"></a>    status: <span class="bu">str</span></span>
+<span id="cb86-39"><a href="#cb86-39" aria-hidden="true" tabindex="-1"></a>    hat_loesung: <span class="bu">bool</span></span>
+<span id="cb86-40"><a href="#cb86-40" aria-hidden="true" tabindex="-1"></a>    beweisbar_optimal: <span class="bu">bool</span></span>
+<span id="cb86-41"><a href="#cb86-41" aria-hidden="true" tabindex="-1"></a>    zielwert: <span class="bu">float</span> <span class="op">|</span> <span class="va">None</span></span>
+<span id="cb86-42"><a href="#cb86-42" aria-hidden="true" tabindex="-1"></a>    schranke: <span class="bu">float</span> <span class="op">|</span> <span class="va">None</span></span>
+<span id="cb86-43"><a href="#cb86-43" aria-hidden="true" tabindex="-1"></a>    gap: <span class="bu">float</span> <span class="op">|</span> <span class="va">None</span></span>
+<span id="cb86-44"><a href="#cb86-44" aria-hidden="true" tabindex="-1"></a>    empfehlung: <span class="bu">str</span></span>
+<span id="cb86-45"><a href="#cb86-45" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb86-46"><a href="#cb86-46" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb86-47"><a href="#cb86-47" aria-hidden="true" tabindex="-1"></a><span class="kw">def</span> werte_aus(loeser: cp_model.CpSolver, status: <span class="bu">int</span>,</span>
+<span id="cb86-48"><a href="#cb86-48" aria-hidden="true" tabindex="-1"></a>              mit_zielfunktion: <span class="bu">bool</span>) <span class="op">-&gt;</span> Auswertung:</span>
+<span id="cb86-49"><a href="#cb86-49" aria-hidden="true" tabindex="-1"></a>    <span class="co">&quot;&quot;&quot;Uebersetzt einen CP-SAT-Status in eine Handlungsempfehlung.</span></span>
+<span id="cb86-50"><a href="#cb86-50" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb86-51"><a href="#cb86-51" aria-hidden="true" tabindex="-1"></a><span class="co">    Genau diese Funktion fehlt in den meisten Projekten. Sie ist kurz, aber</span></span>
+<span id="cb86-52"><a href="#cb86-52" aria-hidden="true" tabindex="-1"></a><span class="co">    sie ist der Unterschied zwischen einem Prototyp und einem System, das</span></span>
+<span id="cb86-53"><a href="#cb86-53" aria-hidden="true" tabindex="-1"></a><span class="co">    nachts ohne Aufsicht laeuft.</span></span>
+<span id="cb86-54"><a href="#cb86-54" aria-hidden="true" tabindex="-1"></a><span class="co">    &quot;&quot;&quot;</span></span>
+<span id="cb86-55"><a href="#cb86-55" aria-hidden="true" tabindex="-1"></a>    name <span class="op">=</span> loeser.StatusName(status)</span>
+<span id="cb86-56"><a href="#cb86-56" aria-hidden="true" tabindex="-1"></a>    hat_loesung <span class="op">=</span> status <span class="kw">in</span> (cp_model.OPTIMAL, cp_model.FEASIBLE)</span>
+<span id="cb86-57"><a href="#cb86-57" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb86-58"><a href="#cb86-58" aria-hidden="true" tabindex="-1"></a>    zielwert <span class="op">=</span> schranke <span class="op">=</span> gap <span class="op">=</span> <span class="va">None</span></span>
+<span id="cb86-59"><a href="#cb86-59" aria-hidden="true" tabindex="-1"></a>    <span class="cf">if</span> hat_loesung <span class="kw">and</span> mit_zielfunktion:</span>
+<span id="cb86-60"><a href="#cb86-60" aria-hidden="true" tabindex="-1"></a>        zielwert <span class="op">=</span> loeser.ObjectiveValue()</span>
+<span id="cb86-61"><a href="#cb86-61" aria-hidden="true" tabindex="-1"></a>        schranke <span class="op">=</span> loeser.BestObjectiveBound()</span>
+<span id="cb86-62"><a href="#cb86-62" aria-hidden="true" tabindex="-1"></a>        nenner <span class="op">=</span> <span class="bu">max</span>(<span class="bu">abs</span>(zielwert), <span class="fl">1e-9</span>)</span>
+<span id="cb86-63"><a href="#cb86-63" aria-hidden="true" tabindex="-1"></a>        gap <span class="op">=</span> <span class="bu">abs</span>(zielwert <span class="op">-</span> schranke) <span class="op">/</span> nenner</span>
+<span id="cb86-64"><a href="#cb86-64" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb86-65"><a href="#cb86-65" aria-hidden="true" tabindex="-1"></a>    <span class="cf">if</span> status <span class="op">==</span> cp_model.OPTIMAL:</span>
+<span id="cb86-66"><a href="#cb86-66" aria-hidden="true" tabindex="-1"></a>        empfehlung <span class="op">=</span> <span class="st">&quot;Ausfuehren. Besser geht es nachweislich nicht.&quot;</span></span>
+<span id="cb86-67"><a href="#cb86-67" aria-hidden="true" tabindex="-1"></a>    <span class="cf">elif</span> status <span class="op">==</span> cp_model.FEASIBLE:</span>
+<span id="cb86-68"><a href="#cb86-68" aria-hidden="true" tabindex="-1"></a>        empfehlung <span class="op">=</span> (<span class="ss">f&quot;Brauchbar. Der Plan ist hoechstens </span><span class="sc">{</span>gap <span class="op">*</span> <span class="dv">100</span><span class="sc">:.2f}</span><span class="ss"> % &quot;</span></span>
+<span id="cb86-69"><a href="#cb86-69" aria-hidden="true" tabindex="-1"></a>                      <span class="ss">f&quot;schlechter als das theoretisch Bestmoegliche.&quot;</span></span>
+<span id="cb86-70"><a href="#cb86-70" aria-hidden="true" tabindex="-1"></a>                      <span class="cf">if</span> gap <span class="kw">is</span> <span class="kw">not</span> <span class="va">None</span> <span class="cf">else</span></span>
+<span id="cb86-71"><a href="#cb86-71" aria-hidden="true" tabindex="-1"></a>                      <span class="st">&quot;Brauchbar, aber nicht als optimal bewiesen.&quot;</span>)</span>
+<span id="cb86-72"><a href="#cb86-72" aria-hidden="true" tabindex="-1"></a>    <span class="cf">elif</span> status <span class="op">==</span> cp_model.INFEASIBLE:</span>
+<span id="cb86-73"><a href="#cb86-73" aria-hidden="true" tabindex="-1"></a>        empfehlung <span class="op">=</span> (<span class="st">&quot;KEIN Plan existiert. Das ist eine Aussage ueber Ihre &quot;</span></span>
+<span id="cb86-74"><a href="#cb86-74" aria-hidden="true" tabindex="-1"></a>                      <span class="st">&quot;harten Regeln, nicht ueber die Rechenzeit: Auch &quot;</span></span>
+<span id="cb86-75"><a href="#cb86-75" aria-hidden="true" tabindex="-1"></a>                      <span class="st">&quot;unendlich viel Zeit wuerde nichts aendern. Regeln &quot;</span></span>
+<span id="cb86-76"><a href="#cb86-76" aria-hidden="true" tabindex="-1"></a>                      <span class="st">&quot;lockern oder weich machen (Anhang C).&quot;</span>)</span>
+<span id="cb86-77"><a href="#cb86-77" aria-hidden="true" tabindex="-1"></a>    <span class="cf">elif</span> status <span class="op">==</span> cp_model.MODEL_INVALID:</span>
+<span id="cb86-78"><a href="#cb86-78" aria-hidden="true" tabindex="-1"></a>        empfehlung <span class="op">=</span> (<span class="st">&quot;Das MODELL ist fehlerhaft, nicht das Problem. &quot;</span></span>
+<span id="cb86-79"><a href="#cb86-79" aria-hidden="true" tabindex="-1"></a>                      <span class="st">&quot;Typisch: eine Variable mit leerem Wertebereich. &quot;</span></span>
+<span id="cb86-80"><a href="#cb86-80" aria-hidden="true" tabindex="-1"></a>                      <span class="st">&quot;model.Validate() nennt die Ursache.&quot;</span>)</span>
+<span id="cb86-81"><a href="#cb86-81" aria-hidden="true" tabindex="-1"></a>    <span class="cf">else</span>:                                    <span class="co"># UNKNOWN</span></span>
+<span id="cb86-82"><a href="#cb86-82" aria-hidden="true" tabindex="-1"></a>        empfehlung <span class="op">=</span> (<span class="st">&quot;Nichts gefunden - aber auch nicht widerlegt. Mehr Zeit &quot;</span></span>
+<span id="cb86-83"><a href="#cb86-83" aria-hidden="true" tabindex="-1"></a>                      <span class="st">&quot;geben, das Modell vereinfachen oder mit einer &quot;</span></span>
+<span id="cb86-84"><a href="#cb86-84" aria-hidden="true" tabindex="-1"></a>                      <span class="st">&quot;Heuristik vorbelegen (AddHint).&quot;</span>)</span>
+<span id="cb86-85"><a href="#cb86-85" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb86-86"><a href="#cb86-86" aria-hidden="true" tabindex="-1"></a>    <span class="cf">return</span> Auswertung(</span>
+<span id="cb86-87"><a href="#cb86-87" aria-hidden="true" tabindex="-1"></a>        status<span class="op">=</span>name,</span>
+<span id="cb86-88"><a href="#cb86-88" aria-hidden="true" tabindex="-1"></a>        hat_loesung<span class="op">=</span>hat_loesung,</span>
+<span id="cb86-89"><a href="#cb86-89" aria-hidden="true" tabindex="-1"></a>        beweisbar_optimal<span class="op">=</span>status <span class="op">==</span> cp_model.OPTIMAL,</span>
+<span id="cb86-90"><a href="#cb86-90" aria-hidden="true" tabindex="-1"></a>        zielwert<span class="op">=</span>zielwert, schranke<span class="op">=</span>schranke, gap<span class="op">=</span>gap,</span>
+<span id="cb86-91"><a href="#cb86-91" aria-hidden="true" tabindex="-1"></a>        empfehlung<span class="op">=</span>empfehlung,</span>
+<span id="cb86-92"><a href="#cb86-92" aria-hidden="true" tabindex="-1"></a>    )</span>
+<span id="cb86-93"><a href="#cb86-93" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb86-94"><a href="#cb86-94" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb86-95"><a href="#cb86-95" aria-hidden="true" tabindex="-1"></a><span class="kw">def</span> loese(baue, zeitlimit: <span class="bu">float</span>, mit_zielfunktion: <span class="bu">bool</span>) <span class="op">-&gt;</span> Auswertung:</span>
+<span id="cb86-96"><a href="#cb86-96" aria-hidden="true" tabindex="-1"></a>    modell <span class="op">=</span> cp_model.CpModel()</span>
+<span id="cb86-97"><a href="#cb86-97" aria-hidden="true" tabindex="-1"></a>    baue(modell)</span>
+<span id="cb86-98"><a href="#cb86-98" aria-hidden="true" tabindex="-1"></a>    loeser <span class="op">=</span> cp_model.CpSolver()</span>
+<span id="cb86-99"><a href="#cb86-99" aria-hidden="true" tabindex="-1"></a>    loeser.parameters.max_time_in_seconds <span class="op">=</span> zeitlimit</span>
+<span id="cb86-100"><a href="#cb86-100" aria-hidden="true" tabindex="-1"></a>    <span class="co"># Fuer reproduzierbare Buchausgaben; im Betrieb weglassen.</span></span>
+<span id="cb86-101"><a href="#cb86-101" aria-hidden="true" tabindex="-1"></a>    loeser.parameters.num_workers <span class="op">=</span> <span class="dv">1</span></span>
+<span id="cb86-102"><a href="#cb86-102" aria-hidden="true" tabindex="-1"></a>    loeser.parameters.random_seed <span class="op">=</span> <span class="dv">1</span></span>
+<span id="cb86-103"><a href="#cb86-103" aria-hidden="true" tabindex="-1"></a>    status <span class="op">=</span> loeser.Solve(modell)</span>
+<span id="cb86-104"><a href="#cb86-104" aria-hidden="true" tabindex="-1"></a>    <span class="cf">return</span> werte_aus(loeser, status, mit_zielfunktion)</span>
+<span id="cb86-105"><a href="#cb86-105" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb86-106"><a href="#cb86-106" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb86-107"><a href="#cb86-107" aria-hidden="true" tabindex="-1"></a><span class="co"># --- Die fuenf Faelle --------------------------------------------------------</span></span>
+<span id="cb86-108"><a href="#cb86-108" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb86-109"><a href="#cb86-109" aria-hidden="true" tabindex="-1"></a><span class="kw">def</span> dienstplan_loesbar(modell: cp_model.CpModel) <span class="op">-&gt;</span> <span class="va">None</span>:</span>
+<span id="cb86-110"><a href="#cb86-110" aria-hidden="true" tabindex="-1"></a>    <span class="co">&quot;&quot;&quot;Vier Personen, fuenf Dienste, hoechstens zwei je Person - loesbar.&quot;&quot;&quot;</span></span>
+<span id="cb86-111"><a href="#cb86-111" aria-hidden="true" tabindex="-1"></a>    personen, dienste <span class="op">=</span> <span class="dv">4</span>, <span class="dv">5</span></span>
+<span id="cb86-112"><a href="#cb86-112" aria-hidden="true" tabindex="-1"></a>    x <span class="op">=</span> [[modell.NewBoolVar(<span class="ss">f&quot;x_</span><span class="sc">{</span>i<span class="sc">}</span><span class="ss">_</span><span class="sc">{</span>j<span class="sc">}</span><span class="ss">&quot;</span>) <span class="cf">for</span> j <span class="kw">in</span> <span class="bu">range</span>(dienste)]</span>
+<span id="cb86-113"><a href="#cb86-113" aria-hidden="true" tabindex="-1"></a>         <span class="cf">for</span> i <span class="kw">in</span> <span class="bu">range</span>(personen)]</span>
+<span id="cb86-114"><a href="#cb86-114" aria-hidden="true" tabindex="-1"></a>    <span class="cf">for</span> j <span class="kw">in</span> <span class="bu">range</span>(dienste):</span>
+<span id="cb86-115"><a href="#cb86-115" aria-hidden="true" tabindex="-1"></a>        modell.AddExactlyOne(x[i][j] <span class="cf">for</span> i <span class="kw">in</span> <span class="bu">range</span>(personen))</span>
+<span id="cb86-116"><a href="#cb86-116" aria-hidden="true" tabindex="-1"></a>    <span class="cf">for</span> i <span class="kw">in</span> <span class="bu">range</span>(personen):</span>
+<span id="cb86-117"><a href="#cb86-117" aria-hidden="true" tabindex="-1"></a>        modell.Add(<span class="bu">sum</span>(x[i]) <span class="op">&lt;=</span> <span class="dv">2</span>)</span>
+<span id="cb86-118"><a href="#cb86-118" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb86-119"><a href="#cb86-119" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb86-120"><a href="#cb86-120" aria-hidden="true" tabindex="-1"></a><span class="kw">def</span> dienstplan_unloesbar(modell: cp_model.CpModel) <span class="op">-&gt;</span> <span class="va">None</span>:</span>
+<span id="cb86-121"><a href="#cb86-121" aria-hidden="true" tabindex="-1"></a>    <span class="co">&quot;&quot;&quot;Dieselben fuenf Dienste, aber hoechstens EIN Dienst je Person.</span></span>
+<span id="cb86-122"><a href="#cb86-122" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb86-123"><a href="#cb86-123" aria-hidden="true" tabindex="-1"></a><span class="co">    Vier Personen koennen zusammen hoechstens vier Dienste uebernehmen - fuer</span></span>
+<span id="cb86-124"><a href="#cb86-124" aria-hidden="true" tabindex="-1"></a><span class="co">    fuenf Dienste reicht das nicht. Kein Solver der Welt findet hier etwas.</span></span>
+<span id="cb86-125"><a href="#cb86-125" aria-hidden="true" tabindex="-1"></a><span class="co">    &quot;&quot;&quot;</span></span>
+<span id="cb86-126"><a href="#cb86-126" aria-hidden="true" tabindex="-1"></a>    personen, dienste <span class="op">=</span> <span class="dv">4</span>, <span class="dv">5</span></span>
+<span id="cb86-127"><a href="#cb86-127" aria-hidden="true" tabindex="-1"></a>    x <span class="op">=</span> [[modell.NewBoolVar(<span class="ss">f&quot;x_</span><span class="sc">{</span>i<span class="sc">}</span><span class="ss">_</span><span class="sc">{</span>j<span class="sc">}</span><span class="ss">&quot;</span>) <span class="cf">for</span> j <span class="kw">in</span> <span class="bu">range</span>(dienste)]</span>
+<span id="cb86-128"><a href="#cb86-128" aria-hidden="true" tabindex="-1"></a>         <span class="cf">for</span> i <span class="kw">in</span> <span class="bu">range</span>(personen)]</span>
+<span id="cb86-129"><a href="#cb86-129" aria-hidden="true" tabindex="-1"></a>    <span class="cf">for</span> j <span class="kw">in</span> <span class="bu">range</span>(dienste):</span>
+<span id="cb86-130"><a href="#cb86-130" aria-hidden="true" tabindex="-1"></a>        modell.AddExactlyOne(x[i][j] <span class="cf">for</span> i <span class="kw">in</span> <span class="bu">range</span>(personen))</span>
+<span id="cb86-131"><a href="#cb86-131" aria-hidden="true" tabindex="-1"></a>    <span class="cf">for</span> i <span class="kw">in</span> <span class="bu">range</span>(personen):</span>
+<span id="cb86-132"><a href="#cb86-132" aria-hidden="true" tabindex="-1"></a>        modell.Add(<span class="bu">sum</span>(x[i]) <span class="op">&lt;=</span> <span class="dv">1</span>)</span>
+<span id="cb86-133"><a href="#cb86-133" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb86-134"><a href="#cb86-134" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb86-135"><a href="#cb86-135" aria-hidden="true" tabindex="-1"></a><span class="kw">def</span> modell_fehlerhaft(modell: cp_model.CpModel) <span class="op">-&gt;</span> <span class="va">None</span>:</span>
+<span id="cb86-136"><a href="#cb86-136" aria-hidden="true" tabindex="-1"></a>    <span class="co">&quot;&quot;&quot;Eine Variable mit leerem Wertebereich: untere Schranke &gt; obere.</span></span>
+<span id="cb86-137"><a href="#cb86-137" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb86-138"><a href="#cb86-138" aria-hidden="true" tabindex="-1"></a><span class="co">    Im Alltag entsteht das durch einen Rechenfehler in den Grenzen, etwa</span></span>
+<span id="cb86-139"><a href="#cb86-139" aria-hidden="true" tabindex="-1"></a><span class="co">    NewIntVar(mindestbesetzung, kapazitaet, ...) bei falsch sortierten Daten.</span></span>
+<span id="cb86-140"><a href="#cb86-140" aria-hidden="true" tabindex="-1"></a><span class="co">    &quot;&quot;&quot;</span></span>
+<span id="cb86-141"><a href="#cb86-141" aria-hidden="true" tabindex="-1"></a>    kaputt <span class="op">=</span> modell.NewIntVar(<span class="dv">5</span>, <span class="dv">2</span>, <span class="st">&quot;leerer_bereich&quot;</span>)</span>
+<span id="cb86-142"><a href="#cb86-142" aria-hidden="true" tabindex="-1"></a>    modell.Add(kaputt <span class="op">&gt;=</span> <span class="dv">0</span>)</span>
+<span id="cb86-143"><a href="#cb86-143" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb86-144"><a href="#cb86-144" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb86-145"><a href="#cb86-145" aria-hidden="true" tabindex="-1"></a><span class="kw">def</span> lastverteilung(modell: cp_model.CpModel) <span class="op">-&gt;</span> <span class="va">None</span>:</span>
+<span id="cb86-146"><a href="#cb86-146" aria-hidden="true" tabindex="-1"></a>    <span class="co">&quot;&quot;&quot;120 Auftraege auf 11 Maschinen - gross genug, dass der Optimalitaets-</span></span>
+<span id="cb86-147"><a href="#cb86-147" aria-hidden="true" tabindex="-1"></a><span class="co">    beweis laenger dauert als das Finden einer sehr guten Loesung.&quot;&quot;&quot;</span></span>
+<span id="cb86-148"><a href="#cb86-148" aria-hidden="true" tabindex="-1"></a>    rng <span class="op">=</span> np.random.default_rng(<span class="dv">3</span>)</span>
+<span id="cb86-149"><a href="#cb86-149" aria-hidden="true" tabindex="-1"></a>    dauer <span class="op">=</span> rng.integers(<span class="dv">100</span>, <span class="dv">9000</span>, <span class="dv">120</span>)</span>
+<span id="cb86-150"><a href="#cb86-150" aria-hidden="true" tabindex="-1"></a>    n, maschinen <span class="op">=</span> <span class="bu">len</span>(dauer), <span class="dv">11</span></span>
+<span id="cb86-151"><a href="#cb86-151" aria-hidden="true" tabindex="-1"></a>    obergrenze <span class="op">=</span> <span class="bu">int</span>(dauer.<span class="bu">sum</span>())</span>
+<span id="cb86-152"><a href="#cb86-152" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb86-153"><a href="#cb86-153" aria-hidden="true" tabindex="-1"></a>    x <span class="op">=</span> [[modell.NewBoolVar(<span class="ss">f&quot;x_</span><span class="sc">{</span>i<span class="sc">}</span><span class="ss">_</span><span class="sc">{</span>k<span class="sc">}</span><span class="ss">&quot;</span>) <span class="cf">for</span> k <span class="kw">in</span> <span class="bu">range</span>(maschinen)]</span>
+<span id="cb86-154"><a href="#cb86-154" aria-hidden="true" tabindex="-1"></a>         <span class="cf">for</span> i <span class="kw">in</span> <span class="bu">range</span>(n)]</span>
+<span id="cb86-155"><a href="#cb86-155" aria-hidden="true" tabindex="-1"></a>    <span class="cf">for</span> i <span class="kw">in</span> <span class="bu">range</span>(n):</span>
+<span id="cb86-156"><a href="#cb86-156" aria-hidden="true" tabindex="-1"></a>        modell.AddExactlyOne(x[i])</span>
+<span id="cb86-157"><a href="#cb86-157" aria-hidden="true" tabindex="-1"></a>    belegung <span class="op">=</span> [modell.NewIntVar(<span class="dv">0</span>, obergrenze, <span class="ss">f&quot;l_</span><span class="sc">{</span>k<span class="sc">}</span><span class="ss">&quot;</span>) <span class="cf">for</span> k <span class="kw">in</span> <span class="bu">range</span>(maschinen)]</span>
+<span id="cb86-158"><a href="#cb86-158" aria-hidden="true" tabindex="-1"></a>    <span class="cf">for</span> k <span class="kw">in</span> <span class="bu">range</span>(maschinen):</span>
+<span id="cb86-159"><a href="#cb86-159" aria-hidden="true" tabindex="-1"></a>        modell.Add(belegung[k] <span class="op">==</span> <span class="bu">sum</span>(<span class="bu">int</span>(dauer[i]) <span class="op">*</span> x[i][k] <span class="cf">for</span> i <span class="kw">in</span> <span class="bu">range</span>(n)))</span>
+<span id="cb86-160"><a href="#cb86-160" aria-hidden="true" tabindex="-1"></a>    makespan <span class="op">=</span> modell.NewIntVar(<span class="dv">0</span>, obergrenze, <span class="st">&quot;makespan&quot;</span>)</span>
+<span id="cb86-161"><a href="#cb86-161" aria-hidden="true" tabindex="-1"></a>    modell.AddMaxEquality(makespan, belegung)</span>
+<span id="cb86-162"><a href="#cb86-162" aria-hidden="true" tabindex="-1"></a>    modell.Minimize(makespan)</span>
+<span id="cb86-163"><a href="#cb86-163" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb86-164"><a href="#cb86-164" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb86-165"><a href="#cb86-165" aria-hidden="true" tabindex="-1"></a><span class="kw">def</span> zahlpartition(modell: cp_model.CpModel) <span class="op">-&gt;</span> <span class="va">None</span>:</span>
+<span id="cb86-166"><a href="#cb86-166" aria-hidden="true" tabindex="-1"></a>    <span class="co">&quot;&quot;&quot;46 grosse Zahlen exakt in zwei gleich schwere Haelften teilen.</span></span>
+<span id="cb86-167"><a href="#cb86-167" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb86-168"><a href="#cb86-168" aria-hidden="true" tabindex="-1"></a><span class="co">    Ein beruehmt schweres Problem: Es gibt keine Zielfunktion, entweder es</span></span>
+<span id="cb86-169"><a href="#cb86-169" aria-hidden="true" tabindex="-1"></a><span class="co">    geht auf oder nicht - und beides zu entscheiden dauert lange.</span></span>
+<span id="cb86-170"><a href="#cb86-170" aria-hidden="true" tabindex="-1"></a><span class="co">    &quot;&quot;&quot;</span></span>
+<span id="cb86-171"><a href="#cb86-171" aria-hidden="true" tabindex="-1"></a>    rng <span class="op">=</span> np.random.default_rng(<span class="dv">1</span>)</span>
+<span id="cb86-172"><a href="#cb86-172" aria-hidden="true" tabindex="-1"></a>    gewichte <span class="op">=</span> rng.integers(<span class="dv">10</span><span class="op">**</span><span class="dv">6</span>, <span class="dv">2</span> <span class="op">*</span> <span class="dv">10</span><span class="op">**</span><span class="dv">6</span>, <span class="dv">46</span>)</span>
+<span id="cb86-173"><a href="#cb86-173" aria-hidden="true" tabindex="-1"></a>    x <span class="op">=</span> [modell.NewBoolVar(<span class="ss">f&quot;x_</span><span class="sc">{</span>i<span class="sc">}</span><span class="ss">&quot;</span>) <span class="cf">for</span> i <span class="kw">in</span> <span class="bu">range</span>(<span class="bu">len</span>(gewichte))]</span>
+<span id="cb86-174"><a href="#cb86-174" aria-hidden="true" tabindex="-1"></a>    modell.Add(<span class="bu">sum</span>(<span class="bu">int</span>(gewichte[i]) <span class="op">*</span> x[i] <span class="cf">for</span> i <span class="kw">in</span> <span class="bu">range</span>(<span class="bu">len</span>(gewichte)))</span>
+<span id="cb86-175"><a href="#cb86-175" aria-hidden="true" tabindex="-1"></a>               <span class="op">==</span> <span class="bu">int</span>(gewichte.<span class="bu">sum</span>() <span class="op">//</span> <span class="dv">2</span>))</span>
+<span id="cb86-176"><a href="#cb86-176" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb86-177"><a href="#cb86-177" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb86-178"><a href="#cb86-178" aria-hidden="true" tabindex="-1"></a><span class="kw">def</span> zeige(titel: <span class="bu">str</span>, a: Auswertung) <span class="op">-&gt;</span> <span class="va">None</span>:</span>
+<span id="cb86-179"><a href="#cb86-179" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;</span><span class="ch">\n</span><span class="sc">{</span>titel<span class="sc">}</span><span class="ss">&quot;</span>)</span>
+<span id="cb86-180"><a href="#cb86-180" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;  Status               </span><span class="sc">{</span>a<span class="sc">.</span>status<span class="sc">}</span><span class="ss">&quot;</span>)</span>
+<span id="cb86-181"><a href="#cb86-181" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;  Loesung vorhanden    </span><span class="sc">{</span><span class="st">&#39;ja&#39;</span> <span class="cf">if</span> a<span class="sc">.</span>hat_loesung <span class="cf">else</span> <span class="st">&#39;nein&#39;</span><span class="sc">}</span><span class="ss">&quot;</span>)</span>
+<span id="cb86-182"><a href="#cb86-182" aria-hidden="true" tabindex="-1"></a>    <span class="cf">if</span> a.zielwert <span class="kw">is</span> <span class="kw">not</span> <span class="va">None</span>:</span>
+<span id="cb86-183"><a href="#cb86-183" aria-hidden="true" tabindex="-1"></a>        <span class="bu">print</span>(<span class="ss">f&quot;  Zielwert / Schranke  </span><span class="sc">{</span>a<span class="sc">.</span>zielwert<span class="sc">:,.0f}</span><span class="ss"> / </span><span class="sc">{</span>a<span class="sc">.</span>schranke<span class="sc">:,.0f}</span><span class="ss">&quot;</span></span>
+<span id="cb86-184"><a href="#cb86-184" aria-hidden="true" tabindex="-1"></a>              <span class="ss">f&quot;   (Gap </span><span class="sc">{</span>a<span class="sc">.</span>gap <span class="op">*</span> <span class="dv">100</span><span class="sc">:.3f}</span><span class="ss"> %)&quot;</span>)</span>
+<span id="cb86-185"><a href="#cb86-185" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;  -&gt; </span><span class="sc">{</span>a<span class="sc">.</span>empfehlung<span class="sc">}</span><span class="ss">&quot;</span>)</span>
+<span id="cb86-186"><a href="#cb86-186" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb86-187"><a href="#cb86-187" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb86-188"><a href="#cb86-188" aria-hidden="true" tabindex="-1"></a><span class="cf">if</span> <span class="va">__name__</span> <span class="op">==</span> <span class="st">&quot;__main__&quot;</span>:</span>
+<span id="cb86-189"><a href="#cb86-189" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;=&quot;</span> <span class="op">*</span> <span class="dv">78</span>)</span>
+<span id="cb86-190"><a href="#cb86-190" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;  DIE FUENF ANTWORTEN VON CP-SAT&quot;</span>)</span>
+<span id="cb86-191"><a href="#cb86-191" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;=&quot;</span> <span class="op">*</span> <span class="dv">78</span>)</span>
+<span id="cb86-192"><a href="#cb86-192" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb86-193"><a href="#cb86-193" aria-hidden="true" tabindex="-1"></a>    zeige(<span class="st">&quot;[1] Dienstplan, hoechstens 2 Dienste je Person&quot;</span>,</span>
+<span id="cb86-194"><a href="#cb86-194" aria-hidden="true" tabindex="-1"></a>          loese(dienstplan_loesbar, <span class="fl">10.0</span>, mit_zielfunktion<span class="op">=</span><span class="va">False</span>))</span>
+<span id="cb86-195"><a href="#cb86-195" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb86-196"><a href="#cb86-196" aria-hidden="true" tabindex="-1"></a>    zeige(<span class="st">&quot;[2] Lastverteilung 120 Auftraege / 11 Maschinen, 0,5 s Limit&quot;</span>,</span>
+<span id="cb86-197"><a href="#cb86-197" aria-hidden="true" tabindex="-1"></a>          loese(lastverteilung, <span class="fl">0.5</span>, mit_zielfunktion<span class="op">=</span><span class="va">True</span>))</span>
+<span id="cb86-198"><a href="#cb86-198" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb86-199"><a href="#cb86-199" aria-hidden="true" tabindex="-1"></a>    zeige(<span class="st">&quot;[3] Derselbe Fall mit 10 s Limit&quot;</span>,</span>
+<span id="cb86-200"><a href="#cb86-200" aria-hidden="true" tabindex="-1"></a>          loese(lastverteilung, <span class="fl">10.0</span>, mit_zielfunktion<span class="op">=</span><span class="va">True</span>))</span>
+<span id="cb86-201"><a href="#cb86-201" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb86-202"><a href="#cb86-202" aria-hidden="true" tabindex="-1"></a>    zeige(<span class="st">&quot;[4] Dienstplan, hoechstens 1 Dienst je Person&quot;</span>,</span>
+<span id="cb86-203"><a href="#cb86-203" aria-hidden="true" tabindex="-1"></a>          loese(dienstplan_unloesbar, <span class="fl">10.0</span>, mit_zielfunktion<span class="op">=</span><span class="va">False</span>))</span>
+<span id="cb86-204"><a href="#cb86-204" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb86-205"><a href="#cb86-205" aria-hidden="true" tabindex="-1"></a>    zeige(<span class="st">&quot;[5] Variable mit leerem Wertebereich&quot;</span>,</span>
+<span id="cb86-206"><a href="#cb86-206" aria-hidden="true" tabindex="-1"></a>          loese(modell_fehlerhaft, <span class="fl">10.0</span>, mit_zielfunktion<span class="op">=</span><span class="va">False</span>))</span>
+<span id="cb86-207"><a href="#cb86-207" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb86-208"><a href="#cb86-208" aria-hidden="true" tabindex="-1"></a>    zeige(<span class="st">&quot;[6] Zahlpartition mit 46 grossen Zahlen, 2 s Limit&quot;</span>,</span>
+<span id="cb86-209"><a href="#cb86-209" aria-hidden="true" tabindex="-1"></a>          loese(zahlpartition, <span class="fl">2.0</span>, mit_zielfunktion<span class="op">=</span><span class="va">False</span>))</span>
+<span id="cb86-210"><a href="#cb86-210" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb86-211"><a href="#cb86-211" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;</span><span class="ch">\n</span><span class="st">&quot;</span> <span class="op">+</span> <span class="st">&quot;=&quot;</span> <span class="op">*</span> <span class="dv">78</span>)</span>
+<span id="cb86-212"><a href="#cb86-212" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;  DIE DREI, DIE MAN NICHT VERWECHSELN DARF&quot;</span>)</span>
+<span id="cb86-213"><a href="#cb86-213" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;=&quot;</span> <span class="op">*</span> <span class="dv">78</span>)</span>
+<span id="cb86-214"><a href="#cb86-214" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;INFEASIBLE  Es gibt keine Loesung. Eine Aussage ueber Ihr MODELL.&quot;</span>)</span>
+<span id="cb86-215"><a href="#cb86-215" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;            Mehr Rechenzeit aendert daran nichts.&quot;</span>)</span>
+<span id="cb86-216"><a href="#cb86-216" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;UNKNOWN     Es wurde keine gefunden. Eine Aussage ueber die ZEIT.&quot;</span>)</span>
+<span id="cb86-217"><a href="#cb86-217" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;            Ob es eine gibt, ist offen.&quot;</span>)</span>
+<span id="cb86-218"><a href="#cb86-218" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;MODEL_INVALID  Das Modell ist gar kein gueltiges Modell. Eine&quot;</span>)</span>
+<span id="cb86-219"><a href="#cb86-219" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;            Aussage ueber Ihren CODE - immer ein Programmierfehler.&quot;</span>)</span>
+<span id="cb86-220"><a href="#cb86-220" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>()</span>
+<span id="cb86-221"><a href="#cb86-221" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;Wer diese drei in einem &#39;else: return None&#39; zusammenfasst, verliert&quot;</span>)</span>
+<span id="cb86-222"><a href="#cb86-222" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;genau die Information, die zur Fehlersuche noetig waere.&quot;</span>)</span>
+<span id="cb86-223"><a href="#cb86-223" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;=&quot;</span> <span class="op">*</span> <span class="dv">78</span>)</span></code></pre></div>
 <p><strong>Erwartete Ausgabe (Zielwerte in Lauf [2] hardwareabhängig):</strong></p>
 <pre><code>==============================================================================
   DIE FUENF ANTWORTEN VON CP-SAT
@@ -11724,7 +12465,7 @@ genau die Information, die zur Fehlersuche noetig waere.
 </ul>
 </blockquote>
 <hr />
-<h2 id="sec:cpsat-uebungsaufgaben">7.8 Übungsaufgaben</h2>
+<h2 id="sec:cpsat-uebungsaufgaben">7.9 Übungsaufgaben</h2>
 <blockquote>
 <p>Lösungen: <a href="#sec:loesungen-cpsat">Abschnitt A.7</a>.</p>
 </blockquote>
@@ -11733,12 +12474,13 @@ genau die Information, die zur Fehlersuche noetig waere.
 <p><strong>Aufgabe 7.3 ⭐⭐ — Regeln ergänzen.</strong> Erweitern Sie das Vertretungssystem um: (a) Frau Albrecht ist ab Slot 3 nicht mehr verfügbar. (b) Herr Bauer und Frau Koch sollen nicht beide am selben Tag eingesetzt werden. (c) Wer Slot 1 übernimmt, soll bevorzugt auch Slot 2 bekommen (Belohnung statt Strafe).</p>
 <p><strong>Aufgabe 7.4 ⭐⭐ — Infeasibility erzeugen und diagnostizieren.</strong> Setzen Sie <code>MAX_VERTRETUNGEN = 0</code>. Was meldet das Programm? Bauen Sie anschließend eine <strong>Schlupfvariable</strong> je Slot ein („Stunde fällt aus“, Strafe 10 000) und beobachten Sie, wie der Solver statt einer Fehlermeldung einen Notfallplan liefert. Welche Stunde lässt er ausfallen und warum?</p>
 <p><strong>Aufgabe 7.5 ⭐⭐ — Sudoku.</strong> Lösen Sie ein 9×9-Sudoku mit CP-SAT. Sie brauchen nur <code>NewIntVar(1, 9, ...)</code> und <code>AddAllDifferent</code> für Zeilen, Spalten und die neun 3×3-Blöcke. Wie viele Zeilen Modellcode benötigen Sie?</p>
-<p><strong>Aufgabe 7.6 ⭐⭐⭐ — Job-Shop erweitern.</strong> Ergänzen Sie <code>JobShop_Intervalle.py</code> um: (a) Rüstzeiten von 1 Zeiteinheit zwischen zwei Aufträgen auf derselben Maschine. (b) Fälligkeitstermine je Auftrag mit Strafkosten für Verspätung. (c) Eine zweite Fräse (Kapazität 2 statt 1) mit <code>AddCumulative</code>.</p>
-<p><strong>Aufgabe 7.7 ⭐⭐⭐ — Eigener Dienstplan.</strong> Modellieren Sie einen Wochendienstplan: 7 Tage, 3 Schichten (früh/spät/nacht), 8 Mitarbeitende. Regeln: Jede Schicht 2 Personen; nach Nachtschicht mindestens 2 Tage frei; höchstens 5 Arbeitstage in Folge; jede Person mindestens 2 freie Tage pro Woche; Wünsche als weiche Ziele. Geben Sie den Plan als Wochentabelle aus.</p>
+<p><strong>Aufgabe 7.6 ⭐⭐ — Die Grenze der Parallelität finden.</strong> <code>Parallele_Suche.py</code> misst 1, 2, 4 und 8 Arbeiter. (a) Ergänzen Sie 16 und 24 (bzw. die Kernzahl Ihres Rechners). Ab wo bringt ein weiterer Arbeiter nichts mehr — und wird es irgendwann wieder schlechter? (b) Setzen Sie <code>random_seed</code> bei jedem Lauf auf einen <strong>anderen</strong> Wert, aber <code>num_workers = 1</code>. Wie viele verschiedene Pläne kommen jetzt heraus? Was folgt daraus für die Frage, welcher der beiden Parameter die Reproduzierbarkeit sichert? (c) Vergrößern Sie die Instanz auf 15 Aufträge. Ab welcher Größe erreicht der Lauf mit einem Arbeiter das Zeitlimit, während acht noch <code>OPTIMAL</code> melden?</p>
+<p><strong>Aufgabe 7.7 ⭐⭐⭐ — Job-Shop erweitern.</strong> Ergänzen Sie <code>JobShop_Intervalle.py</code> um: (a) Rüstzeiten von 1 Zeiteinheit zwischen zwei Aufträgen auf derselben Maschine. (b) Fälligkeitstermine je Auftrag mit Strafkosten für Verspätung. (c) Eine zweite Fräse (Kapazität 2 statt 1) mit <code>AddCumulative</code>.</p>
+<p><strong>Aufgabe 7.8 ⭐⭐⭐ — Eigener Dienstplan.</strong> Modellieren Sie einen Wochendienstplan: 7 Tage, 3 Schichten (früh/spät/nacht), 8 Mitarbeitende. Regeln: Jede Schicht 2 Personen; nach Nachtschicht mindestens 2 Tage frei; höchstens 5 Arbeitstage in Folge; jede Person mindestens 2 freie Tage pro Woche; Wünsche als weiche Ziele. Geben Sie den Plan als Wochentabelle aus.</p>
 <hr />
-<h2 id="sec:cpsat-denkfehler">7.9 Finde den Denkfehler</h2>
+<h2 id="sec:cpsat-denkfehler">7.10 Finde den Denkfehler</h2>
 <blockquote>
-<p><strong>🐛 Finde den Denkfehler 6.1: Die Betriebsvereinbarung, die niemanden interessiert</strong></p>
+<p><strong>🐛 Finde den Denkfehler: Die Betriebsvereinbarung, die niemanden interessiert</strong></p>
 <p>Ein Klinikteam lässt seinen Schichtplan optimieren. Zwei Wünsche kommen aus dem Betrieb:</p>
 <ul>
 <li><strong>Betriebsvereinbarung:</strong> niemand mehr als zwei Dienste in Folge.</li>
@@ -11750,138 +12492,138 @@ genau die Information, die zur Fehlersuche noetig waere.
 <p><em>Auflösung: <a href="#sec:loesungen-cpsat">Abschnitt A.7</a>.</em></p>
 </blockquote>
 <p>Das folgende Programm rechnet den Plan für sechs verschiedene Gewichte durch. Es ist damit zugleich die Antwort auf (c) — und die Tabelle, die man in so einem Fall dem Auftraggeber vorlegt, statt ein Gewicht zu raten.</p>
-<div class="sourceCode" id="cb86"><pre class="sourceCode python"><code class="sourceCode python"><span id="cb86-1"><a href="#cb86-1" aria-hidden="true" tabindex="-1"></a><span class="co">#!/usr/bin/env python3</span></span>
-<span id="cb86-2"><a href="#cb86-2" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb86-3"><a href="#cb86-3" aria-hidden="true" tabindex="-1"></a><span class="co"># Strafgewichte.py</span></span>
-<span id="cb86-4"><a href="#cb86-4" aria-hidden="true" tabindex="-1"></a><span class="co">&quot;&quot;&quot;</span></span>
-<span id="cb86-5"><a href="#cb86-5" aria-hidden="true" tabindex="-1"></a><span class="co">Kapitel CP-SAT: Warum ein Strafgewicht keine Wichtigkeit ausdrueckt, sondern</span></span>
-<span id="cb86-6"><a href="#cb86-6" aria-hidden="true" tabindex="-1"></a><span class="co">einen Wechselkurs.</span></span>
-<span id="cb86-7"><a href="#cb86-7" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb86-8"><a href="#cb86-8" aria-hidden="true" tabindex="-1"></a><span class="co">Weiche Regeln kommen als Strafterm in die Zielfunktion. Die Frage, die dabei</span></span>
-<span id="cb86-9"><a href="#cb86-9" aria-hidden="true" tabindex="-1"></a><span class="co">regelmaessig falsch beantwortet wird, lautet: &quot;Wie gross muss die Strafe sein?&quot;</span></span>
-<span id="cb86-10"><a href="#cb86-10" aria-hidden="true" tabindex="-1"></a><span class="co">Die uebliche Antwort - &quot;je wichtiger, desto groesser&quot; - klingt vernuenftig und</span></span>
-<span id="cb86-11"><a href="#cb86-11" aria-hidden="true" tabindex="-1"></a><span class="co">fuehrt zuverlaessig zu Plaenen, die niemand unterschreiben will.</span></span>
-<span id="cb86-12"><a href="#cb86-12" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb86-13"><a href="#cb86-13" aria-hidden="true" tabindex="-1"></a><span class="co">Der Grund: Zwei Strafgewichte legen nicht Wichtigkeiten fest, sondern einen</span></span>
-<span id="cb86-14"><a href="#cb86-14" aria-hidden="true" tabindex="-1"></a><span class="co">UMRECHNUNGSKURS. Steht die Serienregel bei 1 und der Wunschfrei-Tag bei 10,</span></span>
-<span id="cb86-15"><a href="#cb86-15" aria-hidden="true" tabindex="-1"></a><span class="co">dann hat man dem Solver woertlich gesagt: &quot;Zehn Verstoesse gegen die</span></span>
-<span id="cb86-16"><a href="#cb86-16" aria-hidden="true" tabindex="-1"></a><span class="co">Serienregel sind so schlimm wie ein abgelehnter Wunsch.&quot; Er nimmt das</span></span>
-<span id="cb86-17"><a href="#cb86-17" aria-hidden="true" tabindex="-1"></a><span class="co">ernst - und handelt danach.</span></span>
-<span id="cb86-18"><a href="#cb86-18" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb86-19"><a href="#cb86-19" aria-hidden="true" tabindex="-1"></a><span class="co">Szenario: Schichtplan, 6 Personen, 14 Tage, 4 Besetzungen pro Tag.</span></span>
-<span id="cb86-20"><a href="#cb86-20" aria-hidden="true" tabindex="-1"></a><span class="co">  HART   jeder Tag genau 4 Personen; hoechstens 11 Dienste je Person</span></span>
-<span id="cb86-21"><a href="#cb86-21" aria-hidden="true" tabindex="-1"></a><span class="co">  WEICH  keine drei Dienste in Folge (Betriebsvereinbarung)</span></span>
-<span id="cb86-22"><a href="#cb86-22" aria-hidden="true" tabindex="-1"></a><span class="co">  WEICH  Wunschfrei-Tage einhalten (26 Antraege)</span></span>
-<span id="cb86-23"><a href="#cb86-23" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb86-24"><a href="#cb86-24" aria-hidden="true" tabindex="-1"></a><span class="co">Benoetigt: numpy, ortools</span></span>
-<span id="cb86-25"><a href="#cb86-25" aria-hidden="true" tabindex="-1"></a><span class="co">&quot;&quot;&quot;</span></span>
-<span id="cb86-26"><a href="#cb86-26" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb86-27"><a href="#cb86-27" aria-hidden="true" tabindex="-1"></a><span class="im">from</span> __future__ <span class="im">import</span> annotations</span>
-<span id="cb86-28"><a href="#cb86-28" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb86-29"><a href="#cb86-29" aria-hidden="true" tabindex="-1"></a><span class="im">import</span> numpy <span class="im">as</span> np</span>
-<span id="cb86-30"><a href="#cb86-30" aria-hidden="true" tabindex="-1"></a><span class="im">from</span> ortools.sat.python <span class="im">import</span> cp_model</span>
-<span id="cb86-31"><a href="#cb86-31" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb86-32"><a href="#cb86-32" aria-hidden="true" tabindex="-1"></a>PERSONEN, TAGE, PRO_TAG <span class="op">=</span> <span class="dv">6</span>, <span class="dv">14</span>, <span class="dv">4</span></span>
-<span id="cb86-33"><a href="#cb86-33" aria-hidden="true" tabindex="-1"></a>MAX_DIENSTE <span class="op">=</span> <span class="dv">11</span></span>
-<span id="cb86-34"><a href="#cb86-34" aria-hidden="true" tabindex="-1"></a>STRAFE_WUNSCH <span class="op">=</span> <span class="dv">10</span>                    <span class="co"># bleibt fest - variiert wird die Serienstrafe</span></span>
-<span id="cb86-35"><a href="#cb86-35" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb86-36"><a href="#cb86-36" aria-hidden="true" tabindex="-1"></a>RNG <span class="op">=</span> np.random.default_rng(<span class="dv">2</span>)</span>
-<span id="cb86-37"><a href="#cb86-37" aria-hidden="true" tabindex="-1"></a>WUNSCHFREI <span class="op">=</span> <span class="bu">sorted</span>({(p, t) <span class="cf">for</span> p <span class="kw">in</span> <span class="bu">range</span>(PERSONEN) <span class="cf">for</span> t <span class="kw">in</span> <span class="bu">range</span>(TAGE)</span>
-<span id="cb86-38"><a href="#cb86-38" aria-hidden="true" tabindex="-1"></a>                     <span class="cf">if</span> RNG.random() <span class="op">&lt;</span> <span class="fl">0.35</span>})</span>
-<span id="cb86-39"><a href="#cb86-39" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb86-40"><a href="#cb86-40" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb86-41"><a href="#cb86-41" aria-hidden="true" tabindex="-1"></a><span class="kw">def</span> plane(strafe_serie: <span class="bu">int</span>, zeitlimit: <span class="bu">float</span> <span class="op">=</span> <span class="fl">25.0</span>) <span class="op">-&gt;</span> <span class="bu">dict</span>:</span>
-<span id="cb86-42"><a href="#cb86-42" aria-hidden="true" tabindex="-1"></a>    <span class="co">&quot;&quot;&quot;Baut den Schichtplan mit dem angegebenen Gewicht fuer die Serienregel.&quot;&quot;&quot;</span></span>
-<span id="cb86-43"><a href="#cb86-43" aria-hidden="true" tabindex="-1"></a>    modell <span class="op">=</span> cp_model.CpModel()</span>
-<span id="cb86-44"><a href="#cb86-44" aria-hidden="true" tabindex="-1"></a>    x <span class="op">=</span> {(p, t): modell.NewBoolVar(<span class="ss">f&quot;x_</span><span class="sc">{</span>p<span class="sc">}</span><span class="ss">_</span><span class="sc">{</span>t<span class="sc">}</span><span class="ss">&quot;</span>)</span>
-<span id="cb86-45"><a href="#cb86-45" aria-hidden="true" tabindex="-1"></a>         <span class="cf">for</span> p <span class="kw">in</span> <span class="bu">range</span>(PERSONEN) <span class="cf">for</span> t <span class="kw">in</span> <span class="bu">range</span>(TAGE)}</span>
-<span id="cb86-46"><a href="#cb86-46" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb86-47"><a href="#cb86-47" aria-hidden="true" tabindex="-1"></a>    <span class="co"># --- harte Regeln --------------------------------------------------</span></span>
-<span id="cb86-48"><a href="#cb86-48" aria-hidden="true" tabindex="-1"></a>    <span class="cf">for</span> t <span class="kw">in</span> <span class="bu">range</span>(TAGE):</span>
-<span id="cb86-49"><a href="#cb86-49" aria-hidden="true" tabindex="-1"></a>        modell.Add(<span class="bu">sum</span>(x[p, t] <span class="cf">for</span> p <span class="kw">in</span> <span class="bu">range</span>(PERSONEN)) <span class="op">==</span> PRO_TAG)</span>
-<span id="cb86-50"><a href="#cb86-50" aria-hidden="true" tabindex="-1"></a>    <span class="cf">for</span> p <span class="kw">in</span> <span class="bu">range</span>(PERSONEN):</span>
-<span id="cb86-51"><a href="#cb86-51" aria-hidden="true" tabindex="-1"></a>        modell.Add(<span class="bu">sum</span>(x[p, t] <span class="cf">for</span> t <span class="kw">in</span> <span class="bu">range</span>(TAGE)) <span class="op">&lt;=</span> MAX_DIENSTE)</span>
-<span id="cb86-52"><a href="#cb86-52" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb86-53"><a href="#cb86-53" aria-hidden="true" tabindex="-1"></a>    <span class="co"># --- weiche Regel 1: keine drei Dienste in Folge --------------------</span></span>
-<span id="cb86-54"><a href="#cb86-54" aria-hidden="true" tabindex="-1"></a>    <span class="co"># serie[p, t] = 1  &lt;=&gt;  Person p arbeitet an t, t+1 UND t+2.</span></span>
-<span id="cb86-55"><a href="#cb86-55" aria-hidden="true" tabindex="-1"></a>    <span class="co"># Die Ungleichung erzwingt das nur in eine Richtung; das genuegt, weil</span></span>
-<span id="cb86-56"><a href="#cb86-56" aria-hidden="true" tabindex="-1"></a>    <span class="co"># der Solver serie minimiert - er wuerde die Variable nie freiwillig</span></span>
-<span id="cb86-57"><a href="#cb86-57" aria-hidden="true" tabindex="-1"></a>    <span class="co"># auf 1 setzen.</span></span>
-<span id="cb86-58"><a href="#cb86-58" aria-hidden="true" tabindex="-1"></a>    strafterme <span class="op">=</span> []</span>
-<span id="cb86-59"><a href="#cb86-59" aria-hidden="true" tabindex="-1"></a>    serien <span class="op">=</span> []</span>
-<span id="cb86-60"><a href="#cb86-60" aria-hidden="true" tabindex="-1"></a>    <span class="cf">for</span> p <span class="kw">in</span> <span class="bu">range</span>(PERSONEN):</span>
-<span id="cb86-61"><a href="#cb86-61" aria-hidden="true" tabindex="-1"></a>        <span class="cf">for</span> t <span class="kw">in</span> <span class="bu">range</span>(TAGE <span class="op">-</span> <span class="dv">2</span>):</span>
-<span id="cb86-62"><a href="#cb86-62" aria-hidden="true" tabindex="-1"></a>            serie <span class="op">=</span> modell.NewBoolVar(<span class="ss">f&quot;serie_</span><span class="sc">{</span>p<span class="sc">}</span><span class="ss">_</span><span class="sc">{</span>t<span class="sc">}</span><span class="ss">&quot;</span>)</span>
-<span id="cb86-63"><a href="#cb86-63" aria-hidden="true" tabindex="-1"></a>            modell.Add(x[p, t] <span class="op">+</span> x[p, t <span class="op">+</span> <span class="dv">1</span>] <span class="op">+</span> x[p, t <span class="op">+</span> <span class="dv">2</span>] <span class="op">&lt;=</span> <span class="dv">2</span> <span class="op">+</span> serie)</span>
-<span id="cb86-64"><a href="#cb86-64" aria-hidden="true" tabindex="-1"></a>            serien.append(serie)</span>
-<span id="cb86-65"><a href="#cb86-65" aria-hidden="true" tabindex="-1"></a>            strafterme.append(serie <span class="op">*</span> strafe_serie)</span>
-<span id="cb86-66"><a href="#cb86-66" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb86-67"><a href="#cb86-67" aria-hidden="true" tabindex="-1"></a>    <span class="co"># --- weiche Regel 2: Wunschfrei ------------------------------------</span></span>
-<span id="cb86-68"><a href="#cb86-68" aria-hidden="true" tabindex="-1"></a>    wunschverstoesse <span class="op">=</span> []</span>
-<span id="cb86-69"><a href="#cb86-69" aria-hidden="true" tabindex="-1"></a>    <span class="cf">for</span> p, t <span class="kw">in</span> WUNSCHFREI:</span>
-<span id="cb86-70"><a href="#cb86-70" aria-hidden="true" tabindex="-1"></a>        wunschverstoesse.append(x[p, t])</span>
-<span id="cb86-71"><a href="#cb86-71" aria-hidden="true" tabindex="-1"></a>        strafterme.append(x[p, t] <span class="op">*</span> STRAFE_WUNSCH)</span>
-<span id="cb86-72"><a href="#cb86-72" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb86-73"><a href="#cb86-73" aria-hidden="true" tabindex="-1"></a>    modell.Minimize(<span class="bu">sum</span>(strafterme))</span>
-<span id="cb86-74"><a href="#cb86-74" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb86-75"><a href="#cb86-75" aria-hidden="true" tabindex="-1"></a>    loeser <span class="op">=</span> cp_model.CpSolver()</span>
-<span id="cb86-76"><a href="#cb86-76" aria-hidden="true" tabindex="-1"></a>    loeser.parameters.max_time_in_seconds <span class="op">=</span> zeitlimit</span>
-<span id="cb86-77"><a href="#cb86-77" aria-hidden="true" tabindex="-1"></a>    loeser.parameters.num_workers <span class="op">=</span> <span class="dv">1</span>          <span class="co"># reproduzierbare Buchausgabe</span></span>
-<span id="cb86-78"><a href="#cb86-78" aria-hidden="true" tabindex="-1"></a>    loeser.parameters.random_seed <span class="op">=</span> <span class="dv">1</span></span>
-<span id="cb86-79"><a href="#cb86-79" aria-hidden="true" tabindex="-1"></a>    status <span class="op">=</span> loeser.Solve(modell)</span>
-<span id="cb86-80"><a href="#cb86-80" aria-hidden="true" tabindex="-1"></a>    <span class="cf">if</span> status <span class="kw">not</span> <span class="kw">in</span> (cp_model.OPTIMAL, cp_model.FEASIBLE):</span>
-<span id="cb86-81"><a href="#cb86-81" aria-hidden="true" tabindex="-1"></a>        <span class="cf">raise</span> <span class="pp">RuntimeError</span>(<span class="ss">f&quot;Kein Plan: </span><span class="sc">{</span>loeser<span class="sc">.</span>StatusName(status)<span class="sc">}</span><span class="ss">&quot;</span>)</span>
-<span id="cb86-82"><a href="#cb86-82" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb86-83"><a href="#cb86-83" aria-hidden="true" tabindex="-1"></a>    <span class="cf">return</span> {</span>
-<span id="cb86-84"><a href="#cb86-84" aria-hidden="true" tabindex="-1"></a>        <span class="st">&quot;status&quot;</span>: loeser.StatusName(status),</span>
-<span id="cb86-85"><a href="#cb86-85" aria-hidden="true" tabindex="-1"></a>        <span class="st">&quot;zielwert&quot;</span>: loeser.ObjectiveValue(),</span>
-<span id="cb86-86"><a href="#cb86-86" aria-hidden="true" tabindex="-1"></a>        <span class="st">&quot;serien&quot;</span>: <span class="bu">sum</span>(loeser.Value(v) <span class="cf">for</span> v <span class="kw">in</span> serien),</span>
-<span id="cb86-87"><a href="#cb86-87" aria-hidden="true" tabindex="-1"></a>        <span class="st">&quot;wunsch_verletzt&quot;</span>: <span class="bu">sum</span>(loeser.Value(v) <span class="cf">for</span> v <span class="kw">in</span> wunschverstoesse),</span>
-<span id="cb86-88"><a href="#cb86-88" aria-hidden="true" tabindex="-1"></a>    }</span>
-<span id="cb86-89"><a href="#cb86-89" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb86-90"><a href="#cb86-90" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb86-91"><a href="#cb86-91" aria-hidden="true" tabindex="-1"></a><span class="cf">if</span> <span class="va">__name__</span> <span class="op">==</span> <span class="st">&quot;__main__&quot;</span>:</span>
-<span id="cb86-92"><a href="#cb86-92" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;=&quot;</span> <span class="op">*</span> <span class="dv">78</span>)</span>
-<span id="cb86-93"><a href="#cb86-93" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;  STRAFGEWICHTE SIND WECHSELKURSE, KEINE WICHTIGKEITEN&quot;</span>)</span>
-<span id="cb86-94"><a href="#cb86-94" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;=&quot;</span> <span class="op">*</span> <span class="dv">78</span>)</span>
-<span id="cb86-95"><a href="#cb86-95" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;</span><span class="sc">{</span>PERSONEN<span class="sc">}</span><span class="ss"> Personen, </span><span class="sc">{</span>TAGE<span class="sc">}</span><span class="ss"> Tage, </span><span class="sc">{</span>PRO_TAG<span class="sc">}</span><span class="ss"> Besetzungen pro Tag &quot;</span></span>
-<span id="cb86-96"><a href="#cb86-96" aria-hidden="true" tabindex="-1"></a>          <span class="ss">f&quot;= </span><span class="sc">{</span>TAGE <span class="op">*</span> PRO_TAG<span class="sc">}</span><span class="ss"> Dienste&quot;</span>)</span>
-<span id="cb86-97"><a href="#cb86-97" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;Das sind </span><span class="sc">{</span>TAGE <span class="op">*</span> PRO_TAG <span class="op">/</span> PERSONEN<span class="sc">:.1f}</span><span class="ss"> Dienste je Person - der Plan ist eng.&quot;</span>)</span>
-<span id="cb86-98"><a href="#cb86-98" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;</span><span class="sc">{</span><span class="bu">len</span>(WUNSCHFREI)<span class="sc">}</span><span class="ss"> Wunschfrei-Antraege, Strafe je abgelehntem Wunsch: &quot;</span></span>
-<span id="cb86-99"><a href="#cb86-99" aria-hidden="true" tabindex="-1"></a>          <span class="ss">f&quot;</span><span class="sc">{</span>STRAFE_WUNSCH<span class="sc">}</span><span class="ch">\n</span><span class="ss">&quot;</span>)</span>
-<span id="cb86-100"><a href="#cb86-100" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb86-101"><a href="#cb86-101" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;</span><span class="sc">{</span><span class="st">&#39;Strafe je 3er-Serie&#39;</span><span class="sc">:&gt;20}</span><span class="ss"> </span><span class="sc">{</span><span class="st">&#39;3er-Serien&#39;</span><span class="sc">:&gt;12}</span><span class="ss"> </span><span class="sc">{</span><span class="st">&#39;Wunsch verletzt&#39;</span><span class="sc">:&gt;17}</span><span class="ss"> &quot;</span></span>
-<span id="cb86-102"><a href="#cb86-102" aria-hidden="true" tabindex="-1"></a>          <span class="ss">f&quot;</span><span class="sc">{</span><span class="st">&#39;Zielwert&#39;</span><span class="sc">:&gt;10}</span><span class="ss">&quot;</span>)</span>
-<span id="cb86-103"><a href="#cb86-103" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;-&quot;</span> <span class="op">*</span> <span class="dv">78</span>)</span>
-<span id="cb86-104"><a href="#cb86-104" aria-hidden="true" tabindex="-1"></a>    ergebnisse <span class="op">=</span> {}</span>
-<span id="cb86-105"><a href="#cb86-105" aria-hidden="true" tabindex="-1"></a>    <span class="cf">for</span> strafe <span class="kw">in</span> (<span class="dv">1</span>, <span class="dv">2</span>, <span class="dv">5</span>, <span class="dv">10</span>, <span class="dv">30</span>, <span class="dv">100</span>):</span>
-<span id="cb86-106"><a href="#cb86-106" aria-hidden="true" tabindex="-1"></a>        e <span class="op">=</span> plane(strafe)</span>
-<span id="cb86-107"><a href="#cb86-107" aria-hidden="true" tabindex="-1"></a>        ergebnisse[strafe] <span class="op">=</span> e</span>
-<span id="cb86-108"><a href="#cb86-108" aria-hidden="true" tabindex="-1"></a>        <span class="bu">print</span>(<span class="ss">f&quot;</span><span class="sc">{</span>strafe<span class="sc">:&gt;20}</span><span class="ss"> </span><span class="sc">{</span>e[<span class="st">&#39;serien&#39;</span>]<span class="sc">:&gt;12}</span><span class="ss"> </span><span class="sc">{</span>e[<span class="st">&#39;wunsch_verletzt&#39;</span>]<span class="sc">:&gt;17}</span><span class="ss"> &quot;</span></span>
-<span id="cb86-109"><a href="#cb86-109" aria-hidden="true" tabindex="-1"></a>              <span class="ss">f&quot;</span><span class="sc">{</span>e[<span class="st">&#39;zielwert&#39;</span>]<span class="sc">:&gt;10.0f}</span><span class="ss">&quot;</span>)</span>
-<span id="cb86-110"><a href="#cb86-110" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;-&quot;</span> <span class="op">*</span> <span class="dv">78</span>)</span>
-<span id="cb86-111"><a href="#cb86-111" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb86-112"><a href="#cb86-112" aria-hidden="true" tabindex="-1"></a>    niedrig, hoch <span class="op">=</span> ergebnisse[<span class="dv">1</span>], ergebnisse[<span class="dv">30</span>]</span>
-<span id="cb86-113"><a href="#cb86-113" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;</span><span class="ch">\n</span><span class="ss">Bei Strafe 1 baut der Solver </span><span class="sc">{</span>niedrig[<span class="st">&#39;serien&#39;</span>]<span class="sc">}</span><span class="ss"> Drei-Tage-Serien ein.&quot;</span>)</span>
-<span id="cb86-114"><a href="#cb86-114" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;Die Betriebsvereinbarung steht im Modell - und wird trotzdem&quot;</span>)</span>
-<span id="cb86-115"><a href="#cb86-115" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;systematisch verletzt. Das ist kein Fehler des Solvers: Bei einem&quot;</span>)</span>
-<span id="cb86-116"><a href="#cb86-116" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;Gewicht von 1 gegen </span><span class="sc">{</span>STRAFE_WUNSCH<span class="sc">}</span><span class="ss"> lohnt sich jede Serie, solange sie&quot;</span>)</span>
-<span id="cb86-117"><a href="#cb86-117" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;auch nur einen Zehntel-Wunsch rettet.&quot;</span>)</span>
-<span id="cb86-118"><a href="#cb86-118" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;</span><span class="ch">\n</span><span class="ss">Bei Strafe 30 sind es </span><span class="sc">{</span>hoch[<span class="st">&#39;serien&#39;</span>]<span class="sc">}</span><span class="ss"> Serien - dafuer werden&quot;</span>)</span>
-<span id="cb86-119"><a href="#cb86-119" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;</span><span class="sc">{</span>hoch[<span class="st">&#39;wunsch_verletzt&#39;</span>]<span class="sc">}</span><span class="ss"> statt </span><span class="sc">{</span>niedrig[<span class="st">&#39;wunsch_verletzt&#39;</span>]<span class="sc">}</span><span class="ss"> Wuensche abgelehnt.&quot;</span>)</span>
-<span id="cb86-120"><a href="#cb86-120" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;Beide Plaene sind optimal. Sie beantworten nur verschiedene Fragen.&quot;</span>)</span>
-<span id="cb86-121"><a href="#cb86-121" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>()</span>
-<span id="cb86-122"><a href="#cb86-122" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;Die Frage lautet also nie &#39;wie wichtig ist mir diese Regel?&#39;, sondern:&quot;</span>)</span>
-<span id="cb86-123"><a href="#cb86-123" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;  &#39;Wie viele abgelehnte Wuensche bin ich bereit zu akzeptieren,&quot;</span>)</span>
-<span id="cb86-124"><a href="#cb86-124" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;   um eine Drei-Tage-Serie zu vermeiden?&#39;&quot;</span>)</span>
-<span id="cb86-125"><a href="#cb86-125" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;Wer darauf keine Zahl nennen kann, hat das Problem noch nicht&quot;</span>)</span>
-<span id="cb86-126"><a href="#cb86-126" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;verstanden - und sollte diese Tabelle dem Auftraggeber vorlegen,&quot;</span>)</span>
-<span id="cb86-127"><a href="#cb86-127" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;statt ein Gewicht zu raten.&quot;</span>)</span>
-<span id="cb86-128"><a href="#cb86-128" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>()</span>
-<span id="cb86-129"><a href="#cb86-129" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;Und die wichtigste Konsequenz: Eine Regel, die NIE gebrochen werden&quot;</span>)</span>
-<span id="cb86-130"><a href="#cb86-130" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;darf, gehoert nicht in die Zielfunktion, sondern unter die harten&quot;</span>)</span>
-<span id="cb86-131"><a href="#cb86-131" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;Nebenbedingungen. Alles, was einen Preis hat, wird irgendwann gekauft.&quot;</span>)</span>
-<span id="cb86-132"><a href="#cb86-132" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;=&quot;</span> <span class="op">*</span> <span class="dv">78</span>)</span></code></pre></div>
+<div class="sourceCode" id="cb88"><pre class="sourceCode python"><code class="sourceCode python"><span id="cb88-1"><a href="#cb88-1" aria-hidden="true" tabindex="-1"></a><span class="co">#!/usr/bin/env python3</span></span>
+<span id="cb88-2"><a href="#cb88-2" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb88-3"><a href="#cb88-3" aria-hidden="true" tabindex="-1"></a><span class="co"># Strafgewichte.py</span></span>
+<span id="cb88-4"><a href="#cb88-4" aria-hidden="true" tabindex="-1"></a><span class="co">&quot;&quot;&quot;</span></span>
+<span id="cb88-5"><a href="#cb88-5" aria-hidden="true" tabindex="-1"></a><span class="co">Kapitel CP-SAT: Warum ein Strafgewicht keine Wichtigkeit ausdrueckt, sondern</span></span>
+<span id="cb88-6"><a href="#cb88-6" aria-hidden="true" tabindex="-1"></a><span class="co">einen Wechselkurs.</span></span>
+<span id="cb88-7"><a href="#cb88-7" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb88-8"><a href="#cb88-8" aria-hidden="true" tabindex="-1"></a><span class="co">Weiche Regeln kommen als Strafterm in die Zielfunktion. Die Frage, die dabei</span></span>
+<span id="cb88-9"><a href="#cb88-9" aria-hidden="true" tabindex="-1"></a><span class="co">regelmaessig falsch beantwortet wird, lautet: &quot;Wie gross muss die Strafe sein?&quot;</span></span>
+<span id="cb88-10"><a href="#cb88-10" aria-hidden="true" tabindex="-1"></a><span class="co">Die uebliche Antwort - &quot;je wichtiger, desto groesser&quot; - klingt vernuenftig und</span></span>
+<span id="cb88-11"><a href="#cb88-11" aria-hidden="true" tabindex="-1"></a><span class="co">fuehrt zuverlaessig zu Plaenen, die niemand unterschreiben will.</span></span>
+<span id="cb88-12"><a href="#cb88-12" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb88-13"><a href="#cb88-13" aria-hidden="true" tabindex="-1"></a><span class="co">Der Grund: Zwei Strafgewichte legen nicht Wichtigkeiten fest, sondern einen</span></span>
+<span id="cb88-14"><a href="#cb88-14" aria-hidden="true" tabindex="-1"></a><span class="co">UMRECHNUNGSKURS. Steht die Serienregel bei 1 und der Wunschfrei-Tag bei 10,</span></span>
+<span id="cb88-15"><a href="#cb88-15" aria-hidden="true" tabindex="-1"></a><span class="co">dann hat man dem Solver woertlich gesagt: &quot;Zehn Verstoesse gegen die</span></span>
+<span id="cb88-16"><a href="#cb88-16" aria-hidden="true" tabindex="-1"></a><span class="co">Serienregel sind so schlimm wie ein abgelehnter Wunsch.&quot; Er nimmt das</span></span>
+<span id="cb88-17"><a href="#cb88-17" aria-hidden="true" tabindex="-1"></a><span class="co">ernst - und handelt danach.</span></span>
+<span id="cb88-18"><a href="#cb88-18" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb88-19"><a href="#cb88-19" aria-hidden="true" tabindex="-1"></a><span class="co">Szenario: Schichtplan, 6 Personen, 14 Tage, 4 Besetzungen pro Tag.</span></span>
+<span id="cb88-20"><a href="#cb88-20" aria-hidden="true" tabindex="-1"></a><span class="co">  HART   jeder Tag genau 4 Personen; hoechstens 11 Dienste je Person</span></span>
+<span id="cb88-21"><a href="#cb88-21" aria-hidden="true" tabindex="-1"></a><span class="co">  WEICH  keine drei Dienste in Folge (Betriebsvereinbarung)</span></span>
+<span id="cb88-22"><a href="#cb88-22" aria-hidden="true" tabindex="-1"></a><span class="co">  WEICH  Wunschfrei-Tage einhalten (26 Antraege)</span></span>
+<span id="cb88-23"><a href="#cb88-23" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb88-24"><a href="#cb88-24" aria-hidden="true" tabindex="-1"></a><span class="co">Benoetigt: numpy, ortools</span></span>
+<span id="cb88-25"><a href="#cb88-25" aria-hidden="true" tabindex="-1"></a><span class="co">&quot;&quot;&quot;</span></span>
+<span id="cb88-26"><a href="#cb88-26" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb88-27"><a href="#cb88-27" aria-hidden="true" tabindex="-1"></a><span class="im">from</span> __future__ <span class="im">import</span> annotations</span>
+<span id="cb88-28"><a href="#cb88-28" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb88-29"><a href="#cb88-29" aria-hidden="true" tabindex="-1"></a><span class="im">import</span> numpy <span class="im">as</span> np</span>
+<span id="cb88-30"><a href="#cb88-30" aria-hidden="true" tabindex="-1"></a><span class="im">from</span> ortools.sat.python <span class="im">import</span> cp_model</span>
+<span id="cb88-31"><a href="#cb88-31" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb88-32"><a href="#cb88-32" aria-hidden="true" tabindex="-1"></a>PERSONEN, TAGE, PRO_TAG <span class="op">=</span> <span class="dv">6</span>, <span class="dv">14</span>, <span class="dv">4</span></span>
+<span id="cb88-33"><a href="#cb88-33" aria-hidden="true" tabindex="-1"></a>MAX_DIENSTE <span class="op">=</span> <span class="dv">11</span></span>
+<span id="cb88-34"><a href="#cb88-34" aria-hidden="true" tabindex="-1"></a>STRAFE_WUNSCH <span class="op">=</span> <span class="dv">10</span>                    <span class="co"># bleibt fest - variiert wird die Serienstrafe</span></span>
+<span id="cb88-35"><a href="#cb88-35" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb88-36"><a href="#cb88-36" aria-hidden="true" tabindex="-1"></a>RNG <span class="op">=</span> np.random.default_rng(<span class="dv">2</span>)</span>
+<span id="cb88-37"><a href="#cb88-37" aria-hidden="true" tabindex="-1"></a>WUNSCHFREI <span class="op">=</span> <span class="bu">sorted</span>({(p, t) <span class="cf">for</span> p <span class="kw">in</span> <span class="bu">range</span>(PERSONEN) <span class="cf">for</span> t <span class="kw">in</span> <span class="bu">range</span>(TAGE)</span>
+<span id="cb88-38"><a href="#cb88-38" aria-hidden="true" tabindex="-1"></a>                     <span class="cf">if</span> RNG.random() <span class="op">&lt;</span> <span class="fl">0.35</span>})</span>
+<span id="cb88-39"><a href="#cb88-39" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb88-40"><a href="#cb88-40" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb88-41"><a href="#cb88-41" aria-hidden="true" tabindex="-1"></a><span class="kw">def</span> plane(strafe_serie: <span class="bu">int</span>, zeitlimit: <span class="bu">float</span> <span class="op">=</span> <span class="fl">25.0</span>) <span class="op">-&gt;</span> <span class="bu">dict</span>:</span>
+<span id="cb88-42"><a href="#cb88-42" aria-hidden="true" tabindex="-1"></a>    <span class="co">&quot;&quot;&quot;Baut den Schichtplan mit dem angegebenen Gewicht fuer die Serienregel.&quot;&quot;&quot;</span></span>
+<span id="cb88-43"><a href="#cb88-43" aria-hidden="true" tabindex="-1"></a>    modell <span class="op">=</span> cp_model.CpModel()</span>
+<span id="cb88-44"><a href="#cb88-44" aria-hidden="true" tabindex="-1"></a>    x <span class="op">=</span> {(p, t): modell.NewBoolVar(<span class="ss">f&quot;x_</span><span class="sc">{</span>p<span class="sc">}</span><span class="ss">_</span><span class="sc">{</span>t<span class="sc">}</span><span class="ss">&quot;</span>)</span>
+<span id="cb88-45"><a href="#cb88-45" aria-hidden="true" tabindex="-1"></a>         <span class="cf">for</span> p <span class="kw">in</span> <span class="bu">range</span>(PERSONEN) <span class="cf">for</span> t <span class="kw">in</span> <span class="bu">range</span>(TAGE)}</span>
+<span id="cb88-46"><a href="#cb88-46" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb88-47"><a href="#cb88-47" aria-hidden="true" tabindex="-1"></a>    <span class="co"># --- harte Regeln --------------------------------------------------</span></span>
+<span id="cb88-48"><a href="#cb88-48" aria-hidden="true" tabindex="-1"></a>    <span class="cf">for</span> t <span class="kw">in</span> <span class="bu">range</span>(TAGE):</span>
+<span id="cb88-49"><a href="#cb88-49" aria-hidden="true" tabindex="-1"></a>        modell.Add(<span class="bu">sum</span>(x[p, t] <span class="cf">for</span> p <span class="kw">in</span> <span class="bu">range</span>(PERSONEN)) <span class="op">==</span> PRO_TAG)</span>
+<span id="cb88-50"><a href="#cb88-50" aria-hidden="true" tabindex="-1"></a>    <span class="cf">for</span> p <span class="kw">in</span> <span class="bu">range</span>(PERSONEN):</span>
+<span id="cb88-51"><a href="#cb88-51" aria-hidden="true" tabindex="-1"></a>        modell.Add(<span class="bu">sum</span>(x[p, t] <span class="cf">for</span> t <span class="kw">in</span> <span class="bu">range</span>(TAGE)) <span class="op">&lt;=</span> MAX_DIENSTE)</span>
+<span id="cb88-52"><a href="#cb88-52" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb88-53"><a href="#cb88-53" aria-hidden="true" tabindex="-1"></a>    <span class="co"># --- weiche Regel 1: keine drei Dienste in Folge --------------------</span></span>
+<span id="cb88-54"><a href="#cb88-54" aria-hidden="true" tabindex="-1"></a>    <span class="co"># serie[p, t] = 1  &lt;=&gt;  Person p arbeitet an t, t+1 UND t+2.</span></span>
+<span id="cb88-55"><a href="#cb88-55" aria-hidden="true" tabindex="-1"></a>    <span class="co"># Die Ungleichung erzwingt das nur in eine Richtung; das genuegt, weil</span></span>
+<span id="cb88-56"><a href="#cb88-56" aria-hidden="true" tabindex="-1"></a>    <span class="co"># der Solver serie minimiert - er wuerde die Variable nie freiwillig</span></span>
+<span id="cb88-57"><a href="#cb88-57" aria-hidden="true" tabindex="-1"></a>    <span class="co"># auf 1 setzen.</span></span>
+<span id="cb88-58"><a href="#cb88-58" aria-hidden="true" tabindex="-1"></a>    strafterme <span class="op">=</span> []</span>
+<span id="cb88-59"><a href="#cb88-59" aria-hidden="true" tabindex="-1"></a>    serien <span class="op">=</span> []</span>
+<span id="cb88-60"><a href="#cb88-60" aria-hidden="true" tabindex="-1"></a>    <span class="cf">for</span> p <span class="kw">in</span> <span class="bu">range</span>(PERSONEN):</span>
+<span id="cb88-61"><a href="#cb88-61" aria-hidden="true" tabindex="-1"></a>        <span class="cf">for</span> t <span class="kw">in</span> <span class="bu">range</span>(TAGE <span class="op">-</span> <span class="dv">2</span>):</span>
+<span id="cb88-62"><a href="#cb88-62" aria-hidden="true" tabindex="-1"></a>            serie <span class="op">=</span> modell.NewBoolVar(<span class="ss">f&quot;serie_</span><span class="sc">{</span>p<span class="sc">}</span><span class="ss">_</span><span class="sc">{</span>t<span class="sc">}</span><span class="ss">&quot;</span>)</span>
+<span id="cb88-63"><a href="#cb88-63" aria-hidden="true" tabindex="-1"></a>            modell.Add(x[p, t] <span class="op">+</span> x[p, t <span class="op">+</span> <span class="dv">1</span>] <span class="op">+</span> x[p, t <span class="op">+</span> <span class="dv">2</span>] <span class="op">&lt;=</span> <span class="dv">2</span> <span class="op">+</span> serie)</span>
+<span id="cb88-64"><a href="#cb88-64" aria-hidden="true" tabindex="-1"></a>            serien.append(serie)</span>
+<span id="cb88-65"><a href="#cb88-65" aria-hidden="true" tabindex="-1"></a>            strafterme.append(serie <span class="op">*</span> strafe_serie)</span>
+<span id="cb88-66"><a href="#cb88-66" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb88-67"><a href="#cb88-67" aria-hidden="true" tabindex="-1"></a>    <span class="co"># --- weiche Regel 2: Wunschfrei ------------------------------------</span></span>
+<span id="cb88-68"><a href="#cb88-68" aria-hidden="true" tabindex="-1"></a>    wunschverstoesse <span class="op">=</span> []</span>
+<span id="cb88-69"><a href="#cb88-69" aria-hidden="true" tabindex="-1"></a>    <span class="cf">for</span> p, t <span class="kw">in</span> WUNSCHFREI:</span>
+<span id="cb88-70"><a href="#cb88-70" aria-hidden="true" tabindex="-1"></a>        wunschverstoesse.append(x[p, t])</span>
+<span id="cb88-71"><a href="#cb88-71" aria-hidden="true" tabindex="-1"></a>        strafterme.append(x[p, t] <span class="op">*</span> STRAFE_WUNSCH)</span>
+<span id="cb88-72"><a href="#cb88-72" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb88-73"><a href="#cb88-73" aria-hidden="true" tabindex="-1"></a>    modell.Minimize(<span class="bu">sum</span>(strafterme))</span>
+<span id="cb88-74"><a href="#cb88-74" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb88-75"><a href="#cb88-75" aria-hidden="true" tabindex="-1"></a>    loeser <span class="op">=</span> cp_model.CpSolver()</span>
+<span id="cb88-76"><a href="#cb88-76" aria-hidden="true" tabindex="-1"></a>    loeser.parameters.max_time_in_seconds <span class="op">=</span> zeitlimit</span>
+<span id="cb88-77"><a href="#cb88-77" aria-hidden="true" tabindex="-1"></a>    loeser.parameters.num_workers <span class="op">=</span> <span class="dv">1</span>          <span class="co"># reproduzierbare Buchausgabe</span></span>
+<span id="cb88-78"><a href="#cb88-78" aria-hidden="true" tabindex="-1"></a>    loeser.parameters.random_seed <span class="op">=</span> <span class="dv">1</span></span>
+<span id="cb88-79"><a href="#cb88-79" aria-hidden="true" tabindex="-1"></a>    status <span class="op">=</span> loeser.Solve(modell)</span>
+<span id="cb88-80"><a href="#cb88-80" aria-hidden="true" tabindex="-1"></a>    <span class="cf">if</span> status <span class="kw">not</span> <span class="kw">in</span> (cp_model.OPTIMAL, cp_model.FEASIBLE):</span>
+<span id="cb88-81"><a href="#cb88-81" aria-hidden="true" tabindex="-1"></a>        <span class="cf">raise</span> <span class="pp">RuntimeError</span>(<span class="ss">f&quot;Kein Plan: </span><span class="sc">{</span>loeser<span class="sc">.</span>StatusName(status)<span class="sc">}</span><span class="ss">&quot;</span>)</span>
+<span id="cb88-82"><a href="#cb88-82" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb88-83"><a href="#cb88-83" aria-hidden="true" tabindex="-1"></a>    <span class="cf">return</span> {</span>
+<span id="cb88-84"><a href="#cb88-84" aria-hidden="true" tabindex="-1"></a>        <span class="st">&quot;status&quot;</span>: loeser.StatusName(status),</span>
+<span id="cb88-85"><a href="#cb88-85" aria-hidden="true" tabindex="-1"></a>        <span class="st">&quot;zielwert&quot;</span>: loeser.ObjectiveValue(),</span>
+<span id="cb88-86"><a href="#cb88-86" aria-hidden="true" tabindex="-1"></a>        <span class="st">&quot;serien&quot;</span>: <span class="bu">sum</span>(loeser.Value(v) <span class="cf">for</span> v <span class="kw">in</span> serien),</span>
+<span id="cb88-87"><a href="#cb88-87" aria-hidden="true" tabindex="-1"></a>        <span class="st">&quot;wunsch_verletzt&quot;</span>: <span class="bu">sum</span>(loeser.Value(v) <span class="cf">for</span> v <span class="kw">in</span> wunschverstoesse),</span>
+<span id="cb88-88"><a href="#cb88-88" aria-hidden="true" tabindex="-1"></a>    }</span>
+<span id="cb88-89"><a href="#cb88-89" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb88-90"><a href="#cb88-90" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb88-91"><a href="#cb88-91" aria-hidden="true" tabindex="-1"></a><span class="cf">if</span> <span class="va">__name__</span> <span class="op">==</span> <span class="st">&quot;__main__&quot;</span>:</span>
+<span id="cb88-92"><a href="#cb88-92" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;=&quot;</span> <span class="op">*</span> <span class="dv">78</span>)</span>
+<span id="cb88-93"><a href="#cb88-93" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;  STRAFGEWICHTE SIND WECHSELKURSE, KEINE WICHTIGKEITEN&quot;</span>)</span>
+<span id="cb88-94"><a href="#cb88-94" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;=&quot;</span> <span class="op">*</span> <span class="dv">78</span>)</span>
+<span id="cb88-95"><a href="#cb88-95" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;</span><span class="sc">{</span>PERSONEN<span class="sc">}</span><span class="ss"> Personen, </span><span class="sc">{</span>TAGE<span class="sc">}</span><span class="ss"> Tage, </span><span class="sc">{</span>PRO_TAG<span class="sc">}</span><span class="ss"> Besetzungen pro Tag &quot;</span></span>
+<span id="cb88-96"><a href="#cb88-96" aria-hidden="true" tabindex="-1"></a>          <span class="ss">f&quot;= </span><span class="sc">{</span>TAGE <span class="op">*</span> PRO_TAG<span class="sc">}</span><span class="ss"> Dienste&quot;</span>)</span>
+<span id="cb88-97"><a href="#cb88-97" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;Das sind </span><span class="sc">{</span>TAGE <span class="op">*</span> PRO_TAG <span class="op">/</span> PERSONEN<span class="sc">:.1f}</span><span class="ss"> Dienste je Person - der Plan ist eng.&quot;</span>)</span>
+<span id="cb88-98"><a href="#cb88-98" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;</span><span class="sc">{</span><span class="bu">len</span>(WUNSCHFREI)<span class="sc">}</span><span class="ss"> Wunschfrei-Antraege, Strafe je abgelehntem Wunsch: &quot;</span></span>
+<span id="cb88-99"><a href="#cb88-99" aria-hidden="true" tabindex="-1"></a>          <span class="ss">f&quot;</span><span class="sc">{</span>STRAFE_WUNSCH<span class="sc">}</span><span class="ch">\n</span><span class="ss">&quot;</span>)</span>
+<span id="cb88-100"><a href="#cb88-100" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb88-101"><a href="#cb88-101" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;</span><span class="sc">{</span><span class="st">&#39;Strafe je 3er-Serie&#39;</span><span class="sc">:&gt;20}</span><span class="ss"> </span><span class="sc">{</span><span class="st">&#39;3er-Serien&#39;</span><span class="sc">:&gt;12}</span><span class="ss"> </span><span class="sc">{</span><span class="st">&#39;Wunsch verletzt&#39;</span><span class="sc">:&gt;17}</span><span class="ss"> &quot;</span></span>
+<span id="cb88-102"><a href="#cb88-102" aria-hidden="true" tabindex="-1"></a>          <span class="ss">f&quot;</span><span class="sc">{</span><span class="st">&#39;Zielwert&#39;</span><span class="sc">:&gt;10}</span><span class="ss">&quot;</span>)</span>
+<span id="cb88-103"><a href="#cb88-103" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;-&quot;</span> <span class="op">*</span> <span class="dv">78</span>)</span>
+<span id="cb88-104"><a href="#cb88-104" aria-hidden="true" tabindex="-1"></a>    ergebnisse <span class="op">=</span> {}</span>
+<span id="cb88-105"><a href="#cb88-105" aria-hidden="true" tabindex="-1"></a>    <span class="cf">for</span> strafe <span class="kw">in</span> (<span class="dv">1</span>, <span class="dv">2</span>, <span class="dv">5</span>, <span class="dv">10</span>, <span class="dv">30</span>, <span class="dv">100</span>):</span>
+<span id="cb88-106"><a href="#cb88-106" aria-hidden="true" tabindex="-1"></a>        e <span class="op">=</span> plane(strafe)</span>
+<span id="cb88-107"><a href="#cb88-107" aria-hidden="true" tabindex="-1"></a>        ergebnisse[strafe] <span class="op">=</span> e</span>
+<span id="cb88-108"><a href="#cb88-108" aria-hidden="true" tabindex="-1"></a>        <span class="bu">print</span>(<span class="ss">f&quot;</span><span class="sc">{</span>strafe<span class="sc">:&gt;20}</span><span class="ss"> </span><span class="sc">{</span>e[<span class="st">&#39;serien&#39;</span>]<span class="sc">:&gt;12}</span><span class="ss"> </span><span class="sc">{</span>e[<span class="st">&#39;wunsch_verletzt&#39;</span>]<span class="sc">:&gt;17}</span><span class="ss"> &quot;</span></span>
+<span id="cb88-109"><a href="#cb88-109" aria-hidden="true" tabindex="-1"></a>              <span class="ss">f&quot;</span><span class="sc">{</span>e[<span class="st">&#39;zielwert&#39;</span>]<span class="sc">:&gt;10.0f}</span><span class="ss">&quot;</span>)</span>
+<span id="cb88-110"><a href="#cb88-110" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;-&quot;</span> <span class="op">*</span> <span class="dv">78</span>)</span>
+<span id="cb88-111"><a href="#cb88-111" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb88-112"><a href="#cb88-112" aria-hidden="true" tabindex="-1"></a>    niedrig, hoch <span class="op">=</span> ergebnisse[<span class="dv">1</span>], ergebnisse[<span class="dv">30</span>]</span>
+<span id="cb88-113"><a href="#cb88-113" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;</span><span class="ch">\n</span><span class="ss">Bei Strafe 1 baut der Solver </span><span class="sc">{</span>niedrig[<span class="st">&#39;serien&#39;</span>]<span class="sc">}</span><span class="ss"> Drei-Tage-Serien ein.&quot;</span>)</span>
+<span id="cb88-114"><a href="#cb88-114" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;Die Betriebsvereinbarung steht im Modell - und wird trotzdem&quot;</span>)</span>
+<span id="cb88-115"><a href="#cb88-115" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;systematisch verletzt. Das ist kein Fehler des Solvers: Bei einem&quot;</span>)</span>
+<span id="cb88-116"><a href="#cb88-116" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;Gewicht von 1 gegen </span><span class="sc">{</span>STRAFE_WUNSCH<span class="sc">}</span><span class="ss"> lohnt sich jede Serie, solange sie&quot;</span>)</span>
+<span id="cb88-117"><a href="#cb88-117" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;auch nur einen Zehntel-Wunsch rettet.&quot;</span>)</span>
+<span id="cb88-118"><a href="#cb88-118" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;</span><span class="ch">\n</span><span class="ss">Bei Strafe 30 sind es </span><span class="sc">{</span>hoch[<span class="st">&#39;serien&#39;</span>]<span class="sc">}</span><span class="ss"> Serien - dafuer werden&quot;</span>)</span>
+<span id="cb88-119"><a href="#cb88-119" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;</span><span class="sc">{</span>hoch[<span class="st">&#39;wunsch_verletzt&#39;</span>]<span class="sc">}</span><span class="ss"> statt </span><span class="sc">{</span>niedrig[<span class="st">&#39;wunsch_verletzt&#39;</span>]<span class="sc">}</span><span class="ss"> Wuensche abgelehnt.&quot;</span>)</span>
+<span id="cb88-120"><a href="#cb88-120" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;Beide Plaene sind optimal. Sie beantworten nur verschiedene Fragen.&quot;</span>)</span>
+<span id="cb88-121"><a href="#cb88-121" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>()</span>
+<span id="cb88-122"><a href="#cb88-122" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;Die Frage lautet also nie &#39;wie wichtig ist mir diese Regel?&#39;, sondern:&quot;</span>)</span>
+<span id="cb88-123"><a href="#cb88-123" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;  &#39;Wie viele abgelehnte Wuensche bin ich bereit zu akzeptieren,&quot;</span>)</span>
+<span id="cb88-124"><a href="#cb88-124" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;   um eine Drei-Tage-Serie zu vermeiden?&#39;&quot;</span>)</span>
+<span id="cb88-125"><a href="#cb88-125" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;Wer darauf keine Zahl nennen kann, hat das Problem noch nicht&quot;</span>)</span>
+<span id="cb88-126"><a href="#cb88-126" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;verstanden - und sollte diese Tabelle dem Auftraggeber vorlegen,&quot;</span>)</span>
+<span id="cb88-127"><a href="#cb88-127" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;statt ein Gewicht zu raten.&quot;</span>)</span>
+<span id="cb88-128"><a href="#cb88-128" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>()</span>
+<span id="cb88-129"><a href="#cb88-129" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;Und die wichtigste Konsequenz: Eine Regel, die NIE gebrochen werden&quot;</span>)</span>
+<span id="cb88-130"><a href="#cb88-130" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;darf, gehoert nicht in die Zielfunktion, sondern unter die harten&quot;</span>)</span>
+<span id="cb88-131"><a href="#cb88-131" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;Nebenbedingungen. Alles, was einen Preis hat, wird irgendwann gekauft.&quot;</span>)</span>
+<span id="cb88-132"><a href="#cb88-132" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;=&quot;</span> <span class="op">*</span> <span class="dv">78</span>)</span></code></pre></div>
 <p><strong>Erwartete Ausgabe:</strong></p>
 <pre><code>==============================================================================
   STRAFGEWICHTE SIND WECHSELKURSE, KEINE WICHTIGKEITEN
@@ -11934,16 +12676,16 @@ Nebenbedingungen. Alles, was einen Preis hat, wird irgendwann gekauft.
 </ul>
 </blockquote>
 <hr />
-<h2 id="sec:cpsat-quiz">7.10 Micro-Quiz</h2>
+<h2 id="sec:cpsat-quiz">7.11 Micro-Quiz</h2>
 <blockquote>
-<p><strong>❓ Micro-Quiz 6: Drei Fragen zum Selbstcheck</strong></p>
+<p><strong>❓ Micro-Quiz 7: Drei Fragen zum Selbstcheck</strong></p>
 <p>Genau eine Antwort ist jeweils richtig. Auflösung in <a href="#quiz-loesung-cpsat">Anhang A</a>.</p>
 <p><strong>1. Ihr Dienstplanmodell meldet <code>INFEASIBLE</code>. Ein Kollege schlägt vor, das Zeitlimit von 10 auf 300 Sekunden zu erhöhen. Was halten Sie davon?</strong> (a) Sinnvoll — bei schweren Instanzen braucht CP-SAT einfach länger. (b) Wirkungslos: <code>INFEASIBLE</code> ist ein <strong>Beweis</strong>, dass keine zulässige Lösung existiert. Die Ursache liegt in den harten Regeln, nicht in der Rechenzeit. (c) Sinnvoll, aber nur zusammen mit mehr Arbeitern (<code>num_workers</code>).</p>
 <p><strong>2. Sie modellieren „auf einer Maschine läuft immer nur ein Auftrag“. Was ist der Vorteil von <code>AddNoOverlap</code> gegenüber der MILP-Formulierung mit Big-M?</strong> (a) <code>AddNoOverlap</code> findet grundsätzlich bessere Lösungen. (b) Eine Zeile ersetzt bei <span class="math inline">k</span> Aufträgen <span class="math inline">\binom{k}{2}</span> Entweder-Oder-Konstruktionen mit je zwei Ungleichungen und einer Binärvariablen — und propagiert stärker, weil der Propagator die Struktur als Ganzes betrachtet. (c) <code>AddNoOverlap</code> funktioniert auch mit kontinuierlichen Zeiten, Big-M nicht.</p>
 <p><strong>3. Zwei Läufe desselben Job-Shop-Programms liefern verschiedene Pläne, beide mit Makespan 11. Was folgt daraus für Ihre Tests?</strong> (a) Das Programm ist fehlerhaft; ein korrektes Modell hat genau eine Lösung. (b) Es gibt mehrere optimale Pläne. Tests dürfen deshalb nicht auf einen bestimmten Plan prüfen, sondern auf den Zielwert und die Einhaltung aller Regeln. (c) Der Solver arbeitet ungenau; man sollte die Toleranzen verschärfen.</p>
 </blockquote>
 <hr />
-<h2 id="sec:cpsat-selbsttest">7.11 Selbsttest</h2>
+<h2 id="sec:cpsat-selbsttest">7.12 Selbsttest</h2>
 <blockquote>
 <p>Antworten: <a href="#selbsttest-loesung-cpsat">Anhang A</a>.</p>
 </blockquote>
@@ -11952,21 +12694,24 @@ Nebenbedingungen. Alles, was einen Preis hat, wird irgendwann gekauft.
 <li>Welchen Vorteil hat <code>AddAllDifferent(x)</code> gegenüber <span class="math inline">\binom{n}{2}</span> Einzelbedingungen?</li>
 <li>Was ist eine Intervallvariable, und welche Bedingung garantiert sie automatisch?</li>
 <li>Warum sollten möglichst wenige Bedingungen hart formuliert werden?</li>
-<li>Warum ist die Aufschlüsselung der Strafkosten in der Praxis wichtiger als der Zielwert selbst?</li>
+<li>Warum ist die Aufschlüsselung der Strafkosten in der Praxis wichtiger als der Zielwert</li>
+<li>Sie setzen <code>random_seed = 1</code>, bekommen aber trotzdem bei jedem Lauf einen anderen Plan. Woran liegt das, und was hilft?</li>
+<li>Warum kann ein CP-SAT-Lauf mit acht Arbeitern <strong>mehr</strong> als achtmal schneller sein als mit einem? selbst?</li>
 </ol>
 <hr />
-<h2 id="sec:cpsat-zusammenfassung">7.12 Zusammenfassung</h2>
+<h2 id="sec:cpsat-zusammenfassung">7.13 Zusammenfassung</h2>
 <ul>
-<li><strong>CP denkt in Wertebereichen und Regeln</strong>, nicht in Ungleichungen und Schranken.</li>
-<li><strong>Propagation</strong> streicht unmögliche Werte, bevor gesucht wird; <strong>Conflict Learning</strong> verhindert, dieselbe Sackgasse zweimal zu betreten.</li>
-<li><strong>Globale Constraints</strong> wie , und ersetzen ganze Blöcke von Big-M-Ungleichungen und propagieren stärker.</li>
-<li><strong>Intervallvariablen</strong> sind das Werkzeug für Zeitplanung; <code>AddNoOverlap</code> erledigt in einer Zeile, was in MILP dutzende Disjunktionen kostet.</li>
-<li><strong>Weiche Ziele mit Strafkosten</strong> machen Modelle robust gegen <code>INFEASIBLE</code> — und die <strong>Kostenzerlegung</strong> macht sie erklärbar.</li>
-<li><strong>Strafgewichte sind Wechselkurse, keine Wichtigkeiten.</strong> Rechnen Sie mehrere Gewichte durch und lassen Sie den Auftraggeber eine Zeile der Tabelle wählen. Und was nie gebrochen werden darf, gehört unter die harten Nebenbedingungen: Alles, was einen Preis hat, wird irgendwann gekauft.</li>
-<li><strong>Fünf Antworten, nicht zwei.</strong> <code>INFEASIBLE</code> (es gibt keine Lösung), <code>UNKNOWN</code> (es wurde keine gefunden) und <code>MODEL_INVALID</code> (Ihr Code ist fehlerhaft) bedeuten Grundverschiedenes. Wer sie in ein <code>else</code> zusammenfasst, verliert die Information zur Fehlersuche.</li>
-<li><strong>Bei mehrdeutigen Optima nie auf einen bestimmten Plan testen</strong> — nur auf den Zielwert und die Einhaltung aller Regeln.</li>
+<li><p><strong>CP denkt in Wertebereichen und Regeln</strong>, nicht in Ungleichungen und Schranken.</p></li>
+<li><p><strong>Propagation</strong> streicht unmögliche Werte, bevor gesucht wird; <strong>Conflict Learning</strong> verhindert, dieselbe Sackgasse zweimal zu betreten.</p></li>
+<li><p><strong>Globale Constraints</strong> wie , und ersetzen ganze Blöcke von Big-M-Ungleichungen und propagieren stärker.</p></li>
+<li><p><strong>Intervallvariablen</strong> sind das Werkzeug für Zeitplanung; <code>AddNoOverlap</code> erledigt in einer Zeile, was in MILP dutzende Disjunktionen kostet.</p></li>
+<li><p><strong>Weiche Ziele mit Strafkosten</strong> machen Modelle robust gegen <code>INFEASIBLE</code> — und die <strong>Kostenzerlegung</strong> macht sie erklärbar.</p></li>
+<li><p><strong>Strafgewichte sind Wechselkurse, keine Wichtigkeiten.</strong> Rechnen Sie mehrere Gewichte durch und lassen Sie den Auftraggeber eine Zeile der Tabelle wählen. Und was nie gebrochen werden darf, gehört unter die harten Nebenbedingungen: Alles, was einen Preis hat, wird irgendwann gekauft.</p></li>
+<li><p><strong>Fünf Antworten, nicht zwei.</strong> <code>INFEASIBLE</code> (es gibt keine Lösung), <code>UNKNOWN</code> (es wurde keine gefunden) und <code>MODEL_INVALID</code> (Ihr Code ist fehlerhaft) bedeuten Grundverschiedenes. Wer sie in ein <code>else</code> zusammenfasst, verliert die Information zur Fehlersuche.</p></li>
+<li><p><strong>Bei mehrdeutigen Optima nie auf einen bestimmten Plan testen</strong> — nur auf den Zielwert und die Einhaltung aller Regeln.</p></li>
+<li><p><strong>Ein paralleler Solver hat zwei Zufallsquellen: den Seed und die Uhr.</strong> Nur die erste lässt sich setzen. Reproduzierbar wird ein Lauf erst mit <code>num_workers = 1</code> <strong>und</strong> Seed — gemessen in <a href="#sec:cpsat-parallele-suche">Abschnitt 7.7</a>: schon zwei Arbeiter liefern bei identischem Seed drei verschiedene Pläne zum selben Zielwert.</p></li>
+<li><p><strong>Parallele Suche kann überlinear beschleunigen</strong>, weil CP-SAT nicht dieselbe Suche vervielfacht, sondern verschiedene Strategien nebeneinander laufen lässt, die einander ihre Schranken mitteilen. <strong>Ausblick.</strong> <a href="#kap-graphen">Kapitel 8</a> behandelt Probleme, die sich am besten als <strong>Graph</strong> begreifen lassen: Flüsse durch Netzwerke, Zuordnungen und die Tourenplanung mit Fahrzeugen und Zeitfenstern.</p></li>
 </ul>
-<p><strong>Ausblick.</strong> <a href="#kap-graphen">Kapitel 8</a> behandelt Probleme, die sich am besten als <strong>Graph</strong> begreifen lassen: Flüsse durch Netzwerke, Zuordnungen und die Tourenplanung mit Fahrzeugen und Zeitfenstern.</p>
 <hr />
 <h1 id="kap-graphen">Kapitel 8: Graphen, Flüsse und Touren — Min-Cost-Flow, Matching und VRP</h1>
 <blockquote>
@@ -12029,20 +12774,20 @@ Nebenbedingungen. Alles, was einen Preis hat, wird irgendwann gekauft.
 </tr>
 </tbody>
 </table>
-<div class="sourceCode" id="cb88"><pre class="sourceCode python"><code class="sourceCode python"><span id="cb88-1"><a href="#cb88-1" aria-hidden="true" tabindex="-1"></a><span class="im">import</span> numpy <span class="im">as</span> np</span>
-<span id="cb88-2"><a href="#cb88-2" aria-hidden="true" tabindex="-1"></a><span class="im">from</span> scipy.optimize <span class="im">import</span> linear_sum_assignment</span>
-<span id="cb88-3"><a href="#cb88-3" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb88-4"><a href="#cb88-4" aria-hidden="true" tabindex="-1"></a>kosten <span class="op">=</span> np.array([[<span class="dv">21</span>, <span class="dv">45</span>, <span class="dv">33</span>, <span class="dv">60</span>],      <span class="co"># Bauer</span></span>
-<span id="cb88-5"><a href="#cb88-5" aria-hidden="true" tabindex="-1"></a>                   [<span class="dv">18</span>, <span class="dv">52</span>, <span class="dv">29</span>, <span class="dv">47</span>],      <span class="co"># Cakir</span></span>
-<span id="cb88-6"><a href="#cb88-6" aria-hidden="true" tabindex="-1"></a>                   [<span class="dv">40</span>, <span class="dv">24</span>, <span class="dv">55</span>, <span class="dv">38</span>],      <span class="co"># Diaz</span></span>
-<span id="cb88-7"><a href="#cb88-7" aria-hidden="true" tabindex="-1"></a>                   [<span class="dv">35</span>, <span class="dv">31</span>, <span class="dv">26</span>, <span class="dv">44</span>]])     <span class="co"># Engel</span></span>
-<span id="cb88-8"><a href="#cb88-8" aria-hidden="true" tabindex="-1"></a>monteur <span class="op">=</span> [<span class="st">&quot;Bauer&quot;</span>, <span class="st">&quot;Cakir&quot;</span>, <span class="st">&quot;Diaz&quot;</span>, <span class="st">&quot;Engel&quot;</span>]</span>
-<span id="cb88-9"><a href="#cb88-9" aria-hidden="true" tabindex="-1"></a>ort <span class="op">=</span> [<span class="st">&quot;Nord&quot;</span>, <span class="st">&quot;Ost&quot;</span>, <span class="st">&quot;Sued&quot;</span>, <span class="st">&quot;West&quot;</span>]</span>
-<span id="cb88-10"><a href="#cb88-10" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb88-11"><a href="#cb88-11" aria-hidden="true" tabindex="-1"></a>zeile, spalte <span class="op">=</span> linear_sum_assignment(kosten)</span>
-<span id="cb88-12"><a href="#cb88-12" aria-hidden="true" tabindex="-1"></a><span class="cf">for</span> z, s <span class="kw">in</span> <span class="bu">zip</span>(zeile, spalte):</span>
-<span id="cb88-13"><a href="#cb88-13" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;</span><span class="sc">{</span>monteur[z]<span class="sc">:6}</span><span class="ss"> -&gt; </span><span class="sc">{</span>ort[s]<span class="sc">:5}</span><span class="ss"> (</span><span class="sc">{</span>kosten[z, s]<span class="sc">}</span><span class="ss"> min)&quot;</span>)</span>
-<span id="cb88-14"><a href="#cb88-14" aria-hidden="true" tabindex="-1"></a><span class="bu">print</span>(<span class="st">&quot;Gesamtfahrzeit:&quot;</span>, kosten[zeile, spalte].<span class="bu">sum</span>(), <span class="st">&quot;min&quot;</span>)</span></code></pre></div>
+<div class="sourceCode" id="cb90"><pre class="sourceCode python"><code class="sourceCode python"><span id="cb90-1"><a href="#cb90-1" aria-hidden="true" tabindex="-1"></a><span class="im">import</span> numpy <span class="im">as</span> np</span>
+<span id="cb90-2"><a href="#cb90-2" aria-hidden="true" tabindex="-1"></a><span class="im">from</span> scipy.optimize <span class="im">import</span> linear_sum_assignment</span>
+<span id="cb90-3"><a href="#cb90-3" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb90-4"><a href="#cb90-4" aria-hidden="true" tabindex="-1"></a>kosten <span class="op">=</span> np.array([[<span class="dv">21</span>, <span class="dv">45</span>, <span class="dv">33</span>, <span class="dv">60</span>],      <span class="co"># Bauer</span></span>
+<span id="cb90-5"><a href="#cb90-5" aria-hidden="true" tabindex="-1"></a>                   [<span class="dv">18</span>, <span class="dv">52</span>, <span class="dv">29</span>, <span class="dv">47</span>],      <span class="co"># Cakir</span></span>
+<span id="cb90-6"><a href="#cb90-6" aria-hidden="true" tabindex="-1"></a>                   [<span class="dv">40</span>, <span class="dv">24</span>, <span class="dv">55</span>, <span class="dv">38</span>],      <span class="co"># Diaz</span></span>
+<span id="cb90-7"><a href="#cb90-7" aria-hidden="true" tabindex="-1"></a>                   [<span class="dv">35</span>, <span class="dv">31</span>, <span class="dv">26</span>, <span class="dv">44</span>]])     <span class="co"># Engel</span></span>
+<span id="cb90-8"><a href="#cb90-8" aria-hidden="true" tabindex="-1"></a>monteur <span class="op">=</span> [<span class="st">&quot;Bauer&quot;</span>, <span class="st">&quot;Cakir&quot;</span>, <span class="st">&quot;Diaz&quot;</span>, <span class="st">&quot;Engel&quot;</span>]</span>
+<span id="cb90-9"><a href="#cb90-9" aria-hidden="true" tabindex="-1"></a>ort <span class="op">=</span> [<span class="st">&quot;Nord&quot;</span>, <span class="st">&quot;Ost&quot;</span>, <span class="st">&quot;Sued&quot;</span>, <span class="st">&quot;West&quot;</span>]</span>
+<span id="cb90-10"><a href="#cb90-10" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb90-11"><a href="#cb90-11" aria-hidden="true" tabindex="-1"></a>zeile, spalte <span class="op">=</span> linear_sum_assignment(kosten)</span>
+<span id="cb90-12"><a href="#cb90-12" aria-hidden="true" tabindex="-1"></a><span class="cf">for</span> z, s <span class="kw">in</span> <span class="bu">zip</span>(zeile, spalte):</span>
+<span id="cb90-13"><a href="#cb90-13" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;</span><span class="sc">{</span>monteur[z]<span class="sc">:6}</span><span class="ss"> -&gt; </span><span class="sc">{</span>ort[s]<span class="sc">:5}</span><span class="ss"> (</span><span class="sc">{</span>kosten[z, s]<span class="sc">}</span><span class="ss"> min)&quot;</span>)</span>
+<span id="cb90-14"><a href="#cb90-14" aria-hidden="true" tabindex="-1"></a><span class="bu">print</span>(<span class="st">&quot;Gesamtfahrzeit:&quot;</span>, kosten[zeile, spalte].<span class="bu">sum</span>(), <span class="st">&quot;min&quot;</span>)</span></code></pre></div>
 <p><strong>Ausgabe:</strong></p>
 <pre><code>Bauer  -&gt; Nord  (21 min)
 Cakir  -&gt; Sued  (29 min)
@@ -12155,103 +12900,103 @@ Gesamtfahrzeit: 118 min</code></pre>
 <p><strong>Ohne Formel gesagt:</strong> Das ist die Kirchhoffsche Knotenregel aus der Elektrotechnik — nichts geht verloren, nichts entsteht aus dem Nichts. Für einen Umladeknoten heißt das wörtlich: „Was ankommt, fährt auch wieder weg.“</p>
 <p><strong>Wichtig:</strong> Damit das Problem lösbar ist, muss <span class="math inline">\sum_i b_i = 0</span> gelten — das Gesamtangebot muss dem Gesamtbedarf entsprechen.</p>
 </blockquote>
-<div class="sourceCode" id="cb90"><pre class="sourceCode python"><code class="sourceCode python"><span id="cb90-1"><a href="#cb90-1" aria-hidden="true" tabindex="-1"></a><span class="co">#!/usr/bin/env python3</span></span>
-<span id="cb90-2"><a href="#cb90-2" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb90-3"><a href="#cb90-3" aria-hidden="true" tabindex="-1"></a><span class="co"># Min_Cost_Flow.py</span></span>
-<span id="cb90-4"><a href="#cb90-4" aria-hidden="true" tabindex="-1"></a><span class="co">&quot;&quot;&quot;</span></span>
-<span id="cb90-5"><a href="#cb90-5" aria-hidden="true" tabindex="-1"></a><span class="co">Kapitel Graphen: Kostenminimaler Fluss durch ein Netzwerk.</span></span>
-<span id="cb90-6"><a href="#cb90-6" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb90-7"><a href="#cb90-7" aria-hidden="true" tabindex="-1"></a><span class="co">Loest dasselbe Problem zweimal:</span></span>
-<span id="cb90-8"><a href="#cb90-8" aria-hidden="true" tabindex="-1"></a><span class="co">  (1) als allgemeines LP mit scipy  -&gt; zeigt die Modellstruktur</span></span>
-<span id="cb90-9"><a href="#cb90-9" aria-hidden="true" tabindex="-1"></a><span class="co">  (2) mit dem spezialisierten Netzwerk-Solver von OR-Tools -&gt; zeigt den</span></span>
-<span id="cb90-10"><a href="#cb90-10" aria-hidden="true" tabindex="-1"></a><span class="co">      Geschwindigkeitsvorteil eines Verfahrens, das die Struktur ausnutzt</span></span>
-<span id="cb90-11"><a href="#cb90-11" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb90-12"><a href="#cb90-12" aria-hidden="true" tabindex="-1"></a><span class="co">Beide laufen in eigenen Prozessen nicht noetig: scipy und ortools vertragen</span></span>
-<span id="cb90-13"><a href="#cb90-13" aria-hidden="true" tabindex="-1"></a><span class="co">sich (nur ortools + highspy kollidieren, siehe Kapitel Oekosystem).</span></span>
-<span id="cb90-14"><a href="#cb90-14" aria-hidden="true" tabindex="-1"></a><span class="co">&quot;&quot;&quot;</span></span>
-<span id="cb90-15"><a href="#cb90-15" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb90-16"><a href="#cb90-16" aria-hidden="true" tabindex="-1"></a><span class="im">import</span> numpy <span class="im">as</span> np</span>
-<span id="cb90-17"><a href="#cb90-17" aria-hidden="true" tabindex="-1"></a><span class="im">from</span> scipy.optimize <span class="im">import</span> linprog</span>
-<span id="cb90-18"><a href="#cb90-18" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb90-19"><a href="#cb90-19" aria-hidden="true" tabindex="-1"></a><span class="co"># --- Netzwerk definieren ---------------------------------------------------</span></span>
-<span id="cb90-20"><a href="#cb90-20" aria-hidden="true" tabindex="-1"></a>KNOTEN <span class="op">=</span> [<span class="st">&quot;Werk_A&quot;</span>, <span class="st">&quot;Werk_B&quot;</span>, <span class="st">&quot;Umschlag&quot;</span>, <span class="st">&quot;Kunde_1&quot;</span>, <span class="st">&quot;Kunde_2&quot;</span>]</span>
-<span id="cb90-21"><a href="#cb90-21" aria-hidden="true" tabindex="-1"></a><span class="co"># (von, nach, Kosten je Einheit, Kapazitaet)</span></span>
-<span id="cb90-22"><a href="#cb90-22" aria-hidden="true" tabindex="-1"></a>KANTEN <span class="op">=</span> [</span>
-<span id="cb90-23"><a href="#cb90-23" aria-hidden="true" tabindex="-1"></a>    (<span class="st">&quot;Werk_A&quot;</span>,   <span class="st">&quot;Umschlag&quot;</span>, <span class="fl">2.0</span>, <span class="dv">15</span>),</span>
-<span id="cb90-24"><a href="#cb90-24" aria-hidden="true" tabindex="-1"></a>    (<span class="st">&quot;Werk_A&quot;</span>,   <span class="st">&quot;Kunde_1&quot;</span>,  <span class="fl">5.0</span>, <span class="dv">10</span>),</span>
-<span id="cb90-25"><a href="#cb90-25" aria-hidden="true" tabindex="-1"></a>    (<span class="st">&quot;Werk_B&quot;</span>,   <span class="st">&quot;Umschlag&quot;</span>, <span class="fl">4.0</span>, <span class="dv">10</span>),</span>
-<span id="cb90-26"><a href="#cb90-26" aria-hidden="true" tabindex="-1"></a>    (<span class="st">&quot;Werk_B&quot;</span>,   <span class="st">&quot;Kunde_2&quot;</span>,  <span class="fl">6.0</span>, <span class="dv">10</span>),</span>
-<span id="cb90-27"><a href="#cb90-27" aria-hidden="true" tabindex="-1"></a>    (<span class="st">&quot;Umschlag&quot;</span>, <span class="st">&quot;Kunde_1&quot;</span>,  <span class="fl">1.0</span>, <span class="dv">20</span>),</span>
-<span id="cb90-28"><a href="#cb90-28" aria-hidden="true" tabindex="-1"></a>    (<span class="st">&quot;Umschlag&quot;</span>, <span class="st">&quot;Kunde_2&quot;</span>,  <span class="fl">3.0</span>, <span class="dv">10</span>),</span>
-<span id="cb90-29"><a href="#cb90-29" aria-hidden="true" tabindex="-1"></a>]</span>
-<span id="cb90-30"><a href="#cb90-30" aria-hidden="true" tabindex="-1"></a><span class="co"># Angebot (+) bzw. Bedarf (-) je Knoten</span></span>
-<span id="cb90-31"><a href="#cb90-31" aria-hidden="true" tabindex="-1"></a>SALDO <span class="op">=</span> {<span class="st">&quot;Werk_A&quot;</span>: <span class="dv">20</span>, <span class="st">&quot;Werk_B&quot;</span>: <span class="dv">10</span>, <span class="st">&quot;Umschlag&quot;</span>: <span class="dv">0</span>, <span class="st">&quot;Kunde_1&quot;</span>: <span class="op">-</span><span class="dv">15</span>, <span class="st">&quot;Kunde_2&quot;</span>: <span class="op">-</span><span class="dv">15</span>}</span>
-<span id="cb90-32"><a href="#cb90-32" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb90-33"><a href="#cb90-33" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb90-34"><a href="#cb90-34" aria-hidden="true" tabindex="-1"></a><span class="kw">def</span> loese_als_lp():</span>
-<span id="cb90-35"><a href="#cb90-35" aria-hidden="true" tabindex="-1"></a>    <span class="co">&quot;&quot;&quot;Flussproblem als allgemeines lineares Programm.&quot;&quot;&quot;</span></span>
-<span id="cb90-36"><a href="#cb90-36" aria-hidden="true" tabindex="-1"></a>    n_kanten <span class="op">=</span> <span class="bu">len</span>(KANTEN)</span>
-<span id="cb90-37"><a href="#cb90-37" aria-hidden="true" tabindex="-1"></a>    knoten_index <span class="op">=</span> {k: i <span class="cf">for</span> i, k <span class="kw">in</span> <span class="bu">enumerate</span>(KNOTEN)}</span>
-<span id="cb90-38"><a href="#cb90-38" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb90-39"><a href="#cb90-39" aria-hidden="true" tabindex="-1"></a>    <span class="co"># Zielfunktion: Summe der Transportkosten</span></span>
-<span id="cb90-40"><a href="#cb90-40" aria-hidden="true" tabindex="-1"></a>    kosten <span class="op">=</span> np.array([k[<span class="dv">2</span>] <span class="cf">for</span> k <span class="kw">in</span> KANTEN])</span>
-<span id="cb90-41"><a href="#cb90-41" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb90-42"><a href="#cb90-42" aria-hidden="true" tabindex="-1"></a>    <span class="co"># Flusserhaltung als Gleichungssystem: A_eq @ x = b_eq</span></span>
-<span id="cb90-43"><a href="#cb90-43" aria-hidden="true" tabindex="-1"></a>    A_eq <span class="op">=</span> np.zeros((<span class="bu">len</span>(KNOTEN), n_kanten))</span>
-<span id="cb90-44"><a href="#cb90-44" aria-hidden="true" tabindex="-1"></a>    <span class="cf">for</span> e, (von, nach, _, _) <span class="kw">in</span> <span class="bu">enumerate</span>(KANTEN):</span>
-<span id="cb90-45"><a href="#cb90-45" aria-hidden="true" tabindex="-1"></a>        A_eq[knoten_index[von], e] <span class="op">=</span> <span class="op">+</span><span class="fl">1.0</span>      <span class="co"># fliesst hinaus</span></span>
-<span id="cb90-46"><a href="#cb90-46" aria-hidden="true" tabindex="-1"></a>        A_eq[knoten_index[nach], e] <span class="op">=</span> <span class="op">-</span><span class="fl">1.0</span>     <span class="co"># fliesst hinein</span></span>
-<span id="cb90-47"><a href="#cb90-47" aria-hidden="true" tabindex="-1"></a>    b_eq <span class="op">=</span> np.array([SALDO[k] <span class="cf">for</span> k <span class="kw">in</span> KNOTEN], dtype<span class="op">=</span><span class="bu">float</span>)</span>
-<span id="cb90-48"><a href="#cb90-48" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb90-49"><a href="#cb90-49" aria-hidden="true" tabindex="-1"></a>    schranken <span class="op">=</span> [(<span class="dv">0</span>, k[<span class="dv">3</span>]) <span class="cf">for</span> k <span class="kw">in</span> KANTEN]    <span class="co"># 0 &lt;= x_ij &lt;= u_ij</span></span>
-<span id="cb90-50"><a href="#cb90-50" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb90-51"><a href="#cb90-51" aria-hidden="true" tabindex="-1"></a>    ergebnis <span class="op">=</span> linprog(c<span class="op">=</span>kosten, A_eq<span class="op">=</span>A_eq, b_eq<span class="op">=</span>b_eq, bounds<span class="op">=</span>schranken, method<span class="op">=</span><span class="st">&quot;highs&quot;</span>)</span>
-<span id="cb90-52"><a href="#cb90-52" aria-hidden="true" tabindex="-1"></a>    <span class="cf">if</span> <span class="kw">not</span> ergebnis.success:</span>
-<span id="cb90-53"><a href="#cb90-53" aria-hidden="true" tabindex="-1"></a>        <span class="cf">raise</span> <span class="pp">SystemExit</span>(<span class="ss">f&quot;Nicht loesbar: </span><span class="sc">{</span>ergebnis<span class="sc">.</span>message<span class="sc">}</span><span class="ss">&quot;</span>)</span>
-<span id="cb90-54"><a href="#cb90-54" aria-hidden="true" tabindex="-1"></a>    <span class="cf">return</span> ergebnis.fun, ergebnis.x, ergebnis.eqlin.marginals</span>
-<span id="cb90-55"><a href="#cb90-55" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb90-56"><a href="#cb90-56" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb90-57"><a href="#cb90-57" aria-hidden="true" tabindex="-1"></a><span class="cf">if</span> <span class="va">__name__</span> <span class="op">==</span> <span class="st">&quot;__main__&quot;</span>:</span>
-<span id="cb90-58"><a href="#cb90-58" aria-hidden="true" tabindex="-1"></a>    <span class="co"># Vorabpruefung: Angebot muss Bedarf entsprechen</span></span>
-<span id="cb90-59"><a href="#cb90-59" aria-hidden="true" tabindex="-1"></a>    gesamt <span class="op">=</span> <span class="bu">sum</span>(SALDO.values())</span>
-<span id="cb90-60"><a href="#cb90-60" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;=&quot;</span> <span class="op">*</span> <span class="dv">78</span>)</span>
-<span id="cb90-61"><a href="#cb90-61" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;  KOSTENMINIMALER FLUSS DURCH EIN TRANSPORTNETZ&quot;</span>)</span>
-<span id="cb90-62"><a href="#cb90-62" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;=&quot;</span> <span class="op">*</span> <span class="dv">78</span>)</span>
-<span id="cb90-63"><a href="#cb90-63" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;Angebot gesamt: </span><span class="sc">{</span><span class="bu">sum</span>(v <span class="cf">for</span> v <span class="kw">in</span> SALDO.values() <span class="cf">if</span> v <span class="op">&gt;</span> <span class="dv">0</span>)<span class="sc">}</span><span class="ss"> | &quot;</span></span>
-<span id="cb90-64"><a href="#cb90-64" aria-hidden="true" tabindex="-1"></a>          <span class="ss">f&quot;Bedarf gesamt: </span><span class="sc">{</span><span class="op">-</span><span class="bu">sum</span>(v <span class="cf">for</span> v <span class="kw">in</span> SALDO.values() <span class="cf">if</span> v <span class="op">&lt;</span> <span class="dv">0</span>)<span class="sc">}</span><span class="ss"> | &quot;</span></span>
-<span id="cb90-65"><a href="#cb90-65" aria-hidden="true" tabindex="-1"></a>          <span class="ss">f&quot;Saldo: </span><span class="sc">{</span>gesamt<span class="sc">}</span><span class="ss">&quot;</span>)</span>
-<span id="cb90-66"><a href="#cb90-66" aria-hidden="true" tabindex="-1"></a>    <span class="cf">if</span> gesamt <span class="op">!=</span> <span class="dv">0</span>:</span>
-<span id="cb90-67"><a href="#cb90-67" aria-hidden="true" tabindex="-1"></a>        <span class="cf">raise</span> <span class="pp">SystemExit</span>(<span class="st">&quot;Angebot und Bedarf stimmen nicht ueberein - unloesbar!&quot;</span>)</span>
-<span id="cb90-68"><a href="#cb90-68" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb90-69"><a href="#cb90-69" aria-hidden="true" tabindex="-1"></a>    kosten_gesamt, fluss, knotenpreise <span class="op">=</span> loese_als_lp()</span>
-<span id="cb90-70"><a href="#cb90-70" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb90-71"><a href="#cb90-71" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;</span><span class="ch">\n</span><span class="ss">Minimale Transportkosten: </span><span class="sc">{</span>kosten_gesamt<span class="sc">:,.2f}</span><span class="ss"> EUR</span><span class="ch">\n</span><span class="ss">&quot;</span>)</span>
-<span id="cb90-72"><a href="#cb90-72" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;</span><span class="sc">{</span><span class="st">&#39;Kante&#39;</span><span class="sc">:&lt;24}</span><span class="ss"> </span><span class="sc">{</span><span class="st">&#39;Fluss&#39;</span><span class="sc">:&gt;7}</span><span class="ss"> </span><span class="sc">{</span><span class="st">&#39;Kapazitaet&#39;</span><span class="sc">:&gt;11}</span><span class="ss"> </span><span class="sc">{</span><span class="st">&#39;Kosten/E&#39;</span><span class="sc">:&gt;9}</span><span class="ss"> </span><span class="sc">{</span><span class="st">&#39;Kosten&#39;</span><span class="sc">:&gt;9}</span><span class="ss">&quot;</span>)</span>
-<span id="cb90-73"><a href="#cb90-73" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;-&quot;</span> <span class="op">*</span> <span class="dv">78</span>)</span>
-<span id="cb90-74"><a href="#cb90-74" aria-hidden="true" tabindex="-1"></a>    <span class="cf">for</span> e, (von, nach, c, u) <span class="kw">in</span> <span class="bu">enumerate</span>(KANTEN):</span>
-<span id="cb90-75"><a href="#cb90-75" aria-hidden="true" tabindex="-1"></a>        menge <span class="op">=</span> fluss[e] <span class="op">+</span> <span class="fl">0.0</span> <span class="cf">if</span> <span class="bu">abs</span>(fluss[e]) <span class="op">&gt;</span> <span class="fl">1e-9</span> <span class="cf">else</span> <span class="fl">0.0</span>   <span class="co"># vermeidet &quot;-0.0&quot;</span></span>
-<span id="cb90-76"><a href="#cb90-76" aria-hidden="true" tabindex="-1"></a>        ausgelastet <span class="op">=</span> <span class="st">&quot; (VOLL)&quot;</span> <span class="cf">if</span> <span class="bu">abs</span>(menge <span class="op">-</span> u) <span class="op">&lt;</span> <span class="fl">1e-6</span> <span class="cf">else</span> <span class="st">&quot;&quot;</span></span>
-<span id="cb90-77"><a href="#cb90-77" aria-hidden="true" tabindex="-1"></a>        <span class="bu">print</span>(<span class="ss">f&quot;</span><span class="sc">{</span>von <span class="op">+</span> <span class="st">&#39; -&gt; &#39;</span> <span class="op">+</span> nach<span class="sc">:&lt;24}</span><span class="ss"> </span><span class="sc">{</span>menge<span class="sc">:&gt;7.1f}</span><span class="ss"> </span><span class="sc">{</span>u<span class="sc">:&gt;11}</span><span class="ss"> &quot;</span></span>
-<span id="cb90-78"><a href="#cb90-78" aria-hidden="true" tabindex="-1"></a>              <span class="ss">f&quot;</span><span class="sc">{</span>c<span class="sc">:&gt;9.2f}</span><span class="ss"> </span><span class="sc">{</span>menge <span class="op">*</span> c<span class="sc">:&gt;9.2f}{</span>ausgelastet<span class="sc">}</span><span class="ss">&quot;</span>)</span>
-<span id="cb90-79"><a href="#cb90-79" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb90-80"><a href="#cb90-80" aria-hidden="true" tabindex="-1"></a>    <span class="co"># --- Flusserhaltung nachpruefen --------------------------------------</span></span>
-<span id="cb90-81"><a href="#cb90-81" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;</span><span class="ch">\n</span><span class="st">--- Pruefung der Flusserhaltung je Knoten ---&quot;</span>)</span>
-<span id="cb90-82"><a href="#cb90-82" aria-hidden="true" tabindex="-1"></a>    <span class="cf">for</span> k <span class="kw">in</span> KNOTEN:</span>
-<span id="cb90-83"><a href="#cb90-83" aria-hidden="true" tabindex="-1"></a>        hinaus <span class="op">=</span> <span class="bu">sum</span>(fluss[e] <span class="cf">for</span> e, (v, n, _, _) <span class="kw">in</span> <span class="bu">enumerate</span>(KANTEN) <span class="cf">if</span> v <span class="op">==</span> k)</span>
-<span id="cb90-84"><a href="#cb90-84" aria-hidden="true" tabindex="-1"></a>        hinein <span class="op">=</span> <span class="bu">sum</span>(fluss[e] <span class="cf">for</span> e, (v, n, _, _) <span class="kw">in</span> <span class="bu">enumerate</span>(KANTEN) <span class="cf">if</span> n <span class="op">==</span> k)</span>
-<span id="cb90-85"><a href="#cb90-85" aria-hidden="true" tabindex="-1"></a>        netto <span class="op">=</span> hinaus <span class="op">-</span> hinein</span>
-<span id="cb90-86"><a href="#cb90-86" aria-hidden="true" tabindex="-1"></a>        art <span class="op">=</span> <span class="st">&quot;Quelle&quot;</span> <span class="cf">if</span> SALDO[k] <span class="op">&gt;</span> <span class="dv">0</span> <span class="cf">else</span> (<span class="st">&quot;Senke&quot;</span> <span class="cf">if</span> SALDO[k] <span class="op">&lt;</span> <span class="dv">0</span> <span class="cf">else</span> <span class="st">&quot;Umschlag&quot;</span>)</span>
-<span id="cb90-87"><a href="#cb90-87" aria-hidden="true" tabindex="-1"></a>        <span class="bu">print</span>(<span class="ss">f&quot;  </span><span class="sc">{</span>k<span class="sc">:&lt;10}</span><span class="ss"> (</span><span class="sc">{</span>art<span class="sc">:&lt;8}</span><span class="ss">): hinaus </span><span class="sc">{</span>hinaus<span class="sc">:5.1f}</span><span class="ss"> - hinein </span><span class="sc">{</span>hinein<span class="sc">:5.1f}</span><span class="ss"> &quot;</span></span>
-<span id="cb90-88"><a href="#cb90-88" aria-hidden="true" tabindex="-1"></a>              <span class="ss">f&quot;= </span><span class="sc">{</span>netto<span class="sc">:+6.1f}</span><span class="ss">  (gefordert: </span><span class="sc">{</span>SALDO[k]<span class="sc">:+d}</span><span class="ss">)&quot;</span>)</span>
-<span id="cb90-89"><a href="#cb90-89" aria-hidden="true" tabindex="-1"></a>        <span class="cf">assert</span> <span class="bu">abs</span>(netto <span class="op">-</span> SALDO[k]) <span class="op">&lt;</span> <span class="fl">1e-6</span>, <span class="ss">f&quot;Flusserhaltung verletzt bei </span><span class="sc">{</span>k<span class="sc">}</span><span class="ss">!&quot;</span></span>
-<span id="cb90-90"><a href="#cb90-90" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb90-91"><a href="#cb90-91" aria-hidden="true" tabindex="-1"></a>    <span class="co"># --- Knotenpreise (Dualwerte) interpretieren -------------------------</span></span>
-<span id="cb90-92"><a href="#cb90-92" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;</span><span class="ch">\n</span><span class="st">--- Knotenpreise (Dualwerte der Flusserhaltung) ---&quot;</span>)</span>
-<span id="cb90-93"><a href="#cb90-93" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;  Differenz zweier Knotenpreise = Grenzkosten einer zusaetzlichen Einheit&quot;</span>)</span>
-<span id="cb90-94"><a href="#cb90-94" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;  auf dem guenstigsten Weg zwischen ihnen.&quot;</span>)</span>
-<span id="cb90-95"><a href="#cb90-95" aria-hidden="true" tabindex="-1"></a>    <span class="cf">for</span> k, preis <span class="kw">in</span> <span class="bu">zip</span>(KNOTEN, knotenpreise):</span>
-<span id="cb90-96"><a href="#cb90-96" aria-hidden="true" tabindex="-1"></a>        <span class="bu">print</span>(<span class="ss">f&quot;  </span><span class="sc">{</span>k<span class="sc">:&lt;10}</span><span class="ss">: </span><span class="sc">{</span>preis<span class="sc">:7.2f}</span><span class="ss">&quot;</span>)</span>
-<span id="cb90-97"><a href="#cb90-97" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;=&quot;</span> <span class="op">*</span> <span class="dv">78</span>)</span></code></pre></div>
+<div class="sourceCode" id="cb92"><pre class="sourceCode python"><code class="sourceCode python"><span id="cb92-1"><a href="#cb92-1" aria-hidden="true" tabindex="-1"></a><span class="co">#!/usr/bin/env python3</span></span>
+<span id="cb92-2"><a href="#cb92-2" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb92-3"><a href="#cb92-3" aria-hidden="true" tabindex="-1"></a><span class="co"># Min_Cost_Flow.py</span></span>
+<span id="cb92-4"><a href="#cb92-4" aria-hidden="true" tabindex="-1"></a><span class="co">&quot;&quot;&quot;</span></span>
+<span id="cb92-5"><a href="#cb92-5" aria-hidden="true" tabindex="-1"></a><span class="co">Kapitel Graphen: Kostenminimaler Fluss durch ein Netzwerk.</span></span>
+<span id="cb92-6"><a href="#cb92-6" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb92-7"><a href="#cb92-7" aria-hidden="true" tabindex="-1"></a><span class="co">Loest dasselbe Problem zweimal:</span></span>
+<span id="cb92-8"><a href="#cb92-8" aria-hidden="true" tabindex="-1"></a><span class="co">  (1) als allgemeines LP mit scipy  -&gt; zeigt die Modellstruktur</span></span>
+<span id="cb92-9"><a href="#cb92-9" aria-hidden="true" tabindex="-1"></a><span class="co">  (2) mit dem spezialisierten Netzwerk-Solver von OR-Tools -&gt; zeigt den</span></span>
+<span id="cb92-10"><a href="#cb92-10" aria-hidden="true" tabindex="-1"></a><span class="co">      Geschwindigkeitsvorteil eines Verfahrens, das die Struktur ausnutzt</span></span>
+<span id="cb92-11"><a href="#cb92-11" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb92-12"><a href="#cb92-12" aria-hidden="true" tabindex="-1"></a><span class="co">Beide laufen in eigenen Prozessen nicht noetig: scipy und ortools vertragen</span></span>
+<span id="cb92-13"><a href="#cb92-13" aria-hidden="true" tabindex="-1"></a><span class="co">sich (nur ortools + highspy kollidieren, siehe Kapitel Oekosystem).</span></span>
+<span id="cb92-14"><a href="#cb92-14" aria-hidden="true" tabindex="-1"></a><span class="co">&quot;&quot;&quot;</span></span>
+<span id="cb92-15"><a href="#cb92-15" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb92-16"><a href="#cb92-16" aria-hidden="true" tabindex="-1"></a><span class="im">import</span> numpy <span class="im">as</span> np</span>
+<span id="cb92-17"><a href="#cb92-17" aria-hidden="true" tabindex="-1"></a><span class="im">from</span> scipy.optimize <span class="im">import</span> linprog</span>
+<span id="cb92-18"><a href="#cb92-18" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb92-19"><a href="#cb92-19" aria-hidden="true" tabindex="-1"></a><span class="co"># --- Netzwerk definieren ---------------------------------------------------</span></span>
+<span id="cb92-20"><a href="#cb92-20" aria-hidden="true" tabindex="-1"></a>KNOTEN <span class="op">=</span> [<span class="st">&quot;Werk_A&quot;</span>, <span class="st">&quot;Werk_B&quot;</span>, <span class="st">&quot;Umschlag&quot;</span>, <span class="st">&quot;Kunde_1&quot;</span>, <span class="st">&quot;Kunde_2&quot;</span>]</span>
+<span id="cb92-21"><a href="#cb92-21" aria-hidden="true" tabindex="-1"></a><span class="co"># (von, nach, Kosten je Einheit, Kapazitaet)</span></span>
+<span id="cb92-22"><a href="#cb92-22" aria-hidden="true" tabindex="-1"></a>KANTEN <span class="op">=</span> [</span>
+<span id="cb92-23"><a href="#cb92-23" aria-hidden="true" tabindex="-1"></a>    (<span class="st">&quot;Werk_A&quot;</span>,   <span class="st">&quot;Umschlag&quot;</span>, <span class="fl">2.0</span>, <span class="dv">15</span>),</span>
+<span id="cb92-24"><a href="#cb92-24" aria-hidden="true" tabindex="-1"></a>    (<span class="st">&quot;Werk_A&quot;</span>,   <span class="st">&quot;Kunde_1&quot;</span>,  <span class="fl">5.0</span>, <span class="dv">10</span>),</span>
+<span id="cb92-25"><a href="#cb92-25" aria-hidden="true" tabindex="-1"></a>    (<span class="st">&quot;Werk_B&quot;</span>,   <span class="st">&quot;Umschlag&quot;</span>, <span class="fl">4.0</span>, <span class="dv">10</span>),</span>
+<span id="cb92-26"><a href="#cb92-26" aria-hidden="true" tabindex="-1"></a>    (<span class="st">&quot;Werk_B&quot;</span>,   <span class="st">&quot;Kunde_2&quot;</span>,  <span class="fl">6.0</span>, <span class="dv">10</span>),</span>
+<span id="cb92-27"><a href="#cb92-27" aria-hidden="true" tabindex="-1"></a>    (<span class="st">&quot;Umschlag&quot;</span>, <span class="st">&quot;Kunde_1&quot;</span>,  <span class="fl">1.0</span>, <span class="dv">20</span>),</span>
+<span id="cb92-28"><a href="#cb92-28" aria-hidden="true" tabindex="-1"></a>    (<span class="st">&quot;Umschlag&quot;</span>, <span class="st">&quot;Kunde_2&quot;</span>,  <span class="fl">3.0</span>, <span class="dv">10</span>),</span>
+<span id="cb92-29"><a href="#cb92-29" aria-hidden="true" tabindex="-1"></a>]</span>
+<span id="cb92-30"><a href="#cb92-30" aria-hidden="true" tabindex="-1"></a><span class="co"># Angebot (+) bzw. Bedarf (-) je Knoten</span></span>
+<span id="cb92-31"><a href="#cb92-31" aria-hidden="true" tabindex="-1"></a>SALDO <span class="op">=</span> {<span class="st">&quot;Werk_A&quot;</span>: <span class="dv">20</span>, <span class="st">&quot;Werk_B&quot;</span>: <span class="dv">10</span>, <span class="st">&quot;Umschlag&quot;</span>: <span class="dv">0</span>, <span class="st">&quot;Kunde_1&quot;</span>: <span class="op">-</span><span class="dv">15</span>, <span class="st">&quot;Kunde_2&quot;</span>: <span class="op">-</span><span class="dv">15</span>}</span>
+<span id="cb92-32"><a href="#cb92-32" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb92-33"><a href="#cb92-33" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb92-34"><a href="#cb92-34" aria-hidden="true" tabindex="-1"></a><span class="kw">def</span> loese_als_lp():</span>
+<span id="cb92-35"><a href="#cb92-35" aria-hidden="true" tabindex="-1"></a>    <span class="co">&quot;&quot;&quot;Flussproblem als allgemeines lineares Programm.&quot;&quot;&quot;</span></span>
+<span id="cb92-36"><a href="#cb92-36" aria-hidden="true" tabindex="-1"></a>    n_kanten <span class="op">=</span> <span class="bu">len</span>(KANTEN)</span>
+<span id="cb92-37"><a href="#cb92-37" aria-hidden="true" tabindex="-1"></a>    knoten_index <span class="op">=</span> {k: i <span class="cf">for</span> i, k <span class="kw">in</span> <span class="bu">enumerate</span>(KNOTEN)}</span>
+<span id="cb92-38"><a href="#cb92-38" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb92-39"><a href="#cb92-39" aria-hidden="true" tabindex="-1"></a>    <span class="co"># Zielfunktion: Summe der Transportkosten</span></span>
+<span id="cb92-40"><a href="#cb92-40" aria-hidden="true" tabindex="-1"></a>    kosten <span class="op">=</span> np.array([k[<span class="dv">2</span>] <span class="cf">for</span> k <span class="kw">in</span> KANTEN])</span>
+<span id="cb92-41"><a href="#cb92-41" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb92-42"><a href="#cb92-42" aria-hidden="true" tabindex="-1"></a>    <span class="co"># Flusserhaltung als Gleichungssystem: A_eq @ x = b_eq</span></span>
+<span id="cb92-43"><a href="#cb92-43" aria-hidden="true" tabindex="-1"></a>    A_eq <span class="op">=</span> np.zeros((<span class="bu">len</span>(KNOTEN), n_kanten))</span>
+<span id="cb92-44"><a href="#cb92-44" aria-hidden="true" tabindex="-1"></a>    <span class="cf">for</span> e, (von, nach, _, _) <span class="kw">in</span> <span class="bu">enumerate</span>(KANTEN):</span>
+<span id="cb92-45"><a href="#cb92-45" aria-hidden="true" tabindex="-1"></a>        A_eq[knoten_index[von], e] <span class="op">=</span> <span class="op">+</span><span class="fl">1.0</span>      <span class="co"># fliesst hinaus</span></span>
+<span id="cb92-46"><a href="#cb92-46" aria-hidden="true" tabindex="-1"></a>        A_eq[knoten_index[nach], e] <span class="op">=</span> <span class="op">-</span><span class="fl">1.0</span>     <span class="co"># fliesst hinein</span></span>
+<span id="cb92-47"><a href="#cb92-47" aria-hidden="true" tabindex="-1"></a>    b_eq <span class="op">=</span> np.array([SALDO[k] <span class="cf">for</span> k <span class="kw">in</span> KNOTEN], dtype<span class="op">=</span><span class="bu">float</span>)</span>
+<span id="cb92-48"><a href="#cb92-48" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb92-49"><a href="#cb92-49" aria-hidden="true" tabindex="-1"></a>    schranken <span class="op">=</span> [(<span class="dv">0</span>, k[<span class="dv">3</span>]) <span class="cf">for</span> k <span class="kw">in</span> KANTEN]    <span class="co"># 0 &lt;= x_ij &lt;= u_ij</span></span>
+<span id="cb92-50"><a href="#cb92-50" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb92-51"><a href="#cb92-51" aria-hidden="true" tabindex="-1"></a>    ergebnis <span class="op">=</span> linprog(c<span class="op">=</span>kosten, A_eq<span class="op">=</span>A_eq, b_eq<span class="op">=</span>b_eq, bounds<span class="op">=</span>schranken, method<span class="op">=</span><span class="st">&quot;highs&quot;</span>)</span>
+<span id="cb92-52"><a href="#cb92-52" aria-hidden="true" tabindex="-1"></a>    <span class="cf">if</span> <span class="kw">not</span> ergebnis.success:</span>
+<span id="cb92-53"><a href="#cb92-53" aria-hidden="true" tabindex="-1"></a>        <span class="cf">raise</span> <span class="pp">SystemExit</span>(<span class="ss">f&quot;Nicht loesbar: </span><span class="sc">{</span>ergebnis<span class="sc">.</span>message<span class="sc">}</span><span class="ss">&quot;</span>)</span>
+<span id="cb92-54"><a href="#cb92-54" aria-hidden="true" tabindex="-1"></a>    <span class="cf">return</span> ergebnis.fun, ergebnis.x, ergebnis.eqlin.marginals</span>
+<span id="cb92-55"><a href="#cb92-55" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb92-56"><a href="#cb92-56" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb92-57"><a href="#cb92-57" aria-hidden="true" tabindex="-1"></a><span class="cf">if</span> <span class="va">__name__</span> <span class="op">==</span> <span class="st">&quot;__main__&quot;</span>:</span>
+<span id="cb92-58"><a href="#cb92-58" aria-hidden="true" tabindex="-1"></a>    <span class="co"># Vorabpruefung: Angebot muss Bedarf entsprechen</span></span>
+<span id="cb92-59"><a href="#cb92-59" aria-hidden="true" tabindex="-1"></a>    gesamt <span class="op">=</span> <span class="bu">sum</span>(SALDO.values())</span>
+<span id="cb92-60"><a href="#cb92-60" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;=&quot;</span> <span class="op">*</span> <span class="dv">78</span>)</span>
+<span id="cb92-61"><a href="#cb92-61" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;  KOSTENMINIMALER FLUSS DURCH EIN TRANSPORTNETZ&quot;</span>)</span>
+<span id="cb92-62"><a href="#cb92-62" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;=&quot;</span> <span class="op">*</span> <span class="dv">78</span>)</span>
+<span id="cb92-63"><a href="#cb92-63" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;Angebot gesamt: </span><span class="sc">{</span><span class="bu">sum</span>(v <span class="cf">for</span> v <span class="kw">in</span> SALDO.values() <span class="cf">if</span> v <span class="op">&gt;</span> <span class="dv">0</span>)<span class="sc">}</span><span class="ss"> | &quot;</span></span>
+<span id="cb92-64"><a href="#cb92-64" aria-hidden="true" tabindex="-1"></a>          <span class="ss">f&quot;Bedarf gesamt: </span><span class="sc">{</span><span class="op">-</span><span class="bu">sum</span>(v <span class="cf">for</span> v <span class="kw">in</span> SALDO.values() <span class="cf">if</span> v <span class="op">&lt;</span> <span class="dv">0</span>)<span class="sc">}</span><span class="ss"> | &quot;</span></span>
+<span id="cb92-65"><a href="#cb92-65" aria-hidden="true" tabindex="-1"></a>          <span class="ss">f&quot;Saldo: </span><span class="sc">{</span>gesamt<span class="sc">}</span><span class="ss">&quot;</span>)</span>
+<span id="cb92-66"><a href="#cb92-66" aria-hidden="true" tabindex="-1"></a>    <span class="cf">if</span> gesamt <span class="op">!=</span> <span class="dv">0</span>:</span>
+<span id="cb92-67"><a href="#cb92-67" aria-hidden="true" tabindex="-1"></a>        <span class="cf">raise</span> <span class="pp">SystemExit</span>(<span class="st">&quot;Angebot und Bedarf stimmen nicht ueberein - unloesbar!&quot;</span>)</span>
+<span id="cb92-68"><a href="#cb92-68" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb92-69"><a href="#cb92-69" aria-hidden="true" tabindex="-1"></a>    kosten_gesamt, fluss, knotenpreise <span class="op">=</span> loese_als_lp()</span>
+<span id="cb92-70"><a href="#cb92-70" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb92-71"><a href="#cb92-71" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;</span><span class="ch">\n</span><span class="ss">Minimale Transportkosten: </span><span class="sc">{</span>kosten_gesamt<span class="sc">:,.2f}</span><span class="ss"> EUR</span><span class="ch">\n</span><span class="ss">&quot;</span>)</span>
+<span id="cb92-72"><a href="#cb92-72" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;</span><span class="sc">{</span><span class="st">&#39;Kante&#39;</span><span class="sc">:&lt;24}</span><span class="ss"> </span><span class="sc">{</span><span class="st">&#39;Fluss&#39;</span><span class="sc">:&gt;7}</span><span class="ss"> </span><span class="sc">{</span><span class="st">&#39;Kapazitaet&#39;</span><span class="sc">:&gt;11}</span><span class="ss"> </span><span class="sc">{</span><span class="st">&#39;Kosten/E&#39;</span><span class="sc">:&gt;9}</span><span class="ss"> </span><span class="sc">{</span><span class="st">&#39;Kosten&#39;</span><span class="sc">:&gt;9}</span><span class="ss">&quot;</span>)</span>
+<span id="cb92-73"><a href="#cb92-73" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;-&quot;</span> <span class="op">*</span> <span class="dv">78</span>)</span>
+<span id="cb92-74"><a href="#cb92-74" aria-hidden="true" tabindex="-1"></a>    <span class="cf">for</span> e, (von, nach, c, u) <span class="kw">in</span> <span class="bu">enumerate</span>(KANTEN):</span>
+<span id="cb92-75"><a href="#cb92-75" aria-hidden="true" tabindex="-1"></a>        menge <span class="op">=</span> fluss[e] <span class="op">+</span> <span class="fl">0.0</span> <span class="cf">if</span> <span class="bu">abs</span>(fluss[e]) <span class="op">&gt;</span> <span class="fl">1e-9</span> <span class="cf">else</span> <span class="fl">0.0</span>   <span class="co"># vermeidet &quot;-0.0&quot;</span></span>
+<span id="cb92-76"><a href="#cb92-76" aria-hidden="true" tabindex="-1"></a>        ausgelastet <span class="op">=</span> <span class="st">&quot; (VOLL)&quot;</span> <span class="cf">if</span> <span class="bu">abs</span>(menge <span class="op">-</span> u) <span class="op">&lt;</span> <span class="fl">1e-6</span> <span class="cf">else</span> <span class="st">&quot;&quot;</span></span>
+<span id="cb92-77"><a href="#cb92-77" aria-hidden="true" tabindex="-1"></a>        <span class="bu">print</span>(<span class="ss">f&quot;</span><span class="sc">{</span>von <span class="op">+</span> <span class="st">&#39; -&gt; &#39;</span> <span class="op">+</span> nach<span class="sc">:&lt;24}</span><span class="ss"> </span><span class="sc">{</span>menge<span class="sc">:&gt;7.1f}</span><span class="ss"> </span><span class="sc">{</span>u<span class="sc">:&gt;11}</span><span class="ss"> &quot;</span></span>
+<span id="cb92-78"><a href="#cb92-78" aria-hidden="true" tabindex="-1"></a>              <span class="ss">f&quot;</span><span class="sc">{</span>c<span class="sc">:&gt;9.2f}</span><span class="ss"> </span><span class="sc">{</span>menge <span class="op">*</span> c<span class="sc">:&gt;9.2f}{</span>ausgelastet<span class="sc">}</span><span class="ss">&quot;</span>)</span>
+<span id="cb92-79"><a href="#cb92-79" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb92-80"><a href="#cb92-80" aria-hidden="true" tabindex="-1"></a>    <span class="co"># --- Flusserhaltung nachpruefen --------------------------------------</span></span>
+<span id="cb92-81"><a href="#cb92-81" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;</span><span class="ch">\n</span><span class="st">--- Pruefung der Flusserhaltung je Knoten ---&quot;</span>)</span>
+<span id="cb92-82"><a href="#cb92-82" aria-hidden="true" tabindex="-1"></a>    <span class="cf">for</span> k <span class="kw">in</span> KNOTEN:</span>
+<span id="cb92-83"><a href="#cb92-83" aria-hidden="true" tabindex="-1"></a>        hinaus <span class="op">=</span> <span class="bu">sum</span>(fluss[e] <span class="cf">for</span> e, (v, n, _, _) <span class="kw">in</span> <span class="bu">enumerate</span>(KANTEN) <span class="cf">if</span> v <span class="op">==</span> k)</span>
+<span id="cb92-84"><a href="#cb92-84" aria-hidden="true" tabindex="-1"></a>        hinein <span class="op">=</span> <span class="bu">sum</span>(fluss[e] <span class="cf">for</span> e, (v, n, _, _) <span class="kw">in</span> <span class="bu">enumerate</span>(KANTEN) <span class="cf">if</span> n <span class="op">==</span> k)</span>
+<span id="cb92-85"><a href="#cb92-85" aria-hidden="true" tabindex="-1"></a>        netto <span class="op">=</span> hinaus <span class="op">-</span> hinein</span>
+<span id="cb92-86"><a href="#cb92-86" aria-hidden="true" tabindex="-1"></a>        art <span class="op">=</span> <span class="st">&quot;Quelle&quot;</span> <span class="cf">if</span> SALDO[k] <span class="op">&gt;</span> <span class="dv">0</span> <span class="cf">else</span> (<span class="st">&quot;Senke&quot;</span> <span class="cf">if</span> SALDO[k] <span class="op">&lt;</span> <span class="dv">0</span> <span class="cf">else</span> <span class="st">&quot;Umschlag&quot;</span>)</span>
+<span id="cb92-87"><a href="#cb92-87" aria-hidden="true" tabindex="-1"></a>        <span class="bu">print</span>(<span class="ss">f&quot;  </span><span class="sc">{</span>k<span class="sc">:&lt;10}</span><span class="ss"> (</span><span class="sc">{</span>art<span class="sc">:&lt;8}</span><span class="ss">): hinaus </span><span class="sc">{</span>hinaus<span class="sc">:5.1f}</span><span class="ss"> - hinein </span><span class="sc">{</span>hinein<span class="sc">:5.1f}</span><span class="ss"> &quot;</span></span>
+<span id="cb92-88"><a href="#cb92-88" aria-hidden="true" tabindex="-1"></a>              <span class="ss">f&quot;= </span><span class="sc">{</span>netto<span class="sc">:+6.1f}</span><span class="ss">  (gefordert: </span><span class="sc">{</span>SALDO[k]<span class="sc">:+d}</span><span class="ss">)&quot;</span>)</span>
+<span id="cb92-89"><a href="#cb92-89" aria-hidden="true" tabindex="-1"></a>        <span class="cf">assert</span> <span class="bu">abs</span>(netto <span class="op">-</span> SALDO[k]) <span class="op">&lt;</span> <span class="fl">1e-6</span>, <span class="ss">f&quot;Flusserhaltung verletzt bei </span><span class="sc">{</span>k<span class="sc">}</span><span class="ss">!&quot;</span></span>
+<span id="cb92-90"><a href="#cb92-90" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb92-91"><a href="#cb92-91" aria-hidden="true" tabindex="-1"></a>    <span class="co"># --- Knotenpreise (Dualwerte) interpretieren -------------------------</span></span>
+<span id="cb92-92"><a href="#cb92-92" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;</span><span class="ch">\n</span><span class="st">--- Knotenpreise (Dualwerte der Flusserhaltung) ---&quot;</span>)</span>
+<span id="cb92-93"><a href="#cb92-93" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;  Differenz zweier Knotenpreise = Grenzkosten einer zusaetzlichen Einheit&quot;</span>)</span>
+<span id="cb92-94"><a href="#cb92-94" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;  auf dem guenstigsten Weg zwischen ihnen.&quot;</span>)</span>
+<span id="cb92-95"><a href="#cb92-95" aria-hidden="true" tabindex="-1"></a>    <span class="cf">for</span> k, preis <span class="kw">in</span> <span class="bu">zip</span>(KNOTEN, knotenpreise):</span>
+<span id="cb92-96"><a href="#cb92-96" aria-hidden="true" tabindex="-1"></a>        <span class="bu">print</span>(<span class="ss">f&quot;  </span><span class="sc">{</span>k<span class="sc">:&lt;10}</span><span class="ss">: </span><span class="sc">{</span>preis<span class="sc">:7.2f}</span><span class="ss">&quot;</span>)</span>
+<span id="cb92-97"><a href="#cb92-97" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;=&quot;</span> <span class="op">*</span> <span class="dv">78</span>)</span></code></pre></div>
 <p><strong>Erwartete Ausgabe:</strong></p>
 <pre><code>==============================================================================
   KOSTENMINIMALER FLUSS DURCH EIN TRANSPORTNETZ
@@ -12326,111 +13071,111 @@ Umschlag -&gt; Kunde_2          5.0          10      3.00     15.00
 <p><strong>Die praktische Folge in einem Satz:</strong> <em>Bei Zuordnungs- und Flussproblemen dürfen Sie die Ganzzahligkeit weglassen und trotzdem ganzzahlige Lösungen erwarten — Sie sparen sich die NP-Schwere von Branch-and-Bound vollständig.</em></p>
 <p><strong>Und die Warnung dazu:</strong> Diese Eigenschaft ist zerbrechlich. Eine einzige zusätzliche Nebenbedingung, die nicht in das Schema passt — „höchstens drei Fahrzeuge insgesamt“, eine Fixkostenkopplung, eine Mindestabnahmemenge — zerstört die totale Unimodularität. Dann liefert die Relaxation wieder Brüche, und Sie brauchen doch ein MILP. Prüfen Sie das, bevor Sie sich auf die Struktur verlassen.</p>
 </blockquote>
-<div class="sourceCode" id="cb92"><pre class="sourceCode python"><code class="sourceCode python"><span id="cb92-1"><a href="#cb92-1" aria-hidden="true" tabindex="-1"></a><span class="co">#!/usr/bin/env python3</span></span>
-<span id="cb92-2"><a href="#cb92-2" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb92-3"><a href="#cb92-3" aria-hidden="true" tabindex="-1"></a><span class="co"># Zuordnung_Ungarisch.py</span></span>
-<span id="cb92-4"><a href="#cb92-4" aria-hidden="true" tabindex="-1"></a><span class="co">&quot;&quot;&quot;</span></span>
-<span id="cb92-5"><a href="#cb92-5" aria-hidden="true" tabindex="-1"></a><span class="co">Kapitel Graphen: Das Zuordnungsproblem, dreifach geloest.</span></span>
-<span id="cb92-6"><a href="#cb92-6" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb92-7"><a href="#cb92-7" aria-hidden="true" tabindex="-1"></a><span class="co">  (1) Ungarischer Algorithmus (scipy.optimize.linear_sum_assignment) - O(n^3)</span></span>
-<span id="cb92-8"><a href="#cb92-8" aria-hidden="true" tabindex="-1"></a><span class="co">  (2) als LP OHNE Ganzzahligkeitsforderung -&gt; liefert trotzdem 0/1 (Birkhoff)</span></span>
-<span id="cb92-9"><a href="#cb92-9" aria-hidden="true" tabindex="-1"></a><span class="co">  (3) als MILP MIT Ganzzahligkeitsforderung -&gt; gleiches Ergebnis, mehr Aufwand</span></span>
-<span id="cb92-10"><a href="#cb92-10" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb92-11"><a href="#cb92-11" aria-hidden="true" tabindex="-1"></a><span class="co">Zeigt damit die praktische Bedeutung der totalen Unimodularitaet.</span></span>
-<span id="cb92-12"><a href="#cb92-12" aria-hidden="true" tabindex="-1"></a><span class="co">&quot;&quot;&quot;</span></span>
-<span id="cb92-13"><a href="#cb92-13" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb92-14"><a href="#cb92-14" aria-hidden="true" tabindex="-1"></a><span class="im">import</span> time</span>
-<span id="cb92-15"><a href="#cb92-15" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb92-16"><a href="#cb92-16" aria-hidden="true" tabindex="-1"></a><span class="im">import</span> numpy <span class="im">as</span> np</span>
-<span id="cb92-17"><a href="#cb92-17" aria-hidden="true" tabindex="-1"></a><span class="im">from</span> scipy.optimize <span class="im">import</span> linear_sum_assignment, linprog</span>
-<span id="cb92-18"><a href="#cb92-18" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb92-19"><a href="#cb92-19" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb92-20"><a href="#cb92-20" aria-hidden="true" tabindex="-1"></a><span class="kw">def</span> erzeuge_kosten(n, seed<span class="op">=</span><span class="dv">11</span>):</span>
-<span id="cb92-21"><a href="#cb92-21" aria-hidden="true" tabindex="-1"></a>    rng <span class="op">=</span> np.random.default_rng(seed)</span>
-<span id="cb92-22"><a href="#cb92-22" aria-hidden="true" tabindex="-1"></a>    <span class="cf">return</span> rng.integers(<span class="dv">10</span>, <span class="dv">99</span>, size<span class="op">=</span>(n, n)).astype(<span class="bu">float</span>)</span>
-<span id="cb92-23"><a href="#cb92-23" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb92-24"><a href="#cb92-24" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb92-25"><a href="#cb92-25" aria-hidden="true" tabindex="-1"></a><span class="kw">def</span> loese_ungarisch(kosten):</span>
-<span id="cb92-26"><a href="#cb92-26" aria-hidden="true" tabindex="-1"></a>    zeilen, spalten <span class="op">=</span> linear_sum_assignment(kosten)</span>
-<span id="cb92-27"><a href="#cb92-27" aria-hidden="true" tabindex="-1"></a>    <span class="cf">return</span> kosten[zeilen, spalten].<span class="bu">sum</span>(), spalten</span>
-<span id="cb92-28"><a href="#cb92-28" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb92-29"><a href="#cb92-29" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb92-30"><a href="#cb92-30" aria-hidden="true" tabindex="-1"></a><span class="kw">def</span> baue_lp(kosten):</span>
-<span id="cb92-31"><a href="#cb92-31" aria-hidden="true" tabindex="-1"></a>    <span class="co">&quot;&quot;&quot;Gemeinsame LP-Struktur fuer Variante 2 und 3.&quot;&quot;&quot;</span></span>
-<span id="cb92-32"><a href="#cb92-32" aria-hidden="true" tabindex="-1"></a>    n <span class="op">=</span> <span class="bu">len</span>(kosten)</span>
-<span id="cb92-33"><a href="#cb92-33" aria-hidden="true" tabindex="-1"></a>    c <span class="op">=</span> kosten.flatten()                       <span class="co"># x_ij in Zeilenreihenfolge</span></span>
-<span id="cb92-34"><a href="#cb92-34" aria-hidden="true" tabindex="-1"></a>    A_eq <span class="op">=</span> np.zeros((<span class="dv">2</span> <span class="op">*</span> n, n <span class="op">*</span> n))</span>
-<span id="cb92-35"><a href="#cb92-35" aria-hidden="true" tabindex="-1"></a>    <span class="cf">for</span> i <span class="kw">in</span> <span class="bu">range</span>(n):                         <span class="co"># jede Person genau eine Aufgabe</span></span>
-<span id="cb92-36"><a href="#cb92-36" aria-hidden="true" tabindex="-1"></a>        A_eq[i, i <span class="op">*</span> n:(i <span class="op">+</span> <span class="dv">1</span>) <span class="op">*</span> n] <span class="op">=</span> <span class="fl">1.0</span></span>
-<span id="cb92-37"><a href="#cb92-37" aria-hidden="true" tabindex="-1"></a>    <span class="cf">for</span> j <span class="kw">in</span> <span class="bu">range</span>(n):                         <span class="co"># jede Aufgabe genau einer Person</span></span>
-<span id="cb92-38"><a href="#cb92-38" aria-hidden="true" tabindex="-1"></a>        A_eq[n <span class="op">+</span> j, j::n] <span class="op">=</span> <span class="fl">1.0</span></span>
-<span id="cb92-39"><a href="#cb92-39" aria-hidden="true" tabindex="-1"></a>    b_eq <span class="op">=</span> np.ones(<span class="dv">2</span> <span class="op">*</span> n)</span>
-<span id="cb92-40"><a href="#cb92-40" aria-hidden="true" tabindex="-1"></a>    <span class="cf">return</span> c, A_eq, b_eq</span>
-<span id="cb92-41"><a href="#cb92-41" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb92-42"><a href="#cb92-42" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb92-43"><a href="#cb92-43" aria-hidden="true" tabindex="-1"></a><span class="kw">def</span> loese_lp(kosten, ganzzahlig):</span>
-<span id="cb92-44"><a href="#cb92-44" aria-hidden="true" tabindex="-1"></a>    n <span class="op">=</span> <span class="bu">len</span>(kosten)</span>
-<span id="cb92-45"><a href="#cb92-45" aria-hidden="true" tabindex="-1"></a>    c, A_eq, b_eq <span class="op">=</span> baue_lp(kosten)</span>
-<span id="cb92-46"><a href="#cb92-46" aria-hidden="true" tabindex="-1"></a>    ergebnis <span class="op">=</span> linprog(c<span class="op">=</span>c, A_eq<span class="op">=</span>A_eq, b_eq<span class="op">=</span>b_eq, bounds<span class="op">=</span>[(<span class="dv">0</span>, <span class="dv">1</span>)] <span class="op">*</span> (n <span class="op">*</span> n),</span>
-<span id="cb92-47"><a href="#cb92-47" aria-hidden="true" tabindex="-1"></a>                       integrality<span class="op">=</span>np.ones(n <span class="op">*</span> n) <span class="cf">if</span> ganzzahlig <span class="cf">else</span> <span class="va">None</span>,</span>
-<span id="cb92-48"><a href="#cb92-48" aria-hidden="true" tabindex="-1"></a>                       method<span class="op">=</span><span class="st">&quot;highs&quot;</span>)</span>
-<span id="cb92-49"><a href="#cb92-49" aria-hidden="true" tabindex="-1"></a>    x <span class="op">=</span> ergebnis.x.reshape(n, n)</span>
-<span id="cb92-50"><a href="#cb92-50" aria-hidden="true" tabindex="-1"></a>    <span class="cf">return</span> ergebnis.fun, x</span>
-<span id="cb92-51"><a href="#cb92-51" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb92-52"><a href="#cb92-52" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb92-53"><a href="#cb92-53" aria-hidden="true" tabindex="-1"></a><span class="cf">if</span> <span class="va">__name__</span> <span class="op">==</span> <span class="st">&quot;__main__&quot;</span>:</span>
-<span id="cb92-54"><a href="#cb92-54" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;=&quot;</span> <span class="op">*</span> <span class="dv">84</span>)</span>
-<span id="cb92-55"><a href="#cb92-55" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;  ZUORDNUNGSPROBLEM: DREI WEGE ZUM SELBEN ERGEBNIS&quot;</span>)</span>
-<span id="cb92-56"><a href="#cb92-56" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;=&quot;</span> <span class="op">*</span> <span class="dv">84</span>)</span>
-<span id="cb92-57"><a href="#cb92-57" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb92-58"><a href="#cb92-58" aria-hidden="true" tabindex="-1"></a>    <span class="co"># --- Kleines Beispiel zum Nachvollziehen ------------------------------</span></span>
-<span id="cb92-59"><a href="#cb92-59" aria-hidden="true" tabindex="-1"></a>    kosten <span class="op">=</span> np.array([[<span class="fl">82.</span>, <span class="fl">83.</span>, <span class="fl">69.</span>, <span class="fl">92.</span>],</span>
-<span id="cb92-60"><a href="#cb92-60" aria-hidden="true" tabindex="-1"></a>                       [<span class="fl">77.</span>, <span class="fl">37.</span>, <span class="fl">49.</span>, <span class="fl">92.</span>],</span>
-<span id="cb92-61"><a href="#cb92-61" aria-hidden="true" tabindex="-1"></a>                       [<span class="fl">11.</span>, <span class="fl">69.</span>, <span class="fl">5.</span>, <span class="fl">86.</span>],</span>
-<span id="cb92-62"><a href="#cb92-62" aria-hidden="true" tabindex="-1"></a>                       [<span class="fl">8.</span>, <span class="fl">9.</span>, <span class="fl">98.</span>, <span class="fl">23.</span>]])</span>
-<span id="cb92-63"><a href="#cb92-63" aria-hidden="true" tabindex="-1"></a>    namen <span class="op">=</span> [<span class="st">&quot;Anna&quot;</span>, <span class="st">&quot;Ben&quot;</span>, <span class="st">&quot;Carla&quot;</span>, <span class="st">&quot;David&quot;</span>]</span>
-<span id="cb92-64"><a href="#cb92-64" aria-hidden="true" tabindex="-1"></a>    aufgaben <span class="op">=</span> [<span class="st">&quot;Auftrag W&quot;</span>, <span class="st">&quot;Auftrag X&quot;</span>, <span class="st">&quot;Auftrag Y&quot;</span>, <span class="st">&quot;Auftrag Z&quot;</span>]</span>
-<span id="cb92-65"><a href="#cb92-65" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb92-66"><a href="#cb92-66" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;</span><span class="ch">\n</span><span class="st">Kostenmatrix (wer bearbeitet was zu welchen Kosten?):&quot;</span>)</span>
-<span id="cb92-67"><a href="#cb92-67" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;</span><span class="sc">{</span><span class="st">&#39;&#39;</span><span class="sc">:&lt;8}</span><span class="ss">&quot;</span> <span class="op">+</span> <span class="st">&quot;&quot;</span>.join(<span class="ss">f&quot;</span><span class="sc">{</span>a<span class="sc">:&gt;12}</span><span class="ss">&quot;</span> <span class="cf">for</span> a <span class="kw">in</span> aufgaben))</span>
-<span id="cb92-68"><a href="#cb92-68" aria-hidden="true" tabindex="-1"></a>    <span class="cf">for</span> i, name <span class="kw">in</span> <span class="bu">enumerate</span>(namen):</span>
-<span id="cb92-69"><a href="#cb92-69" aria-hidden="true" tabindex="-1"></a>        <span class="bu">print</span>(<span class="ss">f&quot;</span><span class="sc">{</span>name<span class="sc">:&lt;8}</span><span class="ss">&quot;</span> <span class="op">+</span> <span class="st">&quot;&quot;</span>.join(<span class="ss">f&quot;</span><span class="sc">{</span>kosten[i, j]<span class="sc">:&gt;12.0f}</span><span class="ss">&quot;</span> <span class="cf">for</span> j <span class="kw">in</span> <span class="bu">range</span>(<span class="dv">4</span>)))</span>
-<span id="cb92-70"><a href="#cb92-70" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb92-71"><a href="#cb92-71" aria-hidden="true" tabindex="-1"></a>    wert, zuordnung <span class="op">=</span> loese_ungarisch(kosten)</span>
-<span id="cb92-72"><a href="#cb92-72" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;</span><span class="ch">\n</span><span class="ss">Optimale Zuordnung (Gesamtkosten </span><span class="sc">{</span>wert<span class="sc">:.0f}</span><span class="ss">):&quot;</span>)</span>
-<span id="cb92-73"><a href="#cb92-73" aria-hidden="true" tabindex="-1"></a>    <span class="cf">for</span> i, j <span class="kw">in</span> <span class="bu">enumerate</span>(zuordnung):</span>
-<span id="cb92-74"><a href="#cb92-74" aria-hidden="true" tabindex="-1"></a>        <span class="bu">print</span>(<span class="ss">f&quot;  </span><span class="sc">{</span>namen[i]<span class="sc">:&lt;8}</span><span class="ss"> -&gt; </span><span class="sc">{</span>aufgaben[j]<span class="sc">:&lt;12}</span><span class="ss"> (</span><span class="sc">{</span>kosten[i, j]<span class="sc">:.0f}</span><span class="ss"> EUR)&quot;</span>)</span>
-<span id="cb92-75"><a href="#cb92-75" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb92-76"><a href="#cb92-76" aria-hidden="true" tabindex="-1"></a>    <span class="co"># --- Nachweis: LP ohne Ganzzahligkeit liefert trotzdem 0/1 -----------</span></span>
-<span id="cb92-77"><a href="#cb92-77" aria-hidden="true" tabindex="-1"></a>    wert_lp, x_lp <span class="op">=</span> loese_lp(kosten, ganzzahlig<span class="op">=</span><span class="va">False</span>)</span>
-<span id="cb92-78"><a href="#cb92-78" aria-hidden="true" tabindex="-1"></a>    ist_binaer <span class="op">=</span> np.<span class="bu">all</span>((np.<span class="bu">abs</span>(x_lp) <span class="op">&lt;</span> <span class="fl">1e-9</span>) <span class="op">|</span> (np.<span class="bu">abs</span>(x_lp <span class="op">-</span> <span class="dv">1</span>) <span class="op">&lt;</span> <span class="fl">1e-9</span>))</span>
-<span id="cb92-79"><a href="#cb92-79" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;</span><span class="ch">\n</span><span class="ss">LP OHNE Ganzzahligkeitsforderung: Kosten </span><span class="sc">{</span>wert_lp<span class="sc">:.0f}</span><span class="ss">, &quot;</span></span>
-<span id="cb92-80"><a href="#cb92-80" aria-hidden="true" tabindex="-1"></a>          <span class="ss">f&quot;Loesung ist </span><span class="sc">{</span><span class="st">&#39;0/1-wertig&#39;</span> <span class="cf">if</span> ist_binaer <span class="cf">else</span> <span class="st">&#39;GEBROCHEN&#39;</span><span class="sc">}</span><span class="ss">&quot;</span>)</span>
-<span id="cb92-81"><a href="#cb92-81" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;  -&gt; Satz von Birkhoff/von Neumann bestaetigt: Die Ecken sind Permutationen.&quot;</span>)</span>
-<span id="cb92-82"><a href="#cb92-82" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb92-83"><a href="#cb92-83" aria-hidden="true" tabindex="-1"></a>    <span class="co"># --- Laufzeitvergleich bei wachsender Groesse ------------------------</span></span>
-<span id="cb92-84"><a href="#cb92-84" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;</span><span class="ch">\n</span><span class="st">&quot;</span> <span class="op">+</span> <span class="st">&quot;-&quot;</span> <span class="op">*</span> <span class="dv">84</span>)</span>
-<span id="cb92-85"><a href="#cb92-85" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;</span><span class="sc">{</span><span class="st">&#39;n&#39;</span><span class="sc">:&gt;4}</span><span class="ss"> | </span><span class="sc">{</span><span class="st">&#39;Ungarisch&#39;</span><span class="sc">:&gt;12}</span><span class="ss"> | </span><span class="sc">{</span><span class="st">&#39;LP (kontinuierlich)&#39;</span><span class="sc">:&gt;21}</span><span class="ss"> | &quot;</span></span>
-<span id="cb92-86"><a href="#cb92-86" aria-hidden="true" tabindex="-1"></a>          <span class="ss">f&quot;</span><span class="sc">{</span><span class="st">&#39;MILP (ganzzahlig)&#39;</span><span class="sc">:&gt;19}</span><span class="ss"> | </span><span class="sc">{</span><span class="st">&#39;gleich?&#39;</span><span class="sc">:&gt;8}</span><span class="ss">&quot;</span>)</span>
-<span id="cb92-87"><a href="#cb92-87" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;-&quot;</span> <span class="op">*</span> <span class="dv">84</span>)</span>
-<span id="cb92-88"><a href="#cb92-88" aria-hidden="true" tabindex="-1"></a>    <span class="cf">for</span> n <span class="kw">in</span> [<span class="dv">10</span>, <span class="dv">25</span>, <span class="dv">50</span>, <span class="dv">100</span>]:</span>
-<span id="cb92-89"><a href="#cb92-89" aria-hidden="true" tabindex="-1"></a>        k <span class="op">=</span> erzeuge_kosten(n)</span>
-<span id="cb92-90"><a href="#cb92-90" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb92-91"><a href="#cb92-91" aria-hidden="true" tabindex="-1"></a>        t0 <span class="op">=</span> time.perf_counter()<span class="op">;</span> w1, _ <span class="op">=</span> loese_ungarisch(k)<span class="op">;</span> t1 <span class="op">=</span> time.perf_counter() <span class="op">-</span> t0</span>
-<span id="cb92-92"><a href="#cb92-92" aria-hidden="true" tabindex="-1"></a>        t0 <span class="op">=</span> time.perf_counter()<span class="op">;</span> w2, _ <span class="op">=</span> loese_lp(k, <span class="va">False</span>)<span class="op">;</span>  t2 <span class="op">=</span> time.perf_counter() <span class="op">-</span> t0</span>
-<span id="cb92-93"><a href="#cb92-93" aria-hidden="true" tabindex="-1"></a>        <span class="cf">if</span> n <span class="op">&lt;=</span> <span class="dv">50</span>:</span>
-<span id="cb92-94"><a href="#cb92-94" aria-hidden="true" tabindex="-1"></a>            t0 <span class="op">=</span> time.perf_counter()<span class="op">;</span> w3, _ <span class="op">=</span> loese_lp(k, <span class="va">True</span>)<span class="op">;</span> t3 <span class="op">=</span> time.perf_counter() <span class="op">-</span> t0</span>
-<span id="cb92-95"><a href="#cb92-95" aria-hidden="true" tabindex="-1"></a>            t3_text, gleich <span class="op">=</span> <span class="ss">f&quot;</span><span class="sc">{</span>t3<span class="op">*</span><span class="dv">1000</span><span class="sc">:&gt;16.1f}</span><span class="ss"> ms&quot;</span>, <span class="bu">abs</span>(w1 <span class="op">-</span> w3) <span class="op">&lt;</span> <span class="fl">1e-6</span></span>
-<span id="cb92-96"><a href="#cb92-96" aria-hidden="true" tabindex="-1"></a>        <span class="cf">else</span>:</span>
-<span id="cb92-97"><a href="#cb92-97" aria-hidden="true" tabindex="-1"></a>            t3_text, gleich <span class="op">=</span> <span class="ss">f&quot;</span><span class="sc">{</span><span class="st">&#39;uebersprungen&#39;</span><span class="sc">:&gt;19}</span><span class="ss">&quot;</span>, <span class="bu">abs</span>(w1 <span class="op">-</span> w2) <span class="op">&lt;</span> <span class="fl">1e-6</span></span>
-<span id="cb92-98"><a href="#cb92-98" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb92-99"><a href="#cb92-99" aria-hidden="true" tabindex="-1"></a>        <span class="bu">print</span>(<span class="ss">f&quot;</span><span class="sc">{</span>n<span class="sc">:&gt;4}</span><span class="ss"> | </span><span class="sc">{</span>t1<span class="op">*</span><span class="dv">1000</span><span class="sc">:&gt;9.1f}</span><span class="ss"> ms | </span><span class="sc">{</span>t2<span class="op">*</span><span class="dv">1000</span><span class="sc">:&gt;18.1f}</span><span class="ss"> ms | </span><span class="sc">{</span>t3_text<span class="sc">}</span><span class="ss"> | &quot;</span></span>
-<span id="cb92-100"><a href="#cb92-100" aria-hidden="true" tabindex="-1"></a>              <span class="ss">f&quot;</span><span class="sc">{</span><span class="st">&#39;ja&#39;</span> <span class="cf">if</span> gleich <span class="cf">else</span> <span class="st">&#39;NEIN&#39;</span><span class="sc">:&gt;8}</span><span class="ss">&quot;</span>)</span>
-<span id="cb92-101"><a href="#cb92-101" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb92-102"><a href="#cb92-102" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;-&quot;</span> <span class="op">*</span> <span class="dv">84</span>)</span>
-<span id="cb92-103"><a href="#cb92-103" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;Fazit: Der spezialisierte Ungarische Algorithmus ist um Groessenordnungen&quot;</span>)</span>
-<span id="cb92-104"><a href="#cb92-104" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;schneller. Nutzen Sie fuer reine Zuordnungen NIE einen MILP-Solver.&quot;</span>)</span>
-<span id="cb92-105"><a href="#cb92-105" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;=&quot;</span> <span class="op">*</span> <span class="dv">84</span>)</span></code></pre></div>
+<div class="sourceCode" id="cb94"><pre class="sourceCode python"><code class="sourceCode python"><span id="cb94-1"><a href="#cb94-1" aria-hidden="true" tabindex="-1"></a><span class="co">#!/usr/bin/env python3</span></span>
+<span id="cb94-2"><a href="#cb94-2" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb94-3"><a href="#cb94-3" aria-hidden="true" tabindex="-1"></a><span class="co"># Zuordnung_Ungarisch.py</span></span>
+<span id="cb94-4"><a href="#cb94-4" aria-hidden="true" tabindex="-1"></a><span class="co">&quot;&quot;&quot;</span></span>
+<span id="cb94-5"><a href="#cb94-5" aria-hidden="true" tabindex="-1"></a><span class="co">Kapitel Graphen: Das Zuordnungsproblem, dreifach geloest.</span></span>
+<span id="cb94-6"><a href="#cb94-6" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb94-7"><a href="#cb94-7" aria-hidden="true" tabindex="-1"></a><span class="co">  (1) Ungarischer Algorithmus (scipy.optimize.linear_sum_assignment) - O(n^3)</span></span>
+<span id="cb94-8"><a href="#cb94-8" aria-hidden="true" tabindex="-1"></a><span class="co">  (2) als LP OHNE Ganzzahligkeitsforderung -&gt; liefert trotzdem 0/1 (Birkhoff)</span></span>
+<span id="cb94-9"><a href="#cb94-9" aria-hidden="true" tabindex="-1"></a><span class="co">  (3) als MILP MIT Ganzzahligkeitsforderung -&gt; gleiches Ergebnis, mehr Aufwand</span></span>
+<span id="cb94-10"><a href="#cb94-10" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb94-11"><a href="#cb94-11" aria-hidden="true" tabindex="-1"></a><span class="co">Zeigt damit die praktische Bedeutung der totalen Unimodularitaet.</span></span>
+<span id="cb94-12"><a href="#cb94-12" aria-hidden="true" tabindex="-1"></a><span class="co">&quot;&quot;&quot;</span></span>
+<span id="cb94-13"><a href="#cb94-13" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb94-14"><a href="#cb94-14" aria-hidden="true" tabindex="-1"></a><span class="im">import</span> time</span>
+<span id="cb94-15"><a href="#cb94-15" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb94-16"><a href="#cb94-16" aria-hidden="true" tabindex="-1"></a><span class="im">import</span> numpy <span class="im">as</span> np</span>
+<span id="cb94-17"><a href="#cb94-17" aria-hidden="true" tabindex="-1"></a><span class="im">from</span> scipy.optimize <span class="im">import</span> linear_sum_assignment, linprog</span>
+<span id="cb94-18"><a href="#cb94-18" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb94-19"><a href="#cb94-19" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb94-20"><a href="#cb94-20" aria-hidden="true" tabindex="-1"></a><span class="kw">def</span> erzeuge_kosten(n, seed<span class="op">=</span><span class="dv">11</span>):</span>
+<span id="cb94-21"><a href="#cb94-21" aria-hidden="true" tabindex="-1"></a>    rng <span class="op">=</span> np.random.default_rng(seed)</span>
+<span id="cb94-22"><a href="#cb94-22" aria-hidden="true" tabindex="-1"></a>    <span class="cf">return</span> rng.integers(<span class="dv">10</span>, <span class="dv">99</span>, size<span class="op">=</span>(n, n)).astype(<span class="bu">float</span>)</span>
+<span id="cb94-23"><a href="#cb94-23" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb94-24"><a href="#cb94-24" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb94-25"><a href="#cb94-25" aria-hidden="true" tabindex="-1"></a><span class="kw">def</span> loese_ungarisch(kosten):</span>
+<span id="cb94-26"><a href="#cb94-26" aria-hidden="true" tabindex="-1"></a>    zeilen, spalten <span class="op">=</span> linear_sum_assignment(kosten)</span>
+<span id="cb94-27"><a href="#cb94-27" aria-hidden="true" tabindex="-1"></a>    <span class="cf">return</span> kosten[zeilen, spalten].<span class="bu">sum</span>(), spalten</span>
+<span id="cb94-28"><a href="#cb94-28" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb94-29"><a href="#cb94-29" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb94-30"><a href="#cb94-30" aria-hidden="true" tabindex="-1"></a><span class="kw">def</span> baue_lp(kosten):</span>
+<span id="cb94-31"><a href="#cb94-31" aria-hidden="true" tabindex="-1"></a>    <span class="co">&quot;&quot;&quot;Gemeinsame LP-Struktur fuer Variante 2 und 3.&quot;&quot;&quot;</span></span>
+<span id="cb94-32"><a href="#cb94-32" aria-hidden="true" tabindex="-1"></a>    n <span class="op">=</span> <span class="bu">len</span>(kosten)</span>
+<span id="cb94-33"><a href="#cb94-33" aria-hidden="true" tabindex="-1"></a>    c <span class="op">=</span> kosten.flatten()                       <span class="co"># x_ij in Zeilenreihenfolge</span></span>
+<span id="cb94-34"><a href="#cb94-34" aria-hidden="true" tabindex="-1"></a>    A_eq <span class="op">=</span> np.zeros((<span class="dv">2</span> <span class="op">*</span> n, n <span class="op">*</span> n))</span>
+<span id="cb94-35"><a href="#cb94-35" aria-hidden="true" tabindex="-1"></a>    <span class="cf">for</span> i <span class="kw">in</span> <span class="bu">range</span>(n):                         <span class="co"># jede Person genau eine Aufgabe</span></span>
+<span id="cb94-36"><a href="#cb94-36" aria-hidden="true" tabindex="-1"></a>        A_eq[i, i <span class="op">*</span> n:(i <span class="op">+</span> <span class="dv">1</span>) <span class="op">*</span> n] <span class="op">=</span> <span class="fl">1.0</span></span>
+<span id="cb94-37"><a href="#cb94-37" aria-hidden="true" tabindex="-1"></a>    <span class="cf">for</span> j <span class="kw">in</span> <span class="bu">range</span>(n):                         <span class="co"># jede Aufgabe genau einer Person</span></span>
+<span id="cb94-38"><a href="#cb94-38" aria-hidden="true" tabindex="-1"></a>        A_eq[n <span class="op">+</span> j, j::n] <span class="op">=</span> <span class="fl">1.0</span></span>
+<span id="cb94-39"><a href="#cb94-39" aria-hidden="true" tabindex="-1"></a>    b_eq <span class="op">=</span> np.ones(<span class="dv">2</span> <span class="op">*</span> n)</span>
+<span id="cb94-40"><a href="#cb94-40" aria-hidden="true" tabindex="-1"></a>    <span class="cf">return</span> c, A_eq, b_eq</span>
+<span id="cb94-41"><a href="#cb94-41" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb94-42"><a href="#cb94-42" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb94-43"><a href="#cb94-43" aria-hidden="true" tabindex="-1"></a><span class="kw">def</span> loese_lp(kosten, ganzzahlig):</span>
+<span id="cb94-44"><a href="#cb94-44" aria-hidden="true" tabindex="-1"></a>    n <span class="op">=</span> <span class="bu">len</span>(kosten)</span>
+<span id="cb94-45"><a href="#cb94-45" aria-hidden="true" tabindex="-1"></a>    c, A_eq, b_eq <span class="op">=</span> baue_lp(kosten)</span>
+<span id="cb94-46"><a href="#cb94-46" aria-hidden="true" tabindex="-1"></a>    ergebnis <span class="op">=</span> linprog(c<span class="op">=</span>c, A_eq<span class="op">=</span>A_eq, b_eq<span class="op">=</span>b_eq, bounds<span class="op">=</span>[(<span class="dv">0</span>, <span class="dv">1</span>)] <span class="op">*</span> (n <span class="op">*</span> n),</span>
+<span id="cb94-47"><a href="#cb94-47" aria-hidden="true" tabindex="-1"></a>                       integrality<span class="op">=</span>np.ones(n <span class="op">*</span> n) <span class="cf">if</span> ganzzahlig <span class="cf">else</span> <span class="va">None</span>,</span>
+<span id="cb94-48"><a href="#cb94-48" aria-hidden="true" tabindex="-1"></a>                       method<span class="op">=</span><span class="st">&quot;highs&quot;</span>)</span>
+<span id="cb94-49"><a href="#cb94-49" aria-hidden="true" tabindex="-1"></a>    x <span class="op">=</span> ergebnis.x.reshape(n, n)</span>
+<span id="cb94-50"><a href="#cb94-50" aria-hidden="true" tabindex="-1"></a>    <span class="cf">return</span> ergebnis.fun, x</span>
+<span id="cb94-51"><a href="#cb94-51" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb94-52"><a href="#cb94-52" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb94-53"><a href="#cb94-53" aria-hidden="true" tabindex="-1"></a><span class="cf">if</span> <span class="va">__name__</span> <span class="op">==</span> <span class="st">&quot;__main__&quot;</span>:</span>
+<span id="cb94-54"><a href="#cb94-54" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;=&quot;</span> <span class="op">*</span> <span class="dv">84</span>)</span>
+<span id="cb94-55"><a href="#cb94-55" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;  ZUORDNUNGSPROBLEM: DREI WEGE ZUM SELBEN ERGEBNIS&quot;</span>)</span>
+<span id="cb94-56"><a href="#cb94-56" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;=&quot;</span> <span class="op">*</span> <span class="dv">84</span>)</span>
+<span id="cb94-57"><a href="#cb94-57" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb94-58"><a href="#cb94-58" aria-hidden="true" tabindex="-1"></a>    <span class="co"># --- Kleines Beispiel zum Nachvollziehen ------------------------------</span></span>
+<span id="cb94-59"><a href="#cb94-59" aria-hidden="true" tabindex="-1"></a>    kosten <span class="op">=</span> np.array([[<span class="fl">82.</span>, <span class="fl">83.</span>, <span class="fl">69.</span>, <span class="fl">92.</span>],</span>
+<span id="cb94-60"><a href="#cb94-60" aria-hidden="true" tabindex="-1"></a>                       [<span class="fl">77.</span>, <span class="fl">37.</span>, <span class="fl">49.</span>, <span class="fl">92.</span>],</span>
+<span id="cb94-61"><a href="#cb94-61" aria-hidden="true" tabindex="-1"></a>                       [<span class="fl">11.</span>, <span class="fl">69.</span>, <span class="fl">5.</span>, <span class="fl">86.</span>],</span>
+<span id="cb94-62"><a href="#cb94-62" aria-hidden="true" tabindex="-1"></a>                       [<span class="fl">8.</span>, <span class="fl">9.</span>, <span class="fl">98.</span>, <span class="fl">23.</span>]])</span>
+<span id="cb94-63"><a href="#cb94-63" aria-hidden="true" tabindex="-1"></a>    namen <span class="op">=</span> [<span class="st">&quot;Anna&quot;</span>, <span class="st">&quot;Ben&quot;</span>, <span class="st">&quot;Carla&quot;</span>, <span class="st">&quot;David&quot;</span>]</span>
+<span id="cb94-64"><a href="#cb94-64" aria-hidden="true" tabindex="-1"></a>    aufgaben <span class="op">=</span> [<span class="st">&quot;Auftrag W&quot;</span>, <span class="st">&quot;Auftrag X&quot;</span>, <span class="st">&quot;Auftrag Y&quot;</span>, <span class="st">&quot;Auftrag Z&quot;</span>]</span>
+<span id="cb94-65"><a href="#cb94-65" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb94-66"><a href="#cb94-66" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;</span><span class="ch">\n</span><span class="st">Kostenmatrix (wer bearbeitet was zu welchen Kosten?):&quot;</span>)</span>
+<span id="cb94-67"><a href="#cb94-67" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;</span><span class="sc">{</span><span class="st">&#39;&#39;</span><span class="sc">:&lt;8}</span><span class="ss">&quot;</span> <span class="op">+</span> <span class="st">&quot;&quot;</span>.join(<span class="ss">f&quot;</span><span class="sc">{</span>a<span class="sc">:&gt;12}</span><span class="ss">&quot;</span> <span class="cf">for</span> a <span class="kw">in</span> aufgaben))</span>
+<span id="cb94-68"><a href="#cb94-68" aria-hidden="true" tabindex="-1"></a>    <span class="cf">for</span> i, name <span class="kw">in</span> <span class="bu">enumerate</span>(namen):</span>
+<span id="cb94-69"><a href="#cb94-69" aria-hidden="true" tabindex="-1"></a>        <span class="bu">print</span>(<span class="ss">f&quot;</span><span class="sc">{</span>name<span class="sc">:&lt;8}</span><span class="ss">&quot;</span> <span class="op">+</span> <span class="st">&quot;&quot;</span>.join(<span class="ss">f&quot;</span><span class="sc">{</span>kosten[i, j]<span class="sc">:&gt;12.0f}</span><span class="ss">&quot;</span> <span class="cf">for</span> j <span class="kw">in</span> <span class="bu">range</span>(<span class="dv">4</span>)))</span>
+<span id="cb94-70"><a href="#cb94-70" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb94-71"><a href="#cb94-71" aria-hidden="true" tabindex="-1"></a>    wert, zuordnung <span class="op">=</span> loese_ungarisch(kosten)</span>
+<span id="cb94-72"><a href="#cb94-72" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;</span><span class="ch">\n</span><span class="ss">Optimale Zuordnung (Gesamtkosten </span><span class="sc">{</span>wert<span class="sc">:.0f}</span><span class="ss">):&quot;</span>)</span>
+<span id="cb94-73"><a href="#cb94-73" aria-hidden="true" tabindex="-1"></a>    <span class="cf">for</span> i, j <span class="kw">in</span> <span class="bu">enumerate</span>(zuordnung):</span>
+<span id="cb94-74"><a href="#cb94-74" aria-hidden="true" tabindex="-1"></a>        <span class="bu">print</span>(<span class="ss">f&quot;  </span><span class="sc">{</span>namen[i]<span class="sc">:&lt;8}</span><span class="ss"> -&gt; </span><span class="sc">{</span>aufgaben[j]<span class="sc">:&lt;12}</span><span class="ss"> (</span><span class="sc">{</span>kosten[i, j]<span class="sc">:.0f}</span><span class="ss"> EUR)&quot;</span>)</span>
+<span id="cb94-75"><a href="#cb94-75" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb94-76"><a href="#cb94-76" aria-hidden="true" tabindex="-1"></a>    <span class="co"># --- Nachweis: LP ohne Ganzzahligkeit liefert trotzdem 0/1 -----------</span></span>
+<span id="cb94-77"><a href="#cb94-77" aria-hidden="true" tabindex="-1"></a>    wert_lp, x_lp <span class="op">=</span> loese_lp(kosten, ganzzahlig<span class="op">=</span><span class="va">False</span>)</span>
+<span id="cb94-78"><a href="#cb94-78" aria-hidden="true" tabindex="-1"></a>    ist_binaer <span class="op">=</span> np.<span class="bu">all</span>((np.<span class="bu">abs</span>(x_lp) <span class="op">&lt;</span> <span class="fl">1e-9</span>) <span class="op">|</span> (np.<span class="bu">abs</span>(x_lp <span class="op">-</span> <span class="dv">1</span>) <span class="op">&lt;</span> <span class="fl">1e-9</span>))</span>
+<span id="cb94-79"><a href="#cb94-79" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;</span><span class="ch">\n</span><span class="ss">LP OHNE Ganzzahligkeitsforderung: Kosten </span><span class="sc">{</span>wert_lp<span class="sc">:.0f}</span><span class="ss">, &quot;</span></span>
+<span id="cb94-80"><a href="#cb94-80" aria-hidden="true" tabindex="-1"></a>          <span class="ss">f&quot;Loesung ist </span><span class="sc">{</span><span class="st">&#39;0/1-wertig&#39;</span> <span class="cf">if</span> ist_binaer <span class="cf">else</span> <span class="st">&#39;GEBROCHEN&#39;</span><span class="sc">}</span><span class="ss">&quot;</span>)</span>
+<span id="cb94-81"><a href="#cb94-81" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;  -&gt; Satz von Birkhoff/von Neumann bestaetigt: Die Ecken sind Permutationen.&quot;</span>)</span>
+<span id="cb94-82"><a href="#cb94-82" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb94-83"><a href="#cb94-83" aria-hidden="true" tabindex="-1"></a>    <span class="co"># --- Laufzeitvergleich bei wachsender Groesse ------------------------</span></span>
+<span id="cb94-84"><a href="#cb94-84" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;</span><span class="ch">\n</span><span class="st">&quot;</span> <span class="op">+</span> <span class="st">&quot;-&quot;</span> <span class="op">*</span> <span class="dv">84</span>)</span>
+<span id="cb94-85"><a href="#cb94-85" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;</span><span class="sc">{</span><span class="st">&#39;n&#39;</span><span class="sc">:&gt;4}</span><span class="ss"> | </span><span class="sc">{</span><span class="st">&#39;Ungarisch&#39;</span><span class="sc">:&gt;12}</span><span class="ss"> | </span><span class="sc">{</span><span class="st">&#39;LP (kontinuierlich)&#39;</span><span class="sc">:&gt;21}</span><span class="ss"> | &quot;</span></span>
+<span id="cb94-86"><a href="#cb94-86" aria-hidden="true" tabindex="-1"></a>          <span class="ss">f&quot;</span><span class="sc">{</span><span class="st">&#39;MILP (ganzzahlig)&#39;</span><span class="sc">:&gt;19}</span><span class="ss"> | </span><span class="sc">{</span><span class="st">&#39;gleich?&#39;</span><span class="sc">:&gt;8}</span><span class="ss">&quot;</span>)</span>
+<span id="cb94-87"><a href="#cb94-87" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;-&quot;</span> <span class="op">*</span> <span class="dv">84</span>)</span>
+<span id="cb94-88"><a href="#cb94-88" aria-hidden="true" tabindex="-1"></a>    <span class="cf">for</span> n <span class="kw">in</span> [<span class="dv">10</span>, <span class="dv">25</span>, <span class="dv">50</span>, <span class="dv">100</span>]:</span>
+<span id="cb94-89"><a href="#cb94-89" aria-hidden="true" tabindex="-1"></a>        k <span class="op">=</span> erzeuge_kosten(n)</span>
+<span id="cb94-90"><a href="#cb94-90" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb94-91"><a href="#cb94-91" aria-hidden="true" tabindex="-1"></a>        t0 <span class="op">=</span> time.perf_counter()<span class="op">;</span> w1, _ <span class="op">=</span> loese_ungarisch(k)<span class="op">;</span> t1 <span class="op">=</span> time.perf_counter() <span class="op">-</span> t0</span>
+<span id="cb94-92"><a href="#cb94-92" aria-hidden="true" tabindex="-1"></a>        t0 <span class="op">=</span> time.perf_counter()<span class="op">;</span> w2, _ <span class="op">=</span> loese_lp(k, <span class="va">False</span>)<span class="op">;</span>  t2 <span class="op">=</span> time.perf_counter() <span class="op">-</span> t0</span>
+<span id="cb94-93"><a href="#cb94-93" aria-hidden="true" tabindex="-1"></a>        <span class="cf">if</span> n <span class="op">&lt;=</span> <span class="dv">50</span>:</span>
+<span id="cb94-94"><a href="#cb94-94" aria-hidden="true" tabindex="-1"></a>            t0 <span class="op">=</span> time.perf_counter()<span class="op">;</span> w3, _ <span class="op">=</span> loese_lp(k, <span class="va">True</span>)<span class="op">;</span> t3 <span class="op">=</span> time.perf_counter() <span class="op">-</span> t0</span>
+<span id="cb94-95"><a href="#cb94-95" aria-hidden="true" tabindex="-1"></a>            t3_text, gleich <span class="op">=</span> <span class="ss">f&quot;</span><span class="sc">{</span>t3<span class="op">*</span><span class="dv">1000</span><span class="sc">:&gt;16.1f}</span><span class="ss"> ms&quot;</span>, <span class="bu">abs</span>(w1 <span class="op">-</span> w3) <span class="op">&lt;</span> <span class="fl">1e-6</span></span>
+<span id="cb94-96"><a href="#cb94-96" aria-hidden="true" tabindex="-1"></a>        <span class="cf">else</span>:</span>
+<span id="cb94-97"><a href="#cb94-97" aria-hidden="true" tabindex="-1"></a>            t3_text, gleich <span class="op">=</span> <span class="ss">f&quot;</span><span class="sc">{</span><span class="st">&#39;uebersprungen&#39;</span><span class="sc">:&gt;19}</span><span class="ss">&quot;</span>, <span class="bu">abs</span>(w1 <span class="op">-</span> w2) <span class="op">&lt;</span> <span class="fl">1e-6</span></span>
+<span id="cb94-98"><a href="#cb94-98" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb94-99"><a href="#cb94-99" aria-hidden="true" tabindex="-1"></a>        <span class="bu">print</span>(<span class="ss">f&quot;</span><span class="sc">{</span>n<span class="sc">:&gt;4}</span><span class="ss"> | </span><span class="sc">{</span>t1<span class="op">*</span><span class="dv">1000</span><span class="sc">:&gt;9.1f}</span><span class="ss"> ms | </span><span class="sc">{</span>t2<span class="op">*</span><span class="dv">1000</span><span class="sc">:&gt;18.1f}</span><span class="ss"> ms | </span><span class="sc">{</span>t3_text<span class="sc">}</span><span class="ss"> | &quot;</span></span>
+<span id="cb94-100"><a href="#cb94-100" aria-hidden="true" tabindex="-1"></a>              <span class="ss">f&quot;</span><span class="sc">{</span><span class="st">&#39;ja&#39;</span> <span class="cf">if</span> gleich <span class="cf">else</span> <span class="st">&#39;NEIN&#39;</span><span class="sc">:&gt;8}</span><span class="ss">&quot;</span>)</span>
+<span id="cb94-101"><a href="#cb94-101" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb94-102"><a href="#cb94-102" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;-&quot;</span> <span class="op">*</span> <span class="dv">84</span>)</span>
+<span id="cb94-103"><a href="#cb94-103" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;Fazit: Der spezialisierte Ungarische Algorithmus ist um Groessenordnungen&quot;</span>)</span>
+<span id="cb94-104"><a href="#cb94-104" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;schneller. Nutzen Sie fuer reine Zuordnungen NIE einen MILP-Solver.&quot;</span>)</span>
+<span id="cb94-105"><a href="#cb94-105" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;=&quot;</span> <span class="op">*</span> <span class="dv">84</span>)</span></code></pre></div>
 <blockquote>
 <p><strong>💻 Code-Durchgang: die Indexakrobatik</strong></p>
 <p>Die Variable <span class="math inline">x_{ij}</span> wird zu einem flachen Vektor der Länge <span class="math inline">n^2</span> aufgerollt: Position von <span class="math inline">x_{ij}</span> ist <span class="math inline">i \cdot n + j</span>. * <code>A_eq[i, i*n:(i+1)*n] = 1</code> — Zeile <span class="math inline">i</span>: alle Aufgaben <strong>einer</strong> Person (ein zusammenhängender Block). * <code>A_eq[n+j, j::n] = 1</code> — Zeile <span class="math inline">n+j</span>: alle Personen <strong>einer</strong> Aufgabe (jedes <span class="math inline">n</span>-te Element, deshalb die Schrittweite <code>::n</code>).</p>
@@ -12456,171 +13201,171 @@ u_i - u_j + C \cdot x_{ij} \le C - d_j \qquad \forall i \ne j
 <p><strong>💡 In der Praxis: nicht selbst modellieren</strong> Die MTZ-Formulierung ist didaktisch wertvoll, aber für reale Instanzen zu schwach — die LP-Relaxation ist sehr locker, und Branch-and-Bound braucht sehr lange. Professionelle Solver verwenden stattdessen dynamisch erzeugte Subtour-Eliminationsschnitte oder, wie OR-Tools, <strong>spezialisierte Metaheuristiken</strong>. Nutzen Sie für Routing die <strong>Routing-Bibliothek</strong>, nicht ein selbstgebautes MILP.</p>
 </blockquote>
 <h3 id="praxisbeispiel-flotten-routing">Praxisbeispiel: Flotten-Routing</h3>
-<div class="sourceCode" id="cb93"><pre class="sourceCode python"><code class="sourceCode python"><span id="cb93-1"><a href="#cb93-1" aria-hidden="true" tabindex="-1"></a><span class="co">#!/usr/bin/env python3</span></span>
-<span id="cb93-2"><a href="#cb93-2" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb93-3"><a href="#cb93-3" aria-hidden="true" tabindex="-1"></a><span class="co"># VRP_Flotten_Routing.py</span></span>
-<span id="cb93-4"><a href="#cb93-4" aria-hidden="true" tabindex="-1"></a><span class="co">&quot;&quot;&quot;</span></span>
-<span id="cb93-5"><a href="#cb93-5" aria-hidden="true" tabindex="-1"></a><span class="co">Kapitel Graphen: Capacitated Vehicle Routing Problem with Time Windows (CVRPTW)</span></span>
-<span id="cb93-6"><a href="#cb93-6" aria-hidden="true" tabindex="-1"></a><span class="co">mit der Routing-Bibliothek von Google OR-Tools.</span></span>
-<span id="cb93-7"><a href="#cb93-7" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb93-8"><a href="#cb93-8" aria-hidden="true" tabindex="-1"></a><span class="co">Eigenschaften:</span></span>
-<span id="cb93-9"><a href="#cb93-9" aria-hidden="true" tabindex="-1"></a><span class="co">  * Eingabedaten werden vorab auf Plausibilitaet geprueft (Kapazitaet</span></span>
-<span id="cb93-10"><a href="#cb93-10" aria-hidden="true" tabindex="-1"></a><span class="co">    ausreichend? Zeitfenster erreichbar?)</span></span>
-<span id="cb93-11"><a href="#cb93-11" aria-hidden="true" tabindex="-1"></a><span class="co">  * Fahrzeit und Servicezeit werden getrennt ausgewiesen</span></span>
-<span id="cb93-12"><a href="#cb93-12" aria-hidden="true" tabindex="-1"></a><span class="co">  * Ausgabe als lesbarer Tourenplan mit Ankunftszeiten</span></span>
-<span id="cb93-13"><a href="#cb93-13" aria-hidden="true" tabindex="-1"></a><span class="co">  * Kennzahlen: Auslastung, Leerfahrten, Wartezeit</span></span>
-<span id="cb93-14"><a href="#cb93-14" aria-hidden="true" tabindex="-1"></a><span class="co">&quot;&quot;&quot;</span></span>
-<span id="cb93-15"><a href="#cb93-15" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb93-16"><a href="#cb93-16" aria-hidden="true" tabindex="-1"></a><span class="im">import</span> numpy <span class="im">as</span> np</span>
-<span id="cb93-17"><a href="#cb93-17" aria-hidden="true" tabindex="-1"></a><span class="im">from</span> ortools.constraint_solver <span class="im">import</span> pywrapcp, routing_enums_pb2</span>
-<span id="cb93-18"><a href="#cb93-18" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb93-19"><a href="#cb93-19" aria-hidden="true" tabindex="-1"></a>SERVICEZEIT <span class="op">=</span> <span class="dv">10</span>          <span class="co"># Minuten je Kundenstopp</span></span>
-<span id="cb93-20"><a href="#cb93-20" aria-hidden="true" tabindex="-1"></a>WARTEZEIT_MAX <span class="op">=</span> <span class="dv">60</span>        <span class="co"># zulaessige Wartezeit bei zu frueher Ankunft</span></span>
-<span id="cb93-21"><a href="#cb93-21" aria-hidden="true" tabindex="-1"></a>SCHICHTLAENGE <span class="op">=</span> <span class="dv">600</span>       <span class="co"># Minuten</span></span>
-<span id="cb93-22"><a href="#cb93-22" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb93-23"><a href="#cb93-23" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb93-24"><a href="#cb93-24" aria-hidden="true" tabindex="-1"></a><span class="kw">def</span> erzeuge_daten(seed: <span class="bu">int</span> <span class="op">=</span> <span class="dv">42</span>):</span>
-<span id="cb93-25"><a href="#cb93-25" aria-hidden="true" tabindex="-1"></a>    <span class="co">&quot;&quot;&quot;Synthetische, aber reproduzierbare Instanz: 1 Depot + 16 Kunden.&quot;&quot;&quot;</span></span>
-<span id="cb93-26"><a href="#cb93-26" aria-hidden="true" tabindex="-1"></a>    anzahl_orte <span class="op">=</span> <span class="dv">17</span></span>
-<span id="cb93-27"><a href="#cb93-27" aria-hidden="true" tabindex="-1"></a>    rng <span class="op">=</span> np.random.default_rng(seed)</span>
-<span id="cb93-28"><a href="#cb93-28" aria-hidden="true" tabindex="-1"></a>    koordinaten <span class="op">=</span> rng.random((anzahl_orte, <span class="dv">2</span>)) <span class="op">*</span> <span class="dv">100</span>      <span class="co"># 100 x 100 km Raster</span></span>
-<span id="cb93-29"><a href="#cb93-29" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb93-30"><a href="#cb93-30" aria-hidden="true" tabindex="-1"></a>    distanz <span class="op">=</span> np.zeros((anzahl_orte, anzahl_orte), dtype<span class="op">=</span><span class="bu">int</span>)</span>
-<span id="cb93-31"><a href="#cb93-31" aria-hidden="true" tabindex="-1"></a>    <span class="cf">for</span> i <span class="kw">in</span> <span class="bu">range</span>(anzahl_orte):</span>
-<span id="cb93-32"><a href="#cb93-32" aria-hidden="true" tabindex="-1"></a>        <span class="cf">for</span> j <span class="kw">in</span> <span class="bu">range</span>(anzahl_orte):</span>
-<span id="cb93-33"><a href="#cb93-33" aria-hidden="true" tabindex="-1"></a>            distanz[i][j] <span class="op">=</span> <span class="bu">int</span>(np.linalg.norm(koordinaten[i] <span class="op">-</span> koordinaten[j]))</span>
-<span id="cb93-34"><a href="#cb93-34" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb93-35"><a href="#cb93-35" aria-hidden="true" tabindex="-1"></a>    <span class="cf">return</span> {</span>
-<span id="cb93-36"><a href="#cb93-36" aria-hidden="true" tabindex="-1"></a>        <span class="st">&quot;distanzmatrix&quot;</span>: distanz.tolist(),</span>
-<span id="cb93-37"><a href="#cb93-37" aria-hidden="true" tabindex="-1"></a>        <span class="st">&quot;zeitfenster&quot;</span>: [</span>
-<span id="cb93-38"><a href="#cb93-38" aria-hidden="true" tabindex="-1"></a>            (<span class="dv">0</span>, SCHICHTLAENGE),                                   <span class="co"># 0: Depot</span></span>
-<span id="cb93-39"><a href="#cb93-39" aria-hidden="true" tabindex="-1"></a>            (<span class="dv">30</span>, <span class="dv">120</span>),  (<span class="dv">60</span>, <span class="dv">180</span>),  (<span class="dv">100</span>, <span class="dv">240</span>), (<span class="dv">150</span>, <span class="dv">300</span>),       <span class="co"># Kunden 1-4</span></span>
-<span id="cb93-40"><a href="#cb93-40" aria-hidden="true" tabindex="-1"></a>            (<span class="dv">60</span>, <span class="dv">180</span>),  (<span class="dv">120</span>, <span class="dv">240</span>), (<span class="dv">200</span>, <span class="dv">360</span>), (<span class="dv">300</span>, <span class="dv">450</span>),       <span class="co"># Kunden 5-8</span></span>
-<span id="cb93-41"><a href="#cb93-41" aria-hidden="true" tabindex="-1"></a>            (<span class="dv">180</span>, <span class="dv">300</span>), (<span class="dv">240</span>, <span class="dv">360</span>), (<span class="dv">300</span>, <span class="dv">480</span>), (<span class="dv">360</span>, <span class="dv">500</span>),       <span class="co"># Kunden 9-12</span></span>
-<span id="cb93-42"><a href="#cb93-42" aria-hidden="true" tabindex="-1"></a>            (<span class="dv">60</span>, <span class="dv">200</span>),  (<span class="dv">120</span>, <span class="dv">300</span>), (<span class="dv">240</span>, <span class="dv">400</span>), (<span class="dv">300</span>, <span class="dv">550</span>),       <span class="co"># Kunden 13-16</span></span>
-<span id="cb93-43"><a href="#cb93-43" aria-hidden="true" tabindex="-1"></a>        ],</span>
-<span id="cb93-44"><a href="#cb93-44" aria-hidden="true" tabindex="-1"></a>        <span class="st">&quot;bedarfe&quot;</span>: [<span class="dv">0</span>, <span class="dv">2</span>, <span class="dv">3</span>, <span class="dv">1</span>, <span class="dv">4</span>, <span class="dv">2</span>, <span class="dv">2</span>, <span class="dv">3</span>, <span class="dv">1</span>, <span class="dv">2</span>, <span class="dv">4</span>, <span class="dv">3</span>, <span class="dv">2</span>, <span class="dv">1</span>, <span class="dv">2</span>, <span class="dv">3</span>, <span class="dv">2</span>],</span>
-<span id="cb93-45"><a href="#cb93-45" aria-hidden="true" tabindex="-1"></a>        <span class="st">&quot;kapazitaeten&quot;</span>: [<span class="dv">10</span>, <span class="dv">10</span>, <span class="dv">10</span>, <span class="dv">10</span>],</span>
-<span id="cb93-46"><a href="#cb93-46" aria-hidden="true" tabindex="-1"></a>        <span class="st">&quot;anzahl_fahrzeuge&quot;</span>: <span class="dv">4</span>,</span>
-<span id="cb93-47"><a href="#cb93-47" aria-hidden="true" tabindex="-1"></a>        <span class="st">&quot;depot&quot;</span>: <span class="dv">0</span>,</span>
-<span id="cb93-48"><a href="#cb93-48" aria-hidden="true" tabindex="-1"></a>    }</span>
-<span id="cb93-49"><a href="#cb93-49" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb93-50"><a href="#cb93-50" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb93-51"><a href="#cb93-51" aria-hidden="true" tabindex="-1"></a><span class="kw">def</span> pruefe_daten(daten) <span class="op">-&gt;</span> <span class="va">None</span>:</span>
-<span id="cb93-52"><a href="#cb93-52" aria-hidden="true" tabindex="-1"></a>    <span class="co">&quot;&quot;&quot;Vorabdiagnose - fangt die haeufigsten Ursachen fuer &#39;keine Loesung&#39; ab.&quot;&quot;&quot;</span></span>
-<span id="cb93-53"><a href="#cb93-53" aria-hidden="true" tabindex="-1"></a>    gesamtbedarf <span class="op">=</span> <span class="bu">sum</span>(daten[<span class="st">&quot;bedarfe&quot;</span>])</span>
-<span id="cb93-54"><a href="#cb93-54" aria-hidden="true" tabindex="-1"></a>    gesamtkapazitaet <span class="op">=</span> <span class="bu">sum</span>(daten[<span class="st">&quot;kapazitaeten&quot;</span>])</span>
-<span id="cb93-55"><a href="#cb93-55" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;Gesamtbedarf </span><span class="sc">{</span>gesamtbedarf<span class="sc">}</span><span class="ss"> Einheiten | &quot;</span></span>
-<span id="cb93-56"><a href="#cb93-56" aria-hidden="true" tabindex="-1"></a>          <span class="ss">f&quot;Flottenkapazitaet </span><span class="sc">{</span>gesamtkapazitaet<span class="sc">}</span><span class="ss"> Einheiten | &quot;</span></span>
-<span id="cb93-57"><a href="#cb93-57" aria-hidden="true" tabindex="-1"></a>          <span class="ss">f&quot;Auslastung </span><span class="sc">{</span>gesamtbedarf <span class="op">/</span> gesamtkapazitaet <span class="op">*</span> <span class="dv">100</span><span class="sc">:.0f}</span><span class="ss"> %&quot;</span>)</span>
-<span id="cb93-58"><a href="#cb93-58" aria-hidden="true" tabindex="-1"></a>    <span class="cf">if</span> gesamtbedarf <span class="op">&gt;</span> gesamtkapazitaet:</span>
-<span id="cb93-59"><a href="#cb93-59" aria-hidden="true" tabindex="-1"></a>        <span class="cf">raise</span> <span class="pp">SystemExit</span>(<span class="st">&quot;UNLOESBAR: Der Bedarf uebersteigt die Flottenkapazitaet.&quot;</span>)</span>
-<span id="cb93-60"><a href="#cb93-60" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb93-61"><a href="#cb93-61" aria-hidden="true" tabindex="-1"></a>    d <span class="op">=</span> daten[<span class="st">&quot;distanzmatrix&quot;</span>]</span>
-<span id="cb93-62"><a href="#cb93-62" aria-hidden="true" tabindex="-1"></a>    <span class="cf">for</span> kunde, (fruehestens, spaetestens) <span class="kw">in</span> <span class="bu">enumerate</span>(daten[<span class="st">&quot;zeitfenster&quot;</span>]):</span>
-<span id="cb93-63"><a href="#cb93-63" aria-hidden="true" tabindex="-1"></a>        <span class="cf">if</span> kunde <span class="op">==</span> <span class="dv">0</span>:</span>
-<span id="cb93-64"><a href="#cb93-64" aria-hidden="true" tabindex="-1"></a>            <span class="cf">continue</span></span>
-<span id="cb93-65"><a href="#cb93-65" aria-hidden="true" tabindex="-1"></a>        direktfahrt <span class="op">=</span> d[<span class="dv">0</span>][kunde]</span>
-<span id="cb93-66"><a href="#cb93-66" aria-hidden="true" tabindex="-1"></a>        <span class="cf">if</span> direktfahrt <span class="op">&gt;</span> spaetestens:</span>
-<span id="cb93-67"><a href="#cb93-67" aria-hidden="true" tabindex="-1"></a>            <span class="cf">raise</span> <span class="pp">SystemExit</span>(</span>
-<span id="cb93-68"><a href="#cb93-68" aria-hidden="true" tabindex="-1"></a>                <span class="ss">f&quot;UNLOESBAR: Kunde </span><span class="sc">{</span>kunde<span class="sc">}</span><span class="ss"> ist erst nach </span><span class="sc">{</span>direktfahrt<span class="sc">}</span><span class="ss"> min erreichbar, &quot;</span></span>
-<span id="cb93-69"><a href="#cb93-69" aria-hidden="true" tabindex="-1"></a>                <span class="ss">f&quot;sein Zeitfenster endet aber bei </span><span class="sc">{</span>spaetestens<span class="sc">}</span><span class="ss"> min.&quot;</span>)</span>
-<span id="cb93-70"><a href="#cb93-70" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;Vorabpruefung bestanden: Kapazitaet und Zeitfenster sind grundsaetzlich machbar.&quot;</span>)</span>
-<span id="cb93-71"><a href="#cb93-71" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb93-72"><a href="#cb93-72" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb93-73"><a href="#cb93-73" aria-hidden="true" tabindex="-1"></a><span class="kw">def</span> loese_cvrptw(zeitlimit_s: <span class="bu">int</span> <span class="op">=</span> <span class="dv">5</span>):</span>
-<span id="cb93-74"><a href="#cb93-74" aria-hidden="true" tabindex="-1"></a>    daten <span class="op">=</span> erzeuge_daten()</span>
-<span id="cb93-75"><a href="#cb93-75" aria-hidden="true" tabindex="-1"></a>    pruefe_daten(daten)</span>
-<span id="cb93-76"><a href="#cb93-76" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb93-77"><a href="#cb93-77" aria-hidden="true" tabindex="-1"></a>    manager <span class="op">=</span> pywrapcp.RoutingIndexManager(</span>
-<span id="cb93-78"><a href="#cb93-78" aria-hidden="true" tabindex="-1"></a>        <span class="bu">len</span>(daten[<span class="st">&quot;distanzmatrix&quot;</span>]), daten[<span class="st">&quot;anzahl_fahrzeuge&quot;</span>], daten[<span class="st">&quot;depot&quot;</span>])</span>
-<span id="cb93-79"><a href="#cb93-79" aria-hidden="true" tabindex="-1"></a>    routing <span class="op">=</span> pywrapcp.RoutingModel(manager)</span>
-<span id="cb93-80"><a href="#cb93-80" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb93-81"><a href="#cb93-81" aria-hidden="true" tabindex="-1"></a>    <span class="co"># --- Fahrzeit + Servicezeit als Kantengewicht ------------------------</span></span>
-<span id="cb93-82"><a href="#cb93-82" aria-hidden="true" tabindex="-1"></a>    <span class="kw">def</span> zeit_callback(von_index, nach_index):</span>
-<span id="cb93-83"><a href="#cb93-83" aria-hidden="true" tabindex="-1"></a>        von <span class="op">=</span> manager.IndexToNode(von_index)</span>
-<span id="cb93-84"><a href="#cb93-84" aria-hidden="true" tabindex="-1"></a>        nach <span class="op">=</span> manager.IndexToNode(nach_index)</span>
-<span id="cb93-85"><a href="#cb93-85" aria-hidden="true" tabindex="-1"></a>        service <span class="op">=</span> SERVICEZEIT <span class="cf">if</span> von <span class="op">!=</span> daten[<span class="st">&quot;depot&quot;</span>] <span class="cf">else</span> <span class="dv">0</span></span>
-<span id="cb93-86"><a href="#cb93-86" aria-hidden="true" tabindex="-1"></a>        <span class="cf">return</span> daten[<span class="st">&quot;distanzmatrix&quot;</span>][von][nach] <span class="op">+</span> service</span>
-<span id="cb93-87"><a href="#cb93-87" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb93-88"><a href="#cb93-88" aria-hidden="true" tabindex="-1"></a>    zeit_index <span class="op">=</span> routing.RegisterTransitCallback(zeit_callback)</span>
-<span id="cb93-89"><a href="#cb93-89" aria-hidden="true" tabindex="-1"></a>    routing.SetArcCostEvaluatorOfAllVehicles(zeit_index)</span>
-<span id="cb93-90"><a href="#cb93-90" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb93-91"><a href="#cb93-91" aria-hidden="true" tabindex="-1"></a>    <span class="co"># --- Kapazitaetsdimension ---------------------------------------------</span></span>
-<span id="cb93-92"><a href="#cb93-92" aria-hidden="true" tabindex="-1"></a>    <span class="kw">def</span> bedarf_callback(von_index):</span>
-<span id="cb93-93"><a href="#cb93-93" aria-hidden="true" tabindex="-1"></a>        <span class="cf">return</span> daten[<span class="st">&quot;bedarfe&quot;</span>][manager.IndexToNode(von_index)]</span>
-<span id="cb93-94"><a href="#cb93-94" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb93-95"><a href="#cb93-95" aria-hidden="true" tabindex="-1"></a>    bedarf_index <span class="op">=</span> routing.RegisterUnaryTransitCallback(bedarf_callback)</span>
-<span id="cb93-96"><a href="#cb93-96" aria-hidden="true" tabindex="-1"></a>    routing.AddDimensionWithVehicleCapacity(</span>
-<span id="cb93-97"><a href="#cb93-97" aria-hidden="true" tabindex="-1"></a>        bedarf_index, <span class="dv">0</span>, daten[<span class="st">&quot;kapazitaeten&quot;</span>], <span class="va">True</span>, <span class="st">&quot;Kapazitaet&quot;</span>)</span>
-<span id="cb93-98"><a href="#cb93-98" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb93-99"><a href="#cb93-99" aria-hidden="true" tabindex="-1"></a>    <span class="co"># --- Zeitdimension mit Zeitfenstern -----------------------------------</span></span>
-<span id="cb93-100"><a href="#cb93-100" aria-hidden="true" tabindex="-1"></a>    routing.AddDimension(zeit_index, WARTEZEIT_MAX, SCHICHTLAENGE, <span class="va">False</span>, <span class="st">&quot;Zeit&quot;</span>)</span>
-<span id="cb93-101"><a href="#cb93-101" aria-hidden="true" tabindex="-1"></a>    zeit_dimension <span class="op">=</span> routing.GetDimensionOrDie(<span class="st">&quot;Zeit&quot;</span>)</span>
-<span id="cb93-102"><a href="#cb93-102" aria-hidden="true" tabindex="-1"></a>    <span class="cf">for</span> ort, (fruehestens, spaetestens) <span class="kw">in</span> <span class="bu">enumerate</span>(daten[<span class="st">&quot;zeitfenster&quot;</span>]):</span>
-<span id="cb93-103"><a href="#cb93-103" aria-hidden="true" tabindex="-1"></a>        zeit_dimension.CumulVar(manager.NodeToIndex(ort)).SetRange(fruehestens, spaetestens)</span>
-<span id="cb93-104"><a href="#cb93-104" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb93-105"><a href="#cb93-105" aria-hidden="true" tabindex="-1"></a>    <span class="co"># --- Suchparameter -----------------------------------------------------</span></span>
-<span id="cb93-106"><a href="#cb93-106" aria-hidden="true" tabindex="-1"></a>    parameter <span class="op">=</span> pywrapcp.DefaultRoutingSearchParameters()</span>
-<span id="cb93-107"><a href="#cb93-107" aria-hidden="true" tabindex="-1"></a>    parameter.first_solution_strategy <span class="op">=</span> (</span>
-<span id="cb93-108"><a href="#cb93-108" aria-hidden="true" tabindex="-1"></a>        routing_enums_pb2.FirstSolutionStrategy.PATH_CHEAPEST_ARC)</span>
-<span id="cb93-109"><a href="#cb93-109" aria-hidden="true" tabindex="-1"></a>    parameter.local_search_metaheuristic <span class="op">=</span> (</span>
-<span id="cb93-110"><a href="#cb93-110" aria-hidden="true" tabindex="-1"></a>        routing_enums_pb2.LocalSearchMetaheuristic.GUIDED_LOCAL_SEARCH)</span>
-<span id="cb93-111"><a href="#cb93-111" aria-hidden="true" tabindex="-1"></a>    parameter.time_limit.seconds <span class="op">=</span> zeitlimit_s</span>
-<span id="cb93-112"><a href="#cb93-112" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb93-113"><a href="#cb93-113" aria-hidden="true" tabindex="-1"></a>    loesung <span class="op">=</span> routing.SolveWithParameters(parameter)</span>
-<span id="cb93-114"><a href="#cb93-114" aria-hidden="true" tabindex="-1"></a>    <span class="cf">if</span> <span class="kw">not</span> loesung:</span>
-<span id="cb93-115"><a href="#cb93-115" aria-hidden="true" tabindex="-1"></a>        <span class="bu">print</span>(<span class="st">&quot;Keine zulaessige Routenfuehrung gefunden.&quot;</span>)</span>
-<span id="cb93-116"><a href="#cb93-116" aria-hidden="true" tabindex="-1"></a>        <span class="cf">return</span></span>
-<span id="cb93-117"><a href="#cb93-117" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb93-118"><a href="#cb93-118" aria-hidden="true" tabindex="-1"></a>    <span class="co"># --- Auswertung --------------------------------------------------------</span></span>
-<span id="cb93-119"><a href="#cb93-119" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;</span><span class="ch">\n</span><span class="st">&quot;</span> <span class="op">+</span> <span class="st">&quot;=&quot;</span> <span class="op">*</span> <span class="dv">84</span>)</span>
-<span id="cb93-120"><a href="#cb93-120" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;         OPTIMIERTER TOURENPLAN (CVRPTW)&quot;</span>)</span>
-<span id="cb93-121"><a href="#cb93-121" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;=&quot;</span> <span class="op">*</span> <span class="dv">84</span>)</span>
-<span id="cb93-122"><a href="#cb93-122" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb93-123"><a href="#cb93-123" aria-hidden="true" tabindex="-1"></a>    gesamtzeit <span class="op">=</span> gesamtfracht <span class="op">=</span> gesamtdistanz <span class="op">=</span> <span class="dv">0</span></span>
-<span id="cb93-124"><a href="#cb93-124" aria-hidden="true" tabindex="-1"></a>    kapazitaet <span class="op">=</span> daten[<span class="st">&quot;kapazitaeten&quot;</span>]</span>
-<span id="cb93-125"><a href="#cb93-125" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb93-126"><a href="#cb93-126" aria-hidden="true" tabindex="-1"></a>    <span class="cf">for</span> fahrzeug <span class="kw">in</span> <span class="bu">range</span>(daten[<span class="st">&quot;anzahl_fahrzeuge&quot;</span>]):</span>
-<span id="cb93-127"><a href="#cb93-127" aria-hidden="true" tabindex="-1"></a>        index <span class="op">=</span> routing.Start(fahrzeug)</span>
-<span id="cb93-128"><a href="#cb93-128" aria-hidden="true" tabindex="-1"></a>        <span class="cf">if</span> routing.IsEnd(loesung.Value(routing.NextVar(index))):</span>
-<span id="cb93-129"><a href="#cb93-129" aria-hidden="true" tabindex="-1"></a>            <span class="bu">print</span>(<span class="ss">f&quot;</span><span class="ch">\n</span><span class="ss">Fahrzeug </span><span class="sc">{</span>fahrzeug <span class="op">+</span> <span class="dv">1</span><span class="sc">}</span><span class="ss">: nicht eingesetzt&quot;</span>)</span>
-<span id="cb93-130"><a href="#cb93-130" aria-hidden="true" tabindex="-1"></a>            <span class="cf">continue</span></span>
-<span id="cb93-131"><a href="#cb93-131" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb93-132"><a href="#cb93-132" aria-hidden="true" tabindex="-1"></a>        stationen, fracht, distanz <span class="op">=</span> [], <span class="dv">0</span>, <span class="dv">0</span></span>
-<span id="cb93-133"><a href="#cb93-133" aria-hidden="true" tabindex="-1"></a>        <span class="cf">while</span> <span class="kw">not</span> routing.IsEnd(index):</span>
-<span id="cb93-134"><a href="#cb93-134" aria-hidden="true" tabindex="-1"></a>            knoten <span class="op">=</span> manager.IndexToNode(index)</span>
-<span id="cb93-135"><a href="#cb93-135" aria-hidden="true" tabindex="-1"></a>            ankunft <span class="op">=</span> loesung.Min(zeit_dimension.CumulVar(index))</span>
-<span id="cb93-136"><a href="#cb93-136" aria-hidden="true" tabindex="-1"></a>            fracht <span class="op">+=</span> daten[<span class="st">&quot;bedarfe&quot;</span>][knoten]</span>
-<span id="cb93-137"><a href="#cb93-137" aria-hidden="true" tabindex="-1"></a>            bezeichnung <span class="op">=</span> <span class="st">&quot;Depot&quot;</span> <span class="cf">if</span> knoten <span class="op">==</span> <span class="dv">0</span> <span class="cf">else</span> <span class="ss">f&quot;K</span><span class="sc">{</span>knoten<span class="sc">}</span><span class="ss">&quot;</span></span>
-<span id="cb93-138"><a href="#cb93-138" aria-hidden="true" tabindex="-1"></a>            stationen.append(<span class="ss">f&quot;</span><span class="sc">{</span>bezeichnung<span class="sc">}</span><span class="ss">@</span><span class="sc">{</span>ankunft<span class="sc">}</span><span class="ss">&quot;</span>)</span>
-<span id="cb93-139"><a href="#cb93-139" aria-hidden="true" tabindex="-1"></a>            naechster <span class="op">=</span> loesung.Value(routing.NextVar(index))</span>
-<span id="cb93-140"><a href="#cb93-140" aria-hidden="true" tabindex="-1"></a>            distanz <span class="op">+=</span> daten[<span class="st">&quot;distanzmatrix&quot;</span>][knoten][manager.IndexToNode(naechster)]</span>
-<span id="cb93-141"><a href="#cb93-141" aria-hidden="true" tabindex="-1"></a>            index <span class="op">=</span> naechster</span>
-<span id="cb93-142"><a href="#cb93-142" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb93-143"><a href="#cb93-143" aria-hidden="true" tabindex="-1"></a>        endzeit <span class="op">=</span> loesung.Min(zeit_dimension.CumulVar(index))</span>
-<span id="cb93-144"><a href="#cb93-144" aria-hidden="true" tabindex="-1"></a>        stationen.append(<span class="ss">f&quot;Depot@</span><span class="sc">{</span>endzeit<span class="sc">}</span><span class="ss">&quot;</span>)</span>
-<span id="cb93-145"><a href="#cb93-145" aria-hidden="true" tabindex="-1"></a>        gesamtzeit <span class="op">+=</span> endzeit</span>
-<span id="cb93-146"><a href="#cb93-146" aria-hidden="true" tabindex="-1"></a>        gesamtfracht <span class="op">+=</span> fracht</span>
-<span id="cb93-147"><a href="#cb93-147" aria-hidden="true" tabindex="-1"></a>        gesamtdistanz <span class="op">+=</span> distanz</span>
-<span id="cb93-148"><a href="#cb93-148" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb93-149"><a href="#cb93-149" aria-hidden="true" tabindex="-1"></a>        <span class="bu">print</span>(<span class="ss">f&quot;</span><span class="ch">\n</span><span class="ss">Fahrzeug </span><span class="sc">{</span>fahrzeug <span class="op">+</span> <span class="dv">1</span><span class="sc">}</span><span class="ss">:&quot;</span>)</span>
-<span id="cb93-150"><a href="#cb93-150" aria-hidden="true" tabindex="-1"></a>        <span class="bu">print</span>(<span class="st">&quot;  &quot;</span> <span class="op">+</span> <span class="st">&quot; -&gt; &quot;</span>.join(stationen))</span>
-<span id="cb93-151"><a href="#cb93-151" aria-hidden="true" tabindex="-1"></a>        <span class="bu">print</span>(<span class="ss">f&quot;  Schichtzeit </span><span class="sc">{</span>endzeit<span class="sc">}</span><span class="ss"> min | Fahrstrecke </span><span class="sc">{</span>distanz<span class="sc">}</span><span class="ss"> km | &quot;</span></span>
-<span id="cb93-152"><a href="#cb93-152" aria-hidden="true" tabindex="-1"></a>              <span class="ss">f&quot;Fracht </span><span class="sc">{</span>fracht<span class="sc">}</span><span class="ss">/</span><span class="sc">{</span>kapazitaet[fahrzeug]<span class="sc">}</span><span class="ss"> &quot;</span></span>
-<span id="cb93-153"><a href="#cb93-153" aria-hidden="true" tabindex="-1"></a>              <span class="ss">f&quot;(</span><span class="sc">{</span>fracht <span class="op">/</span> kapazitaet[fahrzeug] <span class="op">*</span> <span class="dv">100</span><span class="sc">:.0f}</span><span class="ss"> % Auslastung)&quot;</span>)</span>
-<span id="cb93-154"><a href="#cb93-154" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb93-155"><a href="#cb93-155" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;</span><span class="ch">\n</span><span class="st">&quot;</span> <span class="op">+</span> <span class="st">&quot;-&quot;</span> <span class="op">*</span> <span class="dv">84</span>)</span>
-<span id="cb93-156"><a href="#cb93-156" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;Summe Schichtzeiten:   </span><span class="sc">{</span>gesamtzeit<span class="sc">}</span><span class="ss"> min&quot;</span>)</span>
-<span id="cb93-157"><a href="#cb93-157" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;Summe Fahrstrecken:    </span><span class="sc">{</span>gesamtdistanz<span class="sc">}</span><span class="ss"> km&quot;</span>)</span>
-<span id="cb93-158"><a href="#cb93-158" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;Transportierte Fracht: </span><span class="sc">{</span>gesamtfracht<span class="sc">}</span><span class="ss"> von </span><span class="sc">{</span><span class="bu">sum</span>(daten[<span class="st">&#39;bedarfe&#39;</span>])<span class="sc">}</span><span class="ss"> Einheiten&quot;</span>)</span>
-<span id="cb93-159"><a href="#cb93-159" aria-hidden="true" tabindex="-1"></a>    <span class="cf">assert</span> gesamtfracht <span class="op">==</span> <span class="bu">sum</span>(daten[<span class="st">&quot;bedarfe&quot;</span>]), <span class="st">&quot;Nicht alle Kunden wurden beliefert!&quot;</span></span>
-<span id="cb93-160"><a href="#cb93-160" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;Alle Kunden wurden innerhalb ihrer Zeitfenster beliefert.&quot;</span>)</span>
-<span id="cb93-161"><a href="#cb93-161" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;=&quot;</span> <span class="op">*</span> <span class="dv">84</span>)</span>
-<span id="cb93-162"><a href="#cb93-162" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb93-163"><a href="#cb93-163" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb93-164"><a href="#cb93-164" aria-hidden="true" tabindex="-1"></a><span class="cf">if</span> <span class="va">__name__</span> <span class="op">==</span> <span class="st">&quot;__main__&quot;</span>:</span>
-<span id="cb93-165"><a href="#cb93-165" aria-hidden="true" tabindex="-1"></a>    loese_cvrptw()</span></code></pre></div>
+<div class="sourceCode" id="cb95"><pre class="sourceCode python"><code class="sourceCode python"><span id="cb95-1"><a href="#cb95-1" aria-hidden="true" tabindex="-1"></a><span class="co">#!/usr/bin/env python3</span></span>
+<span id="cb95-2"><a href="#cb95-2" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb95-3"><a href="#cb95-3" aria-hidden="true" tabindex="-1"></a><span class="co"># VRP_Flotten_Routing.py</span></span>
+<span id="cb95-4"><a href="#cb95-4" aria-hidden="true" tabindex="-1"></a><span class="co">&quot;&quot;&quot;</span></span>
+<span id="cb95-5"><a href="#cb95-5" aria-hidden="true" tabindex="-1"></a><span class="co">Kapitel Graphen: Capacitated Vehicle Routing Problem with Time Windows (CVRPTW)</span></span>
+<span id="cb95-6"><a href="#cb95-6" aria-hidden="true" tabindex="-1"></a><span class="co">mit der Routing-Bibliothek von Google OR-Tools.</span></span>
+<span id="cb95-7"><a href="#cb95-7" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb95-8"><a href="#cb95-8" aria-hidden="true" tabindex="-1"></a><span class="co">Eigenschaften:</span></span>
+<span id="cb95-9"><a href="#cb95-9" aria-hidden="true" tabindex="-1"></a><span class="co">  * Eingabedaten werden vorab auf Plausibilitaet geprueft (Kapazitaet</span></span>
+<span id="cb95-10"><a href="#cb95-10" aria-hidden="true" tabindex="-1"></a><span class="co">    ausreichend? Zeitfenster erreichbar?)</span></span>
+<span id="cb95-11"><a href="#cb95-11" aria-hidden="true" tabindex="-1"></a><span class="co">  * Fahrzeit und Servicezeit werden getrennt ausgewiesen</span></span>
+<span id="cb95-12"><a href="#cb95-12" aria-hidden="true" tabindex="-1"></a><span class="co">  * Ausgabe als lesbarer Tourenplan mit Ankunftszeiten</span></span>
+<span id="cb95-13"><a href="#cb95-13" aria-hidden="true" tabindex="-1"></a><span class="co">  * Kennzahlen: Auslastung, Leerfahrten, Wartezeit</span></span>
+<span id="cb95-14"><a href="#cb95-14" aria-hidden="true" tabindex="-1"></a><span class="co">&quot;&quot;&quot;</span></span>
+<span id="cb95-15"><a href="#cb95-15" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb95-16"><a href="#cb95-16" aria-hidden="true" tabindex="-1"></a><span class="im">import</span> numpy <span class="im">as</span> np</span>
+<span id="cb95-17"><a href="#cb95-17" aria-hidden="true" tabindex="-1"></a><span class="im">from</span> ortools.constraint_solver <span class="im">import</span> pywrapcp, routing_enums_pb2</span>
+<span id="cb95-18"><a href="#cb95-18" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb95-19"><a href="#cb95-19" aria-hidden="true" tabindex="-1"></a>SERVICEZEIT <span class="op">=</span> <span class="dv">10</span>          <span class="co"># Minuten je Kundenstopp</span></span>
+<span id="cb95-20"><a href="#cb95-20" aria-hidden="true" tabindex="-1"></a>WARTEZEIT_MAX <span class="op">=</span> <span class="dv">60</span>        <span class="co"># zulaessige Wartezeit bei zu frueher Ankunft</span></span>
+<span id="cb95-21"><a href="#cb95-21" aria-hidden="true" tabindex="-1"></a>SCHICHTLAENGE <span class="op">=</span> <span class="dv">600</span>       <span class="co"># Minuten</span></span>
+<span id="cb95-22"><a href="#cb95-22" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb95-23"><a href="#cb95-23" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb95-24"><a href="#cb95-24" aria-hidden="true" tabindex="-1"></a><span class="kw">def</span> erzeuge_daten(seed: <span class="bu">int</span> <span class="op">=</span> <span class="dv">42</span>):</span>
+<span id="cb95-25"><a href="#cb95-25" aria-hidden="true" tabindex="-1"></a>    <span class="co">&quot;&quot;&quot;Synthetische, aber reproduzierbare Instanz: 1 Depot + 16 Kunden.&quot;&quot;&quot;</span></span>
+<span id="cb95-26"><a href="#cb95-26" aria-hidden="true" tabindex="-1"></a>    anzahl_orte <span class="op">=</span> <span class="dv">17</span></span>
+<span id="cb95-27"><a href="#cb95-27" aria-hidden="true" tabindex="-1"></a>    rng <span class="op">=</span> np.random.default_rng(seed)</span>
+<span id="cb95-28"><a href="#cb95-28" aria-hidden="true" tabindex="-1"></a>    koordinaten <span class="op">=</span> rng.random((anzahl_orte, <span class="dv">2</span>)) <span class="op">*</span> <span class="dv">100</span>      <span class="co"># 100 x 100 km Raster</span></span>
+<span id="cb95-29"><a href="#cb95-29" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb95-30"><a href="#cb95-30" aria-hidden="true" tabindex="-1"></a>    distanz <span class="op">=</span> np.zeros((anzahl_orte, anzahl_orte), dtype<span class="op">=</span><span class="bu">int</span>)</span>
+<span id="cb95-31"><a href="#cb95-31" aria-hidden="true" tabindex="-1"></a>    <span class="cf">for</span> i <span class="kw">in</span> <span class="bu">range</span>(anzahl_orte):</span>
+<span id="cb95-32"><a href="#cb95-32" aria-hidden="true" tabindex="-1"></a>        <span class="cf">for</span> j <span class="kw">in</span> <span class="bu">range</span>(anzahl_orte):</span>
+<span id="cb95-33"><a href="#cb95-33" aria-hidden="true" tabindex="-1"></a>            distanz[i][j] <span class="op">=</span> <span class="bu">int</span>(np.linalg.norm(koordinaten[i] <span class="op">-</span> koordinaten[j]))</span>
+<span id="cb95-34"><a href="#cb95-34" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb95-35"><a href="#cb95-35" aria-hidden="true" tabindex="-1"></a>    <span class="cf">return</span> {</span>
+<span id="cb95-36"><a href="#cb95-36" aria-hidden="true" tabindex="-1"></a>        <span class="st">&quot;distanzmatrix&quot;</span>: distanz.tolist(),</span>
+<span id="cb95-37"><a href="#cb95-37" aria-hidden="true" tabindex="-1"></a>        <span class="st">&quot;zeitfenster&quot;</span>: [</span>
+<span id="cb95-38"><a href="#cb95-38" aria-hidden="true" tabindex="-1"></a>            (<span class="dv">0</span>, SCHICHTLAENGE),                                   <span class="co"># 0: Depot</span></span>
+<span id="cb95-39"><a href="#cb95-39" aria-hidden="true" tabindex="-1"></a>            (<span class="dv">30</span>, <span class="dv">120</span>),  (<span class="dv">60</span>, <span class="dv">180</span>),  (<span class="dv">100</span>, <span class="dv">240</span>), (<span class="dv">150</span>, <span class="dv">300</span>),       <span class="co"># Kunden 1-4</span></span>
+<span id="cb95-40"><a href="#cb95-40" aria-hidden="true" tabindex="-1"></a>            (<span class="dv">60</span>, <span class="dv">180</span>),  (<span class="dv">120</span>, <span class="dv">240</span>), (<span class="dv">200</span>, <span class="dv">360</span>), (<span class="dv">300</span>, <span class="dv">450</span>),       <span class="co"># Kunden 5-8</span></span>
+<span id="cb95-41"><a href="#cb95-41" aria-hidden="true" tabindex="-1"></a>            (<span class="dv">180</span>, <span class="dv">300</span>), (<span class="dv">240</span>, <span class="dv">360</span>), (<span class="dv">300</span>, <span class="dv">480</span>), (<span class="dv">360</span>, <span class="dv">500</span>),       <span class="co"># Kunden 9-12</span></span>
+<span id="cb95-42"><a href="#cb95-42" aria-hidden="true" tabindex="-1"></a>            (<span class="dv">60</span>, <span class="dv">200</span>),  (<span class="dv">120</span>, <span class="dv">300</span>), (<span class="dv">240</span>, <span class="dv">400</span>), (<span class="dv">300</span>, <span class="dv">550</span>),       <span class="co"># Kunden 13-16</span></span>
+<span id="cb95-43"><a href="#cb95-43" aria-hidden="true" tabindex="-1"></a>        ],</span>
+<span id="cb95-44"><a href="#cb95-44" aria-hidden="true" tabindex="-1"></a>        <span class="st">&quot;bedarfe&quot;</span>: [<span class="dv">0</span>, <span class="dv">2</span>, <span class="dv">3</span>, <span class="dv">1</span>, <span class="dv">4</span>, <span class="dv">2</span>, <span class="dv">2</span>, <span class="dv">3</span>, <span class="dv">1</span>, <span class="dv">2</span>, <span class="dv">4</span>, <span class="dv">3</span>, <span class="dv">2</span>, <span class="dv">1</span>, <span class="dv">2</span>, <span class="dv">3</span>, <span class="dv">2</span>],</span>
+<span id="cb95-45"><a href="#cb95-45" aria-hidden="true" tabindex="-1"></a>        <span class="st">&quot;kapazitaeten&quot;</span>: [<span class="dv">10</span>, <span class="dv">10</span>, <span class="dv">10</span>, <span class="dv">10</span>],</span>
+<span id="cb95-46"><a href="#cb95-46" aria-hidden="true" tabindex="-1"></a>        <span class="st">&quot;anzahl_fahrzeuge&quot;</span>: <span class="dv">4</span>,</span>
+<span id="cb95-47"><a href="#cb95-47" aria-hidden="true" tabindex="-1"></a>        <span class="st">&quot;depot&quot;</span>: <span class="dv">0</span>,</span>
+<span id="cb95-48"><a href="#cb95-48" aria-hidden="true" tabindex="-1"></a>    }</span>
+<span id="cb95-49"><a href="#cb95-49" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb95-50"><a href="#cb95-50" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb95-51"><a href="#cb95-51" aria-hidden="true" tabindex="-1"></a><span class="kw">def</span> pruefe_daten(daten) <span class="op">-&gt;</span> <span class="va">None</span>:</span>
+<span id="cb95-52"><a href="#cb95-52" aria-hidden="true" tabindex="-1"></a>    <span class="co">&quot;&quot;&quot;Vorabdiagnose - fangt die haeufigsten Ursachen fuer &#39;keine Loesung&#39; ab.&quot;&quot;&quot;</span></span>
+<span id="cb95-53"><a href="#cb95-53" aria-hidden="true" tabindex="-1"></a>    gesamtbedarf <span class="op">=</span> <span class="bu">sum</span>(daten[<span class="st">&quot;bedarfe&quot;</span>])</span>
+<span id="cb95-54"><a href="#cb95-54" aria-hidden="true" tabindex="-1"></a>    gesamtkapazitaet <span class="op">=</span> <span class="bu">sum</span>(daten[<span class="st">&quot;kapazitaeten&quot;</span>])</span>
+<span id="cb95-55"><a href="#cb95-55" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;Gesamtbedarf </span><span class="sc">{</span>gesamtbedarf<span class="sc">}</span><span class="ss"> Einheiten | &quot;</span></span>
+<span id="cb95-56"><a href="#cb95-56" aria-hidden="true" tabindex="-1"></a>          <span class="ss">f&quot;Flottenkapazitaet </span><span class="sc">{</span>gesamtkapazitaet<span class="sc">}</span><span class="ss"> Einheiten | &quot;</span></span>
+<span id="cb95-57"><a href="#cb95-57" aria-hidden="true" tabindex="-1"></a>          <span class="ss">f&quot;Auslastung </span><span class="sc">{</span>gesamtbedarf <span class="op">/</span> gesamtkapazitaet <span class="op">*</span> <span class="dv">100</span><span class="sc">:.0f}</span><span class="ss"> %&quot;</span>)</span>
+<span id="cb95-58"><a href="#cb95-58" aria-hidden="true" tabindex="-1"></a>    <span class="cf">if</span> gesamtbedarf <span class="op">&gt;</span> gesamtkapazitaet:</span>
+<span id="cb95-59"><a href="#cb95-59" aria-hidden="true" tabindex="-1"></a>        <span class="cf">raise</span> <span class="pp">SystemExit</span>(<span class="st">&quot;UNLOESBAR: Der Bedarf uebersteigt die Flottenkapazitaet.&quot;</span>)</span>
+<span id="cb95-60"><a href="#cb95-60" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb95-61"><a href="#cb95-61" aria-hidden="true" tabindex="-1"></a>    d <span class="op">=</span> daten[<span class="st">&quot;distanzmatrix&quot;</span>]</span>
+<span id="cb95-62"><a href="#cb95-62" aria-hidden="true" tabindex="-1"></a>    <span class="cf">for</span> kunde, (fruehestens, spaetestens) <span class="kw">in</span> <span class="bu">enumerate</span>(daten[<span class="st">&quot;zeitfenster&quot;</span>]):</span>
+<span id="cb95-63"><a href="#cb95-63" aria-hidden="true" tabindex="-1"></a>        <span class="cf">if</span> kunde <span class="op">==</span> <span class="dv">0</span>:</span>
+<span id="cb95-64"><a href="#cb95-64" aria-hidden="true" tabindex="-1"></a>            <span class="cf">continue</span></span>
+<span id="cb95-65"><a href="#cb95-65" aria-hidden="true" tabindex="-1"></a>        direktfahrt <span class="op">=</span> d[<span class="dv">0</span>][kunde]</span>
+<span id="cb95-66"><a href="#cb95-66" aria-hidden="true" tabindex="-1"></a>        <span class="cf">if</span> direktfahrt <span class="op">&gt;</span> spaetestens:</span>
+<span id="cb95-67"><a href="#cb95-67" aria-hidden="true" tabindex="-1"></a>            <span class="cf">raise</span> <span class="pp">SystemExit</span>(</span>
+<span id="cb95-68"><a href="#cb95-68" aria-hidden="true" tabindex="-1"></a>                <span class="ss">f&quot;UNLOESBAR: Kunde </span><span class="sc">{</span>kunde<span class="sc">}</span><span class="ss"> ist erst nach </span><span class="sc">{</span>direktfahrt<span class="sc">}</span><span class="ss"> min erreichbar, &quot;</span></span>
+<span id="cb95-69"><a href="#cb95-69" aria-hidden="true" tabindex="-1"></a>                <span class="ss">f&quot;sein Zeitfenster endet aber bei </span><span class="sc">{</span>spaetestens<span class="sc">}</span><span class="ss"> min.&quot;</span>)</span>
+<span id="cb95-70"><a href="#cb95-70" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;Vorabpruefung bestanden: Kapazitaet und Zeitfenster sind grundsaetzlich machbar.&quot;</span>)</span>
+<span id="cb95-71"><a href="#cb95-71" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb95-72"><a href="#cb95-72" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb95-73"><a href="#cb95-73" aria-hidden="true" tabindex="-1"></a><span class="kw">def</span> loese_cvrptw(zeitlimit_s: <span class="bu">int</span> <span class="op">=</span> <span class="dv">5</span>):</span>
+<span id="cb95-74"><a href="#cb95-74" aria-hidden="true" tabindex="-1"></a>    daten <span class="op">=</span> erzeuge_daten()</span>
+<span id="cb95-75"><a href="#cb95-75" aria-hidden="true" tabindex="-1"></a>    pruefe_daten(daten)</span>
+<span id="cb95-76"><a href="#cb95-76" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb95-77"><a href="#cb95-77" aria-hidden="true" tabindex="-1"></a>    manager <span class="op">=</span> pywrapcp.RoutingIndexManager(</span>
+<span id="cb95-78"><a href="#cb95-78" aria-hidden="true" tabindex="-1"></a>        <span class="bu">len</span>(daten[<span class="st">&quot;distanzmatrix&quot;</span>]), daten[<span class="st">&quot;anzahl_fahrzeuge&quot;</span>], daten[<span class="st">&quot;depot&quot;</span>])</span>
+<span id="cb95-79"><a href="#cb95-79" aria-hidden="true" tabindex="-1"></a>    routing <span class="op">=</span> pywrapcp.RoutingModel(manager)</span>
+<span id="cb95-80"><a href="#cb95-80" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb95-81"><a href="#cb95-81" aria-hidden="true" tabindex="-1"></a>    <span class="co"># --- Fahrzeit + Servicezeit als Kantengewicht ------------------------</span></span>
+<span id="cb95-82"><a href="#cb95-82" aria-hidden="true" tabindex="-1"></a>    <span class="kw">def</span> zeit_callback(von_index, nach_index):</span>
+<span id="cb95-83"><a href="#cb95-83" aria-hidden="true" tabindex="-1"></a>        von <span class="op">=</span> manager.IndexToNode(von_index)</span>
+<span id="cb95-84"><a href="#cb95-84" aria-hidden="true" tabindex="-1"></a>        nach <span class="op">=</span> manager.IndexToNode(nach_index)</span>
+<span id="cb95-85"><a href="#cb95-85" aria-hidden="true" tabindex="-1"></a>        service <span class="op">=</span> SERVICEZEIT <span class="cf">if</span> von <span class="op">!=</span> daten[<span class="st">&quot;depot&quot;</span>] <span class="cf">else</span> <span class="dv">0</span></span>
+<span id="cb95-86"><a href="#cb95-86" aria-hidden="true" tabindex="-1"></a>        <span class="cf">return</span> daten[<span class="st">&quot;distanzmatrix&quot;</span>][von][nach] <span class="op">+</span> service</span>
+<span id="cb95-87"><a href="#cb95-87" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb95-88"><a href="#cb95-88" aria-hidden="true" tabindex="-1"></a>    zeit_index <span class="op">=</span> routing.RegisterTransitCallback(zeit_callback)</span>
+<span id="cb95-89"><a href="#cb95-89" aria-hidden="true" tabindex="-1"></a>    routing.SetArcCostEvaluatorOfAllVehicles(zeit_index)</span>
+<span id="cb95-90"><a href="#cb95-90" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb95-91"><a href="#cb95-91" aria-hidden="true" tabindex="-1"></a>    <span class="co"># --- Kapazitaetsdimension ---------------------------------------------</span></span>
+<span id="cb95-92"><a href="#cb95-92" aria-hidden="true" tabindex="-1"></a>    <span class="kw">def</span> bedarf_callback(von_index):</span>
+<span id="cb95-93"><a href="#cb95-93" aria-hidden="true" tabindex="-1"></a>        <span class="cf">return</span> daten[<span class="st">&quot;bedarfe&quot;</span>][manager.IndexToNode(von_index)]</span>
+<span id="cb95-94"><a href="#cb95-94" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb95-95"><a href="#cb95-95" aria-hidden="true" tabindex="-1"></a>    bedarf_index <span class="op">=</span> routing.RegisterUnaryTransitCallback(bedarf_callback)</span>
+<span id="cb95-96"><a href="#cb95-96" aria-hidden="true" tabindex="-1"></a>    routing.AddDimensionWithVehicleCapacity(</span>
+<span id="cb95-97"><a href="#cb95-97" aria-hidden="true" tabindex="-1"></a>        bedarf_index, <span class="dv">0</span>, daten[<span class="st">&quot;kapazitaeten&quot;</span>], <span class="va">True</span>, <span class="st">&quot;Kapazitaet&quot;</span>)</span>
+<span id="cb95-98"><a href="#cb95-98" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb95-99"><a href="#cb95-99" aria-hidden="true" tabindex="-1"></a>    <span class="co"># --- Zeitdimension mit Zeitfenstern -----------------------------------</span></span>
+<span id="cb95-100"><a href="#cb95-100" aria-hidden="true" tabindex="-1"></a>    routing.AddDimension(zeit_index, WARTEZEIT_MAX, SCHICHTLAENGE, <span class="va">False</span>, <span class="st">&quot;Zeit&quot;</span>)</span>
+<span id="cb95-101"><a href="#cb95-101" aria-hidden="true" tabindex="-1"></a>    zeit_dimension <span class="op">=</span> routing.GetDimensionOrDie(<span class="st">&quot;Zeit&quot;</span>)</span>
+<span id="cb95-102"><a href="#cb95-102" aria-hidden="true" tabindex="-1"></a>    <span class="cf">for</span> ort, (fruehestens, spaetestens) <span class="kw">in</span> <span class="bu">enumerate</span>(daten[<span class="st">&quot;zeitfenster&quot;</span>]):</span>
+<span id="cb95-103"><a href="#cb95-103" aria-hidden="true" tabindex="-1"></a>        zeit_dimension.CumulVar(manager.NodeToIndex(ort)).SetRange(fruehestens, spaetestens)</span>
+<span id="cb95-104"><a href="#cb95-104" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb95-105"><a href="#cb95-105" aria-hidden="true" tabindex="-1"></a>    <span class="co"># --- Suchparameter -----------------------------------------------------</span></span>
+<span id="cb95-106"><a href="#cb95-106" aria-hidden="true" tabindex="-1"></a>    parameter <span class="op">=</span> pywrapcp.DefaultRoutingSearchParameters()</span>
+<span id="cb95-107"><a href="#cb95-107" aria-hidden="true" tabindex="-1"></a>    parameter.first_solution_strategy <span class="op">=</span> (</span>
+<span id="cb95-108"><a href="#cb95-108" aria-hidden="true" tabindex="-1"></a>        routing_enums_pb2.FirstSolutionStrategy.PATH_CHEAPEST_ARC)</span>
+<span id="cb95-109"><a href="#cb95-109" aria-hidden="true" tabindex="-1"></a>    parameter.local_search_metaheuristic <span class="op">=</span> (</span>
+<span id="cb95-110"><a href="#cb95-110" aria-hidden="true" tabindex="-1"></a>        routing_enums_pb2.LocalSearchMetaheuristic.GUIDED_LOCAL_SEARCH)</span>
+<span id="cb95-111"><a href="#cb95-111" aria-hidden="true" tabindex="-1"></a>    parameter.time_limit.seconds <span class="op">=</span> zeitlimit_s</span>
+<span id="cb95-112"><a href="#cb95-112" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb95-113"><a href="#cb95-113" aria-hidden="true" tabindex="-1"></a>    loesung <span class="op">=</span> routing.SolveWithParameters(parameter)</span>
+<span id="cb95-114"><a href="#cb95-114" aria-hidden="true" tabindex="-1"></a>    <span class="cf">if</span> <span class="kw">not</span> loesung:</span>
+<span id="cb95-115"><a href="#cb95-115" aria-hidden="true" tabindex="-1"></a>        <span class="bu">print</span>(<span class="st">&quot;Keine zulaessige Routenfuehrung gefunden.&quot;</span>)</span>
+<span id="cb95-116"><a href="#cb95-116" aria-hidden="true" tabindex="-1"></a>        <span class="cf">return</span></span>
+<span id="cb95-117"><a href="#cb95-117" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb95-118"><a href="#cb95-118" aria-hidden="true" tabindex="-1"></a>    <span class="co"># --- Auswertung --------------------------------------------------------</span></span>
+<span id="cb95-119"><a href="#cb95-119" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;</span><span class="ch">\n</span><span class="st">&quot;</span> <span class="op">+</span> <span class="st">&quot;=&quot;</span> <span class="op">*</span> <span class="dv">84</span>)</span>
+<span id="cb95-120"><a href="#cb95-120" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;         OPTIMIERTER TOURENPLAN (CVRPTW)&quot;</span>)</span>
+<span id="cb95-121"><a href="#cb95-121" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;=&quot;</span> <span class="op">*</span> <span class="dv">84</span>)</span>
+<span id="cb95-122"><a href="#cb95-122" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb95-123"><a href="#cb95-123" aria-hidden="true" tabindex="-1"></a>    gesamtzeit <span class="op">=</span> gesamtfracht <span class="op">=</span> gesamtdistanz <span class="op">=</span> <span class="dv">0</span></span>
+<span id="cb95-124"><a href="#cb95-124" aria-hidden="true" tabindex="-1"></a>    kapazitaet <span class="op">=</span> daten[<span class="st">&quot;kapazitaeten&quot;</span>]</span>
+<span id="cb95-125"><a href="#cb95-125" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb95-126"><a href="#cb95-126" aria-hidden="true" tabindex="-1"></a>    <span class="cf">for</span> fahrzeug <span class="kw">in</span> <span class="bu">range</span>(daten[<span class="st">&quot;anzahl_fahrzeuge&quot;</span>]):</span>
+<span id="cb95-127"><a href="#cb95-127" aria-hidden="true" tabindex="-1"></a>        index <span class="op">=</span> routing.Start(fahrzeug)</span>
+<span id="cb95-128"><a href="#cb95-128" aria-hidden="true" tabindex="-1"></a>        <span class="cf">if</span> routing.IsEnd(loesung.Value(routing.NextVar(index))):</span>
+<span id="cb95-129"><a href="#cb95-129" aria-hidden="true" tabindex="-1"></a>            <span class="bu">print</span>(<span class="ss">f&quot;</span><span class="ch">\n</span><span class="ss">Fahrzeug </span><span class="sc">{</span>fahrzeug <span class="op">+</span> <span class="dv">1</span><span class="sc">}</span><span class="ss">: nicht eingesetzt&quot;</span>)</span>
+<span id="cb95-130"><a href="#cb95-130" aria-hidden="true" tabindex="-1"></a>            <span class="cf">continue</span></span>
+<span id="cb95-131"><a href="#cb95-131" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb95-132"><a href="#cb95-132" aria-hidden="true" tabindex="-1"></a>        stationen, fracht, distanz <span class="op">=</span> [], <span class="dv">0</span>, <span class="dv">0</span></span>
+<span id="cb95-133"><a href="#cb95-133" aria-hidden="true" tabindex="-1"></a>        <span class="cf">while</span> <span class="kw">not</span> routing.IsEnd(index):</span>
+<span id="cb95-134"><a href="#cb95-134" aria-hidden="true" tabindex="-1"></a>            knoten <span class="op">=</span> manager.IndexToNode(index)</span>
+<span id="cb95-135"><a href="#cb95-135" aria-hidden="true" tabindex="-1"></a>            ankunft <span class="op">=</span> loesung.Min(zeit_dimension.CumulVar(index))</span>
+<span id="cb95-136"><a href="#cb95-136" aria-hidden="true" tabindex="-1"></a>            fracht <span class="op">+=</span> daten[<span class="st">&quot;bedarfe&quot;</span>][knoten]</span>
+<span id="cb95-137"><a href="#cb95-137" aria-hidden="true" tabindex="-1"></a>            bezeichnung <span class="op">=</span> <span class="st">&quot;Depot&quot;</span> <span class="cf">if</span> knoten <span class="op">==</span> <span class="dv">0</span> <span class="cf">else</span> <span class="ss">f&quot;K</span><span class="sc">{</span>knoten<span class="sc">}</span><span class="ss">&quot;</span></span>
+<span id="cb95-138"><a href="#cb95-138" aria-hidden="true" tabindex="-1"></a>            stationen.append(<span class="ss">f&quot;</span><span class="sc">{</span>bezeichnung<span class="sc">}</span><span class="ss">@</span><span class="sc">{</span>ankunft<span class="sc">}</span><span class="ss">&quot;</span>)</span>
+<span id="cb95-139"><a href="#cb95-139" aria-hidden="true" tabindex="-1"></a>            naechster <span class="op">=</span> loesung.Value(routing.NextVar(index))</span>
+<span id="cb95-140"><a href="#cb95-140" aria-hidden="true" tabindex="-1"></a>            distanz <span class="op">+=</span> daten[<span class="st">&quot;distanzmatrix&quot;</span>][knoten][manager.IndexToNode(naechster)]</span>
+<span id="cb95-141"><a href="#cb95-141" aria-hidden="true" tabindex="-1"></a>            index <span class="op">=</span> naechster</span>
+<span id="cb95-142"><a href="#cb95-142" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb95-143"><a href="#cb95-143" aria-hidden="true" tabindex="-1"></a>        endzeit <span class="op">=</span> loesung.Min(zeit_dimension.CumulVar(index))</span>
+<span id="cb95-144"><a href="#cb95-144" aria-hidden="true" tabindex="-1"></a>        stationen.append(<span class="ss">f&quot;Depot@</span><span class="sc">{</span>endzeit<span class="sc">}</span><span class="ss">&quot;</span>)</span>
+<span id="cb95-145"><a href="#cb95-145" aria-hidden="true" tabindex="-1"></a>        gesamtzeit <span class="op">+=</span> endzeit</span>
+<span id="cb95-146"><a href="#cb95-146" aria-hidden="true" tabindex="-1"></a>        gesamtfracht <span class="op">+=</span> fracht</span>
+<span id="cb95-147"><a href="#cb95-147" aria-hidden="true" tabindex="-1"></a>        gesamtdistanz <span class="op">+=</span> distanz</span>
+<span id="cb95-148"><a href="#cb95-148" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb95-149"><a href="#cb95-149" aria-hidden="true" tabindex="-1"></a>        <span class="bu">print</span>(<span class="ss">f&quot;</span><span class="ch">\n</span><span class="ss">Fahrzeug </span><span class="sc">{</span>fahrzeug <span class="op">+</span> <span class="dv">1</span><span class="sc">}</span><span class="ss">:&quot;</span>)</span>
+<span id="cb95-150"><a href="#cb95-150" aria-hidden="true" tabindex="-1"></a>        <span class="bu">print</span>(<span class="st">&quot;  &quot;</span> <span class="op">+</span> <span class="st">&quot; -&gt; &quot;</span>.join(stationen))</span>
+<span id="cb95-151"><a href="#cb95-151" aria-hidden="true" tabindex="-1"></a>        <span class="bu">print</span>(<span class="ss">f&quot;  Schichtzeit </span><span class="sc">{</span>endzeit<span class="sc">}</span><span class="ss"> min | Fahrstrecke </span><span class="sc">{</span>distanz<span class="sc">}</span><span class="ss"> km | &quot;</span></span>
+<span id="cb95-152"><a href="#cb95-152" aria-hidden="true" tabindex="-1"></a>              <span class="ss">f&quot;Fracht </span><span class="sc">{</span>fracht<span class="sc">}</span><span class="ss">/</span><span class="sc">{</span>kapazitaet[fahrzeug]<span class="sc">}</span><span class="ss"> &quot;</span></span>
+<span id="cb95-153"><a href="#cb95-153" aria-hidden="true" tabindex="-1"></a>              <span class="ss">f&quot;(</span><span class="sc">{</span>fracht <span class="op">/</span> kapazitaet[fahrzeug] <span class="op">*</span> <span class="dv">100</span><span class="sc">:.0f}</span><span class="ss"> % Auslastung)&quot;</span>)</span>
+<span id="cb95-154"><a href="#cb95-154" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb95-155"><a href="#cb95-155" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;</span><span class="ch">\n</span><span class="st">&quot;</span> <span class="op">+</span> <span class="st">&quot;-&quot;</span> <span class="op">*</span> <span class="dv">84</span>)</span>
+<span id="cb95-156"><a href="#cb95-156" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;Summe Schichtzeiten:   </span><span class="sc">{</span>gesamtzeit<span class="sc">}</span><span class="ss"> min&quot;</span>)</span>
+<span id="cb95-157"><a href="#cb95-157" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;Summe Fahrstrecken:    </span><span class="sc">{</span>gesamtdistanz<span class="sc">}</span><span class="ss"> km&quot;</span>)</span>
+<span id="cb95-158"><a href="#cb95-158" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;Transportierte Fracht: </span><span class="sc">{</span>gesamtfracht<span class="sc">}</span><span class="ss"> von </span><span class="sc">{</span><span class="bu">sum</span>(daten[<span class="st">&#39;bedarfe&#39;</span>])<span class="sc">}</span><span class="ss"> Einheiten&quot;</span>)</span>
+<span id="cb95-159"><a href="#cb95-159" aria-hidden="true" tabindex="-1"></a>    <span class="cf">assert</span> gesamtfracht <span class="op">==</span> <span class="bu">sum</span>(daten[<span class="st">&quot;bedarfe&quot;</span>]), <span class="st">&quot;Nicht alle Kunden wurden beliefert!&quot;</span></span>
+<span id="cb95-160"><a href="#cb95-160" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;Alle Kunden wurden innerhalb ihrer Zeitfenster beliefert.&quot;</span>)</span>
+<span id="cb95-161"><a href="#cb95-161" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;=&quot;</span> <span class="op">*</span> <span class="dv">84</span>)</span>
+<span id="cb95-162"><a href="#cb95-162" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb95-163"><a href="#cb95-163" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb95-164"><a href="#cb95-164" aria-hidden="true" tabindex="-1"></a><span class="cf">if</span> <span class="va">__name__</span> <span class="op">==</span> <span class="st">&quot;__main__&quot;</span>:</span>
+<span id="cb95-165"><a href="#cb95-165" aria-hidden="true" tabindex="-1"></a>    loese_cvrptw()</span></code></pre></div>
 <blockquote>
 <p><strong>⚠️ Typische Fehler beim VRP</strong></p>
 <ul>
@@ -12645,189 +13390,189 @@ u_i - u_j + C \cdot x_{ij} \le C - d_j \qquad \forall i \ne j
 <hr />
 <h2 id="sec:graphen-denkfehler">8.7 Finde den Denkfehler</h2>
 <blockquote>
-<p><strong>🐛 Finde den Denkfehler 7.1: Die vergessene Dimension</strong></p>
+<p><strong>🐛 Finde den Denkfehler: Die vergessene Dimension</strong></p>
 <p>Eine Spedition lässt ihre Tagestouren optimieren: 16 Kunden, 4 Fahrzeuge zu je 10 Paletten, Gesamtbedarf 37 Paletten. Das erste Ergebnis begeistert alle — <strong>326 km</strong>. Nach einem Hinweis aus dem Fuhrpark wird das Modell überarbeitet; jetzt kommen <strong>572 km</strong> heraus, 75 % mehr. Der Auftraggeber ist verärgert: <em>„Ihre erste Version war doch viel besser.“</em></p>
 <p>Der Unterschied zwischen beiden Fassungen ist ein einziger Codeblock:</p>
-<div class="sourceCode" id="cb94"><pre class="sourceCode python"><code class="sourceCode python"><span id="cb94-1"><a href="#cb94-1" aria-hidden="true" tabindex="-1"></a><span class="kw">def</span> bedarf(index):</span>
-<span id="cb94-2"><a href="#cb94-2" aria-hidden="true" tabindex="-1"></a>    <span class="cf">return</span> BEDARFE[manager.IndexToNode(index)]</span>
-<span id="cb94-3"><a href="#cb94-3" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb94-4"><a href="#cb94-4" aria-hidden="true" tabindex="-1"></a>bedarf_id <span class="op">=</span> routing.RegisterUnaryTransitCallback(bedarf)</span>
-<span id="cb94-5"><a href="#cb94-5" aria-hidden="true" tabindex="-1"></a>routing.AddDimensionWithVehicleCapacity(</span>
-<span id="cb94-6"><a href="#cb94-6" aria-hidden="true" tabindex="-1"></a>    bedarf_id, <span class="dv">0</span>, KAPAZITAETEN, <span class="va">True</span>, <span class="st">&quot;Ladung&quot;</span>)</span></code></pre></div>
+<div class="sourceCode" id="cb96"><pre class="sourceCode python"><code class="sourceCode python"><span id="cb96-1"><a href="#cb96-1" aria-hidden="true" tabindex="-1"></a><span class="kw">def</span> bedarf(index):</span>
+<span id="cb96-2"><a href="#cb96-2" aria-hidden="true" tabindex="-1"></a>    <span class="cf">return</span> BEDARFE[manager.IndexToNode(index)]</span>
+<span id="cb96-3"><a href="#cb96-3" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb96-4"><a href="#cb96-4" aria-hidden="true" tabindex="-1"></a>bedarf_id <span class="op">=</span> routing.RegisterUnaryTransitCallback(bedarf)</span>
+<span id="cb96-5"><a href="#cb96-5" aria-hidden="true" tabindex="-1"></a>routing.AddDimensionWithVehicleCapacity(</span>
+<span id="cb96-6"><a href="#cb96-6" aria-hidden="true" tabindex="-1"></a>    bedarf_id, <span class="dv">0</span>, KAPAZITAETEN, <span class="va">True</span>, <span class="st">&quot;Ladung&quot;</span>)</span></code></pre></div>
 <p><strong>Ihre Aufgabe:</strong> (a) Sehen Sie sich unten die Tourenübersicht des ersten Laufs an. Was tun die Fahrzeuge 1 bis 3, und wie viel lädt Fahrzeug 4? (b) Warum hat die Routing-Bibliothek das nicht von allein verhindert — die Kapazitäten standen doch in den Daten? (c) Warum ist ausgerechnet ein <em>besser</em> aussehendes Ergebnis hier das gefährliche? (d) Welche Prüfung hätte den Fehler sofort sichtbar gemacht — und warum darf sie nicht dieselben Bausteine benutzen wie das Modell?</p>
 <p><em>Auflösung: <a href="#sec:loesungen-graphen">Abschnitt A.8</a>.</em></p>
 </blockquote>
-<div class="sourceCode" id="cb95"><pre class="sourceCode python"><code class="sourceCode python"><span id="cb95-1"><a href="#cb95-1" aria-hidden="true" tabindex="-1"></a><span class="co">#!/usr/bin/env python3</span></span>
-<span id="cb95-2"><a href="#cb95-2" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb95-3"><a href="#cb95-3" aria-hidden="true" tabindex="-1"></a><span class="co"># VRP_Kapazitaetsfalle.py</span></span>
-<span id="cb95-4"><a href="#cb95-4" aria-hidden="true" tabindex="-1"></a><span class="co">&quot;&quot;&quot;</span></span>
-<span id="cb95-5"><a href="#cb95-5" aria-hidden="true" tabindex="-1"></a><span class="co">Kapitel Graphen: Die vergessene Dimension.</span></span>
-<span id="cb95-6"><a href="#cb95-6" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb95-7"><a href="#cb95-7" aria-hidden="true" tabindex="-1"></a><span class="co">Die Routing-Bibliothek von OR-Tools kennt keine &quot;Kapazitaet&quot; von sich aus.</span></span>
-<span id="cb95-8"><a href="#cb95-8" aria-hidden="true" tabindex="-1"></a><span class="co">Sie kennt nur DIMENSIONEN - benannte Groessen, die sich entlang einer Tour</span></span>
-<span id="cb95-9"><a href="#cb95-9" aria-hidden="true" tabindex="-1"></a><span class="co">aufsummieren und begrenzt werden koennen. Distanz ist eine, Zeit ist eine,</span></span>
-<span id="cb95-10"><a href="#cb95-10" aria-hidden="true" tabindex="-1"></a><span class="co">Ladung ist eine. Wer eine davon nicht anlegt, bekommt trotzdem eine Loesung:</span></span>
-<span id="cb95-11"><a href="#cb95-11" aria-hidden="true" tabindex="-1"></a><span class="co">eine schoene, kurze, guenstige - und unfahrbare.</span></span>
-<span id="cb95-12"><a href="#cb95-12" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb95-13"><a href="#cb95-13" aria-hidden="true" tabindex="-1"></a><span class="co">Dieses Programm loest dieselbe Instanz zweimal und prueft beide Ergebnisse</span></span>
-<span id="cb95-14"><a href="#cb95-14" aria-hidden="true" tabindex="-1"></a><span class="co">gegen die tatsaechlichen Lademengen.</span></span>
-<span id="cb95-15"><a href="#cb95-15" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb95-16"><a href="#cb95-16" aria-hidden="true" tabindex="-1"></a><span class="co">Instanz: 1 Depot, 16 Kunden, 4 Fahrzeuge zu je 10 Paletten.</span></span>
-<span id="cb95-17"><a href="#cb95-17" aria-hidden="true" tabindex="-1"></a><span class="co">Gesamtbedarf 37 Paletten bei 40 Paletten Flottenkapazitaet - es ist also</span></span>
-<span id="cb95-18"><a href="#cb95-18" aria-hidden="true" tabindex="-1"></a><span class="co">knapp, aber machbar.</span></span>
-<span id="cb95-19"><a href="#cb95-19" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb95-20"><a href="#cb95-20" aria-hidden="true" tabindex="-1"></a><span class="co">Benoetigt: numpy, ortools</span></span>
-<span id="cb95-21"><a href="#cb95-21" aria-hidden="true" tabindex="-1"></a><span class="co">&quot;&quot;&quot;</span></span>
-<span id="cb95-22"><a href="#cb95-22" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb95-23"><a href="#cb95-23" aria-hidden="true" tabindex="-1"></a><span class="im">from</span> __future__ <span class="im">import</span> annotations</span>
-<span id="cb95-24"><a href="#cb95-24" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb95-25"><a href="#cb95-25" aria-hidden="true" tabindex="-1"></a><span class="im">import</span> numpy <span class="im">as</span> np</span>
-<span id="cb95-26"><a href="#cb95-26" aria-hidden="true" tabindex="-1"></a><span class="im">from</span> ortools.constraint_solver <span class="im">import</span> pywrapcp, routing_enums_pb2</span>
-<span id="cb95-27"><a href="#cb95-27" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb95-28"><a href="#cb95-28" aria-hidden="true" tabindex="-1"></a><span class="co"># Dieselbe Instanz wie VRP_Flotten_Routing.py</span></span>
-<span id="cb95-29"><a href="#cb95-29" aria-hidden="true" tabindex="-1"></a>BEDARFE <span class="op">=</span> [<span class="dv">0</span>, <span class="dv">2</span>, <span class="dv">3</span>, <span class="dv">1</span>, <span class="dv">4</span>, <span class="dv">2</span>, <span class="dv">2</span>, <span class="dv">3</span>, <span class="dv">1</span>, <span class="dv">2</span>, <span class="dv">4</span>, <span class="dv">3</span>, <span class="dv">2</span>, <span class="dv">1</span>, <span class="dv">2</span>, <span class="dv">3</span>, <span class="dv">2</span>]</span>
-<span id="cb95-30"><a href="#cb95-30" aria-hidden="true" tabindex="-1"></a>KAPAZITAETEN <span class="op">=</span> [<span class="dv">10</span>, <span class="dv">10</span>, <span class="dv">10</span>, <span class="dv">10</span>]</span>
-<span id="cb95-31"><a href="#cb95-31" aria-hidden="true" tabindex="-1"></a>ANZAHL_FAHRZEUGE <span class="op">=</span> <span class="dv">4</span></span>
-<span id="cb95-32"><a href="#cb95-32" aria-hidden="true" tabindex="-1"></a>DEPOT <span class="op">=</span> <span class="dv">0</span></span>
-<span id="cb95-33"><a href="#cb95-33" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb95-34"><a href="#cb95-34" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb95-35"><a href="#cb95-35" aria-hidden="true" tabindex="-1"></a><span class="kw">def</span> distanzmatrix(seed: <span class="bu">int</span> <span class="op">=</span> <span class="dv">42</span>) <span class="op">-&gt;</span> <span class="bu">list</span>[<span class="bu">list</span>[<span class="bu">int</span>]]:</span>
-<span id="cb95-36"><a href="#cb95-36" aria-hidden="true" tabindex="-1"></a>    rng <span class="op">=</span> np.random.default_rng(seed)</span>
-<span id="cb95-37"><a href="#cb95-37" aria-hidden="true" tabindex="-1"></a>    koordinaten <span class="op">=</span> rng.random((<span class="bu">len</span>(BEDARFE), <span class="dv">2</span>)) <span class="op">*</span> <span class="dv">100</span>         <span class="co"># 100 x 100 km</span></span>
-<span id="cb95-38"><a href="#cb95-38" aria-hidden="true" tabindex="-1"></a>    n <span class="op">=</span> <span class="bu">len</span>(BEDARFE)</span>
-<span id="cb95-39"><a href="#cb95-39" aria-hidden="true" tabindex="-1"></a>    <span class="cf">return</span> [[<span class="bu">int</span>(np.linalg.norm(koordinaten[i] <span class="op">-</span> koordinaten[j]))</span>
-<span id="cb95-40"><a href="#cb95-40" aria-hidden="true" tabindex="-1"></a>             <span class="cf">for</span> j <span class="kw">in</span> <span class="bu">range</span>(n)] <span class="cf">for</span> i <span class="kw">in</span> <span class="bu">range</span>(n)]</span>
-<span id="cb95-41"><a href="#cb95-41" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb95-42"><a href="#cb95-42" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb95-43"><a href="#cb95-43" aria-hidden="true" tabindex="-1"></a><span class="kw">def</span> plane(mit_kapazitaet: <span class="bu">bool</span>, zeitlimit: <span class="bu">int</span> <span class="op">=</span> <span class="dv">5</span>) <span class="op">-&gt;</span> <span class="bu">dict</span>:</span>
-<span id="cb95-44"><a href="#cb95-44" aria-hidden="true" tabindex="-1"></a>    <span class="co">&quot;&quot;&quot;Loest die Tourenplanung - wahlweise mit oder ohne Ladungsdimension.&quot;&quot;&quot;</span></span>
-<span id="cb95-45"><a href="#cb95-45" aria-hidden="true" tabindex="-1"></a>    distanz <span class="op">=</span> distanzmatrix()</span>
-<span id="cb95-46"><a href="#cb95-46" aria-hidden="true" tabindex="-1"></a>    manager <span class="op">=</span> pywrapcp.RoutingIndexManager(<span class="bu">len</span>(distanz), ANZAHL_FAHRZEUGE, DEPOT)</span>
-<span id="cb95-47"><a href="#cb95-47" aria-hidden="true" tabindex="-1"></a>    routing <span class="op">=</span> pywrapcp.RoutingModel(manager)</span>
-<span id="cb95-48"><a href="#cb95-48" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb95-49"><a href="#cb95-49" aria-hidden="true" tabindex="-1"></a>    <span class="kw">def</span> entfernung(von_index, nach_index):</span>
-<span id="cb95-50"><a href="#cb95-50" aria-hidden="true" tabindex="-1"></a>        <span class="cf">return</span> distanz[manager.IndexToNode(von_index)][manager.IndexToNode(nach_index)]</span>
-<span id="cb95-51"><a href="#cb95-51" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb95-52"><a href="#cb95-52" aria-hidden="true" tabindex="-1"></a>    kosten_id <span class="op">=</span> routing.RegisterTransitCallback(entfernung)</span>
-<span id="cb95-53"><a href="#cb95-53" aria-hidden="true" tabindex="-1"></a>    routing.SetArcCostEvaluatorOfAllVehicles(kosten_id)</span>
-<span id="cb95-54"><a href="#cb95-54" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb95-55"><a href="#cb95-55" aria-hidden="true" tabindex="-1"></a>    <span class="co"># DIE entscheidende Stelle. Ohne diesen Block existiert im Modell keine</span></span>
-<span id="cb95-56"><a href="#cb95-56" aria-hidden="true" tabindex="-1"></a>    <span class="co"># Ladung - die Fahrzeuge sind dann unendlich gross.</span></span>
-<span id="cb95-57"><a href="#cb95-57" aria-hidden="true" tabindex="-1"></a>    <span class="cf">if</span> mit_kapazitaet:</span>
-<span id="cb95-58"><a href="#cb95-58" aria-hidden="true" tabindex="-1"></a>        <span class="kw">def</span> bedarf(index):</span>
-<span id="cb95-59"><a href="#cb95-59" aria-hidden="true" tabindex="-1"></a>            <span class="cf">return</span> BEDARFE[manager.IndexToNode(index)]</span>
-<span id="cb95-60"><a href="#cb95-60" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb95-61"><a href="#cb95-61" aria-hidden="true" tabindex="-1"></a>        bedarf_id <span class="op">=</span> routing.RegisterUnaryTransitCallback(bedarf)</span>
-<span id="cb95-62"><a href="#cb95-62" aria-hidden="true" tabindex="-1"></a>        routing.AddDimensionWithVehicleCapacity(</span>
-<span id="cb95-63"><a href="#cb95-63" aria-hidden="true" tabindex="-1"></a>            bedarf_id,</span>
-<span id="cb95-64"><a href="#cb95-64" aria-hidden="true" tabindex="-1"></a>            <span class="dv">0</span>,                      <span class="co"># kein Zwischenpuffer</span></span>
-<span id="cb95-65"><a href="#cb95-65" aria-hidden="true" tabindex="-1"></a>            KAPAZITAETEN,           <span class="co"># Obergrenze je Fahrzeug</span></span>
-<span id="cb95-66"><a href="#cb95-66" aria-hidden="true" tabindex="-1"></a>            <span class="va">True</span>,                   <span class="co"># Ladung startet bei 0</span></span>
-<span id="cb95-67"><a href="#cb95-67" aria-hidden="true" tabindex="-1"></a>            <span class="st">&quot;Ladung&quot;</span>)</span>
-<span id="cb95-68"><a href="#cb95-68" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb95-69"><a href="#cb95-69" aria-hidden="true" tabindex="-1"></a>    parameter <span class="op">=</span> pywrapcp.DefaultRoutingSearchParameters()</span>
-<span id="cb95-70"><a href="#cb95-70" aria-hidden="true" tabindex="-1"></a>    parameter.first_solution_strategy <span class="op">=</span> (</span>
-<span id="cb95-71"><a href="#cb95-71" aria-hidden="true" tabindex="-1"></a>        routing_enums_pb2.FirstSolutionStrategy.PATH_CHEAPEST_ARC)</span>
-<span id="cb95-72"><a href="#cb95-72" aria-hidden="true" tabindex="-1"></a>    parameter.local_search_metaheuristic <span class="op">=</span> (</span>
-<span id="cb95-73"><a href="#cb95-73" aria-hidden="true" tabindex="-1"></a>        routing_enums_pb2.LocalSearchMetaheuristic.GUIDED_LOCAL_SEARCH)</span>
-<span id="cb95-74"><a href="#cb95-74" aria-hidden="true" tabindex="-1"></a>    parameter.time_limit.FromSeconds(zeitlimit)</span>
-<span id="cb95-75"><a href="#cb95-75" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb95-76"><a href="#cb95-76" aria-hidden="true" tabindex="-1"></a>    loesung <span class="op">=</span> routing.SolveWithParameters(parameter)</span>
-<span id="cb95-77"><a href="#cb95-77" aria-hidden="true" tabindex="-1"></a>    <span class="cf">if</span> loesung <span class="kw">is</span> <span class="va">None</span>:</span>
-<span id="cb95-78"><a href="#cb95-78" aria-hidden="true" tabindex="-1"></a>        <span class="cf">raise</span> <span class="pp">RuntimeError</span>(<span class="st">&quot;Keine Loesung gefunden&quot;</span>)</span>
-<span id="cb95-79"><a href="#cb95-79" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb95-80"><a href="#cb95-80" aria-hidden="true" tabindex="-1"></a>    touren, strecken, ladungen <span class="op">=</span> [], [], []</span>
-<span id="cb95-81"><a href="#cb95-81" aria-hidden="true" tabindex="-1"></a>    <span class="cf">for</span> fahrzeug <span class="kw">in</span> <span class="bu">range</span>(ANZAHL_FAHRZEUGE):</span>
-<span id="cb95-82"><a href="#cb95-82" aria-hidden="true" tabindex="-1"></a>        index <span class="op">=</span> routing.Start(fahrzeug)</span>
-<span id="cb95-83"><a href="#cb95-83" aria-hidden="true" tabindex="-1"></a>        tour, strecke, ladung <span class="op">=</span> [], <span class="dv">0</span>, <span class="dv">0</span></span>
-<span id="cb95-84"><a href="#cb95-84" aria-hidden="true" tabindex="-1"></a>        <span class="cf">while</span> <span class="kw">not</span> routing.IsEnd(index):</span>
-<span id="cb95-85"><a href="#cb95-85" aria-hidden="true" tabindex="-1"></a>            knoten <span class="op">=</span> manager.IndexToNode(index)</span>
-<span id="cb95-86"><a href="#cb95-86" aria-hidden="true" tabindex="-1"></a>            tour.append(knoten)</span>
-<span id="cb95-87"><a href="#cb95-87" aria-hidden="true" tabindex="-1"></a>            ladung <span class="op">+=</span> BEDARFE[knoten]</span>
-<span id="cb95-88"><a href="#cb95-88" aria-hidden="true" tabindex="-1"></a>            vorher <span class="op">=</span> index</span>
-<span id="cb95-89"><a href="#cb95-89" aria-hidden="true" tabindex="-1"></a>            index <span class="op">=</span> loesung.Value(routing.NextVar(index))</span>
-<span id="cb95-90"><a href="#cb95-90" aria-hidden="true" tabindex="-1"></a>            strecke <span class="op">+=</span> routing.GetArcCostForVehicle(vorher, index, fahrzeug)</span>
-<span id="cb95-91"><a href="#cb95-91" aria-hidden="true" tabindex="-1"></a>        tour.append(manager.IndexToNode(index))</span>
-<span id="cb95-92"><a href="#cb95-92" aria-hidden="true" tabindex="-1"></a>        touren.append(tour)</span>
-<span id="cb95-93"><a href="#cb95-93" aria-hidden="true" tabindex="-1"></a>        strecken.append(strecke)</span>
-<span id="cb95-94"><a href="#cb95-94" aria-hidden="true" tabindex="-1"></a>        ladungen.append(ladung)</span>
-<span id="cb95-95"><a href="#cb95-95" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb95-96"><a href="#cb95-96" aria-hidden="true" tabindex="-1"></a>    <span class="cf">return</span> {<span class="st">&quot;touren&quot;</span>: touren, <span class="st">&quot;strecken&quot;</span>: strecken, <span class="st">&quot;ladungen&quot;</span>: ladungen,</span>
-<span id="cb95-97"><a href="#cb95-97" aria-hidden="true" tabindex="-1"></a>            <span class="st">&quot;gesamtstrecke&quot;</span>: <span class="bu">sum</span>(strecken)}</span>
-<span id="cb95-98"><a href="#cb95-98" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb95-99"><a href="#cb95-99" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb95-100"><a href="#cb95-100" aria-hidden="true" tabindex="-1"></a><span class="kw">def</span> pruefe(ergebnis: <span class="bu">dict</span>) <span class="op">-&gt;</span> <span class="bu">list</span>[<span class="bu">str</span>]:</span>
-<span id="cb95-101"><a href="#cb95-101" aria-hidden="true" tabindex="-1"></a>    <span class="co">&quot;&quot;&quot;Prueft den Plan gegen die Wirklichkeit - unabhaengig vom Modell.</span></span>
-<span id="cb95-102"><a href="#cb95-102" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb95-103"><a href="#cb95-103" aria-hidden="true" tabindex="-1"></a><span class="co">    Genau diese Trennung ist der Punkt: Die Pruefung darf nicht dieselben</span></span>
-<span id="cb95-104"><a href="#cb95-104" aria-hidden="true" tabindex="-1"></a><span class="co">    Annahmen benutzen wie das Modell, sonst prueft sie nichts.</span></span>
-<span id="cb95-105"><a href="#cb95-105" aria-hidden="true" tabindex="-1"></a><span class="co">    &quot;&quot;&quot;</span></span>
-<span id="cb95-106"><a href="#cb95-106" aria-hidden="true" tabindex="-1"></a>    beanstandungen <span class="op">=</span> []</span>
-<span id="cb95-107"><a href="#cb95-107" aria-hidden="true" tabindex="-1"></a>    <span class="cf">for</span> fahrzeug, (ladung, kapazitaet) <span class="kw">in</span> <span class="bu">enumerate</span>(</span>
-<span id="cb95-108"><a href="#cb95-108" aria-hidden="true" tabindex="-1"></a>            <span class="bu">zip</span>(ergebnis[<span class="st">&quot;ladungen&quot;</span>], KAPAZITAETEN)):</span>
-<span id="cb95-109"><a href="#cb95-109" aria-hidden="true" tabindex="-1"></a>        <span class="cf">if</span> ladung <span class="op">&gt;</span> kapazitaet:</span>
-<span id="cb95-110"><a href="#cb95-110" aria-hidden="true" tabindex="-1"></a>            beanstandungen.append(</span>
-<span id="cb95-111"><a href="#cb95-111" aria-hidden="true" tabindex="-1"></a>                <span class="ss">f&quot;Fahrzeug </span><span class="sc">{</span>fahrzeug <span class="op">+</span> <span class="dv">1</span><span class="sc">}</span><span class="ss">: </span><span class="sc">{</span>ladung<span class="sc">}</span><span class="ss"> Paletten geladen, &quot;</span></span>
-<span id="cb95-112"><a href="#cb95-112" aria-hidden="true" tabindex="-1"></a>                <span class="ss">f&quot;Kapazitaet </span><span class="sc">{</span>kapazitaet<span class="sc">}</span><span class="ss"> (</span><span class="sc">{</span>ladung <span class="op">-</span> kapazitaet<span class="sc">}</span><span class="ss"> zu viel)&quot;</span>)</span>
-<span id="cb95-113"><a href="#cb95-113" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb95-114"><a href="#cb95-114" aria-hidden="true" tabindex="-1"></a>    beliefert <span class="op">=</span> <span class="bu">sorted</span>(k <span class="cf">for</span> tour <span class="kw">in</span> ergebnis[<span class="st">&quot;touren&quot;</span>] <span class="cf">for</span> k <span class="kw">in</span> tour[<span class="dv">1</span>:<span class="op">-</span><span class="dv">1</span>])</span>
-<span id="cb95-115"><a href="#cb95-115" aria-hidden="true" tabindex="-1"></a>    erwartet <span class="op">=</span> <span class="bu">list</span>(<span class="bu">range</span>(<span class="dv">1</span>, <span class="bu">len</span>(BEDARFE)))</span>
-<span id="cb95-116"><a href="#cb95-116" aria-hidden="true" tabindex="-1"></a>    <span class="cf">if</span> beliefert <span class="op">!=</span> erwartet:</span>
-<span id="cb95-117"><a href="#cb95-117" aria-hidden="true" tabindex="-1"></a>        fehlend <span class="op">=</span> <span class="bu">set</span>(erwartet) <span class="op">-</span> <span class="bu">set</span>(beliefert)</span>
-<span id="cb95-118"><a href="#cb95-118" aria-hidden="true" tabindex="-1"></a>        <span class="cf">if</span> fehlend:</span>
-<span id="cb95-119"><a href="#cb95-119" aria-hidden="true" tabindex="-1"></a>            beanstandungen.append(<span class="ss">f&quot;nicht beliefert: </span><span class="sc">{</span><span class="bu">sorted</span>(fehlend)<span class="sc">}</span><span class="ss">&quot;</span>)</span>
-<span id="cb95-120"><a href="#cb95-120" aria-hidden="true" tabindex="-1"></a>    <span class="cf">return</span> beanstandungen</span>
-<span id="cb95-121"><a href="#cb95-121" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb95-122"><a href="#cb95-122" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb95-123"><a href="#cb95-123" aria-hidden="true" tabindex="-1"></a><span class="kw">def</span> zeige(titel: <span class="bu">str</span>, ergebnis: <span class="bu">dict</span>) <span class="op">-&gt;</span> <span class="va">None</span>:</span>
-<span id="cb95-124"><a href="#cb95-124" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;</span><span class="ch">\n</span><span class="sc">{</span>titel<span class="sc">}</span><span class="ss">&quot;</span>)</span>
-<span id="cb95-125"><a href="#cb95-125" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;  Gesamtstrecke </span><span class="sc">{</span>ergebnis[<span class="st">&#39;gesamtstrecke&#39;</span>]<span class="sc">}</span><span class="ss"> km&quot;</span>)</span>
-<span id="cb95-126"><a href="#cb95-126" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;  </span><span class="sc">{</span><span class="st">&#39;Fahrzeug&#39;</span><span class="sc">:&lt;10}</span><span class="ss"> </span><span class="sc">{</span><span class="st">&#39;Stopps&#39;</span><span class="sc">:&gt;7}</span><span class="ss"> </span><span class="sc">{</span><span class="st">&#39;Strecke&#39;</span><span class="sc">:&gt;9}</span><span class="ss"> </span><span class="sc">{</span><span class="st">&#39;Ladung&#39;</span><span class="sc">:&gt;8}</span><span class="ss"> &quot;</span></span>
-<span id="cb95-127"><a href="#cb95-127" aria-hidden="true" tabindex="-1"></a>          <span class="ss">f&quot;</span><span class="sc">{</span><span class="st">&#39;Kapazitaet&#39;</span><span class="sc">:&gt;11}</span><span class="ss">&quot;</span>)</span>
-<span id="cb95-128"><a href="#cb95-128" aria-hidden="true" tabindex="-1"></a>    <span class="cf">for</span> i, (tour, strecke, ladung) <span class="kw">in</span> <span class="bu">enumerate</span>(</span>
-<span id="cb95-129"><a href="#cb95-129" aria-hidden="true" tabindex="-1"></a>            <span class="bu">zip</span>(ergebnis[<span class="st">&quot;touren&quot;</span>], ergebnis[<span class="st">&quot;strecken&quot;</span>], ergebnis[<span class="st">&quot;ladungen&quot;</span>])):</span>
-<span id="cb95-130"><a href="#cb95-130" aria-hidden="true" tabindex="-1"></a>        markierung <span class="op">=</span> <span class="st">&quot;  &lt;-- ueberladen&quot;</span> <span class="cf">if</span> ladung <span class="op">&gt;</span> KAPAZITAETEN[i] <span class="cf">else</span> <span class="st">&quot;&quot;</span></span>
-<span id="cb95-131"><a href="#cb95-131" aria-hidden="true" tabindex="-1"></a>        <span class="bu">print</span>(<span class="ss">f&quot;  </span><span class="sc">{</span>i <span class="op">+</span> <span class="dv">1</span><span class="sc">:&lt;10}</span><span class="ss"> </span><span class="sc">{</span><span class="bu">len</span>(tour) <span class="op">-</span> <span class="dv">2</span><span class="sc">:&gt;7}</span><span class="ss"> </span><span class="sc">{</span>strecke<span class="sc">:&gt;8}</span><span class="ss"> km </span><span class="sc">{</span>ladung<span class="sc">:&gt;8}</span><span class="ss"> &quot;</span></span>
-<span id="cb95-132"><a href="#cb95-132" aria-hidden="true" tabindex="-1"></a>              <span class="ss">f&quot;</span><span class="sc">{</span>KAPAZITAETEN[i]<span class="sc">:&gt;11}{</span>markierung<span class="sc">}</span><span class="ss">&quot;</span>)</span>
-<span id="cb95-133"><a href="#cb95-133" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb95-134"><a href="#cb95-134" aria-hidden="true" tabindex="-1"></a>    beanstandungen <span class="op">=</span> pruefe(ergebnis)</span>
-<span id="cb95-135"><a href="#cb95-135" aria-hidden="true" tabindex="-1"></a>    <span class="cf">if</span> beanstandungen:</span>
-<span id="cb95-136"><a href="#cb95-136" aria-hidden="true" tabindex="-1"></a>        <span class="bu">print</span>(<span class="st">&quot;  PRUEFUNG: DURCHGEFALLEN&quot;</span>)</span>
-<span id="cb95-137"><a href="#cb95-137" aria-hidden="true" tabindex="-1"></a>        <span class="cf">for</span> text <span class="kw">in</span> beanstandungen:</span>
-<span id="cb95-138"><a href="#cb95-138" aria-hidden="true" tabindex="-1"></a>            <span class="bu">print</span>(<span class="ss">f&quot;    - </span><span class="sc">{</span>text<span class="sc">}</span><span class="ss">&quot;</span>)</span>
-<span id="cb95-139"><a href="#cb95-139" aria-hidden="true" tabindex="-1"></a>    <span class="cf">else</span>:</span>
-<span id="cb95-140"><a href="#cb95-140" aria-hidden="true" tabindex="-1"></a>        <span class="bu">print</span>(<span class="st">&quot;  PRUEFUNG: bestanden&quot;</span>)</span>
-<span id="cb95-141"><a href="#cb95-141" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb95-142"><a href="#cb95-142" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb95-143"><a href="#cb95-143" aria-hidden="true" tabindex="-1"></a><span class="cf">if</span> <span class="va">__name__</span> <span class="op">==</span> <span class="st">&quot;__main__&quot;</span>:</span>
-<span id="cb95-144"><a href="#cb95-144" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;=&quot;</span> <span class="op">*</span> <span class="dv">78</span>)</span>
-<span id="cb95-145"><a href="#cb95-145" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;  DIE VERGESSENE DIMENSION&quot;</span>)</span>
-<span id="cb95-146"><a href="#cb95-146" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;=&quot;</span> <span class="op">*</span> <span class="dv">78</span>)</span>
-<span id="cb95-147"><a href="#cb95-147" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;16 Kunden, Gesamtbedarf </span><span class="sc">{</span><span class="bu">sum</span>(BEDARFE)<span class="sc">}</span><span class="ss"> Paletten, &quot;</span></span>
-<span id="cb95-148"><a href="#cb95-148" aria-hidden="true" tabindex="-1"></a>          <span class="ss">f&quot;</span><span class="sc">{</span>ANZAHL_FAHRZEUGE<span class="sc">}</span><span class="ss"> Fahrzeuge zu je </span><span class="sc">{</span>KAPAZITAETEN[<span class="dv">0</span>]<span class="sc">}</span><span class="ss"> &quot;</span></span>
-<span id="cb95-149"><a href="#cb95-149" aria-hidden="true" tabindex="-1"></a>          <span class="ss">f&quot;= </span><span class="sc">{</span><span class="bu">sum</span>(KAPAZITAETEN)<span class="sc">}</span><span class="ss"> Paletten Flottenkapazitaet.&quot;</span>)</span>
-<span id="cb95-150"><a href="#cb95-150" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb95-151"><a href="#cb95-151" aria-hidden="true" tabindex="-1"></a>    ohne <span class="op">=</span> plane(mit_kapazitaet<span class="op">=</span><span class="va">False</span>)</span>
-<span id="cb95-152"><a href="#cb95-152" aria-hidden="true" tabindex="-1"></a>    zeige(<span class="st">&quot;[1] Ohne Ladungsdimension&quot;</span>, ohne)</span>
-<span id="cb95-153"><a href="#cb95-153" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb95-154"><a href="#cb95-154" aria-hidden="true" tabindex="-1"></a>    mit <span class="op">=</span> plane(mit_kapazitaet<span class="op">=</span><span class="va">True</span>)</span>
-<span id="cb95-155"><a href="#cb95-155" aria-hidden="true" tabindex="-1"></a>    zeige(<span class="st">&quot;[2] Mit AddDimensionWithVehicleCapacity&quot;</span>, mit)</span>
-<span id="cb95-156"><a href="#cb95-156" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb95-157"><a href="#cb95-157" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;</span><span class="ch">\n</span><span class="st">&quot;</span> <span class="op">+</span> <span class="st">&quot;=&quot;</span> <span class="op">*</span> <span class="dv">78</span>)</span>
-<span id="cb95-158"><a href="#cb95-158" aria-hidden="true" tabindex="-1"></a>    mehr <span class="op">=</span> mit[<span class="st">&quot;gesamtstrecke&quot;</span>] <span class="op">-</span> ohne[<span class="st">&quot;gesamtstrecke&quot;</span>]</span>
-<span id="cb95-159"><a href="#cb95-159" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;Der korrekte Plan ist </span><span class="sc">{</span>mehr<span class="sc">}</span><span class="ss"> km laenger &quot;</span></span>
-<span id="cb95-160"><a href="#cb95-160" aria-hidden="true" tabindex="-1"></a>          <span class="ss">f&quot;(</span><span class="sc">{</span>mehr <span class="op">/</span> ohne[<span class="st">&#39;gesamtstrecke&#39;</span>] <span class="op">*</span> <span class="dv">100</span><span class="sc">:.1f}</span><span class="ss"> %).&quot;</span>)</span>
-<span id="cb95-161"><a href="#cb95-161" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>()</span>
-<span id="cb95-162"><a href="#cb95-162" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;Und genau darin liegt die Gefahr: Lauf [1] sieht BESSER aus. Wer&quot;</span>)</span>
-<span id="cb95-163"><a href="#cb95-163" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;beide Zahlen nebeneinander legt, ohne die Ladung zu pruefen, haelt&quot;</span>)</span>
-<span id="cb95-164"><a href="#cb95-164" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;die unfahrbare Loesung fuer die bessere Optimierung - und den&quot;</span>)</span>
-<span id="cb95-165"><a href="#cb95-165" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;korrekten Plan fuer schlechte Arbeit.&quot;</span>)</span>
-<span id="cb95-166"><a href="#cb95-166" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>()</span>
-<span id="cb95-167"><a href="#cb95-167" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;Die Routing-Bibliothek kennt keine &#39;Kapazitaet&#39;. Sie kennt nur&quot;</span>)</span>
-<span id="cb95-168"><a href="#cb95-168" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;Dimensionen, die man ihr anlegt. Was nicht als Dimension existiert,&quot;</span>)</span>
-<span id="cb95-169"><a href="#cb95-169" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;wird nicht begrenzt - und faellt niemandem auf, weil das Ergebnis&quot;</span>)</span>
-<span id="cb95-170"><a href="#cb95-170" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;plausibel aussieht.&quot;</span>)</span>
-<span id="cb95-171"><a href="#cb95-171" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;=&quot;</span> <span class="op">*</span> <span class="dv">78</span>)</span></code></pre></div>
+<div class="sourceCode" id="cb97"><pre class="sourceCode python"><code class="sourceCode python"><span id="cb97-1"><a href="#cb97-1" aria-hidden="true" tabindex="-1"></a><span class="co">#!/usr/bin/env python3</span></span>
+<span id="cb97-2"><a href="#cb97-2" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb97-3"><a href="#cb97-3" aria-hidden="true" tabindex="-1"></a><span class="co"># VRP_Kapazitaetsfalle.py</span></span>
+<span id="cb97-4"><a href="#cb97-4" aria-hidden="true" tabindex="-1"></a><span class="co">&quot;&quot;&quot;</span></span>
+<span id="cb97-5"><a href="#cb97-5" aria-hidden="true" tabindex="-1"></a><span class="co">Kapitel Graphen: Die vergessene Dimension.</span></span>
+<span id="cb97-6"><a href="#cb97-6" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb97-7"><a href="#cb97-7" aria-hidden="true" tabindex="-1"></a><span class="co">Die Routing-Bibliothek von OR-Tools kennt keine &quot;Kapazitaet&quot; von sich aus.</span></span>
+<span id="cb97-8"><a href="#cb97-8" aria-hidden="true" tabindex="-1"></a><span class="co">Sie kennt nur DIMENSIONEN - benannte Groessen, die sich entlang einer Tour</span></span>
+<span id="cb97-9"><a href="#cb97-9" aria-hidden="true" tabindex="-1"></a><span class="co">aufsummieren und begrenzt werden koennen. Distanz ist eine, Zeit ist eine,</span></span>
+<span id="cb97-10"><a href="#cb97-10" aria-hidden="true" tabindex="-1"></a><span class="co">Ladung ist eine. Wer eine davon nicht anlegt, bekommt trotzdem eine Loesung:</span></span>
+<span id="cb97-11"><a href="#cb97-11" aria-hidden="true" tabindex="-1"></a><span class="co">eine schoene, kurze, guenstige - und unfahrbare.</span></span>
+<span id="cb97-12"><a href="#cb97-12" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb97-13"><a href="#cb97-13" aria-hidden="true" tabindex="-1"></a><span class="co">Dieses Programm loest dieselbe Instanz zweimal und prueft beide Ergebnisse</span></span>
+<span id="cb97-14"><a href="#cb97-14" aria-hidden="true" tabindex="-1"></a><span class="co">gegen die tatsaechlichen Lademengen.</span></span>
+<span id="cb97-15"><a href="#cb97-15" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb97-16"><a href="#cb97-16" aria-hidden="true" tabindex="-1"></a><span class="co">Instanz: 1 Depot, 16 Kunden, 4 Fahrzeuge zu je 10 Paletten.</span></span>
+<span id="cb97-17"><a href="#cb97-17" aria-hidden="true" tabindex="-1"></a><span class="co">Gesamtbedarf 37 Paletten bei 40 Paletten Flottenkapazitaet - es ist also</span></span>
+<span id="cb97-18"><a href="#cb97-18" aria-hidden="true" tabindex="-1"></a><span class="co">knapp, aber machbar.</span></span>
+<span id="cb97-19"><a href="#cb97-19" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb97-20"><a href="#cb97-20" aria-hidden="true" tabindex="-1"></a><span class="co">Benoetigt: numpy, ortools</span></span>
+<span id="cb97-21"><a href="#cb97-21" aria-hidden="true" tabindex="-1"></a><span class="co">&quot;&quot;&quot;</span></span>
+<span id="cb97-22"><a href="#cb97-22" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb97-23"><a href="#cb97-23" aria-hidden="true" tabindex="-1"></a><span class="im">from</span> __future__ <span class="im">import</span> annotations</span>
+<span id="cb97-24"><a href="#cb97-24" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb97-25"><a href="#cb97-25" aria-hidden="true" tabindex="-1"></a><span class="im">import</span> numpy <span class="im">as</span> np</span>
+<span id="cb97-26"><a href="#cb97-26" aria-hidden="true" tabindex="-1"></a><span class="im">from</span> ortools.constraint_solver <span class="im">import</span> pywrapcp, routing_enums_pb2</span>
+<span id="cb97-27"><a href="#cb97-27" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb97-28"><a href="#cb97-28" aria-hidden="true" tabindex="-1"></a><span class="co"># Dieselbe Instanz wie VRP_Flotten_Routing.py</span></span>
+<span id="cb97-29"><a href="#cb97-29" aria-hidden="true" tabindex="-1"></a>BEDARFE <span class="op">=</span> [<span class="dv">0</span>, <span class="dv">2</span>, <span class="dv">3</span>, <span class="dv">1</span>, <span class="dv">4</span>, <span class="dv">2</span>, <span class="dv">2</span>, <span class="dv">3</span>, <span class="dv">1</span>, <span class="dv">2</span>, <span class="dv">4</span>, <span class="dv">3</span>, <span class="dv">2</span>, <span class="dv">1</span>, <span class="dv">2</span>, <span class="dv">3</span>, <span class="dv">2</span>]</span>
+<span id="cb97-30"><a href="#cb97-30" aria-hidden="true" tabindex="-1"></a>KAPAZITAETEN <span class="op">=</span> [<span class="dv">10</span>, <span class="dv">10</span>, <span class="dv">10</span>, <span class="dv">10</span>]</span>
+<span id="cb97-31"><a href="#cb97-31" aria-hidden="true" tabindex="-1"></a>ANZAHL_FAHRZEUGE <span class="op">=</span> <span class="dv">4</span></span>
+<span id="cb97-32"><a href="#cb97-32" aria-hidden="true" tabindex="-1"></a>DEPOT <span class="op">=</span> <span class="dv">0</span></span>
+<span id="cb97-33"><a href="#cb97-33" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb97-34"><a href="#cb97-34" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb97-35"><a href="#cb97-35" aria-hidden="true" tabindex="-1"></a><span class="kw">def</span> distanzmatrix(seed: <span class="bu">int</span> <span class="op">=</span> <span class="dv">42</span>) <span class="op">-&gt;</span> <span class="bu">list</span>[<span class="bu">list</span>[<span class="bu">int</span>]]:</span>
+<span id="cb97-36"><a href="#cb97-36" aria-hidden="true" tabindex="-1"></a>    rng <span class="op">=</span> np.random.default_rng(seed)</span>
+<span id="cb97-37"><a href="#cb97-37" aria-hidden="true" tabindex="-1"></a>    koordinaten <span class="op">=</span> rng.random((<span class="bu">len</span>(BEDARFE), <span class="dv">2</span>)) <span class="op">*</span> <span class="dv">100</span>         <span class="co"># 100 x 100 km</span></span>
+<span id="cb97-38"><a href="#cb97-38" aria-hidden="true" tabindex="-1"></a>    n <span class="op">=</span> <span class="bu">len</span>(BEDARFE)</span>
+<span id="cb97-39"><a href="#cb97-39" aria-hidden="true" tabindex="-1"></a>    <span class="cf">return</span> [[<span class="bu">int</span>(np.linalg.norm(koordinaten[i] <span class="op">-</span> koordinaten[j]))</span>
+<span id="cb97-40"><a href="#cb97-40" aria-hidden="true" tabindex="-1"></a>             <span class="cf">for</span> j <span class="kw">in</span> <span class="bu">range</span>(n)] <span class="cf">for</span> i <span class="kw">in</span> <span class="bu">range</span>(n)]</span>
+<span id="cb97-41"><a href="#cb97-41" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb97-42"><a href="#cb97-42" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb97-43"><a href="#cb97-43" aria-hidden="true" tabindex="-1"></a><span class="kw">def</span> plane(mit_kapazitaet: <span class="bu">bool</span>, zeitlimit: <span class="bu">int</span> <span class="op">=</span> <span class="dv">5</span>) <span class="op">-&gt;</span> <span class="bu">dict</span>:</span>
+<span id="cb97-44"><a href="#cb97-44" aria-hidden="true" tabindex="-1"></a>    <span class="co">&quot;&quot;&quot;Loest die Tourenplanung - wahlweise mit oder ohne Ladungsdimension.&quot;&quot;&quot;</span></span>
+<span id="cb97-45"><a href="#cb97-45" aria-hidden="true" tabindex="-1"></a>    distanz <span class="op">=</span> distanzmatrix()</span>
+<span id="cb97-46"><a href="#cb97-46" aria-hidden="true" tabindex="-1"></a>    manager <span class="op">=</span> pywrapcp.RoutingIndexManager(<span class="bu">len</span>(distanz), ANZAHL_FAHRZEUGE, DEPOT)</span>
+<span id="cb97-47"><a href="#cb97-47" aria-hidden="true" tabindex="-1"></a>    routing <span class="op">=</span> pywrapcp.RoutingModel(manager)</span>
+<span id="cb97-48"><a href="#cb97-48" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb97-49"><a href="#cb97-49" aria-hidden="true" tabindex="-1"></a>    <span class="kw">def</span> entfernung(von_index, nach_index):</span>
+<span id="cb97-50"><a href="#cb97-50" aria-hidden="true" tabindex="-1"></a>        <span class="cf">return</span> distanz[manager.IndexToNode(von_index)][manager.IndexToNode(nach_index)]</span>
+<span id="cb97-51"><a href="#cb97-51" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb97-52"><a href="#cb97-52" aria-hidden="true" tabindex="-1"></a>    kosten_id <span class="op">=</span> routing.RegisterTransitCallback(entfernung)</span>
+<span id="cb97-53"><a href="#cb97-53" aria-hidden="true" tabindex="-1"></a>    routing.SetArcCostEvaluatorOfAllVehicles(kosten_id)</span>
+<span id="cb97-54"><a href="#cb97-54" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb97-55"><a href="#cb97-55" aria-hidden="true" tabindex="-1"></a>    <span class="co"># DIE entscheidende Stelle. Ohne diesen Block existiert im Modell keine</span></span>
+<span id="cb97-56"><a href="#cb97-56" aria-hidden="true" tabindex="-1"></a>    <span class="co"># Ladung - die Fahrzeuge sind dann unendlich gross.</span></span>
+<span id="cb97-57"><a href="#cb97-57" aria-hidden="true" tabindex="-1"></a>    <span class="cf">if</span> mit_kapazitaet:</span>
+<span id="cb97-58"><a href="#cb97-58" aria-hidden="true" tabindex="-1"></a>        <span class="kw">def</span> bedarf(index):</span>
+<span id="cb97-59"><a href="#cb97-59" aria-hidden="true" tabindex="-1"></a>            <span class="cf">return</span> BEDARFE[manager.IndexToNode(index)]</span>
+<span id="cb97-60"><a href="#cb97-60" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb97-61"><a href="#cb97-61" aria-hidden="true" tabindex="-1"></a>        bedarf_id <span class="op">=</span> routing.RegisterUnaryTransitCallback(bedarf)</span>
+<span id="cb97-62"><a href="#cb97-62" aria-hidden="true" tabindex="-1"></a>        routing.AddDimensionWithVehicleCapacity(</span>
+<span id="cb97-63"><a href="#cb97-63" aria-hidden="true" tabindex="-1"></a>            bedarf_id,</span>
+<span id="cb97-64"><a href="#cb97-64" aria-hidden="true" tabindex="-1"></a>            <span class="dv">0</span>,                      <span class="co"># kein Zwischenpuffer</span></span>
+<span id="cb97-65"><a href="#cb97-65" aria-hidden="true" tabindex="-1"></a>            KAPAZITAETEN,           <span class="co"># Obergrenze je Fahrzeug</span></span>
+<span id="cb97-66"><a href="#cb97-66" aria-hidden="true" tabindex="-1"></a>            <span class="va">True</span>,                   <span class="co"># Ladung startet bei 0</span></span>
+<span id="cb97-67"><a href="#cb97-67" aria-hidden="true" tabindex="-1"></a>            <span class="st">&quot;Ladung&quot;</span>)</span>
+<span id="cb97-68"><a href="#cb97-68" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb97-69"><a href="#cb97-69" aria-hidden="true" tabindex="-1"></a>    parameter <span class="op">=</span> pywrapcp.DefaultRoutingSearchParameters()</span>
+<span id="cb97-70"><a href="#cb97-70" aria-hidden="true" tabindex="-1"></a>    parameter.first_solution_strategy <span class="op">=</span> (</span>
+<span id="cb97-71"><a href="#cb97-71" aria-hidden="true" tabindex="-1"></a>        routing_enums_pb2.FirstSolutionStrategy.PATH_CHEAPEST_ARC)</span>
+<span id="cb97-72"><a href="#cb97-72" aria-hidden="true" tabindex="-1"></a>    parameter.local_search_metaheuristic <span class="op">=</span> (</span>
+<span id="cb97-73"><a href="#cb97-73" aria-hidden="true" tabindex="-1"></a>        routing_enums_pb2.LocalSearchMetaheuristic.GUIDED_LOCAL_SEARCH)</span>
+<span id="cb97-74"><a href="#cb97-74" aria-hidden="true" tabindex="-1"></a>    parameter.time_limit.FromSeconds(zeitlimit)</span>
+<span id="cb97-75"><a href="#cb97-75" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb97-76"><a href="#cb97-76" aria-hidden="true" tabindex="-1"></a>    loesung <span class="op">=</span> routing.SolveWithParameters(parameter)</span>
+<span id="cb97-77"><a href="#cb97-77" aria-hidden="true" tabindex="-1"></a>    <span class="cf">if</span> loesung <span class="kw">is</span> <span class="va">None</span>:</span>
+<span id="cb97-78"><a href="#cb97-78" aria-hidden="true" tabindex="-1"></a>        <span class="cf">raise</span> <span class="pp">RuntimeError</span>(<span class="st">&quot;Keine Loesung gefunden&quot;</span>)</span>
+<span id="cb97-79"><a href="#cb97-79" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb97-80"><a href="#cb97-80" aria-hidden="true" tabindex="-1"></a>    touren, strecken, ladungen <span class="op">=</span> [], [], []</span>
+<span id="cb97-81"><a href="#cb97-81" aria-hidden="true" tabindex="-1"></a>    <span class="cf">for</span> fahrzeug <span class="kw">in</span> <span class="bu">range</span>(ANZAHL_FAHRZEUGE):</span>
+<span id="cb97-82"><a href="#cb97-82" aria-hidden="true" tabindex="-1"></a>        index <span class="op">=</span> routing.Start(fahrzeug)</span>
+<span id="cb97-83"><a href="#cb97-83" aria-hidden="true" tabindex="-1"></a>        tour, strecke, ladung <span class="op">=</span> [], <span class="dv">0</span>, <span class="dv">0</span></span>
+<span id="cb97-84"><a href="#cb97-84" aria-hidden="true" tabindex="-1"></a>        <span class="cf">while</span> <span class="kw">not</span> routing.IsEnd(index):</span>
+<span id="cb97-85"><a href="#cb97-85" aria-hidden="true" tabindex="-1"></a>            knoten <span class="op">=</span> manager.IndexToNode(index)</span>
+<span id="cb97-86"><a href="#cb97-86" aria-hidden="true" tabindex="-1"></a>            tour.append(knoten)</span>
+<span id="cb97-87"><a href="#cb97-87" aria-hidden="true" tabindex="-1"></a>            ladung <span class="op">+=</span> BEDARFE[knoten]</span>
+<span id="cb97-88"><a href="#cb97-88" aria-hidden="true" tabindex="-1"></a>            vorher <span class="op">=</span> index</span>
+<span id="cb97-89"><a href="#cb97-89" aria-hidden="true" tabindex="-1"></a>            index <span class="op">=</span> loesung.Value(routing.NextVar(index))</span>
+<span id="cb97-90"><a href="#cb97-90" aria-hidden="true" tabindex="-1"></a>            strecke <span class="op">+=</span> routing.GetArcCostForVehicle(vorher, index, fahrzeug)</span>
+<span id="cb97-91"><a href="#cb97-91" aria-hidden="true" tabindex="-1"></a>        tour.append(manager.IndexToNode(index))</span>
+<span id="cb97-92"><a href="#cb97-92" aria-hidden="true" tabindex="-1"></a>        touren.append(tour)</span>
+<span id="cb97-93"><a href="#cb97-93" aria-hidden="true" tabindex="-1"></a>        strecken.append(strecke)</span>
+<span id="cb97-94"><a href="#cb97-94" aria-hidden="true" tabindex="-1"></a>        ladungen.append(ladung)</span>
+<span id="cb97-95"><a href="#cb97-95" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb97-96"><a href="#cb97-96" aria-hidden="true" tabindex="-1"></a>    <span class="cf">return</span> {<span class="st">&quot;touren&quot;</span>: touren, <span class="st">&quot;strecken&quot;</span>: strecken, <span class="st">&quot;ladungen&quot;</span>: ladungen,</span>
+<span id="cb97-97"><a href="#cb97-97" aria-hidden="true" tabindex="-1"></a>            <span class="st">&quot;gesamtstrecke&quot;</span>: <span class="bu">sum</span>(strecken)}</span>
+<span id="cb97-98"><a href="#cb97-98" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb97-99"><a href="#cb97-99" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb97-100"><a href="#cb97-100" aria-hidden="true" tabindex="-1"></a><span class="kw">def</span> pruefe(ergebnis: <span class="bu">dict</span>) <span class="op">-&gt;</span> <span class="bu">list</span>[<span class="bu">str</span>]:</span>
+<span id="cb97-101"><a href="#cb97-101" aria-hidden="true" tabindex="-1"></a>    <span class="co">&quot;&quot;&quot;Prueft den Plan gegen die Wirklichkeit - unabhaengig vom Modell.</span></span>
+<span id="cb97-102"><a href="#cb97-102" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb97-103"><a href="#cb97-103" aria-hidden="true" tabindex="-1"></a><span class="co">    Genau diese Trennung ist der Punkt: Die Pruefung darf nicht dieselben</span></span>
+<span id="cb97-104"><a href="#cb97-104" aria-hidden="true" tabindex="-1"></a><span class="co">    Annahmen benutzen wie das Modell, sonst prueft sie nichts.</span></span>
+<span id="cb97-105"><a href="#cb97-105" aria-hidden="true" tabindex="-1"></a><span class="co">    &quot;&quot;&quot;</span></span>
+<span id="cb97-106"><a href="#cb97-106" aria-hidden="true" tabindex="-1"></a>    beanstandungen <span class="op">=</span> []</span>
+<span id="cb97-107"><a href="#cb97-107" aria-hidden="true" tabindex="-1"></a>    <span class="cf">for</span> fahrzeug, (ladung, kapazitaet) <span class="kw">in</span> <span class="bu">enumerate</span>(</span>
+<span id="cb97-108"><a href="#cb97-108" aria-hidden="true" tabindex="-1"></a>            <span class="bu">zip</span>(ergebnis[<span class="st">&quot;ladungen&quot;</span>], KAPAZITAETEN)):</span>
+<span id="cb97-109"><a href="#cb97-109" aria-hidden="true" tabindex="-1"></a>        <span class="cf">if</span> ladung <span class="op">&gt;</span> kapazitaet:</span>
+<span id="cb97-110"><a href="#cb97-110" aria-hidden="true" tabindex="-1"></a>            beanstandungen.append(</span>
+<span id="cb97-111"><a href="#cb97-111" aria-hidden="true" tabindex="-1"></a>                <span class="ss">f&quot;Fahrzeug </span><span class="sc">{</span>fahrzeug <span class="op">+</span> <span class="dv">1</span><span class="sc">}</span><span class="ss">: </span><span class="sc">{</span>ladung<span class="sc">}</span><span class="ss"> Paletten geladen, &quot;</span></span>
+<span id="cb97-112"><a href="#cb97-112" aria-hidden="true" tabindex="-1"></a>                <span class="ss">f&quot;Kapazitaet </span><span class="sc">{</span>kapazitaet<span class="sc">}</span><span class="ss"> (</span><span class="sc">{</span>ladung <span class="op">-</span> kapazitaet<span class="sc">}</span><span class="ss"> zu viel)&quot;</span>)</span>
+<span id="cb97-113"><a href="#cb97-113" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb97-114"><a href="#cb97-114" aria-hidden="true" tabindex="-1"></a>    beliefert <span class="op">=</span> <span class="bu">sorted</span>(k <span class="cf">for</span> tour <span class="kw">in</span> ergebnis[<span class="st">&quot;touren&quot;</span>] <span class="cf">for</span> k <span class="kw">in</span> tour[<span class="dv">1</span>:<span class="op">-</span><span class="dv">1</span>])</span>
+<span id="cb97-115"><a href="#cb97-115" aria-hidden="true" tabindex="-1"></a>    erwartet <span class="op">=</span> <span class="bu">list</span>(<span class="bu">range</span>(<span class="dv">1</span>, <span class="bu">len</span>(BEDARFE)))</span>
+<span id="cb97-116"><a href="#cb97-116" aria-hidden="true" tabindex="-1"></a>    <span class="cf">if</span> beliefert <span class="op">!=</span> erwartet:</span>
+<span id="cb97-117"><a href="#cb97-117" aria-hidden="true" tabindex="-1"></a>        fehlend <span class="op">=</span> <span class="bu">set</span>(erwartet) <span class="op">-</span> <span class="bu">set</span>(beliefert)</span>
+<span id="cb97-118"><a href="#cb97-118" aria-hidden="true" tabindex="-1"></a>        <span class="cf">if</span> fehlend:</span>
+<span id="cb97-119"><a href="#cb97-119" aria-hidden="true" tabindex="-1"></a>            beanstandungen.append(<span class="ss">f&quot;nicht beliefert: </span><span class="sc">{</span><span class="bu">sorted</span>(fehlend)<span class="sc">}</span><span class="ss">&quot;</span>)</span>
+<span id="cb97-120"><a href="#cb97-120" aria-hidden="true" tabindex="-1"></a>    <span class="cf">return</span> beanstandungen</span>
+<span id="cb97-121"><a href="#cb97-121" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb97-122"><a href="#cb97-122" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb97-123"><a href="#cb97-123" aria-hidden="true" tabindex="-1"></a><span class="kw">def</span> zeige(titel: <span class="bu">str</span>, ergebnis: <span class="bu">dict</span>) <span class="op">-&gt;</span> <span class="va">None</span>:</span>
+<span id="cb97-124"><a href="#cb97-124" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;</span><span class="ch">\n</span><span class="sc">{</span>titel<span class="sc">}</span><span class="ss">&quot;</span>)</span>
+<span id="cb97-125"><a href="#cb97-125" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;  Gesamtstrecke </span><span class="sc">{</span>ergebnis[<span class="st">&#39;gesamtstrecke&#39;</span>]<span class="sc">}</span><span class="ss"> km&quot;</span>)</span>
+<span id="cb97-126"><a href="#cb97-126" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;  </span><span class="sc">{</span><span class="st">&#39;Fahrzeug&#39;</span><span class="sc">:&lt;10}</span><span class="ss"> </span><span class="sc">{</span><span class="st">&#39;Stopps&#39;</span><span class="sc">:&gt;7}</span><span class="ss"> </span><span class="sc">{</span><span class="st">&#39;Strecke&#39;</span><span class="sc">:&gt;9}</span><span class="ss"> </span><span class="sc">{</span><span class="st">&#39;Ladung&#39;</span><span class="sc">:&gt;8}</span><span class="ss"> &quot;</span></span>
+<span id="cb97-127"><a href="#cb97-127" aria-hidden="true" tabindex="-1"></a>          <span class="ss">f&quot;</span><span class="sc">{</span><span class="st">&#39;Kapazitaet&#39;</span><span class="sc">:&gt;11}</span><span class="ss">&quot;</span>)</span>
+<span id="cb97-128"><a href="#cb97-128" aria-hidden="true" tabindex="-1"></a>    <span class="cf">for</span> i, (tour, strecke, ladung) <span class="kw">in</span> <span class="bu">enumerate</span>(</span>
+<span id="cb97-129"><a href="#cb97-129" aria-hidden="true" tabindex="-1"></a>            <span class="bu">zip</span>(ergebnis[<span class="st">&quot;touren&quot;</span>], ergebnis[<span class="st">&quot;strecken&quot;</span>], ergebnis[<span class="st">&quot;ladungen&quot;</span>])):</span>
+<span id="cb97-130"><a href="#cb97-130" aria-hidden="true" tabindex="-1"></a>        markierung <span class="op">=</span> <span class="st">&quot;  &lt;-- ueberladen&quot;</span> <span class="cf">if</span> ladung <span class="op">&gt;</span> KAPAZITAETEN[i] <span class="cf">else</span> <span class="st">&quot;&quot;</span></span>
+<span id="cb97-131"><a href="#cb97-131" aria-hidden="true" tabindex="-1"></a>        <span class="bu">print</span>(<span class="ss">f&quot;  </span><span class="sc">{</span>i <span class="op">+</span> <span class="dv">1</span><span class="sc">:&lt;10}</span><span class="ss"> </span><span class="sc">{</span><span class="bu">len</span>(tour) <span class="op">-</span> <span class="dv">2</span><span class="sc">:&gt;7}</span><span class="ss"> </span><span class="sc">{</span>strecke<span class="sc">:&gt;8}</span><span class="ss"> km </span><span class="sc">{</span>ladung<span class="sc">:&gt;8}</span><span class="ss"> &quot;</span></span>
+<span id="cb97-132"><a href="#cb97-132" aria-hidden="true" tabindex="-1"></a>              <span class="ss">f&quot;</span><span class="sc">{</span>KAPAZITAETEN[i]<span class="sc">:&gt;11}{</span>markierung<span class="sc">}</span><span class="ss">&quot;</span>)</span>
+<span id="cb97-133"><a href="#cb97-133" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb97-134"><a href="#cb97-134" aria-hidden="true" tabindex="-1"></a>    beanstandungen <span class="op">=</span> pruefe(ergebnis)</span>
+<span id="cb97-135"><a href="#cb97-135" aria-hidden="true" tabindex="-1"></a>    <span class="cf">if</span> beanstandungen:</span>
+<span id="cb97-136"><a href="#cb97-136" aria-hidden="true" tabindex="-1"></a>        <span class="bu">print</span>(<span class="st">&quot;  PRUEFUNG: DURCHGEFALLEN&quot;</span>)</span>
+<span id="cb97-137"><a href="#cb97-137" aria-hidden="true" tabindex="-1"></a>        <span class="cf">for</span> text <span class="kw">in</span> beanstandungen:</span>
+<span id="cb97-138"><a href="#cb97-138" aria-hidden="true" tabindex="-1"></a>            <span class="bu">print</span>(<span class="ss">f&quot;    - </span><span class="sc">{</span>text<span class="sc">}</span><span class="ss">&quot;</span>)</span>
+<span id="cb97-139"><a href="#cb97-139" aria-hidden="true" tabindex="-1"></a>    <span class="cf">else</span>:</span>
+<span id="cb97-140"><a href="#cb97-140" aria-hidden="true" tabindex="-1"></a>        <span class="bu">print</span>(<span class="st">&quot;  PRUEFUNG: bestanden&quot;</span>)</span>
+<span id="cb97-141"><a href="#cb97-141" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb97-142"><a href="#cb97-142" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb97-143"><a href="#cb97-143" aria-hidden="true" tabindex="-1"></a><span class="cf">if</span> <span class="va">__name__</span> <span class="op">==</span> <span class="st">&quot;__main__&quot;</span>:</span>
+<span id="cb97-144"><a href="#cb97-144" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;=&quot;</span> <span class="op">*</span> <span class="dv">78</span>)</span>
+<span id="cb97-145"><a href="#cb97-145" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;  DIE VERGESSENE DIMENSION&quot;</span>)</span>
+<span id="cb97-146"><a href="#cb97-146" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;=&quot;</span> <span class="op">*</span> <span class="dv">78</span>)</span>
+<span id="cb97-147"><a href="#cb97-147" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;16 Kunden, Gesamtbedarf </span><span class="sc">{</span><span class="bu">sum</span>(BEDARFE)<span class="sc">}</span><span class="ss"> Paletten, &quot;</span></span>
+<span id="cb97-148"><a href="#cb97-148" aria-hidden="true" tabindex="-1"></a>          <span class="ss">f&quot;</span><span class="sc">{</span>ANZAHL_FAHRZEUGE<span class="sc">}</span><span class="ss"> Fahrzeuge zu je </span><span class="sc">{</span>KAPAZITAETEN[<span class="dv">0</span>]<span class="sc">}</span><span class="ss"> &quot;</span></span>
+<span id="cb97-149"><a href="#cb97-149" aria-hidden="true" tabindex="-1"></a>          <span class="ss">f&quot;= </span><span class="sc">{</span><span class="bu">sum</span>(KAPAZITAETEN)<span class="sc">}</span><span class="ss"> Paletten Flottenkapazitaet.&quot;</span>)</span>
+<span id="cb97-150"><a href="#cb97-150" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb97-151"><a href="#cb97-151" aria-hidden="true" tabindex="-1"></a>    ohne <span class="op">=</span> plane(mit_kapazitaet<span class="op">=</span><span class="va">False</span>)</span>
+<span id="cb97-152"><a href="#cb97-152" aria-hidden="true" tabindex="-1"></a>    zeige(<span class="st">&quot;[1] Ohne Ladungsdimension&quot;</span>, ohne)</span>
+<span id="cb97-153"><a href="#cb97-153" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb97-154"><a href="#cb97-154" aria-hidden="true" tabindex="-1"></a>    mit <span class="op">=</span> plane(mit_kapazitaet<span class="op">=</span><span class="va">True</span>)</span>
+<span id="cb97-155"><a href="#cb97-155" aria-hidden="true" tabindex="-1"></a>    zeige(<span class="st">&quot;[2] Mit AddDimensionWithVehicleCapacity&quot;</span>, mit)</span>
+<span id="cb97-156"><a href="#cb97-156" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb97-157"><a href="#cb97-157" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;</span><span class="ch">\n</span><span class="st">&quot;</span> <span class="op">+</span> <span class="st">&quot;=&quot;</span> <span class="op">*</span> <span class="dv">78</span>)</span>
+<span id="cb97-158"><a href="#cb97-158" aria-hidden="true" tabindex="-1"></a>    mehr <span class="op">=</span> mit[<span class="st">&quot;gesamtstrecke&quot;</span>] <span class="op">-</span> ohne[<span class="st">&quot;gesamtstrecke&quot;</span>]</span>
+<span id="cb97-159"><a href="#cb97-159" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;Der korrekte Plan ist </span><span class="sc">{</span>mehr<span class="sc">}</span><span class="ss"> km laenger &quot;</span></span>
+<span id="cb97-160"><a href="#cb97-160" aria-hidden="true" tabindex="-1"></a>          <span class="ss">f&quot;(</span><span class="sc">{</span>mehr <span class="op">/</span> ohne[<span class="st">&#39;gesamtstrecke&#39;</span>] <span class="op">*</span> <span class="dv">100</span><span class="sc">:.1f}</span><span class="ss"> %).&quot;</span>)</span>
+<span id="cb97-161"><a href="#cb97-161" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>()</span>
+<span id="cb97-162"><a href="#cb97-162" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;Und genau darin liegt die Gefahr: Lauf [1] sieht BESSER aus. Wer&quot;</span>)</span>
+<span id="cb97-163"><a href="#cb97-163" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;beide Zahlen nebeneinander legt, ohne die Ladung zu pruefen, haelt&quot;</span>)</span>
+<span id="cb97-164"><a href="#cb97-164" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;die unfahrbare Loesung fuer die bessere Optimierung - und den&quot;</span>)</span>
+<span id="cb97-165"><a href="#cb97-165" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;korrekten Plan fuer schlechte Arbeit.&quot;</span>)</span>
+<span id="cb97-166"><a href="#cb97-166" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>()</span>
+<span id="cb97-167"><a href="#cb97-167" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;Die Routing-Bibliothek kennt keine &#39;Kapazitaet&#39;. Sie kennt nur&quot;</span>)</span>
+<span id="cb97-168"><a href="#cb97-168" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;Dimensionen, die man ihr anlegt. Was nicht als Dimension existiert,&quot;</span>)</span>
+<span id="cb97-169"><a href="#cb97-169" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;wird nicht begrenzt - und faellt niemandem auf, weil das Ergebnis&quot;</span>)</span>
+<span id="cb97-170"><a href="#cb97-170" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;plausibel aussieht.&quot;</span>)</span>
+<span id="cb97-171"><a href="#cb97-171" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;=&quot;</span> <span class="op">*</span> <span class="dv">78</span>)</span></code></pre></div>
 <p><strong>Erwartete Ausgabe:</strong></p>
 <pre><code>==============================================================================
   DIE VERGESSENE DIMENSION
@@ -12881,7 +13626,7 @@ plausibel aussieht.
 <hr />
 <h2 id="sec:graphen-quiz">8.8 Micro-Quiz</h2>
 <blockquote>
-<p><strong>❓ Micro-Quiz 7: Drei Fragen zum Selbstcheck</strong></p>
+<p><strong>❓ Micro-Quiz 8: Drei Fragen zum Selbstcheck</strong></p>
 <p>Genau eine Antwort ist jeweils richtig. Auflösung in <a href="#quiz-loesung-graphen">Anhang A</a>.</p>
 <p><strong>1. Sie lösen ein Zuordnungsproblem (12 Monteure, 12 Aufträge) als LP — ganz ohne Binärvariablen. Das Ergebnis ist trotzdem 0/1-wertig. Warum?</strong> (a) Zufall; bei anderen Daten kämen Brüche heraus. (b) Die Nebenbedingungsmatrix ist total unimodular, deshalb sind alle Ecken des zulässigen Bereichs ganzzahlig — und in einer Ecke liegt das LP-Optimum. (c) <code>linprog</code> rundet die Lösung intern.</p>
 <p><strong>2. Sie ergänzen dasselbe Zuordnungsmodell um die Regel „höchstens 4 Monteure dürfen Überstunden machen“. Was ändert sich?</strong> (a) Nichts — die Struktur bleibt total unimodular. (b) Die Kardinalitätsbedingung passt nicht ins Schema; die totale Unimodularität geht verloren, die Relaxation kann Brüche liefern und Sie brauchen ein MILP. (c) Das Problem wird unlösbar.</p>
@@ -13001,22 +13746,22 @@ plausibel aussieht.
 </tr>
 </tbody>
 </table>
-<div class="sourceCode" id="cb97"><pre class="sourceCode python"><code class="sourceCode python"><span id="cb97-1"><a href="#cb97-1" aria-hidden="true" tabindex="-1"></a><span class="im">from</span> itertools <span class="im">import</span> permutations</span>
-<span id="cb97-2"><a href="#cb97-2" aria-hidden="true" tabindex="-1"></a><span class="op">&gt;</span> lack <span class="op">=</span> [<span class="st">&quot;Weiss&quot;</span>, <span class="st">&quot;Elfenbein&quot;</span>, <span class="st">&quot;Rot&quot;</span>, <span class="st">&quot;Dunkelrot&quot;</span>, <span class="st">&quot;Schwarz&quot;</span>, <span class="st">&quot;Beige&quot;</span>]</span>
-<span id="cb97-3"><a href="#cb97-3" aria-hidden="true" tabindex="-1"></a>ruest <span class="op">=</span> [[<span class="dv">0</span>, <span class="dv">2</span>, <span class="dv">49</span>, <span class="dv">49</span>, <span class="dv">49</span>, <span class="dv">2</span>],      <span class="co"># Ruestzeit in Minuten von Zeile nach Spalte</span></span>
-<span id="cb97-4"><a href="#cb97-4" aria-hidden="true" tabindex="-1"></a>         [<span class="dv">2</span>, <span class="dv">0</span>, <span class="dv">49</span>, <span class="dv">49</span>, <span class="dv">49</span>, <span class="dv">2</span>],</span>
-<span id="cb97-5"><a href="#cb97-5" aria-hidden="true" tabindex="-1"></a>         [<span class="dv">50</span>, <span class="dv">50</span>, <span class="dv">0</span>, <span class="dv">2</span>, <span class="dv">2</span>, <span class="dv">50</span>],</span>
-<span id="cb97-6"><a href="#cb97-6" aria-hidden="true" tabindex="-1"></a>         [<span class="dv">53</span>, <span class="dv">53</span>, <span class="dv">5</span>, <span class="dv">0</span>, <span class="dv">2</span>, <span class="dv">50</span>],</span>
-<span id="cb97-7"><a href="#cb97-7" aria-hidden="true" tabindex="-1"></a>         [<span class="dv">77</span>, <span class="dv">77</span>, <span class="dv">29</span>, <span class="dv">26</span>, <span class="dv">0</span>, <span class="dv">74</span>],</span>
-<span id="cb97-8"><a href="#cb97-8" aria-hidden="true" tabindex="-1"></a>         [<span class="dv">5</span>, <span class="dv">5</span>, <span class="dv">52</span>, <span class="dv">49</span>, <span class="dv">49</span>, <span class="dv">0</span>]]</span>
-<span id="cb97-9"><a href="#cb97-9" aria-hidden="true" tabindex="-1"></a><span class="op">&gt;</span> dauer <span class="op">=</span> <span class="kw">lambda</span> p: <span class="bu">sum</span>(ruest[p[k]][p[k <span class="op">+</span> <span class="dv">1</span>]] <span class="cf">for</span> k <span class="kw">in</span> <span class="bu">range</span>(<span class="bu">len</span>(p) <span class="op">-</span> <span class="dv">1</span>))</span>
-<span id="cb97-10"><a href="#cb97-10" aria-hidden="true" tabindex="-1"></a><span class="op">&gt;</span> offen, plan <span class="op">=</span> <span class="bu">set</span>(<span class="bu">range</span>(<span class="dv">1</span>, <span class="dv">6</span>)), [<span class="dv">0</span>]                  <span class="co"># Faustregel: billigster naechster</span></span>
-<span id="cb97-11"><a href="#cb97-11" aria-hidden="true" tabindex="-1"></a><span class="cf">while</span> offen:</span>
-<span id="cb97-12"><a href="#cb97-12" aria-hidden="true" tabindex="-1"></a>    naechster <span class="op">=</span> <span class="bu">min</span>(offen, key<span class="op">=</span><span class="kw">lambda</span> j: ruest[plan[<span class="op">-</span><span class="dv">1</span>]][j])</span>
-<span id="cb97-13"><a href="#cb97-13" aria-hidden="true" tabindex="-1"></a>    plan.append(naechster)<span class="op">;</span> offen.discard(naechster)</span>
-<span id="cb97-14"><a href="#cb97-14" aria-hidden="true" tabindex="-1"></a><span class="op">&gt;</span> best <span class="op">=</span> <span class="bu">min</span>(permutations(<span class="bu">range</span>(<span class="dv">1</span>, <span class="dv">6</span>)), key<span class="op">=</span><span class="kw">lambda</span> p: dauer((<span class="dv">0</span>,) <span class="op">+</span> p))</span>
-<span id="cb97-15"><a href="#cb97-15" aria-hidden="true" tabindex="-1"></a><span class="bu">print</span>(<span class="st">&quot;Faustregel:&quot;</span>, <span class="st">&quot; -&gt; &quot;</span>.join(lack[i] <span class="cf">for</span> i <span class="kw">in</span> plan), <span class="ss">f&quot;= </span><span class="sc">{</span>dauer(plan)<span class="sc">}</span><span class="ss"> min&quot;</span>)</span>
-<span id="cb97-16"><a href="#cb97-16" aria-hidden="true" tabindex="-1"></a><span class="bu">print</span>(<span class="st">&quot;Optimal   :&quot;</span>, <span class="st">&quot; -&gt; &quot;</span>.join(lack[i] <span class="cf">for</span> i <span class="kw">in</span> (<span class="dv">0</span>,) <span class="op">+</span> best), <span class="ss">f&quot;= </span><span class="sc">{</span>dauer((<span class="dv">0</span>,) <span class="op">+</span> best)<span class="sc">}</span><span class="ss"> min&quot;</span>)</span></code></pre></div>
+<div class="sourceCode" id="cb99"><pre class="sourceCode python"><code class="sourceCode python"><span id="cb99-1"><a href="#cb99-1" aria-hidden="true" tabindex="-1"></a><span class="im">from</span> itertools <span class="im">import</span> permutations</span>
+<span id="cb99-2"><a href="#cb99-2" aria-hidden="true" tabindex="-1"></a><span class="op">&gt;</span> lack <span class="op">=</span> [<span class="st">&quot;Weiss&quot;</span>, <span class="st">&quot;Elfenbein&quot;</span>, <span class="st">&quot;Rot&quot;</span>, <span class="st">&quot;Dunkelrot&quot;</span>, <span class="st">&quot;Schwarz&quot;</span>, <span class="st">&quot;Beige&quot;</span>]</span>
+<span id="cb99-3"><a href="#cb99-3" aria-hidden="true" tabindex="-1"></a>ruest <span class="op">=</span> [[<span class="dv">0</span>, <span class="dv">2</span>, <span class="dv">49</span>, <span class="dv">49</span>, <span class="dv">49</span>, <span class="dv">2</span>],      <span class="co"># Ruestzeit in Minuten von Zeile nach Spalte</span></span>
+<span id="cb99-4"><a href="#cb99-4" aria-hidden="true" tabindex="-1"></a>         [<span class="dv">2</span>, <span class="dv">0</span>, <span class="dv">49</span>, <span class="dv">49</span>, <span class="dv">49</span>, <span class="dv">2</span>],</span>
+<span id="cb99-5"><a href="#cb99-5" aria-hidden="true" tabindex="-1"></a>         [<span class="dv">50</span>, <span class="dv">50</span>, <span class="dv">0</span>, <span class="dv">2</span>, <span class="dv">2</span>, <span class="dv">50</span>],</span>
+<span id="cb99-6"><a href="#cb99-6" aria-hidden="true" tabindex="-1"></a>         [<span class="dv">53</span>, <span class="dv">53</span>, <span class="dv">5</span>, <span class="dv">0</span>, <span class="dv">2</span>, <span class="dv">50</span>],</span>
+<span id="cb99-7"><a href="#cb99-7" aria-hidden="true" tabindex="-1"></a>         [<span class="dv">77</span>, <span class="dv">77</span>, <span class="dv">29</span>, <span class="dv">26</span>, <span class="dv">0</span>, <span class="dv">74</span>],</span>
+<span id="cb99-8"><a href="#cb99-8" aria-hidden="true" tabindex="-1"></a>         [<span class="dv">5</span>, <span class="dv">5</span>, <span class="dv">52</span>, <span class="dv">49</span>, <span class="dv">49</span>, <span class="dv">0</span>]]</span>
+<span id="cb99-9"><a href="#cb99-9" aria-hidden="true" tabindex="-1"></a><span class="op">&gt;</span> dauer <span class="op">=</span> <span class="kw">lambda</span> p: <span class="bu">sum</span>(ruest[p[k]][p[k <span class="op">+</span> <span class="dv">1</span>]] <span class="cf">for</span> k <span class="kw">in</span> <span class="bu">range</span>(<span class="bu">len</span>(p) <span class="op">-</span> <span class="dv">1</span>))</span>
+<span id="cb99-10"><a href="#cb99-10" aria-hidden="true" tabindex="-1"></a><span class="op">&gt;</span> offen, plan <span class="op">=</span> <span class="bu">set</span>(<span class="bu">range</span>(<span class="dv">1</span>, <span class="dv">6</span>)), [<span class="dv">0</span>]                  <span class="co"># Faustregel: billigster naechster</span></span>
+<span id="cb99-11"><a href="#cb99-11" aria-hidden="true" tabindex="-1"></a><span class="cf">while</span> offen:</span>
+<span id="cb99-12"><a href="#cb99-12" aria-hidden="true" tabindex="-1"></a>    naechster <span class="op">=</span> <span class="bu">min</span>(offen, key<span class="op">=</span><span class="kw">lambda</span> j: ruest[plan[<span class="op">-</span><span class="dv">1</span>]][j])</span>
+<span id="cb99-13"><a href="#cb99-13" aria-hidden="true" tabindex="-1"></a>    plan.append(naechster)<span class="op">;</span> offen.discard(naechster)</span>
+<span id="cb99-14"><a href="#cb99-14" aria-hidden="true" tabindex="-1"></a><span class="op">&gt;</span> best <span class="op">=</span> <span class="bu">min</span>(permutations(<span class="bu">range</span>(<span class="dv">1</span>, <span class="dv">6</span>)), key<span class="op">=</span><span class="kw">lambda</span> p: dauer((<span class="dv">0</span>,) <span class="op">+</span> p))</span>
+<span id="cb99-15"><a href="#cb99-15" aria-hidden="true" tabindex="-1"></a><span class="bu">print</span>(<span class="st">&quot;Faustregel:&quot;</span>, <span class="st">&quot; -&gt; &quot;</span>.join(lack[i] <span class="cf">for</span> i <span class="kw">in</span> plan), <span class="ss">f&quot;= </span><span class="sc">{</span>dauer(plan)<span class="sc">}</span><span class="ss"> min&quot;</span>)</span>
+<span id="cb99-16"><a href="#cb99-16" aria-hidden="true" tabindex="-1"></a><span class="bu">print</span>(<span class="st">&quot;Optimal   :&quot;</span>, <span class="st">&quot; -&gt; &quot;</span>.join(lack[i] <span class="cf">for</span> i <span class="kw">in</span> (<span class="dv">0</span>,) <span class="op">+</span> best), <span class="ss">f&quot;= </span><span class="sc">{</span>dauer((<span class="dv">0</span>,) <span class="op">+</span> best)<span class="sc">}</span><span class="ss"> min&quot;</span>)</span></code></pre></div>
 <p><strong>Ausgabe:</strong></p>
 <pre><code>Faustregel: Weiss -&gt; Elfenbein -&gt; Beige -&gt; Dunkelrot -&gt; Schwarz -&gt; Rot = 84 min
 Optimal   : Weiss -&gt; Elfenbein -&gt; Beige -&gt; Rot -&gt; Dunkelrot -&gt; Schwarz = 60 min</code></pre>
@@ -13103,7 +13848,7 @@ Optimal   : Weiss -&gt; Elfenbein -&gt; Beige -&gt; Rot -&gt; Dunkelrot -&gt; Sc
 <blockquote>
 <p><strong>⚠️ Die Stelle, an der Metaheuristiken scheitern</strong></p>
 <p>Es ist verlockend, die Kosten eines Zugs so zu bewerten:</p>
-<div class="sourceCode" id="cb99"><pre class="sourceCode python"><code class="sourceCode python"><span id="cb99-1"><a href="#cb99-1" aria-hidden="true" tabindex="-1"></a>neue_kosten <span class="op">=</span> gesamtruestzeit(neue_reihe, matrix)      <span class="co"># falsch gedacht</span></span></code></pre></div>
+<div class="sourceCode" id="cb101"><pre class="sourceCode python"><code class="sourceCode python"><span id="cb101-1"><a href="#cb101-1" aria-hidden="true" tabindex="-1"></a>neue_kosten <span class="op">=</span> gesamtruestzeit(neue_reihe, matrix)      <span class="co"># falsch gedacht</span></span></code></pre></div>
 <p>Das ist korrekt und trotzdem der Fehler, der ein Projekt scheitern lässt. Die volle Summe kostet <span class="math inline">O(n)</span> je Zug. Herausnehmen und Einsetzen verändert aber nur <strong>drei Kanten</strong> — die Kostenänderung steht in höchstens sechs Matrixeinträgen und ist in <span class="math inline">O(1)</span> zu haben.</p>
 <p>Bei 500 Aufträgen ist das der Unterschied zwischen einigen tausend und einigen hunderttausend geprüften Zügen im selben Zeitbudget. Eine Metaheuristik lebt von der Zahl der Züge; wer sie durch eine bequeme Bewertungsfunktion um zwei Größenordnungen drückt, misst am Ende nicht das Verfahren, sondern seine eigene Implementierung.</p>
 </blockquote>
@@ -13160,305 +13905,305 @@ e^{-\Delta / T} &amp; \Delta &gt; 0
 </table>
 <p>Die letzte Zeile ist die praktisch wichtigste: <strong><span class="math inline">T</span> und <span class="math inline">\Delta</span> werden in derselben Einheit gemessen.</strong> Wer die Temperatur wählt, ohne die typische Zuggröße zu kennen, wählt blind.</p>
 </blockquote>
-<div class="sourceCode" id="cb100"><pre class="sourceCode python"><code class="sourceCode python"><span id="cb100-1"><a href="#cb100-1" aria-hidden="true" tabindex="-1"></a><span class="co">#!/usr/bin/env python3</span></span>
-<span id="cb100-2"><a href="#cb100-2" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb100-3"><a href="#cb100-3" aria-hidden="true" tabindex="-1"></a><span class="co"># Simulated_Annealing.py</span></span>
-<span id="cb100-4"><a href="#cb100-4" aria-hidden="true" tabindex="-1"></a><span class="co">&quot;&quot;&quot;</span></span>
-<span id="cb100-5"><a href="#cb100-5" aria-hidden="true" tabindex="-1"></a><span class="co">Kapitel Metaheuristiken: Simulated Annealing an der Lackieranlage.</span></span>
-<span id="cb100-6"><a href="#cb100-6" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb100-7"><a href="#cb100-7" aria-hidden="true" tabindex="-1"></a><span class="co">Aufgabe: n Auftraege in eine Reihenfolge bringen. Zwischen zwei Auftraegen</span></span>
-<span id="cb100-8"><a href="#cb100-8" aria-hidden="true" tabindex="-1"></a><span class="co">faellt eine Ruestzeit an - die Anlage muss gereinigt werden. Wie lange das</span></span>
-<span id="cb100-9"><a href="#cb100-9" aria-hidden="true" tabindex="-1"></a><span class="co">dauert, haengt von BEIDEN Auftraegen ab: Ein Wechsel innerhalb derselben</span></span>
-<span id="cb100-10"><a href="#cb100-10" aria-hidden="true" tabindex="-1"></a><span class="co">Produktfamilie kostet fast nichts, ein Wechsel von Dunkel nach Hell ist teuer,</span></span>
-<span id="cb100-11"><a href="#cb100-11" aria-hidden="true" tabindex="-1"></a><span class="co">und zwischen manchen Familien ist der Reinigungsaufwand schlicht hoch. Gesucht</span></span>
-<span id="cb100-12"><a href="#cb100-12" aria-hidden="true" tabindex="-1"></a><span class="co">ist die Reihenfolge mit der kleinsten Summe der Ruestzeiten.</span></span>
-<span id="cb100-13"><a href="#cb100-13" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb100-14"><a href="#cb100-14" aria-hidden="true" tabindex="-1"></a><span class="co">Das Programm zeigt drei Dinge:</span></span>
-<span id="cb100-15"><a href="#cb100-15" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb100-16"><a href="#cb100-16" aria-hidden="true" tabindex="-1"></a><span class="co">  1. Warum die Faustregel &quot;immer der billigste naechste Auftrag&quot; in eine</span></span>
-<span id="cb100-17"><a href="#cb100-17" aria-hidden="true" tabindex="-1"></a><span class="co">     Sackgasse laeuft - und wie weit man sie mit lokaler Suche verbessert.</span></span>
-<span id="cb100-18"><a href="#cb100-18" aria-hidden="true" tabindex="-1"></a><span class="co">  2. Wie gross der Beitrag der Verschlechterungen WIRKLICH ist. Die Antwort</span></span>
-<span id="cb100-19"><a href="#cb100-19" aria-hidden="true" tabindex="-1"></a><span class="co">     faellt bescheidener aus als das Lehrbuch verspricht, und genau das ist</span></span>
-<span id="cb100-20"><a href="#cb100-20" aria-hidden="true" tabindex="-1"></a><span class="co">     der Grund, den Vergleich immer mitzurechnen.</span></span>
-<span id="cb100-21"><a href="#cb100-21" aria-hidden="true" tabindex="-1"></a><span class="co">  3. Dass die Starttemperatur kein Beiwerk ist: zu heiss macht die Suche</span></span>
-<span id="cb100-22"><a href="#cb100-22" aria-hidden="true" tabindex="-1"></a><span class="co">     nutzlos, und man sieht es an einer einzigen Kennzahl kommen.</span></span>
-<span id="cb100-23"><a href="#cb100-23" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb100-24"><a href="#cb100-24" aria-hidden="true" tabindex="-1"></a><span class="co">Zum Budget: Der Abkuehlplan laeuft ueber eine feste ZUGZAHL, nicht ueber eine</span></span>
-<span id="cb100-25"><a href="#cb100-25" aria-hidden="true" tabindex="-1"></a><span class="co">Sekundenzahl. Im Betrieb hat man zwar ein Zeitbudget - fuer einen VERGLEICH ist</span></span>
-<span id="cb100-26"><a href="#cb100-26" aria-hidden="true" tabindex="-1"></a><span class="co">die Zugzahl aber das ehrlichere Mass: Sie ist auf jeder Maschine dieselbe, und</span></span>
-<span id="cb100-27"><a href="#cb100-27" aria-hidden="true" tabindex="-1"></a><span class="co">die abgedruckten Zahlen unten lassen sich damit nachrechnen. Die gemessene</span></span>
-<span id="cb100-28"><a href="#cb100-28" aria-hidden="true" tabindex="-1"></a><span class="co">Laufzeit steht trotzdem dabei.</span></span>
-<span id="cb100-29"><a href="#cb100-29" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb100-30"><a href="#cb100-30" aria-hidden="true" tabindex="-1"></a><span class="co">Benoetigt: numpy</span></span>
-<span id="cb100-31"><a href="#cb100-31" aria-hidden="true" tabindex="-1"></a><span class="co">&quot;&quot;&quot;</span></span>
-<span id="cb100-32"><a href="#cb100-32" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb100-33"><a href="#cb100-33" aria-hidden="true" tabindex="-1"></a><span class="im">from</span> __future__ <span class="im">import</span> annotations</span>
-<span id="cb100-34"><a href="#cb100-34" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb100-35"><a href="#cb100-35" aria-hidden="true" tabindex="-1"></a><span class="im">import</span> math</span>
-<span id="cb100-36"><a href="#cb100-36" aria-hidden="true" tabindex="-1"></a><span class="im">import</span> time</span>
-<span id="cb100-37"><a href="#cb100-37" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb100-38"><a href="#cb100-38" aria-hidden="true" tabindex="-1"></a><span class="im">import</span> numpy <span class="im">as</span> np</span>
-<span id="cb100-39"><a href="#cb100-39" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb100-40"><a href="#cb100-40" aria-hidden="true" tabindex="-1"></a>ZUEGE <span class="op">=</span> <span class="dv">400_000</span>           <span class="co"># Zugbudget je Lauf (statt Sekunden: reproduzierbar)</span></span>
-<span id="cb100-41"><a href="#cb100-41" aria-hidden="true" tabindex="-1"></a>SAAT <span class="op">=</span> <span class="dv">11</span>                 <span class="co"># feste Saat -&gt; reproduzierbare Instanz</span></span>
-<span id="cb100-42"><a href="#cb100-42" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb100-43"><a href="#cb100-43" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb100-44"><a href="#cb100-44" aria-hidden="true" tabindex="-1"></a><span class="co"># --- 1. Die Instanz ---------------------------------------------------------</span></span>
-<span id="cb100-45"><a href="#cb100-45" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb100-46"><a href="#cb100-46" aria-hidden="true" tabindex="-1"></a><span class="kw">def</span> erzeuge_ruestmatrix(n: <span class="bu">int</span>, saat: <span class="bu">int</span> <span class="op">=</span> SAAT) <span class="op">-&gt;</span> np.ndarray:</span>
-<span id="cb100-47"><a href="#cb100-47" aria-hidden="true" tabindex="-1"></a>    <span class="co">&quot;&quot;&quot;Ruestzeiten in Minuten zwischen je zwei Auftraegen.</span></span>
-<span id="cb100-48"><a href="#cb100-48" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb100-49"><a href="#cb100-49" aria-hidden="true" tabindex="-1"></a><span class="co">    Die Zahl der Produktfamilien waechst mit der Auftragszahl (eine Familie je</span></span>
-<span id="cb100-50"><a href="#cb100-50" aria-hidden="true" tabindex="-1"></a><span class="co">    zehn Auftraege). Sonst wuerde das Problem mit wachsendem n LEICHTER: Bei</span></span>
-<span id="cb100-51"><a href="#cb100-51" aria-hidden="true" tabindex="-1"></a><span class="co">    fester Familienzahl haette der Plan irgendwann nur noch ein paar grosse</span></span>
-<span id="cb100-52"><a href="#cb100-52" aria-hidden="true" tabindex="-1"></a><span class="co">    Bloecke, und jede Faustregel faende ihn.</span></span>
-<span id="cb100-53"><a href="#cb100-53" aria-hidden="true" tabindex="-1"></a><span class="co">    &quot;&quot;&quot;</span></span>
-<span id="cb100-54"><a href="#cb100-54" aria-hidden="true" tabindex="-1"></a>    rng <span class="op">=</span> np.random.default_rng(saat)</span>
-<span id="cb100-55"><a href="#cb100-55" aria-hidden="true" tabindex="-1"></a>    familien <span class="op">=</span> <span class="bu">max</span>(<span class="dv">6</span>, n <span class="op">//</span> <span class="dv">10</span>)</span>
-<span id="cb100-56"><a href="#cb100-56" aria-hidden="true" tabindex="-1"></a>    <span class="co"># Reinigungsaufwand zwischen den Familien - unregelmaessig und asymmetrisch,</span></span>
-<span id="cb100-57"><a href="#cb100-57" aria-hidden="true" tabindex="-1"></a>    <span class="co"># so wie im Betrieb: Von Klarlack auf Rot ist etwas anderes als umgekehrt.</span></span>
-<span id="cb100-58"><a href="#cb100-58" aria-hidden="true" tabindex="-1"></a>    zwischen <span class="op">=</span> rng.integers(<span class="dv">8</span>, <span class="dv">60</span>, (familien, familien))</span>
-<span id="cb100-59"><a href="#cb100-59" aria-hidden="true" tabindex="-1"></a>    np.fill_diagonal(zwischen, <span class="dv">2</span>)</span>
-<span id="cb100-60"><a href="#cb100-60" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb100-61"><a href="#cb100-61" aria-hidden="true" tabindex="-1"></a>    familie <span class="op">=</span> rng.integers(<span class="dv">0</span>, familien, n)</span>
-<span id="cb100-62"><a href="#cb100-62" aria-hidden="true" tabindex="-1"></a>    farbe <span class="op">=</span> rng.integers(<span class="dv">0</span>, <span class="dv">10</span>, n)          <span class="co"># 0 = weiss ... 9 = schwarz</span></span>
-<span id="cb100-63"><a href="#cb100-63" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb100-64"><a href="#cb100-64" aria-hidden="true" tabindex="-1"></a>    matrix <span class="op">=</span> np.zeros((n, n), dtype<span class="op">=</span>np.int64)</span>
-<span id="cb100-65"><a href="#cb100-65" aria-hidden="true" tabindex="-1"></a>    <span class="cf">for</span> i <span class="kw">in</span> <span class="bu">range</span>(n):</span>
-<span id="cb100-66"><a href="#cb100-66" aria-hidden="true" tabindex="-1"></a>        <span class="cf">for</span> j <span class="kw">in</span> <span class="bu">range</span>(n):</span>
-<span id="cb100-67"><a href="#cb100-67" aria-hidden="true" tabindex="-1"></a>            <span class="cf">if</span> i <span class="op">!=</span> j:</span>
-<span id="cb100-68"><a href="#cb100-68" aria-hidden="true" tabindex="-1"></a>                <span class="co"># Dunkel -&gt; hell kostet zusaetzlich: die Anlage muss heller</span></span>
-<span id="cb100-69"><a href="#cb100-69" aria-hidden="true" tabindex="-1"></a>                <span class="co"># werden, das braucht mehr Spuelgaenge.</span></span>
-<span id="cb100-70"><a href="#cb100-70" aria-hidden="true" tabindex="-1"></a>                matrix[i, j] <span class="op">=</span> (zwischen[familie[i], familie[j]]</span>
-<span id="cb100-71"><a href="#cb100-71" aria-hidden="true" tabindex="-1"></a>                                <span class="op">+</span> <span class="dv">3</span> <span class="op">*</span> <span class="bu">max</span>(<span class="dv">0</span>, farbe[i] <span class="op">-</span> farbe[j]))</span>
-<span id="cb100-72"><a href="#cb100-72" aria-hidden="true" tabindex="-1"></a>    <span class="cf">return</span> matrix</span>
-<span id="cb100-73"><a href="#cb100-73" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb100-74"><a href="#cb100-74" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb100-75"><a href="#cb100-75" aria-hidden="true" tabindex="-1"></a><span class="kw">def</span> gesamtruestzeit(reihe: <span class="bu">list</span>[<span class="bu">int</span>], matrix: np.ndarray) <span class="op">-&gt;</span> <span class="bu">int</span>:</span>
-<span id="cb100-76"><a href="#cb100-76" aria-hidden="true" tabindex="-1"></a>    <span class="co">&quot;&quot;&quot;Summe der Ruestzeiten einer Reihenfolge (offene Kette, keine Rundreise).&quot;&quot;&quot;</span></span>
-<span id="cb100-77"><a href="#cb100-77" aria-hidden="true" tabindex="-1"></a>    <span class="cf">return</span> <span class="bu">int</span>(<span class="bu">sum</span>(matrix[reihe[k], reihe[k <span class="op">+</span> <span class="dv">1</span>]] <span class="cf">for</span> k <span class="kw">in</span> <span class="bu">range</span>(<span class="bu">len</span>(reihe) <span class="op">-</span> <span class="dv">1</span>)))</span>
-<span id="cb100-78"><a href="#cb100-78" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb100-79"><a href="#cb100-79" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb100-80"><a href="#cb100-80" aria-hidden="true" tabindex="-1"></a><span class="kw">def</span> faustregel(matrix: np.ndarray) <span class="op">-&gt;</span> <span class="bu">list</span>[<span class="bu">int</span>]:</span>
-<span id="cb100-81"><a href="#cb100-81" aria-hidden="true" tabindex="-1"></a>    <span class="co">&quot;&quot;&quot;Immer der billigste noch offene Auftrag - &#39;naechster Nachbar&#39;.</span></span>
-<span id="cb100-82"><a href="#cb100-82" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb100-83"><a href="#cb100-83" aria-hidden="true" tabindex="-1"></a><span class="co">    So plant ein Meister von Hand, und es ist keine schlechte Regel. Ihr Fehler</span></span>
-<span id="cb100-84"><a href="#cb100-84" aria-hidden="true" tabindex="-1"></a><span class="co">    ist die Kurzsichtigkeit: Sie spart am Anfang und laesst die teuren Wechsel</span></span>
-<span id="cb100-85"><a href="#cb100-85" aria-hidden="true" tabindex="-1"></a><span class="co">    fuer das Ende uebrig, wo keine Wahl mehr bleibt.</span></span>
-<span id="cb100-86"><a href="#cb100-86" aria-hidden="true" tabindex="-1"></a><span class="co">    &quot;&quot;&quot;</span></span>
-<span id="cb100-87"><a href="#cb100-87" aria-hidden="true" tabindex="-1"></a>    n <span class="op">=</span> <span class="bu">len</span>(matrix)</span>
-<span id="cb100-88"><a href="#cb100-88" aria-hidden="true" tabindex="-1"></a>    offen <span class="op">=</span> <span class="bu">set</span>(<span class="bu">range</span>(<span class="dv">1</span>, n))</span>
-<span id="cb100-89"><a href="#cb100-89" aria-hidden="true" tabindex="-1"></a>    reihe <span class="op">=</span> [<span class="dv">0</span>]</span>
-<span id="cb100-90"><a href="#cb100-90" aria-hidden="true" tabindex="-1"></a>    <span class="cf">while</span> offen:</span>
-<span id="cb100-91"><a href="#cb100-91" aria-hidden="true" tabindex="-1"></a>        naechster <span class="op">=</span> <span class="bu">min</span>(offen, key<span class="op">=</span><span class="kw">lambda</span> j: matrix[reihe[<span class="op">-</span><span class="dv">1</span>], j])</span>
-<span id="cb100-92"><a href="#cb100-92" aria-hidden="true" tabindex="-1"></a>        reihe.append(naechster)</span>
-<span id="cb100-93"><a href="#cb100-93" aria-hidden="true" tabindex="-1"></a>        offen.discard(naechster)</span>
-<span id="cb100-94"><a href="#cb100-94" aria-hidden="true" tabindex="-1"></a>    <span class="cf">return</span> reihe</span>
-<span id="cb100-95"><a href="#cb100-95" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb100-96"><a href="#cb100-96" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb100-97"><a href="#cb100-97" aria-hidden="true" tabindex="-1"></a><span class="co"># --- 2. Der Zug und seine Kostenaenderung -----------------------------------</span></span>
-<span id="cb100-98"><a href="#cb100-98" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb100-99"><a href="#cb100-99" aria-hidden="true" tabindex="-1"></a><span class="kw">def</span> delta_verschieben(reihe: <span class="bu">list</span>[<span class="bu">int</span>], matrix: np.ndarray,</span>
-<span id="cb100-100"><a href="#cb100-100" aria-hidden="true" tabindex="-1"></a>                      von: <span class="bu">int</span>, nach: <span class="bu">int</span>):</span>
-<span id="cb100-101"><a href="#cb100-101" aria-hidden="true" tabindex="-1"></a>    <span class="co">&quot;&quot;&quot;Auftrag von Position &#39;von&#39; an Position &#39;nach&#39; versetzen.</span></span>
-<span id="cb100-102"><a href="#cb100-102" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb100-103"><a href="#cb100-103" aria-hidden="true" tabindex="-1"></a><span class="co">    Liefert (Kostenaenderung, Restliste, Einfuegeposition) oder None, wenn der</span></span>
-<span id="cb100-104"><a href="#cb100-104" aria-hidden="true" tabindex="-1"></a><span class="co">    Zug nichts aendert.</span></span>
-<span id="cb100-105"><a href="#cb100-105" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb100-106"><a href="#cb100-106" aria-hidden="true" tabindex="-1"></a><span class="co">    DAS IST DIE WICHTIGSTE FUNKTION DES PROGRAMMS. Sie berechnet die</span></span>
-<span id="cb100-107"><a href="#cb100-107" aria-hidden="true" tabindex="-1"></a><span class="co">    Kostenaenderung aus HOECHSTENS SECHS Matrixeintraegen, statt die</span></span>
-<span id="cb100-108"><a href="#cb100-108" aria-hidden="true" tabindex="-1"></a><span class="co">    Reihenfolge neu durchzusummieren. Der Unterschied ist nicht kosmetisch:</span></span>
-<span id="cb100-109"><a href="#cb100-109" aria-hidden="true" tabindex="-1"></a><span class="co">    Die volle Summe kostet O(n) je Zug, diese Rechnung O(1). Bei 500 Auftraegen</span></span>
-<span id="cb100-110"><a href="#cb100-110" aria-hidden="true" tabindex="-1"></a><span class="co">    sind das rund 500-mal mehr geprueste Zuege im selben Zeitbudget - und eine</span></span>
-<span id="cb100-111"><a href="#cb100-111" aria-hidden="true" tabindex="-1"></a><span class="co">    Metaheuristik lebt von der Zahl der Zuege.</span></span>
-<span id="cb100-112"><a href="#cb100-112" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb100-113"><a href="#cb100-113" aria-hidden="true" tabindex="-1"></a><span class="co">    Herausgerissen wird der Auftrag aus zwei Kanten, seine Nachbarn ruecken</span></span>
-<span id="cb100-114"><a href="#cb100-114" aria-hidden="true" tabindex="-1"></a><span class="co">    zusammen (eine neue Kante). Eingefuegt wird er zwischen zwei andere</span></span>
-<span id="cb100-115"><a href="#cb100-115" aria-hidden="true" tabindex="-1"></a><span class="co">    Nachbarn, deren bisherige Kante dadurch verschwindet.</span></span>
-<span id="cb100-116"><a href="#cb100-116" aria-hidden="true" tabindex="-1"></a><span class="co">    &quot;&quot;&quot;</span></span>
-<span id="cb100-117"><a href="#cb100-117" aria-hidden="true" tabindex="-1"></a>    n <span class="op">=</span> <span class="bu">len</span>(reihe)</span>
-<span id="cb100-118"><a href="#cb100-118" aria-hidden="true" tabindex="-1"></a>    <span class="cf">if</span> von <span class="op">==</span> nach <span class="kw">or</span> nach <span class="op">==</span> von <span class="op">+</span> <span class="dv">1</span>:</span>
-<span id="cb100-119"><a href="#cb100-119" aria-hidden="true" tabindex="-1"></a>        <span class="cf">return</span> <span class="va">None</span></span>
-<span id="cb100-120"><a href="#cb100-120" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb100-121"><a href="#cb100-121" aria-hidden="true" tabindex="-1"></a>    heraus <span class="op">=</span> <span class="dv">0</span></span>
-<span id="cb100-122"><a href="#cb100-122" aria-hidden="true" tabindex="-1"></a>    <span class="cf">if</span> von <span class="op">&gt;</span> <span class="dv">0</span>:</span>
-<span id="cb100-123"><a href="#cb100-123" aria-hidden="true" tabindex="-1"></a>        heraus <span class="op">+=</span> matrix[reihe[von <span class="op">-</span> <span class="dv">1</span>], reihe[von]]</span>
-<span id="cb100-124"><a href="#cb100-124" aria-hidden="true" tabindex="-1"></a>    <span class="cf">if</span> von <span class="op">&lt;</span> n <span class="op">-</span> <span class="dv">1</span>:</span>
-<span id="cb100-125"><a href="#cb100-125" aria-hidden="true" tabindex="-1"></a>        heraus <span class="op">+=</span> matrix[reihe[von], reihe[von <span class="op">+</span> <span class="dv">1</span>]]</span>
-<span id="cb100-126"><a href="#cb100-126" aria-hidden="true" tabindex="-1"></a>    <span class="cf">if</span> <span class="dv">0</span> <span class="op">&lt;</span> von <span class="op">&lt;</span> n <span class="op">-</span> <span class="dv">1</span>:                       <span class="co"># die Nachbarn ruecken zusammen</span></span>
-<span id="cb100-127"><a href="#cb100-127" aria-hidden="true" tabindex="-1"></a>        heraus <span class="op">-=</span> matrix[reihe[von <span class="op">-</span> <span class="dv">1</span>], reihe[von <span class="op">+</span> <span class="dv">1</span>]]</span>
-<span id="cb100-128"><a href="#cb100-128" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb100-129"><a href="#cb100-129" aria-hidden="true" tabindex="-1"></a>    rest <span class="op">=</span> reihe[:von] <span class="op">+</span> reihe[von <span class="op">+</span> <span class="dv">1</span>:]</span>
-<span id="cb100-130"><a href="#cb100-130" aria-hidden="true" tabindex="-1"></a>    stelle <span class="op">=</span> nach <span class="cf">if</span> nach <span class="op">&lt;</span> von <span class="cf">else</span> nach <span class="op">-</span> <span class="dv">1</span></span>
-<span id="cb100-131"><a href="#cb100-131" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb100-132"><a href="#cb100-132" aria-hidden="true" tabindex="-1"></a>    hinein <span class="op">=</span> <span class="dv">0</span></span>
-<span id="cb100-133"><a href="#cb100-133" aria-hidden="true" tabindex="-1"></a>    <span class="cf">if</span> stelle <span class="op">&gt;</span> <span class="dv">0</span>:</span>
-<span id="cb100-134"><a href="#cb100-134" aria-hidden="true" tabindex="-1"></a>        hinein <span class="op">+=</span> matrix[rest[stelle <span class="op">-</span> <span class="dv">1</span>], reihe[von]]</span>
-<span id="cb100-135"><a href="#cb100-135" aria-hidden="true" tabindex="-1"></a>    <span class="cf">if</span> stelle <span class="op">&lt;</span> <span class="bu">len</span>(rest):</span>
-<span id="cb100-136"><a href="#cb100-136" aria-hidden="true" tabindex="-1"></a>        hinein <span class="op">+=</span> matrix[reihe[von], rest[stelle]]</span>
-<span id="cb100-137"><a href="#cb100-137" aria-hidden="true" tabindex="-1"></a>    <span class="cf">if</span> <span class="dv">0</span> <span class="op">&lt;</span> stelle <span class="op">&lt;</span> <span class="bu">len</span>(rest):                <span class="co"># die aufgetrennte Kante faellt weg</span></span>
-<span id="cb100-138"><a href="#cb100-138" aria-hidden="true" tabindex="-1"></a>        hinein <span class="op">-=</span> matrix[rest[stelle <span class="op">-</span> <span class="dv">1</span>], rest[stelle]]</span>
-<span id="cb100-139"><a href="#cb100-139" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb100-140"><a href="#cb100-140" aria-hidden="true" tabindex="-1"></a>    <span class="cf">return</span> <span class="bu">int</span>(hinein <span class="op">-</span> heraus), rest, stelle</span>
-<span id="cb100-141"><a href="#cb100-141" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb100-142"><a href="#cb100-142" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb100-143"><a href="#cb100-143" aria-hidden="true" tabindex="-1"></a><span class="co"># --- 3. Die Suche -----------------------------------------------------------</span></span>
-<span id="cb100-144"><a href="#cb100-144" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb100-145"><a href="#cb100-145" aria-hidden="true" tabindex="-1"></a><span class="kw">class</span> Verlauf:</span>
-<span id="cb100-146"><a href="#cb100-146" aria-hidden="true" tabindex="-1"></a>    <span class="co">&quot;&quot;&quot;Was ein Lauf ausser dem Ergebnis noch verraet.&quot;&quot;&quot;</span></span>
-<span id="cb100-147"><a href="#cb100-147" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb100-148"><a href="#cb100-148" aria-hidden="true" tabindex="-1"></a>    <span class="kw">def</span> <span class="fu">__init__</span>(<span class="va">self</span>) <span class="op">-&gt;</span> <span class="va">None</span>:</span>
-<span id="cb100-149"><a href="#cb100-149" aria-hidden="true" tabindex="-1"></a>        <span class="va">self</span>.schritte <span class="op">=</span> <span class="dv">0</span></span>
-<span id="cb100-150"><a href="#cb100-150" aria-hidden="true" tabindex="-1"></a>        <span class="va">self</span>.verschlechterungen_geprueft <span class="op">=</span> <span class="dv">0</span></span>
-<span id="cb100-151"><a href="#cb100-151" aria-hidden="true" tabindex="-1"></a>        <span class="va">self</span>.verschlechterungen_genommen <span class="op">=</span> <span class="dv">0</span></span>
-<span id="cb100-152"><a href="#cb100-152" aria-hidden="true" tabindex="-1"></a>        <span class="va">self</span>.schlechtester_zustand <span class="op">=</span> <span class="dv">0</span>      <span class="co"># wie weit die Suche abgedriftet ist</span></span>
-<span id="cb100-153"><a href="#cb100-153" aria-hidden="true" tabindex="-1"></a>        <span class="va">self</span>.sekunden <span class="op">=</span> <span class="fl">0.0</span>                 <span class="co"># nur zur Information, nicht zum Vergleich</span></span>
-<span id="cb100-154"><a href="#cb100-154" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb100-155"><a href="#cb100-155" aria-hidden="true" tabindex="-1"></a>    <span class="at">@property</span></span>
-<span id="cb100-156"><a href="#cb100-156" aria-hidden="true" tabindex="-1"></a>    <span class="kw">def</span> annahmequote(<span class="va">self</span>) <span class="op">-&gt;</span> <span class="bu">float</span>:</span>
-<span id="cb100-157"><a href="#cb100-157" aria-hidden="true" tabindex="-1"></a>        <span class="cf">if</span> <span class="kw">not</span> <span class="va">self</span>.verschlechterungen_geprueft:</span>
-<span id="cb100-158"><a href="#cb100-158" aria-hidden="true" tabindex="-1"></a>            <span class="cf">return</span> <span class="fl">0.0</span></span>
-<span id="cb100-159"><a href="#cb100-159" aria-hidden="true" tabindex="-1"></a>        <span class="cf">return</span> <span class="va">self</span>.verschlechterungen_genommen <span class="op">/</span> <span class="va">self</span>.verschlechterungen_geprueft</span>
-<span id="cb100-160"><a href="#cb100-160" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb100-161"><a href="#cb100-161" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb100-162"><a href="#cb100-162" aria-hidden="true" tabindex="-1"></a><span class="kw">def</span> suche(matrix: np.ndarray, zuege: <span class="bu">int</span>, start_temperatur: <span class="bu">float</span>,</span>
-<span id="cb100-163"><a href="#cb100-163" aria-hidden="true" tabindex="-1"></a>          end_temperatur: <span class="bu">float</span> <span class="op">=</span> <span class="fl">0.05</span>, saat: <span class="bu">int</span> <span class="op">=</span> <span class="dv">1</span>,</span>
-<span id="cb100-164"><a href="#cb100-164" aria-hidden="true" tabindex="-1"></a>          bergsteigen: <span class="bu">bool</span> <span class="op">=</span> <span class="va">False</span>) <span class="op">-&gt;</span> <span class="bu">tuple</span>[<span class="bu">list</span>[<span class="bu">int</span>], <span class="bu">int</span>, Verlauf]:</span>
-<span id="cb100-165"><a href="#cb100-165" aria-hidden="true" tabindex="-1"></a>    <span class="co">&quot;&quot;&quot;Simulated Annealing (oder reines Bergsteigen, wenn bergsteigen=True).</span></span>
-<span id="cb100-166"><a href="#cb100-166" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb100-167"><a href="#cb100-167" aria-hidden="true" tabindex="-1"></a><span class="co">    Der einzige Unterschied zwischen beiden steht in der Annahmezeile: Das</span></span>
-<span id="cb100-168"><a href="#cb100-168" aria-hidden="true" tabindex="-1"></a><span class="co">    Bergsteigen nimmt nur Verbesserungen, SA nimmt Verschlechterungen mit einer</span></span>
-<span id="cb100-169"><a href="#cb100-169" aria-hidden="true" tabindex="-1"></a><span class="co">    Wahrscheinlichkeit an, die mit der Zeit gegen null geht.</span></span>
-<span id="cb100-170"><a href="#cb100-170" aria-hidden="true" tabindex="-1"></a><span class="co">    &quot;&quot;&quot;</span></span>
-<span id="cb100-171"><a href="#cb100-171" aria-hidden="true" tabindex="-1"></a>    rng <span class="op">=</span> np.random.default_rng(saat)</span>
-<span id="cb100-172"><a href="#cb100-172" aria-hidden="true" tabindex="-1"></a>    n <span class="op">=</span> <span class="bu">len</span>(matrix)</span>
-<span id="cb100-173"><a href="#cb100-173" aria-hidden="true" tabindex="-1"></a>    reihe <span class="op">=</span> faustregel(matrix)</span>
-<span id="cb100-174"><a href="#cb100-174" aria-hidden="true" tabindex="-1"></a>    kosten <span class="op">=</span> gesamtruestzeit(reihe, matrix)</span>
-<span id="cb100-175"><a href="#cb100-175" aria-hidden="true" tabindex="-1"></a>    beste, beste_kosten <span class="op">=</span> reihe[:], kosten</span>
-<span id="cb100-176"><a href="#cb100-176" aria-hidden="true" tabindex="-1"></a>    verlauf <span class="op">=</span> Verlauf()</span>
-<span id="cb100-177"><a href="#cb100-177" aria-hidden="true" tabindex="-1"></a>    verlauf.schlechtester_zustand <span class="op">=</span> kosten</span>
-<span id="cb100-178"><a href="#cb100-178" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb100-179"><a href="#cb100-179" aria-hidden="true" tabindex="-1"></a>    start <span class="op">=</span> time.perf_counter()</span>
-<span id="cb100-180"><a href="#cb100-180" aria-hidden="true" tabindex="-1"></a>    <span class="cf">for</span> zug <span class="kw">in</span> <span class="bu">range</span>(zuege):</span>
-<span id="cb100-181"><a href="#cb100-181" aria-hidden="true" tabindex="-1"></a>        verlauf.schritte <span class="op">+=</span> <span class="dv">1</span></span>
-<span id="cb100-182"><a href="#cb100-182" aria-hidden="true" tabindex="-1"></a>        <span class="co"># Geometrischer Abkuehlplan ueber das Zugbudget.</span></span>
-<span id="cb100-183"><a href="#cb100-183" aria-hidden="true" tabindex="-1"></a>        temperatur <span class="op">=</span> start_temperatur <span class="op">*</span> (end_temperatur <span class="op">/</span> start_temperatur) <span class="op">\</span></span>
-<span id="cb100-184"><a href="#cb100-184" aria-hidden="true" tabindex="-1"></a>            <span class="op">**</span> (zug <span class="op">/</span> zuege)</span>
-<span id="cb100-185"><a href="#cb100-185" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb100-186"><a href="#cb100-186" aria-hidden="true" tabindex="-1"></a>        von <span class="op">=</span> <span class="bu">int</span>(rng.integers(<span class="dv">0</span>, n))</span>
-<span id="cb100-187"><a href="#cb100-187" aria-hidden="true" tabindex="-1"></a>        nach <span class="op">=</span> <span class="bu">int</span>(rng.integers(<span class="dv">0</span>, n <span class="op">+</span> <span class="dv">1</span>))</span>
-<span id="cb100-188"><a href="#cb100-188" aria-hidden="true" tabindex="-1"></a>        ergebnis <span class="op">=</span> delta_verschieben(reihe, matrix, von, nach)</span>
-<span id="cb100-189"><a href="#cb100-189" aria-hidden="true" tabindex="-1"></a>        <span class="cf">if</span> ergebnis <span class="kw">is</span> <span class="va">None</span>:</span>
-<span id="cb100-190"><a href="#cb100-190" aria-hidden="true" tabindex="-1"></a>            <span class="cf">continue</span></span>
-<span id="cb100-191"><a href="#cb100-191" aria-hidden="true" tabindex="-1"></a>        aenderung, rest, stelle <span class="op">=</span> ergebnis</span>
-<span id="cb100-192"><a href="#cb100-192" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb100-193"><a href="#cb100-193" aria-hidden="true" tabindex="-1"></a>        <span class="cf">if</span> aenderung <span class="op">&lt;=</span> <span class="dv">0</span>:</span>
-<span id="cb100-194"><a href="#cb100-194" aria-hidden="true" tabindex="-1"></a>            annehmen <span class="op">=</span> <span class="va">True</span></span>
-<span id="cb100-195"><a href="#cb100-195" aria-hidden="true" tabindex="-1"></a>        <span class="cf">else</span>:</span>
-<span id="cb100-196"><a href="#cb100-196" aria-hidden="true" tabindex="-1"></a>            verlauf.verschlechterungen_geprueft <span class="op">+=</span> <span class="dv">1</span></span>
-<span id="cb100-197"><a href="#cb100-197" aria-hidden="true" tabindex="-1"></a>            <span class="co"># Metropolis-Kriterium: je groesser die Verschlechterung und je</span></span>
-<span id="cb100-198"><a href="#cb100-198" aria-hidden="true" tabindex="-1"></a>            <span class="co"># kaelter es ist, desto unwahrscheinlicher.</span></span>
-<span id="cb100-199"><a href="#cb100-199" aria-hidden="true" tabindex="-1"></a>            annehmen <span class="op">=</span> (<span class="kw">not</span> bergsteigen</span>
-<span id="cb100-200"><a href="#cb100-200" aria-hidden="true" tabindex="-1"></a>                        <span class="kw">and</span> rng.random() <span class="op">&lt;</span> math.exp(<span class="op">-</span>aenderung <span class="op">/</span> temperatur))</span>
-<span id="cb100-201"><a href="#cb100-201" aria-hidden="true" tabindex="-1"></a>            verlauf.verschlechterungen_genommen <span class="op">+=</span> annehmen</span>
-<span id="cb100-202"><a href="#cb100-202" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb100-203"><a href="#cb100-203" aria-hidden="true" tabindex="-1"></a>        <span class="cf">if</span> annehmen:</span>
-<span id="cb100-204"><a href="#cb100-204" aria-hidden="true" tabindex="-1"></a>            reihe <span class="op">=</span> rest[:stelle] <span class="op">+</span> [reihe[von]] <span class="op">+</span> rest[stelle:]</span>
-<span id="cb100-205"><a href="#cb100-205" aria-hidden="true" tabindex="-1"></a>            kosten <span class="op">+=</span> aenderung</span>
-<span id="cb100-206"><a href="#cb100-206" aria-hidden="true" tabindex="-1"></a>            verlauf.schlechtester_zustand <span class="op">=</span> <span class="bu">max</span>(verlauf.schlechtester_zustand,</span>
-<span id="cb100-207"><a href="#cb100-207" aria-hidden="true" tabindex="-1"></a>                                                kosten)</span>
-<span id="cb100-208"><a href="#cb100-208" aria-hidden="true" tabindex="-1"></a>            <span class="cf">if</span> kosten <span class="op">&lt;</span> beste_kosten:</span>
-<span id="cb100-209"><a href="#cb100-209" aria-hidden="true" tabindex="-1"></a>                beste, beste_kosten <span class="op">=</span> reihe[:], kosten</span>
-<span id="cb100-210"><a href="#cb100-210" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb100-211"><a href="#cb100-211" aria-hidden="true" tabindex="-1"></a>    verlauf.sekunden <span class="op">=</span> time.perf_counter() <span class="op">-</span> start</span>
-<span id="cb100-212"><a href="#cb100-212" aria-hidden="true" tabindex="-1"></a>    <span class="cf">return</span> beste, beste_kosten, verlauf</span>
-<span id="cb100-213"><a href="#cb100-213" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb100-214"><a href="#cb100-214" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb100-215"><a href="#cb100-215" aria-hidden="true" tabindex="-1"></a><span class="cf">if</span> <span class="va">__name__</span> <span class="op">==</span> <span class="st">&quot;__main__&quot;</span>:</span>
-<span id="cb100-216"><a href="#cb100-216" aria-hidden="true" tabindex="-1"></a>    N <span class="op">=</span> <span class="dv">200</span></span>
-<span id="cb100-217"><a href="#cb100-217" aria-hidden="true" tabindex="-1"></a>    matrix <span class="op">=</span> erzeuge_ruestmatrix(N)</span>
-<span id="cb100-218"><a href="#cb100-218" aria-hidden="true" tabindex="-1"></a>    start_reihe <span class="op">=</span> faustregel(matrix)</span>
-<span id="cb100-219"><a href="#cb100-219" aria-hidden="true" tabindex="-1"></a>    start_kosten <span class="op">=</span> gesamtruestzeit(start_reihe, matrix)</span>
-<span id="cb100-220"><a href="#cb100-220" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb100-221"><a href="#cb100-221" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;=&quot;</span> <span class="op">*</span> <span class="dv">78</span>)</span>
-<span id="cb100-222"><a href="#cb100-222" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;  SIMULATED ANNEALING AN DER LACKIERANLAGE&quot;</span>)</span>
-<span id="cb100-223"><a href="#cb100-223" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;=&quot;</span> <span class="op">*</span> <span class="dv">78</span>)</span>
-<span id="cb100-224"><a href="#cb100-224" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;</span><span class="sc">{</span>N<span class="sc">}</span><span class="ss"> Auftraege, </span><span class="sc">{</span><span class="bu">max</span>(<span class="dv">6</span>, N <span class="op">//</span> <span class="dv">10</span>)<span class="sc">}</span><span class="ss"> Produktfamilien, &quot;</span></span>
-<span id="cb100-225"><a href="#cb100-225" aria-hidden="true" tabindex="-1"></a>          <span class="ss">f&quot;Zugbudget </span><span class="sc">{</span>ZUEGE<span class="sc">:,}</span><span class="ss"> je Lauf.</span><span class="ch">\n</span><span class="ss">&quot;</span>)</span>
-<span id="cb100-226"><a href="#cb100-226" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;Faustregel &#39;billigster naechster Auftrag&#39;: &quot;</span></span>
-<span id="cb100-227"><a href="#cb100-227" aria-hidden="true" tabindex="-1"></a>          <span class="ss">f&quot;</span><span class="sc">{</span>start_kosten<span class="sc">:,}</span><span class="ss"> Minuten Ruestzeit&quot;</span>)</span>
-<span id="cb100-228"><a href="#cb100-228" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb100-229"><a href="#cb100-229" aria-hidden="true" tabindex="-1"></a>    <span class="co"># --- Wie gross sind die Zuege ueberhaupt? ---------------------------</span></span>
-<span id="cb100-230"><a href="#cb100-230" aria-hidden="true" tabindex="-1"></a>    <span class="co"># Ohne diese Zahl kann man die Temperatur nicht waehlen: Das</span></span>
-<span id="cb100-231"><a href="#cb100-231" aria-hidden="true" tabindex="-1"></a>    <span class="co"># Metropolis-Kriterium vergleicht die Verschlechterung MIT der Temperatur.</span></span>
-<span id="cb100-232"><a href="#cb100-232" aria-hidden="true" tabindex="-1"></a>    rng <span class="op">=</span> np.random.default_rng(<span class="dv">0</span>)</span>
-<span id="cb100-233"><a href="#cb100-233" aria-hidden="true" tabindex="-1"></a>    stichprobe <span class="op">=</span> []</span>
-<span id="cb100-234"><a href="#cb100-234" aria-hidden="true" tabindex="-1"></a>    <span class="cf">for</span> _ <span class="kw">in</span> <span class="bu">range</span>(<span class="dv">5000</span>):</span>
-<span id="cb100-235"><a href="#cb100-235" aria-hidden="true" tabindex="-1"></a>        e <span class="op">=</span> delta_verschieben(start_reihe, matrix,</span>
-<span id="cb100-236"><a href="#cb100-236" aria-hidden="true" tabindex="-1"></a>                              <span class="bu">int</span>(rng.integers(<span class="dv">0</span>, N)), <span class="bu">int</span>(rng.integers(<span class="dv">0</span>, N <span class="op">+</span> <span class="dv">1</span>)))</span>
-<span id="cb100-237"><a href="#cb100-237" aria-hidden="true" tabindex="-1"></a>        <span class="cf">if</span> e:</span>
-<span id="cb100-238"><a href="#cb100-238" aria-hidden="true" tabindex="-1"></a>            stichprobe.append(<span class="bu">abs</span>(e[<span class="dv">0</span>]))</span>
-<span id="cb100-239"><a href="#cb100-239" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;Typische Zuggroesse |Delta|: Median </span><span class="sc">{</span>np<span class="sc">.</span>median(stichprobe)<span class="sc">:.0f}</span><span class="ss">, &quot;</span></span>
-<span id="cb100-240"><a href="#cb100-240" aria-hidden="true" tabindex="-1"></a>          <span class="ss">f&quot;90 %-Quantil </span><span class="sc">{</span>np<span class="sc">.</span>quantile(stichprobe, <span class="fl">0.9</span>)<span class="sc">:.0f}</span><span class="ss"> Minuten&quot;</span>)</span>
-<span id="cb100-241"><a href="#cb100-241" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb100-242"><a href="#cb100-242" aria-hidden="true" tabindex="-1"></a>    <span class="co"># --- Bergsteigen gegen Annealing -------------------------------------</span></span>
-<span id="cb100-243"><a href="#cb100-243" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;</span><span class="ch">\n</span><span class="st">&quot;</span> <span class="op">+</span> <span class="st">&quot;-&quot;</span> <span class="op">*</span> <span class="dv">78</span>)</span>
-<span id="cb100-244"><a href="#cb100-244" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;Nur Verbesserungen annehmen (Bergsteigen) gegen Annealing:</span><span class="ch">\n</span><span class="st">&quot;</span>)</span>
-<span id="cb100-245"><a href="#cb100-245" aria-hidden="true" tabindex="-1"></a>    _, berg, berg_verlauf <span class="op">=</span> suche(matrix, ZUEGE, <span class="fl">1.0</span>, bergsteigen<span class="op">=</span><span class="va">True</span>)</span>
-<span id="cb100-246"><a href="#cb100-246" aria-hidden="true" tabindex="-1"></a>    _, gluehen, gluehen_verlauf <span class="op">=</span> suche(matrix, ZUEGE, <span class="fl">1.0</span>)</span>
-<span id="cb100-247"><a href="#cb100-247" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;  </span><span class="sc">{</span><span class="st">&#39;Faustregel (Start)&#39;</span><span class="sc">:&lt;34}</span><span class="ss"> </span><span class="sc">{</span>start_kosten<span class="sc">:&gt;7,}</span><span class="ss"> Minuten&quot;</span>)</span>
-<span id="cb100-248"><a href="#cb100-248" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;  </span><span class="sc">{</span><span class="st">&#39;Bergsteigen&#39;</span><span class="sc">:&lt;34}</span><span class="ss"> </span><span class="sc">{</span>berg<span class="sc">:&gt;7,}</span><span class="ss"> Minuten  &quot;</span></span>
-<span id="cb100-249"><a href="#cb100-249" aria-hidden="true" tabindex="-1"></a>          <span class="ss">f&quot;(</span><span class="sc">{</span>(start_kosten <span class="op">-</span> berg) <span class="op">/</span> start_kosten <span class="op">*</span> <span class="dv">100</span><span class="sc">:5.1f}</span><span class="ss"> % besser)&quot;</span>)</span>
-<span id="cb100-250"><a href="#cb100-250" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;  </span><span class="sc">{</span><span class="st">&#39;Simulated Annealing&#39;</span><span class="sc">:&lt;34}</span><span class="ss"> </span><span class="sc">{</span>gluehen<span class="sc">:&gt;7,}</span><span class="ss"> Minuten  &quot;</span></span>
-<span id="cb100-251"><a href="#cb100-251" aria-hidden="true" tabindex="-1"></a>          <span class="ss">f&quot;(</span><span class="sc">{</span>(start_kosten <span class="op">-</span> gluehen) <span class="op">/</span> start_kosten <span class="op">*</span> <span class="dv">100</span><span class="sc">:5.1f}</span><span class="ss"> % besser)&quot;</span>)</span>
-<span id="cb100-252"><a href="#cb100-252" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;</span><span class="ch">\n</span><span class="ss">  Beide pruefen genau </span><span class="sc">{</span>berg_verlauf<span class="sc">.</span>schritte<span class="sc">:,}</span><span class="ss"> Zuege &quot;</span></span>
-<span id="cb100-253"><a href="#cb100-253" aria-hidden="true" tabindex="-1"></a>          <span class="ss">f&quot;(</span><span class="sc">{</span>berg_verlauf<span class="sc">.</span>sekunden<span class="sc">:.1f}</span><span class="ss"> bzw. </span><span class="sc">{</span>gluehen_verlauf<span class="sc">.</span>sekunden<span class="sc">:.1f}</span><span class="ss"> Sekunden).&quot;</span>)</span>
-<span id="cb100-254"><a href="#cb100-254" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;  Annealing nimmt davon </span><span class="sc">{</span>gluehen_verlauf<span class="sc">.</span>annahmequote <span class="op">*</span> <span class="dv">100</span><span class="sc">:.2f}</span><span class="ss"> % der &quot;</span></span>
-<span id="cb100-255"><a href="#cb100-255" aria-hidden="true" tabindex="-1"></a>          <span class="ss">f&quot;VERSCHLECHTERUNGEN an, Bergsteigen keine.&quot;</span>)</span>
-<span id="cb100-256"><a href="#cb100-256" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;</span><span class="ch">\n</span><span class="st">  Bemerkenswert ist, wie klein der Abstand ist: Das simple&quot;</span>)</span>
-<span id="cb100-257"><a href="#cb100-257" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;  Bergsteigen holt hier bereits </span><span class="sc">{</span>(start_kosten <span class="op">-</span> berg) <span class="op">/</span> (start_kosten <span class="op">-</span> gluehen) <span class="op">*</span> <span class="dv">100</span><span class="sc">:.0f}</span><span class="ss"> % dessen, was Annealing&quot;</span>)</span>
-<span id="cb100-258"><a href="#cb100-258" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;  schafft. Wer eine Metaheuristik einsetzt, sollte diesen Vergleich&quot;</span>)</span>
-<span id="cb100-259"><a href="#cb100-259" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;  IMMER mitrechnen - sonst schreibt man einer aufwendigen Methode&quot;</span>)</span>
-<span id="cb100-260"><a href="#cb100-260" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;  gut, was schon die einfache geliefert haette.&quot;</span>)</span>
-<span id="cb100-261"><a href="#cb100-261" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb100-262"><a href="#cb100-262" aria-hidden="true" tabindex="-1"></a>    <span class="co"># --- Die Temperatur ist kein Beiwerk ---------------------------------</span></span>
-<span id="cb100-263"><a href="#cb100-263" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;</span><span class="ch">\n</span><span class="st">&quot;</span> <span class="op">+</span> <span class="st">&quot;-&quot;</span> <span class="op">*</span> <span class="dv">78</span>)</span>
-<span id="cb100-264"><a href="#cb100-264" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;Und warum die Starttemperatur ausgemessen gehoert:</span><span class="ch">\n</span><span class="st">&quot;</span>)</span>
-<span id="cb100-265"><a href="#cb100-265" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;  </span><span class="sc">{</span><span class="st">&#39;Start-T&#39;</span><span class="sc">:&gt;8}</span><span class="ss"> </span><span class="sc">{</span><span class="st">&#39;Ruestzeit&#39;</span><span class="sc">:&gt;11}</span><span class="ss"> </span><span class="sc">{</span><span class="st">&#39;gg. Faustregel&#39;</span><span class="sc">:&gt;15}</span><span class="ss"> &quot;</span></span>
-<span id="cb100-266"><a href="#cb100-266" aria-hidden="true" tabindex="-1"></a>          <span class="ss">f&quot;</span><span class="sc">{</span><span class="st">&#39;angenommene&#39;</span><span class="sc">:&gt;12}</span><span class="ss"> </span><span class="sc">{</span><span class="st">&#39;schlechtester&#39;</span><span class="sc">:&gt;14}</span><span class="ss">&quot;</span>)</span>
-<span id="cb100-267"><a href="#cb100-267" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;  </span><span class="sc">{</span><span class="st">&#39;&#39;</span><span class="sc">:&gt;8}</span><span class="ss"> </span><span class="sc">{</span><span class="st">&#39;&#39;</span><span class="sc">:&gt;11}</span><span class="ss"> </span><span class="sc">{</span><span class="st">&#39;&#39;</span><span class="sc">:&gt;15}</span><span class="ss"> </span><span class="sc">{</span><span class="st">&#39;Verschlecht.&#39;</span><span class="sc">:&gt;12}</span><span class="ss"> </span><span class="sc">{</span><span class="st">&#39;Zwischenwert&#39;</span><span class="sc">:&gt;14}</span><span class="ss">&quot;</span>)</span>
-<span id="cb100-268"><a href="#cb100-268" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;  &quot;</span> <span class="op">+</span> <span class="st">&quot;-&quot;</span> <span class="op">*</span> <span class="dv">64</span>)</span>
-<span id="cb100-269"><a href="#cb100-269" aria-hidden="true" tabindex="-1"></a>    ergebnisse, verlaeufe <span class="op">=</span> {}, {}</span>
-<span id="cb100-270"><a href="#cb100-270" aria-hidden="true" tabindex="-1"></a>    <span class="cf">for</span> temperatur <span class="kw">in</span> (<span class="fl">0.5</span>, <span class="fl">1.0</span>, <span class="fl">2.0</span>, <span class="fl">4.0</span>, <span class="fl">8.0</span>):</span>
-<span id="cb100-271"><a href="#cb100-271" aria-hidden="true" tabindex="-1"></a>        _, wert, verlauf <span class="op">=</span> suche(matrix, ZUEGE, temperatur)</span>
-<span id="cb100-272"><a href="#cb100-272" aria-hidden="true" tabindex="-1"></a>        ergebnisse[temperatur] <span class="op">=</span> wert</span>
-<span id="cb100-273"><a href="#cb100-273" aria-hidden="true" tabindex="-1"></a>        verlaeufe[temperatur] <span class="op">=</span> verlauf</span>
-<span id="cb100-274"><a href="#cb100-274" aria-hidden="true" tabindex="-1"></a>        gewinn <span class="op">=</span> (start_kosten <span class="op">-</span> wert) <span class="op">/</span> start_kosten <span class="op">*</span> <span class="dv">100</span></span>
-<span id="cb100-275"><a href="#cb100-275" aria-hidden="true" tabindex="-1"></a>        <span class="bu">print</span>(<span class="ss">f&quot;  </span><span class="sc">{</span>temperatur<span class="sc">:&gt;8.1f}</span><span class="ss"> </span><span class="sc">{</span>wert<span class="sc">:&gt;11,}</span><span class="ss"> </span><span class="sc">{</span>gewinn<span class="sc">:&gt;13.1f}</span><span class="ss"> % &quot;</span></span>
-<span id="cb100-276"><a href="#cb100-276" aria-hidden="true" tabindex="-1"></a>              <span class="ss">f&quot;</span><span class="sc">{</span>verlauf<span class="sc">.</span>annahmequote <span class="op">*</span> <span class="dv">100</span><span class="sc">:&gt;11.2f}</span><span class="ss"> % &quot;</span></span>
-<span id="cb100-277"><a href="#cb100-277" aria-hidden="true" tabindex="-1"></a>              <span class="ss">f&quot;</span><span class="sc">{</span>verlauf<span class="sc">.</span>schlechtester_zustand<span class="sc">:&gt;14,}</span><span class="ss">&quot;</span>)</span>
-<span id="cb100-278"><a href="#cb100-278" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb100-279"><a href="#cb100-279" aria-hidden="true" tabindex="-1"></a>    beste_temperatur <span class="op">=</span> <span class="bu">min</span>(ergebnisse, key<span class="op">=</span>ergebnisse.get)</span>
-<span id="cb100-280"><a href="#cb100-280" aria-hidden="true" tabindex="-1"></a>    heiss <span class="op">=</span> verlaeufe[<span class="fl">8.0</span>]</span>
-<span id="cb100-281"><a href="#cb100-281" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;</span><span class="ch">\n</span><span class="ss">  Bester Wert bei T0 = </span><span class="sc">{</span>beste_temperatur<span class="sc">}</span><span class="ss">.&quot;</span>)</span>
-<span id="cb100-282"><a href="#cb100-282" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;</span><span class="ch">\n</span><span class="st">  Die letzten beiden Spalten erklaeren, warum es nach oben kippt.&quot;</span>)</span>
-<span id="cb100-283"><a href="#cb100-283" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;  Bei T0 = 8 gehen nur </span><span class="sc">{</span>heiss<span class="sc">.</span>annahmequote <span class="op">*</span> <span class="dv">100</span><span class="sc">:.2f}</span><span class="ss"> % der Verschlechterungen&quot;</span>)</span>
-<span id="cb100-284"><a href="#cb100-284" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;  durch - wenig genug, dass man es fuer harmlos halten koennte. Es&quot;</span>)</span>
-<span id="cb100-285"><a href="#cb100-285" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;  genuegt aber: Die Suche driftet bis auf </span><span class="sc">{</span>heiss<span class="sc">.</span>schlechtester_zustand<span class="sc">:,}</span><span class="ss"> Minuten ab, das&quot;</span>)</span>
-<span id="cb100-286"><a href="#cb100-286" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;  </span><span class="sc">{</span>heiss<span class="sc">.</span>schlechtester_zustand <span class="op">/</span> start_kosten<span class="sc">:.1f}</span><span class="ss">-fache der Startloesung, und findet im Zugbudget nicht&quot;</span>)</span>
-<span id="cb100-287"><a href="#cb100-287" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;  mehr zurueck. Vom Ergebnis bleibt fast nichts uebrig: Die Suche hat&quot;</span>)</span>
-<span id="cb100-288"><a href="#cb100-288" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;  in </span><span class="sc">{</span>ZUEGE<span class="sc">:,}</span><span class="ss"> Zuegen nie etwas GESEHEN, das mehr als&quot;</span>)</span>
-<span id="cb100-289"><a href="#cb100-289" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;  </span><span class="sc">{</span>(start_kosten <span class="op">-</span> ergebnisse[<span class="fl">8.0</span>]) <span class="op">/</span> start_kosten <span class="op">*</span> <span class="dv">100</span><span class="sc">:.1f}</span><span class="ss"> % unter der Startloesung lag.&quot;</span>)</span>
-<span id="cb100-290"><a href="#cb100-290" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;</span><span class="ch">\n</span><span class="st">  Bemerkenswert ist die andere Richtung: Die besten Werte entstehen&quot;</span>)</span>
-<span id="cb100-291"><a href="#cb100-291" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;  bei Annahmequoten nahe null. Die Lehrbuchregel &#39;anfangs sollen&quot;</span>)</span>
-<span id="cb100-292"><a href="#cb100-292" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;  20 bis 50 Prozent der Verschlechterungen durchgehen&#39; fuehrt hier in&quot;</span>)</span>
-<span id="cb100-293"><a href="#cb100-293" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;  die Irre - sie stammt aus Problemen mit sehr kleinen Zuggroessen.&quot;</span>)</span>
-<span id="cb100-294"><a href="#cb100-294" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;  Bei Ruestzeiten in Minuten ist ein einziger schlechter Zug teuer.&quot;</span>)</span>
-<span id="cb100-295"><a href="#cb100-295" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;</span><span class="ch">\n</span><span class="st">  Was stattdessen traegt: Den SCHLECHTESTEN Zwischenwert protokollieren&quot;</span>)</span>
-<span id="cb100-296"><a href="#cb100-296" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;  und T0 so waehlen, dass er die Startloesung nicht wesentlich&quot;</span>)</span>
-<span id="cb100-297"><a href="#cb100-297" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;  ueberschreitet. Diese eine Zahl haette hier auf Anhieb gezeigt, dass&quot;</span>)</span>
-<span id="cb100-298"><a href="#cb100-298" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;  T0 = 8 unbrauchbar ist - ohne dass man das Endergebnis abwarten muss.&quot;</span>)</span>
-<span id="cb100-299"><a href="#cb100-299" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;=&quot;</span> <span class="op">*</span> <span class="dv">78</span>)</span></code></pre></div>
+<div class="sourceCode" id="cb102"><pre class="sourceCode python"><code class="sourceCode python"><span id="cb102-1"><a href="#cb102-1" aria-hidden="true" tabindex="-1"></a><span class="co">#!/usr/bin/env python3</span></span>
+<span id="cb102-2"><a href="#cb102-2" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb102-3"><a href="#cb102-3" aria-hidden="true" tabindex="-1"></a><span class="co"># Simulated_Annealing.py</span></span>
+<span id="cb102-4"><a href="#cb102-4" aria-hidden="true" tabindex="-1"></a><span class="co">&quot;&quot;&quot;</span></span>
+<span id="cb102-5"><a href="#cb102-5" aria-hidden="true" tabindex="-1"></a><span class="co">Kapitel Metaheuristiken: Simulated Annealing an der Lackieranlage.</span></span>
+<span id="cb102-6"><a href="#cb102-6" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb102-7"><a href="#cb102-7" aria-hidden="true" tabindex="-1"></a><span class="co">Aufgabe: n Auftraege in eine Reihenfolge bringen. Zwischen zwei Auftraegen</span></span>
+<span id="cb102-8"><a href="#cb102-8" aria-hidden="true" tabindex="-1"></a><span class="co">faellt eine Ruestzeit an - die Anlage muss gereinigt werden. Wie lange das</span></span>
+<span id="cb102-9"><a href="#cb102-9" aria-hidden="true" tabindex="-1"></a><span class="co">dauert, haengt von BEIDEN Auftraegen ab: Ein Wechsel innerhalb derselben</span></span>
+<span id="cb102-10"><a href="#cb102-10" aria-hidden="true" tabindex="-1"></a><span class="co">Produktfamilie kostet fast nichts, ein Wechsel von Dunkel nach Hell ist teuer,</span></span>
+<span id="cb102-11"><a href="#cb102-11" aria-hidden="true" tabindex="-1"></a><span class="co">und zwischen manchen Familien ist der Reinigungsaufwand schlicht hoch. Gesucht</span></span>
+<span id="cb102-12"><a href="#cb102-12" aria-hidden="true" tabindex="-1"></a><span class="co">ist die Reihenfolge mit der kleinsten Summe der Ruestzeiten.</span></span>
+<span id="cb102-13"><a href="#cb102-13" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb102-14"><a href="#cb102-14" aria-hidden="true" tabindex="-1"></a><span class="co">Das Programm zeigt drei Dinge:</span></span>
+<span id="cb102-15"><a href="#cb102-15" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb102-16"><a href="#cb102-16" aria-hidden="true" tabindex="-1"></a><span class="co">  1. Warum die Faustregel &quot;immer der billigste naechste Auftrag&quot; in eine</span></span>
+<span id="cb102-17"><a href="#cb102-17" aria-hidden="true" tabindex="-1"></a><span class="co">     Sackgasse laeuft - und wie weit man sie mit lokaler Suche verbessert.</span></span>
+<span id="cb102-18"><a href="#cb102-18" aria-hidden="true" tabindex="-1"></a><span class="co">  2. Wie gross der Beitrag der Verschlechterungen WIRKLICH ist. Die Antwort</span></span>
+<span id="cb102-19"><a href="#cb102-19" aria-hidden="true" tabindex="-1"></a><span class="co">     faellt bescheidener aus als das Lehrbuch verspricht, und genau das ist</span></span>
+<span id="cb102-20"><a href="#cb102-20" aria-hidden="true" tabindex="-1"></a><span class="co">     der Grund, den Vergleich immer mitzurechnen.</span></span>
+<span id="cb102-21"><a href="#cb102-21" aria-hidden="true" tabindex="-1"></a><span class="co">  3. Dass die Starttemperatur kein Beiwerk ist: zu heiss macht die Suche</span></span>
+<span id="cb102-22"><a href="#cb102-22" aria-hidden="true" tabindex="-1"></a><span class="co">     nutzlos, und man sieht es an einer einzigen Kennzahl kommen.</span></span>
+<span id="cb102-23"><a href="#cb102-23" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb102-24"><a href="#cb102-24" aria-hidden="true" tabindex="-1"></a><span class="co">Zum Budget: Der Abkuehlplan laeuft ueber eine feste ZUGZAHL, nicht ueber eine</span></span>
+<span id="cb102-25"><a href="#cb102-25" aria-hidden="true" tabindex="-1"></a><span class="co">Sekundenzahl. Im Betrieb hat man zwar ein Zeitbudget - fuer einen VERGLEICH ist</span></span>
+<span id="cb102-26"><a href="#cb102-26" aria-hidden="true" tabindex="-1"></a><span class="co">die Zugzahl aber das ehrlichere Mass: Sie ist auf jeder Maschine dieselbe, und</span></span>
+<span id="cb102-27"><a href="#cb102-27" aria-hidden="true" tabindex="-1"></a><span class="co">die abgedruckten Zahlen unten lassen sich damit nachrechnen. Die gemessene</span></span>
+<span id="cb102-28"><a href="#cb102-28" aria-hidden="true" tabindex="-1"></a><span class="co">Laufzeit steht trotzdem dabei.</span></span>
+<span id="cb102-29"><a href="#cb102-29" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb102-30"><a href="#cb102-30" aria-hidden="true" tabindex="-1"></a><span class="co">Benoetigt: numpy</span></span>
+<span id="cb102-31"><a href="#cb102-31" aria-hidden="true" tabindex="-1"></a><span class="co">&quot;&quot;&quot;</span></span>
+<span id="cb102-32"><a href="#cb102-32" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb102-33"><a href="#cb102-33" aria-hidden="true" tabindex="-1"></a><span class="im">from</span> __future__ <span class="im">import</span> annotations</span>
+<span id="cb102-34"><a href="#cb102-34" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb102-35"><a href="#cb102-35" aria-hidden="true" tabindex="-1"></a><span class="im">import</span> math</span>
+<span id="cb102-36"><a href="#cb102-36" aria-hidden="true" tabindex="-1"></a><span class="im">import</span> time</span>
+<span id="cb102-37"><a href="#cb102-37" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb102-38"><a href="#cb102-38" aria-hidden="true" tabindex="-1"></a><span class="im">import</span> numpy <span class="im">as</span> np</span>
+<span id="cb102-39"><a href="#cb102-39" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb102-40"><a href="#cb102-40" aria-hidden="true" tabindex="-1"></a>ZUEGE <span class="op">=</span> <span class="dv">400_000</span>           <span class="co"># Zugbudget je Lauf (statt Sekunden: reproduzierbar)</span></span>
+<span id="cb102-41"><a href="#cb102-41" aria-hidden="true" tabindex="-1"></a>SAAT <span class="op">=</span> <span class="dv">11</span>                 <span class="co"># feste Saat -&gt; reproduzierbare Instanz</span></span>
+<span id="cb102-42"><a href="#cb102-42" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb102-43"><a href="#cb102-43" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb102-44"><a href="#cb102-44" aria-hidden="true" tabindex="-1"></a><span class="co"># --- 1. Die Instanz ---------------------------------------------------------</span></span>
+<span id="cb102-45"><a href="#cb102-45" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb102-46"><a href="#cb102-46" aria-hidden="true" tabindex="-1"></a><span class="kw">def</span> erzeuge_ruestmatrix(n: <span class="bu">int</span>, saat: <span class="bu">int</span> <span class="op">=</span> SAAT) <span class="op">-&gt;</span> np.ndarray:</span>
+<span id="cb102-47"><a href="#cb102-47" aria-hidden="true" tabindex="-1"></a>    <span class="co">&quot;&quot;&quot;Ruestzeiten in Minuten zwischen je zwei Auftraegen.</span></span>
+<span id="cb102-48"><a href="#cb102-48" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb102-49"><a href="#cb102-49" aria-hidden="true" tabindex="-1"></a><span class="co">    Die Zahl der Produktfamilien waechst mit der Auftragszahl (eine Familie je</span></span>
+<span id="cb102-50"><a href="#cb102-50" aria-hidden="true" tabindex="-1"></a><span class="co">    zehn Auftraege). Sonst wuerde das Problem mit wachsendem n LEICHTER: Bei</span></span>
+<span id="cb102-51"><a href="#cb102-51" aria-hidden="true" tabindex="-1"></a><span class="co">    fester Familienzahl haette der Plan irgendwann nur noch ein paar grosse</span></span>
+<span id="cb102-52"><a href="#cb102-52" aria-hidden="true" tabindex="-1"></a><span class="co">    Bloecke, und jede Faustregel faende ihn.</span></span>
+<span id="cb102-53"><a href="#cb102-53" aria-hidden="true" tabindex="-1"></a><span class="co">    &quot;&quot;&quot;</span></span>
+<span id="cb102-54"><a href="#cb102-54" aria-hidden="true" tabindex="-1"></a>    rng <span class="op">=</span> np.random.default_rng(saat)</span>
+<span id="cb102-55"><a href="#cb102-55" aria-hidden="true" tabindex="-1"></a>    familien <span class="op">=</span> <span class="bu">max</span>(<span class="dv">6</span>, n <span class="op">//</span> <span class="dv">10</span>)</span>
+<span id="cb102-56"><a href="#cb102-56" aria-hidden="true" tabindex="-1"></a>    <span class="co"># Reinigungsaufwand zwischen den Familien - unregelmaessig und asymmetrisch,</span></span>
+<span id="cb102-57"><a href="#cb102-57" aria-hidden="true" tabindex="-1"></a>    <span class="co"># so wie im Betrieb: Von Klarlack auf Rot ist etwas anderes als umgekehrt.</span></span>
+<span id="cb102-58"><a href="#cb102-58" aria-hidden="true" tabindex="-1"></a>    zwischen <span class="op">=</span> rng.integers(<span class="dv">8</span>, <span class="dv">60</span>, (familien, familien))</span>
+<span id="cb102-59"><a href="#cb102-59" aria-hidden="true" tabindex="-1"></a>    np.fill_diagonal(zwischen, <span class="dv">2</span>)</span>
+<span id="cb102-60"><a href="#cb102-60" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb102-61"><a href="#cb102-61" aria-hidden="true" tabindex="-1"></a>    familie <span class="op">=</span> rng.integers(<span class="dv">0</span>, familien, n)</span>
+<span id="cb102-62"><a href="#cb102-62" aria-hidden="true" tabindex="-1"></a>    farbe <span class="op">=</span> rng.integers(<span class="dv">0</span>, <span class="dv">10</span>, n)          <span class="co"># 0 = weiss ... 9 = schwarz</span></span>
+<span id="cb102-63"><a href="#cb102-63" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb102-64"><a href="#cb102-64" aria-hidden="true" tabindex="-1"></a>    matrix <span class="op">=</span> np.zeros((n, n), dtype<span class="op">=</span>np.int64)</span>
+<span id="cb102-65"><a href="#cb102-65" aria-hidden="true" tabindex="-1"></a>    <span class="cf">for</span> i <span class="kw">in</span> <span class="bu">range</span>(n):</span>
+<span id="cb102-66"><a href="#cb102-66" aria-hidden="true" tabindex="-1"></a>        <span class="cf">for</span> j <span class="kw">in</span> <span class="bu">range</span>(n):</span>
+<span id="cb102-67"><a href="#cb102-67" aria-hidden="true" tabindex="-1"></a>            <span class="cf">if</span> i <span class="op">!=</span> j:</span>
+<span id="cb102-68"><a href="#cb102-68" aria-hidden="true" tabindex="-1"></a>                <span class="co"># Dunkel -&gt; hell kostet zusaetzlich: die Anlage muss heller</span></span>
+<span id="cb102-69"><a href="#cb102-69" aria-hidden="true" tabindex="-1"></a>                <span class="co"># werden, das braucht mehr Spuelgaenge.</span></span>
+<span id="cb102-70"><a href="#cb102-70" aria-hidden="true" tabindex="-1"></a>                matrix[i, j] <span class="op">=</span> (zwischen[familie[i], familie[j]]</span>
+<span id="cb102-71"><a href="#cb102-71" aria-hidden="true" tabindex="-1"></a>                                <span class="op">+</span> <span class="dv">3</span> <span class="op">*</span> <span class="bu">max</span>(<span class="dv">0</span>, farbe[i] <span class="op">-</span> farbe[j]))</span>
+<span id="cb102-72"><a href="#cb102-72" aria-hidden="true" tabindex="-1"></a>    <span class="cf">return</span> matrix</span>
+<span id="cb102-73"><a href="#cb102-73" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb102-74"><a href="#cb102-74" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb102-75"><a href="#cb102-75" aria-hidden="true" tabindex="-1"></a><span class="kw">def</span> gesamtruestzeit(reihe: <span class="bu">list</span>[<span class="bu">int</span>], matrix: np.ndarray) <span class="op">-&gt;</span> <span class="bu">int</span>:</span>
+<span id="cb102-76"><a href="#cb102-76" aria-hidden="true" tabindex="-1"></a>    <span class="co">&quot;&quot;&quot;Summe der Ruestzeiten einer Reihenfolge (offene Kette, keine Rundreise).&quot;&quot;&quot;</span></span>
+<span id="cb102-77"><a href="#cb102-77" aria-hidden="true" tabindex="-1"></a>    <span class="cf">return</span> <span class="bu">int</span>(<span class="bu">sum</span>(matrix[reihe[k], reihe[k <span class="op">+</span> <span class="dv">1</span>]] <span class="cf">for</span> k <span class="kw">in</span> <span class="bu">range</span>(<span class="bu">len</span>(reihe) <span class="op">-</span> <span class="dv">1</span>)))</span>
+<span id="cb102-78"><a href="#cb102-78" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb102-79"><a href="#cb102-79" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb102-80"><a href="#cb102-80" aria-hidden="true" tabindex="-1"></a><span class="kw">def</span> faustregel(matrix: np.ndarray) <span class="op">-&gt;</span> <span class="bu">list</span>[<span class="bu">int</span>]:</span>
+<span id="cb102-81"><a href="#cb102-81" aria-hidden="true" tabindex="-1"></a>    <span class="co">&quot;&quot;&quot;Immer der billigste noch offene Auftrag - &#39;naechster Nachbar&#39;.</span></span>
+<span id="cb102-82"><a href="#cb102-82" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb102-83"><a href="#cb102-83" aria-hidden="true" tabindex="-1"></a><span class="co">    So plant ein Meister von Hand, und es ist keine schlechte Regel. Ihr Fehler</span></span>
+<span id="cb102-84"><a href="#cb102-84" aria-hidden="true" tabindex="-1"></a><span class="co">    ist die Kurzsichtigkeit: Sie spart am Anfang und laesst die teuren Wechsel</span></span>
+<span id="cb102-85"><a href="#cb102-85" aria-hidden="true" tabindex="-1"></a><span class="co">    fuer das Ende uebrig, wo keine Wahl mehr bleibt.</span></span>
+<span id="cb102-86"><a href="#cb102-86" aria-hidden="true" tabindex="-1"></a><span class="co">    &quot;&quot;&quot;</span></span>
+<span id="cb102-87"><a href="#cb102-87" aria-hidden="true" tabindex="-1"></a>    n <span class="op">=</span> <span class="bu">len</span>(matrix)</span>
+<span id="cb102-88"><a href="#cb102-88" aria-hidden="true" tabindex="-1"></a>    offen <span class="op">=</span> <span class="bu">set</span>(<span class="bu">range</span>(<span class="dv">1</span>, n))</span>
+<span id="cb102-89"><a href="#cb102-89" aria-hidden="true" tabindex="-1"></a>    reihe <span class="op">=</span> [<span class="dv">0</span>]</span>
+<span id="cb102-90"><a href="#cb102-90" aria-hidden="true" tabindex="-1"></a>    <span class="cf">while</span> offen:</span>
+<span id="cb102-91"><a href="#cb102-91" aria-hidden="true" tabindex="-1"></a>        naechster <span class="op">=</span> <span class="bu">min</span>(offen, key<span class="op">=</span><span class="kw">lambda</span> j: matrix[reihe[<span class="op">-</span><span class="dv">1</span>], j])</span>
+<span id="cb102-92"><a href="#cb102-92" aria-hidden="true" tabindex="-1"></a>        reihe.append(naechster)</span>
+<span id="cb102-93"><a href="#cb102-93" aria-hidden="true" tabindex="-1"></a>        offen.discard(naechster)</span>
+<span id="cb102-94"><a href="#cb102-94" aria-hidden="true" tabindex="-1"></a>    <span class="cf">return</span> reihe</span>
+<span id="cb102-95"><a href="#cb102-95" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb102-96"><a href="#cb102-96" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb102-97"><a href="#cb102-97" aria-hidden="true" tabindex="-1"></a><span class="co"># --- 2. Der Zug und seine Kostenaenderung -----------------------------------</span></span>
+<span id="cb102-98"><a href="#cb102-98" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb102-99"><a href="#cb102-99" aria-hidden="true" tabindex="-1"></a><span class="kw">def</span> delta_verschieben(reihe: <span class="bu">list</span>[<span class="bu">int</span>], matrix: np.ndarray,</span>
+<span id="cb102-100"><a href="#cb102-100" aria-hidden="true" tabindex="-1"></a>                      von: <span class="bu">int</span>, nach: <span class="bu">int</span>):</span>
+<span id="cb102-101"><a href="#cb102-101" aria-hidden="true" tabindex="-1"></a>    <span class="co">&quot;&quot;&quot;Auftrag von Position &#39;von&#39; an Position &#39;nach&#39; versetzen.</span></span>
+<span id="cb102-102"><a href="#cb102-102" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb102-103"><a href="#cb102-103" aria-hidden="true" tabindex="-1"></a><span class="co">    Liefert (Kostenaenderung, Restliste, Einfuegeposition) oder None, wenn der</span></span>
+<span id="cb102-104"><a href="#cb102-104" aria-hidden="true" tabindex="-1"></a><span class="co">    Zug nichts aendert.</span></span>
+<span id="cb102-105"><a href="#cb102-105" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb102-106"><a href="#cb102-106" aria-hidden="true" tabindex="-1"></a><span class="co">    DAS IST DIE WICHTIGSTE FUNKTION DES PROGRAMMS. Sie berechnet die</span></span>
+<span id="cb102-107"><a href="#cb102-107" aria-hidden="true" tabindex="-1"></a><span class="co">    Kostenaenderung aus HOECHSTENS SECHS Matrixeintraegen, statt die</span></span>
+<span id="cb102-108"><a href="#cb102-108" aria-hidden="true" tabindex="-1"></a><span class="co">    Reihenfolge neu durchzusummieren. Der Unterschied ist nicht kosmetisch:</span></span>
+<span id="cb102-109"><a href="#cb102-109" aria-hidden="true" tabindex="-1"></a><span class="co">    Die volle Summe kostet O(n) je Zug, diese Rechnung O(1). Bei 500 Auftraegen</span></span>
+<span id="cb102-110"><a href="#cb102-110" aria-hidden="true" tabindex="-1"></a><span class="co">    sind das rund 500-mal mehr geprueste Zuege im selben Zeitbudget - und eine</span></span>
+<span id="cb102-111"><a href="#cb102-111" aria-hidden="true" tabindex="-1"></a><span class="co">    Metaheuristik lebt von der Zahl der Zuege.</span></span>
+<span id="cb102-112"><a href="#cb102-112" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb102-113"><a href="#cb102-113" aria-hidden="true" tabindex="-1"></a><span class="co">    Herausgerissen wird der Auftrag aus zwei Kanten, seine Nachbarn ruecken</span></span>
+<span id="cb102-114"><a href="#cb102-114" aria-hidden="true" tabindex="-1"></a><span class="co">    zusammen (eine neue Kante). Eingefuegt wird er zwischen zwei andere</span></span>
+<span id="cb102-115"><a href="#cb102-115" aria-hidden="true" tabindex="-1"></a><span class="co">    Nachbarn, deren bisherige Kante dadurch verschwindet.</span></span>
+<span id="cb102-116"><a href="#cb102-116" aria-hidden="true" tabindex="-1"></a><span class="co">    &quot;&quot;&quot;</span></span>
+<span id="cb102-117"><a href="#cb102-117" aria-hidden="true" tabindex="-1"></a>    n <span class="op">=</span> <span class="bu">len</span>(reihe)</span>
+<span id="cb102-118"><a href="#cb102-118" aria-hidden="true" tabindex="-1"></a>    <span class="cf">if</span> von <span class="op">==</span> nach <span class="kw">or</span> nach <span class="op">==</span> von <span class="op">+</span> <span class="dv">1</span>:</span>
+<span id="cb102-119"><a href="#cb102-119" aria-hidden="true" tabindex="-1"></a>        <span class="cf">return</span> <span class="va">None</span></span>
+<span id="cb102-120"><a href="#cb102-120" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb102-121"><a href="#cb102-121" aria-hidden="true" tabindex="-1"></a>    heraus <span class="op">=</span> <span class="dv">0</span></span>
+<span id="cb102-122"><a href="#cb102-122" aria-hidden="true" tabindex="-1"></a>    <span class="cf">if</span> von <span class="op">&gt;</span> <span class="dv">0</span>:</span>
+<span id="cb102-123"><a href="#cb102-123" aria-hidden="true" tabindex="-1"></a>        heraus <span class="op">+=</span> matrix[reihe[von <span class="op">-</span> <span class="dv">1</span>], reihe[von]]</span>
+<span id="cb102-124"><a href="#cb102-124" aria-hidden="true" tabindex="-1"></a>    <span class="cf">if</span> von <span class="op">&lt;</span> n <span class="op">-</span> <span class="dv">1</span>:</span>
+<span id="cb102-125"><a href="#cb102-125" aria-hidden="true" tabindex="-1"></a>        heraus <span class="op">+=</span> matrix[reihe[von], reihe[von <span class="op">+</span> <span class="dv">1</span>]]</span>
+<span id="cb102-126"><a href="#cb102-126" aria-hidden="true" tabindex="-1"></a>    <span class="cf">if</span> <span class="dv">0</span> <span class="op">&lt;</span> von <span class="op">&lt;</span> n <span class="op">-</span> <span class="dv">1</span>:                       <span class="co"># die Nachbarn ruecken zusammen</span></span>
+<span id="cb102-127"><a href="#cb102-127" aria-hidden="true" tabindex="-1"></a>        heraus <span class="op">-=</span> matrix[reihe[von <span class="op">-</span> <span class="dv">1</span>], reihe[von <span class="op">+</span> <span class="dv">1</span>]]</span>
+<span id="cb102-128"><a href="#cb102-128" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb102-129"><a href="#cb102-129" aria-hidden="true" tabindex="-1"></a>    rest <span class="op">=</span> reihe[:von] <span class="op">+</span> reihe[von <span class="op">+</span> <span class="dv">1</span>:]</span>
+<span id="cb102-130"><a href="#cb102-130" aria-hidden="true" tabindex="-1"></a>    stelle <span class="op">=</span> nach <span class="cf">if</span> nach <span class="op">&lt;</span> von <span class="cf">else</span> nach <span class="op">-</span> <span class="dv">1</span></span>
+<span id="cb102-131"><a href="#cb102-131" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb102-132"><a href="#cb102-132" aria-hidden="true" tabindex="-1"></a>    hinein <span class="op">=</span> <span class="dv">0</span></span>
+<span id="cb102-133"><a href="#cb102-133" aria-hidden="true" tabindex="-1"></a>    <span class="cf">if</span> stelle <span class="op">&gt;</span> <span class="dv">0</span>:</span>
+<span id="cb102-134"><a href="#cb102-134" aria-hidden="true" tabindex="-1"></a>        hinein <span class="op">+=</span> matrix[rest[stelle <span class="op">-</span> <span class="dv">1</span>], reihe[von]]</span>
+<span id="cb102-135"><a href="#cb102-135" aria-hidden="true" tabindex="-1"></a>    <span class="cf">if</span> stelle <span class="op">&lt;</span> <span class="bu">len</span>(rest):</span>
+<span id="cb102-136"><a href="#cb102-136" aria-hidden="true" tabindex="-1"></a>        hinein <span class="op">+=</span> matrix[reihe[von], rest[stelle]]</span>
+<span id="cb102-137"><a href="#cb102-137" aria-hidden="true" tabindex="-1"></a>    <span class="cf">if</span> <span class="dv">0</span> <span class="op">&lt;</span> stelle <span class="op">&lt;</span> <span class="bu">len</span>(rest):                <span class="co"># die aufgetrennte Kante faellt weg</span></span>
+<span id="cb102-138"><a href="#cb102-138" aria-hidden="true" tabindex="-1"></a>        hinein <span class="op">-=</span> matrix[rest[stelle <span class="op">-</span> <span class="dv">1</span>], rest[stelle]]</span>
+<span id="cb102-139"><a href="#cb102-139" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb102-140"><a href="#cb102-140" aria-hidden="true" tabindex="-1"></a>    <span class="cf">return</span> <span class="bu">int</span>(hinein <span class="op">-</span> heraus), rest, stelle</span>
+<span id="cb102-141"><a href="#cb102-141" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb102-142"><a href="#cb102-142" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb102-143"><a href="#cb102-143" aria-hidden="true" tabindex="-1"></a><span class="co"># --- 3. Die Suche -----------------------------------------------------------</span></span>
+<span id="cb102-144"><a href="#cb102-144" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb102-145"><a href="#cb102-145" aria-hidden="true" tabindex="-1"></a><span class="kw">class</span> Verlauf:</span>
+<span id="cb102-146"><a href="#cb102-146" aria-hidden="true" tabindex="-1"></a>    <span class="co">&quot;&quot;&quot;Was ein Lauf ausser dem Ergebnis noch verraet.&quot;&quot;&quot;</span></span>
+<span id="cb102-147"><a href="#cb102-147" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb102-148"><a href="#cb102-148" aria-hidden="true" tabindex="-1"></a>    <span class="kw">def</span> <span class="fu">__init__</span>(<span class="va">self</span>) <span class="op">-&gt;</span> <span class="va">None</span>:</span>
+<span id="cb102-149"><a href="#cb102-149" aria-hidden="true" tabindex="-1"></a>        <span class="va">self</span>.schritte <span class="op">=</span> <span class="dv">0</span></span>
+<span id="cb102-150"><a href="#cb102-150" aria-hidden="true" tabindex="-1"></a>        <span class="va">self</span>.verschlechterungen_geprueft <span class="op">=</span> <span class="dv">0</span></span>
+<span id="cb102-151"><a href="#cb102-151" aria-hidden="true" tabindex="-1"></a>        <span class="va">self</span>.verschlechterungen_genommen <span class="op">=</span> <span class="dv">0</span></span>
+<span id="cb102-152"><a href="#cb102-152" aria-hidden="true" tabindex="-1"></a>        <span class="va">self</span>.schlechtester_zustand <span class="op">=</span> <span class="dv">0</span>      <span class="co"># wie weit die Suche abgedriftet ist</span></span>
+<span id="cb102-153"><a href="#cb102-153" aria-hidden="true" tabindex="-1"></a>        <span class="va">self</span>.sekunden <span class="op">=</span> <span class="fl">0.0</span>                 <span class="co"># nur zur Information, nicht zum Vergleich</span></span>
+<span id="cb102-154"><a href="#cb102-154" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb102-155"><a href="#cb102-155" aria-hidden="true" tabindex="-1"></a>    <span class="at">@property</span></span>
+<span id="cb102-156"><a href="#cb102-156" aria-hidden="true" tabindex="-1"></a>    <span class="kw">def</span> annahmequote(<span class="va">self</span>) <span class="op">-&gt;</span> <span class="bu">float</span>:</span>
+<span id="cb102-157"><a href="#cb102-157" aria-hidden="true" tabindex="-1"></a>        <span class="cf">if</span> <span class="kw">not</span> <span class="va">self</span>.verschlechterungen_geprueft:</span>
+<span id="cb102-158"><a href="#cb102-158" aria-hidden="true" tabindex="-1"></a>            <span class="cf">return</span> <span class="fl">0.0</span></span>
+<span id="cb102-159"><a href="#cb102-159" aria-hidden="true" tabindex="-1"></a>        <span class="cf">return</span> <span class="va">self</span>.verschlechterungen_genommen <span class="op">/</span> <span class="va">self</span>.verschlechterungen_geprueft</span>
+<span id="cb102-160"><a href="#cb102-160" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb102-161"><a href="#cb102-161" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb102-162"><a href="#cb102-162" aria-hidden="true" tabindex="-1"></a><span class="kw">def</span> suche(matrix: np.ndarray, zuege: <span class="bu">int</span>, start_temperatur: <span class="bu">float</span>,</span>
+<span id="cb102-163"><a href="#cb102-163" aria-hidden="true" tabindex="-1"></a>          end_temperatur: <span class="bu">float</span> <span class="op">=</span> <span class="fl">0.05</span>, saat: <span class="bu">int</span> <span class="op">=</span> <span class="dv">1</span>,</span>
+<span id="cb102-164"><a href="#cb102-164" aria-hidden="true" tabindex="-1"></a>          bergsteigen: <span class="bu">bool</span> <span class="op">=</span> <span class="va">False</span>) <span class="op">-&gt;</span> <span class="bu">tuple</span>[<span class="bu">list</span>[<span class="bu">int</span>], <span class="bu">int</span>, Verlauf]:</span>
+<span id="cb102-165"><a href="#cb102-165" aria-hidden="true" tabindex="-1"></a>    <span class="co">&quot;&quot;&quot;Simulated Annealing (oder reines Bergsteigen, wenn bergsteigen=True).</span></span>
+<span id="cb102-166"><a href="#cb102-166" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb102-167"><a href="#cb102-167" aria-hidden="true" tabindex="-1"></a><span class="co">    Der einzige Unterschied zwischen beiden steht in der Annahmezeile: Das</span></span>
+<span id="cb102-168"><a href="#cb102-168" aria-hidden="true" tabindex="-1"></a><span class="co">    Bergsteigen nimmt nur Verbesserungen, SA nimmt Verschlechterungen mit einer</span></span>
+<span id="cb102-169"><a href="#cb102-169" aria-hidden="true" tabindex="-1"></a><span class="co">    Wahrscheinlichkeit an, die mit der Zeit gegen null geht.</span></span>
+<span id="cb102-170"><a href="#cb102-170" aria-hidden="true" tabindex="-1"></a><span class="co">    &quot;&quot;&quot;</span></span>
+<span id="cb102-171"><a href="#cb102-171" aria-hidden="true" tabindex="-1"></a>    rng <span class="op">=</span> np.random.default_rng(saat)</span>
+<span id="cb102-172"><a href="#cb102-172" aria-hidden="true" tabindex="-1"></a>    n <span class="op">=</span> <span class="bu">len</span>(matrix)</span>
+<span id="cb102-173"><a href="#cb102-173" aria-hidden="true" tabindex="-1"></a>    reihe <span class="op">=</span> faustregel(matrix)</span>
+<span id="cb102-174"><a href="#cb102-174" aria-hidden="true" tabindex="-1"></a>    kosten <span class="op">=</span> gesamtruestzeit(reihe, matrix)</span>
+<span id="cb102-175"><a href="#cb102-175" aria-hidden="true" tabindex="-1"></a>    beste, beste_kosten <span class="op">=</span> reihe[:], kosten</span>
+<span id="cb102-176"><a href="#cb102-176" aria-hidden="true" tabindex="-1"></a>    verlauf <span class="op">=</span> Verlauf()</span>
+<span id="cb102-177"><a href="#cb102-177" aria-hidden="true" tabindex="-1"></a>    verlauf.schlechtester_zustand <span class="op">=</span> kosten</span>
+<span id="cb102-178"><a href="#cb102-178" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb102-179"><a href="#cb102-179" aria-hidden="true" tabindex="-1"></a>    start <span class="op">=</span> time.perf_counter()</span>
+<span id="cb102-180"><a href="#cb102-180" aria-hidden="true" tabindex="-1"></a>    <span class="cf">for</span> zug <span class="kw">in</span> <span class="bu">range</span>(zuege):</span>
+<span id="cb102-181"><a href="#cb102-181" aria-hidden="true" tabindex="-1"></a>        verlauf.schritte <span class="op">+=</span> <span class="dv">1</span></span>
+<span id="cb102-182"><a href="#cb102-182" aria-hidden="true" tabindex="-1"></a>        <span class="co"># Geometrischer Abkuehlplan ueber das Zugbudget.</span></span>
+<span id="cb102-183"><a href="#cb102-183" aria-hidden="true" tabindex="-1"></a>        temperatur <span class="op">=</span> start_temperatur <span class="op">*</span> (end_temperatur <span class="op">/</span> start_temperatur) <span class="op">\</span></span>
+<span id="cb102-184"><a href="#cb102-184" aria-hidden="true" tabindex="-1"></a>            <span class="op">**</span> (zug <span class="op">/</span> zuege)</span>
+<span id="cb102-185"><a href="#cb102-185" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb102-186"><a href="#cb102-186" aria-hidden="true" tabindex="-1"></a>        von <span class="op">=</span> <span class="bu">int</span>(rng.integers(<span class="dv">0</span>, n))</span>
+<span id="cb102-187"><a href="#cb102-187" aria-hidden="true" tabindex="-1"></a>        nach <span class="op">=</span> <span class="bu">int</span>(rng.integers(<span class="dv">0</span>, n <span class="op">+</span> <span class="dv">1</span>))</span>
+<span id="cb102-188"><a href="#cb102-188" aria-hidden="true" tabindex="-1"></a>        ergebnis <span class="op">=</span> delta_verschieben(reihe, matrix, von, nach)</span>
+<span id="cb102-189"><a href="#cb102-189" aria-hidden="true" tabindex="-1"></a>        <span class="cf">if</span> ergebnis <span class="kw">is</span> <span class="va">None</span>:</span>
+<span id="cb102-190"><a href="#cb102-190" aria-hidden="true" tabindex="-1"></a>            <span class="cf">continue</span></span>
+<span id="cb102-191"><a href="#cb102-191" aria-hidden="true" tabindex="-1"></a>        aenderung, rest, stelle <span class="op">=</span> ergebnis</span>
+<span id="cb102-192"><a href="#cb102-192" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb102-193"><a href="#cb102-193" aria-hidden="true" tabindex="-1"></a>        <span class="cf">if</span> aenderung <span class="op">&lt;=</span> <span class="dv">0</span>:</span>
+<span id="cb102-194"><a href="#cb102-194" aria-hidden="true" tabindex="-1"></a>            annehmen <span class="op">=</span> <span class="va">True</span></span>
+<span id="cb102-195"><a href="#cb102-195" aria-hidden="true" tabindex="-1"></a>        <span class="cf">else</span>:</span>
+<span id="cb102-196"><a href="#cb102-196" aria-hidden="true" tabindex="-1"></a>            verlauf.verschlechterungen_geprueft <span class="op">+=</span> <span class="dv">1</span></span>
+<span id="cb102-197"><a href="#cb102-197" aria-hidden="true" tabindex="-1"></a>            <span class="co"># Metropolis-Kriterium: je groesser die Verschlechterung und je</span></span>
+<span id="cb102-198"><a href="#cb102-198" aria-hidden="true" tabindex="-1"></a>            <span class="co"># kaelter es ist, desto unwahrscheinlicher.</span></span>
+<span id="cb102-199"><a href="#cb102-199" aria-hidden="true" tabindex="-1"></a>            annehmen <span class="op">=</span> (<span class="kw">not</span> bergsteigen</span>
+<span id="cb102-200"><a href="#cb102-200" aria-hidden="true" tabindex="-1"></a>                        <span class="kw">and</span> rng.random() <span class="op">&lt;</span> math.exp(<span class="op">-</span>aenderung <span class="op">/</span> temperatur))</span>
+<span id="cb102-201"><a href="#cb102-201" aria-hidden="true" tabindex="-1"></a>            verlauf.verschlechterungen_genommen <span class="op">+=</span> annehmen</span>
+<span id="cb102-202"><a href="#cb102-202" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb102-203"><a href="#cb102-203" aria-hidden="true" tabindex="-1"></a>        <span class="cf">if</span> annehmen:</span>
+<span id="cb102-204"><a href="#cb102-204" aria-hidden="true" tabindex="-1"></a>            reihe <span class="op">=</span> rest[:stelle] <span class="op">+</span> [reihe[von]] <span class="op">+</span> rest[stelle:]</span>
+<span id="cb102-205"><a href="#cb102-205" aria-hidden="true" tabindex="-1"></a>            kosten <span class="op">+=</span> aenderung</span>
+<span id="cb102-206"><a href="#cb102-206" aria-hidden="true" tabindex="-1"></a>            verlauf.schlechtester_zustand <span class="op">=</span> <span class="bu">max</span>(verlauf.schlechtester_zustand,</span>
+<span id="cb102-207"><a href="#cb102-207" aria-hidden="true" tabindex="-1"></a>                                                kosten)</span>
+<span id="cb102-208"><a href="#cb102-208" aria-hidden="true" tabindex="-1"></a>            <span class="cf">if</span> kosten <span class="op">&lt;</span> beste_kosten:</span>
+<span id="cb102-209"><a href="#cb102-209" aria-hidden="true" tabindex="-1"></a>                beste, beste_kosten <span class="op">=</span> reihe[:], kosten</span>
+<span id="cb102-210"><a href="#cb102-210" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb102-211"><a href="#cb102-211" aria-hidden="true" tabindex="-1"></a>    verlauf.sekunden <span class="op">=</span> time.perf_counter() <span class="op">-</span> start</span>
+<span id="cb102-212"><a href="#cb102-212" aria-hidden="true" tabindex="-1"></a>    <span class="cf">return</span> beste, beste_kosten, verlauf</span>
+<span id="cb102-213"><a href="#cb102-213" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb102-214"><a href="#cb102-214" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb102-215"><a href="#cb102-215" aria-hidden="true" tabindex="-1"></a><span class="cf">if</span> <span class="va">__name__</span> <span class="op">==</span> <span class="st">&quot;__main__&quot;</span>:</span>
+<span id="cb102-216"><a href="#cb102-216" aria-hidden="true" tabindex="-1"></a>    N <span class="op">=</span> <span class="dv">200</span></span>
+<span id="cb102-217"><a href="#cb102-217" aria-hidden="true" tabindex="-1"></a>    matrix <span class="op">=</span> erzeuge_ruestmatrix(N)</span>
+<span id="cb102-218"><a href="#cb102-218" aria-hidden="true" tabindex="-1"></a>    start_reihe <span class="op">=</span> faustregel(matrix)</span>
+<span id="cb102-219"><a href="#cb102-219" aria-hidden="true" tabindex="-1"></a>    start_kosten <span class="op">=</span> gesamtruestzeit(start_reihe, matrix)</span>
+<span id="cb102-220"><a href="#cb102-220" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb102-221"><a href="#cb102-221" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;=&quot;</span> <span class="op">*</span> <span class="dv">78</span>)</span>
+<span id="cb102-222"><a href="#cb102-222" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;  SIMULATED ANNEALING AN DER LACKIERANLAGE&quot;</span>)</span>
+<span id="cb102-223"><a href="#cb102-223" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;=&quot;</span> <span class="op">*</span> <span class="dv">78</span>)</span>
+<span id="cb102-224"><a href="#cb102-224" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;</span><span class="sc">{</span>N<span class="sc">}</span><span class="ss"> Auftraege, </span><span class="sc">{</span><span class="bu">max</span>(<span class="dv">6</span>, N <span class="op">//</span> <span class="dv">10</span>)<span class="sc">}</span><span class="ss"> Produktfamilien, &quot;</span></span>
+<span id="cb102-225"><a href="#cb102-225" aria-hidden="true" tabindex="-1"></a>          <span class="ss">f&quot;Zugbudget </span><span class="sc">{</span>ZUEGE<span class="sc">:,}</span><span class="ss"> je Lauf.</span><span class="ch">\n</span><span class="ss">&quot;</span>)</span>
+<span id="cb102-226"><a href="#cb102-226" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;Faustregel &#39;billigster naechster Auftrag&#39;: &quot;</span></span>
+<span id="cb102-227"><a href="#cb102-227" aria-hidden="true" tabindex="-1"></a>          <span class="ss">f&quot;</span><span class="sc">{</span>start_kosten<span class="sc">:,}</span><span class="ss"> Minuten Ruestzeit&quot;</span>)</span>
+<span id="cb102-228"><a href="#cb102-228" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb102-229"><a href="#cb102-229" aria-hidden="true" tabindex="-1"></a>    <span class="co"># --- Wie gross sind die Zuege ueberhaupt? ---------------------------</span></span>
+<span id="cb102-230"><a href="#cb102-230" aria-hidden="true" tabindex="-1"></a>    <span class="co"># Ohne diese Zahl kann man die Temperatur nicht waehlen: Das</span></span>
+<span id="cb102-231"><a href="#cb102-231" aria-hidden="true" tabindex="-1"></a>    <span class="co"># Metropolis-Kriterium vergleicht die Verschlechterung MIT der Temperatur.</span></span>
+<span id="cb102-232"><a href="#cb102-232" aria-hidden="true" tabindex="-1"></a>    rng <span class="op">=</span> np.random.default_rng(<span class="dv">0</span>)</span>
+<span id="cb102-233"><a href="#cb102-233" aria-hidden="true" tabindex="-1"></a>    stichprobe <span class="op">=</span> []</span>
+<span id="cb102-234"><a href="#cb102-234" aria-hidden="true" tabindex="-1"></a>    <span class="cf">for</span> _ <span class="kw">in</span> <span class="bu">range</span>(<span class="dv">5000</span>):</span>
+<span id="cb102-235"><a href="#cb102-235" aria-hidden="true" tabindex="-1"></a>        e <span class="op">=</span> delta_verschieben(start_reihe, matrix,</span>
+<span id="cb102-236"><a href="#cb102-236" aria-hidden="true" tabindex="-1"></a>                              <span class="bu">int</span>(rng.integers(<span class="dv">0</span>, N)), <span class="bu">int</span>(rng.integers(<span class="dv">0</span>, N <span class="op">+</span> <span class="dv">1</span>)))</span>
+<span id="cb102-237"><a href="#cb102-237" aria-hidden="true" tabindex="-1"></a>        <span class="cf">if</span> e:</span>
+<span id="cb102-238"><a href="#cb102-238" aria-hidden="true" tabindex="-1"></a>            stichprobe.append(<span class="bu">abs</span>(e[<span class="dv">0</span>]))</span>
+<span id="cb102-239"><a href="#cb102-239" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;Typische Zuggroesse |Delta|: Median </span><span class="sc">{</span>np<span class="sc">.</span>median(stichprobe)<span class="sc">:.0f}</span><span class="ss">, &quot;</span></span>
+<span id="cb102-240"><a href="#cb102-240" aria-hidden="true" tabindex="-1"></a>          <span class="ss">f&quot;90 %-Quantil </span><span class="sc">{</span>np<span class="sc">.</span>quantile(stichprobe, <span class="fl">0.9</span>)<span class="sc">:.0f}</span><span class="ss"> Minuten&quot;</span>)</span>
+<span id="cb102-241"><a href="#cb102-241" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb102-242"><a href="#cb102-242" aria-hidden="true" tabindex="-1"></a>    <span class="co"># --- Bergsteigen gegen Annealing -------------------------------------</span></span>
+<span id="cb102-243"><a href="#cb102-243" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;</span><span class="ch">\n</span><span class="st">&quot;</span> <span class="op">+</span> <span class="st">&quot;-&quot;</span> <span class="op">*</span> <span class="dv">78</span>)</span>
+<span id="cb102-244"><a href="#cb102-244" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;Nur Verbesserungen annehmen (Bergsteigen) gegen Annealing:</span><span class="ch">\n</span><span class="st">&quot;</span>)</span>
+<span id="cb102-245"><a href="#cb102-245" aria-hidden="true" tabindex="-1"></a>    _, berg, berg_verlauf <span class="op">=</span> suche(matrix, ZUEGE, <span class="fl">1.0</span>, bergsteigen<span class="op">=</span><span class="va">True</span>)</span>
+<span id="cb102-246"><a href="#cb102-246" aria-hidden="true" tabindex="-1"></a>    _, gluehen, gluehen_verlauf <span class="op">=</span> suche(matrix, ZUEGE, <span class="fl">1.0</span>)</span>
+<span id="cb102-247"><a href="#cb102-247" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;  </span><span class="sc">{</span><span class="st">&#39;Faustregel (Start)&#39;</span><span class="sc">:&lt;34}</span><span class="ss"> </span><span class="sc">{</span>start_kosten<span class="sc">:&gt;7,}</span><span class="ss"> Minuten&quot;</span>)</span>
+<span id="cb102-248"><a href="#cb102-248" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;  </span><span class="sc">{</span><span class="st">&#39;Bergsteigen&#39;</span><span class="sc">:&lt;34}</span><span class="ss"> </span><span class="sc">{</span>berg<span class="sc">:&gt;7,}</span><span class="ss"> Minuten  &quot;</span></span>
+<span id="cb102-249"><a href="#cb102-249" aria-hidden="true" tabindex="-1"></a>          <span class="ss">f&quot;(</span><span class="sc">{</span>(start_kosten <span class="op">-</span> berg) <span class="op">/</span> start_kosten <span class="op">*</span> <span class="dv">100</span><span class="sc">:5.1f}</span><span class="ss"> % besser)&quot;</span>)</span>
+<span id="cb102-250"><a href="#cb102-250" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;  </span><span class="sc">{</span><span class="st">&#39;Simulated Annealing&#39;</span><span class="sc">:&lt;34}</span><span class="ss"> </span><span class="sc">{</span>gluehen<span class="sc">:&gt;7,}</span><span class="ss"> Minuten  &quot;</span></span>
+<span id="cb102-251"><a href="#cb102-251" aria-hidden="true" tabindex="-1"></a>          <span class="ss">f&quot;(</span><span class="sc">{</span>(start_kosten <span class="op">-</span> gluehen) <span class="op">/</span> start_kosten <span class="op">*</span> <span class="dv">100</span><span class="sc">:5.1f}</span><span class="ss"> % besser)&quot;</span>)</span>
+<span id="cb102-252"><a href="#cb102-252" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;</span><span class="ch">\n</span><span class="ss">  Beide pruefen genau </span><span class="sc">{</span>berg_verlauf<span class="sc">.</span>schritte<span class="sc">:,}</span><span class="ss"> Zuege &quot;</span></span>
+<span id="cb102-253"><a href="#cb102-253" aria-hidden="true" tabindex="-1"></a>          <span class="ss">f&quot;(</span><span class="sc">{</span>berg_verlauf<span class="sc">.</span>sekunden<span class="sc">:.1f}</span><span class="ss"> bzw. </span><span class="sc">{</span>gluehen_verlauf<span class="sc">.</span>sekunden<span class="sc">:.1f}</span><span class="ss"> Sekunden).&quot;</span>)</span>
+<span id="cb102-254"><a href="#cb102-254" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;  Annealing nimmt davon </span><span class="sc">{</span>gluehen_verlauf<span class="sc">.</span>annahmequote <span class="op">*</span> <span class="dv">100</span><span class="sc">:.2f}</span><span class="ss"> % der &quot;</span></span>
+<span id="cb102-255"><a href="#cb102-255" aria-hidden="true" tabindex="-1"></a>          <span class="ss">f&quot;VERSCHLECHTERUNGEN an, Bergsteigen keine.&quot;</span>)</span>
+<span id="cb102-256"><a href="#cb102-256" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;</span><span class="ch">\n</span><span class="st">  Bemerkenswert ist, wie klein der Abstand ist: Das simple&quot;</span>)</span>
+<span id="cb102-257"><a href="#cb102-257" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;  Bergsteigen holt hier bereits </span><span class="sc">{</span>(start_kosten <span class="op">-</span> berg) <span class="op">/</span> (start_kosten <span class="op">-</span> gluehen) <span class="op">*</span> <span class="dv">100</span><span class="sc">:.0f}</span><span class="ss"> % dessen, was Annealing&quot;</span>)</span>
+<span id="cb102-258"><a href="#cb102-258" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;  schafft. Wer eine Metaheuristik einsetzt, sollte diesen Vergleich&quot;</span>)</span>
+<span id="cb102-259"><a href="#cb102-259" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;  IMMER mitrechnen - sonst schreibt man einer aufwendigen Methode&quot;</span>)</span>
+<span id="cb102-260"><a href="#cb102-260" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;  gut, was schon die einfache geliefert haette.&quot;</span>)</span>
+<span id="cb102-261"><a href="#cb102-261" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb102-262"><a href="#cb102-262" aria-hidden="true" tabindex="-1"></a>    <span class="co"># --- Die Temperatur ist kein Beiwerk ---------------------------------</span></span>
+<span id="cb102-263"><a href="#cb102-263" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;</span><span class="ch">\n</span><span class="st">&quot;</span> <span class="op">+</span> <span class="st">&quot;-&quot;</span> <span class="op">*</span> <span class="dv">78</span>)</span>
+<span id="cb102-264"><a href="#cb102-264" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;Und warum die Starttemperatur ausgemessen gehoert:</span><span class="ch">\n</span><span class="st">&quot;</span>)</span>
+<span id="cb102-265"><a href="#cb102-265" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;  </span><span class="sc">{</span><span class="st">&#39;Start-T&#39;</span><span class="sc">:&gt;8}</span><span class="ss"> </span><span class="sc">{</span><span class="st">&#39;Ruestzeit&#39;</span><span class="sc">:&gt;11}</span><span class="ss"> </span><span class="sc">{</span><span class="st">&#39;gg. Faustregel&#39;</span><span class="sc">:&gt;15}</span><span class="ss"> &quot;</span></span>
+<span id="cb102-266"><a href="#cb102-266" aria-hidden="true" tabindex="-1"></a>          <span class="ss">f&quot;</span><span class="sc">{</span><span class="st">&#39;angenommene&#39;</span><span class="sc">:&gt;12}</span><span class="ss"> </span><span class="sc">{</span><span class="st">&#39;schlechtester&#39;</span><span class="sc">:&gt;14}</span><span class="ss">&quot;</span>)</span>
+<span id="cb102-267"><a href="#cb102-267" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;  </span><span class="sc">{</span><span class="st">&#39;&#39;</span><span class="sc">:&gt;8}</span><span class="ss"> </span><span class="sc">{</span><span class="st">&#39;&#39;</span><span class="sc">:&gt;11}</span><span class="ss"> </span><span class="sc">{</span><span class="st">&#39;&#39;</span><span class="sc">:&gt;15}</span><span class="ss"> </span><span class="sc">{</span><span class="st">&#39;Verschlecht.&#39;</span><span class="sc">:&gt;12}</span><span class="ss"> </span><span class="sc">{</span><span class="st">&#39;Zwischenwert&#39;</span><span class="sc">:&gt;14}</span><span class="ss">&quot;</span>)</span>
+<span id="cb102-268"><a href="#cb102-268" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;  &quot;</span> <span class="op">+</span> <span class="st">&quot;-&quot;</span> <span class="op">*</span> <span class="dv">64</span>)</span>
+<span id="cb102-269"><a href="#cb102-269" aria-hidden="true" tabindex="-1"></a>    ergebnisse, verlaeufe <span class="op">=</span> {}, {}</span>
+<span id="cb102-270"><a href="#cb102-270" aria-hidden="true" tabindex="-1"></a>    <span class="cf">for</span> temperatur <span class="kw">in</span> (<span class="fl">0.5</span>, <span class="fl">1.0</span>, <span class="fl">2.0</span>, <span class="fl">4.0</span>, <span class="fl">8.0</span>):</span>
+<span id="cb102-271"><a href="#cb102-271" aria-hidden="true" tabindex="-1"></a>        _, wert, verlauf <span class="op">=</span> suche(matrix, ZUEGE, temperatur)</span>
+<span id="cb102-272"><a href="#cb102-272" aria-hidden="true" tabindex="-1"></a>        ergebnisse[temperatur] <span class="op">=</span> wert</span>
+<span id="cb102-273"><a href="#cb102-273" aria-hidden="true" tabindex="-1"></a>        verlaeufe[temperatur] <span class="op">=</span> verlauf</span>
+<span id="cb102-274"><a href="#cb102-274" aria-hidden="true" tabindex="-1"></a>        gewinn <span class="op">=</span> (start_kosten <span class="op">-</span> wert) <span class="op">/</span> start_kosten <span class="op">*</span> <span class="dv">100</span></span>
+<span id="cb102-275"><a href="#cb102-275" aria-hidden="true" tabindex="-1"></a>        <span class="bu">print</span>(<span class="ss">f&quot;  </span><span class="sc">{</span>temperatur<span class="sc">:&gt;8.1f}</span><span class="ss"> </span><span class="sc">{</span>wert<span class="sc">:&gt;11,}</span><span class="ss"> </span><span class="sc">{</span>gewinn<span class="sc">:&gt;13.1f}</span><span class="ss"> % &quot;</span></span>
+<span id="cb102-276"><a href="#cb102-276" aria-hidden="true" tabindex="-1"></a>              <span class="ss">f&quot;</span><span class="sc">{</span>verlauf<span class="sc">.</span>annahmequote <span class="op">*</span> <span class="dv">100</span><span class="sc">:&gt;11.2f}</span><span class="ss"> % &quot;</span></span>
+<span id="cb102-277"><a href="#cb102-277" aria-hidden="true" tabindex="-1"></a>              <span class="ss">f&quot;</span><span class="sc">{</span>verlauf<span class="sc">.</span>schlechtester_zustand<span class="sc">:&gt;14,}</span><span class="ss">&quot;</span>)</span>
+<span id="cb102-278"><a href="#cb102-278" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb102-279"><a href="#cb102-279" aria-hidden="true" tabindex="-1"></a>    beste_temperatur <span class="op">=</span> <span class="bu">min</span>(ergebnisse, key<span class="op">=</span>ergebnisse.get)</span>
+<span id="cb102-280"><a href="#cb102-280" aria-hidden="true" tabindex="-1"></a>    heiss <span class="op">=</span> verlaeufe[<span class="fl">8.0</span>]</span>
+<span id="cb102-281"><a href="#cb102-281" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;</span><span class="ch">\n</span><span class="ss">  Bester Wert bei T0 = </span><span class="sc">{</span>beste_temperatur<span class="sc">}</span><span class="ss">.&quot;</span>)</span>
+<span id="cb102-282"><a href="#cb102-282" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;</span><span class="ch">\n</span><span class="st">  Die letzten beiden Spalten erklaeren, warum es nach oben kippt.&quot;</span>)</span>
+<span id="cb102-283"><a href="#cb102-283" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;  Bei T0 = 8 gehen nur </span><span class="sc">{</span>heiss<span class="sc">.</span>annahmequote <span class="op">*</span> <span class="dv">100</span><span class="sc">:.2f}</span><span class="ss"> % der Verschlechterungen&quot;</span>)</span>
+<span id="cb102-284"><a href="#cb102-284" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;  durch - wenig genug, dass man es fuer harmlos halten koennte. Es&quot;</span>)</span>
+<span id="cb102-285"><a href="#cb102-285" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;  genuegt aber: Die Suche driftet bis auf </span><span class="sc">{</span>heiss<span class="sc">.</span>schlechtester_zustand<span class="sc">:,}</span><span class="ss"> Minuten ab, das&quot;</span>)</span>
+<span id="cb102-286"><a href="#cb102-286" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;  </span><span class="sc">{</span>heiss<span class="sc">.</span>schlechtester_zustand <span class="op">/</span> start_kosten<span class="sc">:.1f}</span><span class="ss">-fache der Startloesung, und findet im Zugbudget nicht&quot;</span>)</span>
+<span id="cb102-287"><a href="#cb102-287" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;  mehr zurueck. Vom Ergebnis bleibt fast nichts uebrig: Die Suche hat&quot;</span>)</span>
+<span id="cb102-288"><a href="#cb102-288" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;  in </span><span class="sc">{</span>ZUEGE<span class="sc">:,}</span><span class="ss"> Zuegen nie etwas GESEHEN, das mehr als&quot;</span>)</span>
+<span id="cb102-289"><a href="#cb102-289" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;  </span><span class="sc">{</span>(start_kosten <span class="op">-</span> ergebnisse[<span class="fl">8.0</span>]) <span class="op">/</span> start_kosten <span class="op">*</span> <span class="dv">100</span><span class="sc">:.1f}</span><span class="ss"> % unter der Startloesung lag.&quot;</span>)</span>
+<span id="cb102-290"><a href="#cb102-290" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;</span><span class="ch">\n</span><span class="st">  Bemerkenswert ist die andere Richtung: Die besten Werte entstehen&quot;</span>)</span>
+<span id="cb102-291"><a href="#cb102-291" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;  bei Annahmequoten nahe null. Die Lehrbuchregel &#39;anfangs sollen&quot;</span>)</span>
+<span id="cb102-292"><a href="#cb102-292" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;  20 bis 50 Prozent der Verschlechterungen durchgehen&#39; fuehrt hier in&quot;</span>)</span>
+<span id="cb102-293"><a href="#cb102-293" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;  die Irre - sie stammt aus Problemen mit sehr kleinen Zuggroessen.&quot;</span>)</span>
+<span id="cb102-294"><a href="#cb102-294" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;  Bei Ruestzeiten in Minuten ist ein einziger schlechter Zug teuer.&quot;</span>)</span>
+<span id="cb102-295"><a href="#cb102-295" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;</span><span class="ch">\n</span><span class="st">  Was stattdessen traegt: Den SCHLECHTESTEN Zwischenwert protokollieren&quot;</span>)</span>
+<span id="cb102-296"><a href="#cb102-296" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;  und T0 so waehlen, dass er die Startloesung nicht wesentlich&quot;</span>)</span>
+<span id="cb102-297"><a href="#cb102-297" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;  ueberschreitet. Diese eine Zahl haette hier auf Anhieb gezeigt, dass&quot;</span>)</span>
+<span id="cb102-298"><a href="#cb102-298" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;  T0 = 8 unbrauchbar ist - ohne dass man das Endergebnis abwarten muss.&quot;</span>)</span>
+<span id="cb102-299"><a href="#cb102-299" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;=&quot;</span> <span class="op">*</span> <span class="dv">78</span>)</span></code></pre></div>
 <p><strong>Erwartete Ausgabe</strong> (Laufzeiten hardwareabhängig, die Werte nicht):</p>
 <pre><code>==============================================================================
   SIMULATED ANNEALING AN DER LACKIERANLAGE
@@ -13625,238 +14370,238 @@ Und warum die Starttemperatur ausgemessen gehoert:
 <hr />
 <h2 id="sec:metaheuristiken-umschlagpunkt">9.6 Ab wann lohnt es sich?</h2>
 <p>„Kleine Probleme exakt, große mit Metaheuristiken“ ist richtig und nutzlos, solange niemand sagt, wo <em>groß</em> anfängt. Diese Zahl lässt sich messen.</p>
-<div class="sourceCode" id="cb102"><pre class="sourceCode python"><code class="sourceCode python"><span id="cb102-1"><a href="#cb102-1" aria-hidden="true" tabindex="-1"></a><span class="co">#!/usr/bin/env python3</span></span>
-<span id="cb102-2"><a href="#cb102-2" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb102-3"><a href="#cb102-3" aria-hidden="true" tabindex="-1"></a><span class="co"># Metaheuristik_vs_Exakt.py</span></span>
-<span id="cb102-4"><a href="#cb102-4" aria-hidden="true" tabindex="-1"></a><span class="co">&quot;&quot;&quot;</span></span>
-<span id="cb102-5"><a href="#cb102-5" aria-hidden="true" tabindex="-1"></a><span class="co">Kapitel Metaheuristiken: Ab wann lohnt sich eine Metaheuristik? Die Antwort ist eine Zahl.</span></span>
-<span id="cb102-6"><a href="#cb102-6" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb102-7"><a href="#cb102-7" aria-hidden="true" tabindex="-1"></a><span class="co">Die verbreitete Regel lautet: &quot;Kleine Probleme exakt, grosse mit</span></span>
-<span id="cb102-8"><a href="#cb102-8" aria-hidden="true" tabindex="-1"></a><span class="co">Metaheuristiken.&quot; Sie ist richtig - aber voellig nutzlos, solange niemand sagt,</span></span>
-<span id="cb102-9"><a href="#cb102-9" aria-hidden="true" tabindex="-1"></a><span class="co">wo &#39;gross&#39; anfaengt. Dieses Programm misst es fuer die Ruestzeitenaufgabe aus</span></span>
-<span id="cb102-10"><a href="#cb102-10" aria-hidden="true" tabindex="-1"></a><span class="co">Simulated_Annealing.py nach, und das Ergebnis ueberrascht in beide Richtungen:</span></span>
-<span id="cb102-11"><a href="#cb102-11" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb102-12"><a href="#cb102-12" aria-hidden="true" tabindex="-1"></a><span class="co">  * Bei 60 Auftraegen loest CP-SAT BEWEISBAR optimal, in wenigen Sekunden.</span></span>
-<span id="cb102-13"><a href="#cb102-13" aria-hidden="true" tabindex="-1"></a><span class="co">    Die Metaheuristik ist hier schlicht die schlechtere Wahl - sie liefert ein</span></span>
-<span id="cb102-14"><a href="#cb102-14" aria-hidden="true" tabindex="-1"></a><span class="co">    schwaecheres Ergebnis und weiss nicht einmal, wie schwach.</span></span>
-<span id="cb102-15"><a href="#cb102-15" aria-hidden="true" tabindex="-1"></a><span class="co">  * Bei 200 Auftraegen liegt CP-SAT ohne Optimalitaetsbeweis vorne.</span></span>
-<span id="cb102-16"><a href="#cb102-16" aria-hidden="true" tabindex="-1"></a><span class="co">  * Erst bei 500 Auftraegen kippt es: Dort gibt CP-SAT im Zeitlimit eine</span></span>
-<span id="cb102-17"><a href="#cb102-17" aria-hidden="true" tabindex="-1"></a><span class="co">    Loesung aus, die SCHLECHTER ist als die Faustregel eines Meisters.</span></span>
-<span id="cb102-18"><a href="#cb102-18" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb102-19"><a href="#cb102-19" aria-hidden="true" tabindex="-1"></a><span class="co">Der Punkt des Kapitels steht in der letzten Spalte: Die Schranke. Nur der</span></span>
-<span id="cb102-20"><a href="#cb102-20" aria-hidden="true" tabindex="-1"></a><span class="co">exakte Solver sagt, wie gut die Loesung sein KANN. Eine Metaheuristik allein</span></span>
-<span id="cb102-21"><a href="#cb102-21" aria-hidden="true" tabindex="-1"></a><span class="co">liefert eine Zahl ohne Massstab - man weiss nie, ob man 2 % oder 40 % neben dem</span></span>
-<span id="cb102-22"><a href="#cb102-22" aria-hidden="true" tabindex="-1"></a><span class="co">Optimum liegt.</span></span>
-<span id="cb102-23"><a href="#cb102-23" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb102-24"><a href="#cb102-24" aria-hidden="true" tabindex="-1"></a><span class="co">ZUR REPRODUZIERBARKEIT: Die Spalte &#39;Annealing&#39; ist auf jeder Maschine gleich -</span></span>
-<span id="cb102-25"><a href="#cb102-25" aria-hidden="true" tabindex="-1"></a><span class="co">sie laeuft ueber ein festes ZUGbudget. Die CP-SAT-Spalten sind es nicht: Ein</span></span>
-<span id="cb102-26"><a href="#cb102-26" aria-hidden="true" tabindex="-1"></a><span class="co">Zeitlimit ist ein Wanduhr-Limit, und wie weit der Solver in 30 Sekunden kommt,</span></span>
-<span id="cb102-27"><a href="#cb102-27" aria-hidden="true" tabindex="-1"></a><span class="co">haengt von der Maschine ab. CP-SAT kennt zwar ein deterministisches Zeitmass</span></span>
-<span id="cb102-28"><a href="#cb102-28" aria-hidden="true" tabindex="-1"></a><span class="co">(max_deterministic_time), das aber in einer Groessenordnung rechnet, die fuer</span></span>
-<span id="cb102-29"><a href="#cb102-29" aria-hidden="true" tabindex="-1"></a><span class="co">ein Buchbeispiel unbrauchbar langsam ist. Die Zahlen unten sind also</span></span>
-<span id="cb102-30"><a href="#cb102-30" aria-hidden="true" tabindex="-1"></a><span class="co">hardwareabhaengig - die AUSSAGE der Tabelle ist es nicht, sie ist auf</span></span>
-<span id="cb102-31"><a href="#cb102-31" aria-hidden="true" tabindex="-1"></a><span class="co">verschiedenen Groessen und in mehreren Laeufen stabil.</span></span>
-<span id="cb102-32"><a href="#cb102-32" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb102-33"><a href="#cb102-33" aria-hidden="true" tabindex="-1"></a><span class="co">WICHTIG: Hier wird nur ortools importiert, nicht highspy (Kapitel Oekosystem).</span></span>
-<span id="cb102-34"><a href="#cb102-34" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb102-35"><a href="#cb102-35" aria-hidden="true" tabindex="-1"></a><span class="co">Benoetigt: numpy, ortools</span></span>
-<span id="cb102-36"><a href="#cb102-36" aria-hidden="true" tabindex="-1"></a><span class="co">&quot;&quot;&quot;</span></span>
-<span id="cb102-37"><a href="#cb102-37" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb102-38"><a href="#cb102-38" aria-hidden="true" tabindex="-1"></a><span class="im">from</span> __future__ <span class="im">import</span> annotations</span>
-<span id="cb102-39"><a href="#cb102-39" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb102-40"><a href="#cb102-40" aria-hidden="true" tabindex="-1"></a><span class="im">import</span> time</span>
-<span id="cb102-41"><a href="#cb102-41" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb102-42"><a href="#cb102-42" aria-hidden="true" tabindex="-1"></a><span class="im">import</span> numpy <span class="im">as</span> np</span>
-<span id="cb102-43"><a href="#cb102-43" aria-hidden="true" tabindex="-1"></a><span class="im">from</span> ortools.sat.python <span class="im">import</span> cp_model</span>
-<span id="cb102-44"><a href="#cb102-44" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb102-45"><a href="#cb102-45" aria-hidden="true" tabindex="-1"></a>ZUEGE <span class="op">=</span> <span class="dv">400_000</span>           <span class="co"># Zugbudget der Metaheuristik (wie Simulated_Annealing.py)</span></span>
-<span id="cb102-46"><a href="#cb102-46" aria-hidden="true" tabindex="-1"></a>ZEITLIMIT <span class="op">=</span> <span class="fl">30.0</span>          <span class="co"># Zeitbudget des exakten Solvers</span></span>
-<span id="cb102-47"><a href="#cb102-47" aria-hidden="true" tabindex="-1"></a>GROESSEN <span class="op">=</span> (<span class="dv">60</span>, <span class="dv">200</span>, <span class="dv">500</span>)</span>
-<span id="cb102-48"><a href="#cb102-48" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb102-49"><a href="#cb102-49" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb102-50"><a href="#cb102-50" aria-hidden="true" tabindex="-1"></a><span class="co"># --- Instanz, Faustregel und Suche: identisch zu Simulated_Annealing.py -----</span></span>
-<span id="cb102-51"><a href="#cb102-51" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb102-52"><a href="#cb102-52" aria-hidden="true" tabindex="-1"></a><span class="kw">def</span> erzeuge_ruestmatrix(n: <span class="bu">int</span>, saat: <span class="bu">int</span> <span class="op">=</span> <span class="dv">11</span>) <span class="op">-&gt;</span> np.ndarray:</span>
-<span id="cb102-53"><a href="#cb102-53" aria-hidden="true" tabindex="-1"></a>    rng <span class="op">=</span> np.random.default_rng(saat)</span>
-<span id="cb102-54"><a href="#cb102-54" aria-hidden="true" tabindex="-1"></a>    familien <span class="op">=</span> <span class="bu">max</span>(<span class="dv">6</span>, n <span class="op">//</span> <span class="dv">10</span>)</span>
-<span id="cb102-55"><a href="#cb102-55" aria-hidden="true" tabindex="-1"></a>    zwischen <span class="op">=</span> rng.integers(<span class="dv">8</span>, <span class="dv">60</span>, (familien, familien))</span>
-<span id="cb102-56"><a href="#cb102-56" aria-hidden="true" tabindex="-1"></a>    np.fill_diagonal(zwischen, <span class="dv">2</span>)</span>
-<span id="cb102-57"><a href="#cb102-57" aria-hidden="true" tabindex="-1"></a>    familie <span class="op">=</span> rng.integers(<span class="dv">0</span>, familien, n)</span>
-<span id="cb102-58"><a href="#cb102-58" aria-hidden="true" tabindex="-1"></a>    farbe <span class="op">=</span> rng.integers(<span class="dv">0</span>, <span class="dv">10</span>, n)</span>
-<span id="cb102-59"><a href="#cb102-59" aria-hidden="true" tabindex="-1"></a>    matrix <span class="op">=</span> np.zeros((n, n), dtype<span class="op">=</span>np.int64)</span>
-<span id="cb102-60"><a href="#cb102-60" aria-hidden="true" tabindex="-1"></a>    <span class="cf">for</span> i <span class="kw">in</span> <span class="bu">range</span>(n):</span>
-<span id="cb102-61"><a href="#cb102-61" aria-hidden="true" tabindex="-1"></a>        <span class="cf">for</span> j <span class="kw">in</span> <span class="bu">range</span>(n):</span>
-<span id="cb102-62"><a href="#cb102-62" aria-hidden="true" tabindex="-1"></a>            <span class="cf">if</span> i <span class="op">!=</span> j:</span>
-<span id="cb102-63"><a href="#cb102-63" aria-hidden="true" tabindex="-1"></a>                matrix[i, j] <span class="op">=</span> (zwischen[familie[i], familie[j]]</span>
-<span id="cb102-64"><a href="#cb102-64" aria-hidden="true" tabindex="-1"></a>                                <span class="op">+</span> <span class="dv">3</span> <span class="op">*</span> <span class="bu">max</span>(<span class="dv">0</span>, farbe[i] <span class="op">-</span> farbe[j]))</span>
-<span id="cb102-65"><a href="#cb102-65" aria-hidden="true" tabindex="-1"></a>    <span class="cf">return</span> matrix</span>
-<span id="cb102-66"><a href="#cb102-66" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb102-67"><a href="#cb102-67" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb102-68"><a href="#cb102-68" aria-hidden="true" tabindex="-1"></a><span class="kw">def</span> gesamtruestzeit(reihe: <span class="bu">list</span>[<span class="bu">int</span>], matrix: np.ndarray) <span class="op">-&gt;</span> <span class="bu">int</span>:</span>
-<span id="cb102-69"><a href="#cb102-69" aria-hidden="true" tabindex="-1"></a>    <span class="cf">return</span> <span class="bu">int</span>(<span class="bu">sum</span>(matrix[reihe[k], reihe[k <span class="op">+</span> <span class="dv">1</span>]] <span class="cf">for</span> k <span class="kw">in</span> <span class="bu">range</span>(<span class="bu">len</span>(reihe) <span class="op">-</span> <span class="dv">1</span>)))</span>
-<span id="cb102-70"><a href="#cb102-70" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb102-71"><a href="#cb102-71" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb102-72"><a href="#cb102-72" aria-hidden="true" tabindex="-1"></a><span class="kw">def</span> faustregel(matrix: np.ndarray) <span class="op">-&gt;</span> <span class="bu">list</span>[<span class="bu">int</span>]:</span>
-<span id="cb102-73"><a href="#cb102-73" aria-hidden="true" tabindex="-1"></a>    n <span class="op">=</span> <span class="bu">len</span>(matrix)</span>
-<span id="cb102-74"><a href="#cb102-74" aria-hidden="true" tabindex="-1"></a>    offen <span class="op">=</span> <span class="bu">set</span>(<span class="bu">range</span>(<span class="dv">1</span>, n))</span>
-<span id="cb102-75"><a href="#cb102-75" aria-hidden="true" tabindex="-1"></a>    reihe <span class="op">=</span> [<span class="dv">0</span>]</span>
-<span id="cb102-76"><a href="#cb102-76" aria-hidden="true" tabindex="-1"></a>    <span class="cf">while</span> offen:</span>
-<span id="cb102-77"><a href="#cb102-77" aria-hidden="true" tabindex="-1"></a>        naechster <span class="op">=</span> <span class="bu">min</span>(offen, key<span class="op">=</span><span class="kw">lambda</span> j: matrix[reihe[<span class="op">-</span><span class="dv">1</span>], j])</span>
-<span id="cb102-78"><a href="#cb102-78" aria-hidden="true" tabindex="-1"></a>        reihe.append(naechster)</span>
-<span id="cb102-79"><a href="#cb102-79" aria-hidden="true" tabindex="-1"></a>        offen.discard(naechster)</span>
-<span id="cb102-80"><a href="#cb102-80" aria-hidden="true" tabindex="-1"></a>    <span class="cf">return</span> reihe</span>
-<span id="cb102-81"><a href="#cb102-81" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb102-82"><a href="#cb102-82" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb102-83"><a href="#cb102-83" aria-hidden="true" tabindex="-1"></a><span class="kw">def</span> delta_verschieben(reihe, matrix, von, nach):</span>
-<span id="cb102-84"><a href="#cb102-84" aria-hidden="true" tabindex="-1"></a>    n <span class="op">=</span> <span class="bu">len</span>(reihe)</span>
-<span id="cb102-85"><a href="#cb102-85" aria-hidden="true" tabindex="-1"></a>    <span class="cf">if</span> von <span class="op">==</span> nach <span class="kw">or</span> nach <span class="op">==</span> von <span class="op">+</span> <span class="dv">1</span>:</span>
-<span id="cb102-86"><a href="#cb102-86" aria-hidden="true" tabindex="-1"></a>        <span class="cf">return</span> <span class="va">None</span></span>
-<span id="cb102-87"><a href="#cb102-87" aria-hidden="true" tabindex="-1"></a>    heraus <span class="op">=</span> <span class="dv">0</span></span>
-<span id="cb102-88"><a href="#cb102-88" aria-hidden="true" tabindex="-1"></a>    <span class="cf">if</span> von <span class="op">&gt;</span> <span class="dv">0</span>:</span>
-<span id="cb102-89"><a href="#cb102-89" aria-hidden="true" tabindex="-1"></a>        heraus <span class="op">+=</span> matrix[reihe[von <span class="op">-</span> <span class="dv">1</span>], reihe[von]]</span>
-<span id="cb102-90"><a href="#cb102-90" aria-hidden="true" tabindex="-1"></a>    <span class="cf">if</span> von <span class="op">&lt;</span> n <span class="op">-</span> <span class="dv">1</span>:</span>
-<span id="cb102-91"><a href="#cb102-91" aria-hidden="true" tabindex="-1"></a>        heraus <span class="op">+=</span> matrix[reihe[von], reihe[von <span class="op">+</span> <span class="dv">1</span>]]</span>
-<span id="cb102-92"><a href="#cb102-92" aria-hidden="true" tabindex="-1"></a>    <span class="cf">if</span> <span class="dv">0</span> <span class="op">&lt;</span> von <span class="op">&lt;</span> n <span class="op">-</span> <span class="dv">1</span>:</span>
-<span id="cb102-93"><a href="#cb102-93" aria-hidden="true" tabindex="-1"></a>        heraus <span class="op">-=</span> matrix[reihe[von <span class="op">-</span> <span class="dv">1</span>], reihe[von <span class="op">+</span> <span class="dv">1</span>]]</span>
-<span id="cb102-94"><a href="#cb102-94" aria-hidden="true" tabindex="-1"></a>    rest <span class="op">=</span> reihe[:von] <span class="op">+</span> reihe[von <span class="op">+</span> <span class="dv">1</span>:]</span>
-<span id="cb102-95"><a href="#cb102-95" aria-hidden="true" tabindex="-1"></a>    stelle <span class="op">=</span> nach <span class="cf">if</span> nach <span class="op">&lt;</span> von <span class="cf">else</span> nach <span class="op">-</span> <span class="dv">1</span></span>
-<span id="cb102-96"><a href="#cb102-96" aria-hidden="true" tabindex="-1"></a>    hinein <span class="op">=</span> <span class="dv">0</span></span>
-<span id="cb102-97"><a href="#cb102-97" aria-hidden="true" tabindex="-1"></a>    <span class="cf">if</span> stelle <span class="op">&gt;</span> <span class="dv">0</span>:</span>
-<span id="cb102-98"><a href="#cb102-98" aria-hidden="true" tabindex="-1"></a>        hinein <span class="op">+=</span> matrix[rest[stelle <span class="op">-</span> <span class="dv">1</span>], reihe[von]]</span>
-<span id="cb102-99"><a href="#cb102-99" aria-hidden="true" tabindex="-1"></a>    <span class="cf">if</span> stelle <span class="op">&lt;</span> <span class="bu">len</span>(rest):</span>
-<span id="cb102-100"><a href="#cb102-100" aria-hidden="true" tabindex="-1"></a>        hinein <span class="op">+=</span> matrix[reihe[von], rest[stelle]]</span>
-<span id="cb102-101"><a href="#cb102-101" aria-hidden="true" tabindex="-1"></a>    <span class="cf">if</span> <span class="dv">0</span> <span class="op">&lt;</span> stelle <span class="op">&lt;</span> <span class="bu">len</span>(rest):</span>
-<span id="cb102-102"><a href="#cb102-102" aria-hidden="true" tabindex="-1"></a>        hinein <span class="op">-=</span> matrix[rest[stelle <span class="op">-</span> <span class="dv">1</span>], rest[stelle]]</span>
-<span id="cb102-103"><a href="#cb102-103" aria-hidden="true" tabindex="-1"></a>    <span class="cf">return</span> <span class="bu">int</span>(hinein <span class="op">-</span> heraus), rest, stelle</span>
-<span id="cb102-104"><a href="#cb102-104" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb102-105"><a href="#cb102-105" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb102-106"><a href="#cb102-106" aria-hidden="true" tabindex="-1"></a><span class="kw">def</span> annealing(matrix: np.ndarray, zuege: <span class="bu">int</span> <span class="op">=</span> ZUEGE,</span>
-<span id="cb102-107"><a href="#cb102-107" aria-hidden="true" tabindex="-1"></a>              start_temperatur: <span class="bu">float</span> <span class="op">=</span> <span class="fl">1.0</span>, saat: <span class="bu">int</span> <span class="op">=</span> <span class="dv">1</span>) <span class="op">-&gt;</span> <span class="bu">tuple</span>[<span class="bu">int</span>, <span class="bu">float</span>]:</span>
-<span id="cb102-108"><a href="#cb102-108" aria-hidden="true" tabindex="-1"></a>    <span class="co">&quot;&quot;&quot;Dieselbe Suche wie in Simulated_Annealing.py, hier nur als Vergleichswert.&quot;&quot;&quot;</span></span>
-<span id="cb102-109"><a href="#cb102-109" aria-hidden="true" tabindex="-1"></a>    <span class="im">import</span> math</span>
-<span id="cb102-110"><a href="#cb102-110" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb102-111"><a href="#cb102-111" aria-hidden="true" tabindex="-1"></a>    rng <span class="op">=</span> np.random.default_rng(saat)</span>
-<span id="cb102-112"><a href="#cb102-112" aria-hidden="true" tabindex="-1"></a>    n <span class="op">=</span> <span class="bu">len</span>(matrix)</span>
-<span id="cb102-113"><a href="#cb102-113" aria-hidden="true" tabindex="-1"></a>    reihe <span class="op">=</span> faustregel(matrix)</span>
-<span id="cb102-114"><a href="#cb102-114" aria-hidden="true" tabindex="-1"></a>    kosten <span class="op">=</span> gesamtruestzeit(reihe, matrix)</span>
-<span id="cb102-115"><a href="#cb102-115" aria-hidden="true" tabindex="-1"></a>    beste_kosten <span class="op">=</span> kosten</span>
-<span id="cb102-116"><a href="#cb102-116" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb102-117"><a href="#cb102-117" aria-hidden="true" tabindex="-1"></a>    t0 <span class="op">=</span> time.perf_counter()</span>
-<span id="cb102-118"><a href="#cb102-118" aria-hidden="true" tabindex="-1"></a>    <span class="cf">for</span> zug <span class="kw">in</span> <span class="bu">range</span>(zuege):</span>
-<span id="cb102-119"><a href="#cb102-119" aria-hidden="true" tabindex="-1"></a>        temperatur <span class="op">=</span> start_temperatur <span class="op">*</span> (<span class="fl">0.05</span> <span class="op">/</span> start_temperatur) <span class="op">**</span> (zug <span class="op">/</span> zuege)</span>
-<span id="cb102-120"><a href="#cb102-120" aria-hidden="true" tabindex="-1"></a>        von <span class="op">=</span> <span class="bu">int</span>(rng.integers(<span class="dv">0</span>, n))</span>
-<span id="cb102-121"><a href="#cb102-121" aria-hidden="true" tabindex="-1"></a>        nach <span class="op">=</span> <span class="bu">int</span>(rng.integers(<span class="dv">0</span>, n <span class="op">+</span> <span class="dv">1</span>))</span>
-<span id="cb102-122"><a href="#cb102-122" aria-hidden="true" tabindex="-1"></a>        ergebnis <span class="op">=</span> delta_verschieben(reihe, matrix, von, nach)</span>
-<span id="cb102-123"><a href="#cb102-123" aria-hidden="true" tabindex="-1"></a>        <span class="cf">if</span> ergebnis <span class="kw">is</span> <span class="va">None</span>:</span>
-<span id="cb102-124"><a href="#cb102-124" aria-hidden="true" tabindex="-1"></a>            <span class="cf">continue</span></span>
-<span id="cb102-125"><a href="#cb102-125" aria-hidden="true" tabindex="-1"></a>        aenderung, rest, stelle <span class="op">=</span> ergebnis</span>
-<span id="cb102-126"><a href="#cb102-126" aria-hidden="true" tabindex="-1"></a>        <span class="cf">if</span> aenderung <span class="op">&lt;=</span> <span class="dv">0</span> <span class="kw">or</span> rng.random() <span class="op">&lt;</span> math.exp(<span class="op">-</span>aenderung <span class="op">/</span> temperatur):</span>
-<span id="cb102-127"><a href="#cb102-127" aria-hidden="true" tabindex="-1"></a>            reihe <span class="op">=</span> rest[:stelle] <span class="op">+</span> [reihe[von]] <span class="op">+</span> rest[stelle:]</span>
-<span id="cb102-128"><a href="#cb102-128" aria-hidden="true" tabindex="-1"></a>            kosten <span class="op">+=</span> aenderung</span>
-<span id="cb102-129"><a href="#cb102-129" aria-hidden="true" tabindex="-1"></a>            beste_kosten <span class="op">=</span> <span class="bu">min</span>(beste_kosten, kosten)</span>
-<span id="cb102-130"><a href="#cb102-130" aria-hidden="true" tabindex="-1"></a>    <span class="cf">return</span> beste_kosten, time.perf_counter() <span class="op">-</span> t0</span>
-<span id="cb102-131"><a href="#cb102-131" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb102-132"><a href="#cb102-132" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb102-133"><a href="#cb102-133" aria-hidden="true" tabindex="-1"></a><span class="co"># --- Der exakte Weg: CP-SAT mit AddCircuit ---------------------------------</span></span>
-<span id="cb102-134"><a href="#cb102-134" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb102-135"><a href="#cb102-135" aria-hidden="true" tabindex="-1"></a><span class="kw">def</span> exakt(matrix: np.ndarray, zeitlimit: <span class="bu">float</span> <span class="op">=</span> ZEITLIMIT):</span>
-<span id="cb102-136"><a href="#cb102-136" aria-hidden="true" tabindex="-1"></a>    <span class="co">&quot;&quot;&quot;Reihenfolge als Rundreise mit einem kostenlosen Hilfsknoten.</span></span>
-<span id="cb102-137"><a href="#cb102-137" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb102-138"><a href="#cb102-138" aria-hidden="true" tabindex="-1"></a><span class="co">    AddCircuit verlangt einen geschlossenen Kreis. Unsere Aufgabe ist aber eine</span></span>
-<span id="cb102-139"><a href="#cb102-139" aria-hidden="true" tabindex="-1"></a><span class="co">    offene Kette: Der erste Auftrag hat keinen Vorgaenger, der letzte keinen</span></span>
-<span id="cb102-140"><a href="#cb102-140" aria-hidden="true" tabindex="-1"></a><span class="co">    Nachfolger. Der uebliche Kniff ist ein zusaetzlicher Hilfsknoten n, dessen</span></span>
-<span id="cb102-141"><a href="#cb102-141" aria-hidden="true" tabindex="-1"></a><span class="co">    Kanten nichts kosten. Der Kreis laeuft dann Hilfsknoten -&gt; Kette -&gt;</span></span>
-<span id="cb102-142"><a href="#cb102-142" aria-hidden="true" tabindex="-1"></a><span class="co">    Hilfsknoten, und die Kosten des Kreises sind genau die der Kette.</span></span>
-<span id="cb102-143"><a href="#cb102-143" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb102-144"><a href="#cb102-144" aria-hidden="true" tabindex="-1"></a><span class="co">    AddCircuit ist der Grund, warum CP-SAT hier so lange mithaelt: Die</span></span>
-<span id="cb102-145"><a href="#cb102-145" aria-hidden="true" tabindex="-1"></a><span class="co">    Nebenbedingung sorgt selbst dafuer, dass keine Teilkreise entstehen. Wer</span></span>
-<span id="cb102-146"><a href="#cb102-146" aria-hidden="true" tabindex="-1"></a><span class="co">    dasselbe als MILP formuliert, braucht dafuer entweder exponentiell viele</span></span>
-<span id="cb102-147"><a href="#cb102-147" aria-hidden="true" tabindex="-1"></a><span class="co">    Ungleichungen oder die schwache MTZ-Formulierung (Kapitel Graphen).</span></span>
-<span id="cb102-148"><a href="#cb102-148" aria-hidden="true" tabindex="-1"></a><span class="co">    &quot;&quot;&quot;</span></span>
-<span id="cb102-149"><a href="#cb102-149" aria-hidden="true" tabindex="-1"></a>    n <span class="op">=</span> <span class="bu">len</span>(matrix)</span>
-<span id="cb102-150"><a href="#cb102-150" aria-hidden="true" tabindex="-1"></a>    modell <span class="op">=</span> cp_model.CpModel()</span>
-<span id="cb102-151"><a href="#cb102-151" aria-hidden="true" tabindex="-1"></a>    kanten, ziel <span class="op">=</span> [], []</span>
-<span id="cb102-152"><a href="#cb102-152" aria-hidden="true" tabindex="-1"></a>    <span class="cf">for</span> i <span class="kw">in</span> <span class="bu">range</span>(n <span class="op">+</span> <span class="dv">1</span>):</span>
-<span id="cb102-153"><a href="#cb102-153" aria-hidden="true" tabindex="-1"></a>        <span class="cf">for</span> j <span class="kw">in</span> <span class="bu">range</span>(n <span class="op">+</span> <span class="dv">1</span>):</span>
-<span id="cb102-154"><a href="#cb102-154" aria-hidden="true" tabindex="-1"></a>            <span class="cf">if</span> i <span class="op">==</span> j:</span>
-<span id="cb102-155"><a href="#cb102-155" aria-hidden="true" tabindex="-1"></a>                <span class="cf">continue</span></span>
-<span id="cb102-156"><a href="#cb102-156" aria-hidden="true" tabindex="-1"></a>            aktiv <span class="op">=</span> modell.NewBoolVar(<span class="ss">f&quot;kante_</span><span class="sc">{</span>i<span class="sc">}</span><span class="ss">_</span><span class="sc">{</span>j<span class="sc">}</span><span class="ss">&quot;</span>)</span>
-<span id="cb102-157"><a href="#cb102-157" aria-hidden="true" tabindex="-1"></a>            kanten.append((i, j, aktiv))</span>
-<span id="cb102-158"><a href="#cb102-158" aria-hidden="true" tabindex="-1"></a>            <span class="cf">if</span> i <span class="op">&lt;</span> n <span class="kw">and</span> j <span class="op">&lt;</span> n:                  <span class="co"># Hilfsknoten kostet nichts</span></span>
-<span id="cb102-159"><a href="#cb102-159" aria-hidden="true" tabindex="-1"></a>                ziel.append(<span class="bu">int</span>(matrix[i, j]) <span class="op">*</span> aktiv)</span>
-<span id="cb102-160"><a href="#cb102-160" aria-hidden="true" tabindex="-1"></a>    modell.AddCircuit(kanten)</span>
-<span id="cb102-161"><a href="#cb102-161" aria-hidden="true" tabindex="-1"></a>    modell.Minimize(<span class="bu">sum</span>(ziel))</span>
-<span id="cb102-162"><a href="#cb102-162" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb102-163"><a href="#cb102-163" aria-hidden="true" tabindex="-1"></a>    loeser <span class="op">=</span> cp_model.CpSolver()</span>
-<span id="cb102-164"><a href="#cb102-164" aria-hidden="true" tabindex="-1"></a>    loeser.parameters.max_time_in_seconds <span class="op">=</span> zeitlimit</span>
-<span id="cb102-165"><a href="#cb102-165" aria-hidden="true" tabindex="-1"></a>    loeser.parameters.num_workers <span class="op">=</span> <span class="dv">8</span></span>
-<span id="cb102-166"><a href="#cb102-166" aria-hidden="true" tabindex="-1"></a>    loeser.parameters.random_seed <span class="op">=</span> <span class="dv">1</span></span>
-<span id="cb102-167"><a href="#cb102-167" aria-hidden="true" tabindex="-1"></a>    t0 <span class="op">=</span> time.perf_counter()</span>
-<span id="cb102-168"><a href="#cb102-168" aria-hidden="true" tabindex="-1"></a>    status <span class="op">=</span> loeser.Solve(modell)</span>
-<span id="cb102-169"><a href="#cb102-169" aria-hidden="true" tabindex="-1"></a>    dauer <span class="op">=</span> time.perf_counter() <span class="op">-</span> t0</span>
-<span id="cb102-170"><a href="#cb102-170" aria-hidden="true" tabindex="-1"></a>    <span class="cf">return</span> (loeser.StatusName(status), <span class="bu">int</span>(loeser.ObjectiveValue()),</span>
-<span id="cb102-171"><a href="#cb102-171" aria-hidden="true" tabindex="-1"></a>            <span class="bu">int</span>(loeser.BestObjectiveBound()), dauer)</span>
-<span id="cb102-172"><a href="#cb102-172" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb102-173"><a href="#cb102-173" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb102-174"><a href="#cb102-174" aria-hidden="true" tabindex="-1"></a><span class="cf">if</span> <span class="va">__name__</span> <span class="op">==</span> <span class="st">&quot;__main__&quot;</span>:</span>
-<span id="cb102-175"><a href="#cb102-175" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;=&quot;</span> <span class="op">*</span> <span class="dv">88</span>)</span>
-<span id="cb102-176"><a href="#cb102-176" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;  AB WANN LOHNT SICH DIE METAHEURISTIK?&quot;</span>)</span>
-<span id="cb102-177"><a href="#cb102-177" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;=&quot;</span> <span class="op">*</span> <span class="dv">88</span>)</span>
-<span id="cb102-178"><a href="#cb102-178" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;Dieselbe Aufgabe in drei Groessen. Metaheuristik: </span><span class="sc">{</span>ZUEGE<span class="sc">:,}</span><span class="ss"> Zuege. &quot;</span></span>
-<span id="cb102-179"><a href="#cb102-179" aria-hidden="true" tabindex="-1"></a>          <span class="ss">f&quot;Exakt: </span><span class="sc">{</span>ZEITLIMIT<span class="sc">:.0f}</span><span class="ss"> s Zeitlimit.</span><span class="ch">\n</span><span class="ss">&quot;</span>)</span>
-<span id="cb102-180"><a href="#cb102-180" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb102-181"><a href="#cb102-181" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;</span><span class="sc">{</span><span class="st">&#39;Auftraege&#39;</span><span class="sc">:&gt;10}</span><span class="ss"> </span><span class="sc">{</span><span class="st">&#39;Faustregel&#39;</span><span class="sc">:&gt;11}</span><span class="ss"> </span><span class="sc">{</span><span class="st">&#39;Annealing&#39;</span><span class="sc">:&gt;10}</span><span class="ss"> &quot;</span></span>
-<span id="cb102-182"><a href="#cb102-182" aria-hidden="true" tabindex="-1"></a>          <span class="ss">f&quot;</span><span class="sc">{</span><span class="st">&#39;CP-SAT&#39;</span><span class="sc">:&gt;9}</span><span class="ss"> </span><span class="sc">{</span><span class="st">&#39;Status&#39;</span><span class="sc">:&gt;10}</span><span class="ss"> </span><span class="sc">{</span><span class="st">&#39;Schranke&#39;</span><span class="sc">:&gt;9}</span><span class="ss"> </span><span class="sc">{</span><span class="st">&#39;CP-Zeit&#39;</span><span class="sc">:&gt;9}</span><span class="ss">&quot;</span>)</span>
-<span id="cb102-183"><a href="#cb102-183" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;-&quot;</span> <span class="op">*</span> <span class="dv">88</span>)</span>
-<span id="cb102-184"><a href="#cb102-184" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb102-185"><a href="#cb102-185" aria-hidden="true" tabindex="-1"></a>    zeilen <span class="op">=</span> []</span>
-<span id="cb102-186"><a href="#cb102-186" aria-hidden="true" tabindex="-1"></a>    <span class="cf">for</span> n <span class="kw">in</span> GROESSEN:</span>
-<span id="cb102-187"><a href="#cb102-187" aria-hidden="true" tabindex="-1"></a>        matrix <span class="op">=</span> erzeuge_ruestmatrix(n)</span>
-<span id="cb102-188"><a href="#cb102-188" aria-hidden="true" tabindex="-1"></a>        start <span class="op">=</span> gesamtruestzeit(faustregel(matrix), matrix)</span>
-<span id="cb102-189"><a href="#cb102-189" aria-hidden="true" tabindex="-1"></a>        heuristisch, _ <span class="op">=</span> annealing(matrix)</span>
-<span id="cb102-190"><a href="#cb102-190" aria-hidden="true" tabindex="-1"></a>        status, wert, schranke, dauer <span class="op">=</span> exakt(matrix)</span>
-<span id="cb102-191"><a href="#cb102-191" aria-hidden="true" tabindex="-1"></a>        zeilen.append((n, start, heuristisch, wert, status, schranke, dauer))</span>
-<span id="cb102-192"><a href="#cb102-192" aria-hidden="true" tabindex="-1"></a>        <span class="bu">print</span>(<span class="ss">f&quot;</span><span class="sc">{</span>n<span class="sc">:&gt;10}</span><span class="ss"> </span><span class="sc">{</span>start<span class="sc">:&gt;11,}</span><span class="ss"> </span><span class="sc">{</span>heuristisch<span class="sc">:&gt;10,}</span><span class="ss"> </span><span class="sc">{</span>wert<span class="sc">:&gt;9,}</span><span class="ss"> &quot;</span></span>
-<span id="cb102-193"><a href="#cb102-193" aria-hidden="true" tabindex="-1"></a>              <span class="ss">f&quot;</span><span class="sc">{</span>status<span class="sc">:&gt;10}</span><span class="ss"> </span><span class="sc">{</span>schranke<span class="sc">:&gt;9,}</span><span class="ss"> </span><span class="sc">{</span>dauer<span class="sc">:&gt;8.1f}</span><span class="ss">s&quot;</span>)</span>
-<span id="cb102-194"><a href="#cb102-194" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb102-195"><a href="#cb102-195" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;-&quot;</span> <span class="op">*</span> <span class="dv">88</span>)</span>
-<span id="cb102-196"><a href="#cb102-196" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;</span><span class="ch">\n</span><span class="st">Was in jeder Zeile steht:</span><span class="ch">\n</span><span class="st">&quot;</span>)</span>
-<span id="cb102-197"><a href="#cb102-197" aria-hidden="true" tabindex="-1"></a>    <span class="cf">for</span> n, start, heur, wert, status, schranke, _ <span class="kw">in</span> zeilen:</span>
-<span id="cb102-198"><a href="#cb102-198" aria-hidden="true" tabindex="-1"></a>        <span class="cf">if</span> status <span class="op">==</span> <span class="st">&quot;OPTIMAL&quot;</span>:</span>
-<span id="cb102-199"><a href="#cb102-199" aria-hidden="true" tabindex="-1"></a>            urteil <span class="op">=</span> (<span class="ss">f&quot;CP-SAT beweist das Optimum. Annealing liegt &quot;</span></span>
-<span id="cb102-200"><a href="#cb102-200" aria-hidden="true" tabindex="-1"></a>                      <span class="ss">f&quot;</span><span class="sc">{</span>(heur <span class="op">-</span> wert) <span class="op">/</span> wert <span class="op">*</span> <span class="dv">100</span><span class="sc">:.1f}</span><span class="ss"> % daneben - und haette&quot;</span>)</span>
-<span id="cb102-201"><a href="#cb102-201" aria-hidden="true" tabindex="-1"></a>            zweite <span class="op">=</span> <span class="st">&quot;     das ohne den exakten Lauf nicht erfahren.&quot;</span></span>
-<span id="cb102-202"><a href="#cb102-202" aria-hidden="true" tabindex="-1"></a>        <span class="cf">elif</span> wert <span class="op">&lt;=</span> heur:</span>
-<span id="cb102-203"><a href="#cb102-203" aria-hidden="true" tabindex="-1"></a>            urteil <span class="op">=</span> (<span class="ss">f&quot;CP-SAT liegt </span><span class="sc">{</span>(heur <span class="op">-</span> wert) <span class="op">/</span> heur <span class="op">*</span> <span class="dv">100</span><span class="sc">:.1f}</span><span class="ss"> % vor Annealing, &quot;</span></span>
-<span id="cb102-204"><a href="#cb102-204" aria-hidden="true" tabindex="-1"></a>                      <span class="ss">f&quot;ohne Beweis (Gap </span><span class="sc">{</span>(wert <span class="op">-</span> schranke) <span class="op">/</span> wert <span class="op">*</span> <span class="dv">100</span><span class="sc">:.1f}</span><span class="ss"> %).&quot;</span>)</span>
-<span id="cb102-205"><a href="#cb102-205" aria-hidden="true" tabindex="-1"></a>            zweite <span class="op">=</span> <span class="st">&quot;     Auch ohne Optimalitaetsbeweis ist es die bessere Wahl.&quot;</span></span>
-<span id="cb102-206"><a href="#cb102-206" aria-hidden="true" tabindex="-1"></a>        <span class="cf">else</span>:</span>
-<span id="cb102-207"><a href="#cb102-207" aria-hidden="true" tabindex="-1"></a>            urteil <span class="op">=</span> (<span class="ss">f&quot;UMSCHLAGPUNKT: CP-SAT ist </span><span class="sc">{</span>(wert <span class="op">-</span> heur) <span class="op">/</span> heur <span class="op">*</span> <span class="dv">100</span><span class="sc">:.1f}</span><span class="ss"> % &quot;</span></span>
-<span id="cb102-208"><a href="#cb102-208" aria-hidden="true" tabindex="-1"></a>                      <span class="ss">f&quot;SCHLECHTER als Annealing&quot;</span>)</span>
-<span id="cb102-209"><a href="#cb102-209" aria-hidden="true" tabindex="-1"></a>            zweite <span class="op">=</span> (<span class="ss">f&quot;     und sogar </span><span class="sc">{</span>(wert <span class="op">-</span> start) <span class="op">/</span> start <span class="op">*</span> <span class="dv">100</span><span class="sc">:.1f}</span><span class="ss"> % schlechter &quot;</span></span>
-<span id="cb102-210"><a href="#cb102-210" aria-hidden="true" tabindex="-1"></a>                      <span class="ss">f&quot;als die Faustregel des Meisters.&quot;</span>)</span>
-<span id="cb102-211"><a href="#cb102-211" aria-hidden="true" tabindex="-1"></a>        <span class="bu">print</span>(<span class="ss">f&quot;  </span><span class="sc">{</span>n<span class="sc">:&gt;4}</span><span class="ss"> Auftraege: </span><span class="sc">{</span>urteil<span class="sc">}</span><span class="ss">&quot;</span>)</span>
-<span id="cb102-212"><a href="#cb102-212" aria-hidden="true" tabindex="-1"></a>        <span class="bu">print</span>(zweite)</span>
-<span id="cb102-213"><a href="#cb102-213" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb102-214"><a href="#cb102-214" aria-hidden="true" tabindex="-1"></a>    n, start, heur, wert, status, schranke, _ <span class="op">=</span> zeilen[<span class="op">-</span><span class="dv">1</span>]</span>
-<span id="cb102-215"><a href="#cb102-215" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;</span><span class="ch">\n</span><span class="st">&quot;</span> <span class="op">+</span> <span class="st">&quot;=&quot;</span> <span class="op">*</span> <span class="dv">88</span>)</span>
-<span id="cb102-216"><a href="#cb102-216" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;  DIE SPALTE, DIE MAN NICHT WEGLASSEN DARF&quot;</span>)</span>
-<span id="cb102-217"><a href="#cb102-217" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;=&quot;</span> <span class="op">*</span> <span class="dv">88</span>)</span>
-<span id="cb102-218"><a href="#cb102-218" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;Die Schranke ist der eigentliche Ertrag des exakten Solvers - auch dann,&quot;</span>)</span>
-<span id="cb102-219"><a href="#cb102-219" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;wenn seine LOESUNG unbrauchbar ist.&quot;</span>)</span>
-<span id="cb102-220"><a href="#cb102-220" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>()</span>
-<span id="cb102-221"><a href="#cb102-221" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;Bei </span><span class="sc">{</span>n<span class="sc">}</span><span class="ss"> Auftraegen liefert Annealing </span><span class="sc">{</span>heur<span class="sc">:,}</span><span class="ss"> Minuten. Klingt gut: &quot;</span></span>
-<span id="cb102-222"><a href="#cb102-222" aria-hidden="true" tabindex="-1"></a>          <span class="ss">f&quot;</span><span class="sc">{</span>(start <span class="op">-</span> heur) <span class="op">/</span> start <span class="op">*</span> <span class="dv">100</span><span class="sc">:.1f}</span><span class="ss"> %&quot;</span>)</span>
-<span id="cb102-223"><a href="#cb102-223" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;besser als die Faustregel. Die Schranke aus demselben CP-SAT-Lauf, dessen&quot;</span>)</span>
-<span id="cb102-224"><a href="#cb102-224" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;Loesung wir gerade verworfen haben, sagt aber: Unter </span><span class="sc">{</span>schranke<span class="sc">:,}</span><span class="ss"> Minuten geht&quot;</span>)</span>
-<span id="cb102-225"><a href="#cb102-225" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;es nicht. Zwischen </span><span class="sc">{</span>schranke<span class="sc">:,}</span><span class="ss"> und </span><span class="sc">{</span>heur<span class="sc">:,}</span><span class="ss"> liegen </span><span class="sc">{</span>(heur <span class="op">-</span> schranke) <span class="op">/</span> heur <span class="op">*</span> <span class="dv">100</span><span class="sc">:.0f}</span><span class="ss"> % - so viel Luft&quot;</span>)</span>
-<span id="cb102-226"><a href="#cb102-226" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;kann noch nach oben sein.&quot;</span>)</span>
-<span id="cb102-227"><a href="#cb102-227" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>()</span>
-<span id="cb102-228"><a href="#cb102-228" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;Das ist der Unterschied zwischen &#39;besser als vorher&#39; und &#39;gut&#39;. Eine&quot;</span>)</span>
-<span id="cb102-229"><a href="#cb102-229" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;Metaheuristik allein kann nur das Erste. Deshalb gehoert auch dann ein&quot;</span>)</span>
-<span id="cb102-230"><a href="#cb102-230" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;exakter Lauf dazu, wenn man am Ende die heuristische Loesung einsetzt:&quot;</span>)</span>
-<span id="cb102-231"><a href="#cb102-231" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;nicht wegen seiner Loesung, sondern wegen seiner Schranke.&quot;</span>)</span>
-<span id="cb102-232"><a href="#cb102-232" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;=&quot;</span> <span class="op">*</span> <span class="dv">88</span>)</span></code></pre></div>
+<div class="sourceCode" id="cb104"><pre class="sourceCode python"><code class="sourceCode python"><span id="cb104-1"><a href="#cb104-1" aria-hidden="true" tabindex="-1"></a><span class="co">#!/usr/bin/env python3</span></span>
+<span id="cb104-2"><a href="#cb104-2" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb104-3"><a href="#cb104-3" aria-hidden="true" tabindex="-1"></a><span class="co"># Metaheuristik_vs_Exakt.py</span></span>
+<span id="cb104-4"><a href="#cb104-4" aria-hidden="true" tabindex="-1"></a><span class="co">&quot;&quot;&quot;</span></span>
+<span id="cb104-5"><a href="#cb104-5" aria-hidden="true" tabindex="-1"></a><span class="co">Kapitel Metaheuristiken: Ab wann lohnt sich eine Metaheuristik? Die Antwort ist eine Zahl.</span></span>
+<span id="cb104-6"><a href="#cb104-6" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb104-7"><a href="#cb104-7" aria-hidden="true" tabindex="-1"></a><span class="co">Die verbreitete Regel lautet: &quot;Kleine Probleme exakt, grosse mit</span></span>
+<span id="cb104-8"><a href="#cb104-8" aria-hidden="true" tabindex="-1"></a><span class="co">Metaheuristiken.&quot; Sie ist richtig - aber voellig nutzlos, solange niemand sagt,</span></span>
+<span id="cb104-9"><a href="#cb104-9" aria-hidden="true" tabindex="-1"></a><span class="co">wo &#39;gross&#39; anfaengt. Dieses Programm misst es fuer die Ruestzeitenaufgabe aus</span></span>
+<span id="cb104-10"><a href="#cb104-10" aria-hidden="true" tabindex="-1"></a><span class="co">Simulated_Annealing.py nach, und das Ergebnis ueberrascht in beide Richtungen:</span></span>
+<span id="cb104-11"><a href="#cb104-11" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb104-12"><a href="#cb104-12" aria-hidden="true" tabindex="-1"></a><span class="co">  * Bei 60 Auftraegen loest CP-SAT BEWEISBAR optimal, in wenigen Sekunden.</span></span>
+<span id="cb104-13"><a href="#cb104-13" aria-hidden="true" tabindex="-1"></a><span class="co">    Die Metaheuristik ist hier schlicht die schlechtere Wahl - sie liefert ein</span></span>
+<span id="cb104-14"><a href="#cb104-14" aria-hidden="true" tabindex="-1"></a><span class="co">    schwaecheres Ergebnis und weiss nicht einmal, wie schwach.</span></span>
+<span id="cb104-15"><a href="#cb104-15" aria-hidden="true" tabindex="-1"></a><span class="co">  * Bei 200 Auftraegen liegt CP-SAT ohne Optimalitaetsbeweis vorne.</span></span>
+<span id="cb104-16"><a href="#cb104-16" aria-hidden="true" tabindex="-1"></a><span class="co">  * Erst bei 500 Auftraegen kippt es: Dort gibt CP-SAT im Zeitlimit eine</span></span>
+<span id="cb104-17"><a href="#cb104-17" aria-hidden="true" tabindex="-1"></a><span class="co">    Loesung aus, die SCHLECHTER ist als die Faustregel eines Meisters.</span></span>
+<span id="cb104-18"><a href="#cb104-18" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb104-19"><a href="#cb104-19" aria-hidden="true" tabindex="-1"></a><span class="co">Der Punkt des Kapitels steht in der letzten Spalte: Die Schranke. Nur der</span></span>
+<span id="cb104-20"><a href="#cb104-20" aria-hidden="true" tabindex="-1"></a><span class="co">exakte Solver sagt, wie gut die Loesung sein KANN. Eine Metaheuristik allein</span></span>
+<span id="cb104-21"><a href="#cb104-21" aria-hidden="true" tabindex="-1"></a><span class="co">liefert eine Zahl ohne Massstab - man weiss nie, ob man 2 % oder 40 % neben dem</span></span>
+<span id="cb104-22"><a href="#cb104-22" aria-hidden="true" tabindex="-1"></a><span class="co">Optimum liegt.</span></span>
+<span id="cb104-23"><a href="#cb104-23" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb104-24"><a href="#cb104-24" aria-hidden="true" tabindex="-1"></a><span class="co">ZUR REPRODUZIERBARKEIT: Die Spalte &#39;Annealing&#39; ist auf jeder Maschine gleich -</span></span>
+<span id="cb104-25"><a href="#cb104-25" aria-hidden="true" tabindex="-1"></a><span class="co">sie laeuft ueber ein festes ZUGbudget. Die CP-SAT-Spalten sind es nicht: Ein</span></span>
+<span id="cb104-26"><a href="#cb104-26" aria-hidden="true" tabindex="-1"></a><span class="co">Zeitlimit ist ein Wanduhr-Limit, und wie weit der Solver in 30 Sekunden kommt,</span></span>
+<span id="cb104-27"><a href="#cb104-27" aria-hidden="true" tabindex="-1"></a><span class="co">haengt von der Maschine ab. CP-SAT kennt zwar ein deterministisches Zeitmass</span></span>
+<span id="cb104-28"><a href="#cb104-28" aria-hidden="true" tabindex="-1"></a><span class="co">(max_deterministic_time), das aber in einer Groessenordnung rechnet, die fuer</span></span>
+<span id="cb104-29"><a href="#cb104-29" aria-hidden="true" tabindex="-1"></a><span class="co">ein Buchbeispiel unbrauchbar langsam ist. Die Zahlen unten sind also</span></span>
+<span id="cb104-30"><a href="#cb104-30" aria-hidden="true" tabindex="-1"></a><span class="co">hardwareabhaengig - die AUSSAGE der Tabelle ist es nicht, sie ist auf</span></span>
+<span id="cb104-31"><a href="#cb104-31" aria-hidden="true" tabindex="-1"></a><span class="co">verschiedenen Groessen und in mehreren Laeufen stabil.</span></span>
+<span id="cb104-32"><a href="#cb104-32" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb104-33"><a href="#cb104-33" aria-hidden="true" tabindex="-1"></a><span class="co">WICHTIG: Hier wird nur ortools importiert, nicht highspy (Kapitel Oekosystem).</span></span>
+<span id="cb104-34"><a href="#cb104-34" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb104-35"><a href="#cb104-35" aria-hidden="true" tabindex="-1"></a><span class="co">Benoetigt: numpy, ortools</span></span>
+<span id="cb104-36"><a href="#cb104-36" aria-hidden="true" tabindex="-1"></a><span class="co">&quot;&quot;&quot;</span></span>
+<span id="cb104-37"><a href="#cb104-37" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb104-38"><a href="#cb104-38" aria-hidden="true" tabindex="-1"></a><span class="im">from</span> __future__ <span class="im">import</span> annotations</span>
+<span id="cb104-39"><a href="#cb104-39" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb104-40"><a href="#cb104-40" aria-hidden="true" tabindex="-1"></a><span class="im">import</span> time</span>
+<span id="cb104-41"><a href="#cb104-41" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb104-42"><a href="#cb104-42" aria-hidden="true" tabindex="-1"></a><span class="im">import</span> numpy <span class="im">as</span> np</span>
+<span id="cb104-43"><a href="#cb104-43" aria-hidden="true" tabindex="-1"></a><span class="im">from</span> ortools.sat.python <span class="im">import</span> cp_model</span>
+<span id="cb104-44"><a href="#cb104-44" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb104-45"><a href="#cb104-45" aria-hidden="true" tabindex="-1"></a>ZUEGE <span class="op">=</span> <span class="dv">400_000</span>           <span class="co"># Zugbudget der Metaheuristik (wie Simulated_Annealing.py)</span></span>
+<span id="cb104-46"><a href="#cb104-46" aria-hidden="true" tabindex="-1"></a>ZEITLIMIT <span class="op">=</span> <span class="fl">30.0</span>          <span class="co"># Zeitbudget des exakten Solvers</span></span>
+<span id="cb104-47"><a href="#cb104-47" aria-hidden="true" tabindex="-1"></a>GROESSEN <span class="op">=</span> (<span class="dv">60</span>, <span class="dv">200</span>, <span class="dv">500</span>)</span>
+<span id="cb104-48"><a href="#cb104-48" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb104-49"><a href="#cb104-49" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb104-50"><a href="#cb104-50" aria-hidden="true" tabindex="-1"></a><span class="co"># --- Instanz, Faustregel und Suche: identisch zu Simulated_Annealing.py -----</span></span>
+<span id="cb104-51"><a href="#cb104-51" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb104-52"><a href="#cb104-52" aria-hidden="true" tabindex="-1"></a><span class="kw">def</span> erzeuge_ruestmatrix(n: <span class="bu">int</span>, saat: <span class="bu">int</span> <span class="op">=</span> <span class="dv">11</span>) <span class="op">-&gt;</span> np.ndarray:</span>
+<span id="cb104-53"><a href="#cb104-53" aria-hidden="true" tabindex="-1"></a>    rng <span class="op">=</span> np.random.default_rng(saat)</span>
+<span id="cb104-54"><a href="#cb104-54" aria-hidden="true" tabindex="-1"></a>    familien <span class="op">=</span> <span class="bu">max</span>(<span class="dv">6</span>, n <span class="op">//</span> <span class="dv">10</span>)</span>
+<span id="cb104-55"><a href="#cb104-55" aria-hidden="true" tabindex="-1"></a>    zwischen <span class="op">=</span> rng.integers(<span class="dv">8</span>, <span class="dv">60</span>, (familien, familien))</span>
+<span id="cb104-56"><a href="#cb104-56" aria-hidden="true" tabindex="-1"></a>    np.fill_diagonal(zwischen, <span class="dv">2</span>)</span>
+<span id="cb104-57"><a href="#cb104-57" aria-hidden="true" tabindex="-1"></a>    familie <span class="op">=</span> rng.integers(<span class="dv">0</span>, familien, n)</span>
+<span id="cb104-58"><a href="#cb104-58" aria-hidden="true" tabindex="-1"></a>    farbe <span class="op">=</span> rng.integers(<span class="dv">0</span>, <span class="dv">10</span>, n)</span>
+<span id="cb104-59"><a href="#cb104-59" aria-hidden="true" tabindex="-1"></a>    matrix <span class="op">=</span> np.zeros((n, n), dtype<span class="op">=</span>np.int64)</span>
+<span id="cb104-60"><a href="#cb104-60" aria-hidden="true" tabindex="-1"></a>    <span class="cf">for</span> i <span class="kw">in</span> <span class="bu">range</span>(n):</span>
+<span id="cb104-61"><a href="#cb104-61" aria-hidden="true" tabindex="-1"></a>        <span class="cf">for</span> j <span class="kw">in</span> <span class="bu">range</span>(n):</span>
+<span id="cb104-62"><a href="#cb104-62" aria-hidden="true" tabindex="-1"></a>            <span class="cf">if</span> i <span class="op">!=</span> j:</span>
+<span id="cb104-63"><a href="#cb104-63" aria-hidden="true" tabindex="-1"></a>                matrix[i, j] <span class="op">=</span> (zwischen[familie[i], familie[j]]</span>
+<span id="cb104-64"><a href="#cb104-64" aria-hidden="true" tabindex="-1"></a>                                <span class="op">+</span> <span class="dv">3</span> <span class="op">*</span> <span class="bu">max</span>(<span class="dv">0</span>, farbe[i] <span class="op">-</span> farbe[j]))</span>
+<span id="cb104-65"><a href="#cb104-65" aria-hidden="true" tabindex="-1"></a>    <span class="cf">return</span> matrix</span>
+<span id="cb104-66"><a href="#cb104-66" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb104-67"><a href="#cb104-67" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb104-68"><a href="#cb104-68" aria-hidden="true" tabindex="-1"></a><span class="kw">def</span> gesamtruestzeit(reihe: <span class="bu">list</span>[<span class="bu">int</span>], matrix: np.ndarray) <span class="op">-&gt;</span> <span class="bu">int</span>:</span>
+<span id="cb104-69"><a href="#cb104-69" aria-hidden="true" tabindex="-1"></a>    <span class="cf">return</span> <span class="bu">int</span>(<span class="bu">sum</span>(matrix[reihe[k], reihe[k <span class="op">+</span> <span class="dv">1</span>]] <span class="cf">for</span> k <span class="kw">in</span> <span class="bu">range</span>(<span class="bu">len</span>(reihe) <span class="op">-</span> <span class="dv">1</span>)))</span>
+<span id="cb104-70"><a href="#cb104-70" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb104-71"><a href="#cb104-71" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb104-72"><a href="#cb104-72" aria-hidden="true" tabindex="-1"></a><span class="kw">def</span> faustregel(matrix: np.ndarray) <span class="op">-&gt;</span> <span class="bu">list</span>[<span class="bu">int</span>]:</span>
+<span id="cb104-73"><a href="#cb104-73" aria-hidden="true" tabindex="-1"></a>    n <span class="op">=</span> <span class="bu">len</span>(matrix)</span>
+<span id="cb104-74"><a href="#cb104-74" aria-hidden="true" tabindex="-1"></a>    offen <span class="op">=</span> <span class="bu">set</span>(<span class="bu">range</span>(<span class="dv">1</span>, n))</span>
+<span id="cb104-75"><a href="#cb104-75" aria-hidden="true" tabindex="-1"></a>    reihe <span class="op">=</span> [<span class="dv">0</span>]</span>
+<span id="cb104-76"><a href="#cb104-76" aria-hidden="true" tabindex="-1"></a>    <span class="cf">while</span> offen:</span>
+<span id="cb104-77"><a href="#cb104-77" aria-hidden="true" tabindex="-1"></a>        naechster <span class="op">=</span> <span class="bu">min</span>(offen, key<span class="op">=</span><span class="kw">lambda</span> j: matrix[reihe[<span class="op">-</span><span class="dv">1</span>], j])</span>
+<span id="cb104-78"><a href="#cb104-78" aria-hidden="true" tabindex="-1"></a>        reihe.append(naechster)</span>
+<span id="cb104-79"><a href="#cb104-79" aria-hidden="true" tabindex="-1"></a>        offen.discard(naechster)</span>
+<span id="cb104-80"><a href="#cb104-80" aria-hidden="true" tabindex="-1"></a>    <span class="cf">return</span> reihe</span>
+<span id="cb104-81"><a href="#cb104-81" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb104-82"><a href="#cb104-82" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb104-83"><a href="#cb104-83" aria-hidden="true" tabindex="-1"></a><span class="kw">def</span> delta_verschieben(reihe, matrix, von, nach):</span>
+<span id="cb104-84"><a href="#cb104-84" aria-hidden="true" tabindex="-1"></a>    n <span class="op">=</span> <span class="bu">len</span>(reihe)</span>
+<span id="cb104-85"><a href="#cb104-85" aria-hidden="true" tabindex="-1"></a>    <span class="cf">if</span> von <span class="op">==</span> nach <span class="kw">or</span> nach <span class="op">==</span> von <span class="op">+</span> <span class="dv">1</span>:</span>
+<span id="cb104-86"><a href="#cb104-86" aria-hidden="true" tabindex="-1"></a>        <span class="cf">return</span> <span class="va">None</span></span>
+<span id="cb104-87"><a href="#cb104-87" aria-hidden="true" tabindex="-1"></a>    heraus <span class="op">=</span> <span class="dv">0</span></span>
+<span id="cb104-88"><a href="#cb104-88" aria-hidden="true" tabindex="-1"></a>    <span class="cf">if</span> von <span class="op">&gt;</span> <span class="dv">0</span>:</span>
+<span id="cb104-89"><a href="#cb104-89" aria-hidden="true" tabindex="-1"></a>        heraus <span class="op">+=</span> matrix[reihe[von <span class="op">-</span> <span class="dv">1</span>], reihe[von]]</span>
+<span id="cb104-90"><a href="#cb104-90" aria-hidden="true" tabindex="-1"></a>    <span class="cf">if</span> von <span class="op">&lt;</span> n <span class="op">-</span> <span class="dv">1</span>:</span>
+<span id="cb104-91"><a href="#cb104-91" aria-hidden="true" tabindex="-1"></a>        heraus <span class="op">+=</span> matrix[reihe[von], reihe[von <span class="op">+</span> <span class="dv">1</span>]]</span>
+<span id="cb104-92"><a href="#cb104-92" aria-hidden="true" tabindex="-1"></a>    <span class="cf">if</span> <span class="dv">0</span> <span class="op">&lt;</span> von <span class="op">&lt;</span> n <span class="op">-</span> <span class="dv">1</span>:</span>
+<span id="cb104-93"><a href="#cb104-93" aria-hidden="true" tabindex="-1"></a>        heraus <span class="op">-=</span> matrix[reihe[von <span class="op">-</span> <span class="dv">1</span>], reihe[von <span class="op">+</span> <span class="dv">1</span>]]</span>
+<span id="cb104-94"><a href="#cb104-94" aria-hidden="true" tabindex="-1"></a>    rest <span class="op">=</span> reihe[:von] <span class="op">+</span> reihe[von <span class="op">+</span> <span class="dv">1</span>:]</span>
+<span id="cb104-95"><a href="#cb104-95" aria-hidden="true" tabindex="-1"></a>    stelle <span class="op">=</span> nach <span class="cf">if</span> nach <span class="op">&lt;</span> von <span class="cf">else</span> nach <span class="op">-</span> <span class="dv">1</span></span>
+<span id="cb104-96"><a href="#cb104-96" aria-hidden="true" tabindex="-1"></a>    hinein <span class="op">=</span> <span class="dv">0</span></span>
+<span id="cb104-97"><a href="#cb104-97" aria-hidden="true" tabindex="-1"></a>    <span class="cf">if</span> stelle <span class="op">&gt;</span> <span class="dv">0</span>:</span>
+<span id="cb104-98"><a href="#cb104-98" aria-hidden="true" tabindex="-1"></a>        hinein <span class="op">+=</span> matrix[rest[stelle <span class="op">-</span> <span class="dv">1</span>], reihe[von]]</span>
+<span id="cb104-99"><a href="#cb104-99" aria-hidden="true" tabindex="-1"></a>    <span class="cf">if</span> stelle <span class="op">&lt;</span> <span class="bu">len</span>(rest):</span>
+<span id="cb104-100"><a href="#cb104-100" aria-hidden="true" tabindex="-1"></a>        hinein <span class="op">+=</span> matrix[reihe[von], rest[stelle]]</span>
+<span id="cb104-101"><a href="#cb104-101" aria-hidden="true" tabindex="-1"></a>    <span class="cf">if</span> <span class="dv">0</span> <span class="op">&lt;</span> stelle <span class="op">&lt;</span> <span class="bu">len</span>(rest):</span>
+<span id="cb104-102"><a href="#cb104-102" aria-hidden="true" tabindex="-1"></a>        hinein <span class="op">-=</span> matrix[rest[stelle <span class="op">-</span> <span class="dv">1</span>], rest[stelle]]</span>
+<span id="cb104-103"><a href="#cb104-103" aria-hidden="true" tabindex="-1"></a>    <span class="cf">return</span> <span class="bu">int</span>(hinein <span class="op">-</span> heraus), rest, stelle</span>
+<span id="cb104-104"><a href="#cb104-104" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb104-105"><a href="#cb104-105" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb104-106"><a href="#cb104-106" aria-hidden="true" tabindex="-1"></a><span class="kw">def</span> annealing(matrix: np.ndarray, zuege: <span class="bu">int</span> <span class="op">=</span> ZUEGE,</span>
+<span id="cb104-107"><a href="#cb104-107" aria-hidden="true" tabindex="-1"></a>              start_temperatur: <span class="bu">float</span> <span class="op">=</span> <span class="fl">1.0</span>, saat: <span class="bu">int</span> <span class="op">=</span> <span class="dv">1</span>) <span class="op">-&gt;</span> <span class="bu">tuple</span>[<span class="bu">int</span>, <span class="bu">float</span>]:</span>
+<span id="cb104-108"><a href="#cb104-108" aria-hidden="true" tabindex="-1"></a>    <span class="co">&quot;&quot;&quot;Dieselbe Suche wie in Simulated_Annealing.py, hier nur als Vergleichswert.&quot;&quot;&quot;</span></span>
+<span id="cb104-109"><a href="#cb104-109" aria-hidden="true" tabindex="-1"></a>    <span class="im">import</span> math</span>
+<span id="cb104-110"><a href="#cb104-110" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb104-111"><a href="#cb104-111" aria-hidden="true" tabindex="-1"></a>    rng <span class="op">=</span> np.random.default_rng(saat)</span>
+<span id="cb104-112"><a href="#cb104-112" aria-hidden="true" tabindex="-1"></a>    n <span class="op">=</span> <span class="bu">len</span>(matrix)</span>
+<span id="cb104-113"><a href="#cb104-113" aria-hidden="true" tabindex="-1"></a>    reihe <span class="op">=</span> faustregel(matrix)</span>
+<span id="cb104-114"><a href="#cb104-114" aria-hidden="true" tabindex="-1"></a>    kosten <span class="op">=</span> gesamtruestzeit(reihe, matrix)</span>
+<span id="cb104-115"><a href="#cb104-115" aria-hidden="true" tabindex="-1"></a>    beste_kosten <span class="op">=</span> kosten</span>
+<span id="cb104-116"><a href="#cb104-116" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb104-117"><a href="#cb104-117" aria-hidden="true" tabindex="-1"></a>    t0 <span class="op">=</span> time.perf_counter()</span>
+<span id="cb104-118"><a href="#cb104-118" aria-hidden="true" tabindex="-1"></a>    <span class="cf">for</span> zug <span class="kw">in</span> <span class="bu">range</span>(zuege):</span>
+<span id="cb104-119"><a href="#cb104-119" aria-hidden="true" tabindex="-1"></a>        temperatur <span class="op">=</span> start_temperatur <span class="op">*</span> (<span class="fl">0.05</span> <span class="op">/</span> start_temperatur) <span class="op">**</span> (zug <span class="op">/</span> zuege)</span>
+<span id="cb104-120"><a href="#cb104-120" aria-hidden="true" tabindex="-1"></a>        von <span class="op">=</span> <span class="bu">int</span>(rng.integers(<span class="dv">0</span>, n))</span>
+<span id="cb104-121"><a href="#cb104-121" aria-hidden="true" tabindex="-1"></a>        nach <span class="op">=</span> <span class="bu">int</span>(rng.integers(<span class="dv">0</span>, n <span class="op">+</span> <span class="dv">1</span>))</span>
+<span id="cb104-122"><a href="#cb104-122" aria-hidden="true" tabindex="-1"></a>        ergebnis <span class="op">=</span> delta_verschieben(reihe, matrix, von, nach)</span>
+<span id="cb104-123"><a href="#cb104-123" aria-hidden="true" tabindex="-1"></a>        <span class="cf">if</span> ergebnis <span class="kw">is</span> <span class="va">None</span>:</span>
+<span id="cb104-124"><a href="#cb104-124" aria-hidden="true" tabindex="-1"></a>            <span class="cf">continue</span></span>
+<span id="cb104-125"><a href="#cb104-125" aria-hidden="true" tabindex="-1"></a>        aenderung, rest, stelle <span class="op">=</span> ergebnis</span>
+<span id="cb104-126"><a href="#cb104-126" aria-hidden="true" tabindex="-1"></a>        <span class="cf">if</span> aenderung <span class="op">&lt;=</span> <span class="dv">0</span> <span class="kw">or</span> rng.random() <span class="op">&lt;</span> math.exp(<span class="op">-</span>aenderung <span class="op">/</span> temperatur):</span>
+<span id="cb104-127"><a href="#cb104-127" aria-hidden="true" tabindex="-1"></a>            reihe <span class="op">=</span> rest[:stelle] <span class="op">+</span> [reihe[von]] <span class="op">+</span> rest[stelle:]</span>
+<span id="cb104-128"><a href="#cb104-128" aria-hidden="true" tabindex="-1"></a>            kosten <span class="op">+=</span> aenderung</span>
+<span id="cb104-129"><a href="#cb104-129" aria-hidden="true" tabindex="-1"></a>            beste_kosten <span class="op">=</span> <span class="bu">min</span>(beste_kosten, kosten)</span>
+<span id="cb104-130"><a href="#cb104-130" aria-hidden="true" tabindex="-1"></a>    <span class="cf">return</span> beste_kosten, time.perf_counter() <span class="op">-</span> t0</span>
+<span id="cb104-131"><a href="#cb104-131" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb104-132"><a href="#cb104-132" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb104-133"><a href="#cb104-133" aria-hidden="true" tabindex="-1"></a><span class="co"># --- Der exakte Weg: CP-SAT mit AddCircuit ---------------------------------</span></span>
+<span id="cb104-134"><a href="#cb104-134" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb104-135"><a href="#cb104-135" aria-hidden="true" tabindex="-1"></a><span class="kw">def</span> exakt(matrix: np.ndarray, zeitlimit: <span class="bu">float</span> <span class="op">=</span> ZEITLIMIT):</span>
+<span id="cb104-136"><a href="#cb104-136" aria-hidden="true" tabindex="-1"></a>    <span class="co">&quot;&quot;&quot;Reihenfolge als Rundreise mit einem kostenlosen Hilfsknoten.</span></span>
+<span id="cb104-137"><a href="#cb104-137" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb104-138"><a href="#cb104-138" aria-hidden="true" tabindex="-1"></a><span class="co">    AddCircuit verlangt einen geschlossenen Kreis. Unsere Aufgabe ist aber eine</span></span>
+<span id="cb104-139"><a href="#cb104-139" aria-hidden="true" tabindex="-1"></a><span class="co">    offene Kette: Der erste Auftrag hat keinen Vorgaenger, der letzte keinen</span></span>
+<span id="cb104-140"><a href="#cb104-140" aria-hidden="true" tabindex="-1"></a><span class="co">    Nachfolger. Der uebliche Kniff ist ein zusaetzlicher Hilfsknoten n, dessen</span></span>
+<span id="cb104-141"><a href="#cb104-141" aria-hidden="true" tabindex="-1"></a><span class="co">    Kanten nichts kosten. Der Kreis laeuft dann Hilfsknoten -&gt; Kette -&gt;</span></span>
+<span id="cb104-142"><a href="#cb104-142" aria-hidden="true" tabindex="-1"></a><span class="co">    Hilfsknoten, und die Kosten des Kreises sind genau die der Kette.</span></span>
+<span id="cb104-143"><a href="#cb104-143" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb104-144"><a href="#cb104-144" aria-hidden="true" tabindex="-1"></a><span class="co">    AddCircuit ist der Grund, warum CP-SAT hier so lange mithaelt: Die</span></span>
+<span id="cb104-145"><a href="#cb104-145" aria-hidden="true" tabindex="-1"></a><span class="co">    Nebenbedingung sorgt selbst dafuer, dass keine Teilkreise entstehen. Wer</span></span>
+<span id="cb104-146"><a href="#cb104-146" aria-hidden="true" tabindex="-1"></a><span class="co">    dasselbe als MILP formuliert, braucht dafuer entweder exponentiell viele</span></span>
+<span id="cb104-147"><a href="#cb104-147" aria-hidden="true" tabindex="-1"></a><span class="co">    Ungleichungen oder die schwache MTZ-Formulierung (Kapitel Graphen).</span></span>
+<span id="cb104-148"><a href="#cb104-148" aria-hidden="true" tabindex="-1"></a><span class="co">    &quot;&quot;&quot;</span></span>
+<span id="cb104-149"><a href="#cb104-149" aria-hidden="true" tabindex="-1"></a>    n <span class="op">=</span> <span class="bu">len</span>(matrix)</span>
+<span id="cb104-150"><a href="#cb104-150" aria-hidden="true" tabindex="-1"></a>    modell <span class="op">=</span> cp_model.CpModel()</span>
+<span id="cb104-151"><a href="#cb104-151" aria-hidden="true" tabindex="-1"></a>    kanten, ziel <span class="op">=</span> [], []</span>
+<span id="cb104-152"><a href="#cb104-152" aria-hidden="true" tabindex="-1"></a>    <span class="cf">for</span> i <span class="kw">in</span> <span class="bu">range</span>(n <span class="op">+</span> <span class="dv">1</span>):</span>
+<span id="cb104-153"><a href="#cb104-153" aria-hidden="true" tabindex="-1"></a>        <span class="cf">for</span> j <span class="kw">in</span> <span class="bu">range</span>(n <span class="op">+</span> <span class="dv">1</span>):</span>
+<span id="cb104-154"><a href="#cb104-154" aria-hidden="true" tabindex="-1"></a>            <span class="cf">if</span> i <span class="op">==</span> j:</span>
+<span id="cb104-155"><a href="#cb104-155" aria-hidden="true" tabindex="-1"></a>                <span class="cf">continue</span></span>
+<span id="cb104-156"><a href="#cb104-156" aria-hidden="true" tabindex="-1"></a>            aktiv <span class="op">=</span> modell.NewBoolVar(<span class="ss">f&quot;kante_</span><span class="sc">{</span>i<span class="sc">}</span><span class="ss">_</span><span class="sc">{</span>j<span class="sc">}</span><span class="ss">&quot;</span>)</span>
+<span id="cb104-157"><a href="#cb104-157" aria-hidden="true" tabindex="-1"></a>            kanten.append((i, j, aktiv))</span>
+<span id="cb104-158"><a href="#cb104-158" aria-hidden="true" tabindex="-1"></a>            <span class="cf">if</span> i <span class="op">&lt;</span> n <span class="kw">and</span> j <span class="op">&lt;</span> n:                  <span class="co"># Hilfsknoten kostet nichts</span></span>
+<span id="cb104-159"><a href="#cb104-159" aria-hidden="true" tabindex="-1"></a>                ziel.append(<span class="bu">int</span>(matrix[i, j]) <span class="op">*</span> aktiv)</span>
+<span id="cb104-160"><a href="#cb104-160" aria-hidden="true" tabindex="-1"></a>    modell.AddCircuit(kanten)</span>
+<span id="cb104-161"><a href="#cb104-161" aria-hidden="true" tabindex="-1"></a>    modell.Minimize(<span class="bu">sum</span>(ziel))</span>
+<span id="cb104-162"><a href="#cb104-162" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb104-163"><a href="#cb104-163" aria-hidden="true" tabindex="-1"></a>    loeser <span class="op">=</span> cp_model.CpSolver()</span>
+<span id="cb104-164"><a href="#cb104-164" aria-hidden="true" tabindex="-1"></a>    loeser.parameters.max_time_in_seconds <span class="op">=</span> zeitlimit</span>
+<span id="cb104-165"><a href="#cb104-165" aria-hidden="true" tabindex="-1"></a>    loeser.parameters.num_workers <span class="op">=</span> <span class="dv">8</span></span>
+<span id="cb104-166"><a href="#cb104-166" aria-hidden="true" tabindex="-1"></a>    loeser.parameters.random_seed <span class="op">=</span> <span class="dv">1</span></span>
+<span id="cb104-167"><a href="#cb104-167" aria-hidden="true" tabindex="-1"></a>    t0 <span class="op">=</span> time.perf_counter()</span>
+<span id="cb104-168"><a href="#cb104-168" aria-hidden="true" tabindex="-1"></a>    status <span class="op">=</span> loeser.Solve(modell)</span>
+<span id="cb104-169"><a href="#cb104-169" aria-hidden="true" tabindex="-1"></a>    dauer <span class="op">=</span> time.perf_counter() <span class="op">-</span> t0</span>
+<span id="cb104-170"><a href="#cb104-170" aria-hidden="true" tabindex="-1"></a>    <span class="cf">return</span> (loeser.StatusName(status), <span class="bu">int</span>(loeser.ObjectiveValue()),</span>
+<span id="cb104-171"><a href="#cb104-171" aria-hidden="true" tabindex="-1"></a>            <span class="bu">int</span>(loeser.BestObjectiveBound()), dauer)</span>
+<span id="cb104-172"><a href="#cb104-172" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb104-173"><a href="#cb104-173" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb104-174"><a href="#cb104-174" aria-hidden="true" tabindex="-1"></a><span class="cf">if</span> <span class="va">__name__</span> <span class="op">==</span> <span class="st">&quot;__main__&quot;</span>:</span>
+<span id="cb104-175"><a href="#cb104-175" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;=&quot;</span> <span class="op">*</span> <span class="dv">88</span>)</span>
+<span id="cb104-176"><a href="#cb104-176" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;  AB WANN LOHNT SICH DIE METAHEURISTIK?&quot;</span>)</span>
+<span id="cb104-177"><a href="#cb104-177" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;=&quot;</span> <span class="op">*</span> <span class="dv">88</span>)</span>
+<span id="cb104-178"><a href="#cb104-178" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;Dieselbe Aufgabe in drei Groessen. Metaheuristik: </span><span class="sc">{</span>ZUEGE<span class="sc">:,}</span><span class="ss"> Zuege. &quot;</span></span>
+<span id="cb104-179"><a href="#cb104-179" aria-hidden="true" tabindex="-1"></a>          <span class="ss">f&quot;Exakt: </span><span class="sc">{</span>ZEITLIMIT<span class="sc">:.0f}</span><span class="ss"> s Zeitlimit.</span><span class="ch">\n</span><span class="ss">&quot;</span>)</span>
+<span id="cb104-180"><a href="#cb104-180" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb104-181"><a href="#cb104-181" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;</span><span class="sc">{</span><span class="st">&#39;Auftraege&#39;</span><span class="sc">:&gt;10}</span><span class="ss"> </span><span class="sc">{</span><span class="st">&#39;Faustregel&#39;</span><span class="sc">:&gt;11}</span><span class="ss"> </span><span class="sc">{</span><span class="st">&#39;Annealing&#39;</span><span class="sc">:&gt;10}</span><span class="ss"> &quot;</span></span>
+<span id="cb104-182"><a href="#cb104-182" aria-hidden="true" tabindex="-1"></a>          <span class="ss">f&quot;</span><span class="sc">{</span><span class="st">&#39;CP-SAT&#39;</span><span class="sc">:&gt;9}</span><span class="ss"> </span><span class="sc">{</span><span class="st">&#39;Status&#39;</span><span class="sc">:&gt;10}</span><span class="ss"> </span><span class="sc">{</span><span class="st">&#39;Schranke&#39;</span><span class="sc">:&gt;9}</span><span class="ss"> </span><span class="sc">{</span><span class="st">&#39;CP-Zeit&#39;</span><span class="sc">:&gt;9}</span><span class="ss">&quot;</span>)</span>
+<span id="cb104-183"><a href="#cb104-183" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;-&quot;</span> <span class="op">*</span> <span class="dv">88</span>)</span>
+<span id="cb104-184"><a href="#cb104-184" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb104-185"><a href="#cb104-185" aria-hidden="true" tabindex="-1"></a>    zeilen <span class="op">=</span> []</span>
+<span id="cb104-186"><a href="#cb104-186" aria-hidden="true" tabindex="-1"></a>    <span class="cf">for</span> n <span class="kw">in</span> GROESSEN:</span>
+<span id="cb104-187"><a href="#cb104-187" aria-hidden="true" tabindex="-1"></a>        matrix <span class="op">=</span> erzeuge_ruestmatrix(n)</span>
+<span id="cb104-188"><a href="#cb104-188" aria-hidden="true" tabindex="-1"></a>        start <span class="op">=</span> gesamtruestzeit(faustregel(matrix), matrix)</span>
+<span id="cb104-189"><a href="#cb104-189" aria-hidden="true" tabindex="-1"></a>        heuristisch, _ <span class="op">=</span> annealing(matrix)</span>
+<span id="cb104-190"><a href="#cb104-190" aria-hidden="true" tabindex="-1"></a>        status, wert, schranke, dauer <span class="op">=</span> exakt(matrix)</span>
+<span id="cb104-191"><a href="#cb104-191" aria-hidden="true" tabindex="-1"></a>        zeilen.append((n, start, heuristisch, wert, status, schranke, dauer))</span>
+<span id="cb104-192"><a href="#cb104-192" aria-hidden="true" tabindex="-1"></a>        <span class="bu">print</span>(<span class="ss">f&quot;</span><span class="sc">{</span>n<span class="sc">:&gt;10}</span><span class="ss"> </span><span class="sc">{</span>start<span class="sc">:&gt;11,}</span><span class="ss"> </span><span class="sc">{</span>heuristisch<span class="sc">:&gt;10,}</span><span class="ss"> </span><span class="sc">{</span>wert<span class="sc">:&gt;9,}</span><span class="ss"> &quot;</span></span>
+<span id="cb104-193"><a href="#cb104-193" aria-hidden="true" tabindex="-1"></a>              <span class="ss">f&quot;</span><span class="sc">{</span>status<span class="sc">:&gt;10}</span><span class="ss"> </span><span class="sc">{</span>schranke<span class="sc">:&gt;9,}</span><span class="ss"> </span><span class="sc">{</span>dauer<span class="sc">:&gt;8.1f}</span><span class="ss">s&quot;</span>)</span>
+<span id="cb104-194"><a href="#cb104-194" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb104-195"><a href="#cb104-195" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;-&quot;</span> <span class="op">*</span> <span class="dv">88</span>)</span>
+<span id="cb104-196"><a href="#cb104-196" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;</span><span class="ch">\n</span><span class="st">Was in jeder Zeile steht:</span><span class="ch">\n</span><span class="st">&quot;</span>)</span>
+<span id="cb104-197"><a href="#cb104-197" aria-hidden="true" tabindex="-1"></a>    <span class="cf">for</span> n, start, heur, wert, status, schranke, _ <span class="kw">in</span> zeilen:</span>
+<span id="cb104-198"><a href="#cb104-198" aria-hidden="true" tabindex="-1"></a>        <span class="cf">if</span> status <span class="op">==</span> <span class="st">&quot;OPTIMAL&quot;</span>:</span>
+<span id="cb104-199"><a href="#cb104-199" aria-hidden="true" tabindex="-1"></a>            urteil <span class="op">=</span> (<span class="ss">f&quot;CP-SAT beweist das Optimum. Annealing liegt &quot;</span></span>
+<span id="cb104-200"><a href="#cb104-200" aria-hidden="true" tabindex="-1"></a>                      <span class="ss">f&quot;</span><span class="sc">{</span>(heur <span class="op">-</span> wert) <span class="op">/</span> wert <span class="op">*</span> <span class="dv">100</span><span class="sc">:.1f}</span><span class="ss"> % daneben - und haette&quot;</span>)</span>
+<span id="cb104-201"><a href="#cb104-201" aria-hidden="true" tabindex="-1"></a>            zweite <span class="op">=</span> <span class="st">&quot;     das ohne den exakten Lauf nicht erfahren.&quot;</span></span>
+<span id="cb104-202"><a href="#cb104-202" aria-hidden="true" tabindex="-1"></a>        <span class="cf">elif</span> wert <span class="op">&lt;=</span> heur:</span>
+<span id="cb104-203"><a href="#cb104-203" aria-hidden="true" tabindex="-1"></a>            urteil <span class="op">=</span> (<span class="ss">f&quot;CP-SAT liegt </span><span class="sc">{</span>(heur <span class="op">-</span> wert) <span class="op">/</span> heur <span class="op">*</span> <span class="dv">100</span><span class="sc">:.1f}</span><span class="ss"> % vor Annealing, &quot;</span></span>
+<span id="cb104-204"><a href="#cb104-204" aria-hidden="true" tabindex="-1"></a>                      <span class="ss">f&quot;ohne Beweis (Gap </span><span class="sc">{</span>(wert <span class="op">-</span> schranke) <span class="op">/</span> wert <span class="op">*</span> <span class="dv">100</span><span class="sc">:.1f}</span><span class="ss"> %).&quot;</span>)</span>
+<span id="cb104-205"><a href="#cb104-205" aria-hidden="true" tabindex="-1"></a>            zweite <span class="op">=</span> <span class="st">&quot;     Auch ohne Optimalitaetsbeweis ist es die bessere Wahl.&quot;</span></span>
+<span id="cb104-206"><a href="#cb104-206" aria-hidden="true" tabindex="-1"></a>        <span class="cf">else</span>:</span>
+<span id="cb104-207"><a href="#cb104-207" aria-hidden="true" tabindex="-1"></a>            urteil <span class="op">=</span> (<span class="ss">f&quot;UMSCHLAGPUNKT: CP-SAT ist </span><span class="sc">{</span>(wert <span class="op">-</span> heur) <span class="op">/</span> heur <span class="op">*</span> <span class="dv">100</span><span class="sc">:.1f}</span><span class="ss"> % &quot;</span></span>
+<span id="cb104-208"><a href="#cb104-208" aria-hidden="true" tabindex="-1"></a>                      <span class="ss">f&quot;SCHLECHTER als Annealing&quot;</span>)</span>
+<span id="cb104-209"><a href="#cb104-209" aria-hidden="true" tabindex="-1"></a>            zweite <span class="op">=</span> (<span class="ss">f&quot;     und sogar </span><span class="sc">{</span>(wert <span class="op">-</span> start) <span class="op">/</span> start <span class="op">*</span> <span class="dv">100</span><span class="sc">:.1f}</span><span class="ss"> % schlechter &quot;</span></span>
+<span id="cb104-210"><a href="#cb104-210" aria-hidden="true" tabindex="-1"></a>                      <span class="ss">f&quot;als die Faustregel des Meisters.&quot;</span>)</span>
+<span id="cb104-211"><a href="#cb104-211" aria-hidden="true" tabindex="-1"></a>        <span class="bu">print</span>(<span class="ss">f&quot;  </span><span class="sc">{</span>n<span class="sc">:&gt;4}</span><span class="ss"> Auftraege: </span><span class="sc">{</span>urteil<span class="sc">}</span><span class="ss">&quot;</span>)</span>
+<span id="cb104-212"><a href="#cb104-212" aria-hidden="true" tabindex="-1"></a>        <span class="bu">print</span>(zweite)</span>
+<span id="cb104-213"><a href="#cb104-213" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb104-214"><a href="#cb104-214" aria-hidden="true" tabindex="-1"></a>    n, start, heur, wert, status, schranke, _ <span class="op">=</span> zeilen[<span class="op">-</span><span class="dv">1</span>]</span>
+<span id="cb104-215"><a href="#cb104-215" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;</span><span class="ch">\n</span><span class="st">&quot;</span> <span class="op">+</span> <span class="st">&quot;=&quot;</span> <span class="op">*</span> <span class="dv">88</span>)</span>
+<span id="cb104-216"><a href="#cb104-216" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;  DIE SPALTE, DIE MAN NICHT WEGLASSEN DARF&quot;</span>)</span>
+<span id="cb104-217"><a href="#cb104-217" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;=&quot;</span> <span class="op">*</span> <span class="dv">88</span>)</span>
+<span id="cb104-218"><a href="#cb104-218" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;Die Schranke ist der eigentliche Ertrag des exakten Solvers - auch dann,&quot;</span>)</span>
+<span id="cb104-219"><a href="#cb104-219" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;wenn seine LOESUNG unbrauchbar ist.&quot;</span>)</span>
+<span id="cb104-220"><a href="#cb104-220" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>()</span>
+<span id="cb104-221"><a href="#cb104-221" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;Bei </span><span class="sc">{</span>n<span class="sc">}</span><span class="ss"> Auftraegen liefert Annealing </span><span class="sc">{</span>heur<span class="sc">:,}</span><span class="ss"> Minuten. Klingt gut: &quot;</span></span>
+<span id="cb104-222"><a href="#cb104-222" aria-hidden="true" tabindex="-1"></a>          <span class="ss">f&quot;</span><span class="sc">{</span>(start <span class="op">-</span> heur) <span class="op">/</span> start <span class="op">*</span> <span class="dv">100</span><span class="sc">:.1f}</span><span class="ss"> %&quot;</span>)</span>
+<span id="cb104-223"><a href="#cb104-223" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;besser als die Faustregel. Die Schranke aus demselben CP-SAT-Lauf, dessen&quot;</span>)</span>
+<span id="cb104-224"><a href="#cb104-224" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;Loesung wir gerade verworfen haben, sagt aber: Unter </span><span class="sc">{</span>schranke<span class="sc">:,}</span><span class="ss"> Minuten geht&quot;</span>)</span>
+<span id="cb104-225"><a href="#cb104-225" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;es nicht. Zwischen </span><span class="sc">{</span>schranke<span class="sc">:,}</span><span class="ss"> und </span><span class="sc">{</span>heur<span class="sc">:,}</span><span class="ss"> liegen </span><span class="sc">{</span>(heur <span class="op">-</span> schranke) <span class="op">/</span> heur <span class="op">*</span> <span class="dv">100</span><span class="sc">:.0f}</span><span class="ss"> % - so viel Luft&quot;</span>)</span>
+<span id="cb104-226"><a href="#cb104-226" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;kann noch nach oben sein.&quot;</span>)</span>
+<span id="cb104-227"><a href="#cb104-227" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>()</span>
+<span id="cb104-228"><a href="#cb104-228" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;Das ist der Unterschied zwischen &#39;besser als vorher&#39; und &#39;gut&#39;. Eine&quot;</span>)</span>
+<span id="cb104-229"><a href="#cb104-229" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;Metaheuristik allein kann nur das Erste. Deshalb gehoert auch dann ein&quot;</span>)</span>
+<span id="cb104-230"><a href="#cb104-230" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;exakter Lauf dazu, wenn man am Ende die heuristische Loesung einsetzt:&quot;</span>)</span>
+<span id="cb104-231"><a href="#cb104-231" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;nicht wegen seiner Loesung, sondern wegen seiner Schranke.&quot;</span>)</span>
+<span id="cb104-232"><a href="#cb104-232" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;=&quot;</span> <span class="op">*</span> <span class="dv">88</span>)</span></code></pre></div>
 <p><strong>Erwartete Ausgabe</strong> (die CP-SAT-Spalten sind hardwareabhängig, siehe Programmkopf):</p>
 <pre><code>========================================================================================
   AB WANN LOHNT SICH DIE METAHEURISTIK?
@@ -13961,292 +14706,292 @@ nicht wegen seiner Loesung, sondern wegen seiner Schranke.
 </tbody>
 </table>
 <p>Der Solver bekommt also nicht mehr das ganze Problem, sondern immer wieder ein kleines.</p>
-<div class="sourceCode" id="cb104"><pre class="sourceCode python"><code class="sourceCode python"><span id="cb104-1"><a href="#cb104-1" aria-hidden="true" tabindex="-1"></a><span class="co">#!/usr/bin/env python3</span></span>
-<span id="cb104-2"><a href="#cb104-2" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb104-3"><a href="#cb104-3" aria-hidden="true" tabindex="-1"></a><span class="co"># Large_Neighborhood_Search.py</span></span>
-<span id="cb104-4"><a href="#cb104-4" aria-hidden="true" tabindex="-1"></a><span class="co">&quot;&quot;&quot;</span></span>
-<span id="cb104-5"><a href="#cb104-5" aria-hidden="true" tabindex="-1"></a><span class="co">Kapitel Metaheuristiken: Zerstoeren und exakt reparieren - der Solver im Dienst der Heuristik.</span></span>
-<span id="cb104-6"><a href="#cb104-6" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb104-7"><a href="#cb104-7" aria-hidden="true" tabindex="-1"></a><span class="co">Metaheuristik_vs_Exakt.py endet mit einem Widerspruch. Bei 500 Auftraegen gilt:</span></span>
-<span id="cb104-8"><a href="#cb104-8" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb104-9"><a href="#cb104-9" aria-hidden="true" tabindex="-1"></a><span class="co">  * Der exakte Solver scheitert an der GROESSE - seine Loesung nach 30 Sekunden</span></span>
-<span id="cb104-10"><a href="#cb104-10" aria-hidden="true" tabindex="-1"></a><span class="co">    ist schlechter als die Faustregel eines Meisters.</span></span>
-<span id="cb104-11"><a href="#cb104-11" aria-hidden="true" tabindex="-1"></a><span class="co">  * Die Metaheuristik kommt weiter, laesst aber laut Schranke noch rund ein</span></span>
-<span id="cb104-12"><a href="#cb104-12" aria-hidden="true" tabindex="-1"></a><span class="co">    Viertel liegen. Ihre Zuege sind zu kleinteilig: Sie verschiebt jeweils</span></span>
-<span id="cb104-13"><a href="#cb104-13" aria-hidden="true" tabindex="-1"></a><span class="co">    EINEN Auftrag und kann eine ganze Passage nicht auf einmal umbauen.</span></span>
-<span id="cb104-14"><a href="#cb104-14" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb104-15"><a href="#cb104-15" aria-hidden="true" tabindex="-1"></a><span class="co">Large Neighborhood Search loest den Widerspruch, indem sie beide einsetzt -</span></span>
-<span id="cb104-16"><a href="#cb104-16" aria-hidden="true" tabindex="-1"></a><span class="co">jeden fuer das, was er kann:</span></span>
-<span id="cb104-17"><a href="#cb104-17" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb104-18"><a href="#cb104-18" aria-hidden="true" tabindex="-1"></a><span class="co">    ZERSTOEREN   Ein Stueck des Plans herausbrechen (hier: ein zusammen-</span></span>
-<span id="cb104-19"><a href="#cb104-19" aria-hidden="true" tabindex="-1"></a><span class="co">                 haengendes Fenster von 20 Auftraegen).</span></span>
-<span id="cb104-20"><a href="#cb104-20" aria-hidden="true" tabindex="-1"></a><span class="co">    REPARIEREN   Genau dieses Stueck EXAKT neu optimieren. 20 Auftraege sind</span></span>
-<span id="cb104-21"><a href="#cb104-21" aria-hidden="true" tabindex="-1"></a><span class="co">                 fuer CP-SAT eine Kleinigkeit, 500 sind es nicht.</span></span>
-<span id="cb104-22"><a href="#cb104-22" aria-hidden="true" tabindex="-1"></a><span class="co">    UEBERNEHMEN  Nur behalten, wenn der Gesamtplan besser wurde.</span></span>
-<span id="cb104-23"><a href="#cb104-23" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb104-24"><a href="#cb104-24" aria-hidden="true" tabindex="-1"></a><span class="co">Der Solver bekommt also nicht mehr das ganze Problem, sondern immer wieder ein</span></span>
-<span id="cb104-25"><a href="#cb104-25" aria-hidden="true" tabindex="-1"></a><span class="co">kleines. Das ist der ganze Trick, und er ist in der Praxis der wichtigste</span></span>
-<span id="cb104-26"><a href="#cb104-26" aria-hidden="true" tabindex="-1"></a><span class="co">Baustein dieses Kapitels.</span></span>
-<span id="cb104-27"><a href="#cb104-27" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb104-28"><a href="#cb104-28" aria-hidden="true" tabindex="-1"></a><span class="co">ZUR REPRODUZIERBARKEIT: Alle Laeufe haben eine feste RUNDENzahl, nicht ein</span></span>
-<span id="cb104-29"><a href="#cb104-29" aria-hidden="true" tabindex="-1"></a><span class="co">Zeitbudget - die Ergebniswerte sind damit auf jeder Maschine gleich. Die</span></span>
-<span id="cb104-30"><a href="#cb104-30" aria-hidden="true" tabindex="-1"></a><span class="co">Laufzeiten daneben sind hardwareabhaengig.</span></span>
-<span id="cb104-31"><a href="#cb104-31" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb104-32"><a href="#cb104-32" aria-hidden="true" tabindex="-1"></a><span class="co">Benoetigt: numpy, ortools</span></span>
-<span id="cb104-33"><a href="#cb104-33" aria-hidden="true" tabindex="-1"></a><span class="co">&quot;&quot;&quot;</span></span>
-<span id="cb104-34"><a href="#cb104-34" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb104-35"><a href="#cb104-35" aria-hidden="true" tabindex="-1"></a><span class="im">from</span> __future__ <span class="im">import</span> annotations</span>
-<span id="cb104-36"><a href="#cb104-36" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb104-37"><a href="#cb104-37" aria-hidden="true" tabindex="-1"></a><span class="im">import</span> math</span>
-<span id="cb104-38"><a href="#cb104-38" aria-hidden="true" tabindex="-1"></a><span class="im">import</span> time</span>
-<span id="cb104-39"><a href="#cb104-39" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb104-40"><a href="#cb104-40" aria-hidden="true" tabindex="-1"></a><span class="im">import</span> numpy <span class="im">as</span> np</span>
-<span id="cb104-41"><a href="#cb104-41" aria-hidden="true" tabindex="-1"></a><span class="im">from</span> ortools.sat.python <span class="im">import</span> cp_model</span>
-<span id="cb104-42"><a href="#cb104-42" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb104-43"><a href="#cb104-43" aria-hidden="true" tabindex="-1"></a>FENSTER <span class="op">=</span> <span class="dv">20</span>              <span class="co"># so viele Auftraege werden je Runde herausgebrochen</span></span>
-<span id="cb104-44"><a href="#cb104-44" aria-hidden="true" tabindex="-1"></a>RUNDEN <span class="op">=</span> <span class="dv">120</span></span>
-<span id="cb104-45"><a href="#cb104-45" aria-hidden="true" tabindex="-1"></a>ZUEGE <span class="op">=</span> <span class="dv">400_000</span>           <span class="co"># Zugbudget des Annealings (wie Simulated_Annealing.py)</span></span>
-<span id="cb104-46"><a href="#cb104-46" aria-hidden="true" tabindex="-1"></a>N <span class="op">=</span> <span class="dv">500</span></span>
-<span id="cb104-47"><a href="#cb104-47" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb104-48"><a href="#cb104-48" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb104-49"><a href="#cb104-49" aria-hidden="true" tabindex="-1"></a><span class="co"># --- Instanz und Faustregel (wie in Simulated_Annealing.py) ----------------</span></span>
-<span id="cb104-50"><a href="#cb104-50" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb104-51"><a href="#cb104-51" aria-hidden="true" tabindex="-1"></a><span class="kw">def</span> erzeuge_ruestmatrix(n: <span class="bu">int</span>, saat: <span class="bu">int</span> <span class="op">=</span> <span class="dv">11</span>) <span class="op">-&gt;</span> np.ndarray:</span>
-<span id="cb104-52"><a href="#cb104-52" aria-hidden="true" tabindex="-1"></a>    rng <span class="op">=</span> np.random.default_rng(saat)</span>
-<span id="cb104-53"><a href="#cb104-53" aria-hidden="true" tabindex="-1"></a>    familien <span class="op">=</span> <span class="bu">max</span>(<span class="dv">6</span>, n <span class="op">//</span> <span class="dv">10</span>)</span>
-<span id="cb104-54"><a href="#cb104-54" aria-hidden="true" tabindex="-1"></a>    zwischen <span class="op">=</span> rng.integers(<span class="dv">8</span>, <span class="dv">60</span>, (familien, familien))</span>
-<span id="cb104-55"><a href="#cb104-55" aria-hidden="true" tabindex="-1"></a>    np.fill_diagonal(zwischen, <span class="dv">2</span>)</span>
-<span id="cb104-56"><a href="#cb104-56" aria-hidden="true" tabindex="-1"></a>    familie <span class="op">=</span> rng.integers(<span class="dv">0</span>, familien, n)</span>
-<span id="cb104-57"><a href="#cb104-57" aria-hidden="true" tabindex="-1"></a>    farbe <span class="op">=</span> rng.integers(<span class="dv">0</span>, <span class="dv">10</span>, n)</span>
-<span id="cb104-58"><a href="#cb104-58" aria-hidden="true" tabindex="-1"></a>    matrix <span class="op">=</span> np.zeros((n, n), dtype<span class="op">=</span>np.int64)</span>
-<span id="cb104-59"><a href="#cb104-59" aria-hidden="true" tabindex="-1"></a>    <span class="cf">for</span> i <span class="kw">in</span> <span class="bu">range</span>(n):</span>
-<span id="cb104-60"><a href="#cb104-60" aria-hidden="true" tabindex="-1"></a>        <span class="cf">for</span> j <span class="kw">in</span> <span class="bu">range</span>(n):</span>
-<span id="cb104-61"><a href="#cb104-61" aria-hidden="true" tabindex="-1"></a>            <span class="cf">if</span> i <span class="op">!=</span> j:</span>
-<span id="cb104-62"><a href="#cb104-62" aria-hidden="true" tabindex="-1"></a>                matrix[i, j] <span class="op">=</span> (zwischen[familie[i], familie[j]]</span>
-<span id="cb104-63"><a href="#cb104-63" aria-hidden="true" tabindex="-1"></a>                                <span class="op">+</span> <span class="dv">3</span> <span class="op">*</span> <span class="bu">max</span>(<span class="dv">0</span>, farbe[i] <span class="op">-</span> farbe[j]))</span>
-<span id="cb104-64"><a href="#cb104-64" aria-hidden="true" tabindex="-1"></a>    <span class="cf">return</span> matrix</span>
-<span id="cb104-65"><a href="#cb104-65" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb104-66"><a href="#cb104-66" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb104-67"><a href="#cb104-67" aria-hidden="true" tabindex="-1"></a><span class="kw">def</span> gesamtruestzeit(reihe: <span class="bu">list</span>[<span class="bu">int</span>], matrix: np.ndarray) <span class="op">-&gt;</span> <span class="bu">int</span>:</span>
-<span id="cb104-68"><a href="#cb104-68" aria-hidden="true" tabindex="-1"></a>    <span class="cf">return</span> <span class="bu">int</span>(<span class="bu">sum</span>(matrix[reihe[k], reihe[k <span class="op">+</span> <span class="dv">1</span>]] <span class="cf">for</span> k <span class="kw">in</span> <span class="bu">range</span>(<span class="bu">len</span>(reihe) <span class="op">-</span> <span class="dv">1</span>)))</span>
-<span id="cb104-69"><a href="#cb104-69" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb104-70"><a href="#cb104-70" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb104-71"><a href="#cb104-71" aria-hidden="true" tabindex="-1"></a><span class="kw">def</span> faustregel(matrix: np.ndarray) <span class="op">-&gt;</span> <span class="bu">list</span>[<span class="bu">int</span>]:</span>
-<span id="cb104-72"><a href="#cb104-72" aria-hidden="true" tabindex="-1"></a>    n <span class="op">=</span> <span class="bu">len</span>(matrix)</span>
-<span id="cb104-73"><a href="#cb104-73" aria-hidden="true" tabindex="-1"></a>    offen <span class="op">=</span> <span class="bu">set</span>(<span class="bu">range</span>(<span class="dv">1</span>, n))</span>
-<span id="cb104-74"><a href="#cb104-74" aria-hidden="true" tabindex="-1"></a>    reihe <span class="op">=</span> [<span class="dv">0</span>]</span>
-<span id="cb104-75"><a href="#cb104-75" aria-hidden="true" tabindex="-1"></a>    <span class="cf">while</span> offen:</span>
-<span id="cb104-76"><a href="#cb104-76" aria-hidden="true" tabindex="-1"></a>        naechster <span class="op">=</span> <span class="bu">min</span>(offen, key<span class="op">=</span><span class="kw">lambda</span> j: matrix[reihe[<span class="op">-</span><span class="dv">1</span>], j])</span>
-<span id="cb104-77"><a href="#cb104-77" aria-hidden="true" tabindex="-1"></a>        reihe.append(naechster)</span>
-<span id="cb104-78"><a href="#cb104-78" aria-hidden="true" tabindex="-1"></a>        offen.discard(naechster)</span>
-<span id="cb104-79"><a href="#cb104-79" aria-hidden="true" tabindex="-1"></a>    <span class="cf">return</span> reihe</span>
-<span id="cb104-80"><a href="#cb104-80" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb104-81"><a href="#cb104-81" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb104-82"><a href="#cb104-82" aria-hidden="true" tabindex="-1"></a><span class="kw">def</span> delta_verschieben(reihe, matrix, von, nach):</span>
-<span id="cb104-83"><a href="#cb104-83" aria-hidden="true" tabindex="-1"></a>    n <span class="op">=</span> <span class="bu">len</span>(reihe)</span>
-<span id="cb104-84"><a href="#cb104-84" aria-hidden="true" tabindex="-1"></a>    <span class="cf">if</span> von <span class="op">==</span> nach <span class="kw">or</span> nach <span class="op">==</span> von <span class="op">+</span> <span class="dv">1</span>:</span>
-<span id="cb104-85"><a href="#cb104-85" aria-hidden="true" tabindex="-1"></a>        <span class="cf">return</span> <span class="va">None</span></span>
-<span id="cb104-86"><a href="#cb104-86" aria-hidden="true" tabindex="-1"></a>    heraus <span class="op">=</span> <span class="dv">0</span></span>
-<span id="cb104-87"><a href="#cb104-87" aria-hidden="true" tabindex="-1"></a>    <span class="cf">if</span> von <span class="op">&gt;</span> <span class="dv">0</span>:</span>
-<span id="cb104-88"><a href="#cb104-88" aria-hidden="true" tabindex="-1"></a>        heraus <span class="op">+=</span> matrix[reihe[von <span class="op">-</span> <span class="dv">1</span>], reihe[von]]</span>
-<span id="cb104-89"><a href="#cb104-89" aria-hidden="true" tabindex="-1"></a>    <span class="cf">if</span> von <span class="op">&lt;</span> n <span class="op">-</span> <span class="dv">1</span>:</span>
-<span id="cb104-90"><a href="#cb104-90" aria-hidden="true" tabindex="-1"></a>        heraus <span class="op">+=</span> matrix[reihe[von], reihe[von <span class="op">+</span> <span class="dv">1</span>]]</span>
-<span id="cb104-91"><a href="#cb104-91" aria-hidden="true" tabindex="-1"></a>    <span class="cf">if</span> <span class="dv">0</span> <span class="op">&lt;</span> von <span class="op">&lt;</span> n <span class="op">-</span> <span class="dv">1</span>:</span>
-<span id="cb104-92"><a href="#cb104-92" aria-hidden="true" tabindex="-1"></a>        heraus <span class="op">-=</span> matrix[reihe[von <span class="op">-</span> <span class="dv">1</span>], reihe[von <span class="op">+</span> <span class="dv">1</span>]]</span>
-<span id="cb104-93"><a href="#cb104-93" aria-hidden="true" tabindex="-1"></a>    rest <span class="op">=</span> reihe[:von] <span class="op">+</span> reihe[von <span class="op">+</span> <span class="dv">1</span>:]</span>
-<span id="cb104-94"><a href="#cb104-94" aria-hidden="true" tabindex="-1"></a>    stelle <span class="op">=</span> nach <span class="cf">if</span> nach <span class="op">&lt;</span> von <span class="cf">else</span> nach <span class="op">-</span> <span class="dv">1</span></span>
-<span id="cb104-95"><a href="#cb104-95" aria-hidden="true" tabindex="-1"></a>    hinein <span class="op">=</span> <span class="dv">0</span></span>
-<span id="cb104-96"><a href="#cb104-96" aria-hidden="true" tabindex="-1"></a>    <span class="cf">if</span> stelle <span class="op">&gt;</span> <span class="dv">0</span>:</span>
-<span id="cb104-97"><a href="#cb104-97" aria-hidden="true" tabindex="-1"></a>        hinein <span class="op">+=</span> matrix[rest[stelle <span class="op">-</span> <span class="dv">1</span>], reihe[von]]</span>
-<span id="cb104-98"><a href="#cb104-98" aria-hidden="true" tabindex="-1"></a>    <span class="cf">if</span> stelle <span class="op">&lt;</span> <span class="bu">len</span>(rest):</span>
-<span id="cb104-99"><a href="#cb104-99" aria-hidden="true" tabindex="-1"></a>        hinein <span class="op">+=</span> matrix[reihe[von], rest[stelle]]</span>
-<span id="cb104-100"><a href="#cb104-100" aria-hidden="true" tabindex="-1"></a>    <span class="cf">if</span> <span class="dv">0</span> <span class="op">&lt;</span> stelle <span class="op">&lt;</span> <span class="bu">len</span>(rest):</span>
-<span id="cb104-101"><a href="#cb104-101" aria-hidden="true" tabindex="-1"></a>        hinein <span class="op">-=</span> matrix[rest[stelle <span class="op">-</span> <span class="dv">1</span>], rest[stelle]]</span>
-<span id="cb104-102"><a href="#cb104-102" aria-hidden="true" tabindex="-1"></a>    <span class="cf">return</span> <span class="bu">int</span>(hinein <span class="op">-</span> heraus), rest, stelle</span>
-<span id="cb104-103"><a href="#cb104-103" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb104-104"><a href="#cb104-104" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb104-105"><a href="#cb104-105" aria-hidden="true" tabindex="-1"></a><span class="kw">def</span> annealing(matrix: np.ndarray, zuege: <span class="bu">int</span> <span class="op">=</span> ZUEGE,</span>
-<span id="cb104-106"><a href="#cb104-106" aria-hidden="true" tabindex="-1"></a>              start_temperatur: <span class="bu">float</span> <span class="op">=</span> <span class="fl">1.0</span>, saat: <span class="bu">int</span> <span class="op">=</span> <span class="dv">1</span>) <span class="op">-&gt;</span> <span class="bu">list</span>[<span class="bu">int</span>]:</span>
-<span id="cb104-107"><a href="#cb104-107" aria-hidden="true" tabindex="-1"></a>    rng <span class="op">=</span> np.random.default_rng(saat)</span>
-<span id="cb104-108"><a href="#cb104-108" aria-hidden="true" tabindex="-1"></a>    n <span class="op">=</span> <span class="bu">len</span>(matrix)</span>
-<span id="cb104-109"><a href="#cb104-109" aria-hidden="true" tabindex="-1"></a>    reihe <span class="op">=</span> faustregel(matrix)</span>
-<span id="cb104-110"><a href="#cb104-110" aria-hidden="true" tabindex="-1"></a>    kosten <span class="op">=</span> gesamtruestzeit(reihe, matrix)</span>
-<span id="cb104-111"><a href="#cb104-111" aria-hidden="true" tabindex="-1"></a>    beste, beste_kosten <span class="op">=</span> reihe[:], kosten</span>
-<span id="cb104-112"><a href="#cb104-112" aria-hidden="true" tabindex="-1"></a>    <span class="cf">for</span> zug <span class="kw">in</span> <span class="bu">range</span>(zuege):</span>
-<span id="cb104-113"><a href="#cb104-113" aria-hidden="true" tabindex="-1"></a>        temperatur <span class="op">=</span> start_temperatur <span class="op">*</span> (<span class="fl">0.05</span> <span class="op">/</span> start_temperatur) <span class="op">**</span> (zug <span class="op">/</span> zuege)</span>
-<span id="cb104-114"><a href="#cb104-114" aria-hidden="true" tabindex="-1"></a>        von, nach <span class="op">=</span> <span class="bu">int</span>(rng.integers(<span class="dv">0</span>, n)), <span class="bu">int</span>(rng.integers(<span class="dv">0</span>, n <span class="op">+</span> <span class="dv">1</span>))</span>
-<span id="cb104-115"><a href="#cb104-115" aria-hidden="true" tabindex="-1"></a>        ergebnis <span class="op">=</span> delta_verschieben(reihe, matrix, von, nach)</span>
-<span id="cb104-116"><a href="#cb104-116" aria-hidden="true" tabindex="-1"></a>        <span class="cf">if</span> ergebnis <span class="kw">is</span> <span class="va">None</span>:</span>
-<span id="cb104-117"><a href="#cb104-117" aria-hidden="true" tabindex="-1"></a>            <span class="cf">continue</span></span>
-<span id="cb104-118"><a href="#cb104-118" aria-hidden="true" tabindex="-1"></a>        aenderung, rest, stelle <span class="op">=</span> ergebnis</span>
-<span id="cb104-119"><a href="#cb104-119" aria-hidden="true" tabindex="-1"></a>        <span class="cf">if</span> aenderung <span class="op">&lt;=</span> <span class="dv">0</span> <span class="kw">or</span> rng.random() <span class="op">&lt;</span> math.exp(<span class="op">-</span>aenderung <span class="op">/</span> temperatur):</span>
-<span id="cb104-120"><a href="#cb104-120" aria-hidden="true" tabindex="-1"></a>            reihe <span class="op">=</span> rest[:stelle] <span class="op">+</span> [reihe[von]] <span class="op">+</span> rest[stelle:]</span>
-<span id="cb104-121"><a href="#cb104-121" aria-hidden="true" tabindex="-1"></a>            kosten <span class="op">+=</span> aenderung</span>
-<span id="cb104-122"><a href="#cb104-122" aria-hidden="true" tabindex="-1"></a>            <span class="cf">if</span> kosten <span class="op">&lt;</span> beste_kosten:</span>
-<span id="cb104-123"><a href="#cb104-123" aria-hidden="true" tabindex="-1"></a>                beste, beste_kosten <span class="op">=</span> reihe[:], kosten</span>
-<span id="cb104-124"><a href="#cb104-124" aria-hidden="true" tabindex="-1"></a>    <span class="cf">return</span> beste</span>
-<span id="cb104-125"><a href="#cb104-125" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb104-126"><a href="#cb104-126" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb104-127"><a href="#cb104-127" aria-hidden="true" tabindex="-1"></a><span class="co"># --- Der Reparaturschritt: ein kleines Problem, exakt geloest --------------</span></span>
-<span id="cb104-128"><a href="#cb104-128" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb104-129"><a href="#cb104-129" aria-hidden="true" tabindex="-1"></a><span class="kw">def</span> repariere_fenster(reihe: <span class="bu">list</span>[<span class="bu">int</span>], matrix: np.ndarray,</span>
-<span id="cb104-130"><a href="#cb104-130" aria-hidden="true" tabindex="-1"></a>                      a: <span class="bu">int</span>, b: <span class="bu">int</span>) <span class="op">-&gt;</span> <span class="bu">list</span>[<span class="bu">int</span>] <span class="op">|</span> <span class="va">None</span>:</span>
-<span id="cb104-131"><a href="#cb104-131" aria-hidden="true" tabindex="-1"></a>    <span class="co">&quot;&quot;&quot;Ordnet reihe[a:b] optimal neu; die beiden Raender bleiben, wo sie sind.</span></span>
-<span id="cb104-132"><a href="#cb104-132" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb104-133"><a href="#cb104-133" aria-hidden="true" tabindex="-1"></a><span class="co">    Die Raender festzuhalten ist entscheidend. Ohne sie waere das Teilproblem</span></span>
-<span id="cb104-134"><a href="#cb104-134" aria-hidden="true" tabindex="-1"></a><span class="co">    ein anderes als der Ausschnitt aus dem Gesamtplan: Der Uebergang vom</span></span>
-<span id="cb104-135"><a href="#cb104-135" aria-hidden="true" tabindex="-1"></a><span class="co">    Vorgaenger in das Fenster und aus dem Fenster in den Nachfolger gehoert</span></span>
-<span id="cb104-136"><a href="#cb104-136" aria-hidden="true" tabindex="-1"></a><span class="co">    zu den Kosten dazu. Genau dafuer steht der Hilfsknoten k - er vertritt</span></span>
-<span id="cb104-137"><a href="#cb104-137" aria-hidden="true" tabindex="-1"></a><span class="co">    beide Raender in einem.</span></span>
-<span id="cb104-138"><a href="#cb104-138" aria-hidden="true" tabindex="-1"></a><span class="co">    &quot;&quot;&quot;</span></span>
-<span id="cb104-139"><a href="#cb104-139" aria-hidden="true" tabindex="-1"></a>    innen <span class="op">=</span> reihe[a:b]</span>
-<span id="cb104-140"><a href="#cb104-140" aria-hidden="true" tabindex="-1"></a>    k <span class="op">=</span> <span class="bu">len</span>(innen)</span>
-<span id="cb104-141"><a href="#cb104-141" aria-hidden="true" tabindex="-1"></a>    vorgaenger <span class="op">=</span> reihe[a <span class="op">-</span> <span class="dv">1</span>] <span class="cf">if</span> a <span class="op">&gt;</span> <span class="dv">0</span> <span class="cf">else</span> <span class="va">None</span></span>
-<span id="cb104-142"><a href="#cb104-142" aria-hidden="true" tabindex="-1"></a>    nachfolger_rand <span class="op">=</span> reihe[b] <span class="cf">if</span> b <span class="op">&lt;</span> <span class="bu">len</span>(reihe) <span class="cf">else</span> <span class="va">None</span></span>
-<span id="cb104-143"><a href="#cb104-143" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb104-144"><a href="#cb104-144" aria-hidden="true" tabindex="-1"></a>    modell <span class="op">=</span> cp_model.CpModel()</span>
-<span id="cb104-145"><a href="#cb104-145" aria-hidden="true" tabindex="-1"></a>    kanten, ziel <span class="op">=</span> [], []</span>
-<span id="cb104-146"><a href="#cb104-146" aria-hidden="true" tabindex="-1"></a>    <span class="cf">for</span> i <span class="kw">in</span> <span class="bu">range</span>(k <span class="op">+</span> <span class="dv">1</span>):</span>
-<span id="cb104-147"><a href="#cb104-147" aria-hidden="true" tabindex="-1"></a>        <span class="cf">for</span> j <span class="kw">in</span> <span class="bu">range</span>(k <span class="op">+</span> <span class="dv">1</span>):</span>
-<span id="cb104-148"><a href="#cb104-148" aria-hidden="true" tabindex="-1"></a>            <span class="cf">if</span> i <span class="op">==</span> j:</span>
-<span id="cb104-149"><a href="#cb104-149" aria-hidden="true" tabindex="-1"></a>                <span class="cf">continue</span></span>
-<span id="cb104-150"><a href="#cb104-150" aria-hidden="true" tabindex="-1"></a>            aktiv <span class="op">=</span> modell.NewBoolVar(<span class="ss">f&quot;kante_</span><span class="sc">{</span>i<span class="sc">}</span><span class="ss">_</span><span class="sc">{</span>j<span class="sc">}</span><span class="ss">&quot;</span>)</span>
-<span id="cb104-151"><a href="#cb104-151" aria-hidden="true" tabindex="-1"></a>            kanten.append((i, j, aktiv))</span>
-<span id="cb104-152"><a href="#cb104-152" aria-hidden="true" tabindex="-1"></a>            <span class="cf">if</span> i <span class="op">&lt;</span> k <span class="kw">and</span> j <span class="op">&lt;</span> k:</span>
-<span id="cb104-153"><a href="#cb104-153" aria-hidden="true" tabindex="-1"></a>                ziel.append(<span class="bu">int</span>(matrix[innen[i], innen[j]]) <span class="op">*</span> aktiv)</span>
-<span id="cb104-154"><a href="#cb104-154" aria-hidden="true" tabindex="-1"></a>            <span class="cf">elif</span> i <span class="op">==</span> k <span class="kw">and</span> j <span class="op">&lt;</span> k <span class="kw">and</span> vorgaenger <span class="kw">is</span> <span class="kw">not</span> <span class="va">None</span>:</span>
-<span id="cb104-155"><a href="#cb104-155" aria-hidden="true" tabindex="-1"></a>                ziel.append(<span class="bu">int</span>(matrix[vorgaenger, innen[j]]) <span class="op">*</span> aktiv)</span>
-<span id="cb104-156"><a href="#cb104-156" aria-hidden="true" tabindex="-1"></a>            <span class="cf">elif</span> j <span class="op">==</span> k <span class="kw">and</span> i <span class="op">&lt;</span> k <span class="kw">and</span> nachfolger_rand <span class="kw">is</span> <span class="kw">not</span> <span class="va">None</span>:</span>
-<span id="cb104-157"><a href="#cb104-157" aria-hidden="true" tabindex="-1"></a>                ziel.append(<span class="bu">int</span>(matrix[innen[i], nachfolger_rand]) <span class="op">*</span> aktiv)</span>
-<span id="cb104-158"><a href="#cb104-158" aria-hidden="true" tabindex="-1"></a>    modell.AddCircuit(kanten)</span>
-<span id="cb104-159"><a href="#cb104-159" aria-hidden="true" tabindex="-1"></a>    modell.Minimize(<span class="bu">sum</span>(ziel))</span>
-<span id="cb104-160"><a href="#cb104-160" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb104-161"><a href="#cb104-161" aria-hidden="true" tabindex="-1"></a>    loeser <span class="op">=</span> cp_model.CpSolver()</span>
-<span id="cb104-162"><a href="#cb104-162" aria-hidden="true" tabindex="-1"></a>    loeser.parameters.num_workers <span class="op">=</span> <span class="dv">1</span></span>
-<span id="cb104-163"><a href="#cb104-163" aria-hidden="true" tabindex="-1"></a>    loeser.parameters.random_seed <span class="op">=</span> <span class="dv">1</span></span>
-<span id="cb104-164"><a href="#cb104-164" aria-hidden="true" tabindex="-1"></a>    loeser.parameters.max_time_in_seconds <span class="op">=</span> <span class="fl">10.0</span></span>
-<span id="cb104-165"><a href="#cb104-165" aria-hidden="true" tabindex="-1"></a>    status <span class="op">=</span> loeser.Solve(modell)</span>
-<span id="cb104-166"><a href="#cb104-166" aria-hidden="true" tabindex="-1"></a>    <span class="cf">if</span> status <span class="kw">not</span> <span class="kw">in</span> (cp_model.OPTIMAL, cp_model.FEASIBLE):</span>
-<span id="cb104-167"><a href="#cb104-167" aria-hidden="true" tabindex="-1"></a>        <span class="co"># Auch das gehoert dazu: Wenn das Teilproblem nicht loest, bleibt der</span></span>
-<span id="cb104-168"><a href="#cb104-168" aria-hidden="true" tabindex="-1"></a>        <span class="co"># Plan, wie er war. Eine LNS-Runde darf scheitern.</span></span>
-<span id="cb104-169"><a href="#cb104-169" aria-hidden="true" tabindex="-1"></a>        <span class="cf">return</span> <span class="va">None</span></span>
-<span id="cb104-170"><a href="#cb104-170" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb104-171"><a href="#cb104-171" aria-hidden="true" tabindex="-1"></a>    nachfolger <span class="op">=</span> {i: j <span class="cf">for</span> i, j, aktiv <span class="kw">in</span> kanten <span class="cf">if</span> loeser.Value(aktiv)}</span>
-<span id="cb104-172"><a href="#cb104-172" aria-hidden="true" tabindex="-1"></a>    neue_folge, aktuell <span class="op">=</span> [], nachfolger[k]</span>
-<span id="cb104-173"><a href="#cb104-173" aria-hidden="true" tabindex="-1"></a>    <span class="cf">while</span> aktuell <span class="op">!=</span> k:</span>
-<span id="cb104-174"><a href="#cb104-174" aria-hidden="true" tabindex="-1"></a>        neue_folge.append(innen[aktuell])</span>
-<span id="cb104-175"><a href="#cb104-175" aria-hidden="true" tabindex="-1"></a>        aktuell <span class="op">=</span> nachfolger[aktuell]</span>
-<span id="cb104-176"><a href="#cb104-176" aria-hidden="true" tabindex="-1"></a>    <span class="cf">return</span> reihe[:a] <span class="op">+</span> neue_folge <span class="op">+</span> reihe[b:]</span>
-<span id="cb104-177"><a href="#cb104-177" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb104-178"><a href="#cb104-178" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb104-179"><a href="#cb104-179" aria-hidden="true" tabindex="-1"></a><span class="kw">def</span> lns(reihe: <span class="bu">list</span>[<span class="bu">int</span>], matrix: np.ndarray, runden: <span class="bu">int</span> <span class="op">=</span> RUNDEN,</span>
-<span id="cb104-180"><a href="#cb104-180" aria-hidden="true" tabindex="-1"></a>        fenster: <span class="bu">int</span> <span class="op">=</span> FENSTER, saat: <span class="bu">int</span> <span class="op">=</span> <span class="dv">3</span>):</span>
-<span id="cb104-181"><a href="#cb104-181" aria-hidden="true" tabindex="-1"></a>    <span class="co">&quot;&quot;&quot;Zerstoeren, exakt reparieren, uebernehmen - so lange das Budget reicht.&quot;&quot;&quot;</span></span>
-<span id="cb104-182"><a href="#cb104-182" aria-hidden="true" tabindex="-1"></a>    rng <span class="op">=</span> np.random.default_rng(saat)</span>
-<span id="cb104-183"><a href="#cb104-183" aria-hidden="true" tabindex="-1"></a>    kosten <span class="op">=</span> gesamtruestzeit(reihe, matrix)</span>
-<span id="cb104-184"><a href="#cb104-184" aria-hidden="true" tabindex="-1"></a>    verbesserungen <span class="op">=</span> <span class="dv">0</span></span>
-<span id="cb104-185"><a href="#cb104-185" aria-hidden="true" tabindex="-1"></a>    start <span class="op">=</span> time.perf_counter()</span>
-<span id="cb104-186"><a href="#cb104-186" aria-hidden="true" tabindex="-1"></a>    <span class="cf">for</span> _ <span class="kw">in</span> <span class="bu">range</span>(runden):</span>
-<span id="cb104-187"><a href="#cb104-187" aria-hidden="true" tabindex="-1"></a>        a <span class="op">=</span> <span class="bu">int</span>(rng.integers(<span class="dv">0</span>, <span class="bu">len</span>(reihe) <span class="op">-</span> fenster))</span>
-<span id="cb104-188"><a href="#cb104-188" aria-hidden="true" tabindex="-1"></a>        neu <span class="op">=</span> repariere_fenster(reihe, matrix, a, a <span class="op">+</span> fenster)</span>
-<span id="cb104-189"><a href="#cb104-189" aria-hidden="true" tabindex="-1"></a>        <span class="cf">if</span> neu <span class="kw">is</span> <span class="va">None</span>:</span>
-<span id="cb104-190"><a href="#cb104-190" aria-hidden="true" tabindex="-1"></a>            <span class="cf">continue</span></span>
-<span id="cb104-191"><a href="#cb104-191" aria-hidden="true" tabindex="-1"></a>        neue_kosten <span class="op">=</span> gesamtruestzeit(neu, matrix)</span>
-<span id="cb104-192"><a href="#cb104-192" aria-hidden="true" tabindex="-1"></a>        <span class="cf">if</span> neue_kosten <span class="op">&lt;</span> kosten:</span>
-<span id="cb104-193"><a href="#cb104-193" aria-hidden="true" tabindex="-1"></a>            reihe, kosten <span class="op">=</span> neu, neue_kosten</span>
-<span id="cb104-194"><a href="#cb104-194" aria-hidden="true" tabindex="-1"></a>            verbesserungen <span class="op">+=</span> <span class="dv">1</span></span>
-<span id="cb104-195"><a href="#cb104-195" aria-hidden="true" tabindex="-1"></a>    <span class="cf">return</span> reihe, kosten, verbesserungen, time.perf_counter() <span class="op">-</span> start</span>
-<span id="cb104-196"><a href="#cb104-196" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb104-197"><a href="#cb104-197" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb104-198"><a href="#cb104-198" aria-hidden="true" tabindex="-1"></a><span class="cf">if</span> <span class="va">__name__</span> <span class="op">==</span> <span class="st">&quot;__main__&quot;</span>:</span>
-<span id="cb104-199"><a href="#cb104-199" aria-hidden="true" tabindex="-1"></a>    matrix <span class="op">=</span> erzeuge_ruestmatrix(N)</span>
-<span id="cb104-200"><a href="#cb104-200" aria-hidden="true" tabindex="-1"></a>    start_reihe <span class="op">=</span> faustregel(matrix)</span>
-<span id="cb104-201"><a href="#cb104-201" aria-hidden="true" tabindex="-1"></a>    start_kosten <span class="op">=</span> gesamtruestzeit(start_reihe, matrix)</span>
-<span id="cb104-202"><a href="#cb104-202" aria-hidden="true" tabindex="-1"></a>    SCHRANKE <span class="op">=</span> <span class="dv">1768</span>        <span class="co"># aus dem CP-SAT-Lauf in Metaheuristik_vs_Exakt.py</span></span>
-<span id="cb104-203"><a href="#cb104-203" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb104-204"><a href="#cb104-204" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;=&quot;</span> <span class="op">*</span> <span class="dv">84</span>)</span>
-<span id="cb104-205"><a href="#cb104-205" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;  ZERSTOEREN UND EXAKT REPARIEREN&quot;</span>)</span>
-<span id="cb104-206"><a href="#cb104-206" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;=&quot;</span> <span class="op">*</span> <span class="dv">84</span>)</span>
-<span id="cb104-207"><a href="#cb104-207" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;</span><span class="sc">{</span>N<span class="sc">}</span><span class="ss"> Auftraege. Je Runde werden </span><span class="sc">{</span>FENSTER<span class="sc">}</span><span class="ss"> aufeinanderfolgende Auftraege&quot;</span>)</span>
-<span id="cb104-208"><a href="#cb104-208" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;herausgebrochen und exakt neu geordnet, </span><span class="sc">{</span>RUNDEN<span class="sc">}</span><span class="ss"> Runden lang.</span><span class="ch">\n</span><span class="ss">&quot;</span>)</span>
-<span id="cb104-209"><a href="#cb104-209" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb104-210"><a href="#cb104-210" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;Erst die Metaheuristik allein, dann LNS auf ihrem Ergebnis:</span><span class="ch">\n</span><span class="st">&quot;</span>)</span>
-<span id="cb104-211"><a href="#cb104-211" aria-hidden="true" tabindex="-1"></a>    sa_reihe <span class="op">=</span> annealing(matrix)</span>
-<span id="cb104-212"><a href="#cb104-212" aria-hidden="true" tabindex="-1"></a>    sa_kosten <span class="op">=</span> gesamtruestzeit(sa_reihe, matrix)</span>
-<span id="cb104-213"><a href="#cb104-213" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb104-214"><a href="#cb104-214" aria-hidden="true" tabindex="-1"></a>    lns_ab_faustregel <span class="op">=</span> lns(start_reihe[:], matrix)</span>
-<span id="cb104-215"><a href="#cb104-215" aria-hidden="true" tabindex="-1"></a>    lns_ab_annealing <span class="op">=</span> lns(sa_reihe[:], matrix)</span>
-<span id="cb104-216"><a href="#cb104-216" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb104-217"><a href="#cb104-217" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;  </span><span class="sc">{</span><span class="st">&#39;Verfahren&#39;</span><span class="sc">:&lt;34}</span><span class="ss"> </span><span class="sc">{</span><span class="st">&#39;Ruestzeit&#39;</span><span class="sc">:&gt;10}</span><span class="ss"> </span><span class="sc">{</span><span class="st">&#39;ueber Schranke&#39;</span><span class="sc">:&gt;15}</span><span class="ss">&quot;</span>)</span>
-<span id="cb104-218"><a href="#cb104-218" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;  &quot;</span> <span class="op">+</span> <span class="st">&quot;-&quot;</span> <span class="op">*</span> <span class="dv">62</span>)</span>
-<span id="cb104-219"><a href="#cb104-219" aria-hidden="true" tabindex="-1"></a>    <span class="cf">for</span> name, wert <span class="kw">in</span> [</span>
-<span id="cb104-220"><a href="#cb104-220" aria-hidden="true" tabindex="-1"></a>            (<span class="st">&quot;Faustregel (ohne Solver)&quot;</span>, start_kosten),</span>
-<span id="cb104-221"><a href="#cb104-221" aria-hidden="true" tabindex="-1"></a>            (<span class="st">&quot;CP-SAT allein, 30 s&quot;</span>, <span class="dv">2628</span>),</span>
-<span id="cb104-222"><a href="#cb104-222" aria-hidden="true" tabindex="-1"></a>            (<span class="st">&quot;Simulated Annealing&quot;</span>, sa_kosten),</span>
-<span id="cb104-223"><a href="#cb104-223" aria-hidden="true" tabindex="-1"></a>            (<span class="st">&quot;LNS ab Faustregel&quot;</span>, lns_ab_faustregel[<span class="dv">1</span>]),</span>
-<span id="cb104-224"><a href="#cb104-224" aria-hidden="true" tabindex="-1"></a>            (<span class="st">&quot;Annealing, dann LNS&quot;</span>, lns_ab_annealing[<span class="dv">1</span>])]:</span>
-<span id="cb104-225"><a href="#cb104-225" aria-hidden="true" tabindex="-1"></a>        <span class="bu">print</span>(<span class="ss">f&quot;  </span><span class="sc">{</span>name<span class="sc">:&lt;34}</span><span class="ss"> </span><span class="sc">{</span>wert<span class="sc">:&gt;10,}</span><span class="ss"> </span><span class="sc">{</span>(wert <span class="op">-</span> SCHRANKE) <span class="op">/</span> SCHRANKE <span class="op">*</span> <span class="dv">100</span><span class="sc">:&gt;13.1f}</span><span class="ss"> %&quot;</span>)</span>
-<span id="cb104-226"><a href="#cb104-226" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;  </span><span class="sc">{</span><span class="st">&#39;untere Schranke (CP-SAT)&#39;</span><span class="sc">:&lt;34}</span><span class="ss"> </span><span class="sc">{</span>SCHRANKE<span class="sc">:&gt;10,}</span><span class="ss"> </span><span class="sc">{</span><span class="fl">0.0</span><span class="sc">:&gt;13.1f}</span><span class="ss"> %&quot;</span>)</span>
-<span id="cb104-227"><a href="#cb104-227" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb104-228"><a href="#cb104-228" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;</span><span class="ch">\n</span><span class="ss">  LNS ab Faustregel: </span><span class="sc">{</span>lns_ab_faustregel[<span class="dv">2</span>]<span class="sc">}</span><span class="ss"> von </span><span class="sc">{</span>RUNDEN<span class="sc">}</span><span class="ss"> Runden brachten &quot;</span></span>
-<span id="cb104-229"><a href="#cb104-229" aria-hidden="true" tabindex="-1"></a>          <span class="ss">f&quot;eine Verbesserung (</span><span class="sc">{</span>lns_ab_faustregel[<span class="dv">3</span>]<span class="sc">:.0f}</span><span class="ss"> s).&quot;</span>)</span>
-<span id="cb104-230"><a href="#cb104-230" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;  LNS ab Annealing:  </span><span class="sc">{</span>lns_ab_annealing[<span class="dv">2</span>]<span class="sc">}</span><span class="ss"> von </span><span class="sc">{</span>RUNDEN<span class="sc">}</span><span class="ss"> Runden &quot;</span></span>
-<span id="cb104-231"><a href="#cb104-231" aria-hidden="true" tabindex="-1"></a>          <span class="ss">f&quot;(</span><span class="sc">{</span>lns_ab_annealing[<span class="dv">3</span>]<span class="sc">:.0f}</span><span class="ss"> s).&quot;</span>)</span>
-<span id="cb104-232"><a href="#cb104-232" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb104-233"><a href="#cb104-233" aria-hidden="true" tabindex="-1"></a>    <span class="co"># --- Die Fenstergroesse ----------------------------------------------</span></span>
-<span id="cb104-234"><a href="#cb104-234" aria-hidden="true" tabindex="-1"></a>    <span class="co"># Verglichen wird bei ANNAEHERND GLEICHER ZEIT, nicht bei gleicher</span></span>
-<span id="cb104-235"><a href="#cb104-235" aria-hidden="true" tabindex="-1"></a>    <span class="co"># Rundenzahl: Eine Runde mit Fenster 30 kostet ein Vielfaches einer Runde</span></span>
-<span id="cb104-236"><a href="#cb104-236" aria-hidden="true" tabindex="-1"></a>    <span class="co"># mit Fenster 10. Wer nach Runden vergleicht, misst nur, dass groessere</span></span>
-<span id="cb104-237"><a href="#cb104-237" aria-hidden="true" tabindex="-1"></a>    <span class="co"># Teilprobleme mehr finden - und uebersieht, was sie kosten. Die</span></span>
-<span id="cb104-238"><a href="#cb104-238" aria-hidden="true" tabindex="-1"></a>    <span class="co"># Rundenzahlen unten sind so gewaehlt, dass alle drei Laeufe in derselben</span></span>
-<span id="cb104-239"><a href="#cb104-239" aria-hidden="true" tabindex="-1"></a>    <span class="co"># Groessenordnung liegen.</span></span>
-<span id="cb104-240"><a href="#cb104-240" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;</span><span class="ch">\n</span><span class="st">&quot;</span> <span class="op">+</span> <span class="st">&quot;-&quot;</span> <span class="op">*</span> <span class="dv">84</span>)</span>
-<span id="cb104-241"><a href="#cb104-241" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;Die Fenstergroesse ist die eine Stellschraube - und sie hat ein&quot;</span>)</span>
-<span id="cb104-242"><a href="#cb104-242" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;Optimum in der Mitte. Gleiche Zeit, verschiedene Fenster:</span><span class="ch">\n</span><span class="st">&quot;</span>)</span>
-<span id="cb104-243"><a href="#cb104-243" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;  </span><span class="sc">{</span><span class="st">&#39;Fenster&#39;</span><span class="sc">:&gt;8}</span><span class="ss"> </span><span class="sc">{</span><span class="st">&#39;Runden&#39;</span><span class="sc">:&gt;8}</span><span class="ss"> </span><span class="sc">{</span><span class="st">&#39;Ruestzeit&#39;</span><span class="sc">:&gt;11}</span><span class="ss"> </span><span class="sc">{</span><span class="st">&#39;Verbesser-&#39;</span><span class="sc">:&gt;12}</span><span class="ss"> </span><span class="sc">{</span><span class="st">&#39;Zeit&#39;</span><span class="sc">:&gt;8}</span><span class="ss">&quot;</span>)</span>
-<span id="cb104-244"><a href="#cb104-244" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;  </span><span class="sc">{</span><span class="st">&#39;&#39;</span><span class="sc">:&gt;8}</span><span class="ss"> </span><span class="sc">{</span><span class="st">&#39;&#39;</span><span class="sc">:&gt;8}</span><span class="ss"> </span><span class="sc">{</span><span class="st">&#39;&#39;</span><span class="sc">:&gt;11}</span><span class="ss"> </span><span class="sc">{</span><span class="st">&#39;ungen&#39;</span><span class="sc">:&gt;12}</span><span class="ss"> </span><span class="sc">{</span><span class="st">&#39;&#39;</span><span class="sc">:&gt;8}</span><span class="ss">&quot;</span>)</span>
-<span id="cb104-245"><a href="#cb104-245" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;  &quot;</span> <span class="op">+</span> <span class="st">&quot;-&quot;</span> <span class="op">*</span> <span class="dv">52</span>)</span>
-<span id="cb104-246"><a href="#cb104-246" aria-hidden="true" tabindex="-1"></a>    fenster_ergebnis <span class="op">=</span> {}</span>
-<span id="cb104-247"><a href="#cb104-247" aria-hidden="true" tabindex="-1"></a>    <span class="cf">for</span> fenster, runden <span class="kw">in</span> ((<span class="dv">10</span>, <span class="dv">4000</span>), (<span class="dv">20</span>, <span class="dv">150</span>), (<span class="dv">30</span>, <span class="dv">20</span>)):</span>
-<span id="cb104-248"><a href="#cb104-248" aria-hidden="true" tabindex="-1"></a>        _, wert, verbesserungen, dauer <span class="op">=</span> lns(sa_reihe[:], matrix,</span>
-<span id="cb104-249"><a href="#cb104-249" aria-hidden="true" tabindex="-1"></a>                                             runden<span class="op">=</span>runden, fenster<span class="op">=</span>fenster)</span>
-<span id="cb104-250"><a href="#cb104-250" aria-hidden="true" tabindex="-1"></a>        fenster_ergebnis[fenster] <span class="op">=</span> wert</span>
-<span id="cb104-251"><a href="#cb104-251" aria-hidden="true" tabindex="-1"></a>        <span class="bu">print</span>(<span class="ss">f&quot;  </span><span class="sc">{</span>fenster<span class="sc">:&gt;8}</span><span class="ss"> </span><span class="sc">{</span>runden<span class="sc">:&gt;8,}</span><span class="ss"> </span><span class="sc">{</span>wert<span class="sc">:&gt;11,}</span><span class="ss"> </span><span class="sc">{</span>verbesserungen<span class="sc">:&gt;12}</span><span class="ss"> &quot;</span></span>
-<span id="cb104-252"><a href="#cb104-252" aria-hidden="true" tabindex="-1"></a>              <span class="ss">f&quot;</span><span class="sc">{</span>dauer<span class="sc">:&gt;7.0f}</span><span class="ss">s&quot;</span>)</span>
-<span id="cb104-253"><a href="#cb104-253" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb104-254"><a href="#cb104-254" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;</span><span class="ch">\n</span><span class="st">  Nach unten ist die Grenze nicht die Zeit, sondern die SAETTIGUNG:&quot;</span>)</span>
-<span id="cb104-255"><a href="#cb104-255" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;  Mit Fenster 10 bleiben von </span><span class="sc">{</span><span class="dv">4000</span><span class="sc">:,}</span><span class="ss"> Runden nur eine Handvoll&quot;</span>)</span>
-<span id="cb104-256"><a href="#cb104-256" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;  Verbesserungen uebrig. Zwanzig Auftraege lassen sich in einem Zug&quot;</span>)</span>
-<span id="cb104-257"><a href="#cb104-257" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;  umbauen, zehn nicht - und was ein Fenster nicht umbauen kann, findet&quot;</span>)</span>
-<span id="cb104-258"><a href="#cb104-258" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;  es auch in beliebig vielen Runden nicht.&quot;</span>)</span>
-<span id="cb104-259"><a href="#cb104-259" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;</span><span class="ch">\n</span><span class="st">  Nach oben ist die Grenze die Rechenzeit: Fenster 30 findet pro Runde&quot;</span>)</span>
-<span id="cb104-260"><a href="#cb104-260" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;  mehr, kommt in derselben Zeit aber nur auf einen Bruchteil der Runden&quot;</span>)</span>
-<span id="cb104-261"><a href="#cb104-261" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;  und landet bei </span><span class="sc">{</span>fenster_ergebnis[<span class="dv">30</span>]<span class="sc">:,}</span><span class="ss"> statt </span><span class="sc">{</span>fenster_ergebnis[<span class="dv">20</span>]<span class="sc">:,}</span><span class="ss">. Eine Reparatur mit 30 Auftraegen&quot;</span>)</span>
-<span id="cb104-262"><a href="#cb104-262" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;  ist eben genau das Problem, an dem der exakte Solver im Grossen&quot;</span>)</span>
-<span id="cb104-263"><a href="#cb104-263" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;  scheitert - nur eine Nummer kleiner.&quot;</span>)</span>
-<span id="cb104-264"><a href="#cb104-264" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;</span><span class="ch">\n</span><span class="st">  Diese Tabelle gehoert an den Anfang jedes LNS-Projekts. Sie zu raten&quot;</span>)</span>
-<span id="cb104-265"><a href="#cb104-265" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;  statt zu messen ist der haeufigste Fehler beim Einsatz des Verfahrens.&quot;</span>)</span>
-<span id="cb104-266"><a href="#cb104-266" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb104-267"><a href="#cb104-267" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;</span><span class="ch">\n</span><span class="st">&quot;</span> <span class="op">+</span> <span class="st">&quot;=&quot;</span> <span class="op">*</span> <span class="dv">84</span>)</span>
-<span id="cb104-268"><a href="#cb104-268" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;  WAS DAS HEISST&quot;</span>)</span>
-<span id="cb104-269"><a href="#cb104-269" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;=&quot;</span> <span class="op">*</span> <span class="dv">84</span>)</span>
-<span id="cb104-270"><a href="#cb104-270" aria-hidden="true" tabindex="-1"></a>    bester <span class="op">=</span> lns_ab_annealing[<span class="dv">1</span>]</span>
-<span id="cb104-271"><a href="#cb104-271" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;Der beste Plan kommt aus der Kombination: </span><span class="sc">{</span>bester<span class="sc">:,}</span><span class="ss"> Minuten,&quot;</span>)</span>
-<span id="cb104-272"><a href="#cb104-272" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;</span><span class="sc">{</span>(start_kosten <span class="op">-</span> bester) <span class="op">/</span> start_kosten <span class="op">*</span> <span class="dv">100</span><span class="sc">:.1f}</span><span class="ss"> % unter der Faustregel und &quot;</span></span>
-<span id="cb104-273"><a href="#cb104-273" aria-hidden="true" tabindex="-1"></a>          <span class="ss">f&quot;</span><span class="sc">{</span>(sa_kosten <span class="op">-</span> bester) <span class="op">/</span> sa_kosten <span class="op">*</span> <span class="dv">100</span><span class="sc">:.1f}</span><span class="ss"> % unter dem reinen Annealing.&quot;</span>)</span>
-<span id="cb104-274"><a href="#cb104-274" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>()</span>
-<span id="cb104-275"><a href="#cb104-275" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;Weder der exakte Solver noch die Metaheuristik allein kommen dorthin.&quot;</span>)</span>
-<span id="cb104-276"><a href="#cb104-276" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;Der Solver scheitert an der Groesse, die Metaheuristik an der Kleinheit&quot;</span>)</span>
-<span id="cb104-277"><a href="#cb104-277" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;ihrer Zuege. LNS gibt dem Solver Teilprobleme in einer Groesse, die er&quot;</span>)</span>
-<span id="cb104-278"><a href="#cb104-278" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;beherrscht, und der Metaheuristik die Umbauten, die sie nicht kann.&quot;</span>)</span>
-<span id="cb104-279"><a href="#cb104-279" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>()</span>
-<span id="cb104-280"><a href="#cb104-280" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;Und die Ehrlichkeit zum Schluss: Auch </span><span class="sc">{</span>bester<span class="sc">:,}</span><span class="ss"> liegt noch &quot;</span></span>
-<span id="cb104-281"><a href="#cb104-281" aria-hidden="true" tabindex="-1"></a>          <span class="ss">f&quot;</span><span class="sc">{</span>(bester <span class="op">-</span> SCHRANKE) <span class="op">/</span> SCHRANKE <span class="op">*</span> <span class="dv">100</span><span class="sc">:.0f}</span><span class="ss"> % ueber der&quot;</span>)</span>
-<span id="cb104-282"><a href="#cb104-282" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;Schranke. Ob dort wirklich noch so viel Luft ist oder ob die Schranke&quot;</span>)</span>
-<span id="cb104-283"><a href="#cb104-283" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;nur schwach ist, weiss man nicht - das ist die Lage, in der man mit&quot;</span>)</span>
-<span id="cb104-284"><a href="#cb104-284" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;einer Metaheuristik arbeitet. Man kennt seine Loesung, nicht ihren&quot;</span>)</span>
-<span id="cb104-285"><a href="#cb104-285" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;Abstand zum Optimum.&quot;</span>)</span>
-<span id="cb104-286"><a href="#cb104-286" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;=&quot;</span> <span class="op">*</span> <span class="dv">84</span>)</span></code></pre></div>
+<div class="sourceCode" id="cb106"><pre class="sourceCode python"><code class="sourceCode python"><span id="cb106-1"><a href="#cb106-1" aria-hidden="true" tabindex="-1"></a><span class="co">#!/usr/bin/env python3</span></span>
+<span id="cb106-2"><a href="#cb106-2" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb106-3"><a href="#cb106-3" aria-hidden="true" tabindex="-1"></a><span class="co"># Large_Neighborhood_Search.py</span></span>
+<span id="cb106-4"><a href="#cb106-4" aria-hidden="true" tabindex="-1"></a><span class="co">&quot;&quot;&quot;</span></span>
+<span id="cb106-5"><a href="#cb106-5" aria-hidden="true" tabindex="-1"></a><span class="co">Kapitel Metaheuristiken: Zerstoeren und exakt reparieren - der Solver im Dienst der Heuristik.</span></span>
+<span id="cb106-6"><a href="#cb106-6" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb106-7"><a href="#cb106-7" aria-hidden="true" tabindex="-1"></a><span class="co">Metaheuristik_vs_Exakt.py endet mit einem Widerspruch. Bei 500 Auftraegen gilt:</span></span>
+<span id="cb106-8"><a href="#cb106-8" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb106-9"><a href="#cb106-9" aria-hidden="true" tabindex="-1"></a><span class="co">  * Der exakte Solver scheitert an der GROESSE - seine Loesung nach 30 Sekunden</span></span>
+<span id="cb106-10"><a href="#cb106-10" aria-hidden="true" tabindex="-1"></a><span class="co">    ist schlechter als die Faustregel eines Meisters.</span></span>
+<span id="cb106-11"><a href="#cb106-11" aria-hidden="true" tabindex="-1"></a><span class="co">  * Die Metaheuristik kommt weiter, laesst aber laut Schranke noch rund ein</span></span>
+<span id="cb106-12"><a href="#cb106-12" aria-hidden="true" tabindex="-1"></a><span class="co">    Viertel liegen. Ihre Zuege sind zu kleinteilig: Sie verschiebt jeweils</span></span>
+<span id="cb106-13"><a href="#cb106-13" aria-hidden="true" tabindex="-1"></a><span class="co">    EINEN Auftrag und kann eine ganze Passage nicht auf einmal umbauen.</span></span>
+<span id="cb106-14"><a href="#cb106-14" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb106-15"><a href="#cb106-15" aria-hidden="true" tabindex="-1"></a><span class="co">Large Neighborhood Search loest den Widerspruch, indem sie beide einsetzt -</span></span>
+<span id="cb106-16"><a href="#cb106-16" aria-hidden="true" tabindex="-1"></a><span class="co">jeden fuer das, was er kann:</span></span>
+<span id="cb106-17"><a href="#cb106-17" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb106-18"><a href="#cb106-18" aria-hidden="true" tabindex="-1"></a><span class="co">    ZERSTOEREN   Ein Stueck des Plans herausbrechen (hier: ein zusammen-</span></span>
+<span id="cb106-19"><a href="#cb106-19" aria-hidden="true" tabindex="-1"></a><span class="co">                 haengendes Fenster von 20 Auftraegen).</span></span>
+<span id="cb106-20"><a href="#cb106-20" aria-hidden="true" tabindex="-1"></a><span class="co">    REPARIEREN   Genau dieses Stueck EXAKT neu optimieren. 20 Auftraege sind</span></span>
+<span id="cb106-21"><a href="#cb106-21" aria-hidden="true" tabindex="-1"></a><span class="co">                 fuer CP-SAT eine Kleinigkeit, 500 sind es nicht.</span></span>
+<span id="cb106-22"><a href="#cb106-22" aria-hidden="true" tabindex="-1"></a><span class="co">    UEBERNEHMEN  Nur behalten, wenn der Gesamtplan besser wurde.</span></span>
+<span id="cb106-23"><a href="#cb106-23" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb106-24"><a href="#cb106-24" aria-hidden="true" tabindex="-1"></a><span class="co">Der Solver bekommt also nicht mehr das ganze Problem, sondern immer wieder ein</span></span>
+<span id="cb106-25"><a href="#cb106-25" aria-hidden="true" tabindex="-1"></a><span class="co">kleines. Das ist der ganze Trick, und er ist in der Praxis der wichtigste</span></span>
+<span id="cb106-26"><a href="#cb106-26" aria-hidden="true" tabindex="-1"></a><span class="co">Baustein dieses Kapitels.</span></span>
+<span id="cb106-27"><a href="#cb106-27" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb106-28"><a href="#cb106-28" aria-hidden="true" tabindex="-1"></a><span class="co">ZUR REPRODUZIERBARKEIT: Alle Laeufe haben eine feste RUNDENzahl, nicht ein</span></span>
+<span id="cb106-29"><a href="#cb106-29" aria-hidden="true" tabindex="-1"></a><span class="co">Zeitbudget - die Ergebniswerte sind damit auf jeder Maschine gleich. Die</span></span>
+<span id="cb106-30"><a href="#cb106-30" aria-hidden="true" tabindex="-1"></a><span class="co">Laufzeiten daneben sind hardwareabhaengig.</span></span>
+<span id="cb106-31"><a href="#cb106-31" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb106-32"><a href="#cb106-32" aria-hidden="true" tabindex="-1"></a><span class="co">Benoetigt: numpy, ortools</span></span>
+<span id="cb106-33"><a href="#cb106-33" aria-hidden="true" tabindex="-1"></a><span class="co">&quot;&quot;&quot;</span></span>
+<span id="cb106-34"><a href="#cb106-34" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb106-35"><a href="#cb106-35" aria-hidden="true" tabindex="-1"></a><span class="im">from</span> __future__ <span class="im">import</span> annotations</span>
+<span id="cb106-36"><a href="#cb106-36" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb106-37"><a href="#cb106-37" aria-hidden="true" tabindex="-1"></a><span class="im">import</span> math</span>
+<span id="cb106-38"><a href="#cb106-38" aria-hidden="true" tabindex="-1"></a><span class="im">import</span> time</span>
+<span id="cb106-39"><a href="#cb106-39" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb106-40"><a href="#cb106-40" aria-hidden="true" tabindex="-1"></a><span class="im">import</span> numpy <span class="im">as</span> np</span>
+<span id="cb106-41"><a href="#cb106-41" aria-hidden="true" tabindex="-1"></a><span class="im">from</span> ortools.sat.python <span class="im">import</span> cp_model</span>
+<span id="cb106-42"><a href="#cb106-42" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb106-43"><a href="#cb106-43" aria-hidden="true" tabindex="-1"></a>FENSTER <span class="op">=</span> <span class="dv">20</span>              <span class="co"># so viele Auftraege werden je Runde herausgebrochen</span></span>
+<span id="cb106-44"><a href="#cb106-44" aria-hidden="true" tabindex="-1"></a>RUNDEN <span class="op">=</span> <span class="dv">120</span></span>
+<span id="cb106-45"><a href="#cb106-45" aria-hidden="true" tabindex="-1"></a>ZUEGE <span class="op">=</span> <span class="dv">400_000</span>           <span class="co"># Zugbudget des Annealings (wie Simulated_Annealing.py)</span></span>
+<span id="cb106-46"><a href="#cb106-46" aria-hidden="true" tabindex="-1"></a>N <span class="op">=</span> <span class="dv">500</span></span>
+<span id="cb106-47"><a href="#cb106-47" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb106-48"><a href="#cb106-48" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb106-49"><a href="#cb106-49" aria-hidden="true" tabindex="-1"></a><span class="co"># --- Instanz und Faustregel (wie in Simulated_Annealing.py) ----------------</span></span>
+<span id="cb106-50"><a href="#cb106-50" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb106-51"><a href="#cb106-51" aria-hidden="true" tabindex="-1"></a><span class="kw">def</span> erzeuge_ruestmatrix(n: <span class="bu">int</span>, saat: <span class="bu">int</span> <span class="op">=</span> <span class="dv">11</span>) <span class="op">-&gt;</span> np.ndarray:</span>
+<span id="cb106-52"><a href="#cb106-52" aria-hidden="true" tabindex="-1"></a>    rng <span class="op">=</span> np.random.default_rng(saat)</span>
+<span id="cb106-53"><a href="#cb106-53" aria-hidden="true" tabindex="-1"></a>    familien <span class="op">=</span> <span class="bu">max</span>(<span class="dv">6</span>, n <span class="op">//</span> <span class="dv">10</span>)</span>
+<span id="cb106-54"><a href="#cb106-54" aria-hidden="true" tabindex="-1"></a>    zwischen <span class="op">=</span> rng.integers(<span class="dv">8</span>, <span class="dv">60</span>, (familien, familien))</span>
+<span id="cb106-55"><a href="#cb106-55" aria-hidden="true" tabindex="-1"></a>    np.fill_diagonal(zwischen, <span class="dv">2</span>)</span>
+<span id="cb106-56"><a href="#cb106-56" aria-hidden="true" tabindex="-1"></a>    familie <span class="op">=</span> rng.integers(<span class="dv">0</span>, familien, n)</span>
+<span id="cb106-57"><a href="#cb106-57" aria-hidden="true" tabindex="-1"></a>    farbe <span class="op">=</span> rng.integers(<span class="dv">0</span>, <span class="dv">10</span>, n)</span>
+<span id="cb106-58"><a href="#cb106-58" aria-hidden="true" tabindex="-1"></a>    matrix <span class="op">=</span> np.zeros((n, n), dtype<span class="op">=</span>np.int64)</span>
+<span id="cb106-59"><a href="#cb106-59" aria-hidden="true" tabindex="-1"></a>    <span class="cf">for</span> i <span class="kw">in</span> <span class="bu">range</span>(n):</span>
+<span id="cb106-60"><a href="#cb106-60" aria-hidden="true" tabindex="-1"></a>        <span class="cf">for</span> j <span class="kw">in</span> <span class="bu">range</span>(n):</span>
+<span id="cb106-61"><a href="#cb106-61" aria-hidden="true" tabindex="-1"></a>            <span class="cf">if</span> i <span class="op">!=</span> j:</span>
+<span id="cb106-62"><a href="#cb106-62" aria-hidden="true" tabindex="-1"></a>                matrix[i, j] <span class="op">=</span> (zwischen[familie[i], familie[j]]</span>
+<span id="cb106-63"><a href="#cb106-63" aria-hidden="true" tabindex="-1"></a>                                <span class="op">+</span> <span class="dv">3</span> <span class="op">*</span> <span class="bu">max</span>(<span class="dv">0</span>, farbe[i] <span class="op">-</span> farbe[j]))</span>
+<span id="cb106-64"><a href="#cb106-64" aria-hidden="true" tabindex="-1"></a>    <span class="cf">return</span> matrix</span>
+<span id="cb106-65"><a href="#cb106-65" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb106-66"><a href="#cb106-66" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb106-67"><a href="#cb106-67" aria-hidden="true" tabindex="-1"></a><span class="kw">def</span> gesamtruestzeit(reihe: <span class="bu">list</span>[<span class="bu">int</span>], matrix: np.ndarray) <span class="op">-&gt;</span> <span class="bu">int</span>:</span>
+<span id="cb106-68"><a href="#cb106-68" aria-hidden="true" tabindex="-1"></a>    <span class="cf">return</span> <span class="bu">int</span>(<span class="bu">sum</span>(matrix[reihe[k], reihe[k <span class="op">+</span> <span class="dv">1</span>]] <span class="cf">for</span> k <span class="kw">in</span> <span class="bu">range</span>(<span class="bu">len</span>(reihe) <span class="op">-</span> <span class="dv">1</span>)))</span>
+<span id="cb106-69"><a href="#cb106-69" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb106-70"><a href="#cb106-70" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb106-71"><a href="#cb106-71" aria-hidden="true" tabindex="-1"></a><span class="kw">def</span> faustregel(matrix: np.ndarray) <span class="op">-&gt;</span> <span class="bu">list</span>[<span class="bu">int</span>]:</span>
+<span id="cb106-72"><a href="#cb106-72" aria-hidden="true" tabindex="-1"></a>    n <span class="op">=</span> <span class="bu">len</span>(matrix)</span>
+<span id="cb106-73"><a href="#cb106-73" aria-hidden="true" tabindex="-1"></a>    offen <span class="op">=</span> <span class="bu">set</span>(<span class="bu">range</span>(<span class="dv">1</span>, n))</span>
+<span id="cb106-74"><a href="#cb106-74" aria-hidden="true" tabindex="-1"></a>    reihe <span class="op">=</span> [<span class="dv">0</span>]</span>
+<span id="cb106-75"><a href="#cb106-75" aria-hidden="true" tabindex="-1"></a>    <span class="cf">while</span> offen:</span>
+<span id="cb106-76"><a href="#cb106-76" aria-hidden="true" tabindex="-1"></a>        naechster <span class="op">=</span> <span class="bu">min</span>(offen, key<span class="op">=</span><span class="kw">lambda</span> j: matrix[reihe[<span class="op">-</span><span class="dv">1</span>], j])</span>
+<span id="cb106-77"><a href="#cb106-77" aria-hidden="true" tabindex="-1"></a>        reihe.append(naechster)</span>
+<span id="cb106-78"><a href="#cb106-78" aria-hidden="true" tabindex="-1"></a>        offen.discard(naechster)</span>
+<span id="cb106-79"><a href="#cb106-79" aria-hidden="true" tabindex="-1"></a>    <span class="cf">return</span> reihe</span>
+<span id="cb106-80"><a href="#cb106-80" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb106-81"><a href="#cb106-81" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb106-82"><a href="#cb106-82" aria-hidden="true" tabindex="-1"></a><span class="kw">def</span> delta_verschieben(reihe, matrix, von, nach):</span>
+<span id="cb106-83"><a href="#cb106-83" aria-hidden="true" tabindex="-1"></a>    n <span class="op">=</span> <span class="bu">len</span>(reihe)</span>
+<span id="cb106-84"><a href="#cb106-84" aria-hidden="true" tabindex="-1"></a>    <span class="cf">if</span> von <span class="op">==</span> nach <span class="kw">or</span> nach <span class="op">==</span> von <span class="op">+</span> <span class="dv">1</span>:</span>
+<span id="cb106-85"><a href="#cb106-85" aria-hidden="true" tabindex="-1"></a>        <span class="cf">return</span> <span class="va">None</span></span>
+<span id="cb106-86"><a href="#cb106-86" aria-hidden="true" tabindex="-1"></a>    heraus <span class="op">=</span> <span class="dv">0</span></span>
+<span id="cb106-87"><a href="#cb106-87" aria-hidden="true" tabindex="-1"></a>    <span class="cf">if</span> von <span class="op">&gt;</span> <span class="dv">0</span>:</span>
+<span id="cb106-88"><a href="#cb106-88" aria-hidden="true" tabindex="-1"></a>        heraus <span class="op">+=</span> matrix[reihe[von <span class="op">-</span> <span class="dv">1</span>], reihe[von]]</span>
+<span id="cb106-89"><a href="#cb106-89" aria-hidden="true" tabindex="-1"></a>    <span class="cf">if</span> von <span class="op">&lt;</span> n <span class="op">-</span> <span class="dv">1</span>:</span>
+<span id="cb106-90"><a href="#cb106-90" aria-hidden="true" tabindex="-1"></a>        heraus <span class="op">+=</span> matrix[reihe[von], reihe[von <span class="op">+</span> <span class="dv">1</span>]]</span>
+<span id="cb106-91"><a href="#cb106-91" aria-hidden="true" tabindex="-1"></a>    <span class="cf">if</span> <span class="dv">0</span> <span class="op">&lt;</span> von <span class="op">&lt;</span> n <span class="op">-</span> <span class="dv">1</span>:</span>
+<span id="cb106-92"><a href="#cb106-92" aria-hidden="true" tabindex="-1"></a>        heraus <span class="op">-=</span> matrix[reihe[von <span class="op">-</span> <span class="dv">1</span>], reihe[von <span class="op">+</span> <span class="dv">1</span>]]</span>
+<span id="cb106-93"><a href="#cb106-93" aria-hidden="true" tabindex="-1"></a>    rest <span class="op">=</span> reihe[:von] <span class="op">+</span> reihe[von <span class="op">+</span> <span class="dv">1</span>:]</span>
+<span id="cb106-94"><a href="#cb106-94" aria-hidden="true" tabindex="-1"></a>    stelle <span class="op">=</span> nach <span class="cf">if</span> nach <span class="op">&lt;</span> von <span class="cf">else</span> nach <span class="op">-</span> <span class="dv">1</span></span>
+<span id="cb106-95"><a href="#cb106-95" aria-hidden="true" tabindex="-1"></a>    hinein <span class="op">=</span> <span class="dv">0</span></span>
+<span id="cb106-96"><a href="#cb106-96" aria-hidden="true" tabindex="-1"></a>    <span class="cf">if</span> stelle <span class="op">&gt;</span> <span class="dv">0</span>:</span>
+<span id="cb106-97"><a href="#cb106-97" aria-hidden="true" tabindex="-1"></a>        hinein <span class="op">+=</span> matrix[rest[stelle <span class="op">-</span> <span class="dv">1</span>], reihe[von]]</span>
+<span id="cb106-98"><a href="#cb106-98" aria-hidden="true" tabindex="-1"></a>    <span class="cf">if</span> stelle <span class="op">&lt;</span> <span class="bu">len</span>(rest):</span>
+<span id="cb106-99"><a href="#cb106-99" aria-hidden="true" tabindex="-1"></a>        hinein <span class="op">+=</span> matrix[reihe[von], rest[stelle]]</span>
+<span id="cb106-100"><a href="#cb106-100" aria-hidden="true" tabindex="-1"></a>    <span class="cf">if</span> <span class="dv">0</span> <span class="op">&lt;</span> stelle <span class="op">&lt;</span> <span class="bu">len</span>(rest):</span>
+<span id="cb106-101"><a href="#cb106-101" aria-hidden="true" tabindex="-1"></a>        hinein <span class="op">-=</span> matrix[rest[stelle <span class="op">-</span> <span class="dv">1</span>], rest[stelle]]</span>
+<span id="cb106-102"><a href="#cb106-102" aria-hidden="true" tabindex="-1"></a>    <span class="cf">return</span> <span class="bu">int</span>(hinein <span class="op">-</span> heraus), rest, stelle</span>
+<span id="cb106-103"><a href="#cb106-103" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb106-104"><a href="#cb106-104" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb106-105"><a href="#cb106-105" aria-hidden="true" tabindex="-1"></a><span class="kw">def</span> annealing(matrix: np.ndarray, zuege: <span class="bu">int</span> <span class="op">=</span> ZUEGE,</span>
+<span id="cb106-106"><a href="#cb106-106" aria-hidden="true" tabindex="-1"></a>              start_temperatur: <span class="bu">float</span> <span class="op">=</span> <span class="fl">1.0</span>, saat: <span class="bu">int</span> <span class="op">=</span> <span class="dv">1</span>) <span class="op">-&gt;</span> <span class="bu">list</span>[<span class="bu">int</span>]:</span>
+<span id="cb106-107"><a href="#cb106-107" aria-hidden="true" tabindex="-1"></a>    rng <span class="op">=</span> np.random.default_rng(saat)</span>
+<span id="cb106-108"><a href="#cb106-108" aria-hidden="true" tabindex="-1"></a>    n <span class="op">=</span> <span class="bu">len</span>(matrix)</span>
+<span id="cb106-109"><a href="#cb106-109" aria-hidden="true" tabindex="-1"></a>    reihe <span class="op">=</span> faustregel(matrix)</span>
+<span id="cb106-110"><a href="#cb106-110" aria-hidden="true" tabindex="-1"></a>    kosten <span class="op">=</span> gesamtruestzeit(reihe, matrix)</span>
+<span id="cb106-111"><a href="#cb106-111" aria-hidden="true" tabindex="-1"></a>    beste, beste_kosten <span class="op">=</span> reihe[:], kosten</span>
+<span id="cb106-112"><a href="#cb106-112" aria-hidden="true" tabindex="-1"></a>    <span class="cf">for</span> zug <span class="kw">in</span> <span class="bu">range</span>(zuege):</span>
+<span id="cb106-113"><a href="#cb106-113" aria-hidden="true" tabindex="-1"></a>        temperatur <span class="op">=</span> start_temperatur <span class="op">*</span> (<span class="fl">0.05</span> <span class="op">/</span> start_temperatur) <span class="op">**</span> (zug <span class="op">/</span> zuege)</span>
+<span id="cb106-114"><a href="#cb106-114" aria-hidden="true" tabindex="-1"></a>        von, nach <span class="op">=</span> <span class="bu">int</span>(rng.integers(<span class="dv">0</span>, n)), <span class="bu">int</span>(rng.integers(<span class="dv">0</span>, n <span class="op">+</span> <span class="dv">1</span>))</span>
+<span id="cb106-115"><a href="#cb106-115" aria-hidden="true" tabindex="-1"></a>        ergebnis <span class="op">=</span> delta_verschieben(reihe, matrix, von, nach)</span>
+<span id="cb106-116"><a href="#cb106-116" aria-hidden="true" tabindex="-1"></a>        <span class="cf">if</span> ergebnis <span class="kw">is</span> <span class="va">None</span>:</span>
+<span id="cb106-117"><a href="#cb106-117" aria-hidden="true" tabindex="-1"></a>            <span class="cf">continue</span></span>
+<span id="cb106-118"><a href="#cb106-118" aria-hidden="true" tabindex="-1"></a>        aenderung, rest, stelle <span class="op">=</span> ergebnis</span>
+<span id="cb106-119"><a href="#cb106-119" aria-hidden="true" tabindex="-1"></a>        <span class="cf">if</span> aenderung <span class="op">&lt;=</span> <span class="dv">0</span> <span class="kw">or</span> rng.random() <span class="op">&lt;</span> math.exp(<span class="op">-</span>aenderung <span class="op">/</span> temperatur):</span>
+<span id="cb106-120"><a href="#cb106-120" aria-hidden="true" tabindex="-1"></a>            reihe <span class="op">=</span> rest[:stelle] <span class="op">+</span> [reihe[von]] <span class="op">+</span> rest[stelle:]</span>
+<span id="cb106-121"><a href="#cb106-121" aria-hidden="true" tabindex="-1"></a>            kosten <span class="op">+=</span> aenderung</span>
+<span id="cb106-122"><a href="#cb106-122" aria-hidden="true" tabindex="-1"></a>            <span class="cf">if</span> kosten <span class="op">&lt;</span> beste_kosten:</span>
+<span id="cb106-123"><a href="#cb106-123" aria-hidden="true" tabindex="-1"></a>                beste, beste_kosten <span class="op">=</span> reihe[:], kosten</span>
+<span id="cb106-124"><a href="#cb106-124" aria-hidden="true" tabindex="-1"></a>    <span class="cf">return</span> beste</span>
+<span id="cb106-125"><a href="#cb106-125" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb106-126"><a href="#cb106-126" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb106-127"><a href="#cb106-127" aria-hidden="true" tabindex="-1"></a><span class="co"># --- Der Reparaturschritt: ein kleines Problem, exakt geloest --------------</span></span>
+<span id="cb106-128"><a href="#cb106-128" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb106-129"><a href="#cb106-129" aria-hidden="true" tabindex="-1"></a><span class="kw">def</span> repariere_fenster(reihe: <span class="bu">list</span>[<span class="bu">int</span>], matrix: np.ndarray,</span>
+<span id="cb106-130"><a href="#cb106-130" aria-hidden="true" tabindex="-1"></a>                      a: <span class="bu">int</span>, b: <span class="bu">int</span>) <span class="op">-&gt;</span> <span class="bu">list</span>[<span class="bu">int</span>] <span class="op">|</span> <span class="va">None</span>:</span>
+<span id="cb106-131"><a href="#cb106-131" aria-hidden="true" tabindex="-1"></a>    <span class="co">&quot;&quot;&quot;Ordnet reihe[a:b] optimal neu; die beiden Raender bleiben, wo sie sind.</span></span>
+<span id="cb106-132"><a href="#cb106-132" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb106-133"><a href="#cb106-133" aria-hidden="true" tabindex="-1"></a><span class="co">    Die Raender festzuhalten ist entscheidend. Ohne sie waere das Teilproblem</span></span>
+<span id="cb106-134"><a href="#cb106-134" aria-hidden="true" tabindex="-1"></a><span class="co">    ein anderes als der Ausschnitt aus dem Gesamtplan: Der Uebergang vom</span></span>
+<span id="cb106-135"><a href="#cb106-135" aria-hidden="true" tabindex="-1"></a><span class="co">    Vorgaenger in das Fenster und aus dem Fenster in den Nachfolger gehoert</span></span>
+<span id="cb106-136"><a href="#cb106-136" aria-hidden="true" tabindex="-1"></a><span class="co">    zu den Kosten dazu. Genau dafuer steht der Hilfsknoten k - er vertritt</span></span>
+<span id="cb106-137"><a href="#cb106-137" aria-hidden="true" tabindex="-1"></a><span class="co">    beide Raender in einem.</span></span>
+<span id="cb106-138"><a href="#cb106-138" aria-hidden="true" tabindex="-1"></a><span class="co">    &quot;&quot;&quot;</span></span>
+<span id="cb106-139"><a href="#cb106-139" aria-hidden="true" tabindex="-1"></a>    innen <span class="op">=</span> reihe[a:b]</span>
+<span id="cb106-140"><a href="#cb106-140" aria-hidden="true" tabindex="-1"></a>    k <span class="op">=</span> <span class="bu">len</span>(innen)</span>
+<span id="cb106-141"><a href="#cb106-141" aria-hidden="true" tabindex="-1"></a>    vorgaenger <span class="op">=</span> reihe[a <span class="op">-</span> <span class="dv">1</span>] <span class="cf">if</span> a <span class="op">&gt;</span> <span class="dv">0</span> <span class="cf">else</span> <span class="va">None</span></span>
+<span id="cb106-142"><a href="#cb106-142" aria-hidden="true" tabindex="-1"></a>    nachfolger_rand <span class="op">=</span> reihe[b] <span class="cf">if</span> b <span class="op">&lt;</span> <span class="bu">len</span>(reihe) <span class="cf">else</span> <span class="va">None</span></span>
+<span id="cb106-143"><a href="#cb106-143" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb106-144"><a href="#cb106-144" aria-hidden="true" tabindex="-1"></a>    modell <span class="op">=</span> cp_model.CpModel()</span>
+<span id="cb106-145"><a href="#cb106-145" aria-hidden="true" tabindex="-1"></a>    kanten, ziel <span class="op">=</span> [], []</span>
+<span id="cb106-146"><a href="#cb106-146" aria-hidden="true" tabindex="-1"></a>    <span class="cf">for</span> i <span class="kw">in</span> <span class="bu">range</span>(k <span class="op">+</span> <span class="dv">1</span>):</span>
+<span id="cb106-147"><a href="#cb106-147" aria-hidden="true" tabindex="-1"></a>        <span class="cf">for</span> j <span class="kw">in</span> <span class="bu">range</span>(k <span class="op">+</span> <span class="dv">1</span>):</span>
+<span id="cb106-148"><a href="#cb106-148" aria-hidden="true" tabindex="-1"></a>            <span class="cf">if</span> i <span class="op">==</span> j:</span>
+<span id="cb106-149"><a href="#cb106-149" aria-hidden="true" tabindex="-1"></a>                <span class="cf">continue</span></span>
+<span id="cb106-150"><a href="#cb106-150" aria-hidden="true" tabindex="-1"></a>            aktiv <span class="op">=</span> modell.NewBoolVar(<span class="ss">f&quot;kante_</span><span class="sc">{</span>i<span class="sc">}</span><span class="ss">_</span><span class="sc">{</span>j<span class="sc">}</span><span class="ss">&quot;</span>)</span>
+<span id="cb106-151"><a href="#cb106-151" aria-hidden="true" tabindex="-1"></a>            kanten.append((i, j, aktiv))</span>
+<span id="cb106-152"><a href="#cb106-152" aria-hidden="true" tabindex="-1"></a>            <span class="cf">if</span> i <span class="op">&lt;</span> k <span class="kw">and</span> j <span class="op">&lt;</span> k:</span>
+<span id="cb106-153"><a href="#cb106-153" aria-hidden="true" tabindex="-1"></a>                ziel.append(<span class="bu">int</span>(matrix[innen[i], innen[j]]) <span class="op">*</span> aktiv)</span>
+<span id="cb106-154"><a href="#cb106-154" aria-hidden="true" tabindex="-1"></a>            <span class="cf">elif</span> i <span class="op">==</span> k <span class="kw">and</span> j <span class="op">&lt;</span> k <span class="kw">and</span> vorgaenger <span class="kw">is</span> <span class="kw">not</span> <span class="va">None</span>:</span>
+<span id="cb106-155"><a href="#cb106-155" aria-hidden="true" tabindex="-1"></a>                ziel.append(<span class="bu">int</span>(matrix[vorgaenger, innen[j]]) <span class="op">*</span> aktiv)</span>
+<span id="cb106-156"><a href="#cb106-156" aria-hidden="true" tabindex="-1"></a>            <span class="cf">elif</span> j <span class="op">==</span> k <span class="kw">and</span> i <span class="op">&lt;</span> k <span class="kw">and</span> nachfolger_rand <span class="kw">is</span> <span class="kw">not</span> <span class="va">None</span>:</span>
+<span id="cb106-157"><a href="#cb106-157" aria-hidden="true" tabindex="-1"></a>                ziel.append(<span class="bu">int</span>(matrix[innen[i], nachfolger_rand]) <span class="op">*</span> aktiv)</span>
+<span id="cb106-158"><a href="#cb106-158" aria-hidden="true" tabindex="-1"></a>    modell.AddCircuit(kanten)</span>
+<span id="cb106-159"><a href="#cb106-159" aria-hidden="true" tabindex="-1"></a>    modell.Minimize(<span class="bu">sum</span>(ziel))</span>
+<span id="cb106-160"><a href="#cb106-160" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb106-161"><a href="#cb106-161" aria-hidden="true" tabindex="-1"></a>    loeser <span class="op">=</span> cp_model.CpSolver()</span>
+<span id="cb106-162"><a href="#cb106-162" aria-hidden="true" tabindex="-1"></a>    loeser.parameters.num_workers <span class="op">=</span> <span class="dv">1</span></span>
+<span id="cb106-163"><a href="#cb106-163" aria-hidden="true" tabindex="-1"></a>    loeser.parameters.random_seed <span class="op">=</span> <span class="dv">1</span></span>
+<span id="cb106-164"><a href="#cb106-164" aria-hidden="true" tabindex="-1"></a>    loeser.parameters.max_time_in_seconds <span class="op">=</span> <span class="fl">10.0</span></span>
+<span id="cb106-165"><a href="#cb106-165" aria-hidden="true" tabindex="-1"></a>    status <span class="op">=</span> loeser.Solve(modell)</span>
+<span id="cb106-166"><a href="#cb106-166" aria-hidden="true" tabindex="-1"></a>    <span class="cf">if</span> status <span class="kw">not</span> <span class="kw">in</span> (cp_model.OPTIMAL, cp_model.FEASIBLE):</span>
+<span id="cb106-167"><a href="#cb106-167" aria-hidden="true" tabindex="-1"></a>        <span class="co"># Auch das gehoert dazu: Wenn das Teilproblem nicht loest, bleibt der</span></span>
+<span id="cb106-168"><a href="#cb106-168" aria-hidden="true" tabindex="-1"></a>        <span class="co"># Plan, wie er war. Eine LNS-Runde darf scheitern.</span></span>
+<span id="cb106-169"><a href="#cb106-169" aria-hidden="true" tabindex="-1"></a>        <span class="cf">return</span> <span class="va">None</span></span>
+<span id="cb106-170"><a href="#cb106-170" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb106-171"><a href="#cb106-171" aria-hidden="true" tabindex="-1"></a>    nachfolger <span class="op">=</span> {i: j <span class="cf">for</span> i, j, aktiv <span class="kw">in</span> kanten <span class="cf">if</span> loeser.Value(aktiv)}</span>
+<span id="cb106-172"><a href="#cb106-172" aria-hidden="true" tabindex="-1"></a>    neue_folge, aktuell <span class="op">=</span> [], nachfolger[k]</span>
+<span id="cb106-173"><a href="#cb106-173" aria-hidden="true" tabindex="-1"></a>    <span class="cf">while</span> aktuell <span class="op">!=</span> k:</span>
+<span id="cb106-174"><a href="#cb106-174" aria-hidden="true" tabindex="-1"></a>        neue_folge.append(innen[aktuell])</span>
+<span id="cb106-175"><a href="#cb106-175" aria-hidden="true" tabindex="-1"></a>        aktuell <span class="op">=</span> nachfolger[aktuell]</span>
+<span id="cb106-176"><a href="#cb106-176" aria-hidden="true" tabindex="-1"></a>    <span class="cf">return</span> reihe[:a] <span class="op">+</span> neue_folge <span class="op">+</span> reihe[b:]</span>
+<span id="cb106-177"><a href="#cb106-177" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb106-178"><a href="#cb106-178" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb106-179"><a href="#cb106-179" aria-hidden="true" tabindex="-1"></a><span class="kw">def</span> lns(reihe: <span class="bu">list</span>[<span class="bu">int</span>], matrix: np.ndarray, runden: <span class="bu">int</span> <span class="op">=</span> RUNDEN,</span>
+<span id="cb106-180"><a href="#cb106-180" aria-hidden="true" tabindex="-1"></a>        fenster: <span class="bu">int</span> <span class="op">=</span> FENSTER, saat: <span class="bu">int</span> <span class="op">=</span> <span class="dv">3</span>):</span>
+<span id="cb106-181"><a href="#cb106-181" aria-hidden="true" tabindex="-1"></a>    <span class="co">&quot;&quot;&quot;Zerstoeren, exakt reparieren, uebernehmen - so lange das Budget reicht.&quot;&quot;&quot;</span></span>
+<span id="cb106-182"><a href="#cb106-182" aria-hidden="true" tabindex="-1"></a>    rng <span class="op">=</span> np.random.default_rng(saat)</span>
+<span id="cb106-183"><a href="#cb106-183" aria-hidden="true" tabindex="-1"></a>    kosten <span class="op">=</span> gesamtruestzeit(reihe, matrix)</span>
+<span id="cb106-184"><a href="#cb106-184" aria-hidden="true" tabindex="-1"></a>    verbesserungen <span class="op">=</span> <span class="dv">0</span></span>
+<span id="cb106-185"><a href="#cb106-185" aria-hidden="true" tabindex="-1"></a>    start <span class="op">=</span> time.perf_counter()</span>
+<span id="cb106-186"><a href="#cb106-186" aria-hidden="true" tabindex="-1"></a>    <span class="cf">for</span> _ <span class="kw">in</span> <span class="bu">range</span>(runden):</span>
+<span id="cb106-187"><a href="#cb106-187" aria-hidden="true" tabindex="-1"></a>        a <span class="op">=</span> <span class="bu">int</span>(rng.integers(<span class="dv">0</span>, <span class="bu">len</span>(reihe) <span class="op">-</span> fenster))</span>
+<span id="cb106-188"><a href="#cb106-188" aria-hidden="true" tabindex="-1"></a>        neu <span class="op">=</span> repariere_fenster(reihe, matrix, a, a <span class="op">+</span> fenster)</span>
+<span id="cb106-189"><a href="#cb106-189" aria-hidden="true" tabindex="-1"></a>        <span class="cf">if</span> neu <span class="kw">is</span> <span class="va">None</span>:</span>
+<span id="cb106-190"><a href="#cb106-190" aria-hidden="true" tabindex="-1"></a>            <span class="cf">continue</span></span>
+<span id="cb106-191"><a href="#cb106-191" aria-hidden="true" tabindex="-1"></a>        neue_kosten <span class="op">=</span> gesamtruestzeit(neu, matrix)</span>
+<span id="cb106-192"><a href="#cb106-192" aria-hidden="true" tabindex="-1"></a>        <span class="cf">if</span> neue_kosten <span class="op">&lt;</span> kosten:</span>
+<span id="cb106-193"><a href="#cb106-193" aria-hidden="true" tabindex="-1"></a>            reihe, kosten <span class="op">=</span> neu, neue_kosten</span>
+<span id="cb106-194"><a href="#cb106-194" aria-hidden="true" tabindex="-1"></a>            verbesserungen <span class="op">+=</span> <span class="dv">1</span></span>
+<span id="cb106-195"><a href="#cb106-195" aria-hidden="true" tabindex="-1"></a>    <span class="cf">return</span> reihe, kosten, verbesserungen, time.perf_counter() <span class="op">-</span> start</span>
+<span id="cb106-196"><a href="#cb106-196" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb106-197"><a href="#cb106-197" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb106-198"><a href="#cb106-198" aria-hidden="true" tabindex="-1"></a><span class="cf">if</span> <span class="va">__name__</span> <span class="op">==</span> <span class="st">&quot;__main__&quot;</span>:</span>
+<span id="cb106-199"><a href="#cb106-199" aria-hidden="true" tabindex="-1"></a>    matrix <span class="op">=</span> erzeuge_ruestmatrix(N)</span>
+<span id="cb106-200"><a href="#cb106-200" aria-hidden="true" tabindex="-1"></a>    start_reihe <span class="op">=</span> faustregel(matrix)</span>
+<span id="cb106-201"><a href="#cb106-201" aria-hidden="true" tabindex="-1"></a>    start_kosten <span class="op">=</span> gesamtruestzeit(start_reihe, matrix)</span>
+<span id="cb106-202"><a href="#cb106-202" aria-hidden="true" tabindex="-1"></a>    SCHRANKE <span class="op">=</span> <span class="dv">1768</span>        <span class="co"># aus dem CP-SAT-Lauf in Metaheuristik_vs_Exakt.py</span></span>
+<span id="cb106-203"><a href="#cb106-203" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb106-204"><a href="#cb106-204" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;=&quot;</span> <span class="op">*</span> <span class="dv">84</span>)</span>
+<span id="cb106-205"><a href="#cb106-205" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;  ZERSTOEREN UND EXAKT REPARIEREN&quot;</span>)</span>
+<span id="cb106-206"><a href="#cb106-206" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;=&quot;</span> <span class="op">*</span> <span class="dv">84</span>)</span>
+<span id="cb106-207"><a href="#cb106-207" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;</span><span class="sc">{</span>N<span class="sc">}</span><span class="ss"> Auftraege. Je Runde werden </span><span class="sc">{</span>FENSTER<span class="sc">}</span><span class="ss"> aufeinanderfolgende Auftraege&quot;</span>)</span>
+<span id="cb106-208"><a href="#cb106-208" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;herausgebrochen und exakt neu geordnet, </span><span class="sc">{</span>RUNDEN<span class="sc">}</span><span class="ss"> Runden lang.</span><span class="ch">\n</span><span class="ss">&quot;</span>)</span>
+<span id="cb106-209"><a href="#cb106-209" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb106-210"><a href="#cb106-210" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;Erst die Metaheuristik allein, dann LNS auf ihrem Ergebnis:</span><span class="ch">\n</span><span class="st">&quot;</span>)</span>
+<span id="cb106-211"><a href="#cb106-211" aria-hidden="true" tabindex="-1"></a>    sa_reihe <span class="op">=</span> annealing(matrix)</span>
+<span id="cb106-212"><a href="#cb106-212" aria-hidden="true" tabindex="-1"></a>    sa_kosten <span class="op">=</span> gesamtruestzeit(sa_reihe, matrix)</span>
+<span id="cb106-213"><a href="#cb106-213" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb106-214"><a href="#cb106-214" aria-hidden="true" tabindex="-1"></a>    lns_ab_faustregel <span class="op">=</span> lns(start_reihe[:], matrix)</span>
+<span id="cb106-215"><a href="#cb106-215" aria-hidden="true" tabindex="-1"></a>    lns_ab_annealing <span class="op">=</span> lns(sa_reihe[:], matrix)</span>
+<span id="cb106-216"><a href="#cb106-216" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb106-217"><a href="#cb106-217" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;  </span><span class="sc">{</span><span class="st">&#39;Verfahren&#39;</span><span class="sc">:&lt;34}</span><span class="ss"> </span><span class="sc">{</span><span class="st">&#39;Ruestzeit&#39;</span><span class="sc">:&gt;10}</span><span class="ss"> </span><span class="sc">{</span><span class="st">&#39;ueber Schranke&#39;</span><span class="sc">:&gt;15}</span><span class="ss">&quot;</span>)</span>
+<span id="cb106-218"><a href="#cb106-218" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;  &quot;</span> <span class="op">+</span> <span class="st">&quot;-&quot;</span> <span class="op">*</span> <span class="dv">62</span>)</span>
+<span id="cb106-219"><a href="#cb106-219" aria-hidden="true" tabindex="-1"></a>    <span class="cf">for</span> name, wert <span class="kw">in</span> [</span>
+<span id="cb106-220"><a href="#cb106-220" aria-hidden="true" tabindex="-1"></a>            (<span class="st">&quot;Faustregel (ohne Solver)&quot;</span>, start_kosten),</span>
+<span id="cb106-221"><a href="#cb106-221" aria-hidden="true" tabindex="-1"></a>            (<span class="st">&quot;CP-SAT allein, 30 s&quot;</span>, <span class="dv">2628</span>),</span>
+<span id="cb106-222"><a href="#cb106-222" aria-hidden="true" tabindex="-1"></a>            (<span class="st">&quot;Simulated Annealing&quot;</span>, sa_kosten),</span>
+<span id="cb106-223"><a href="#cb106-223" aria-hidden="true" tabindex="-1"></a>            (<span class="st">&quot;LNS ab Faustregel&quot;</span>, lns_ab_faustregel[<span class="dv">1</span>]),</span>
+<span id="cb106-224"><a href="#cb106-224" aria-hidden="true" tabindex="-1"></a>            (<span class="st">&quot;Annealing, dann LNS&quot;</span>, lns_ab_annealing[<span class="dv">1</span>])]:</span>
+<span id="cb106-225"><a href="#cb106-225" aria-hidden="true" tabindex="-1"></a>        <span class="bu">print</span>(<span class="ss">f&quot;  </span><span class="sc">{</span>name<span class="sc">:&lt;34}</span><span class="ss"> </span><span class="sc">{</span>wert<span class="sc">:&gt;10,}</span><span class="ss"> </span><span class="sc">{</span>(wert <span class="op">-</span> SCHRANKE) <span class="op">/</span> SCHRANKE <span class="op">*</span> <span class="dv">100</span><span class="sc">:&gt;13.1f}</span><span class="ss"> %&quot;</span>)</span>
+<span id="cb106-226"><a href="#cb106-226" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;  </span><span class="sc">{</span><span class="st">&#39;untere Schranke (CP-SAT)&#39;</span><span class="sc">:&lt;34}</span><span class="ss"> </span><span class="sc">{</span>SCHRANKE<span class="sc">:&gt;10,}</span><span class="ss"> </span><span class="sc">{</span><span class="fl">0.0</span><span class="sc">:&gt;13.1f}</span><span class="ss"> %&quot;</span>)</span>
+<span id="cb106-227"><a href="#cb106-227" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb106-228"><a href="#cb106-228" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;</span><span class="ch">\n</span><span class="ss">  LNS ab Faustregel: </span><span class="sc">{</span>lns_ab_faustregel[<span class="dv">2</span>]<span class="sc">}</span><span class="ss"> von </span><span class="sc">{</span>RUNDEN<span class="sc">}</span><span class="ss"> Runden brachten &quot;</span></span>
+<span id="cb106-229"><a href="#cb106-229" aria-hidden="true" tabindex="-1"></a>          <span class="ss">f&quot;eine Verbesserung (</span><span class="sc">{</span>lns_ab_faustregel[<span class="dv">3</span>]<span class="sc">:.0f}</span><span class="ss"> s).&quot;</span>)</span>
+<span id="cb106-230"><a href="#cb106-230" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;  LNS ab Annealing:  </span><span class="sc">{</span>lns_ab_annealing[<span class="dv">2</span>]<span class="sc">}</span><span class="ss"> von </span><span class="sc">{</span>RUNDEN<span class="sc">}</span><span class="ss"> Runden &quot;</span></span>
+<span id="cb106-231"><a href="#cb106-231" aria-hidden="true" tabindex="-1"></a>          <span class="ss">f&quot;(</span><span class="sc">{</span>lns_ab_annealing[<span class="dv">3</span>]<span class="sc">:.0f}</span><span class="ss"> s).&quot;</span>)</span>
+<span id="cb106-232"><a href="#cb106-232" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb106-233"><a href="#cb106-233" aria-hidden="true" tabindex="-1"></a>    <span class="co"># --- Die Fenstergroesse ----------------------------------------------</span></span>
+<span id="cb106-234"><a href="#cb106-234" aria-hidden="true" tabindex="-1"></a>    <span class="co"># Verglichen wird bei ANNAEHERND GLEICHER ZEIT, nicht bei gleicher</span></span>
+<span id="cb106-235"><a href="#cb106-235" aria-hidden="true" tabindex="-1"></a>    <span class="co"># Rundenzahl: Eine Runde mit Fenster 30 kostet ein Vielfaches einer Runde</span></span>
+<span id="cb106-236"><a href="#cb106-236" aria-hidden="true" tabindex="-1"></a>    <span class="co"># mit Fenster 10. Wer nach Runden vergleicht, misst nur, dass groessere</span></span>
+<span id="cb106-237"><a href="#cb106-237" aria-hidden="true" tabindex="-1"></a>    <span class="co"># Teilprobleme mehr finden - und uebersieht, was sie kosten. Die</span></span>
+<span id="cb106-238"><a href="#cb106-238" aria-hidden="true" tabindex="-1"></a>    <span class="co"># Rundenzahlen unten sind so gewaehlt, dass alle drei Laeufe in derselben</span></span>
+<span id="cb106-239"><a href="#cb106-239" aria-hidden="true" tabindex="-1"></a>    <span class="co"># Groessenordnung liegen.</span></span>
+<span id="cb106-240"><a href="#cb106-240" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;</span><span class="ch">\n</span><span class="st">&quot;</span> <span class="op">+</span> <span class="st">&quot;-&quot;</span> <span class="op">*</span> <span class="dv">84</span>)</span>
+<span id="cb106-241"><a href="#cb106-241" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;Die Fenstergroesse ist die eine Stellschraube - und sie hat ein&quot;</span>)</span>
+<span id="cb106-242"><a href="#cb106-242" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;Optimum in der Mitte. Gleiche Zeit, verschiedene Fenster:</span><span class="ch">\n</span><span class="st">&quot;</span>)</span>
+<span id="cb106-243"><a href="#cb106-243" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;  </span><span class="sc">{</span><span class="st">&#39;Fenster&#39;</span><span class="sc">:&gt;8}</span><span class="ss"> </span><span class="sc">{</span><span class="st">&#39;Runden&#39;</span><span class="sc">:&gt;8}</span><span class="ss"> </span><span class="sc">{</span><span class="st">&#39;Ruestzeit&#39;</span><span class="sc">:&gt;11}</span><span class="ss"> </span><span class="sc">{</span><span class="st">&#39;Verbesser-&#39;</span><span class="sc">:&gt;12}</span><span class="ss"> </span><span class="sc">{</span><span class="st">&#39;Zeit&#39;</span><span class="sc">:&gt;8}</span><span class="ss">&quot;</span>)</span>
+<span id="cb106-244"><a href="#cb106-244" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;  </span><span class="sc">{</span><span class="st">&#39;&#39;</span><span class="sc">:&gt;8}</span><span class="ss"> </span><span class="sc">{</span><span class="st">&#39;&#39;</span><span class="sc">:&gt;8}</span><span class="ss"> </span><span class="sc">{</span><span class="st">&#39;&#39;</span><span class="sc">:&gt;11}</span><span class="ss"> </span><span class="sc">{</span><span class="st">&#39;ungen&#39;</span><span class="sc">:&gt;12}</span><span class="ss"> </span><span class="sc">{</span><span class="st">&#39;&#39;</span><span class="sc">:&gt;8}</span><span class="ss">&quot;</span>)</span>
+<span id="cb106-245"><a href="#cb106-245" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;  &quot;</span> <span class="op">+</span> <span class="st">&quot;-&quot;</span> <span class="op">*</span> <span class="dv">52</span>)</span>
+<span id="cb106-246"><a href="#cb106-246" aria-hidden="true" tabindex="-1"></a>    fenster_ergebnis <span class="op">=</span> {}</span>
+<span id="cb106-247"><a href="#cb106-247" aria-hidden="true" tabindex="-1"></a>    <span class="cf">for</span> fenster, runden <span class="kw">in</span> ((<span class="dv">10</span>, <span class="dv">4000</span>), (<span class="dv">20</span>, <span class="dv">150</span>), (<span class="dv">30</span>, <span class="dv">20</span>)):</span>
+<span id="cb106-248"><a href="#cb106-248" aria-hidden="true" tabindex="-1"></a>        _, wert, verbesserungen, dauer <span class="op">=</span> lns(sa_reihe[:], matrix,</span>
+<span id="cb106-249"><a href="#cb106-249" aria-hidden="true" tabindex="-1"></a>                                             runden<span class="op">=</span>runden, fenster<span class="op">=</span>fenster)</span>
+<span id="cb106-250"><a href="#cb106-250" aria-hidden="true" tabindex="-1"></a>        fenster_ergebnis[fenster] <span class="op">=</span> wert</span>
+<span id="cb106-251"><a href="#cb106-251" aria-hidden="true" tabindex="-1"></a>        <span class="bu">print</span>(<span class="ss">f&quot;  </span><span class="sc">{</span>fenster<span class="sc">:&gt;8}</span><span class="ss"> </span><span class="sc">{</span>runden<span class="sc">:&gt;8,}</span><span class="ss"> </span><span class="sc">{</span>wert<span class="sc">:&gt;11,}</span><span class="ss"> </span><span class="sc">{</span>verbesserungen<span class="sc">:&gt;12}</span><span class="ss"> &quot;</span></span>
+<span id="cb106-252"><a href="#cb106-252" aria-hidden="true" tabindex="-1"></a>              <span class="ss">f&quot;</span><span class="sc">{</span>dauer<span class="sc">:&gt;7.0f}</span><span class="ss">s&quot;</span>)</span>
+<span id="cb106-253"><a href="#cb106-253" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb106-254"><a href="#cb106-254" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;</span><span class="ch">\n</span><span class="st">  Nach unten ist die Grenze nicht die Zeit, sondern die SAETTIGUNG:&quot;</span>)</span>
+<span id="cb106-255"><a href="#cb106-255" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;  Mit Fenster 10 bleiben von </span><span class="sc">{</span><span class="dv">4000</span><span class="sc">:,}</span><span class="ss"> Runden nur eine Handvoll&quot;</span>)</span>
+<span id="cb106-256"><a href="#cb106-256" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;  Verbesserungen uebrig. Zwanzig Auftraege lassen sich in einem Zug&quot;</span>)</span>
+<span id="cb106-257"><a href="#cb106-257" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;  umbauen, zehn nicht - und was ein Fenster nicht umbauen kann, findet&quot;</span>)</span>
+<span id="cb106-258"><a href="#cb106-258" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;  es auch in beliebig vielen Runden nicht.&quot;</span>)</span>
+<span id="cb106-259"><a href="#cb106-259" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;</span><span class="ch">\n</span><span class="st">  Nach oben ist die Grenze die Rechenzeit: Fenster 30 findet pro Runde&quot;</span>)</span>
+<span id="cb106-260"><a href="#cb106-260" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;  mehr, kommt in derselben Zeit aber nur auf einen Bruchteil der Runden&quot;</span>)</span>
+<span id="cb106-261"><a href="#cb106-261" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;  und landet bei </span><span class="sc">{</span>fenster_ergebnis[<span class="dv">30</span>]<span class="sc">:,}</span><span class="ss"> statt </span><span class="sc">{</span>fenster_ergebnis[<span class="dv">20</span>]<span class="sc">:,}</span><span class="ss">. Eine Reparatur mit 30 Auftraegen&quot;</span>)</span>
+<span id="cb106-262"><a href="#cb106-262" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;  ist eben genau das Problem, an dem der exakte Solver im Grossen&quot;</span>)</span>
+<span id="cb106-263"><a href="#cb106-263" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;  scheitert - nur eine Nummer kleiner.&quot;</span>)</span>
+<span id="cb106-264"><a href="#cb106-264" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;</span><span class="ch">\n</span><span class="st">  Diese Tabelle gehoert an den Anfang jedes LNS-Projekts. Sie zu raten&quot;</span>)</span>
+<span id="cb106-265"><a href="#cb106-265" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;  statt zu messen ist der haeufigste Fehler beim Einsatz des Verfahrens.&quot;</span>)</span>
+<span id="cb106-266"><a href="#cb106-266" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb106-267"><a href="#cb106-267" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;</span><span class="ch">\n</span><span class="st">&quot;</span> <span class="op">+</span> <span class="st">&quot;=&quot;</span> <span class="op">*</span> <span class="dv">84</span>)</span>
+<span id="cb106-268"><a href="#cb106-268" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;  WAS DAS HEISST&quot;</span>)</span>
+<span id="cb106-269"><a href="#cb106-269" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;=&quot;</span> <span class="op">*</span> <span class="dv">84</span>)</span>
+<span id="cb106-270"><a href="#cb106-270" aria-hidden="true" tabindex="-1"></a>    bester <span class="op">=</span> lns_ab_annealing[<span class="dv">1</span>]</span>
+<span id="cb106-271"><a href="#cb106-271" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;Der beste Plan kommt aus der Kombination: </span><span class="sc">{</span>bester<span class="sc">:,}</span><span class="ss"> Minuten,&quot;</span>)</span>
+<span id="cb106-272"><a href="#cb106-272" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;</span><span class="sc">{</span>(start_kosten <span class="op">-</span> bester) <span class="op">/</span> start_kosten <span class="op">*</span> <span class="dv">100</span><span class="sc">:.1f}</span><span class="ss"> % unter der Faustregel und &quot;</span></span>
+<span id="cb106-273"><a href="#cb106-273" aria-hidden="true" tabindex="-1"></a>          <span class="ss">f&quot;</span><span class="sc">{</span>(sa_kosten <span class="op">-</span> bester) <span class="op">/</span> sa_kosten <span class="op">*</span> <span class="dv">100</span><span class="sc">:.1f}</span><span class="ss"> % unter dem reinen Annealing.&quot;</span>)</span>
+<span id="cb106-274"><a href="#cb106-274" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>()</span>
+<span id="cb106-275"><a href="#cb106-275" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;Weder der exakte Solver noch die Metaheuristik allein kommen dorthin.&quot;</span>)</span>
+<span id="cb106-276"><a href="#cb106-276" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;Der Solver scheitert an der Groesse, die Metaheuristik an der Kleinheit&quot;</span>)</span>
+<span id="cb106-277"><a href="#cb106-277" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;ihrer Zuege. LNS gibt dem Solver Teilprobleme in einer Groesse, die er&quot;</span>)</span>
+<span id="cb106-278"><a href="#cb106-278" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;beherrscht, und der Metaheuristik die Umbauten, die sie nicht kann.&quot;</span>)</span>
+<span id="cb106-279"><a href="#cb106-279" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>()</span>
+<span id="cb106-280"><a href="#cb106-280" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;Und die Ehrlichkeit zum Schluss: Auch </span><span class="sc">{</span>bester<span class="sc">:,}</span><span class="ss"> liegt noch &quot;</span></span>
+<span id="cb106-281"><a href="#cb106-281" aria-hidden="true" tabindex="-1"></a>          <span class="ss">f&quot;</span><span class="sc">{</span>(bester <span class="op">-</span> SCHRANKE) <span class="op">/</span> SCHRANKE <span class="op">*</span> <span class="dv">100</span><span class="sc">:.0f}</span><span class="ss"> % ueber der&quot;</span>)</span>
+<span id="cb106-282"><a href="#cb106-282" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;Schranke. Ob dort wirklich noch so viel Luft ist oder ob die Schranke&quot;</span>)</span>
+<span id="cb106-283"><a href="#cb106-283" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;nur schwach ist, weiss man nicht - das ist die Lage, in der man mit&quot;</span>)</span>
+<span id="cb106-284"><a href="#cb106-284" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;einer Metaheuristik arbeitet. Man kennt seine Loesung, nicht ihren&quot;</span>)</span>
+<span id="cb106-285"><a href="#cb106-285" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;Abstand zum Optimum.&quot;</span>)</span>
+<span id="cb106-286"><a href="#cb106-286" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;=&quot;</span> <span class="op">*</span> <span class="dv">84</span>)</span></code></pre></div>
 <p><strong>Erwartete Ausgabe</strong> (Laufzeiten hardwareabhängig, die Werte nicht):</p>
 <pre><code>====================================================================================
   ZERSTOEREN UND EXAKT REPARIEREN
@@ -14504,28 +15249,28 @@ Abstand zum Optimum.
 <p><strong>🚀 In 5 Minuten gelöst: Denken Sie in Mustern, nicht in Stücken</strong></p>
 <p>Eine Rolle ist 1 000 mm breit. Bestellt sind 9 Stück à 420 mm, 12 à 310 mm und 14 à 250 mm. Wie viele Rollen braucht man?</p>
 <p>Die naheliegende Frage — <em>„welches Stück kommt auf welche Rolle?“</em> — führt zu 35 Einzelentscheidungen. Die bessere Frage lautet: <em>„Wie oft schneide ich welches Muster?“</em></p>
-<div class="sourceCode" id="cb106"><pre class="sourceCode python"><code class="sourceCode python"><span id="cb106-1"><a href="#cb106-1" aria-hidden="true" tabindex="-1"></a><span class="im">import</span> itertools</span>
-<span id="cb106-2"><a href="#cb106-2" aria-hidden="true" tabindex="-1"></a><span class="im">import</span> numpy <span class="im">as</span> np</span>
-<span id="cb106-3"><a href="#cb106-3" aria-hidden="true" tabindex="-1"></a><span class="im">from</span> scipy.optimize <span class="im">import</span> linprog</span>
-<span id="cb106-4"><a href="#cb106-4" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb106-5"><a href="#cb106-5" aria-hidden="true" tabindex="-1"></a>ROLLE <span class="op">=</span> <span class="dv">1000</span>                                  <span class="co"># mm Mutterrolle</span></span>
-<span id="cb106-6"><a href="#cb106-6" aria-hidden="true" tabindex="-1"></a>breiten, bedarf <span class="op">=</span> [<span class="dv">420</span>, <span class="dv">310</span>, <span class="dv">250</span>], [<span class="dv">9</span>, <span class="dv">12</span>, <span class="dv">14</span>]</span>
-<span id="cb106-7"><a href="#cb106-7" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb106-8"><a href="#cb106-8" aria-hidden="true" tabindex="-1"></a><span class="co"># Alle Schnittmuster aufzaehlen, die in die Rolle passen</span></span>
-<span id="cb106-9"><a href="#cb106-9" aria-hidden="true" tabindex="-1"></a>muster <span class="op">=</span> [m <span class="cf">for</span> m <span class="kw">in</span> itertools.product(<span class="op">*</span>[<span class="bu">range</span>(ROLLE <span class="op">//</span> b <span class="op">+</span> <span class="dv">1</span>) <span class="cf">for</span> b <span class="kw">in</span> breiten])</span>
-<span id="cb106-10"><a href="#cb106-10" aria-hidden="true" tabindex="-1"></a>          <span class="cf">if</span> <span class="bu">sum</span>(a <span class="op">*</span> b <span class="cf">for</span> a, b <span class="kw">in</span> <span class="bu">zip</span>(m, breiten)) <span class="op">&lt;=</span> ROLLE <span class="kw">and</span> <span class="bu">sum</span>(m) <span class="op">&gt;</span> <span class="dv">0</span>]</span>
-<span id="cb106-11"><a href="#cb106-11" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb106-12"><a href="#cb106-12" aria-hidden="true" tabindex="-1"></a><span class="co"># Wie oft schneide ich welches Muster?  min sum(x)  u.d.N.  A x &gt;= bedarf</span></span>
-<span id="cb106-13"><a href="#cb106-13" aria-hidden="true" tabindex="-1"></a>loesung <span class="op">=</span> linprog(np.ones(<span class="bu">len</span>(muster)), A_ub<span class="op">=-</span>np.array(muster, <span class="bu">float</span>).T,</span>
-<span id="cb106-14"><a href="#cb106-14" aria-hidden="true" tabindex="-1"></a>                  b_ub<span class="op">=-</span>np.array(bedarf, <span class="bu">float</span>), bounds<span class="op">=</span>(<span class="dv">0</span>, <span class="va">None</span>),</span>
-<span id="cb106-15"><a href="#cb106-15" aria-hidden="true" tabindex="-1"></a>                  integrality<span class="op">=</span><span class="dv">1</span>, method<span class="op">=</span><span class="st">&quot;highs&quot;</span>)</span>
-<span id="cb106-16"><a href="#cb106-16" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb106-17"><a href="#cb106-17" aria-hidden="true" tabindex="-1"></a><span class="bu">print</span>(<span class="ss">f&quot;</span><span class="sc">{</span><span class="bu">len</span>(muster)<span class="sc">}</span><span class="ss"> zulaessige Muster, </span><span class="sc">{</span><span class="bu">int</span>(<span class="bu">round</span>(loesung.fun))<span class="sc">}</span><span class="ss"> Rollen noetig:&quot;</span>)</span>
-<span id="cb106-18"><a href="#cb106-18" aria-hidden="true" tabindex="-1"></a><span class="cf">for</span> anzahl, m <span class="kw">in</span> <span class="bu">zip</span>(np.<span class="bu">round</span>(loesung.x).astype(<span class="bu">int</span>), muster):</span>
-<span id="cb106-19"><a href="#cb106-19" aria-hidden="true" tabindex="-1"></a>    <span class="cf">if</span> anzahl:</span>
-<span id="cb106-20"><a href="#cb106-20" aria-hidden="true" tabindex="-1"></a>        rest <span class="op">=</span> ROLLE <span class="op">-</span> <span class="bu">sum</span>(a <span class="op">*</span> b <span class="cf">for</span> a, b <span class="kw">in</span> <span class="bu">zip</span>(m, breiten))</span>
-<span id="cb106-21"><a href="#cb106-21" aria-hidden="true" tabindex="-1"></a>        <span class="bu">print</span>(<span class="ss">f&quot;  </span><span class="sc">{</span>anzahl<span class="sc">:2d}</span><span class="ss"> x  &quot;</span> <span class="op">+</span> <span class="st">&quot;  &quot;</span>.join(<span class="ss">f&quot;</span><span class="sc">{</span>a<span class="sc">}</span><span class="ss">x</span><span class="sc">{</span>b<span class="sc">}</span><span class="ss">mm&quot;</span> <span class="cf">for</span> a, b <span class="kw">in</span> <span class="bu">zip</span>(m, breiten))</span>
-<span id="cb106-22"><a href="#cb106-22" aria-hidden="true" tabindex="-1"></a>              <span class="op">+</span> <span class="ss">f&quot;   Verschnitt </span><span class="sc">{</span>rest<span class="sc">}</span><span class="ss"> mm&quot;</span>)</span></code></pre></div>
+<div class="sourceCode" id="cb108"><pre class="sourceCode python"><code class="sourceCode python"><span id="cb108-1"><a href="#cb108-1" aria-hidden="true" tabindex="-1"></a><span class="im">import</span> itertools</span>
+<span id="cb108-2"><a href="#cb108-2" aria-hidden="true" tabindex="-1"></a><span class="im">import</span> numpy <span class="im">as</span> np</span>
+<span id="cb108-3"><a href="#cb108-3" aria-hidden="true" tabindex="-1"></a><span class="im">from</span> scipy.optimize <span class="im">import</span> linprog</span>
+<span id="cb108-4"><a href="#cb108-4" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb108-5"><a href="#cb108-5" aria-hidden="true" tabindex="-1"></a>ROLLE <span class="op">=</span> <span class="dv">1000</span>                                  <span class="co"># mm Mutterrolle</span></span>
+<span id="cb108-6"><a href="#cb108-6" aria-hidden="true" tabindex="-1"></a>breiten, bedarf <span class="op">=</span> [<span class="dv">420</span>, <span class="dv">310</span>, <span class="dv">250</span>], [<span class="dv">9</span>, <span class="dv">12</span>, <span class="dv">14</span>]</span>
+<span id="cb108-7"><a href="#cb108-7" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb108-8"><a href="#cb108-8" aria-hidden="true" tabindex="-1"></a><span class="co"># Alle Schnittmuster aufzaehlen, die in die Rolle passen</span></span>
+<span id="cb108-9"><a href="#cb108-9" aria-hidden="true" tabindex="-1"></a>muster <span class="op">=</span> [m <span class="cf">for</span> m <span class="kw">in</span> itertools.product(<span class="op">*</span>[<span class="bu">range</span>(ROLLE <span class="op">//</span> b <span class="op">+</span> <span class="dv">1</span>) <span class="cf">for</span> b <span class="kw">in</span> breiten])</span>
+<span id="cb108-10"><a href="#cb108-10" aria-hidden="true" tabindex="-1"></a>          <span class="cf">if</span> <span class="bu">sum</span>(a <span class="op">*</span> b <span class="cf">for</span> a, b <span class="kw">in</span> <span class="bu">zip</span>(m, breiten)) <span class="op">&lt;=</span> ROLLE <span class="kw">and</span> <span class="bu">sum</span>(m) <span class="op">&gt;</span> <span class="dv">0</span>]</span>
+<span id="cb108-11"><a href="#cb108-11" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb108-12"><a href="#cb108-12" aria-hidden="true" tabindex="-1"></a><span class="co"># Wie oft schneide ich welches Muster?  min sum(x)  u.d.N.  A x &gt;= bedarf</span></span>
+<span id="cb108-13"><a href="#cb108-13" aria-hidden="true" tabindex="-1"></a>loesung <span class="op">=</span> linprog(np.ones(<span class="bu">len</span>(muster)), A_ub<span class="op">=-</span>np.array(muster, <span class="bu">float</span>).T,</span>
+<span id="cb108-14"><a href="#cb108-14" aria-hidden="true" tabindex="-1"></a>                  b_ub<span class="op">=-</span>np.array(bedarf, <span class="bu">float</span>), bounds<span class="op">=</span>(<span class="dv">0</span>, <span class="va">None</span>),</span>
+<span id="cb108-15"><a href="#cb108-15" aria-hidden="true" tabindex="-1"></a>                  integrality<span class="op">=</span><span class="dv">1</span>, method<span class="op">=</span><span class="st">&quot;highs&quot;</span>)</span>
+<span id="cb108-16"><a href="#cb108-16" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb108-17"><a href="#cb108-17" aria-hidden="true" tabindex="-1"></a><span class="bu">print</span>(<span class="ss">f&quot;</span><span class="sc">{</span><span class="bu">len</span>(muster)<span class="sc">}</span><span class="ss"> zulaessige Muster, </span><span class="sc">{</span><span class="bu">int</span>(<span class="bu">round</span>(loesung.fun))<span class="sc">}</span><span class="ss"> Rollen noetig:&quot;</span>)</span>
+<span id="cb108-18"><a href="#cb108-18" aria-hidden="true" tabindex="-1"></a><span class="cf">for</span> anzahl, m <span class="kw">in</span> <span class="bu">zip</span>(np.<span class="bu">round</span>(loesung.x).astype(<span class="bu">int</span>), muster):</span>
+<span id="cb108-19"><a href="#cb108-19" aria-hidden="true" tabindex="-1"></a>    <span class="cf">if</span> anzahl:</span>
+<span id="cb108-20"><a href="#cb108-20" aria-hidden="true" tabindex="-1"></a>        rest <span class="op">=</span> ROLLE <span class="op">-</span> <span class="bu">sum</span>(a <span class="op">*</span> b <span class="cf">for</span> a, b <span class="kw">in</span> <span class="bu">zip</span>(m, breiten))</span>
+<span id="cb108-21"><a href="#cb108-21" aria-hidden="true" tabindex="-1"></a>        <span class="bu">print</span>(<span class="ss">f&quot;  </span><span class="sc">{</span>anzahl<span class="sc">:2d}</span><span class="ss"> x  &quot;</span> <span class="op">+</span> <span class="st">&quot;  &quot;</span>.join(<span class="ss">f&quot;</span><span class="sc">{</span>a<span class="sc">}</span><span class="ss">x</span><span class="sc">{</span>b<span class="sc">}</span><span class="ss">mm&quot;</span> <span class="cf">for</span> a, b <span class="kw">in</span> <span class="bu">zip</span>(m, breiten))</span>
+<span id="cb108-22"><a href="#cb108-22" aria-hidden="true" tabindex="-1"></a>              <span class="op">+</span> <span class="ss">f&quot;   Verschnitt </span><span class="sc">{</span>rest<span class="sc">}</span><span class="ss"> mm&quot;</span>)</span></code></pre></div>
 <p><strong>Ausgabe:</strong></p>
 <pre><code>16 zulaessige Muster, 12 Rollen noetig:
    2 x  0x420mm  0x310mm  4x250mm   Verschnitt 0 mm
@@ -14678,298 +15423,298 @@ Abstand zum Optimum.
 <p>Das Teilproblem ist also ein Verfahren, das die Leser dieses Buchs schon kennen. <strong>Neu ist allein die Schleife.</strong></p>
 <hr />
 <h2 id="sec:dekomposition-programm">10.5 Das Programm</h2>
-<div class="sourceCode" id="cb108"><pre class="sourceCode python"><code class="sourceCode python"><span id="cb108-1"><a href="#cb108-1" aria-hidden="true" tabindex="-1"></a><span class="co">#!/usr/bin/env python3</span></span>
-<span id="cb108-2"><a href="#cb108-2" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb108-3"><a href="#cb108-3" aria-hidden="true" tabindex="-1"></a><span class="co"># Spaltengenerierung.py</span></span>
-<span id="cb108-4"><a href="#cb108-4" aria-hidden="true" tabindex="-1"></a><span class="co">&quot;&quot;&quot;</span></span>
-<span id="cb108-5"><a href="#cb108-5" aria-hidden="true" tabindex="-1"></a><span class="co">Kapitel Dekomposition: Das Modell umbauen, statt die Loesung zu raten.</span></span>
-<span id="cb108-6"><a href="#cb108-6" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb108-7"><a href="#cb108-7" aria-hidden="true" tabindex="-1"></a><span class="co">Eine Papierfabrik liefert Rollen von 5.600 mm Breite. Die Kunden bestellen</span></span>
-<span id="cb108-8"><a href="#cb108-8" aria-hidden="true" tabindex="-1"></a><span class="co">schmalere Breiten, und aus jeder Mutterrolle werden mehrere davon geschnitten.</span></span>
-<span id="cb108-9"><a href="#cb108-9" aria-hidden="true" tabindex="-1"></a><span class="co">Gesucht ist der Schnittplan, der mit den wenigsten Mutterrollen auskommt.</span></span>
-<span id="cb108-10"><a href="#cb108-10" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb108-11"><a href="#cb108-11" aria-hidden="true" tabindex="-1"></a><span class="co">Der naheliegende Modellansatz - &quot;welches Stueck kommt auf welche Rolle?&quot; -</span></span>
-<span id="cb108-12"><a href="#cb108-12" aria-hidden="true" tabindex="-1"></a><span class="co">fuehrt in eine Sackgasse: Er braucht eine Binaervariable je Stueck-und-Rolle,</span></span>
-<span id="cb108-13"><a href="#cb108-13" aria-hidden="true" tabindex="-1"></a><span class="co">und weil alle Rollen gleich sind, ist er hochgradig symmetrisch. Der Solver</span></span>
-<span id="cb108-14"><a href="#cb108-14" aria-hidden="true" tabindex="-1"></a><span class="co">probiert dieselbe Loesung in tausend Umbenennungen durch.</span></span>
-<span id="cb108-15"><a href="#cb108-15" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb108-16"><a href="#cb108-16" aria-hidden="true" tabindex="-1"></a><span class="co">Die Spaltengenerierung dreht die Frage um:</span></span>
-<span id="cb108-17"><a href="#cb108-17" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb108-18"><a href="#cb108-18" aria-hidden="true" tabindex="-1"></a><span class="co">    Nicht &quot;welches Stueck auf welche Rolle&quot;,</span></span>
-<span id="cb108-19"><a href="#cb108-19" aria-hidden="true" tabindex="-1"></a><span class="co">    sondern &quot;wie oft schneide ich welches MUSTER&quot;.</span></span>
-<span id="cb108-20"><a href="#cb108-20" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb108-21"><a href="#cb108-21" aria-hidden="true" tabindex="-1"></a><span class="co">Damit verschwindet die Symmetrie - aber es entsteht ein neues Problem: Die Zahl</span></span>
-<span id="cb108-22"><a href="#cb108-22" aria-hidden="true" tabindex="-1"></a><span class="co">der moeglichen Muster waechst kombinatorisch. Man kann sie nicht aufschreiben.</span></span>
-<span id="cb108-23"><a href="#cb108-23" aria-hidden="true" tabindex="-1"></a><span class="co">Der Trick besteht darin, sie auch nicht aufzuschreiben, sondern nur die wenigen</span></span>
-<span id="cb108-24"><a href="#cb108-24" aria-hidden="true" tabindex="-1"></a><span class="co">zu erzeugen, die tatsaechlich gebraucht werden - und zwar mit Hilfe der</span></span>
-<span id="cb108-25"><a href="#cb108-25" aria-hidden="true" tabindex="-1"></a><span class="co">Schattenpreise aus dem Kapitel LP.</span></span>
-<span id="cb108-26"><a href="#cb108-26" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb108-27"><a href="#cb108-27" aria-hidden="true" tabindex="-1"></a><span class="co">Das Programm zeigt vier Dinge:</span></span>
-<span id="cb108-28"><a href="#cb108-28" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb108-29"><a href="#cb108-29" aria-hidden="true" tabindex="-1"></a><span class="co">  1. Die beiden Formulierungen desselben Problems und ihre Groesse.</span></span>
-<span id="cb108-30"><a href="#cb108-30" aria-hidden="true" tabindex="-1"></a><span class="co">  2. Wie schnell die Musterzahl waechst - und wie wenige davon genuegen.</span></span>
-<span id="cb108-31"><a href="#cb108-31" aria-hidden="true" tabindex="-1"></a><span class="co">  3. Die Schleife selbst: Master-LP, Dualwerte, Rucksack, neue Spalte.</span></span>
-<span id="cb108-32"><a href="#cb108-32" aria-hidden="true" tabindex="-1"></a><span class="co">  4. Wann sich der Aufwand lohnt und wann nicht. Die Antwort haengt an einer</span></span>
-<span id="cb108-33"><a href="#cb108-33" aria-hidden="true" tabindex="-1"></a><span class="co">     einzigen Kennzahl der Instanz, und sie erklaert nebenbei, warum eine</span></span>
-<span id="cb108-34"><a href="#cb108-34" aria-hidden="true" tabindex="-1"></a><span class="co">     Faustregel bei manchen Zuschnittproblemen schon optimal ist.</span></span>
-<span id="cb108-35"><a href="#cb108-35" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb108-36"><a href="#cb108-36" aria-hidden="true" tabindex="-1"></a><span class="co">Benoetigt: numpy, scipy</span></span>
-<span id="cb108-37"><a href="#cb108-37" aria-hidden="true" tabindex="-1"></a><span class="co">&quot;&quot;&quot;</span></span>
-<span id="cb108-38"><a href="#cb108-38" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb108-39"><a href="#cb108-39" aria-hidden="true" tabindex="-1"></a><span class="im">from</span> __future__ <span class="im">import</span> annotations</span>
-<span id="cb108-40"><a href="#cb108-40" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb108-41"><a href="#cb108-41" aria-hidden="true" tabindex="-1"></a><span class="im">import</span> numpy <span class="im">as</span> np</span>
-<span id="cb108-42"><a href="#cb108-42" aria-hidden="true" tabindex="-1"></a><span class="im">from</span> scipy.optimize <span class="im">import</span> linprog</span>
-<span id="cb108-43"><a href="#cb108-43" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb108-44"><a href="#cb108-44" aria-hidden="true" tabindex="-1"></a>ROLLENBREITE <span class="op">=</span> <span class="dv">5600</span></span>
-<span id="cb108-45"><a href="#cb108-45" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb108-46"><a href="#cb108-46" aria-hidden="true" tabindex="-1"></a><span class="co"># Zwei Instanzen mit demselben Bedarf, aber verschiedenen Breiten. Der</span></span>
-<span id="cb108-47"><a href="#cb108-47" aria-hidden="true" tabindex="-1"></a><span class="co"># Unterschied ist die eine Kennzahl, um die es in Teil 4 geht.</span></span>
-<span id="cb108-48"><a href="#cb108-48" aria-hidden="true" tabindex="-1"></a>BEDARF <span class="op">=</span> [<span class="dv">22</span>, <span class="dv">25</span>, <span class="dv">12</span>, <span class="dv">14</span>, <span class="dv">18</span>, <span class="dv">18</span>, <span class="dv">20</span>, <span class="dv">10</span>, <span class="dv">12</span>, <span class="dv">14</span>, <span class="dv">16</span>, <span class="dv">18</span>, <span class="dv">20</span>]</span>
-<span id="cb108-49"><a href="#cb108-49" aria-hidden="true" tabindex="-1"></a>BREIT <span class="op">=</span> [<span class="dv">1380</span>, <span class="dv">1520</span>, <span class="dv">1560</span>, <span class="dv">1710</span>, <span class="dv">1820</span>, <span class="dv">1880</span>, <span class="dv">1930</span>, <span class="dv">2000</span>, <span class="dv">2050</span>, <span class="dv">2100</span>, <span class="dv">2140</span>,</span>
-<span id="cb108-50"><a href="#cb108-50" aria-hidden="true" tabindex="-1"></a>         <span class="dv">2150</span>, <span class="dv">2200</span>]</span>
-<span id="cb108-51"><a href="#cb108-51" aria-hidden="true" tabindex="-1"></a>SCHMAL <span class="op">=</span> [<span class="dv">380</span>, <span class="dv">520</span>, <span class="dv">560</span>, <span class="dv">710</span>, <span class="dv">820</span>, <span class="dv">880</span>, <span class="dv">930</span>, <span class="dv">1000</span>, <span class="dv">1050</span>, <span class="dv">1100</span>, <span class="dv">1140</span>,</span>
-<span id="cb108-52"><a href="#cb108-52" aria-hidden="true" tabindex="-1"></a>          <span class="dv">1150</span>, <span class="dv">1200</span>]</span>
-<span id="cb108-53"><a href="#cb108-53" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb108-54"><a href="#cb108-54" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb108-55"><a href="#cb108-55" aria-hidden="true" tabindex="-1"></a><span class="co"># --- Die Musterzahl ---------------------------------------------------------</span></span>
-<span id="cb108-56"><a href="#cb108-56" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb108-57"><a href="#cb108-57" aria-hidden="true" tabindex="-1"></a><span class="kw">def</span> zaehle_muster(breiten, rollenbreite: <span class="bu">int</span> <span class="op">=</span> ROLLENBREITE) <span class="op">-&gt;</span> <span class="bu">int</span>:</span>
-<span id="cb108-58"><a href="#cb108-58" aria-hidden="true" tabindex="-1"></a>    <span class="co">&quot;&quot;&quot;Wie viele zulaessige Schnittmuster gibt es ueberhaupt?</span></span>
-<span id="cb108-59"><a href="#cb108-59" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb108-60"><a href="#cb108-60" aria-hidden="true" tabindex="-1"></a><span class="co">    Nur zum Zeigen - in einem produktiven Programm wuerde man das nie</span></span>
-<span id="cb108-61"><a href="#cb108-61" aria-hidden="true" tabindex="-1"></a><span class="co">    ausrechnen, weil die Zahl bei realistischen Instanzen jede Vorstellung</span></span>
-<span id="cb108-62"><a href="#cb108-62" aria-hidden="true" tabindex="-1"></a><span class="co">    sprengt. Genau das ist der Punkt.</span></span>
-<span id="cb108-63"><a href="#cb108-63" aria-hidden="true" tabindex="-1"></a><span class="co">    &quot;&quot;&quot;</span></span>
-<span id="cb108-64"><a href="#cb108-64" aria-hidden="true" tabindex="-1"></a>    speicher: <span class="bu">dict</span>[<span class="bu">tuple</span>[<span class="bu">int</span>, <span class="bu">int</span>], <span class="bu">int</span>] <span class="op">=</span> {}</span>
-<span id="cb108-65"><a href="#cb108-65" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb108-66"><a href="#cb108-66" aria-hidden="true" tabindex="-1"></a>    <span class="kw">def</span> ab(i: <span class="bu">int</span>, rest: <span class="bu">int</span>) <span class="op">-&gt;</span> <span class="bu">int</span>:</span>
-<span id="cb108-67"><a href="#cb108-67" aria-hidden="true" tabindex="-1"></a>        <span class="cf">if</span> i <span class="op">==</span> <span class="bu">len</span>(breiten):</span>
-<span id="cb108-68"><a href="#cb108-68" aria-hidden="true" tabindex="-1"></a>            <span class="cf">return</span> <span class="dv">1</span></span>
-<span id="cb108-69"><a href="#cb108-69" aria-hidden="true" tabindex="-1"></a>        <span class="cf">if</span> (i, rest) <span class="kw">in</span> speicher:</span>
-<span id="cb108-70"><a href="#cb108-70" aria-hidden="true" tabindex="-1"></a>            <span class="cf">return</span> speicher[(i, rest)]</span>
-<span id="cb108-71"><a href="#cb108-71" aria-hidden="true" tabindex="-1"></a>        summe <span class="op">=</span> <span class="bu">sum</span>(ab(i <span class="op">+</span> <span class="dv">1</span>, rest <span class="op">-</span> anzahl <span class="op">*</span> breiten[i])</span>
-<span id="cb108-72"><a href="#cb108-72" aria-hidden="true" tabindex="-1"></a>                    <span class="cf">for</span> anzahl <span class="kw">in</span> <span class="bu">range</span>(rest <span class="op">//</span> breiten[i] <span class="op">+</span> <span class="dv">1</span>))</span>
-<span id="cb108-73"><a href="#cb108-73" aria-hidden="true" tabindex="-1"></a>        speicher[(i, rest)] <span class="op">=</span> summe</span>
-<span id="cb108-74"><a href="#cb108-74" aria-hidden="true" tabindex="-1"></a>        <span class="cf">return</span> summe</span>
-<span id="cb108-75"><a href="#cb108-75" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb108-76"><a href="#cb108-76" aria-hidden="true" tabindex="-1"></a>    <span class="cf">return</span> ab(<span class="dv">0</span>, rollenbreite)</span>
-<span id="cb108-77"><a href="#cb108-77" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb108-78"><a href="#cb108-78" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb108-79"><a href="#cb108-79" aria-hidden="true" tabindex="-1"></a><span class="co"># --- Die beiden Bausteine der Schleife --------------------------------------</span></span>
-<span id="cb108-80"><a href="#cb108-80" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb108-81"><a href="#cb108-81" aria-hidden="true" tabindex="-1"></a><span class="kw">def</span> loese_master(muster, bedarf, ganzzahlig: <span class="bu">bool</span> <span class="op">=</span> <span class="va">False</span>):</span>
-<span id="cb108-82"><a href="#cb108-82" aria-hidden="true" tabindex="-1"></a>    <span class="co">&quot;&quot;&quot;Restringiertes Master: Wie oft schneide ich jedes bekannte Muster?</span></span>
-<span id="cb108-83"><a href="#cb108-83" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb108-84"><a href="#cb108-84" aria-hidden="true" tabindex="-1"></a><span class="co">        min  sum_p x_p           unter   sum_p a_ip * x_p &gt;= bedarf_i</span></span>
-<span id="cb108-85"><a href="#cb108-85" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb108-86"><a href="#cb108-86" aria-hidden="true" tabindex="-1"></a><span class="co">    Als LP gerechnet liefert es zusaetzlich die DUALWERTE - und die sind der</span></span>
-<span id="cb108-87"><a href="#cb108-87" aria-hidden="true" tabindex="-1"></a><span class="co">    eigentliche Ertrag: Der Dualwert zu Breite i sagt, was ein zusaetzliches</span></span>
-<span id="cb108-88"><a href="#cb108-88" aria-hidden="true" tabindex="-1"></a><span class="co">    Stueck dieser Breite an Rollen kostet. Es ist derselbe Schattenpreis wie</span></span>
-<span id="cb108-89"><a href="#cb108-89" aria-hidden="true" tabindex="-1"></a><span class="co">    im Kapitel LP, nur dass er hier nicht berichtet, sondern weiterverarbeitet</span></span>
-<span id="cb108-90"><a href="#cb108-90" aria-hidden="true" tabindex="-1"></a><span class="co">    wird.</span></span>
-<span id="cb108-91"><a href="#cb108-91" aria-hidden="true" tabindex="-1"></a><span class="co">    &quot;&quot;&quot;</span></span>
-<span id="cb108-92"><a href="#cb108-92" aria-hidden="true" tabindex="-1"></a>    matrix <span class="op">=</span> <span class="op">-</span>np.array(muster, dtype<span class="op">=</span><span class="bu">float</span>).T        <span class="co"># &gt;= wird zu &lt;= mit Minus</span></span>
-<span id="cb108-93"><a href="#cb108-93" aria-hidden="true" tabindex="-1"></a>    ergebnis <span class="op">=</span> linprog(np.ones(<span class="bu">len</span>(muster)),</span>
-<span id="cb108-94"><a href="#cb108-94" aria-hidden="true" tabindex="-1"></a>                       A_ub<span class="op">=</span>matrix, b_ub<span class="op">=-</span>np.array(bedarf, dtype<span class="op">=</span><span class="bu">float</span>),</span>
-<span id="cb108-95"><a href="#cb108-95" aria-hidden="true" tabindex="-1"></a>                       bounds<span class="op">=</span>(<span class="dv">0</span>, <span class="va">None</span>),</span>
-<span id="cb108-96"><a href="#cb108-96" aria-hidden="true" tabindex="-1"></a>                       integrality<span class="op">=</span>(<span class="dv">1</span> <span class="cf">if</span> ganzzahlig <span class="cf">else</span> <span class="dv">0</span>), method<span class="op">=</span><span class="st">&quot;highs&quot;</span>)</span>
-<span id="cb108-97"><a href="#cb108-97" aria-hidden="true" tabindex="-1"></a>    <span class="cf">if</span> <span class="kw">not</span> ergebnis.success:</span>
-<span id="cb108-98"><a href="#cb108-98" aria-hidden="true" tabindex="-1"></a>        <span class="cf">raise</span> <span class="pp">SystemExit</span>(<span class="ss">f&quot;Master nicht loesbar: </span><span class="sc">{</span>ergebnis<span class="sc">.</span>message<span class="sc">}</span><span class="ss">&quot;</span>)</span>
-<span id="cb108-99"><a href="#cb108-99" aria-hidden="true" tabindex="-1"></a>    dual <span class="op">=</span> <span class="va">None</span> <span class="cf">if</span> ganzzahlig <span class="cf">else</span> <span class="op">-</span>ergebnis.ineqlin.marginals</span>
-<span id="cb108-100"><a href="#cb108-100" aria-hidden="true" tabindex="-1"></a>    <span class="cf">return</span> ergebnis.fun, ergebnis.x, dual</span>
-<span id="cb108-101"><a href="#cb108-101" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb108-102"><a href="#cb108-102" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb108-103"><a href="#cb108-103" aria-hidden="true" tabindex="-1"></a><span class="kw">def</span> bestes_neues_muster(dual, breiten, rollenbreite: <span class="bu">int</span> <span class="op">=</span> ROLLENBREITE):</span>
-<span id="cb108-104"><a href="#cb108-104" aria-hidden="true" tabindex="-1"></a>    <span class="co">&quot;&quot;&quot;Pricing: Gibt es ein Muster, das sich noch lohnt?</span></span>
-<span id="cb108-105"><a href="#cb108-105" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb108-106"><a href="#cb108-106" aria-hidden="true" tabindex="-1"></a><span class="co">    Gesucht ist das Muster mit dem groessten Gesamtwert zu den aktuellen</span></span>
-<span id="cb108-107"><a href="#cb108-107" aria-hidden="true" tabindex="-1"></a><span class="co">    Schattenpreisen - unter der Bedingung, dass es in die Rolle passt. Das ist</span></span>
-<span id="cb108-108"><a href="#cb108-108" aria-hidden="true" tabindex="-1"></a><span class="co">    ein RUCKSACKPROBLEM (Kapitel MILP, Rucksack.py): Preise sind der Nutzen,</span></span>
-<span id="cb108-109"><a href="#cb108-109" aria-hidden="true" tabindex="-1"></a><span class="co">    Breiten das Gewicht, die Rollenbreite die Kapazitaet. Hier mit dynamischer</span></span>
-<span id="cb108-110"><a href="#cb108-110" aria-hidden="true" tabindex="-1"></a><span class="co">    Programmierung geloest, weil die Breiten ganzzahlig sind.</span></span>
-<span id="cb108-111"><a href="#cb108-111" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb108-112"><a href="#cb108-112" aria-hidden="true" tabindex="-1"></a><span class="co">    Bei Gleichstand wird bewusst der KLEINSTE Index bevorzugt (&gt;-Vergleich mit</span></span>
-<span id="cb108-113"><a href="#cb108-113" aria-hidden="true" tabindex="-1"></a><span class="co">    Toleranz statt &gt;=). Sonst haengt das erzeugte Muster von der Reihenfolge</span></span>
-<span id="cb108-114"><a href="#cb108-114" aria-hidden="true" tabindex="-1"></a><span class="co">    der Gleitkommaoperationen ab, und das Programm liefert von Lauf zu Lauf</span></span>
-<span id="cb108-115"><a href="#cb108-115" aria-hidden="true" tabindex="-1"></a><span class="co">    verschiedene Ausgaben.</span></span>
-<span id="cb108-116"><a href="#cb108-116" aria-hidden="true" tabindex="-1"></a><span class="co">    &quot;&quot;&quot;</span></span>
-<span id="cb108-117"><a href="#cb108-117" aria-hidden="true" tabindex="-1"></a>    wert <span class="op">=</span> np.zeros(rollenbreite <span class="op">+</span> <span class="dv">1</span>)</span>
-<span id="cb108-118"><a href="#cb108-118" aria-hidden="true" tabindex="-1"></a>    herkunft <span class="op">=</span> [<span class="op">-</span><span class="dv">1</span>] <span class="op">*</span> (rollenbreite <span class="op">+</span> <span class="dv">1</span>)</span>
-<span id="cb108-119"><a href="#cb108-119" aria-hidden="true" tabindex="-1"></a>    <span class="cf">for</span> platz <span class="kw">in</span> <span class="bu">range</span>(rollenbreite <span class="op">+</span> <span class="dv">1</span>):</span>
-<span id="cb108-120"><a href="#cb108-120" aria-hidden="true" tabindex="-1"></a>        <span class="cf">for</span> i, breite <span class="kw">in</span> <span class="bu">enumerate</span>(breiten):</span>
-<span id="cb108-121"><a href="#cb108-121" aria-hidden="true" tabindex="-1"></a>            <span class="cf">if</span> breite <span class="op">&lt;=</span> platz <span class="kw">and</span> wert[platz <span class="op">-</span> breite] <span class="op">+</span> dual[i] <span class="op">&gt;</span> wert[platz] <span class="op">+</span> <span class="fl">1e-9</span>:</span>
-<span id="cb108-122"><a href="#cb108-122" aria-hidden="true" tabindex="-1"></a>                wert[platz] <span class="op">=</span> wert[platz <span class="op">-</span> breite] <span class="op">+</span> dual[i]</span>
-<span id="cb108-123"><a href="#cb108-123" aria-hidden="true" tabindex="-1"></a>                herkunft[platz] <span class="op">=</span> i</span>
-<span id="cb108-124"><a href="#cb108-124" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb108-125"><a href="#cb108-125" aria-hidden="true" tabindex="-1"></a>    muster <span class="op">=</span> [<span class="dv">0</span>] <span class="op">*</span> <span class="bu">len</span>(breiten)</span>
-<span id="cb108-126"><a href="#cb108-126" aria-hidden="true" tabindex="-1"></a>    platz <span class="op">=</span> rollenbreite</span>
-<span id="cb108-127"><a href="#cb108-127" aria-hidden="true" tabindex="-1"></a>    <span class="cf">while</span> herkunft[platz] <span class="op">&gt;=</span> <span class="dv">0</span>:</span>
-<span id="cb108-128"><a href="#cb108-128" aria-hidden="true" tabindex="-1"></a>        i <span class="op">=</span> herkunft[platz]</span>
-<span id="cb108-129"><a href="#cb108-129" aria-hidden="true" tabindex="-1"></a>        muster[i] <span class="op">+=</span> <span class="dv">1</span></span>
-<span id="cb108-130"><a href="#cb108-130" aria-hidden="true" tabindex="-1"></a>        platz <span class="op">-=</span> breiten[i]</span>
-<span id="cb108-131"><a href="#cb108-131" aria-hidden="true" tabindex="-1"></a>    <span class="cf">return</span> <span class="bu">float</span>(wert[rollenbreite]), muster</span>
-<span id="cb108-132"><a href="#cb108-132" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb108-133"><a href="#cb108-133" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb108-134"><a href="#cb108-134" aria-hidden="true" tabindex="-1"></a><span class="kw">def</span> spaltengenerierung(breiten, bedarf, rollenbreite: <span class="bu">int</span> <span class="op">=</span> ROLLENBREITE):</span>
-<span id="cb108-135"><a href="#cb108-135" aria-hidden="true" tabindex="-1"></a>    <span class="co">&quot;&quot;&quot;Die Schleife. Startbasis: je ein Muster mit nur einer Breite.</span></span>
-<span id="cb108-136"><a href="#cb108-136" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb108-137"><a href="#cb108-137" aria-hidden="true" tabindex="-1"></a><span class="co">    Abbruch, wenn kein Muster mehr einen Wert ueber 1 hat: Eine zusaetzliche</span></span>
-<span id="cb108-138"><a href="#cb108-138" aria-hidden="true" tabindex="-1"></a><span class="co">    Rolle kostet 1, also lohnt sich ein neues Muster nur, wenn es zu den</span></span>
-<span id="cb108-139"><a href="#cb108-139" aria-hidden="true" tabindex="-1"></a><span class="co">    aktuellen Preisen mehr als 1 wert ist. Das ist das Kriterium der</span></span>
-<span id="cb108-140"><a href="#cb108-140" aria-hidden="true" tabindex="-1"></a><span class="co">    reduzierten Kosten.</span></span>
-<span id="cb108-141"><a href="#cb108-141" aria-hidden="true" tabindex="-1"></a><span class="co">    &quot;&quot;&quot;</span></span>
-<span id="cb108-142"><a href="#cb108-142" aria-hidden="true" tabindex="-1"></a>    anzahl <span class="op">=</span> <span class="bu">len</span>(breiten)</span>
-<span id="cb108-143"><a href="#cb108-143" aria-hidden="true" tabindex="-1"></a>    muster <span class="op">=</span> [[<span class="dv">0</span>] <span class="op">*</span> anzahl <span class="cf">for</span> _ <span class="kw">in</span> <span class="bu">range</span>(anzahl)]</span>
-<span id="cb108-144"><a href="#cb108-144" aria-hidden="true" tabindex="-1"></a>    <span class="cf">for</span> i <span class="kw">in</span> <span class="bu">range</span>(anzahl):</span>
-<span id="cb108-145"><a href="#cb108-145" aria-hidden="true" tabindex="-1"></a>        muster[i][i] <span class="op">=</span> rollenbreite <span class="op">//</span> breiten[i]</span>
-<span id="cb108-146"><a href="#cb108-146" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb108-147"><a href="#cb108-147" aria-hidden="true" tabindex="-1"></a>    runden <span class="op">=</span> <span class="dv">0</span></span>
-<span id="cb108-148"><a href="#cb108-148" aria-hidden="true" tabindex="-1"></a>    <span class="cf">while</span> <span class="va">True</span>:</span>
-<span id="cb108-149"><a href="#cb108-149" aria-hidden="true" tabindex="-1"></a>        zielwert, _, dual <span class="op">=</span> loese_master(muster, bedarf)</span>
-<span id="cb108-150"><a href="#cb108-150" aria-hidden="true" tabindex="-1"></a>        wert, neu <span class="op">=</span> bestes_neues_muster(dual, breiten, rollenbreite)</span>
-<span id="cb108-151"><a href="#cb108-151" aria-hidden="true" tabindex="-1"></a>        runden <span class="op">+=</span> <span class="dv">1</span></span>
-<span id="cb108-152"><a href="#cb108-152" aria-hidden="true" tabindex="-1"></a>        <span class="cf">if</span> wert <span class="op">&lt;=</span> <span class="dv">1</span> <span class="op">+</span> <span class="fl">1e-6</span>:</span>
-<span id="cb108-153"><a href="#cb108-153" aria-hidden="true" tabindex="-1"></a>            <span class="cf">return</span> muster, zielwert, runden</span>
-<span id="cb108-154"><a href="#cb108-154" aria-hidden="true" tabindex="-1"></a>        muster.append(neu)</span>
-<span id="cb108-155"><a href="#cb108-155" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb108-156"><a href="#cb108-156" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb108-157"><a href="#cb108-157" aria-hidden="true" tabindex="-1"></a><span class="kw">def</span> first_fit(breiten, bedarf, rollenbreite: <span class="bu">int</span> <span class="op">=</span> ROLLENBREITE) <span class="op">-&gt;</span> <span class="bu">int</span>:</span>
-<span id="cb108-158"><a href="#cb108-158" aria-hidden="true" tabindex="-1"></a>    <span class="co">&quot;&quot;&quot;Die Faustregel: groesstes Stueck zuerst, auf die erste passende Rolle.&quot;&quot;&quot;</span></span>
-<span id="cb108-159"><a href="#cb108-159" aria-hidden="true" tabindex="-1"></a>    stuecke <span class="op">=</span> <span class="bu">sorted</span>([b <span class="cf">for</span> b, menge <span class="kw">in</span> <span class="bu">zip</span>(breiten, bedarf)</span>
-<span id="cb108-160"><a href="#cb108-160" aria-hidden="true" tabindex="-1"></a>                      <span class="cf">for</span> _ <span class="kw">in</span> <span class="bu">range</span>(menge)], reverse<span class="op">=</span><span class="va">True</span>)</span>
-<span id="cb108-161"><a href="#cb108-161" aria-hidden="true" tabindex="-1"></a>    rollen: <span class="bu">list</span>[<span class="bu">list</span>[<span class="bu">int</span>]] <span class="op">=</span> []</span>
-<span id="cb108-162"><a href="#cb108-162" aria-hidden="true" tabindex="-1"></a>    <span class="cf">for</span> stueck <span class="kw">in</span> stuecke:</span>
-<span id="cb108-163"><a href="#cb108-163" aria-hidden="true" tabindex="-1"></a>        <span class="cf">for</span> rolle <span class="kw">in</span> rollen:</span>
-<span id="cb108-164"><a href="#cb108-164" aria-hidden="true" tabindex="-1"></a>            <span class="cf">if</span> <span class="bu">sum</span>(rolle) <span class="op">+</span> stueck <span class="op">&lt;=</span> rollenbreite:</span>
-<span id="cb108-165"><a href="#cb108-165" aria-hidden="true" tabindex="-1"></a>                rolle.append(stueck)</span>
-<span id="cb108-166"><a href="#cb108-166" aria-hidden="true" tabindex="-1"></a>                <span class="cf">break</span></span>
-<span id="cb108-167"><a href="#cb108-167" aria-hidden="true" tabindex="-1"></a>        <span class="cf">else</span>:</span>
-<span id="cb108-168"><a href="#cb108-168" aria-hidden="true" tabindex="-1"></a>            rollen.append([stueck])</span>
-<span id="cb108-169"><a href="#cb108-169" aria-hidden="true" tabindex="-1"></a>    <span class="cf">return</span> <span class="bu">len</span>(rollen)</span>
-<span id="cb108-170"><a href="#cb108-170" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb108-171"><a href="#cb108-171" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb108-172"><a href="#cb108-172" aria-hidden="true" tabindex="-1"></a><span class="kw">def</span> auswerten(name: <span class="bu">str</span>, breiten, bedarf) <span class="op">-&gt;</span> <span class="bu">dict</span>:</span>
-<span id="cb108-173"><a href="#cb108-173" aria-hidden="true" tabindex="-1"></a>    muster, schranke, runden <span class="op">=</span> spaltengenerierung(breiten, bedarf)</span>
-<span id="cb108-174"><a href="#cb108-174" aria-hidden="true" tabindex="-1"></a>    ganz, _, _ <span class="op">=</span> loese_master(muster, bedarf, ganzzahlig<span class="op">=</span><span class="va">True</span>)</span>
-<span id="cb108-175"><a href="#cb108-175" aria-hidden="true" tabindex="-1"></a>    <span class="cf">return</span> {<span class="st">&quot;name&quot;</span>: name, <span class="st">&quot;muster_gesamt&quot;</span>: zaehle_muster(breiten),</span>
-<span id="cb108-176"><a href="#cb108-176" aria-hidden="true" tabindex="-1"></a>            <span class="st">&quot;muster_erzeugt&quot;</span>: <span class="bu">len</span>(muster), <span class="st">&quot;runden&quot;</span>: runden,</span>
-<span id="cb108-177"><a href="#cb108-177" aria-hidden="true" tabindex="-1"></a>            <span class="st">&quot;schranke&quot;</span>: schranke, <span class="st">&quot;ganzzahlig&quot;</span>: <span class="bu">int</span>(<span class="bu">round</span>(ganz)),</span>
-<span id="cb108-178"><a href="#cb108-178" aria-hidden="true" tabindex="-1"></a>            <span class="st">&quot;first_fit&quot;</span>: first_fit(breiten, bedarf),</span>
-<span id="cb108-179"><a href="#cb108-179" aria-hidden="true" tabindex="-1"></a>            <span class="st">&quot;stuecke_je_rolle&quot;</span>: ROLLENBREITE <span class="op">/</span> np.mean(breiten)}</span>
-<span id="cb108-180"><a href="#cb108-180" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb108-181"><a href="#cb108-181" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb108-182"><a href="#cb108-182" aria-hidden="true" tabindex="-1"></a><span class="cf">if</span> <span class="va">__name__</span> <span class="op">==</span> <span class="st">&quot;__main__&quot;</span>:</span>
-<span id="cb108-183"><a href="#cb108-183" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;=&quot;</span> <span class="op">*</span> <span class="dv">84</span>)</span>
-<span id="cb108-184"><a href="#cb108-184" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;  SPALTENGENERIERUNG: NUR DIE MUSTER ERZEUGEN, DIE MAN BRAUCHT&quot;</span>)</span>
-<span id="cb108-185"><a href="#cb108-185" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;=&quot;</span> <span class="op">*</span> <span class="dv">84</span>)</span>
-<span id="cb108-186"><a href="#cb108-186" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;Mutterrolle </span><span class="sc">{</span>ROLLENBREITE<span class="sc">:,}</span><span class="ss"> mm, </span><span class="sc">{</span><span class="bu">len</span>(BREIT)<span class="sc">}</span><span class="ss"> bestellte Breiten, &quot;</span></span>
-<span id="cb108-187"><a href="#cb108-187" aria-hidden="true" tabindex="-1"></a>          <span class="ss">f&quot;</span><span class="sc">{</span><span class="bu">sum</span>(BEDARF)<span class="sc">}</span><span class="ss"> Zuschnitte.</span><span class="ch">\n</span><span class="ss">&quot;</span>)</span>
-<span id="cb108-188"><a href="#cb108-188" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb108-189"><a href="#cb108-189" aria-hidden="true" tabindex="-1"></a>    <span class="co"># --- 1. Zwei Formulierungen ------------------------------------------</span></span>
-<span id="cb108-190"><a href="#cb108-190" aria-hidden="true" tabindex="-1"></a>    stuecke <span class="op">=</span> <span class="bu">sum</span>(BEDARF)</span>
-<span id="cb108-191"><a href="#cb108-191" aria-hidden="true" tabindex="-1"></a>    <span class="co"># Wie viele Rollen braucht man hoechstens? Die Faustregel liefert eine</span></span>
-<span id="cb108-192"><a href="#cb108-192" aria-hidden="true" tabindex="-1"></a>    <span class="co"># brauchbare Obergrenze - mehr Rollen als das wird niemand benoetigen.</span></span>
-<span id="cb108-193"><a href="#cb108-193" aria-hidden="true" tabindex="-1"></a>    rollen_obergrenze <span class="op">=</span> first_fit(BREIT, BEDARF)</span>
-<span id="cb108-194"><a href="#cb108-194" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;1. Zwei Modelle fuer dieselbe Aufgabe</span><span class="ch">\n</span><span class="st">&quot;</span>)</span>
-<span id="cb108-195"><a href="#cb108-195" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;  </span><span class="sc">{</span><span class="st">&#39;Formulierung&#39;</span><span class="sc">:&lt;34}</span><span class="ss"> </span><span class="sc">{</span><span class="st">&#39;Binaervariablen&#39;</span><span class="sc">:&gt;16}</span><span class="ss"> </span><span class="sc">{</span><span class="st">&#39;symmetrisch?&#39;</span><span class="sc">:&gt;16}</span><span class="ss">&quot;</span>)</span>
-<span id="cb108-196"><a href="#cb108-196" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;  &quot;</span> <span class="op">+</span> <span class="st">&quot;-&quot;</span> <span class="op">*</span> <span class="dv">70</span>)</span>
-<span id="cb108-197"><a href="#cb108-197" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;  </span><span class="sc">{</span><span class="st">&#39;Stueck -&gt; Rolle (naheliegend)&#39;</span><span class="sc">:&lt;34}</span><span class="ss"> &quot;</span></span>
-<span id="cb108-198"><a href="#cb108-198" aria-hidden="true" tabindex="-1"></a>          <span class="ss">f&quot;</span><span class="sc">{</span>stuecke <span class="op">*</span> rollen_obergrenze<span class="sc">:&gt;16,}</span><span class="ss"> </span><span class="sc">{</span><span class="st">&#39;ja&#39;</span><span class="sc">:&gt;16}</span><span class="ss">&quot;</span>)</span>
-<span id="cb108-199"><a href="#cb108-199" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;  </span><span class="sc">{</span><span class="st">&#39;wie oft welches Muster&#39;</span><span class="sc">:&lt;34}</span><span class="ss"> &quot;</span></span>
-<span id="cb108-200"><a href="#cb108-200" aria-hidden="true" tabindex="-1"></a>          <span class="ss">f&quot;</span><span class="sc">{</span><span class="st">&#39;eine je Muster&#39;</span><span class="sc">:&gt;16}</span><span class="ss"> </span><span class="sc">{</span><span class="st">&#39;nein&#39;</span><span class="sc">:&gt;16}</span><span class="ss">&quot;</span>)</span>
-<span id="cb108-201"><a href="#cb108-201" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;</span><span class="ch">\n</span><span class="ss">  Der naheliegende Ansatz braucht eine Variable je Stueck und Rolle:&quot;</span>)</span>
-<span id="cb108-202"><a href="#cb108-202" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;  </span><span class="sc">{</span>stuecke<span class="sc">}</span><span class="ss"> Zuschnitte x </span><span class="sc">{</span>rollen_obergrenze<span class="sc">}</span><span class="ss"> Rollen (Obergrenze aus der Faustregel)&quot;</span>)</span>
-<span id="cb108-203"><a href="#cb108-203" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;  = </span><span class="sc">{</span>stuecke <span class="op">*</span> rollen_obergrenze<span class="sc">:,}</span><span class="ss"> Binaervariablen.&quot;</span>)</span>
-<span id="cb108-204"><a href="#cb108-204" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;</span><span class="ch">\n</span><span class="st">  Schlimmer als die Zahl ist die Symmetrie: Alle Mutterrollen sind&quot;</span>)</span>
-<span id="cb108-205"><a href="#cb108-205" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;  gleich, also beschreibt jede Loesung dieselbe Schnittvorschrift in&quot;</span>)</span>
-<span id="cb108-206"><a href="#cb108-206" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;  unzaehligen Umbenennungen. Branch-and-Bound probiert sie einzeln&quot;</span>)</span>
-<span id="cb108-207"><a href="#cb108-207" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;  durch und kommt nicht voran - der Suchbaum waechst, ohne dass sich&quot;</span>)</span>
-<span id="cb108-208"><a href="#cb108-208" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;  die Schranke bewegt.&quot;</span>)</span>
-<span id="cb108-209"><a href="#cb108-209" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;</span><span class="ch">\n</span><span class="st">  Das Mustermodell hat je Muster genau eine Variable und kennt keine&quot;</span>)</span>
-<span id="cb108-210"><a href="#cb108-210" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;  einzelnen Rollen mehr. Damit ist die Symmetrie weg. Sein Problem ist&quot;</span>)</span>
-<span id="cb108-211"><a href="#cb108-211" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;  ein anderes - und zwar das folgende.&quot;</span>)</span>
-<span id="cb108-212"><a href="#cb108-212" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb108-213"><a href="#cb108-213" aria-hidden="true" tabindex="-1"></a>    <span class="co"># --- 2. Die Musterzahl ------------------------------------------------</span></span>
-<span id="cb108-214"><a href="#cb108-214" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;</span><span class="ch">\n</span><span class="st">&quot;</span> <span class="op">+</span> <span class="st">&quot;-&quot;</span> <span class="op">*</span> <span class="dv">84</span>)</span>
-<span id="cb108-215"><a href="#cb108-215" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;2. Warum man die Muster nicht aufschreiben kann</span><span class="ch">\n</span><span class="st">&quot;</span>)</span>
-<span id="cb108-216"><a href="#cb108-216" aria-hidden="true" tabindex="-1"></a>    gross <span class="op">=</span> auswerten(<span class="st">&quot;breite Zuschnitte (1.380-2.200 mm)&quot;</span>, BREIT, BEDARF)</span>
-<span id="cb108-217"><a href="#cb108-217" aria-hidden="true" tabindex="-1"></a>    schmal <span class="op">=</span> auswerten(<span class="st">&quot;schmale Zuschnitte (380-1.200 mm)&quot;</span>, SCHMAL, BEDARF)</span>
-<span id="cb108-218"><a href="#cb108-218" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb108-219"><a href="#cb108-219" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;  </span><span class="sc">{</span><span class="st">&#39;Instanz&#39;</span><span class="sc">:&lt;36}</span><span class="ss"> </span><span class="sc">{</span><span class="st">&#39;Muster&#39;</span><span class="sc">:&gt;12}</span><span class="ss"> </span><span class="sc">{</span><span class="st">&#39;davon erzeugt&#39;</span><span class="sc">:&gt;14}</span><span class="ss"> </span><span class="sc">{</span><span class="st">&#39;Anteil&#39;</span><span class="sc">:&gt;9}</span><span class="ss">&quot;</span>)</span>
-<span id="cb108-220"><a href="#cb108-220" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;  &quot;</span> <span class="op">+</span> <span class="st">&quot;-&quot;</span> <span class="op">*</span> <span class="dv">76</span>)</span>
-<span id="cb108-221"><a href="#cb108-221" aria-hidden="true" tabindex="-1"></a>    <span class="cf">for</span> fall <span class="kw">in</span> (gross, schmal):</span>
-<span id="cb108-222"><a href="#cb108-222" aria-hidden="true" tabindex="-1"></a>        anteil <span class="op">=</span> fall[<span class="st">&quot;muster_erzeugt&quot;</span>] <span class="op">/</span> fall[<span class="st">&quot;muster_gesamt&quot;</span>]</span>
-<span id="cb108-223"><a href="#cb108-223" aria-hidden="true" tabindex="-1"></a>        <span class="bu">print</span>(<span class="ss">f&quot;  </span><span class="sc">{</span>fall[<span class="st">&#39;name&#39;</span>]<span class="sc">:&lt;36}</span><span class="ss"> </span><span class="sc">{</span>fall[<span class="st">&#39;muster_gesamt&#39;</span>]<span class="sc">:&gt;12,}</span><span class="ss"> &quot;</span></span>
-<span id="cb108-224"><a href="#cb108-224" aria-hidden="true" tabindex="-1"></a>              <span class="ss">f&quot;</span><span class="sc">{</span>fall[<span class="st">&#39;muster_erzeugt&#39;</span>]<span class="sc">:&gt;14}</span><span class="ss"> </span><span class="sc">{</span>anteil<span class="sc">:&gt;8.1%}</span><span class="ss">&quot;</span>)</span>
-<span id="cb108-225"><a href="#cb108-225" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb108-226"><a href="#cb108-226" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;</span><span class="ch">\n</span><span class="ss">  Schon das Halbieren der Breiten laesst die Musterzahl von &quot;</span></span>
-<span id="cb108-227"><a href="#cb108-227" aria-hidden="true" tabindex="-1"></a>          <span class="ss">f&quot;</span><span class="sc">{</span>gross[<span class="st">&#39;muster_gesamt&#39;</span>]<span class="sc">:,}</span><span class="ss"> auf&quot;</span>)</span>
-<span id="cb108-228"><a href="#cb108-228" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;  </span><span class="sc">{</span>schmal[<span class="st">&#39;muster_gesamt&#39;</span>]<span class="sc">:,}</span><span class="ss"> springen - Faktor &quot;</span></span>
-<span id="cb108-229"><a href="#cb108-229" aria-hidden="true" tabindex="-1"></a>          <span class="ss">f&quot;</span><span class="sc">{</span>schmal[<span class="st">&#39;muster_gesamt&#39;</span>] <span class="op">/</span> gross[<span class="st">&#39;muster_gesamt&#39;</span>]<span class="sc">:.0f}</span><span class="ss">. Bei einer echten &quot;</span></span>
-<span id="cb108-230"><a href="#cb108-230" aria-hidden="true" tabindex="-1"></a>          <span class="ss">f&quot;Papierfabrik mit&quot;</span>)</span>
-<span id="cb108-231"><a href="#cb108-231" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;  vierzig Breiten und Millimeterschritten sind es mehr, als sich&quot;</span>)</span>
-<span id="cb108-232"><a href="#cb108-232" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;  speichern liesse.&quot;</span>)</span>
-<span id="cb108-233"><a href="#cb108-233" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;</span><span class="ch">\n</span><span class="ss">  Gebraucht werden davon </span><span class="sc">{</span>schmal[<span class="st">&#39;muster_erzeugt&#39;</span>]<span class="sc">}</span><span class="ss"> - &quot;</span></span>
-<span id="cb108-234"><a href="#cb108-234" aria-hidden="true" tabindex="-1"></a>          <span class="ss">f&quot;</span><span class="sc">{</span>schmal[<span class="st">&#39;muster_erzeugt&#39;</span>] <span class="op">/</span> schmal[<span class="st">&#39;muster_gesamt&#39;</span>]<span class="sc">:.2%}</span><span class="ss"> der Gesamtzahl.&quot;</span>)</span>
-<span id="cb108-235"><a href="#cb108-235" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb108-236"><a href="#cb108-236" aria-hidden="true" tabindex="-1"></a>    <span class="co"># --- 3. Die Schleife --------------------------------------------------</span></span>
-<span id="cb108-237"><a href="#cb108-237" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;</span><span class="ch">\n</span><span class="st">&quot;</span> <span class="op">+</span> <span class="st">&quot;-&quot;</span> <span class="op">*</span> <span class="dv">84</span>)</span>
-<span id="cb108-238"><a href="#cb108-238" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;3. Die Schleife an der breiten Instanz</span><span class="ch">\n</span><span class="st">&quot;</span>)</span>
-<span id="cb108-239"><a href="#cb108-239" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;  Startbasis: </span><span class="sc">{</span><span class="bu">len</span>(BREIT)<span class="sc">}</span><span class="ss"> triviale Muster (je Rolle nur eine Breite)&quot;</span>)</span>
-<span id="cb108-240"><a href="#cb108-240" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;  Runden bis kein Muster mehr lohnt: </span><span class="sc">{</span>gross[<span class="st">&#39;runden&#39;</span>]<span class="sc">}</span><span class="ss">&quot;</span>)</span>
-<span id="cb108-241"><a href="#cb108-241" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;  Muster am Ende: </span><span class="sc">{</span>gross[<span class="st">&#39;muster_erzeugt&#39;</span>]<span class="sc">}</span><span class="ss">&quot;</span>)</span>
-<span id="cb108-242"><a href="#cb108-242" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;  LP-Schranke: </span><span class="sc">{</span>gross[<span class="st">&#39;schranke&#39;</span>]<span class="sc">:.4f}</span><span class="ss"> Rollen&quot;</span>)</span>
-<span id="cb108-243"><a href="#cb108-243" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;</span><span class="ch">\n</span><span class="ss">  Die LP-Schranke ist eine ZUSAGE: Weniger als &quot;</span></span>
-<span id="cb108-244"><a href="#cb108-244" aria-hidden="true" tabindex="-1"></a>          <span class="ss">f&quot;</span><span class="sc">{</span>np<span class="sc">.</span>ceil(gross[<span class="st">&#39;schranke&#39;</span>] <span class="op">-</span> <span class="fl">1e-9</span>)<span class="sc">:.0f}</span><span class="ss"> Rollen sind&quot;</span>)</span>
-<span id="cb108-245"><a href="#cb108-245" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;  nicht moeglich - unabhaengig davon, wie clever man weiterschneidet.&quot;</span>)</span>
-<span id="cb108-246"><a href="#cb108-246" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;  Genau diese Aussage fehlt einer Heuristik (Kapitel Metaheuristiken).&quot;</span>)</span>
-<span id="cb108-247"><a href="#cb108-247" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb108-248"><a href="#cb108-248" aria-hidden="true" tabindex="-1"></a>    <span class="co"># --- 4. Wann es sich lohnt --------------------------------------------</span></span>
-<span id="cb108-249"><a href="#cb108-249" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;</span><span class="ch">\n</span><span class="st">&quot;</span> <span class="op">+</span> <span class="st">&quot;-&quot;</span> <span class="op">*</span> <span class="dv">84</span>)</span>
-<span id="cb108-250"><a href="#cb108-250" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;4. Wann sich der Aufwand lohnt - und wann nicht</span><span class="ch">\n</span><span class="st">&quot;</span>)</span>
-<span id="cb108-251"><a href="#cb108-251" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;  </span><span class="sc">{</span><span class="st">&#39;Instanz&#39;</span><span class="sc">:&lt;36}</span><span class="ss"> </span><span class="sc">{</span><span class="st">&#39;Faustregel&#39;</span><span class="sc">:&gt;11}</span><span class="ss"> </span><span class="sc">{</span><span class="st">&#39;exakt&#39;</span><span class="sc">:&gt;8}</span><span class="ss"> </span><span class="sc">{</span><span class="st">&#39;Schranke&#39;</span><span class="sc">:&gt;10}</span><span class="ss"> &quot;</span></span>
-<span id="cb108-252"><a href="#cb108-252" aria-hidden="true" tabindex="-1"></a>          <span class="ss">f&quot;</span><span class="sc">{</span><span class="st">&#39;Ersparnis&#39;</span><span class="sc">:&gt;11}</span><span class="ss">&quot;</span>)</span>
-<span id="cb108-253"><a href="#cb108-253" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;  &quot;</span> <span class="op">+</span> <span class="st">&quot;-&quot;</span> <span class="op">*</span> <span class="dv">80</span>)</span>
-<span id="cb108-254"><a href="#cb108-254" aria-hidden="true" tabindex="-1"></a>    <span class="cf">for</span> fall <span class="kw">in</span> (gross, schmal):</span>
-<span id="cb108-255"><a href="#cb108-255" aria-hidden="true" tabindex="-1"></a>        ersparnis <span class="op">=</span> (fall[<span class="st">&quot;first_fit&quot;</span>] <span class="op">-</span> fall[<span class="st">&quot;ganzzahlig&quot;</span>]) <span class="op">/</span> fall[<span class="st">&quot;first_fit&quot;</span>]</span>
-<span id="cb108-256"><a href="#cb108-256" aria-hidden="true" tabindex="-1"></a>        <span class="bu">print</span>(<span class="ss">f&quot;  </span><span class="sc">{</span>fall[<span class="st">&#39;name&#39;</span>]<span class="sc">:&lt;36}</span><span class="ss"> </span><span class="sc">{</span>fall[<span class="st">&#39;first_fit&#39;</span>]<span class="sc">:&gt;11}</span><span class="ss"> &quot;</span></span>
-<span id="cb108-257"><a href="#cb108-257" aria-hidden="true" tabindex="-1"></a>              <span class="ss">f&quot;</span><span class="sc">{</span>fall[<span class="st">&#39;ganzzahlig&#39;</span>]<span class="sc">:&gt;8}</span><span class="ss"> </span><span class="sc">{</span>fall[<span class="st">&#39;schranke&#39;</span>]<span class="sc">:&gt;10.2f}</span><span class="ss"> &quot;</span></span>
-<span id="cb108-258"><a href="#cb108-258" aria-hidden="true" tabindex="-1"></a>              <span class="ss">f&quot;</span><span class="sc">{</span>ersparnis<span class="sc">:&gt;10.0%}</span><span class="ss">&quot;</span>)</span>
-<span id="cb108-259"><a href="#cb108-259" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb108-260"><a href="#cb108-260" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;</span><span class="ch">\n</span><span class="ss">  Bei den breiten Zuschnitten spart die Spaltengenerierung &quot;</span></span>
-<span id="cb108-261"><a href="#cb108-261" aria-hidden="true" tabindex="-1"></a>          <span class="ss">f&quot;</span><span class="sc">{</span>gross[<span class="st">&#39;first_fit&#39;</span>] <span class="op">-</span> gross[<span class="st">&#39;ganzzahlig&#39;</span>]<span class="sc">}</span><span class="ss"> von&quot;</span>)</span>
-<span id="cb108-262"><a href="#cb108-262" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;  </span><span class="sc">{</span>gross[<span class="st">&#39;first_fit&#39;</span>]<span class="sc">}</span><span class="ss"> Rollen. Bei den schmalen spart sie NICHTS - dort ist die&quot;</span>)</span>
-<span id="cb108-263"><a href="#cb108-263" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;  Faustregel bereits optimal.&quot;</span>)</span>
-<span id="cb108-264"><a href="#cb108-264" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;</span><span class="ch">\n</span><span class="ss">  Der Unterschied haengt an einer einzigen Kennzahl:</span><span class="ch">\n</span><span class="ss">&quot;</span>)</span>
-<span id="cb108-265"><a href="#cb108-265" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;  </span><span class="sc">{</span><span class="st">&#39;Instanz&#39;</span><span class="sc">:&lt;36}</span><span class="ss"> </span><span class="sc">{</span><span class="st">&#39;Stuecke je Rolle (etwa)&#39;</span><span class="sc">:&gt;24}</span><span class="ss">&quot;</span>)</span>
-<span id="cb108-266"><a href="#cb108-266" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;  &quot;</span> <span class="op">+</span> <span class="st">&quot;-&quot;</span> <span class="op">*</span> <span class="dv">62</span>)</span>
-<span id="cb108-267"><a href="#cb108-267" aria-hidden="true" tabindex="-1"></a>    <span class="cf">for</span> fall <span class="kw">in</span> (gross, schmal):</span>
-<span id="cb108-268"><a href="#cb108-268" aria-hidden="true" tabindex="-1"></a>        <span class="bu">print</span>(<span class="ss">f&quot;  </span><span class="sc">{</span>fall[<span class="st">&#39;name&#39;</span>]<span class="sc">:&lt;36}</span><span class="ss"> </span><span class="sc">{</span>fall[<span class="st">&#39;stuecke_je_rolle&#39;</span>]<span class="sc">:&gt;24.1f}</span><span class="ss">&quot;</span>)</span>
-<span id="cb108-269"><a href="#cb108-269" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb108-270"><a href="#cb108-270" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;</span><span class="ch">\n</span><span class="st">  Passen nur zwei bis drei Stuecke auf eine Rolle, entscheidet jede&quot;</span>)</span>
-<span id="cb108-271"><a href="#cb108-271" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;  einzelne Zuordnung viel, und eine kurzsichtige Regel verschenkt&quot;</span>)</span>
-<span id="cb108-272"><a href="#cb108-272" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;  ganze Rollen. Passen sechs oder mehr darauf, gleichen sich die&quot;</span>)</span>
-<span id="cb108-273"><a href="#cb108-273" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;  Fehler aus - die Reste sind klein gegen die Rollenbreite, und die&quot;</span>)</span>
-<span id="cb108-274"><a href="#cb108-274" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;  Faustregel trifft es fast immer.&quot;</span>)</span>
-<span id="cb108-275"><a href="#cb108-275" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb108-276"><a href="#cb108-276" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;</span><span class="ch">\n</span><span class="st">&quot;</span> <span class="op">+</span> <span class="st">&quot;=&quot;</span> <span class="op">*</span> <span class="dv">84</span>)</span>
-<span id="cb108-277"><a href="#cb108-277" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;  WAS MAN DARAUS MITNIMMT&quot;</span>)</span>
-<span id="cb108-278"><a href="#cb108-278" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;=&quot;</span> <span class="op">*</span> <span class="dv">84</span>)</span>
-<span id="cb108-279"><a href="#cb108-279" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;1. Der Perspektivwechsel ist die eigentliche Arbeit: nicht &#39;welches&quot;</span>)</span>
-<span id="cb108-280"><a href="#cb108-280" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;   Stueck wohin&#39;, sondern &#39;wie oft welches Muster&#39;. Damit verschwindet&quot;</span>)</span>
-<span id="cb108-281"><a href="#cb108-281" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;   die Symmetrie, die das naheliegende Modell unloesbar macht.&quot;</span>)</span>
-<span id="cb108-282"><a href="#cb108-282" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;2. Der Preis dafuer ist eine unaufschreibbare Zahl von Variablen. Die&quot;</span>)</span>
-<span id="cb108-283"><a href="#cb108-283" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;   Spaltengenerierung zahlt ihn nicht, sondern erzeugt nur die wenigen&quot;</span>)</span>
-<span id="cb108-284"><a href="#cb108-284" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;   Spalten, die die Dualwerte als lohnend ausweisen.&quot;</span>)</span>
-<span id="cb108-285"><a href="#cb108-285" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;3. Das Teilproblem ist ein Rucksack - ein Verfahren, das die Leser&quot;</span>)</span>
-<span id="cb108-286"><a href="#cb108-286" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;   dieses Buchs schon kennen. Neu ist allein die Schleife.&quot;</span>)</span>
-<span id="cb108-287"><a href="#cb108-287" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;4. Und die unbequeme Erkenntnis: Ob sich das alles lohnt, entscheidet&quot;</span>)</span>
-<span id="cb108-288"><a href="#cb108-288" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;   die Instanz, nicht die Methode. Bei sechs Stuecken je Rolle ist die&quot;</span>)</span>
-<span id="cb108-289"><a href="#cb108-289" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;   Faustregel so gut wie das Optimum - und der Ertrag der&quot;</span>)</span>
-<span id="cb108-290"><a href="#cb108-290" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;   Spaltengenerierung liegt dann allein in der SCHRANKE, die beweist,&quot;</span>)</span>
-<span id="cb108-291"><a href="#cb108-291" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;   dass man aufhoeren kann zu suchen.&quot;</span>)</span>
-<span id="cb108-292"><a href="#cb108-292" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;=&quot;</span> <span class="op">*</span> <span class="dv">84</span>)</span></code></pre></div>
+<div class="sourceCode" id="cb110"><pre class="sourceCode python"><code class="sourceCode python"><span id="cb110-1"><a href="#cb110-1" aria-hidden="true" tabindex="-1"></a><span class="co">#!/usr/bin/env python3</span></span>
+<span id="cb110-2"><a href="#cb110-2" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb110-3"><a href="#cb110-3" aria-hidden="true" tabindex="-1"></a><span class="co"># Spaltengenerierung.py</span></span>
+<span id="cb110-4"><a href="#cb110-4" aria-hidden="true" tabindex="-1"></a><span class="co">&quot;&quot;&quot;</span></span>
+<span id="cb110-5"><a href="#cb110-5" aria-hidden="true" tabindex="-1"></a><span class="co">Kapitel Dekomposition: Das Modell umbauen, statt die Loesung zu raten.</span></span>
+<span id="cb110-6"><a href="#cb110-6" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb110-7"><a href="#cb110-7" aria-hidden="true" tabindex="-1"></a><span class="co">Eine Papierfabrik liefert Rollen von 5.600 mm Breite. Die Kunden bestellen</span></span>
+<span id="cb110-8"><a href="#cb110-8" aria-hidden="true" tabindex="-1"></a><span class="co">schmalere Breiten, und aus jeder Mutterrolle werden mehrere davon geschnitten.</span></span>
+<span id="cb110-9"><a href="#cb110-9" aria-hidden="true" tabindex="-1"></a><span class="co">Gesucht ist der Schnittplan, der mit den wenigsten Mutterrollen auskommt.</span></span>
+<span id="cb110-10"><a href="#cb110-10" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb110-11"><a href="#cb110-11" aria-hidden="true" tabindex="-1"></a><span class="co">Der naheliegende Modellansatz - &quot;welches Stueck kommt auf welche Rolle?&quot; -</span></span>
+<span id="cb110-12"><a href="#cb110-12" aria-hidden="true" tabindex="-1"></a><span class="co">fuehrt in eine Sackgasse: Er braucht eine Binaervariable je Stueck-und-Rolle,</span></span>
+<span id="cb110-13"><a href="#cb110-13" aria-hidden="true" tabindex="-1"></a><span class="co">und weil alle Rollen gleich sind, ist er hochgradig symmetrisch. Der Solver</span></span>
+<span id="cb110-14"><a href="#cb110-14" aria-hidden="true" tabindex="-1"></a><span class="co">probiert dieselbe Loesung in tausend Umbenennungen durch.</span></span>
+<span id="cb110-15"><a href="#cb110-15" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb110-16"><a href="#cb110-16" aria-hidden="true" tabindex="-1"></a><span class="co">Die Spaltengenerierung dreht die Frage um:</span></span>
+<span id="cb110-17"><a href="#cb110-17" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb110-18"><a href="#cb110-18" aria-hidden="true" tabindex="-1"></a><span class="co">    Nicht &quot;welches Stueck auf welche Rolle&quot;,</span></span>
+<span id="cb110-19"><a href="#cb110-19" aria-hidden="true" tabindex="-1"></a><span class="co">    sondern &quot;wie oft schneide ich welches MUSTER&quot;.</span></span>
+<span id="cb110-20"><a href="#cb110-20" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb110-21"><a href="#cb110-21" aria-hidden="true" tabindex="-1"></a><span class="co">Damit verschwindet die Symmetrie - aber es entsteht ein neues Problem: Die Zahl</span></span>
+<span id="cb110-22"><a href="#cb110-22" aria-hidden="true" tabindex="-1"></a><span class="co">der moeglichen Muster waechst kombinatorisch. Man kann sie nicht aufschreiben.</span></span>
+<span id="cb110-23"><a href="#cb110-23" aria-hidden="true" tabindex="-1"></a><span class="co">Der Trick besteht darin, sie auch nicht aufzuschreiben, sondern nur die wenigen</span></span>
+<span id="cb110-24"><a href="#cb110-24" aria-hidden="true" tabindex="-1"></a><span class="co">zu erzeugen, die tatsaechlich gebraucht werden - und zwar mit Hilfe der</span></span>
+<span id="cb110-25"><a href="#cb110-25" aria-hidden="true" tabindex="-1"></a><span class="co">Schattenpreise aus dem Kapitel LP.</span></span>
+<span id="cb110-26"><a href="#cb110-26" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb110-27"><a href="#cb110-27" aria-hidden="true" tabindex="-1"></a><span class="co">Das Programm zeigt vier Dinge:</span></span>
+<span id="cb110-28"><a href="#cb110-28" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb110-29"><a href="#cb110-29" aria-hidden="true" tabindex="-1"></a><span class="co">  1. Die beiden Formulierungen desselben Problems und ihre Groesse.</span></span>
+<span id="cb110-30"><a href="#cb110-30" aria-hidden="true" tabindex="-1"></a><span class="co">  2. Wie schnell die Musterzahl waechst - und wie wenige davon genuegen.</span></span>
+<span id="cb110-31"><a href="#cb110-31" aria-hidden="true" tabindex="-1"></a><span class="co">  3. Die Schleife selbst: Master-LP, Dualwerte, Rucksack, neue Spalte.</span></span>
+<span id="cb110-32"><a href="#cb110-32" aria-hidden="true" tabindex="-1"></a><span class="co">  4. Wann sich der Aufwand lohnt und wann nicht. Die Antwort haengt an einer</span></span>
+<span id="cb110-33"><a href="#cb110-33" aria-hidden="true" tabindex="-1"></a><span class="co">     einzigen Kennzahl der Instanz, und sie erklaert nebenbei, warum eine</span></span>
+<span id="cb110-34"><a href="#cb110-34" aria-hidden="true" tabindex="-1"></a><span class="co">     Faustregel bei manchen Zuschnittproblemen schon optimal ist.</span></span>
+<span id="cb110-35"><a href="#cb110-35" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb110-36"><a href="#cb110-36" aria-hidden="true" tabindex="-1"></a><span class="co">Benoetigt: numpy, scipy</span></span>
+<span id="cb110-37"><a href="#cb110-37" aria-hidden="true" tabindex="-1"></a><span class="co">&quot;&quot;&quot;</span></span>
+<span id="cb110-38"><a href="#cb110-38" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb110-39"><a href="#cb110-39" aria-hidden="true" tabindex="-1"></a><span class="im">from</span> __future__ <span class="im">import</span> annotations</span>
+<span id="cb110-40"><a href="#cb110-40" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb110-41"><a href="#cb110-41" aria-hidden="true" tabindex="-1"></a><span class="im">import</span> numpy <span class="im">as</span> np</span>
+<span id="cb110-42"><a href="#cb110-42" aria-hidden="true" tabindex="-1"></a><span class="im">from</span> scipy.optimize <span class="im">import</span> linprog</span>
+<span id="cb110-43"><a href="#cb110-43" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb110-44"><a href="#cb110-44" aria-hidden="true" tabindex="-1"></a>ROLLENBREITE <span class="op">=</span> <span class="dv">5600</span></span>
+<span id="cb110-45"><a href="#cb110-45" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb110-46"><a href="#cb110-46" aria-hidden="true" tabindex="-1"></a><span class="co"># Zwei Instanzen mit demselben Bedarf, aber verschiedenen Breiten. Der</span></span>
+<span id="cb110-47"><a href="#cb110-47" aria-hidden="true" tabindex="-1"></a><span class="co"># Unterschied ist die eine Kennzahl, um die es in Teil 4 geht.</span></span>
+<span id="cb110-48"><a href="#cb110-48" aria-hidden="true" tabindex="-1"></a>BEDARF <span class="op">=</span> [<span class="dv">22</span>, <span class="dv">25</span>, <span class="dv">12</span>, <span class="dv">14</span>, <span class="dv">18</span>, <span class="dv">18</span>, <span class="dv">20</span>, <span class="dv">10</span>, <span class="dv">12</span>, <span class="dv">14</span>, <span class="dv">16</span>, <span class="dv">18</span>, <span class="dv">20</span>]</span>
+<span id="cb110-49"><a href="#cb110-49" aria-hidden="true" tabindex="-1"></a>BREIT <span class="op">=</span> [<span class="dv">1380</span>, <span class="dv">1520</span>, <span class="dv">1560</span>, <span class="dv">1710</span>, <span class="dv">1820</span>, <span class="dv">1880</span>, <span class="dv">1930</span>, <span class="dv">2000</span>, <span class="dv">2050</span>, <span class="dv">2100</span>, <span class="dv">2140</span>,</span>
+<span id="cb110-50"><a href="#cb110-50" aria-hidden="true" tabindex="-1"></a>         <span class="dv">2150</span>, <span class="dv">2200</span>]</span>
+<span id="cb110-51"><a href="#cb110-51" aria-hidden="true" tabindex="-1"></a>SCHMAL <span class="op">=</span> [<span class="dv">380</span>, <span class="dv">520</span>, <span class="dv">560</span>, <span class="dv">710</span>, <span class="dv">820</span>, <span class="dv">880</span>, <span class="dv">930</span>, <span class="dv">1000</span>, <span class="dv">1050</span>, <span class="dv">1100</span>, <span class="dv">1140</span>,</span>
+<span id="cb110-52"><a href="#cb110-52" aria-hidden="true" tabindex="-1"></a>          <span class="dv">1150</span>, <span class="dv">1200</span>]</span>
+<span id="cb110-53"><a href="#cb110-53" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb110-54"><a href="#cb110-54" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb110-55"><a href="#cb110-55" aria-hidden="true" tabindex="-1"></a><span class="co"># --- Die Musterzahl ---------------------------------------------------------</span></span>
+<span id="cb110-56"><a href="#cb110-56" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb110-57"><a href="#cb110-57" aria-hidden="true" tabindex="-1"></a><span class="kw">def</span> zaehle_muster(breiten, rollenbreite: <span class="bu">int</span> <span class="op">=</span> ROLLENBREITE) <span class="op">-&gt;</span> <span class="bu">int</span>:</span>
+<span id="cb110-58"><a href="#cb110-58" aria-hidden="true" tabindex="-1"></a>    <span class="co">&quot;&quot;&quot;Wie viele zulaessige Schnittmuster gibt es ueberhaupt?</span></span>
+<span id="cb110-59"><a href="#cb110-59" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb110-60"><a href="#cb110-60" aria-hidden="true" tabindex="-1"></a><span class="co">    Nur zum Zeigen - in einem produktiven Programm wuerde man das nie</span></span>
+<span id="cb110-61"><a href="#cb110-61" aria-hidden="true" tabindex="-1"></a><span class="co">    ausrechnen, weil die Zahl bei realistischen Instanzen jede Vorstellung</span></span>
+<span id="cb110-62"><a href="#cb110-62" aria-hidden="true" tabindex="-1"></a><span class="co">    sprengt. Genau das ist der Punkt.</span></span>
+<span id="cb110-63"><a href="#cb110-63" aria-hidden="true" tabindex="-1"></a><span class="co">    &quot;&quot;&quot;</span></span>
+<span id="cb110-64"><a href="#cb110-64" aria-hidden="true" tabindex="-1"></a>    speicher: <span class="bu">dict</span>[<span class="bu">tuple</span>[<span class="bu">int</span>, <span class="bu">int</span>], <span class="bu">int</span>] <span class="op">=</span> {}</span>
+<span id="cb110-65"><a href="#cb110-65" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb110-66"><a href="#cb110-66" aria-hidden="true" tabindex="-1"></a>    <span class="kw">def</span> ab(i: <span class="bu">int</span>, rest: <span class="bu">int</span>) <span class="op">-&gt;</span> <span class="bu">int</span>:</span>
+<span id="cb110-67"><a href="#cb110-67" aria-hidden="true" tabindex="-1"></a>        <span class="cf">if</span> i <span class="op">==</span> <span class="bu">len</span>(breiten):</span>
+<span id="cb110-68"><a href="#cb110-68" aria-hidden="true" tabindex="-1"></a>            <span class="cf">return</span> <span class="dv">1</span></span>
+<span id="cb110-69"><a href="#cb110-69" aria-hidden="true" tabindex="-1"></a>        <span class="cf">if</span> (i, rest) <span class="kw">in</span> speicher:</span>
+<span id="cb110-70"><a href="#cb110-70" aria-hidden="true" tabindex="-1"></a>            <span class="cf">return</span> speicher[(i, rest)]</span>
+<span id="cb110-71"><a href="#cb110-71" aria-hidden="true" tabindex="-1"></a>        summe <span class="op">=</span> <span class="bu">sum</span>(ab(i <span class="op">+</span> <span class="dv">1</span>, rest <span class="op">-</span> anzahl <span class="op">*</span> breiten[i])</span>
+<span id="cb110-72"><a href="#cb110-72" aria-hidden="true" tabindex="-1"></a>                    <span class="cf">for</span> anzahl <span class="kw">in</span> <span class="bu">range</span>(rest <span class="op">//</span> breiten[i] <span class="op">+</span> <span class="dv">1</span>))</span>
+<span id="cb110-73"><a href="#cb110-73" aria-hidden="true" tabindex="-1"></a>        speicher[(i, rest)] <span class="op">=</span> summe</span>
+<span id="cb110-74"><a href="#cb110-74" aria-hidden="true" tabindex="-1"></a>        <span class="cf">return</span> summe</span>
+<span id="cb110-75"><a href="#cb110-75" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb110-76"><a href="#cb110-76" aria-hidden="true" tabindex="-1"></a>    <span class="cf">return</span> ab(<span class="dv">0</span>, rollenbreite)</span>
+<span id="cb110-77"><a href="#cb110-77" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb110-78"><a href="#cb110-78" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb110-79"><a href="#cb110-79" aria-hidden="true" tabindex="-1"></a><span class="co"># --- Die beiden Bausteine der Schleife --------------------------------------</span></span>
+<span id="cb110-80"><a href="#cb110-80" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb110-81"><a href="#cb110-81" aria-hidden="true" tabindex="-1"></a><span class="kw">def</span> loese_master(muster, bedarf, ganzzahlig: <span class="bu">bool</span> <span class="op">=</span> <span class="va">False</span>):</span>
+<span id="cb110-82"><a href="#cb110-82" aria-hidden="true" tabindex="-1"></a>    <span class="co">&quot;&quot;&quot;Restringiertes Master: Wie oft schneide ich jedes bekannte Muster?</span></span>
+<span id="cb110-83"><a href="#cb110-83" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb110-84"><a href="#cb110-84" aria-hidden="true" tabindex="-1"></a><span class="co">        min  sum_p x_p           unter   sum_p a_ip * x_p &gt;= bedarf_i</span></span>
+<span id="cb110-85"><a href="#cb110-85" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb110-86"><a href="#cb110-86" aria-hidden="true" tabindex="-1"></a><span class="co">    Als LP gerechnet liefert es zusaetzlich die DUALWERTE - und die sind der</span></span>
+<span id="cb110-87"><a href="#cb110-87" aria-hidden="true" tabindex="-1"></a><span class="co">    eigentliche Ertrag: Der Dualwert zu Breite i sagt, was ein zusaetzliches</span></span>
+<span id="cb110-88"><a href="#cb110-88" aria-hidden="true" tabindex="-1"></a><span class="co">    Stueck dieser Breite an Rollen kostet. Es ist derselbe Schattenpreis wie</span></span>
+<span id="cb110-89"><a href="#cb110-89" aria-hidden="true" tabindex="-1"></a><span class="co">    im Kapitel LP, nur dass er hier nicht berichtet, sondern weiterverarbeitet</span></span>
+<span id="cb110-90"><a href="#cb110-90" aria-hidden="true" tabindex="-1"></a><span class="co">    wird.</span></span>
+<span id="cb110-91"><a href="#cb110-91" aria-hidden="true" tabindex="-1"></a><span class="co">    &quot;&quot;&quot;</span></span>
+<span id="cb110-92"><a href="#cb110-92" aria-hidden="true" tabindex="-1"></a>    matrix <span class="op">=</span> <span class="op">-</span>np.array(muster, dtype<span class="op">=</span><span class="bu">float</span>).T        <span class="co"># &gt;= wird zu &lt;= mit Minus</span></span>
+<span id="cb110-93"><a href="#cb110-93" aria-hidden="true" tabindex="-1"></a>    ergebnis <span class="op">=</span> linprog(np.ones(<span class="bu">len</span>(muster)),</span>
+<span id="cb110-94"><a href="#cb110-94" aria-hidden="true" tabindex="-1"></a>                       A_ub<span class="op">=</span>matrix, b_ub<span class="op">=-</span>np.array(bedarf, dtype<span class="op">=</span><span class="bu">float</span>),</span>
+<span id="cb110-95"><a href="#cb110-95" aria-hidden="true" tabindex="-1"></a>                       bounds<span class="op">=</span>(<span class="dv">0</span>, <span class="va">None</span>),</span>
+<span id="cb110-96"><a href="#cb110-96" aria-hidden="true" tabindex="-1"></a>                       integrality<span class="op">=</span>(<span class="dv">1</span> <span class="cf">if</span> ganzzahlig <span class="cf">else</span> <span class="dv">0</span>), method<span class="op">=</span><span class="st">&quot;highs&quot;</span>)</span>
+<span id="cb110-97"><a href="#cb110-97" aria-hidden="true" tabindex="-1"></a>    <span class="cf">if</span> <span class="kw">not</span> ergebnis.success:</span>
+<span id="cb110-98"><a href="#cb110-98" aria-hidden="true" tabindex="-1"></a>        <span class="cf">raise</span> <span class="pp">SystemExit</span>(<span class="ss">f&quot;Master nicht loesbar: </span><span class="sc">{</span>ergebnis<span class="sc">.</span>message<span class="sc">}</span><span class="ss">&quot;</span>)</span>
+<span id="cb110-99"><a href="#cb110-99" aria-hidden="true" tabindex="-1"></a>    dual <span class="op">=</span> <span class="va">None</span> <span class="cf">if</span> ganzzahlig <span class="cf">else</span> <span class="op">-</span>ergebnis.ineqlin.marginals</span>
+<span id="cb110-100"><a href="#cb110-100" aria-hidden="true" tabindex="-1"></a>    <span class="cf">return</span> ergebnis.fun, ergebnis.x, dual</span>
+<span id="cb110-101"><a href="#cb110-101" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb110-102"><a href="#cb110-102" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb110-103"><a href="#cb110-103" aria-hidden="true" tabindex="-1"></a><span class="kw">def</span> bestes_neues_muster(dual, breiten, rollenbreite: <span class="bu">int</span> <span class="op">=</span> ROLLENBREITE):</span>
+<span id="cb110-104"><a href="#cb110-104" aria-hidden="true" tabindex="-1"></a>    <span class="co">&quot;&quot;&quot;Pricing: Gibt es ein Muster, das sich noch lohnt?</span></span>
+<span id="cb110-105"><a href="#cb110-105" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb110-106"><a href="#cb110-106" aria-hidden="true" tabindex="-1"></a><span class="co">    Gesucht ist das Muster mit dem groessten Gesamtwert zu den aktuellen</span></span>
+<span id="cb110-107"><a href="#cb110-107" aria-hidden="true" tabindex="-1"></a><span class="co">    Schattenpreisen - unter der Bedingung, dass es in die Rolle passt. Das ist</span></span>
+<span id="cb110-108"><a href="#cb110-108" aria-hidden="true" tabindex="-1"></a><span class="co">    ein RUCKSACKPROBLEM (Kapitel MILP, Rucksack.py): Preise sind der Nutzen,</span></span>
+<span id="cb110-109"><a href="#cb110-109" aria-hidden="true" tabindex="-1"></a><span class="co">    Breiten das Gewicht, die Rollenbreite die Kapazitaet. Hier mit dynamischer</span></span>
+<span id="cb110-110"><a href="#cb110-110" aria-hidden="true" tabindex="-1"></a><span class="co">    Programmierung geloest, weil die Breiten ganzzahlig sind.</span></span>
+<span id="cb110-111"><a href="#cb110-111" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb110-112"><a href="#cb110-112" aria-hidden="true" tabindex="-1"></a><span class="co">    Bei Gleichstand wird bewusst der KLEINSTE Index bevorzugt (&gt;-Vergleich mit</span></span>
+<span id="cb110-113"><a href="#cb110-113" aria-hidden="true" tabindex="-1"></a><span class="co">    Toleranz statt &gt;=). Sonst haengt das erzeugte Muster von der Reihenfolge</span></span>
+<span id="cb110-114"><a href="#cb110-114" aria-hidden="true" tabindex="-1"></a><span class="co">    der Gleitkommaoperationen ab, und das Programm liefert von Lauf zu Lauf</span></span>
+<span id="cb110-115"><a href="#cb110-115" aria-hidden="true" tabindex="-1"></a><span class="co">    verschiedene Ausgaben.</span></span>
+<span id="cb110-116"><a href="#cb110-116" aria-hidden="true" tabindex="-1"></a><span class="co">    &quot;&quot;&quot;</span></span>
+<span id="cb110-117"><a href="#cb110-117" aria-hidden="true" tabindex="-1"></a>    wert <span class="op">=</span> np.zeros(rollenbreite <span class="op">+</span> <span class="dv">1</span>)</span>
+<span id="cb110-118"><a href="#cb110-118" aria-hidden="true" tabindex="-1"></a>    herkunft <span class="op">=</span> [<span class="op">-</span><span class="dv">1</span>] <span class="op">*</span> (rollenbreite <span class="op">+</span> <span class="dv">1</span>)</span>
+<span id="cb110-119"><a href="#cb110-119" aria-hidden="true" tabindex="-1"></a>    <span class="cf">for</span> platz <span class="kw">in</span> <span class="bu">range</span>(rollenbreite <span class="op">+</span> <span class="dv">1</span>):</span>
+<span id="cb110-120"><a href="#cb110-120" aria-hidden="true" tabindex="-1"></a>        <span class="cf">for</span> i, breite <span class="kw">in</span> <span class="bu">enumerate</span>(breiten):</span>
+<span id="cb110-121"><a href="#cb110-121" aria-hidden="true" tabindex="-1"></a>            <span class="cf">if</span> breite <span class="op">&lt;=</span> platz <span class="kw">and</span> wert[platz <span class="op">-</span> breite] <span class="op">+</span> dual[i] <span class="op">&gt;</span> wert[platz] <span class="op">+</span> <span class="fl">1e-9</span>:</span>
+<span id="cb110-122"><a href="#cb110-122" aria-hidden="true" tabindex="-1"></a>                wert[platz] <span class="op">=</span> wert[platz <span class="op">-</span> breite] <span class="op">+</span> dual[i]</span>
+<span id="cb110-123"><a href="#cb110-123" aria-hidden="true" tabindex="-1"></a>                herkunft[platz] <span class="op">=</span> i</span>
+<span id="cb110-124"><a href="#cb110-124" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb110-125"><a href="#cb110-125" aria-hidden="true" tabindex="-1"></a>    muster <span class="op">=</span> [<span class="dv">0</span>] <span class="op">*</span> <span class="bu">len</span>(breiten)</span>
+<span id="cb110-126"><a href="#cb110-126" aria-hidden="true" tabindex="-1"></a>    platz <span class="op">=</span> rollenbreite</span>
+<span id="cb110-127"><a href="#cb110-127" aria-hidden="true" tabindex="-1"></a>    <span class="cf">while</span> herkunft[platz] <span class="op">&gt;=</span> <span class="dv">0</span>:</span>
+<span id="cb110-128"><a href="#cb110-128" aria-hidden="true" tabindex="-1"></a>        i <span class="op">=</span> herkunft[platz]</span>
+<span id="cb110-129"><a href="#cb110-129" aria-hidden="true" tabindex="-1"></a>        muster[i] <span class="op">+=</span> <span class="dv">1</span></span>
+<span id="cb110-130"><a href="#cb110-130" aria-hidden="true" tabindex="-1"></a>        platz <span class="op">-=</span> breiten[i]</span>
+<span id="cb110-131"><a href="#cb110-131" aria-hidden="true" tabindex="-1"></a>    <span class="cf">return</span> <span class="bu">float</span>(wert[rollenbreite]), muster</span>
+<span id="cb110-132"><a href="#cb110-132" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb110-133"><a href="#cb110-133" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb110-134"><a href="#cb110-134" aria-hidden="true" tabindex="-1"></a><span class="kw">def</span> spaltengenerierung(breiten, bedarf, rollenbreite: <span class="bu">int</span> <span class="op">=</span> ROLLENBREITE):</span>
+<span id="cb110-135"><a href="#cb110-135" aria-hidden="true" tabindex="-1"></a>    <span class="co">&quot;&quot;&quot;Die Schleife. Startbasis: je ein Muster mit nur einer Breite.</span></span>
+<span id="cb110-136"><a href="#cb110-136" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb110-137"><a href="#cb110-137" aria-hidden="true" tabindex="-1"></a><span class="co">    Abbruch, wenn kein Muster mehr einen Wert ueber 1 hat: Eine zusaetzliche</span></span>
+<span id="cb110-138"><a href="#cb110-138" aria-hidden="true" tabindex="-1"></a><span class="co">    Rolle kostet 1, also lohnt sich ein neues Muster nur, wenn es zu den</span></span>
+<span id="cb110-139"><a href="#cb110-139" aria-hidden="true" tabindex="-1"></a><span class="co">    aktuellen Preisen mehr als 1 wert ist. Das ist das Kriterium der</span></span>
+<span id="cb110-140"><a href="#cb110-140" aria-hidden="true" tabindex="-1"></a><span class="co">    reduzierten Kosten.</span></span>
+<span id="cb110-141"><a href="#cb110-141" aria-hidden="true" tabindex="-1"></a><span class="co">    &quot;&quot;&quot;</span></span>
+<span id="cb110-142"><a href="#cb110-142" aria-hidden="true" tabindex="-1"></a>    anzahl <span class="op">=</span> <span class="bu">len</span>(breiten)</span>
+<span id="cb110-143"><a href="#cb110-143" aria-hidden="true" tabindex="-1"></a>    muster <span class="op">=</span> [[<span class="dv">0</span>] <span class="op">*</span> anzahl <span class="cf">for</span> _ <span class="kw">in</span> <span class="bu">range</span>(anzahl)]</span>
+<span id="cb110-144"><a href="#cb110-144" aria-hidden="true" tabindex="-1"></a>    <span class="cf">for</span> i <span class="kw">in</span> <span class="bu">range</span>(anzahl):</span>
+<span id="cb110-145"><a href="#cb110-145" aria-hidden="true" tabindex="-1"></a>        muster[i][i] <span class="op">=</span> rollenbreite <span class="op">//</span> breiten[i]</span>
+<span id="cb110-146"><a href="#cb110-146" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb110-147"><a href="#cb110-147" aria-hidden="true" tabindex="-1"></a>    runden <span class="op">=</span> <span class="dv">0</span></span>
+<span id="cb110-148"><a href="#cb110-148" aria-hidden="true" tabindex="-1"></a>    <span class="cf">while</span> <span class="va">True</span>:</span>
+<span id="cb110-149"><a href="#cb110-149" aria-hidden="true" tabindex="-1"></a>        zielwert, _, dual <span class="op">=</span> loese_master(muster, bedarf)</span>
+<span id="cb110-150"><a href="#cb110-150" aria-hidden="true" tabindex="-1"></a>        wert, neu <span class="op">=</span> bestes_neues_muster(dual, breiten, rollenbreite)</span>
+<span id="cb110-151"><a href="#cb110-151" aria-hidden="true" tabindex="-1"></a>        runden <span class="op">+=</span> <span class="dv">1</span></span>
+<span id="cb110-152"><a href="#cb110-152" aria-hidden="true" tabindex="-1"></a>        <span class="cf">if</span> wert <span class="op">&lt;=</span> <span class="dv">1</span> <span class="op">+</span> <span class="fl">1e-6</span>:</span>
+<span id="cb110-153"><a href="#cb110-153" aria-hidden="true" tabindex="-1"></a>            <span class="cf">return</span> muster, zielwert, runden</span>
+<span id="cb110-154"><a href="#cb110-154" aria-hidden="true" tabindex="-1"></a>        muster.append(neu)</span>
+<span id="cb110-155"><a href="#cb110-155" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb110-156"><a href="#cb110-156" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb110-157"><a href="#cb110-157" aria-hidden="true" tabindex="-1"></a><span class="kw">def</span> first_fit(breiten, bedarf, rollenbreite: <span class="bu">int</span> <span class="op">=</span> ROLLENBREITE) <span class="op">-&gt;</span> <span class="bu">int</span>:</span>
+<span id="cb110-158"><a href="#cb110-158" aria-hidden="true" tabindex="-1"></a>    <span class="co">&quot;&quot;&quot;Die Faustregel: groesstes Stueck zuerst, auf die erste passende Rolle.&quot;&quot;&quot;</span></span>
+<span id="cb110-159"><a href="#cb110-159" aria-hidden="true" tabindex="-1"></a>    stuecke <span class="op">=</span> <span class="bu">sorted</span>([b <span class="cf">for</span> b, menge <span class="kw">in</span> <span class="bu">zip</span>(breiten, bedarf)</span>
+<span id="cb110-160"><a href="#cb110-160" aria-hidden="true" tabindex="-1"></a>                      <span class="cf">for</span> _ <span class="kw">in</span> <span class="bu">range</span>(menge)], reverse<span class="op">=</span><span class="va">True</span>)</span>
+<span id="cb110-161"><a href="#cb110-161" aria-hidden="true" tabindex="-1"></a>    rollen: <span class="bu">list</span>[<span class="bu">list</span>[<span class="bu">int</span>]] <span class="op">=</span> []</span>
+<span id="cb110-162"><a href="#cb110-162" aria-hidden="true" tabindex="-1"></a>    <span class="cf">for</span> stueck <span class="kw">in</span> stuecke:</span>
+<span id="cb110-163"><a href="#cb110-163" aria-hidden="true" tabindex="-1"></a>        <span class="cf">for</span> rolle <span class="kw">in</span> rollen:</span>
+<span id="cb110-164"><a href="#cb110-164" aria-hidden="true" tabindex="-1"></a>            <span class="cf">if</span> <span class="bu">sum</span>(rolle) <span class="op">+</span> stueck <span class="op">&lt;=</span> rollenbreite:</span>
+<span id="cb110-165"><a href="#cb110-165" aria-hidden="true" tabindex="-1"></a>                rolle.append(stueck)</span>
+<span id="cb110-166"><a href="#cb110-166" aria-hidden="true" tabindex="-1"></a>                <span class="cf">break</span></span>
+<span id="cb110-167"><a href="#cb110-167" aria-hidden="true" tabindex="-1"></a>        <span class="cf">else</span>:</span>
+<span id="cb110-168"><a href="#cb110-168" aria-hidden="true" tabindex="-1"></a>            rollen.append([stueck])</span>
+<span id="cb110-169"><a href="#cb110-169" aria-hidden="true" tabindex="-1"></a>    <span class="cf">return</span> <span class="bu">len</span>(rollen)</span>
+<span id="cb110-170"><a href="#cb110-170" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb110-171"><a href="#cb110-171" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb110-172"><a href="#cb110-172" aria-hidden="true" tabindex="-1"></a><span class="kw">def</span> auswerten(name: <span class="bu">str</span>, breiten, bedarf) <span class="op">-&gt;</span> <span class="bu">dict</span>:</span>
+<span id="cb110-173"><a href="#cb110-173" aria-hidden="true" tabindex="-1"></a>    muster, schranke, runden <span class="op">=</span> spaltengenerierung(breiten, bedarf)</span>
+<span id="cb110-174"><a href="#cb110-174" aria-hidden="true" tabindex="-1"></a>    ganz, _, _ <span class="op">=</span> loese_master(muster, bedarf, ganzzahlig<span class="op">=</span><span class="va">True</span>)</span>
+<span id="cb110-175"><a href="#cb110-175" aria-hidden="true" tabindex="-1"></a>    <span class="cf">return</span> {<span class="st">&quot;name&quot;</span>: name, <span class="st">&quot;muster_gesamt&quot;</span>: zaehle_muster(breiten),</span>
+<span id="cb110-176"><a href="#cb110-176" aria-hidden="true" tabindex="-1"></a>            <span class="st">&quot;muster_erzeugt&quot;</span>: <span class="bu">len</span>(muster), <span class="st">&quot;runden&quot;</span>: runden,</span>
+<span id="cb110-177"><a href="#cb110-177" aria-hidden="true" tabindex="-1"></a>            <span class="st">&quot;schranke&quot;</span>: schranke, <span class="st">&quot;ganzzahlig&quot;</span>: <span class="bu">int</span>(<span class="bu">round</span>(ganz)),</span>
+<span id="cb110-178"><a href="#cb110-178" aria-hidden="true" tabindex="-1"></a>            <span class="st">&quot;first_fit&quot;</span>: first_fit(breiten, bedarf),</span>
+<span id="cb110-179"><a href="#cb110-179" aria-hidden="true" tabindex="-1"></a>            <span class="st">&quot;stuecke_je_rolle&quot;</span>: ROLLENBREITE <span class="op">/</span> np.mean(breiten)}</span>
+<span id="cb110-180"><a href="#cb110-180" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb110-181"><a href="#cb110-181" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb110-182"><a href="#cb110-182" aria-hidden="true" tabindex="-1"></a><span class="cf">if</span> <span class="va">__name__</span> <span class="op">==</span> <span class="st">&quot;__main__&quot;</span>:</span>
+<span id="cb110-183"><a href="#cb110-183" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;=&quot;</span> <span class="op">*</span> <span class="dv">84</span>)</span>
+<span id="cb110-184"><a href="#cb110-184" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;  SPALTENGENERIERUNG: NUR DIE MUSTER ERZEUGEN, DIE MAN BRAUCHT&quot;</span>)</span>
+<span id="cb110-185"><a href="#cb110-185" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;=&quot;</span> <span class="op">*</span> <span class="dv">84</span>)</span>
+<span id="cb110-186"><a href="#cb110-186" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;Mutterrolle </span><span class="sc">{</span>ROLLENBREITE<span class="sc">:,}</span><span class="ss"> mm, </span><span class="sc">{</span><span class="bu">len</span>(BREIT)<span class="sc">}</span><span class="ss"> bestellte Breiten, &quot;</span></span>
+<span id="cb110-187"><a href="#cb110-187" aria-hidden="true" tabindex="-1"></a>          <span class="ss">f&quot;</span><span class="sc">{</span><span class="bu">sum</span>(BEDARF)<span class="sc">}</span><span class="ss"> Zuschnitte.</span><span class="ch">\n</span><span class="ss">&quot;</span>)</span>
+<span id="cb110-188"><a href="#cb110-188" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb110-189"><a href="#cb110-189" aria-hidden="true" tabindex="-1"></a>    <span class="co"># --- 1. Zwei Formulierungen ------------------------------------------</span></span>
+<span id="cb110-190"><a href="#cb110-190" aria-hidden="true" tabindex="-1"></a>    stuecke <span class="op">=</span> <span class="bu">sum</span>(BEDARF)</span>
+<span id="cb110-191"><a href="#cb110-191" aria-hidden="true" tabindex="-1"></a>    <span class="co"># Wie viele Rollen braucht man hoechstens? Die Faustregel liefert eine</span></span>
+<span id="cb110-192"><a href="#cb110-192" aria-hidden="true" tabindex="-1"></a>    <span class="co"># brauchbare Obergrenze - mehr Rollen als das wird niemand benoetigen.</span></span>
+<span id="cb110-193"><a href="#cb110-193" aria-hidden="true" tabindex="-1"></a>    rollen_obergrenze <span class="op">=</span> first_fit(BREIT, BEDARF)</span>
+<span id="cb110-194"><a href="#cb110-194" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;1. Zwei Modelle fuer dieselbe Aufgabe</span><span class="ch">\n</span><span class="st">&quot;</span>)</span>
+<span id="cb110-195"><a href="#cb110-195" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;  </span><span class="sc">{</span><span class="st">&#39;Formulierung&#39;</span><span class="sc">:&lt;34}</span><span class="ss"> </span><span class="sc">{</span><span class="st">&#39;Binaervariablen&#39;</span><span class="sc">:&gt;16}</span><span class="ss"> </span><span class="sc">{</span><span class="st">&#39;symmetrisch?&#39;</span><span class="sc">:&gt;16}</span><span class="ss">&quot;</span>)</span>
+<span id="cb110-196"><a href="#cb110-196" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;  &quot;</span> <span class="op">+</span> <span class="st">&quot;-&quot;</span> <span class="op">*</span> <span class="dv">70</span>)</span>
+<span id="cb110-197"><a href="#cb110-197" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;  </span><span class="sc">{</span><span class="st">&#39;Stueck -&gt; Rolle (naheliegend)&#39;</span><span class="sc">:&lt;34}</span><span class="ss"> &quot;</span></span>
+<span id="cb110-198"><a href="#cb110-198" aria-hidden="true" tabindex="-1"></a>          <span class="ss">f&quot;</span><span class="sc">{</span>stuecke <span class="op">*</span> rollen_obergrenze<span class="sc">:&gt;16,}</span><span class="ss"> </span><span class="sc">{</span><span class="st">&#39;ja&#39;</span><span class="sc">:&gt;16}</span><span class="ss">&quot;</span>)</span>
+<span id="cb110-199"><a href="#cb110-199" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;  </span><span class="sc">{</span><span class="st">&#39;wie oft welches Muster&#39;</span><span class="sc">:&lt;34}</span><span class="ss"> &quot;</span></span>
+<span id="cb110-200"><a href="#cb110-200" aria-hidden="true" tabindex="-1"></a>          <span class="ss">f&quot;</span><span class="sc">{</span><span class="st">&#39;eine je Muster&#39;</span><span class="sc">:&gt;16}</span><span class="ss"> </span><span class="sc">{</span><span class="st">&#39;nein&#39;</span><span class="sc">:&gt;16}</span><span class="ss">&quot;</span>)</span>
+<span id="cb110-201"><a href="#cb110-201" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;</span><span class="ch">\n</span><span class="ss">  Der naheliegende Ansatz braucht eine Variable je Stueck und Rolle:&quot;</span>)</span>
+<span id="cb110-202"><a href="#cb110-202" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;  </span><span class="sc">{</span>stuecke<span class="sc">}</span><span class="ss"> Zuschnitte x </span><span class="sc">{</span>rollen_obergrenze<span class="sc">}</span><span class="ss"> Rollen (Obergrenze aus der Faustregel)&quot;</span>)</span>
+<span id="cb110-203"><a href="#cb110-203" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;  = </span><span class="sc">{</span>stuecke <span class="op">*</span> rollen_obergrenze<span class="sc">:,}</span><span class="ss"> Binaervariablen.&quot;</span>)</span>
+<span id="cb110-204"><a href="#cb110-204" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;</span><span class="ch">\n</span><span class="st">  Schlimmer als die Zahl ist die Symmetrie: Alle Mutterrollen sind&quot;</span>)</span>
+<span id="cb110-205"><a href="#cb110-205" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;  gleich, also beschreibt jede Loesung dieselbe Schnittvorschrift in&quot;</span>)</span>
+<span id="cb110-206"><a href="#cb110-206" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;  unzaehligen Umbenennungen. Branch-and-Bound probiert sie einzeln&quot;</span>)</span>
+<span id="cb110-207"><a href="#cb110-207" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;  durch und kommt nicht voran - der Suchbaum waechst, ohne dass sich&quot;</span>)</span>
+<span id="cb110-208"><a href="#cb110-208" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;  die Schranke bewegt.&quot;</span>)</span>
+<span id="cb110-209"><a href="#cb110-209" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;</span><span class="ch">\n</span><span class="st">  Das Mustermodell hat je Muster genau eine Variable und kennt keine&quot;</span>)</span>
+<span id="cb110-210"><a href="#cb110-210" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;  einzelnen Rollen mehr. Damit ist die Symmetrie weg. Sein Problem ist&quot;</span>)</span>
+<span id="cb110-211"><a href="#cb110-211" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;  ein anderes - und zwar das folgende.&quot;</span>)</span>
+<span id="cb110-212"><a href="#cb110-212" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb110-213"><a href="#cb110-213" aria-hidden="true" tabindex="-1"></a>    <span class="co"># --- 2. Die Musterzahl ------------------------------------------------</span></span>
+<span id="cb110-214"><a href="#cb110-214" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;</span><span class="ch">\n</span><span class="st">&quot;</span> <span class="op">+</span> <span class="st">&quot;-&quot;</span> <span class="op">*</span> <span class="dv">84</span>)</span>
+<span id="cb110-215"><a href="#cb110-215" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;2. Warum man die Muster nicht aufschreiben kann</span><span class="ch">\n</span><span class="st">&quot;</span>)</span>
+<span id="cb110-216"><a href="#cb110-216" aria-hidden="true" tabindex="-1"></a>    gross <span class="op">=</span> auswerten(<span class="st">&quot;breite Zuschnitte (1.380-2.200 mm)&quot;</span>, BREIT, BEDARF)</span>
+<span id="cb110-217"><a href="#cb110-217" aria-hidden="true" tabindex="-1"></a>    schmal <span class="op">=</span> auswerten(<span class="st">&quot;schmale Zuschnitte (380-1.200 mm)&quot;</span>, SCHMAL, BEDARF)</span>
+<span id="cb110-218"><a href="#cb110-218" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb110-219"><a href="#cb110-219" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;  </span><span class="sc">{</span><span class="st">&#39;Instanz&#39;</span><span class="sc">:&lt;36}</span><span class="ss"> </span><span class="sc">{</span><span class="st">&#39;Muster&#39;</span><span class="sc">:&gt;12}</span><span class="ss"> </span><span class="sc">{</span><span class="st">&#39;davon erzeugt&#39;</span><span class="sc">:&gt;14}</span><span class="ss"> </span><span class="sc">{</span><span class="st">&#39;Anteil&#39;</span><span class="sc">:&gt;9}</span><span class="ss">&quot;</span>)</span>
+<span id="cb110-220"><a href="#cb110-220" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;  &quot;</span> <span class="op">+</span> <span class="st">&quot;-&quot;</span> <span class="op">*</span> <span class="dv">76</span>)</span>
+<span id="cb110-221"><a href="#cb110-221" aria-hidden="true" tabindex="-1"></a>    <span class="cf">for</span> fall <span class="kw">in</span> (gross, schmal):</span>
+<span id="cb110-222"><a href="#cb110-222" aria-hidden="true" tabindex="-1"></a>        anteil <span class="op">=</span> fall[<span class="st">&quot;muster_erzeugt&quot;</span>] <span class="op">/</span> fall[<span class="st">&quot;muster_gesamt&quot;</span>]</span>
+<span id="cb110-223"><a href="#cb110-223" aria-hidden="true" tabindex="-1"></a>        <span class="bu">print</span>(<span class="ss">f&quot;  </span><span class="sc">{</span>fall[<span class="st">&#39;name&#39;</span>]<span class="sc">:&lt;36}</span><span class="ss"> </span><span class="sc">{</span>fall[<span class="st">&#39;muster_gesamt&#39;</span>]<span class="sc">:&gt;12,}</span><span class="ss"> &quot;</span></span>
+<span id="cb110-224"><a href="#cb110-224" aria-hidden="true" tabindex="-1"></a>              <span class="ss">f&quot;</span><span class="sc">{</span>fall[<span class="st">&#39;muster_erzeugt&#39;</span>]<span class="sc">:&gt;14}</span><span class="ss"> </span><span class="sc">{</span>anteil<span class="sc">:&gt;8.1%}</span><span class="ss">&quot;</span>)</span>
+<span id="cb110-225"><a href="#cb110-225" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb110-226"><a href="#cb110-226" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;</span><span class="ch">\n</span><span class="ss">  Schon das Halbieren der Breiten laesst die Musterzahl von &quot;</span></span>
+<span id="cb110-227"><a href="#cb110-227" aria-hidden="true" tabindex="-1"></a>          <span class="ss">f&quot;</span><span class="sc">{</span>gross[<span class="st">&#39;muster_gesamt&#39;</span>]<span class="sc">:,}</span><span class="ss"> auf&quot;</span>)</span>
+<span id="cb110-228"><a href="#cb110-228" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;  </span><span class="sc">{</span>schmal[<span class="st">&#39;muster_gesamt&#39;</span>]<span class="sc">:,}</span><span class="ss"> springen - Faktor &quot;</span></span>
+<span id="cb110-229"><a href="#cb110-229" aria-hidden="true" tabindex="-1"></a>          <span class="ss">f&quot;</span><span class="sc">{</span>schmal[<span class="st">&#39;muster_gesamt&#39;</span>] <span class="op">/</span> gross[<span class="st">&#39;muster_gesamt&#39;</span>]<span class="sc">:.0f}</span><span class="ss">. Bei einer echten &quot;</span></span>
+<span id="cb110-230"><a href="#cb110-230" aria-hidden="true" tabindex="-1"></a>          <span class="ss">f&quot;Papierfabrik mit&quot;</span>)</span>
+<span id="cb110-231"><a href="#cb110-231" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;  vierzig Breiten und Millimeterschritten sind es mehr, als sich&quot;</span>)</span>
+<span id="cb110-232"><a href="#cb110-232" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;  speichern liesse.&quot;</span>)</span>
+<span id="cb110-233"><a href="#cb110-233" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;</span><span class="ch">\n</span><span class="ss">  Gebraucht werden davon </span><span class="sc">{</span>schmal[<span class="st">&#39;muster_erzeugt&#39;</span>]<span class="sc">}</span><span class="ss"> - &quot;</span></span>
+<span id="cb110-234"><a href="#cb110-234" aria-hidden="true" tabindex="-1"></a>          <span class="ss">f&quot;</span><span class="sc">{</span>schmal[<span class="st">&#39;muster_erzeugt&#39;</span>] <span class="op">/</span> schmal[<span class="st">&#39;muster_gesamt&#39;</span>]<span class="sc">:.2%}</span><span class="ss"> der Gesamtzahl.&quot;</span>)</span>
+<span id="cb110-235"><a href="#cb110-235" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb110-236"><a href="#cb110-236" aria-hidden="true" tabindex="-1"></a>    <span class="co"># --- 3. Die Schleife --------------------------------------------------</span></span>
+<span id="cb110-237"><a href="#cb110-237" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;</span><span class="ch">\n</span><span class="st">&quot;</span> <span class="op">+</span> <span class="st">&quot;-&quot;</span> <span class="op">*</span> <span class="dv">84</span>)</span>
+<span id="cb110-238"><a href="#cb110-238" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;3. Die Schleife an der breiten Instanz</span><span class="ch">\n</span><span class="st">&quot;</span>)</span>
+<span id="cb110-239"><a href="#cb110-239" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;  Startbasis: </span><span class="sc">{</span><span class="bu">len</span>(BREIT)<span class="sc">}</span><span class="ss"> triviale Muster (je Rolle nur eine Breite)&quot;</span>)</span>
+<span id="cb110-240"><a href="#cb110-240" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;  Runden bis kein Muster mehr lohnt: </span><span class="sc">{</span>gross[<span class="st">&#39;runden&#39;</span>]<span class="sc">}</span><span class="ss">&quot;</span>)</span>
+<span id="cb110-241"><a href="#cb110-241" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;  Muster am Ende: </span><span class="sc">{</span>gross[<span class="st">&#39;muster_erzeugt&#39;</span>]<span class="sc">}</span><span class="ss">&quot;</span>)</span>
+<span id="cb110-242"><a href="#cb110-242" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;  LP-Schranke: </span><span class="sc">{</span>gross[<span class="st">&#39;schranke&#39;</span>]<span class="sc">:.4f}</span><span class="ss"> Rollen&quot;</span>)</span>
+<span id="cb110-243"><a href="#cb110-243" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;</span><span class="ch">\n</span><span class="ss">  Die LP-Schranke ist eine ZUSAGE: Weniger als &quot;</span></span>
+<span id="cb110-244"><a href="#cb110-244" aria-hidden="true" tabindex="-1"></a>          <span class="ss">f&quot;</span><span class="sc">{</span>np<span class="sc">.</span>ceil(gross[<span class="st">&#39;schranke&#39;</span>] <span class="op">-</span> <span class="fl">1e-9</span>)<span class="sc">:.0f}</span><span class="ss"> Rollen sind&quot;</span>)</span>
+<span id="cb110-245"><a href="#cb110-245" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;  nicht moeglich - unabhaengig davon, wie clever man weiterschneidet.&quot;</span>)</span>
+<span id="cb110-246"><a href="#cb110-246" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;  Genau diese Aussage fehlt einer Heuristik (Kapitel Metaheuristiken).&quot;</span>)</span>
+<span id="cb110-247"><a href="#cb110-247" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb110-248"><a href="#cb110-248" aria-hidden="true" tabindex="-1"></a>    <span class="co"># --- 4. Wann es sich lohnt --------------------------------------------</span></span>
+<span id="cb110-249"><a href="#cb110-249" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;</span><span class="ch">\n</span><span class="st">&quot;</span> <span class="op">+</span> <span class="st">&quot;-&quot;</span> <span class="op">*</span> <span class="dv">84</span>)</span>
+<span id="cb110-250"><a href="#cb110-250" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;4. Wann sich der Aufwand lohnt - und wann nicht</span><span class="ch">\n</span><span class="st">&quot;</span>)</span>
+<span id="cb110-251"><a href="#cb110-251" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;  </span><span class="sc">{</span><span class="st">&#39;Instanz&#39;</span><span class="sc">:&lt;36}</span><span class="ss"> </span><span class="sc">{</span><span class="st">&#39;Faustregel&#39;</span><span class="sc">:&gt;11}</span><span class="ss"> </span><span class="sc">{</span><span class="st">&#39;exakt&#39;</span><span class="sc">:&gt;8}</span><span class="ss"> </span><span class="sc">{</span><span class="st">&#39;Schranke&#39;</span><span class="sc">:&gt;10}</span><span class="ss"> &quot;</span></span>
+<span id="cb110-252"><a href="#cb110-252" aria-hidden="true" tabindex="-1"></a>          <span class="ss">f&quot;</span><span class="sc">{</span><span class="st">&#39;Ersparnis&#39;</span><span class="sc">:&gt;11}</span><span class="ss">&quot;</span>)</span>
+<span id="cb110-253"><a href="#cb110-253" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;  &quot;</span> <span class="op">+</span> <span class="st">&quot;-&quot;</span> <span class="op">*</span> <span class="dv">80</span>)</span>
+<span id="cb110-254"><a href="#cb110-254" aria-hidden="true" tabindex="-1"></a>    <span class="cf">for</span> fall <span class="kw">in</span> (gross, schmal):</span>
+<span id="cb110-255"><a href="#cb110-255" aria-hidden="true" tabindex="-1"></a>        ersparnis <span class="op">=</span> (fall[<span class="st">&quot;first_fit&quot;</span>] <span class="op">-</span> fall[<span class="st">&quot;ganzzahlig&quot;</span>]) <span class="op">/</span> fall[<span class="st">&quot;first_fit&quot;</span>]</span>
+<span id="cb110-256"><a href="#cb110-256" aria-hidden="true" tabindex="-1"></a>        <span class="bu">print</span>(<span class="ss">f&quot;  </span><span class="sc">{</span>fall[<span class="st">&#39;name&#39;</span>]<span class="sc">:&lt;36}</span><span class="ss"> </span><span class="sc">{</span>fall[<span class="st">&#39;first_fit&#39;</span>]<span class="sc">:&gt;11}</span><span class="ss"> &quot;</span></span>
+<span id="cb110-257"><a href="#cb110-257" aria-hidden="true" tabindex="-1"></a>              <span class="ss">f&quot;</span><span class="sc">{</span>fall[<span class="st">&#39;ganzzahlig&#39;</span>]<span class="sc">:&gt;8}</span><span class="ss"> </span><span class="sc">{</span>fall[<span class="st">&#39;schranke&#39;</span>]<span class="sc">:&gt;10.2f}</span><span class="ss"> &quot;</span></span>
+<span id="cb110-258"><a href="#cb110-258" aria-hidden="true" tabindex="-1"></a>              <span class="ss">f&quot;</span><span class="sc">{</span>ersparnis<span class="sc">:&gt;10.0%}</span><span class="ss">&quot;</span>)</span>
+<span id="cb110-259"><a href="#cb110-259" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb110-260"><a href="#cb110-260" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;</span><span class="ch">\n</span><span class="ss">  Bei den breiten Zuschnitten spart die Spaltengenerierung &quot;</span></span>
+<span id="cb110-261"><a href="#cb110-261" aria-hidden="true" tabindex="-1"></a>          <span class="ss">f&quot;</span><span class="sc">{</span>gross[<span class="st">&#39;first_fit&#39;</span>] <span class="op">-</span> gross[<span class="st">&#39;ganzzahlig&#39;</span>]<span class="sc">}</span><span class="ss"> von&quot;</span>)</span>
+<span id="cb110-262"><a href="#cb110-262" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;  </span><span class="sc">{</span>gross[<span class="st">&#39;first_fit&#39;</span>]<span class="sc">}</span><span class="ss"> Rollen. Bei den schmalen spart sie NICHTS - dort ist die&quot;</span>)</span>
+<span id="cb110-263"><a href="#cb110-263" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;  Faustregel bereits optimal.&quot;</span>)</span>
+<span id="cb110-264"><a href="#cb110-264" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;</span><span class="ch">\n</span><span class="ss">  Der Unterschied haengt an einer einzigen Kennzahl:</span><span class="ch">\n</span><span class="ss">&quot;</span>)</span>
+<span id="cb110-265"><a href="#cb110-265" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;  </span><span class="sc">{</span><span class="st">&#39;Instanz&#39;</span><span class="sc">:&lt;36}</span><span class="ss"> </span><span class="sc">{</span><span class="st">&#39;Stuecke je Rolle (etwa)&#39;</span><span class="sc">:&gt;24}</span><span class="ss">&quot;</span>)</span>
+<span id="cb110-266"><a href="#cb110-266" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;  &quot;</span> <span class="op">+</span> <span class="st">&quot;-&quot;</span> <span class="op">*</span> <span class="dv">62</span>)</span>
+<span id="cb110-267"><a href="#cb110-267" aria-hidden="true" tabindex="-1"></a>    <span class="cf">for</span> fall <span class="kw">in</span> (gross, schmal):</span>
+<span id="cb110-268"><a href="#cb110-268" aria-hidden="true" tabindex="-1"></a>        <span class="bu">print</span>(<span class="ss">f&quot;  </span><span class="sc">{</span>fall[<span class="st">&#39;name&#39;</span>]<span class="sc">:&lt;36}</span><span class="ss"> </span><span class="sc">{</span>fall[<span class="st">&#39;stuecke_je_rolle&#39;</span>]<span class="sc">:&gt;24.1f}</span><span class="ss">&quot;</span>)</span>
+<span id="cb110-269"><a href="#cb110-269" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb110-270"><a href="#cb110-270" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;</span><span class="ch">\n</span><span class="st">  Passen nur zwei bis drei Stuecke auf eine Rolle, entscheidet jede&quot;</span>)</span>
+<span id="cb110-271"><a href="#cb110-271" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;  einzelne Zuordnung viel, und eine kurzsichtige Regel verschenkt&quot;</span>)</span>
+<span id="cb110-272"><a href="#cb110-272" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;  ganze Rollen. Passen sechs oder mehr darauf, gleichen sich die&quot;</span>)</span>
+<span id="cb110-273"><a href="#cb110-273" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;  Fehler aus - die Reste sind klein gegen die Rollenbreite, und die&quot;</span>)</span>
+<span id="cb110-274"><a href="#cb110-274" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;  Faustregel trifft es fast immer.&quot;</span>)</span>
+<span id="cb110-275"><a href="#cb110-275" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb110-276"><a href="#cb110-276" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;</span><span class="ch">\n</span><span class="st">&quot;</span> <span class="op">+</span> <span class="st">&quot;=&quot;</span> <span class="op">*</span> <span class="dv">84</span>)</span>
+<span id="cb110-277"><a href="#cb110-277" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;  WAS MAN DARAUS MITNIMMT&quot;</span>)</span>
+<span id="cb110-278"><a href="#cb110-278" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;=&quot;</span> <span class="op">*</span> <span class="dv">84</span>)</span>
+<span id="cb110-279"><a href="#cb110-279" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;1. Der Perspektivwechsel ist die eigentliche Arbeit: nicht &#39;welches&quot;</span>)</span>
+<span id="cb110-280"><a href="#cb110-280" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;   Stueck wohin&#39;, sondern &#39;wie oft welches Muster&#39;. Damit verschwindet&quot;</span>)</span>
+<span id="cb110-281"><a href="#cb110-281" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;   die Symmetrie, die das naheliegende Modell unloesbar macht.&quot;</span>)</span>
+<span id="cb110-282"><a href="#cb110-282" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;2. Der Preis dafuer ist eine unaufschreibbare Zahl von Variablen. Die&quot;</span>)</span>
+<span id="cb110-283"><a href="#cb110-283" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;   Spaltengenerierung zahlt ihn nicht, sondern erzeugt nur die wenigen&quot;</span>)</span>
+<span id="cb110-284"><a href="#cb110-284" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;   Spalten, die die Dualwerte als lohnend ausweisen.&quot;</span>)</span>
+<span id="cb110-285"><a href="#cb110-285" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;3. Das Teilproblem ist ein Rucksack - ein Verfahren, das die Leser&quot;</span>)</span>
+<span id="cb110-286"><a href="#cb110-286" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;   dieses Buchs schon kennen. Neu ist allein die Schleife.&quot;</span>)</span>
+<span id="cb110-287"><a href="#cb110-287" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;4. Und die unbequeme Erkenntnis: Ob sich das alles lohnt, entscheidet&quot;</span>)</span>
+<span id="cb110-288"><a href="#cb110-288" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;   die Instanz, nicht die Methode. Bei sechs Stuecken je Rolle ist die&quot;</span>)</span>
+<span id="cb110-289"><a href="#cb110-289" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;   Faustregel so gut wie das Optimum - und der Ertrag der&quot;</span>)</span>
+<span id="cb110-290"><a href="#cb110-290" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;   Spaltengenerierung liegt dann allein in der SCHRANKE, die beweist,&quot;</span>)</span>
+<span id="cb110-291"><a href="#cb110-291" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;   dass man aufhoeren kann zu suchen.&quot;</span>)</span>
+<span id="cb110-292"><a href="#cb110-292" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;=&quot;</span> <span class="op">*</span> <span class="dv">84</span>)</span></code></pre></div>
 <p><strong>Erwartete Ausgabe:</strong></p>
 <pre><code>====================================================================================
   SPALTENGENERIERUNG: NUR DIE MUSTER ERZEUGEN, DIE MAN BRAUCHT
@@ -15199,9 +15944,128 @@ Mutterrolle 5,600 mm, 13 bestellte Breiten, 219 Zuschnitte.
 <li>Auch wo es nichts spart, liefert es die <strong>Schranke</strong> — und damit die Erlaubnis, aufzuhören.</li>
 </ul>
 <hr />
+<h1 id="synthese-teil-ii-die-kernverfahren-nebeneinander">Synthese Teil II — Die Kernverfahren nebeneinander</h1>
+<p>Sechs Kapitel, sechs Werkzeuge. Jedes einzelne wurde im Zusammenhang gezeigt; hier stehen sie zum ersten Mal <strong>nebeneinander</strong>, mit der Frage, die vor jedem Projekt zu beantworten ist: Welches nehme ich, und was bekomme ich dafür?</p>
+<h2 id="die-entscheidungsmatrix">Die Entscheidungsmatrix</h2>
+<table>
+<colgroup>
+<col style="width: 20%" />
+<col style="width: 20%" />
+<col style="width: 20%" />
+<col style="width: 20%" />
+<col style="width: 20%" />
+</colgroup>
+<thead>
+<tr class="header">
+<th>Verfahren</th>
+<th>Wofür es gebaut ist</th>
+<th>Was Sie bekommen</th>
+<th>Wo es aufhört</th>
+<th>Kapitel</th>
+</tr>
+</thead>
+<tbody>
+<tr class="odd">
+<td><strong>LP</strong></td>
+<td>teilbare Mengen, lineare Zusammenhänge</td>
+<td>beweisbares Optimum <strong>plus Schattenpreise</strong></td>
+<td>sobald etwas ganzzahlig sein muss</td>
+<td><a href="#kap-lp">Kapitel 5</a></td>
+</tr>
+<tr class="even">
+<td><strong>MILP</strong></td>
+<td>Ja/Nein-Entscheidungen, Fixkosten, Logik</td>
+<td>beweisbares Optimum, Gap als Fortschrittsmaß</td>
+<td>Laufzeit wächst mit der Zahl der Binärvariablen</td>
+<td><a href="#kap-milp">Kapitel 6</a></td>
+</tr>
+<tr class="odd">
+<td><strong>CP-SAT</strong></td>
+<td>Zuweisung, Reihenfolge, Kalender, harte Logik</td>
+<td>beweisbares Optimum, sehr ausdrucksstarke Bedingungen</td>
+<td>keine Schattenpreise, keine stetigen Größen</td>
+<td><a href="#kap-cpsat">Kapitel 7</a></td>
+</tr>
+<tr class="even">
+<td><strong>Graphenalgorithmen</strong></td>
+<td>Flüsse, Zuordnung, Touren</td>
+<td>oft <strong>polynomiell</strong> statt exponentiell</td>
+<td>nur, wenn die Struktur wirklich passt</td>
+<td><a href="#kap-graphen">Kapitel 8</a></td>
+</tr>
+<tr class="odd">
+<td><strong>Metaheuristiken</strong></td>
+<td>wenn der exakte Solver aussteigt</td>
+<td>eine gute Lösung in <strong>fester Zeit</strong></td>
+<td>keine Garantie, kein Beweis, keine Schranke</td>
+<td><a href="#kap-metaheuristiken">Kapitel 9</a></td>
+</tr>
+<tr class="even">
+<td><strong>Spaltengenerierung</strong></td>
+<td>Modelle mit astronomisch vielen Variablen</td>
+<td>beweisbares Optimum über nie erzeugte Spalten</td>
+<td>lohnt nur bei bestimmter Instanzstruktur</td>
+<td><a href="#kap-dekomposition">Kapitel 10</a></td>
+</tr>
+</tbody>
+</table>
+<p><strong>Die Spalte, die am meisten wert ist, ist die vierte.</strong> Ein Verfahren zu kennen heißt zu wissen, wo es aufhört — nicht, wofür es gedacht ist.</p>
+<h2 id="was-dieser-teil-gemessen-hat">Was dieser Teil gemessen hat</h2>
+<table>
+<colgroup>
+<col style="width: 33%" />
+<col style="width: 33%" />
+<col style="width: 33%" />
+</colgroup>
+<thead>
+<tr class="header">
+<th>Behauptung</th>
+<th>Gemessen</th>
+<th>Wo</th>
+</tr>
+</thead>
+<tbody>
+<tr class="odd">
+<td>„Der exakte Solver ist immer besser.”</td>
+<td>Bei 500 Aufträgen liefert CP-SAT eine Lösung, die <strong>5,2 % schlechter</strong> ist als die Faustregel eines Meisters</td>
+<td><a href="#kap-metaheuristiken">Kapitel 9</a></td>
+</tr>
+<tr class="even">
+<td>„Metaheuristiken sind ungenau.”</td>
+<td>Faustregel 2 497 → Annealing 2 343 → Annealing plus LNS <strong>2 289</strong> Minuten Rüstzeit; untere Schranke 1 768</td>
+<td><a href="#kap-metaheuristiken">Kapitel 9</a></td>
+</tr>
+<tr class="odd">
+<td>„Man muss alle Variablen aufschreiben.”</td>
+<td>28 erzeugte Muster von <strong>46 408</strong> möglichen — und die Lösung ist beweisbar optimal</td>
+<td><a href="#kap-dekomposition">Kapitel 10</a></td>
+</tr>
+<tr class="even">
+<td>„Dekomposition lohnt sich immer.”</td>
+<td>Bei drei Stücken je Rolle <strong>11 %</strong> Ersparnis, bei sechs <strong>nichts</strong></td>
+<td><a href="#kap-dekomposition">Kapitel 10</a></td>
+</tr>
+<tr class="odd">
+<td>„Mit Seed ist der Lauf reproduzierbar.”</td>
+<td>Schon <strong>zwei</strong> Arbeiter liefern bei identischem Seed drei verschiedene Pläne zum selben Zielwert</td>
+<td><a href="#sec:cpsat-parallele-suche">Abschnitt 7.7</a></td>
+</tr>
+</tbody>
+</table>
+<h2 id="drei-fehler-die-dieser-teil-verhindert">Drei Fehler, die dieser Teil verhindert</h2>
+<ol type="1">
+<li><strong>Runden.</strong> Die LP-Lösung ist keine Näherung der ganzzahligen Lösung — sie kann beliebig weit danebenliegen, und gerundet sogar unzulässig werden.</li>
+<li><strong>Ein zu großes Big-M.</strong> Es macht das Modell nicht falsch, sondern die Suche langsam und die Schranken wertlos. So klein wie zulässig, nie „sicherheitshalber groß”.</li>
+<li><strong>Zu früh heuristisch werden.</strong> Der Umschlagpunkt, ab dem eine Metaheuristik den exakten Solver schlägt, ist eine Eigenschaft <strong>des Problems</strong> und lässt sich messen. Wer ihn nicht misst, verzichtet auf Optimalitätsgarantien, die er hätte haben können.</li>
+</ol>
+<h2 id="wenn-sie-nur-eines-mitnehmen-1">Wenn Sie nur eines mitnehmen</h2>
+<blockquote>
+<p><strong>🎯</strong> Die Frage lautet nie „welcher Solver ist der beste”, sondern „welche Garantie brauche ich, und was bin ich bereit, dafür an Laufzeit zu zahlen”. Ein Verfahren ohne Schranke liefert eine Lösung; ein Verfahren mit Schranke liefert die Erlaubnis, aufzuhören.</p>
+</blockquote>
+<hr />
 <h1 id="teil-nichtlinear">Teil III: Nichtlinearität, Unsicherheit und mehrperiodige Dynamik</h1>
 <p><a href="#teil-kernverfahren">Teil II</a> ging von festen Daten und linearen Zusammenhängen aus. Beides gilt in der Praxis oft nicht: Risiko wächst <strong>quadratisch</strong> mit dem Einsatz, Nachfrage ist erst morgen bekannt, und eine Entscheidung heute verändert, welche Möglichkeiten übermorgen noch offenstehen.</p>
-<p>Die drei Kapitel dieses Teils behandeln genau diese drei Abweichungen. Welches Werkzeug Sie brauchen, hängt davon ab, <strong>welche</strong> davon bei Ihnen vorliegt:</p>
+<p>Drei Kapitel dieses Teils behandeln genau diese drei Abweichungen. Welches Werkzeug Sie brauchen, hängt davon ab, <strong>welche</strong> davon bei Ihnen vorliegt:</p>
 <figure>
 <img src="bilder_04/teil3_solverwahl.svg" alt="Entscheidungsdiagramm: Welches Werkzeug passt zu meinem Problem? (Teil III)" />
 <figcaption aria-hidden="true">Entscheidungsdiagramm: Welches Werkzeug passt zu meinem Problem? (Teil III)</figcaption>
@@ -15210,6 +16074,7 @@ Mutterrolle 5,600 mm, 13 bestellte Breiten, 219 Zuschnitte.
 <p><strong>🎯 Merksatz zum Diagramm</strong> Die erste Frage trennt zwei Welten, die man nicht vermischen darf. Ist die <strong>Nichtlinearität</strong> das Problem, geht es um Konvexität — und damit darum, ob Sie eine Optimalitätsgarantie bekommen oder nur ein lokales Optimum. Ist die <strong>Unsicherheit</strong> das Problem, geht es um etwas ganz anderes: Nicht der Solver ist die Schwierigkeit, sondern die Frage, was „optimal“ überhaupt heißen soll, wenn man die Daten nicht kennt.</p>
 <p>Der häufigste Fehler an dieser Stelle ist, Unsicherheit durch <strong>Mittelwerte</strong> zu ersetzen und dann deterministisch zu rechnen. Warum das systematisch danebengeht, zeigt <a href="#kap-unsicherheit">Kapitel 12</a> unter dem Namen <em>Fluch des Durchschnitts</em>.</p>
 </blockquote>
+<p>Zwei weitere Kapitel schließen sich an, weil sie dieselbe Voraussetzung aufgeben, nur an einer anderen Stelle: <a href="#kap-mehrziel">Kapitel 14</a> gibt das <strong>eine Ziel</strong> auf, <a href="#kap-prognose">Kapitel 15</a> die Annahme, die <strong>Eingabedaten</strong> seien gegeben statt selbst geschätzt. Was dieser Teil insgesamt leistet, fasst die Synthese an seinem Ende zusammen.</p>
 <hr />
 <h1 id="kap-qp-nlp">Kapitel 11: Quadratische und nichtlineare Optimierung — KKT, Lagrange, Konvexität</h1>
 <blockquote>
@@ -15250,20 +16115,20 @@ Mutterrolle 5,600 mm, 13 bestellte Breiten, 219 Zuschnitte.
 </tbody>
 </table>
 <p>Die beiden bewegen sich <strong>gegenläufig</strong>: Korrelation <span class="math inline">-0{,}40</span>. Wie viel soll in jede?</p>
-<div class="sourceCode" id="cb110"><pre class="sourceCode python"><code class="sourceCode python"><span id="cb110-1"><a href="#cb110-1" aria-hidden="true" tabindex="-1"></a><span class="im">import</span> numpy <span class="im">as</span> np</span>
-<span id="cb110-2"><a href="#cb110-2" aria-hidden="true" tabindex="-1"></a><span class="im">import</span> cvxpy <span class="im">as</span> cp</span>
-<span id="cb110-3"><a href="#cb110-3" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb110-4"><a href="#cb110-4" aria-hidden="true" tabindex="-1"></a>sigma <span class="op">=</span> np.array([<span class="fl">0.12</span>, <span class="fl">0.28</span>])                    <span class="co"># Schwankung je Anlage</span></span>
-<span id="cb110-5"><a href="#cb110-5" aria-hidden="true" tabindex="-1"></a>rho <span class="op">=</span> <span class="op">-</span><span class="fl">0.40</span>                                       <span class="co"># Korrelation</span></span>
-<span id="cb110-6"><a href="#cb110-6" aria-hidden="true" tabindex="-1"></a>S <span class="op">=</span> np.array([[sigma[<span class="dv">0</span>]<span class="op">**</span><span class="dv">2</span>,            rho <span class="op">*</span> sigma[<span class="dv">0</span>] <span class="op">*</span> sigma[<span class="dv">1</span>]],</span>
-<span id="cb110-7"><a href="#cb110-7" aria-hidden="true" tabindex="-1"></a>              [rho <span class="op">*</span> sigma[<span class="dv">0</span>] <span class="op">*</span> sigma[<span class="dv">1</span>], sigma[<span class="dv">1</span>]<span class="op">**</span><span class="dv">2</span>]])</span>
-<span id="cb110-8"><a href="#cb110-8" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb110-9"><a href="#cb110-9" aria-hidden="true" tabindex="-1"></a>w <span class="op">=</span> cp.Variable(<span class="dv">2</span>, nonneg<span class="op">=</span><span class="va">True</span>)                   <span class="co"># Anteile, keine Leerverkäufe</span></span>
-<span id="cb110-10"><a href="#cb110-10" aria-hidden="true" tabindex="-1"></a>problem <span class="op">=</span> cp.Problem(cp.Minimize(cp.quad_form(w, S)), [cp.<span class="bu">sum</span>(w) <span class="op">==</span> <span class="dv">1</span>])</span>
-<span id="cb110-11"><a href="#cb110-11" aria-hidden="true" tabindex="-1"></a>problem.solve()</span>
-<span id="cb110-12"><a href="#cb110-12" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb110-13"><a href="#cb110-13" aria-hidden="true" tabindex="-1"></a><span class="bu">print</span>(<span class="st">&quot;Anteile:&quot;</span>, np.<span class="bu">round</span>(w.value, <span class="dv">3</span>))</span>
-<span id="cb110-14"><a href="#cb110-14" aria-hidden="true" tabindex="-1"></a><span class="bu">print</span>(<span class="ss">f&quot;Risiko der Mischung: </span><span class="sc">{</span>np<span class="sc">.</span>sqrt(problem.value) <span class="op">*</span> <span class="dv">100</span><span class="sc">:.2f}</span><span class="ss"> %&quot;</span>)</span></code></pre></div>
+<div class="sourceCode" id="cb112"><pre class="sourceCode python"><code class="sourceCode python"><span id="cb112-1"><a href="#cb112-1" aria-hidden="true" tabindex="-1"></a><span class="im">import</span> numpy <span class="im">as</span> np</span>
+<span id="cb112-2"><a href="#cb112-2" aria-hidden="true" tabindex="-1"></a><span class="im">import</span> cvxpy <span class="im">as</span> cp</span>
+<span id="cb112-3"><a href="#cb112-3" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb112-4"><a href="#cb112-4" aria-hidden="true" tabindex="-1"></a>sigma <span class="op">=</span> np.array([<span class="fl">0.12</span>, <span class="fl">0.28</span>])                    <span class="co"># Schwankung je Anlage</span></span>
+<span id="cb112-5"><a href="#cb112-5" aria-hidden="true" tabindex="-1"></a>rho <span class="op">=</span> <span class="op">-</span><span class="fl">0.40</span>                                       <span class="co"># Korrelation</span></span>
+<span id="cb112-6"><a href="#cb112-6" aria-hidden="true" tabindex="-1"></a>S <span class="op">=</span> np.array([[sigma[<span class="dv">0</span>]<span class="op">**</span><span class="dv">2</span>,            rho <span class="op">*</span> sigma[<span class="dv">0</span>] <span class="op">*</span> sigma[<span class="dv">1</span>]],</span>
+<span id="cb112-7"><a href="#cb112-7" aria-hidden="true" tabindex="-1"></a>              [rho <span class="op">*</span> sigma[<span class="dv">0</span>] <span class="op">*</span> sigma[<span class="dv">1</span>], sigma[<span class="dv">1</span>]<span class="op">**</span><span class="dv">2</span>]])</span>
+<span id="cb112-8"><a href="#cb112-8" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb112-9"><a href="#cb112-9" aria-hidden="true" tabindex="-1"></a>w <span class="op">=</span> cp.Variable(<span class="dv">2</span>, nonneg<span class="op">=</span><span class="va">True</span>)                   <span class="co"># Anteile, keine Leerverkäufe</span></span>
+<span id="cb112-10"><a href="#cb112-10" aria-hidden="true" tabindex="-1"></a>problem <span class="op">=</span> cp.Problem(cp.Minimize(cp.quad_form(w, S)), [cp.<span class="bu">sum</span>(w) <span class="op">==</span> <span class="dv">1</span>])</span>
+<span id="cb112-11"><a href="#cb112-11" aria-hidden="true" tabindex="-1"></a>problem.solve()</span>
+<span id="cb112-12"><a href="#cb112-12" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb112-13"><a href="#cb112-13" aria-hidden="true" tabindex="-1"></a><span class="bu">print</span>(<span class="st">&quot;Anteile:&quot;</span>, np.<span class="bu">round</span>(w.value, <span class="dv">3</span>))</span>
+<span id="cb112-14"><a href="#cb112-14" aria-hidden="true" tabindex="-1"></a><span class="bu">print</span>(<span class="ss">f&quot;Risiko der Mischung: </span><span class="sc">{</span>np<span class="sc">.</span>sqrt(problem.value) <span class="op">*</span> <span class="dv">100</span><span class="sc">:.2f}</span><span class="ss"> %&quot;</span>)</span></code></pre></div>
 <p><strong>Ausgabe:</strong></p>
 <pre><code>Anteile: [0.767 0.233]
 Risiko der Mischung: 8.90 %</code></pre>
@@ -15401,61 +16266,61 @@ Risiko der Mischung: 8.90 %</code></pre>
 </table>
 <p><strong>Warum das praktisch zählt:</strong> Eine Stichproben-Kovarianzmatrix mit mehr Titeln als Beobachtungen (<span class="math inline">N &gt; T</span>) ist <strong>singulär</strong> — also nur semidefinit. Dann gibt es unendlich viele Portfolios mit exakt demselben minimalen Risiko, und der Solver liefert eines davon, scheinbar willkürlich. Kleine Datenänderungen führen zu völlig anderen Gewichten. Genau dieses Problem behebt die Shrinkage aus <a href="#kap-finanzdaten">Kapitel 18</a>.</p>
 <p>Alle drei Zeilen der Tabelle lassen sich an einem winzigen Zwei-Variablen-QP direkt beobachten — inklusive der Stelle, an der CVXPY ein nicht konvexes Problem <strong>verweigert</strong>, bevor überhaupt ein Solver aufgerufen wird:</p>
-<div class="sourceCode" id="cb112"><pre class="sourceCode python"><code class="sourceCode python"><span id="cb112-1"><a href="#cb112-1" aria-hidden="true" tabindex="-1"></a><span class="co">#!/usr/bin/env python3</span></span>
-<span id="cb112-2"><a href="#cb112-2" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb112-3"><a href="#cb112-3" aria-hidden="true" tabindex="-1"></a><span class="co"># QP_Grundlagen.py</span></span>
-<span id="cb112-4"><a href="#cb112-4" aria-hidden="true" tabindex="-1"></a><span class="co">&quot;&quot;&quot;</span></span>
-<span id="cb112-5"><a href="#cb112-5" aria-hidden="true" tabindex="-1"></a><span class="co">Kapitel QP/NLP: Die drei Faelle aus der Konvexitaets-Tabelle (Abschnitt</span></span>
-<span id="cb112-6"><a href="#cb112-6" aria-hidden="true" tabindex="-1"></a><span class="co">&#39;Das quadratische Programm&#39;) an</span></span>
-<span id="cb112-7"><a href="#cb112-7" aria-hidden="true" tabindex="-1"></a><span class="co">einem Mini-QP demonstriert: P positiv definit, P (singulaer) semidefinit,</span></span>
-<span id="cb112-8"><a href="#cb112-8" aria-hidden="true" tabindex="-1"></a><span class="co">P mit negativem Eigenwert.</span></span>
-<span id="cb112-9"><a href="#cb112-9" aria-hidden="true" tabindex="-1"></a><span class="co">&quot;&quot;&quot;</span></span>
-<span id="cb112-10"><a href="#cb112-10" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb112-11"><a href="#cb112-11" aria-hidden="true" tabindex="-1"></a><span class="im">import</span> numpy <span class="im">as</span> np</span>
-<span id="cb112-12"><a href="#cb112-12" aria-hidden="true" tabindex="-1"></a><span class="im">import</span> cvxpy <span class="im">as</span> cp</span>
-<span id="cb112-13"><a href="#cb112-13" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb112-14"><a href="#cb112-14" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb112-15"><a href="#cb112-15" aria-hidden="true" tabindex="-1"></a><span class="kw">def</span> loese_qp(P, q, name):</span>
-<span id="cb112-16"><a href="#cb112-16" aria-hidden="true" tabindex="-1"></a>    n <span class="op">=</span> <span class="bu">len</span>(q)</span>
-<span id="cb112-17"><a href="#cb112-17" aria-hidden="true" tabindex="-1"></a>    w <span class="op">=</span> cp.Variable(n)</span>
-<span id="cb112-18"><a href="#cb112-18" aria-hidden="true" tabindex="-1"></a>    ziel <span class="op">=</span> cp.Minimize(<span class="fl">0.5</span> <span class="op">*</span> cp.quad_form(w, P) <span class="op">+</span> q <span class="op">@</span> w)</span>
-<span id="cb112-19"><a href="#cb112-19" aria-hidden="true" tabindex="-1"></a>    bedingungen <span class="op">=</span> [cp.<span class="bu">sum</span>(w) <span class="op">==</span> <span class="dv">1</span>, w <span class="op">&gt;=</span> <span class="dv">0</span>]</span>
-<span id="cb112-20"><a href="#cb112-20" aria-hidden="true" tabindex="-1"></a>    problem <span class="op">=</span> cp.Problem(ziel, bedingungen)</span>
-<span id="cb112-21"><a href="#cb112-21" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb112-22"><a href="#cb112-22" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;</span><span class="ch">\n</span><span class="ss">--- </span><span class="sc">{</span>name<span class="sc">}</span><span class="ss"> ---&quot;</span>)</span>
-<span id="cb112-23"><a href="#cb112-23" aria-hidden="true" tabindex="-1"></a>    eigenwerte <span class="op">=</span> np.linalg.eigvalsh(P)</span>
-<span id="cb112-24"><a href="#cb112-24" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;Eigenwerte von P: </span><span class="sc">{</span>np<span class="sc">.</span><span class="bu">round</span>(eigenwerte, <span class="dv">4</span>)<span class="sc">}</span><span class="ss">&quot;</span>)</span>
-<span id="cb112-25"><a href="#cb112-25" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;DCP-konvex (CVXPY-Pruefung)? </span><span class="sc">{</span>problem<span class="sc">.</span>is_dcp()<span class="sc">}</span><span class="ss">&quot;</span>)</span>
-<span id="cb112-26"><a href="#cb112-26" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb112-27"><a href="#cb112-27" aria-hidden="true" tabindex="-1"></a>    <span class="cf">if</span> <span class="kw">not</span> problem.is_dcp():</span>
-<span id="cb112-28"><a href="#cb112-28" aria-hidden="true" tabindex="-1"></a>        <span class="bu">print</span>(<span class="st">&quot;-&gt; CVXPY lehnt das Problem ab, BEVOR ueberhaupt ein Solver laeuft.&quot;</span>)</span>
-<span id="cb112-29"><a href="#cb112-29" aria-hidden="true" tabindex="-1"></a>        <span class="cf">return</span></span>
-<span id="cb112-30"><a href="#cb112-30" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb112-31"><a href="#cb112-31" aria-hidden="true" tabindex="-1"></a>    problem.solve()</span>
-<span id="cb112-32"><a href="#cb112-32" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;Status: </span><span class="sc">{</span>problem<span class="sc">.</span>status<span class="sc">}</span><span class="ss">&quot;</span>)</span>
-<span id="cb112-33"><a href="#cb112-33" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;w* = </span><span class="sc">{</span>np<span class="sc">.</span><span class="bu">round</span>(w.value, <span class="dv">4</span>)<span class="sc">}</span><span class="ss">&quot;</span>)</span>
-<span id="cb112-34"><a href="#cb112-34" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;Zielwert = </span><span class="sc">{</span>problem<span class="sc">.</span>value<span class="sc">:.6f}</span><span class="ss">&quot;</span>)</span>
-<span id="cb112-35"><a href="#cb112-35" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb112-36"><a href="#cb112-36" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb112-37"><a href="#cb112-37" aria-hidden="true" tabindex="-1"></a><span class="cf">if</span> <span class="va">__name__</span> <span class="op">==</span> <span class="st">&quot;__main__&quot;</span>:</span>
-<span id="cb112-38"><a href="#cb112-38" aria-hidden="true" tabindex="-1"></a>    q <span class="op">=</span> np.zeros(<span class="dv">2</span>)</span>
-<span id="cb112-39"><a href="#cb112-39" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb112-40"><a href="#cb112-40" aria-hidden="true" tabindex="-1"></a>    <span class="co"># Fall 1: P positiv definit -&gt; eindeutiges Minimum</span></span>
-<span id="cb112-41"><a href="#cb112-41" aria-hidden="true" tabindex="-1"></a>    P_definit <span class="op">=</span> np.array([[<span class="fl">2.0</span>, <span class="fl">0.5</span>], [<span class="fl">0.5</span>, <span class="fl">1.0</span>]])</span>
-<span id="cb112-42"><a href="#cb112-42" aria-hidden="true" tabindex="-1"></a>    loese_qp(P_definit, q, <span class="st">&quot;P positiv definit&quot;</span>)</span>
-<span id="cb112-43"><a href="#cb112-43" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb112-44"><a href="#cb112-44" aria-hidden="true" tabindex="-1"></a>    <span class="co"># Fall 2: P singulaer/semidefinit (zwei &quot;identische&quot; Assets) -&gt; unendlich viele Minima</span></span>
-<span id="cb112-45"><a href="#cb112-45" aria-hidden="true" tabindex="-1"></a>    P_semidefinit <span class="op">=</span> np.array([[<span class="fl">1.0</span>, <span class="fl">1.0</span>], [<span class="fl">1.0</span>, <span class="fl">1.0</span>]])</span>
-<span id="cb112-46"><a href="#cb112-46" aria-hidden="true" tabindex="-1"></a>    loese_qp(P_semidefinit, q, <span class="st">&quot;P positiv semidefinit (singulaer)&quot;</span>)</span>
-<span id="cb112-47"><a href="#cb112-47" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb112-48"><a href="#cb112-48" aria-hidden="true" tabindex="-1"></a>    <span class="co"># Fall 3: P mit negativem Eigenwert -&gt; nicht konvex</span></span>
-<span id="cb112-49"><a href="#cb112-49" aria-hidden="true" tabindex="-1"></a>    P_indefinit <span class="op">=</span> np.array([[<span class="fl">1.0</span>, <span class="fl">2.0</span>], [<span class="fl">2.0</span>, <span class="fl">1.0</span>]])</span>
-<span id="cb112-50"><a href="#cb112-50" aria-hidden="true" tabindex="-1"></a>    loese_qp(P_indefinit, q, <span class="st">&quot;P indefinit (negativer Eigenwert)&quot;</span>)</span>
-<span id="cb112-51"><a href="#cb112-51" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb112-52"><a href="#cb112-52" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;</span><span class="ch">\n</span><span class="st">--- Nachweis: &#39;unendlich viele Minima&#39; im semidefiniten Fall ---&quot;</span>)</span>
-<span id="cb112-53"><a href="#cb112-53" aria-hidden="true" tabindex="-1"></a>    <span class="cf">for</span> punkt <span class="kw">in</span> [np.array([<span class="fl">1.0</span>, <span class="fl">0.0</span>]), np.array([<span class="fl">0.0</span>, <span class="fl">1.0</span>]), np.array([<span class="fl">0.3</span>, <span class="fl">0.7</span>])]:</span>
-<span id="cb112-54"><a href="#cb112-54" aria-hidden="true" tabindex="-1"></a>        wert <span class="op">=</span> <span class="fl">0.5</span> <span class="op">*</span> punkt <span class="op">@</span> P_semidefinit <span class="op">@</span> punkt</span>
-<span id="cb112-55"><a href="#cb112-55" aria-hidden="true" tabindex="-1"></a>        <span class="bu">print</span>(<span class="ss">f&quot;  w = </span><span class="sc">{</span>punkt<span class="sc">}</span><span class="ss"> -&gt; Zielwert = </span><span class="sc">{</span>wert<span class="sc">:.4f}</span><span class="ss">  (identisch, obwohl w verschieden)&quot;</span>)</span></code></pre></div>
+<div class="sourceCode" id="cb114"><pre class="sourceCode python"><code class="sourceCode python"><span id="cb114-1"><a href="#cb114-1" aria-hidden="true" tabindex="-1"></a><span class="co">#!/usr/bin/env python3</span></span>
+<span id="cb114-2"><a href="#cb114-2" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb114-3"><a href="#cb114-3" aria-hidden="true" tabindex="-1"></a><span class="co"># QP_Grundlagen.py</span></span>
+<span id="cb114-4"><a href="#cb114-4" aria-hidden="true" tabindex="-1"></a><span class="co">&quot;&quot;&quot;</span></span>
+<span id="cb114-5"><a href="#cb114-5" aria-hidden="true" tabindex="-1"></a><span class="co">Kapitel QP/NLP: Die drei Faelle aus der Konvexitaets-Tabelle (Abschnitt</span></span>
+<span id="cb114-6"><a href="#cb114-6" aria-hidden="true" tabindex="-1"></a><span class="co">&#39;Das quadratische Programm&#39;) an</span></span>
+<span id="cb114-7"><a href="#cb114-7" aria-hidden="true" tabindex="-1"></a><span class="co">einem Mini-QP demonstriert: P positiv definit, P (singulaer) semidefinit,</span></span>
+<span id="cb114-8"><a href="#cb114-8" aria-hidden="true" tabindex="-1"></a><span class="co">P mit negativem Eigenwert.</span></span>
+<span id="cb114-9"><a href="#cb114-9" aria-hidden="true" tabindex="-1"></a><span class="co">&quot;&quot;&quot;</span></span>
+<span id="cb114-10"><a href="#cb114-10" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb114-11"><a href="#cb114-11" aria-hidden="true" tabindex="-1"></a><span class="im">import</span> numpy <span class="im">as</span> np</span>
+<span id="cb114-12"><a href="#cb114-12" aria-hidden="true" tabindex="-1"></a><span class="im">import</span> cvxpy <span class="im">as</span> cp</span>
+<span id="cb114-13"><a href="#cb114-13" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb114-14"><a href="#cb114-14" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb114-15"><a href="#cb114-15" aria-hidden="true" tabindex="-1"></a><span class="kw">def</span> loese_qp(P, q, name):</span>
+<span id="cb114-16"><a href="#cb114-16" aria-hidden="true" tabindex="-1"></a>    n <span class="op">=</span> <span class="bu">len</span>(q)</span>
+<span id="cb114-17"><a href="#cb114-17" aria-hidden="true" tabindex="-1"></a>    w <span class="op">=</span> cp.Variable(n)</span>
+<span id="cb114-18"><a href="#cb114-18" aria-hidden="true" tabindex="-1"></a>    ziel <span class="op">=</span> cp.Minimize(<span class="fl">0.5</span> <span class="op">*</span> cp.quad_form(w, P) <span class="op">+</span> q <span class="op">@</span> w)</span>
+<span id="cb114-19"><a href="#cb114-19" aria-hidden="true" tabindex="-1"></a>    bedingungen <span class="op">=</span> [cp.<span class="bu">sum</span>(w) <span class="op">==</span> <span class="dv">1</span>, w <span class="op">&gt;=</span> <span class="dv">0</span>]</span>
+<span id="cb114-20"><a href="#cb114-20" aria-hidden="true" tabindex="-1"></a>    problem <span class="op">=</span> cp.Problem(ziel, bedingungen)</span>
+<span id="cb114-21"><a href="#cb114-21" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb114-22"><a href="#cb114-22" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;</span><span class="ch">\n</span><span class="ss">--- </span><span class="sc">{</span>name<span class="sc">}</span><span class="ss"> ---&quot;</span>)</span>
+<span id="cb114-23"><a href="#cb114-23" aria-hidden="true" tabindex="-1"></a>    eigenwerte <span class="op">=</span> np.linalg.eigvalsh(P)</span>
+<span id="cb114-24"><a href="#cb114-24" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;Eigenwerte von P: </span><span class="sc">{</span>np<span class="sc">.</span><span class="bu">round</span>(eigenwerte, <span class="dv">4</span>)<span class="sc">}</span><span class="ss">&quot;</span>)</span>
+<span id="cb114-25"><a href="#cb114-25" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;DCP-konvex (CVXPY-Pruefung)? </span><span class="sc">{</span>problem<span class="sc">.</span>is_dcp()<span class="sc">}</span><span class="ss">&quot;</span>)</span>
+<span id="cb114-26"><a href="#cb114-26" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb114-27"><a href="#cb114-27" aria-hidden="true" tabindex="-1"></a>    <span class="cf">if</span> <span class="kw">not</span> problem.is_dcp():</span>
+<span id="cb114-28"><a href="#cb114-28" aria-hidden="true" tabindex="-1"></a>        <span class="bu">print</span>(<span class="st">&quot;-&gt; CVXPY lehnt das Problem ab, BEVOR ueberhaupt ein Solver laeuft.&quot;</span>)</span>
+<span id="cb114-29"><a href="#cb114-29" aria-hidden="true" tabindex="-1"></a>        <span class="cf">return</span></span>
+<span id="cb114-30"><a href="#cb114-30" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb114-31"><a href="#cb114-31" aria-hidden="true" tabindex="-1"></a>    problem.solve()</span>
+<span id="cb114-32"><a href="#cb114-32" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;Status: </span><span class="sc">{</span>problem<span class="sc">.</span>status<span class="sc">}</span><span class="ss">&quot;</span>)</span>
+<span id="cb114-33"><a href="#cb114-33" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;w* = </span><span class="sc">{</span>np<span class="sc">.</span><span class="bu">round</span>(w.value, <span class="dv">4</span>)<span class="sc">}</span><span class="ss">&quot;</span>)</span>
+<span id="cb114-34"><a href="#cb114-34" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;Zielwert = </span><span class="sc">{</span>problem<span class="sc">.</span>value<span class="sc">:.6f}</span><span class="ss">&quot;</span>)</span>
+<span id="cb114-35"><a href="#cb114-35" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb114-36"><a href="#cb114-36" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb114-37"><a href="#cb114-37" aria-hidden="true" tabindex="-1"></a><span class="cf">if</span> <span class="va">__name__</span> <span class="op">==</span> <span class="st">&quot;__main__&quot;</span>:</span>
+<span id="cb114-38"><a href="#cb114-38" aria-hidden="true" tabindex="-1"></a>    q <span class="op">=</span> np.zeros(<span class="dv">2</span>)</span>
+<span id="cb114-39"><a href="#cb114-39" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb114-40"><a href="#cb114-40" aria-hidden="true" tabindex="-1"></a>    <span class="co"># Fall 1: P positiv definit -&gt; eindeutiges Minimum</span></span>
+<span id="cb114-41"><a href="#cb114-41" aria-hidden="true" tabindex="-1"></a>    P_definit <span class="op">=</span> np.array([[<span class="fl">2.0</span>, <span class="fl">0.5</span>], [<span class="fl">0.5</span>, <span class="fl">1.0</span>]])</span>
+<span id="cb114-42"><a href="#cb114-42" aria-hidden="true" tabindex="-1"></a>    loese_qp(P_definit, q, <span class="st">&quot;P positiv definit&quot;</span>)</span>
+<span id="cb114-43"><a href="#cb114-43" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb114-44"><a href="#cb114-44" aria-hidden="true" tabindex="-1"></a>    <span class="co"># Fall 2: P singulaer/semidefinit (zwei &quot;identische&quot; Assets) -&gt; unendlich viele Minima</span></span>
+<span id="cb114-45"><a href="#cb114-45" aria-hidden="true" tabindex="-1"></a>    P_semidefinit <span class="op">=</span> np.array([[<span class="fl">1.0</span>, <span class="fl">1.0</span>], [<span class="fl">1.0</span>, <span class="fl">1.0</span>]])</span>
+<span id="cb114-46"><a href="#cb114-46" aria-hidden="true" tabindex="-1"></a>    loese_qp(P_semidefinit, q, <span class="st">&quot;P positiv semidefinit (singulaer)&quot;</span>)</span>
+<span id="cb114-47"><a href="#cb114-47" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb114-48"><a href="#cb114-48" aria-hidden="true" tabindex="-1"></a>    <span class="co"># Fall 3: P mit negativem Eigenwert -&gt; nicht konvex</span></span>
+<span id="cb114-49"><a href="#cb114-49" aria-hidden="true" tabindex="-1"></a>    P_indefinit <span class="op">=</span> np.array([[<span class="fl">1.0</span>, <span class="fl">2.0</span>], [<span class="fl">2.0</span>, <span class="fl">1.0</span>]])</span>
+<span id="cb114-50"><a href="#cb114-50" aria-hidden="true" tabindex="-1"></a>    loese_qp(P_indefinit, q, <span class="st">&quot;P indefinit (negativer Eigenwert)&quot;</span>)</span>
+<span id="cb114-51"><a href="#cb114-51" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb114-52"><a href="#cb114-52" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;</span><span class="ch">\n</span><span class="st">--- Nachweis: &#39;unendlich viele Minima&#39; im semidefiniten Fall ---&quot;</span>)</span>
+<span id="cb114-53"><a href="#cb114-53" aria-hidden="true" tabindex="-1"></a>    <span class="cf">for</span> punkt <span class="kw">in</span> [np.array([<span class="fl">1.0</span>, <span class="fl">0.0</span>]), np.array([<span class="fl">0.0</span>, <span class="fl">1.0</span>]), np.array([<span class="fl">0.3</span>, <span class="fl">0.7</span>])]:</span>
+<span id="cb114-54"><a href="#cb114-54" aria-hidden="true" tabindex="-1"></a>        wert <span class="op">=</span> <span class="fl">0.5</span> <span class="op">*</span> punkt <span class="op">@</span> P_semidefinit <span class="op">@</span> punkt</span>
+<span id="cb114-55"><a href="#cb114-55" aria-hidden="true" tabindex="-1"></a>        <span class="bu">print</span>(<span class="ss">f&quot;  w = </span><span class="sc">{</span>punkt<span class="sc">}</span><span class="ss"> -&gt; Zielwert = </span><span class="sc">{</span>wert<span class="sc">:.4f}</span><span class="ss">  (identisch, obwohl w verschieden)&quot;</span>)</span></code></pre></div>
 <p><strong>Erwartete Ausgabe:</strong></p>
 <pre><code>--- P positiv definit ---
 Eigenwerte von P: [0.7929 2.2071]
@@ -15483,9 +16348,9 @@ DCP-konvex (CVXPY-Pruefung)? False
 <p>Der letzte Block ist der eigentliche Beweis: Drei völlig verschiedene Portfolios <span class="math inline">(1,0)</span>, <span class="math inline">(0,1)</span> und <span class="math inline">(0{,}3;\,0{,}7)</span> liefern <strong>exakt</strong> denselben Zielwert — die „Rinne” aus der Tabelle ist keine Metapher, sie ist hier eine echte Gerade im Lösungsraum.</p>
 <blockquote>
 <p><strong>⚠️ Prüfen Sie jede Matrix, bevor Sie sie verwenden</strong></p>
-<div class="sourceCode" id="cb114"><pre class="sourceCode python"><code class="sourceCode python"><span id="cb114-1"><a href="#cb114-1" aria-hidden="true" tabindex="-1"></a>eigenwerte <span class="op">=</span> np.linalg.eigvalsh(Sigma)     <span class="co"># &#39;h&#39; = fuer symmetrische Matrizen</span></span>
-<span id="cb114-2"><a href="#cb114-2" aria-hidden="true" tabindex="-1"></a><span class="cf">assert</span> np.<span class="bu">all</span>(eigenwerte <span class="op">&gt;=</span> <span class="op">-</span><span class="fl">1e-10</span>), <span class="st">&quot;Sigma ist nicht positiv semidefinit!&quot;</span></span>
-<span id="cb114-3"><a href="#cb114-3" aria-hidden="true" tabindex="-1"></a><span class="bu">print</span>(<span class="ss">f&quot;Konditionszahl: </span><span class="sc">{</span>eigenwerte<span class="sc">.</span><span class="bu">max</span>() <span class="op">/</span> eigenwerte<span class="sc">.</span><span class="bu">min</span>()<span class="sc">:.1f}</span><span class="ss">&quot;</span>)</span></code></pre></div>
+<div class="sourceCode" id="cb116"><pre class="sourceCode python"><code class="sourceCode python"><span id="cb116-1"><a href="#cb116-1" aria-hidden="true" tabindex="-1"></a>eigenwerte <span class="op">=</span> np.linalg.eigvalsh(Sigma)     <span class="co"># &#39;h&#39; = fuer symmetrische Matrizen</span></span>
+<span id="cb116-2"><a href="#cb116-2" aria-hidden="true" tabindex="-1"></a><span class="cf">assert</span> np.<span class="bu">all</span>(eigenwerte <span class="op">&gt;=</span> <span class="op">-</span><span class="fl">1e-10</span>), <span class="st">&quot;Sigma ist nicht positiv semidefinit!&quot;</span></span>
+<span id="cb116-3"><a href="#cb116-3" aria-hidden="true" tabindex="-1"></a><span class="bu">print</span>(<span class="ss">f&quot;Konditionszahl: </span><span class="sc">{</span>eigenwerte<span class="sc">.</span><span class="bu">max</span>() <span class="op">/</span> eigenwerte<span class="sc">.</span><span class="bu">min</span>()<span class="sc">:.1f}</span><span class="ss">&quot;</span>)</span></code></pre></div>
 <p>Eine einzige Zeile — und sie deckt eine ungültige Kovarianzmatrix sofort auf.</p>
 </blockquote>
 <hr />
@@ -15571,116 +16436,116 @@ DCP-konvex (CVXPY-Pruefung)? False
 <p><strong>Lösung:</strong> <span class="math inline">x^* = 3</span>, <span class="math inline">\lambda^* = 4</span>, <span class="math inline">f(x^*) = 4</span>.</p>
 <p><strong>Und was bedeutet <span class="math inline">\lambda^* = 4</span>?</strong> Es ist der Schattenpreis: Dürfte <span class="math inline">x</span> bis 3,1 gehen, sänke <span class="math inline">f</span> um etwa <span class="math inline">4 \times 0{,}1 = 0{,}4</span>. Probe: <span class="math inline">f(3{,}1) = (3{,}1-5)^2 = 3{,}61</span>, tatsächlicher Rückgang <span class="math inline">0{,}39</span> ✓ — die kleine Abweichung ist die Krümmung.</p>
 </blockquote>
-<div class="sourceCode" id="cb115"><pre class="sourceCode python"><code class="sourceCode python"><span id="cb115-1"><a href="#cb115-1" aria-hidden="true" tabindex="-1"></a><span class="co">#!/usr/bin/env python3</span></span>
-<span id="cb115-2"><a href="#cb115-2" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb115-3"><a href="#cb115-3" aria-hidden="true" tabindex="-1"></a><span class="co"># KKT_Nachweis.py</span></span>
-<span id="cb115-4"><a href="#cb115-4" aria-hidden="true" tabindex="-1"></a><span class="co">&quot;&quot;&quot;</span></span>
-<span id="cb115-5"><a href="#cb115-5" aria-hidden="true" tabindex="-1"></a><span class="co">Kapitel QP/NLP: Die KKT-Bedingungen numerisch nachpruefen.</span></span>
-<span id="cb115-6"><a href="#cb115-6" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb115-7"><a href="#cb115-7" aria-hidden="true" tabindex="-1"></a><span class="co">Loest ein QP mit CVXPY, liest die Dualwerte aus und prueft alle vier</span></span>
-<span id="cb115-8"><a href="#cb115-8" aria-hidden="true" tabindex="-1"></a><span class="co">KKT-Bedingungen einzeln nach. Das ist zugleich eine Vorlage fuer die</span></span>
-<span id="cb115-9"><a href="#cb115-9" aria-hidden="true" tabindex="-1"></a><span class="co">Qualitaetssicherung eigener Modelle.</span></span>
-<span id="cb115-10"><a href="#cb115-10" aria-hidden="true" tabindex="-1"></a><span class="co">&quot;&quot;&quot;</span></span>
-<span id="cb115-11"><a href="#cb115-11" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb115-12"><a href="#cb115-12" aria-hidden="true" tabindex="-1"></a><span class="im">import</span> numpy <span class="im">as</span> np</span>
-<span id="cb115-13"><a href="#cb115-13" aria-hidden="true" tabindex="-1"></a><span class="im">import</span> cvxpy <span class="im">as</span> cp</span>
-<span id="cb115-14"><a href="#cb115-14" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb115-15"><a href="#cb115-15" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb115-16"><a href="#cb115-16" aria-hidden="true" tabindex="-1"></a><span class="kw">def</span> baue_gueltige_kovarianz(vola, korrelationen, seed<span class="op">=</span><span class="dv">0</span>):</span>
-<span id="cb115-17"><a href="#cb115-17" aria-hidden="true" tabindex="-1"></a>    <span class="co">&quot;&quot;&quot;</span></span>
-<span id="cb115-18"><a href="#cb115-18" aria-hidden="true" tabindex="-1"></a><span class="co">    Baut Sigma = D * C * D aus Volatilitaeten und einer Korrelationsmatrix.</span></span>
-<span id="cb115-19"><a href="#cb115-19" aria-hidden="true" tabindex="-1"></a><span class="co">    Dieses Vorgehen ist konstruktionsbedingt positiv semidefinit - im</span></span>
-<span id="cb115-20"><a href="#cb115-20" aria-hidden="true" tabindex="-1"></a><span class="co">    Gegensatz zum nachtraeglichen Ueberschreiben der Diagonalen, das die</span></span>
-<span id="cb115-21"><a href="#cb115-21" aria-hidden="true" tabindex="-1"></a><span class="co">    positive Semidefinitheit zerstoeren kann.</span></span>
-<span id="cb115-22"><a href="#cb115-22" aria-hidden="true" tabindex="-1"></a><span class="co">    &quot;&quot;&quot;</span></span>
-<span id="cb115-23"><a href="#cb115-23" aria-hidden="true" tabindex="-1"></a>    C <span class="op">=</span> np.array(korrelationen, dtype<span class="op">=</span><span class="bu">float</span>)</span>
-<span id="cb115-24"><a href="#cb115-24" aria-hidden="true" tabindex="-1"></a>    <span class="cf">assert</span> np.allclose(C, C.T), <span class="st">&quot;Korrelationsmatrix muss symmetrisch sein.&quot;</span></span>
-<span id="cb115-25"><a href="#cb115-25" aria-hidden="true" tabindex="-1"></a>    <span class="cf">assert</span> np.allclose(np.diag(C), <span class="fl">1.0</span>), <span class="st">&quot;Diagonale der Korrelationsmatrix muss 1 sein.&quot;</span></span>
-<span id="cb115-26"><a href="#cb115-26" aria-hidden="true" tabindex="-1"></a>    eigen <span class="op">=</span> np.linalg.eigvalsh(C)</span>
-<span id="cb115-27"><a href="#cb115-27" aria-hidden="true" tabindex="-1"></a>    <span class="cf">assert</span> eigen.<span class="bu">min</span>() <span class="op">&gt;</span> <span class="op">-</span><span class="fl">1e-10</span>, (</span>
-<span id="cb115-28"><a href="#cb115-28" aria-hidden="true" tabindex="-1"></a>        <span class="ss">f&quot;Korrelationsmatrix ist nicht positiv semidefinit &quot;</span></span>
-<span id="cb115-29"><a href="#cb115-29" aria-hidden="true" tabindex="-1"></a>        <span class="ss">f&quot;(kleinster Eigenwert </span><span class="sc">{</span>eigen<span class="sc">.</span><span class="bu">min</span>()<span class="sc">:.4f}</span><span class="ss">). Solche Korrelationen sind unmoeglich.&quot;</span>)</span>
-<span id="cb115-30"><a href="#cb115-30" aria-hidden="true" tabindex="-1"></a>    D <span class="op">=</span> np.diag(vola)</span>
-<span id="cb115-31"><a href="#cb115-31" aria-hidden="true" tabindex="-1"></a>    <span class="cf">return</span> D <span class="op">@</span> C <span class="op">@</span> D</span>
-<span id="cb115-32"><a href="#cb115-32" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb115-33"><a href="#cb115-33" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb115-34"><a href="#cb115-34" aria-hidden="true" tabindex="-1"></a><span class="cf">if</span> <span class="va">__name__</span> <span class="op">==</span> <span class="st">&quot;__main__&quot;</span>:</span>
-<span id="cb115-35"><a href="#cb115-35" aria-hidden="true" tabindex="-1"></a>    <span class="co"># --- Ein kleines Portfolio-QP ----------------------------------------</span></span>
-<span id="cb115-36"><a href="#cb115-36" aria-hidden="true" tabindex="-1"></a>    vola <span class="op">=</span> np.array([<span class="fl">0.20</span>, <span class="fl">0.14</span>, <span class="fl">0.30</span>])                 <span class="co"># Volatilitaeten</span></span>
-<span id="cb115-37"><a href="#cb115-37" aria-hidden="true" tabindex="-1"></a>    korr <span class="op">=</span> [[<span class="fl">1.00</span>, <span class="fl">0.30</span>, <span class="fl">0.10</span>],</span>
-<span id="cb115-38"><a href="#cb115-38" aria-hidden="true" tabindex="-1"></a>            [<span class="fl">0.30</span>, <span class="fl">1.00</span>, <span class="fl">0.25</span>],</span>
-<span id="cb115-39"><a href="#cb115-39" aria-hidden="true" tabindex="-1"></a>            [<span class="fl">0.10</span>, <span class="fl">0.25</span>, <span class="fl">1.00</span>]]</span>
-<span id="cb115-40"><a href="#cb115-40" aria-hidden="true" tabindex="-1"></a>    Sigma <span class="op">=</span> baue_gueltige_kovarianz(vola, korr)</span>
-<span id="cb115-41"><a href="#cb115-41" aria-hidden="true" tabindex="-1"></a>    mu <span class="op">=</span> np.array([<span class="fl">0.09</span>, <span class="fl">0.05</span>, <span class="fl">0.13</span>])                   <span class="co"># erwartete Renditen</span></span>
-<span id="cb115-42"><a href="#cb115-42" aria-hidden="true" tabindex="-1"></a>    lam <span class="op">=</span> <span class="fl">3.0</span>                                           <span class="co"># Risikoaversion</span></span>
-<span id="cb115-43"><a href="#cb115-43" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb115-44"><a href="#cb115-44" aria-hidden="true" tabindex="-1"></a>    eigenwerte <span class="op">=</span> np.linalg.eigvalsh(Sigma)</span>
-<span id="cb115-45"><a href="#cb115-45" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;=&quot;</span> <span class="op">*</span> <span class="dv">74</span>)</span>
-<span id="cb115-46"><a href="#cb115-46" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;  KKT-BEDINGUNGEN AM PORTFOLIO-QP&quot;</span>)</span>
-<span id="cb115-47"><a href="#cb115-47" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;=&quot;</span> <span class="op">*</span> <span class="dv">74</span>)</span>
-<span id="cb115-48"><a href="#cb115-48" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;Eigenwerte von Sigma: </span><span class="sc">{</span>np<span class="sc">.</span><span class="bu">round</span>(eigenwerte, <span class="dv">6</span>)<span class="sc">}</span><span class="ss">&quot;</span>)</span>
-<span id="cb115-49"><a href="#cb115-49" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;  -&gt; positiv definit: </span><span class="sc">{</span><span class="bu">bool</span>(eigenwerte.<span class="bu">min</span>() <span class="op">&gt;</span> <span class="dv">0</span>)<span class="sc">}</span><span class="ss">  &quot;</span></span>
-<span id="cb115-50"><a href="#cb115-50" aria-hidden="true" tabindex="-1"></a>          <span class="ss">f&quot;(Problem ist streng konvex, Loesung eindeutig)&quot;</span>)</span>
-<span id="cb115-51"><a href="#cb115-51" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;  -&gt; Konditionszahl:  </span><span class="sc">{</span>eigenwerte<span class="sc">.</span><span class="bu">max</span>() <span class="op">/</span> eigenwerte<span class="sc">.</span><span class="bu">min</span>()<span class="sc">:.2f}</span><span class="ss">&quot;</span>)</span>
-<span id="cb115-52"><a href="#cb115-52" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb115-53"><a href="#cb115-53" aria-hidden="true" tabindex="-1"></a>    <span class="co"># --- Modell: min  lam/2 * w&#39;Sigma w - mu&#39;w   u.d.N. sum(w)=1, w&gt;=0 ----</span></span>
-<span id="cb115-54"><a href="#cb115-54" aria-hidden="true" tabindex="-1"></a>    n <span class="op">=</span> <span class="bu">len</span>(mu)</span>
-<span id="cb115-55"><a href="#cb115-55" aria-hidden="true" tabindex="-1"></a>    w <span class="op">=</span> cp.Variable(n)</span>
-<span id="cb115-56"><a href="#cb115-56" aria-hidden="true" tabindex="-1"></a>    ziel <span class="op">=</span> cp.Minimize(<span class="fl">0.5</span> <span class="op">*</span> lam <span class="op">*</span> cp.quad_form(w, Sigma) <span class="op">-</span> mu <span class="op">@</span> w)</span>
-<span id="cb115-57"><a href="#cb115-57" aria-hidden="true" tabindex="-1"></a>    budget <span class="op">=</span> cp.<span class="bu">sum</span>(w) <span class="op">==</span> <span class="dv">1</span></span>
-<span id="cb115-58"><a href="#cb115-58" aria-hidden="true" tabindex="-1"></a>    nichtnegativ <span class="op">=</span> w <span class="op">&gt;=</span> <span class="dv">0</span></span>
-<span id="cb115-59"><a href="#cb115-59" aria-hidden="true" tabindex="-1"></a>    problem <span class="op">=</span> cp.Problem(ziel, [budget, nichtnegativ])</span>
-<span id="cb115-60"><a href="#cb115-60" aria-hidden="true" tabindex="-1"></a>    problem.solve()</span>
-<span id="cb115-61"><a href="#cb115-61" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb115-62"><a href="#cb115-62" aria-hidden="true" tabindex="-1"></a>    w_opt <span class="op">=</span> w.value</span>
-<span id="cb115-63"><a href="#cb115-63" aria-hidden="true" tabindex="-1"></a>    nu <span class="op">=</span> budget.dual_value                    <span class="co"># Multiplikator der Gleichung</span></span>
-<span id="cb115-64"><a href="#cb115-64" aria-hidden="true" tabindex="-1"></a>    lam_i <span class="op">=</span> nichtnegativ.dual_value           <span class="co"># Multiplikatoren der Ungleichungen</span></span>
-<span id="cb115-65"><a href="#cb115-65" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb115-66"><a href="#cb115-66" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;</span><span class="ch">\n</span><span class="ss">Status: </span><span class="sc">{</span>problem<span class="sc">.</span>status<span class="sc">}</span><span class="ss">&quot;</span>)</span>
-<span id="cb115-67"><a href="#cb115-67" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;Optimale Gewichte: </span><span class="sc">{</span>np<span class="sc">.</span><span class="bu">round</span>(w_opt, <span class="dv">6</span>)<span class="sc">}</span><span class="ss">&quot;</span>)</span>
-<span id="cb115-68"><a href="#cb115-68" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;Zielwert:          </span><span class="sc">{</span>problem<span class="sc">.</span>value<span class="sc">:.6f}</span><span class="ss">&quot;</span>)</span>
-<span id="cb115-69"><a href="#cb115-69" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;Multiplikator der Budgetgleichung (nu): </span><span class="sc">{</span>nu<span class="sc">:.6f}</span><span class="ss">&quot;</span>)</span>
-<span id="cb115-70"><a href="#cb115-70" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;Multiplikatoren der w&gt;=0-Bedingungen:   </span><span class="sc">{</span>np<span class="sc">.</span><span class="bu">round</span>(lam_i, <span class="dv">6</span>)<span class="sc">}</span><span class="ss">&quot;</span>)</span>
-<span id="cb115-71"><a href="#cb115-71" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb115-72"><a href="#cb115-72" aria-hidden="true" tabindex="-1"></a>    <span class="co"># --- KKT-Bedingungen einzeln pruefen ---------------------------------</span></span>
-<span id="cb115-73"><a href="#cb115-73" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;</span><span class="ch">\n</span><span class="st">--- Pruefung der vier KKT-Bedingungen ---&quot;</span>)</span>
-<span id="cb115-74"><a href="#cb115-74" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb115-75"><a href="#cb115-75" aria-hidden="true" tabindex="-1"></a>    <span class="co"># 1. Stationaritaet:  grad f - lambda + nu*1 = 0</span></span>
-<span id="cb115-76"><a href="#cb115-76" aria-hidden="true" tabindex="-1"></a>    <span class="co">#    f(w) = lam/2 w&#39;Sigma w - mu&#39;w   -&gt;   grad f = lam*Sigma w - mu</span></span>
-<span id="cb115-77"><a href="#cb115-77" aria-hidden="true" tabindex="-1"></a>    <span class="co">#    g_i(w) = -w_i &lt;= 0              -&gt;   grad g_i = -e_i</span></span>
-<span id="cb115-78"><a href="#cb115-78" aria-hidden="true" tabindex="-1"></a>    <span class="co">#    h(w)   = sum(w) - 1 = 0         -&gt;   grad h   = 1</span></span>
-<span id="cb115-79"><a href="#cb115-79" aria-hidden="true" tabindex="-1"></a>    grad_f <span class="op">=</span> lam <span class="op">*</span> (Sigma <span class="op">@</span> w_opt) <span class="op">-</span> mu</span>
-<span id="cb115-80"><a href="#cb115-80" aria-hidden="true" tabindex="-1"></a>    stationaritaet <span class="op">=</span> grad_f <span class="op">-</span> lam_i <span class="op">+</span> nu <span class="op">*</span> np.ones(n)</span>
-<span id="cb115-81"><a href="#cb115-81" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;1. Stationaritaet   : max|Residuum| = </span><span class="sc">{</span>np<span class="sc">.</span><span class="bu">abs</span>(stationaritaet)<span class="sc">.</span><span class="bu">max</span>()<span class="sc">:.2e}</span><span class="ss">&quot;</span>)</span>
-<span id="cb115-82"><a href="#cb115-82" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb115-83"><a href="#cb115-83" aria-hidden="true" tabindex="-1"></a>    <span class="co"># 2. Primale Zulaessigkeit</span></span>
-<span id="cb115-84"><a href="#cb115-84" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;2. Primal zulaessig : sum(w)-1 = </span><span class="sc">{</span>w_opt<span class="sc">.</span><span class="bu">sum</span>()<span class="op">-</span><span class="dv">1</span><span class="sc">:.2e}</span><span class="ss">, &quot;</span></span>
-<span id="cb115-85"><a href="#cb115-85" aria-hidden="true" tabindex="-1"></a>          <span class="ss">f&quot;min(w) = </span><span class="sc">{</span>w_opt<span class="sc">.</span><span class="bu">min</span>()<span class="sc">:.2e}</span><span class="ss">&quot;</span>)</span>
-<span id="cb115-86"><a href="#cb115-86" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb115-87"><a href="#cb115-87" aria-hidden="true" tabindex="-1"></a>    <span class="co"># 3. Duale Zulaessigkeit</span></span>
-<span id="cb115-88"><a href="#cb115-88" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;3. Dual zulaessig   : min(lambda) = </span><span class="sc">{</span>lam_i<span class="sc">.</span><span class="bu">min</span>()<span class="sc">:.2e}</span><span class="ss">  (muss &gt;= 0 sein)&quot;</span>)</span>
-<span id="cb115-89"><a href="#cb115-89" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb115-90"><a href="#cb115-90" aria-hidden="true" tabindex="-1"></a>    <span class="co"># 4. Komplementaerer Schlupf: lambda_i * w_i = 0</span></span>
-<span id="cb115-91"><a href="#cb115-91" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;4. Kompl. Schlupf   : max|lambda_i * w_i| = &quot;</span></span>
-<span id="cb115-92"><a href="#cb115-92" aria-hidden="true" tabindex="-1"></a>          <span class="ss">f&quot;</span><span class="sc">{</span>np<span class="sc">.</span><span class="bu">abs</span>(lam_i <span class="op">*</span> w_opt)<span class="sc">.</span><span class="bu">max</span>()<span class="sc">:.2e}</span><span class="ss">&quot;</span>)</span>
-<span id="cb115-93"><a href="#cb115-93" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb115-94"><a href="#cb115-94" aria-hidden="true" tabindex="-1"></a>    alle_ok <span class="op">=</span> (np.<span class="bu">abs</span>(stationaritaet).<span class="bu">max</span>() <span class="op">&lt;</span> <span class="fl">1e-6</span></span>
-<span id="cb115-95"><a href="#cb115-95" aria-hidden="true" tabindex="-1"></a>               <span class="kw">and</span> <span class="bu">abs</span>(w_opt.<span class="bu">sum</span>() <span class="op">-</span> <span class="dv">1</span>) <span class="op">&lt;</span> <span class="fl">1e-8</span></span>
-<span id="cb115-96"><a href="#cb115-96" aria-hidden="true" tabindex="-1"></a>               <span class="kw">and</span> w_opt.<span class="bu">min</span>() <span class="op">&gt;</span> <span class="op">-</span><span class="fl">1e-8</span></span>
-<span id="cb115-97"><a href="#cb115-97" aria-hidden="true" tabindex="-1"></a>               <span class="kw">and</span> lam_i.<span class="bu">min</span>() <span class="op">&gt;</span> <span class="op">-</span><span class="fl">1e-8</span></span>
-<span id="cb115-98"><a href="#cb115-98" aria-hidden="true" tabindex="-1"></a>               <span class="kw">and</span> np.<span class="bu">abs</span>(lam_i <span class="op">*</span> w_opt).<span class="bu">max</span>() <span class="op">&lt;</span> <span class="fl">1e-6</span>)</span>
-<span id="cb115-99"><a href="#cb115-99" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;</span><span class="ch">\n</span><span class="ss">Alle vier KKT-Bedingungen erfuellt: </span><span class="sc">{</span>alle_ok<span class="sc">}</span><span class="ss">&quot;</span>)</span>
-<span id="cb115-100"><a href="#cb115-100" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb115-101"><a href="#cb115-101" aria-hidden="true" tabindex="-1"></a>    <span class="co"># --- Interpretation von nu -------------------------------------------</span></span>
-<span id="cb115-102"><a href="#cb115-102" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;</span><span class="ch">\n</span><span class="st">--- Was bedeutet nu? ---&quot;</span>)</span>
-<span id="cb115-103"><a href="#cb115-103" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;nu ist der Schattenpreis des Budgets: Um so viel aendert sich der&quot;</span>)</span>
-<span id="cb115-104"><a href="#cb115-104" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;Zielwert, wenn man statt 100 % nur 99 </span><span class="sc">% i</span><span class="st">nvestieren duerfte.&quot;</span>)</span>
-<span id="cb115-105"><a href="#cb115-105" aria-hidden="true" tabindex="-1"></a>    problem2 <span class="op">=</span> cp.Problem(cp.Minimize(<span class="fl">0.5</span> <span class="op">*</span> lam <span class="op">*</span> cp.quad_form(w, Sigma) <span class="op">-</span> mu <span class="op">@</span> w),</span>
-<span id="cb115-106"><a href="#cb115-106" aria-hidden="true" tabindex="-1"></a>                          [cp.<span class="bu">sum</span>(w) <span class="op">==</span> <span class="fl">1.01</span>, w <span class="op">&gt;=</span> <span class="dv">0</span>])</span>
-<span id="cb115-107"><a href="#cb115-107" aria-hidden="true" tabindex="-1"></a>    problem2.solve()</span>
-<span id="cb115-108"><a href="#cb115-108" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;  Vorhergesagt (nu * 0.01): </span><span class="sc">{</span>nu <span class="op">*</span> <span class="fl">0.01</span><span class="sc">:+.6f}</span><span class="ss">&quot;</span>)</span>
-<span id="cb115-109"><a href="#cb115-109" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;  Tatsaechlich gemessen:    </span><span class="sc">{</span>problem2<span class="sc">.</span>value <span class="op">-</span> problem<span class="sc">.</span>value<span class="sc">:+.6f}</span><span class="ss">&quot;</span>)</span>
-<span id="cb115-110"><a href="#cb115-110" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;=&quot;</span> <span class="op">*</span> <span class="dv">74</span>)</span></code></pre></div>
+<div class="sourceCode" id="cb117"><pre class="sourceCode python"><code class="sourceCode python"><span id="cb117-1"><a href="#cb117-1" aria-hidden="true" tabindex="-1"></a><span class="co">#!/usr/bin/env python3</span></span>
+<span id="cb117-2"><a href="#cb117-2" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb117-3"><a href="#cb117-3" aria-hidden="true" tabindex="-1"></a><span class="co"># KKT_Nachweis.py</span></span>
+<span id="cb117-4"><a href="#cb117-4" aria-hidden="true" tabindex="-1"></a><span class="co">&quot;&quot;&quot;</span></span>
+<span id="cb117-5"><a href="#cb117-5" aria-hidden="true" tabindex="-1"></a><span class="co">Kapitel QP/NLP: Die KKT-Bedingungen numerisch nachpruefen.</span></span>
+<span id="cb117-6"><a href="#cb117-6" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb117-7"><a href="#cb117-7" aria-hidden="true" tabindex="-1"></a><span class="co">Loest ein QP mit CVXPY, liest die Dualwerte aus und prueft alle vier</span></span>
+<span id="cb117-8"><a href="#cb117-8" aria-hidden="true" tabindex="-1"></a><span class="co">KKT-Bedingungen einzeln nach. Das ist zugleich eine Vorlage fuer die</span></span>
+<span id="cb117-9"><a href="#cb117-9" aria-hidden="true" tabindex="-1"></a><span class="co">Qualitaetssicherung eigener Modelle.</span></span>
+<span id="cb117-10"><a href="#cb117-10" aria-hidden="true" tabindex="-1"></a><span class="co">&quot;&quot;&quot;</span></span>
+<span id="cb117-11"><a href="#cb117-11" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb117-12"><a href="#cb117-12" aria-hidden="true" tabindex="-1"></a><span class="im">import</span> numpy <span class="im">as</span> np</span>
+<span id="cb117-13"><a href="#cb117-13" aria-hidden="true" tabindex="-1"></a><span class="im">import</span> cvxpy <span class="im">as</span> cp</span>
+<span id="cb117-14"><a href="#cb117-14" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb117-15"><a href="#cb117-15" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb117-16"><a href="#cb117-16" aria-hidden="true" tabindex="-1"></a><span class="kw">def</span> baue_gueltige_kovarianz(vola, korrelationen, seed<span class="op">=</span><span class="dv">0</span>):</span>
+<span id="cb117-17"><a href="#cb117-17" aria-hidden="true" tabindex="-1"></a>    <span class="co">&quot;&quot;&quot;</span></span>
+<span id="cb117-18"><a href="#cb117-18" aria-hidden="true" tabindex="-1"></a><span class="co">    Baut Sigma = D * C * D aus Volatilitaeten und einer Korrelationsmatrix.</span></span>
+<span id="cb117-19"><a href="#cb117-19" aria-hidden="true" tabindex="-1"></a><span class="co">    Dieses Vorgehen ist konstruktionsbedingt positiv semidefinit - im</span></span>
+<span id="cb117-20"><a href="#cb117-20" aria-hidden="true" tabindex="-1"></a><span class="co">    Gegensatz zum nachtraeglichen Ueberschreiben der Diagonalen, das die</span></span>
+<span id="cb117-21"><a href="#cb117-21" aria-hidden="true" tabindex="-1"></a><span class="co">    positive Semidefinitheit zerstoeren kann.</span></span>
+<span id="cb117-22"><a href="#cb117-22" aria-hidden="true" tabindex="-1"></a><span class="co">    &quot;&quot;&quot;</span></span>
+<span id="cb117-23"><a href="#cb117-23" aria-hidden="true" tabindex="-1"></a>    C <span class="op">=</span> np.array(korrelationen, dtype<span class="op">=</span><span class="bu">float</span>)</span>
+<span id="cb117-24"><a href="#cb117-24" aria-hidden="true" tabindex="-1"></a>    <span class="cf">assert</span> np.allclose(C, C.T), <span class="st">&quot;Korrelationsmatrix muss symmetrisch sein.&quot;</span></span>
+<span id="cb117-25"><a href="#cb117-25" aria-hidden="true" tabindex="-1"></a>    <span class="cf">assert</span> np.allclose(np.diag(C), <span class="fl">1.0</span>), <span class="st">&quot;Diagonale der Korrelationsmatrix muss 1 sein.&quot;</span></span>
+<span id="cb117-26"><a href="#cb117-26" aria-hidden="true" tabindex="-1"></a>    eigen <span class="op">=</span> np.linalg.eigvalsh(C)</span>
+<span id="cb117-27"><a href="#cb117-27" aria-hidden="true" tabindex="-1"></a>    <span class="cf">assert</span> eigen.<span class="bu">min</span>() <span class="op">&gt;</span> <span class="op">-</span><span class="fl">1e-10</span>, (</span>
+<span id="cb117-28"><a href="#cb117-28" aria-hidden="true" tabindex="-1"></a>        <span class="ss">f&quot;Korrelationsmatrix ist nicht positiv semidefinit &quot;</span></span>
+<span id="cb117-29"><a href="#cb117-29" aria-hidden="true" tabindex="-1"></a>        <span class="ss">f&quot;(kleinster Eigenwert </span><span class="sc">{</span>eigen<span class="sc">.</span><span class="bu">min</span>()<span class="sc">:.4f}</span><span class="ss">). Solche Korrelationen sind unmoeglich.&quot;</span>)</span>
+<span id="cb117-30"><a href="#cb117-30" aria-hidden="true" tabindex="-1"></a>    D <span class="op">=</span> np.diag(vola)</span>
+<span id="cb117-31"><a href="#cb117-31" aria-hidden="true" tabindex="-1"></a>    <span class="cf">return</span> D <span class="op">@</span> C <span class="op">@</span> D</span>
+<span id="cb117-32"><a href="#cb117-32" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb117-33"><a href="#cb117-33" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb117-34"><a href="#cb117-34" aria-hidden="true" tabindex="-1"></a><span class="cf">if</span> <span class="va">__name__</span> <span class="op">==</span> <span class="st">&quot;__main__&quot;</span>:</span>
+<span id="cb117-35"><a href="#cb117-35" aria-hidden="true" tabindex="-1"></a>    <span class="co"># --- Ein kleines Portfolio-QP ----------------------------------------</span></span>
+<span id="cb117-36"><a href="#cb117-36" aria-hidden="true" tabindex="-1"></a>    vola <span class="op">=</span> np.array([<span class="fl">0.20</span>, <span class="fl">0.14</span>, <span class="fl">0.30</span>])                 <span class="co"># Volatilitaeten</span></span>
+<span id="cb117-37"><a href="#cb117-37" aria-hidden="true" tabindex="-1"></a>    korr <span class="op">=</span> [[<span class="fl">1.00</span>, <span class="fl">0.30</span>, <span class="fl">0.10</span>],</span>
+<span id="cb117-38"><a href="#cb117-38" aria-hidden="true" tabindex="-1"></a>            [<span class="fl">0.30</span>, <span class="fl">1.00</span>, <span class="fl">0.25</span>],</span>
+<span id="cb117-39"><a href="#cb117-39" aria-hidden="true" tabindex="-1"></a>            [<span class="fl">0.10</span>, <span class="fl">0.25</span>, <span class="fl">1.00</span>]]</span>
+<span id="cb117-40"><a href="#cb117-40" aria-hidden="true" tabindex="-1"></a>    Sigma <span class="op">=</span> baue_gueltige_kovarianz(vola, korr)</span>
+<span id="cb117-41"><a href="#cb117-41" aria-hidden="true" tabindex="-1"></a>    mu <span class="op">=</span> np.array([<span class="fl">0.09</span>, <span class="fl">0.05</span>, <span class="fl">0.13</span>])                   <span class="co"># erwartete Renditen</span></span>
+<span id="cb117-42"><a href="#cb117-42" aria-hidden="true" tabindex="-1"></a>    lam <span class="op">=</span> <span class="fl">3.0</span>                                           <span class="co"># Risikoaversion</span></span>
+<span id="cb117-43"><a href="#cb117-43" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb117-44"><a href="#cb117-44" aria-hidden="true" tabindex="-1"></a>    eigenwerte <span class="op">=</span> np.linalg.eigvalsh(Sigma)</span>
+<span id="cb117-45"><a href="#cb117-45" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;=&quot;</span> <span class="op">*</span> <span class="dv">74</span>)</span>
+<span id="cb117-46"><a href="#cb117-46" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;  KKT-BEDINGUNGEN AM PORTFOLIO-QP&quot;</span>)</span>
+<span id="cb117-47"><a href="#cb117-47" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;=&quot;</span> <span class="op">*</span> <span class="dv">74</span>)</span>
+<span id="cb117-48"><a href="#cb117-48" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;Eigenwerte von Sigma: </span><span class="sc">{</span>np<span class="sc">.</span><span class="bu">round</span>(eigenwerte, <span class="dv">6</span>)<span class="sc">}</span><span class="ss">&quot;</span>)</span>
+<span id="cb117-49"><a href="#cb117-49" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;  -&gt; positiv definit: </span><span class="sc">{</span><span class="bu">bool</span>(eigenwerte.<span class="bu">min</span>() <span class="op">&gt;</span> <span class="dv">0</span>)<span class="sc">}</span><span class="ss">  &quot;</span></span>
+<span id="cb117-50"><a href="#cb117-50" aria-hidden="true" tabindex="-1"></a>          <span class="ss">f&quot;(Problem ist streng konvex, Loesung eindeutig)&quot;</span>)</span>
+<span id="cb117-51"><a href="#cb117-51" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;  -&gt; Konditionszahl:  </span><span class="sc">{</span>eigenwerte<span class="sc">.</span><span class="bu">max</span>() <span class="op">/</span> eigenwerte<span class="sc">.</span><span class="bu">min</span>()<span class="sc">:.2f}</span><span class="ss">&quot;</span>)</span>
+<span id="cb117-52"><a href="#cb117-52" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb117-53"><a href="#cb117-53" aria-hidden="true" tabindex="-1"></a>    <span class="co"># --- Modell: min  lam/2 * w&#39;Sigma w - mu&#39;w   u.d.N. sum(w)=1, w&gt;=0 ----</span></span>
+<span id="cb117-54"><a href="#cb117-54" aria-hidden="true" tabindex="-1"></a>    n <span class="op">=</span> <span class="bu">len</span>(mu)</span>
+<span id="cb117-55"><a href="#cb117-55" aria-hidden="true" tabindex="-1"></a>    w <span class="op">=</span> cp.Variable(n)</span>
+<span id="cb117-56"><a href="#cb117-56" aria-hidden="true" tabindex="-1"></a>    ziel <span class="op">=</span> cp.Minimize(<span class="fl">0.5</span> <span class="op">*</span> lam <span class="op">*</span> cp.quad_form(w, Sigma) <span class="op">-</span> mu <span class="op">@</span> w)</span>
+<span id="cb117-57"><a href="#cb117-57" aria-hidden="true" tabindex="-1"></a>    budget <span class="op">=</span> cp.<span class="bu">sum</span>(w) <span class="op">==</span> <span class="dv">1</span></span>
+<span id="cb117-58"><a href="#cb117-58" aria-hidden="true" tabindex="-1"></a>    nichtnegativ <span class="op">=</span> w <span class="op">&gt;=</span> <span class="dv">0</span></span>
+<span id="cb117-59"><a href="#cb117-59" aria-hidden="true" tabindex="-1"></a>    problem <span class="op">=</span> cp.Problem(ziel, [budget, nichtnegativ])</span>
+<span id="cb117-60"><a href="#cb117-60" aria-hidden="true" tabindex="-1"></a>    problem.solve()</span>
+<span id="cb117-61"><a href="#cb117-61" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb117-62"><a href="#cb117-62" aria-hidden="true" tabindex="-1"></a>    w_opt <span class="op">=</span> w.value</span>
+<span id="cb117-63"><a href="#cb117-63" aria-hidden="true" tabindex="-1"></a>    nu <span class="op">=</span> budget.dual_value                    <span class="co"># Multiplikator der Gleichung</span></span>
+<span id="cb117-64"><a href="#cb117-64" aria-hidden="true" tabindex="-1"></a>    lam_i <span class="op">=</span> nichtnegativ.dual_value           <span class="co"># Multiplikatoren der Ungleichungen</span></span>
+<span id="cb117-65"><a href="#cb117-65" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb117-66"><a href="#cb117-66" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;</span><span class="ch">\n</span><span class="ss">Status: </span><span class="sc">{</span>problem<span class="sc">.</span>status<span class="sc">}</span><span class="ss">&quot;</span>)</span>
+<span id="cb117-67"><a href="#cb117-67" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;Optimale Gewichte: </span><span class="sc">{</span>np<span class="sc">.</span><span class="bu">round</span>(w_opt, <span class="dv">6</span>)<span class="sc">}</span><span class="ss">&quot;</span>)</span>
+<span id="cb117-68"><a href="#cb117-68" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;Zielwert:          </span><span class="sc">{</span>problem<span class="sc">.</span>value<span class="sc">:.6f}</span><span class="ss">&quot;</span>)</span>
+<span id="cb117-69"><a href="#cb117-69" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;Multiplikator der Budgetgleichung (nu): </span><span class="sc">{</span>nu<span class="sc">:.6f}</span><span class="ss">&quot;</span>)</span>
+<span id="cb117-70"><a href="#cb117-70" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;Multiplikatoren der w&gt;=0-Bedingungen:   </span><span class="sc">{</span>np<span class="sc">.</span><span class="bu">round</span>(lam_i, <span class="dv">6</span>)<span class="sc">}</span><span class="ss">&quot;</span>)</span>
+<span id="cb117-71"><a href="#cb117-71" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb117-72"><a href="#cb117-72" aria-hidden="true" tabindex="-1"></a>    <span class="co"># --- KKT-Bedingungen einzeln pruefen ---------------------------------</span></span>
+<span id="cb117-73"><a href="#cb117-73" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;</span><span class="ch">\n</span><span class="st">--- Pruefung der vier KKT-Bedingungen ---&quot;</span>)</span>
+<span id="cb117-74"><a href="#cb117-74" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb117-75"><a href="#cb117-75" aria-hidden="true" tabindex="-1"></a>    <span class="co"># 1. Stationaritaet:  grad f - lambda + nu*1 = 0</span></span>
+<span id="cb117-76"><a href="#cb117-76" aria-hidden="true" tabindex="-1"></a>    <span class="co">#    f(w) = lam/2 w&#39;Sigma w - mu&#39;w   -&gt;   grad f = lam*Sigma w - mu</span></span>
+<span id="cb117-77"><a href="#cb117-77" aria-hidden="true" tabindex="-1"></a>    <span class="co">#    g_i(w) = -w_i &lt;= 0              -&gt;   grad g_i = -e_i</span></span>
+<span id="cb117-78"><a href="#cb117-78" aria-hidden="true" tabindex="-1"></a>    <span class="co">#    h(w)   = sum(w) - 1 = 0         -&gt;   grad h   = 1</span></span>
+<span id="cb117-79"><a href="#cb117-79" aria-hidden="true" tabindex="-1"></a>    grad_f <span class="op">=</span> lam <span class="op">*</span> (Sigma <span class="op">@</span> w_opt) <span class="op">-</span> mu</span>
+<span id="cb117-80"><a href="#cb117-80" aria-hidden="true" tabindex="-1"></a>    stationaritaet <span class="op">=</span> grad_f <span class="op">-</span> lam_i <span class="op">+</span> nu <span class="op">*</span> np.ones(n)</span>
+<span id="cb117-81"><a href="#cb117-81" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;1. Stationaritaet   : max|Residuum| = </span><span class="sc">{</span>np<span class="sc">.</span><span class="bu">abs</span>(stationaritaet)<span class="sc">.</span><span class="bu">max</span>()<span class="sc">:.2e}</span><span class="ss">&quot;</span>)</span>
+<span id="cb117-82"><a href="#cb117-82" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb117-83"><a href="#cb117-83" aria-hidden="true" tabindex="-1"></a>    <span class="co"># 2. Primale Zulaessigkeit</span></span>
+<span id="cb117-84"><a href="#cb117-84" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;2. Primal zulaessig : sum(w)-1 = </span><span class="sc">{</span>w_opt<span class="sc">.</span><span class="bu">sum</span>()<span class="op">-</span><span class="dv">1</span><span class="sc">:.2e}</span><span class="ss">, &quot;</span></span>
+<span id="cb117-85"><a href="#cb117-85" aria-hidden="true" tabindex="-1"></a>          <span class="ss">f&quot;min(w) = </span><span class="sc">{</span>w_opt<span class="sc">.</span><span class="bu">min</span>()<span class="sc">:.2e}</span><span class="ss">&quot;</span>)</span>
+<span id="cb117-86"><a href="#cb117-86" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb117-87"><a href="#cb117-87" aria-hidden="true" tabindex="-1"></a>    <span class="co"># 3. Duale Zulaessigkeit</span></span>
+<span id="cb117-88"><a href="#cb117-88" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;3. Dual zulaessig   : min(lambda) = </span><span class="sc">{</span>lam_i<span class="sc">.</span><span class="bu">min</span>()<span class="sc">:.2e}</span><span class="ss">  (muss &gt;= 0 sein)&quot;</span>)</span>
+<span id="cb117-89"><a href="#cb117-89" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb117-90"><a href="#cb117-90" aria-hidden="true" tabindex="-1"></a>    <span class="co"># 4. Komplementaerer Schlupf: lambda_i * w_i = 0</span></span>
+<span id="cb117-91"><a href="#cb117-91" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;4. Kompl. Schlupf   : max|lambda_i * w_i| = &quot;</span></span>
+<span id="cb117-92"><a href="#cb117-92" aria-hidden="true" tabindex="-1"></a>          <span class="ss">f&quot;</span><span class="sc">{</span>np<span class="sc">.</span><span class="bu">abs</span>(lam_i <span class="op">*</span> w_opt)<span class="sc">.</span><span class="bu">max</span>()<span class="sc">:.2e}</span><span class="ss">&quot;</span>)</span>
+<span id="cb117-93"><a href="#cb117-93" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb117-94"><a href="#cb117-94" aria-hidden="true" tabindex="-1"></a>    alle_ok <span class="op">=</span> (np.<span class="bu">abs</span>(stationaritaet).<span class="bu">max</span>() <span class="op">&lt;</span> <span class="fl">1e-6</span></span>
+<span id="cb117-95"><a href="#cb117-95" aria-hidden="true" tabindex="-1"></a>               <span class="kw">and</span> <span class="bu">abs</span>(w_opt.<span class="bu">sum</span>() <span class="op">-</span> <span class="dv">1</span>) <span class="op">&lt;</span> <span class="fl">1e-8</span></span>
+<span id="cb117-96"><a href="#cb117-96" aria-hidden="true" tabindex="-1"></a>               <span class="kw">and</span> w_opt.<span class="bu">min</span>() <span class="op">&gt;</span> <span class="op">-</span><span class="fl">1e-8</span></span>
+<span id="cb117-97"><a href="#cb117-97" aria-hidden="true" tabindex="-1"></a>               <span class="kw">and</span> lam_i.<span class="bu">min</span>() <span class="op">&gt;</span> <span class="op">-</span><span class="fl">1e-8</span></span>
+<span id="cb117-98"><a href="#cb117-98" aria-hidden="true" tabindex="-1"></a>               <span class="kw">and</span> np.<span class="bu">abs</span>(lam_i <span class="op">*</span> w_opt).<span class="bu">max</span>() <span class="op">&lt;</span> <span class="fl">1e-6</span>)</span>
+<span id="cb117-99"><a href="#cb117-99" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;</span><span class="ch">\n</span><span class="ss">Alle vier KKT-Bedingungen erfuellt: </span><span class="sc">{</span>alle_ok<span class="sc">}</span><span class="ss">&quot;</span>)</span>
+<span id="cb117-100"><a href="#cb117-100" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb117-101"><a href="#cb117-101" aria-hidden="true" tabindex="-1"></a>    <span class="co"># --- Interpretation von nu -------------------------------------------</span></span>
+<span id="cb117-102"><a href="#cb117-102" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;</span><span class="ch">\n</span><span class="st">--- Was bedeutet nu? ---&quot;</span>)</span>
+<span id="cb117-103"><a href="#cb117-103" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;nu ist der Schattenpreis des Budgets: Um so viel aendert sich der&quot;</span>)</span>
+<span id="cb117-104"><a href="#cb117-104" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;Zielwert, wenn man statt 100 % nur 99 </span><span class="sc">% i</span><span class="st">nvestieren duerfte.&quot;</span>)</span>
+<span id="cb117-105"><a href="#cb117-105" aria-hidden="true" tabindex="-1"></a>    problem2 <span class="op">=</span> cp.Problem(cp.Minimize(<span class="fl">0.5</span> <span class="op">*</span> lam <span class="op">*</span> cp.quad_form(w, Sigma) <span class="op">-</span> mu <span class="op">@</span> w),</span>
+<span id="cb117-106"><a href="#cb117-106" aria-hidden="true" tabindex="-1"></a>                          [cp.<span class="bu">sum</span>(w) <span class="op">==</span> <span class="fl">1.01</span>, w <span class="op">&gt;=</span> <span class="dv">0</span>])</span>
+<span id="cb117-107"><a href="#cb117-107" aria-hidden="true" tabindex="-1"></a>    problem2.solve()</span>
+<span id="cb117-108"><a href="#cb117-108" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;  Vorhergesagt (nu * 0.01): </span><span class="sc">{</span>nu <span class="op">*</span> <span class="fl">0.01</span><span class="sc">:+.6f}</span><span class="ss">&quot;</span>)</span>
+<span id="cb117-109"><a href="#cb117-109" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;  Tatsaechlich gemessen:    </span><span class="sc">{</span>problem2<span class="sc">.</span>value <span class="op">-</span> problem<span class="sc">.</span>value<span class="sc">:+.6f}</span><span class="ss">&quot;</span>)</span>
+<span id="cb117-110"><a href="#cb117-110" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;=&quot;</span> <span class="op">*</span> <span class="dv">74</span>)</span></code></pre></div>
 <hr />
 <h2 id="sec:qp-nlp-nichtlineare-optimierung-mit-scipy-optimize-minimize">11.5 Nichtlineare Optimierung mit <code>scipy.optimize.minimize</code></h2>
 <p>Wenn Zielfunktion oder Nebenbedingungen weder linear noch quadratisch sind — Logarithmen, Wurzeln, Exponentialfunktionen — nutzt man gradientenbasierte Verfahren wie <strong>SLSQP</strong> (<em>Sequential Least Squares Programming</em>).</p>
@@ -15698,144 +16563,144 @@ DCP-konvex (CVXPY-Pruefung)? False
 <p><strong>📐 Formel-Lesehilfe zur Entropie</strong> <span class="math inline">H(\mathbf{w}) = -\sum_i w_i \ln w_i</span> ist ein Streuungsmaß: * Alles in einem Titel (<span class="math inline">w = (1,0,0,0)</span>): <span class="math inline">H = 0</span> — minimale Streuung. * Gleichverteilt (<span class="math inline">w_i = 1/4</span>): <span class="math inline">H = \ln 4 \approx 1{,}386</span> — maximale Streuung.</p>
 <p><strong>Ohne Formel gesagt:</strong> Die Entropie misst, wie „breit verteilt“ das Portfolio ist. Weil sie mit einem Minuszeichen in die zu minimierende Zielfunktion eingeht, wird breite Streuung <strong>belohnt</strong> — und zwar mathematisch glatt, ohne harte Obergrenzen. Der Vorteil gegenüber einer Schranke wie <span class="math inline">w_i \le 0{,}2</span>: Der Übergang ist weich, das Ergebnis reagiert nicht sprunghaft auf kleine Datenänderungen.</p>
 </blockquote>
-<div class="sourceCode" id="cb116"><pre class="sourceCode python"><code class="sourceCode python"><span id="cb116-1"><a href="#cb116-1" aria-hidden="true" tabindex="-1"></a><span class="co">#!/usr/bin/env python3</span></span>
-<span id="cb116-2"><a href="#cb116-2" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb116-3"><a href="#cb116-3" aria-hidden="true" tabindex="-1"></a><span class="co"># Entropie_Maximierte_Allokation.py</span></span>
-<span id="cb116-4"><a href="#cb116-4" aria-hidden="true" tabindex="-1"></a><span class="co">&quot;&quot;&quot;</span></span>
-<span id="cb116-5"><a href="#cb116-5" aria-hidden="true" tabindex="-1"></a><span class="co">Kapitel QP/NLP: Nichtlineare Optimierung (NLP) mit scipy SLSQP.</span></span>
-<span id="cb116-6"><a href="#cb116-6" aria-hidden="true" tabindex="-1"></a><span class="co">Modell: Mean-Variance-Portfolio mit Shannon-Entropie-Diversifikation.</span></span>
-<span id="cb116-7"><a href="#cb116-7" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb116-8"><a href="#cb116-8" aria-hidden="true" tabindex="-1"></a><span class="co">Achtung, haeufiger Fehler: Sigma per A@A.T zu erzeugen und anschliessend die</span></span>
-<span id="cb116-9"><a href="#cb116-9" aria-hidden="true" tabindex="-1"></a><span class="co">Diagonale zu ueberschreiben zerstoert die positive Semidefinitheit - die</span></span>
-<span id="cb116-10"><a href="#cb116-10" aria-hidden="true" tabindex="-1"></a><span class="co">Matrix kann dadurch einen negativen Eigenwert bekommen und unmoegliche</span></span>
-<span id="cb116-11"><a href="#cb116-11" aria-hidden="true" tabindex="-1"></a><span class="co">Korrelationen (&gt; 1) implizieren. Dieses Programm baut Sigma stattdessen als</span></span>
-<span id="cb116-12"><a href="#cb116-12" aria-hidden="true" tabindex="-1"></a><span class="co">D * C * D aus Volatilitaeten und einer echten Korrelationsmatrix -</span></span>
-<span id="cb116-13"><a href="#cb116-13" aria-hidden="true" tabindex="-1"></a><span class="co">konstruktionsbedingt immer PSD.</span></span>
-<span id="cb116-14"><a href="#cb116-14" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb116-15"><a href="#cb116-15" aria-hidden="true" tabindex="-1"></a><span class="co">Zusaetzlich: Multistart, weil SLSQP nur lokale Optima findet.</span></span>
-<span id="cb116-16"><a href="#cb116-16" aria-hidden="true" tabindex="-1"></a><span class="co">&quot;&quot;&quot;</span></span>
-<span id="cb116-17"><a href="#cb116-17" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb116-18"><a href="#cb116-18" aria-hidden="true" tabindex="-1"></a><span class="im">import</span> numpy <span class="im">as</span> np</span>
-<span id="cb116-19"><a href="#cb116-19" aria-hidden="true" tabindex="-1"></a><span class="im">import</span> pandas <span class="im">as</span> pd</span>
-<span id="cb116-20"><a href="#cb116-20" aria-hidden="true" tabindex="-1"></a><span class="im">from</span> scipy.optimize <span class="im">import</span> minimize</span>
-<span id="cb116-21"><a href="#cb116-21" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb116-22"><a href="#cb116-22" aria-hidden="true" tabindex="-1"></a>ASSETS <span class="op">=</span> [<span class="st">&quot;Tech-Aktien&quot;</span>, <span class="st">&quot;Rohstoffe&quot;</span>, <span class="st">&quot;US-Treasuries&quot;</span>, <span class="st">&quot;Krypto&quot;</span>]</span>
-<span id="cb116-23"><a href="#cb116-23" aria-hidden="true" tabindex="-1"></a>MU <span class="op">=</span> np.array([<span class="fl">0.14</span>, <span class="fl">0.07</span>, <span class="fl">0.03</span>, <span class="fl">0.22</span>])          <span class="co"># erwartete Jahresrenditen</span></span>
-<span id="cb116-24"><a href="#cb116-24" aria-hidden="true" tabindex="-1"></a>VOLA <span class="op">=</span> np.array([<span class="fl">0.20</span>, <span class="fl">0.14</span>, <span class="fl">0.07</span>, <span class="fl">0.40</span>])        <span class="co"># Volatilitaeten p.a.</span></span>
-<span id="cb116-25"><a href="#cb116-25" aria-hidden="true" tabindex="-1"></a>KORRELATION <span class="op">=</span> np.array([</span>
-<span id="cb116-26"><a href="#cb116-26" aria-hidden="true" tabindex="-1"></a>    [<span class="fl">1.00</span>, <span class="fl">0.25</span>, <span class="op">-</span><span class="fl">0.10</span>, <span class="fl">0.55</span>],</span>
-<span id="cb116-27"><a href="#cb116-27" aria-hidden="true" tabindex="-1"></a>    [<span class="fl">0.25</span>, <span class="fl">1.00</span>, <span class="fl">0.05</span>, <span class="fl">0.20</span>],</span>
-<span id="cb116-28"><a href="#cb116-28" aria-hidden="true" tabindex="-1"></a>    [<span class="op">-</span><span class="fl">0.10</span>, <span class="fl">0.05</span>, <span class="fl">1.00</span>, <span class="op">-</span><span class="fl">0.15</span>],</span>
-<span id="cb116-29"><a href="#cb116-29" aria-hidden="true" tabindex="-1"></a>    [<span class="fl">0.55</span>, <span class="fl">0.20</span>, <span class="op">-</span><span class="fl">0.15</span>, <span class="fl">1.00</span>],</span>
-<span id="cb116-30"><a href="#cb116-30" aria-hidden="true" tabindex="-1"></a>])</span>
-<span id="cb116-31"><a href="#cb116-31" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb116-32"><a href="#cb116-32" aria-hidden="true" tabindex="-1"></a>ALPHA <span class="op">=</span> <span class="fl">1.0</span>        <span class="co"># Gewicht des Ertrags</span></span>
-<span id="cb116-33"><a href="#cb116-33" aria-hidden="true" tabindex="-1"></a>BETA <span class="op">=</span> <span class="fl">0.015</span>       <span class="co"># Gewicht der Entropie-Diversifikation</span></span>
-<span id="cb116-34"><a href="#cb116-34" aria-hidden="true" tabindex="-1"></a>UNTERGRENZE <span class="op">=</span> <span class="fl">0.001</span></span>
-<span id="cb116-35"><a href="#cb116-35" aria-hidden="true" tabindex="-1"></a>OBERGRENZE <span class="op">=</span> <span class="fl">0.80</span></span>
-<span id="cb116-36"><a href="#cb116-36" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb116-37"><a href="#cb116-37" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb116-38"><a href="#cb116-38" aria-hidden="true" tabindex="-1"></a><span class="kw">def</span> baue_kovarianz() <span class="op">-&gt;</span> np.ndarray:</span>
-<span id="cb116-39"><a href="#cb116-39" aria-hidden="true" tabindex="-1"></a>    <span class="co">&quot;&quot;&quot;Sigma = D * C * D. Immer PSD, wenn C eine gueltige Korrelationsmatrix ist.&quot;&quot;&quot;</span></span>
-<span id="cb116-40"><a href="#cb116-40" aria-hidden="true" tabindex="-1"></a>    eig_c <span class="op">=</span> np.linalg.eigvalsh(KORRELATION)</span>
-<span id="cb116-41"><a href="#cb116-41" aria-hidden="true" tabindex="-1"></a>    <span class="cf">if</span> eig_c.<span class="bu">min</span>() <span class="op">&lt;</span> <span class="op">-</span><span class="fl">1e-10</span>:</span>
-<span id="cb116-42"><a href="#cb116-42" aria-hidden="true" tabindex="-1"></a>        <span class="cf">raise</span> <span class="pp">ValueError</span>(<span class="ss">f&quot;Korrelationsmatrix unmoeglich (Eigenwert </span><span class="sc">{</span>eig_c<span class="sc">.</span><span class="bu">min</span>()<span class="sc">:.4f}</span><span class="ss">).&quot;</span>)</span>
-<span id="cb116-43"><a href="#cb116-43" aria-hidden="true" tabindex="-1"></a>    D <span class="op">=</span> np.diag(VOLA)</span>
-<span id="cb116-44"><a href="#cb116-44" aria-hidden="true" tabindex="-1"></a>    Sigma <span class="op">=</span> D <span class="op">@</span> KORRELATION <span class="op">@</span> D</span>
-<span id="cb116-45"><a href="#cb116-45" aria-hidden="true" tabindex="-1"></a>    eig_s <span class="op">=</span> np.linalg.eigvalsh(Sigma)</span>
-<span id="cb116-46"><a href="#cb116-46" aria-hidden="true" tabindex="-1"></a>    <span class="cf">assert</span> eig_s.<span class="bu">min</span>() <span class="op">&gt;</span> <span class="dv">0</span>, <span class="st">&quot;Sigma nicht positiv definit!&quot;</span></span>
-<span id="cb116-47"><a href="#cb116-47" aria-hidden="true" tabindex="-1"></a>    <span class="cf">return</span> Sigma</span>
-<span id="cb116-48"><a href="#cb116-48" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb116-49"><a href="#cb116-49" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb116-50"><a href="#cb116-50" aria-hidden="true" tabindex="-1"></a>SIGMA <span class="op">=</span> baue_kovarianz()</span>
-<span id="cb116-51"><a href="#cb116-51" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb116-52"><a href="#cb116-52" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb116-53"><a href="#cb116-53" aria-hidden="true" tabindex="-1"></a><span class="kw">def</span> zielfunktion(w, alpha<span class="op">=</span>ALPHA, beta<span class="op">=</span>BETA):</span>
-<span id="cb116-54"><a href="#cb116-54" aria-hidden="true" tabindex="-1"></a>    <span class="co">&quot;&quot;&quot;Risiko - Ertrag - Entropiepraemie (wird minimiert).&quot;&quot;&quot;</span></span>
-<span id="cb116-55"><a href="#cb116-55" aria-hidden="true" tabindex="-1"></a>    varianz <span class="op">=</span> <span class="fl">0.5</span> <span class="op">*</span> w <span class="op">@</span> SIGMA <span class="op">@</span> w</span>
-<span id="cb116-56"><a href="#cb116-56" aria-hidden="true" tabindex="-1"></a>    ertrag <span class="op">=</span> MU <span class="op">@</span> w</span>
-<span id="cb116-57"><a href="#cb116-57" aria-hidden="true" tabindex="-1"></a>    entropie <span class="op">=</span> <span class="op">-</span>np.<span class="bu">sum</span>(w <span class="op">*</span> np.log(w <span class="op">+</span> <span class="fl">1e-12</span>))</span>
-<span id="cb116-58"><a href="#cb116-58" aria-hidden="true" tabindex="-1"></a>    <span class="cf">return</span> varianz <span class="op">-</span> alpha <span class="op">*</span> ertrag <span class="op">-</span> beta <span class="op">*</span> entropie</span>
-<span id="cb116-59"><a href="#cb116-59" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb116-60"><a href="#cb116-60" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb116-61"><a href="#cb116-61" aria-hidden="true" tabindex="-1"></a><span class="kw">def</span> gradient(w, alpha<span class="op">=</span>ALPHA, beta<span class="op">=</span>BETA):</span>
-<span id="cb116-62"><a href="#cb116-62" aria-hidden="true" tabindex="-1"></a>    <span class="co">&quot;&quot;&quot;Exakter analytischer Gradient - beschleunigt und stabilisiert SLSQP.&quot;&quot;&quot;</span></span>
-<span id="cb116-63"><a href="#cb116-63" aria-hidden="true" tabindex="-1"></a>    grad_varianz <span class="op">=</span> SIGMA <span class="op">@</span> w                       <span class="co"># d/dw von 0.5 w&#39;Sigma w</span></span>
-<span id="cb116-64"><a href="#cb116-64" aria-hidden="true" tabindex="-1"></a>    grad_ertrag <span class="op">=</span> <span class="op">-</span>alpha <span class="op">*</span> MU</span>
-<span id="cb116-65"><a href="#cb116-65" aria-hidden="true" tabindex="-1"></a>    grad_entropie <span class="op">=</span> beta <span class="op">*</span> (np.log(w <span class="op">+</span> <span class="fl">1e-12</span>) <span class="op">+</span> <span class="fl">1.0</span>)</span>
-<span id="cb116-66"><a href="#cb116-66" aria-hidden="true" tabindex="-1"></a>    <span class="cf">return</span> grad_varianz <span class="op">+</span> grad_ertrag <span class="op">+</span> grad_entropie</span>
-<span id="cb116-67"><a href="#cb116-67" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb116-68"><a href="#cb116-68" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb116-69"><a href="#cb116-69" aria-hidden="true" tabindex="-1"></a><span class="kw">def</span> optimiere(startpunkt, alpha<span class="op">=</span>ALPHA, beta<span class="op">=</span>BETA):</span>
-<span id="cb116-70"><a href="#cb116-70" aria-hidden="true" tabindex="-1"></a>    <span class="co">&quot;&quot;&quot;alpha und beta werden durchgereicht - so bleibt die Funktion seiteneffektfrei.&quot;&quot;&quot;</span></span>
-<span id="cb116-71"><a href="#cb116-71" aria-hidden="true" tabindex="-1"></a>    <span class="cf">return</span> minimize(</span>
-<span id="cb116-72"><a href="#cb116-72" aria-hidden="true" tabindex="-1"></a>        zielfunktion, startpunkt, args<span class="op">=</span>(alpha, beta), jac<span class="op">=</span>gradient,</span>
-<span id="cb116-73"><a href="#cb116-73" aria-hidden="true" tabindex="-1"></a>        method<span class="op">=</span><span class="st">&quot;SLSQP&quot;</span>, bounds<span class="op">=</span>[(UNTERGRENZE, OBERGRENZE)] <span class="op">*</span> <span class="bu">len</span>(MU),</span>
-<span id="cb116-74"><a href="#cb116-74" aria-hidden="true" tabindex="-1"></a>        constraints<span class="op">=</span>({<span class="st">&quot;type&quot;</span>: <span class="st">&quot;eq&quot;</span>,</span>
-<span id="cb116-75"><a href="#cb116-75" aria-hidden="true" tabindex="-1"></a>                      <span class="st">&quot;fun&quot;</span>: <span class="kw">lambda</span> w: np.<span class="bu">sum</span>(w) <span class="op">-</span> <span class="fl">1.0</span>,</span>
-<span id="cb116-76"><a href="#cb116-76" aria-hidden="true" tabindex="-1"></a>                      <span class="st">&quot;jac&quot;</span>: <span class="kw">lambda</span> w: np.ones(<span class="bu">len</span>(MU))}),</span>
-<span id="cb116-77"><a href="#cb116-77" aria-hidden="true" tabindex="-1"></a>        options<span class="op">=</span>{<span class="st">&quot;ftol&quot;</span>: <span class="fl">1e-12</span>, <span class="st">&quot;maxiter&quot;</span>: <span class="dv">300</span>})</span>
-<span id="cb116-78"><a href="#cb116-78" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb116-79"><a href="#cb116-79" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb116-80"><a href="#cb116-80" aria-hidden="true" tabindex="-1"></a><span class="cf">if</span> <span class="va">__name__</span> <span class="op">==</span> <span class="st">&quot;__main__&quot;</span>:</span>
-<span id="cb116-81"><a href="#cb116-81" aria-hidden="true" tabindex="-1"></a>    n <span class="op">=</span> <span class="bu">len</span>(MU)</span>
-<span id="cb116-82"><a href="#cb116-82" aria-hidden="true" tabindex="-1"></a>    eig <span class="op">=</span> np.linalg.eigvalsh(SIGMA)</span>
-<span id="cb116-83"><a href="#cb116-83" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb116-84"><a href="#cb116-84" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;=&quot;</span> <span class="op">*</span> <span class="dv">74</span>)</span>
-<span id="cb116-85"><a href="#cb116-85" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;   NICHTLINEARE ENTROPIE-OPTIMIERTE ASSET-ALLOKATION&quot;</span>)</span>
-<span id="cb116-86"><a href="#cb116-86" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;=&quot;</span> <span class="op">*</span> <span class="dv">74</span>)</span>
-<span id="cb116-87"><a href="#cb116-87" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;Pruefung der Kovarianzmatrix:&quot;</span>)</span>
-<span id="cb116-88"><a href="#cb116-88" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;  Eigenwerte:          </span><span class="sc">{</span>np<span class="sc">.</span><span class="bu">round</span>(eig, <span class="dv">6</span>)<span class="sc">}</span><span class="ss">&quot;</span>)</span>
-<span id="cb116-89"><a href="#cb116-89" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;  Positiv definit:     </span><span class="sc">{</span><span class="bu">bool</span>(eig.<span class="bu">min</span>() <span class="op">&gt;</span> <span class="dv">0</span>)<span class="sc">}</span><span class="ss">&quot;</span>)</span>
-<span id="cb116-90"><a href="#cb116-90" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;  Groesste Korrelation ausserhalb der Diagonale: &quot;</span></span>
-<span id="cb116-91"><a href="#cb116-91" aria-hidden="true" tabindex="-1"></a>          <span class="ss">f&quot;</span><span class="sc">{</span>np<span class="sc">.</span><span class="bu">abs</span>(KORRELATION <span class="op">-</span> np.eye(n))<span class="sc">.</span><span class="bu">max</span>()<span class="sc">:.2f}</span><span class="ss">  (muss &lt;= 1 sein)&quot;</span>)</span>
-<span id="cb116-92"><a href="#cb116-92" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb116-93"><a href="#cb116-93" aria-hidden="true" tabindex="-1"></a>    <span class="co"># --- Multistart: SLSQP findet nur lokale Optima -----------------------</span></span>
-<span id="cb116-94"><a href="#cb116-94" aria-hidden="true" tabindex="-1"></a>    rng <span class="op">=</span> np.random.default_rng(<span class="dv">7</span>)</span>
-<span id="cb116-95"><a href="#cb116-95" aria-hidden="true" tabindex="-1"></a>    startpunkte <span class="op">=</span> [np.ones(n) <span class="op">/</span> n]                                  <span class="co"># Gleichgewichtung</span></span>
-<span id="cb116-96"><a href="#cb116-96" aria-hidden="true" tabindex="-1"></a>    <span class="cf">for</span> _ <span class="kw">in</span> <span class="bu">range</span>(<span class="dv">9</span>):</span>
-<span id="cb116-97"><a href="#cb116-97" aria-hidden="true" tabindex="-1"></a>        z <span class="op">=</span> rng.random(n) <span class="op">+</span> <span class="fl">0.05</span></span>
-<span id="cb116-98"><a href="#cb116-98" aria-hidden="true" tabindex="-1"></a>        startpunkte.append(z <span class="op">/</span> z.<span class="bu">sum</span>())</span>
-<span id="cb116-99"><a href="#cb116-99" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb116-100"><a href="#cb116-100" aria-hidden="true" tabindex="-1"></a>    ergebnisse <span class="op">=</span> [optimiere(s) <span class="cf">for</span> s <span class="kw">in</span> startpunkte]</span>
-<span id="cb116-101"><a href="#cb116-101" aria-hidden="true" tabindex="-1"></a>    erfolgreich <span class="op">=</span> [r <span class="cf">for</span> r <span class="kw">in</span> ergebnisse <span class="cf">if</span> r.success]</span>
-<span id="cb116-102"><a href="#cb116-102" aria-hidden="true" tabindex="-1"></a>    bestes <span class="op">=</span> <span class="bu">min</span>(erfolgreich, key<span class="op">=</span><span class="kw">lambda</span> r: r.fun)</span>
-<span id="cb116-103"><a href="#cb116-103" aria-hidden="true" tabindex="-1"></a>    zielwerte <span class="op">=</span> np.array([r.fun <span class="cf">for</span> r <span class="kw">in</span> erfolgreich])</span>
-<span id="cb116-104"><a href="#cb116-104" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb116-105"><a href="#cb116-105" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;</span><span class="ch">\n</span><span class="ss">Multistart mit </span><span class="sc">{</span><span class="bu">len</span>(startpunkte)<span class="sc">}</span><span class="ss"> Startpunkten:&quot;</span>)</span>
-<span id="cb116-106"><a href="#cb116-106" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;  Erfolgreich konvergiert: </span><span class="sc">{</span><span class="bu">len</span>(erfolgreich)<span class="sc">}</span><span class="ss">&quot;</span>)</span>
-<span id="cb116-107"><a href="#cb116-107" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;  Spannweite der Zielwerte: </span><span class="sc">{</span>zielwerte<span class="sc">.</span><span class="bu">max</span>() <span class="op">-</span> zielwerte<span class="sc">.</span><span class="bu">min</span>()<span class="sc">:.2e}</span><span class="ss">&quot;</span>)</span>
-<span id="cb116-108"><a href="#cb116-108" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;  -&gt; &quot;</span> <span class="op">+</span> (<span class="st">&quot;alle Startpunkte fuehren zum selben Optimum (Indiz fuer Konvexitaet)&quot;</span></span>
-<span id="cb116-109"><a href="#cb116-109" aria-hidden="true" tabindex="-1"></a>                     <span class="cf">if</span> zielwerte.<span class="bu">max</span>() <span class="op">-</span> zielwerte.<span class="bu">min</span>() <span class="op">&lt;</span> <span class="fl">1e-6</span></span>
-<span id="cb116-110"><a href="#cb116-110" aria-hidden="true" tabindex="-1"></a>                     <span class="cf">else</span> <span class="st">&quot;ACHTUNG: verschiedene lokale Optima gefunden!&quot;</span>))</span>
-<span id="cb116-111"><a href="#cb116-111" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb116-112"><a href="#cb116-112" aria-hidden="true" tabindex="-1"></a>    w_opt <span class="op">=</span> bestes.x</span>
-<span id="cb116-113"><a href="#cb116-113" aria-hidden="true" tabindex="-1"></a>    rendite <span class="op">=</span> MU <span class="op">@</span> w_opt</span>
-<span id="cb116-114"><a href="#cb116-114" aria-hidden="true" tabindex="-1"></a>    volatilitaet <span class="op">=</span> np.sqrt(w_opt <span class="op">@</span> SIGMA <span class="op">@</span> w_opt)</span>
-<span id="cb116-115"><a href="#cb116-115" aria-hidden="true" tabindex="-1"></a>    entropie <span class="op">=</span> <span class="op">-</span>np.<span class="bu">sum</span>(w_opt <span class="op">*</span> np.log(w_opt))</span>
-<span id="cb116-116"><a href="#cb116-116" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb116-117"><a href="#cb116-117" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;</span><span class="ch">\n</span><span class="ss">Konvergenz:                </span><span class="sc">{</span>bestes<span class="sc">.</span>message<span class="sc">}</span><span class="ss">&quot;</span>)</span>
-<span id="cb116-118"><a href="#cb116-118" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;Iterationen:               </span><span class="sc">{</span>bestes<span class="sc">.</span>nit<span class="sc">}</span><span class="ss">&quot;</span>)</span>
-<span id="cb116-119"><a href="#cb116-119" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;Erwartete Jahresrendite:   </span><span class="sc">{</span>rendite <span class="op">*</span> <span class="dv">100</span><span class="sc">:6.2f}</span><span class="ss"> %&quot;</span>)</span>
-<span id="cb116-120"><a href="#cb116-120" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;Erwartete Volatilitaet:    </span><span class="sc">{</span>volatilitaet <span class="op">*</span> <span class="dv">100</span><span class="sc">:6.2f}</span><span class="ss"> %&quot;</span>)</span>
-<span id="cb116-121"><a href="#cb116-121" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;Diversifikations-Entropie: </span><span class="sc">{</span>entropie<span class="sc">:.4f}</span><span class="ss"> &quot;</span></span>
-<span id="cb116-122"><a href="#cb116-122" aria-hidden="true" tabindex="-1"></a>          <span class="ss">f&quot;(Maximum bei Gleichgewichtung: </span><span class="sc">{</span>np<span class="sc">.</span>log(n)<span class="sc">:.4f}</span><span class="ss">)&quot;</span>)</span>
-<span id="cb116-123"><a href="#cb116-123" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb116-124"><a href="#cb116-124" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;</span><span class="ch">\n</span><span class="st">&quot;</span> <span class="op">+</span> pd.DataFrame({</span>
-<span id="cb116-125"><a href="#cb116-125" aria-hidden="true" tabindex="-1"></a>        <span class="st">&quot;Asset&quot;</span>: ASSETS,</span>
-<span id="cb116-126"><a href="#cb116-126" aria-hidden="true" tabindex="-1"></a>        <span class="st">&quot;Erw. Rendite&quot;</span>: [<span class="ss">f&quot;</span><span class="sc">{</span>r<span class="op">*</span><span class="dv">100</span><span class="sc">:.1f}</span><span class="ss"> %&quot;</span> <span class="cf">for</span> r <span class="kw">in</span> MU],</span>
-<span id="cb116-127"><a href="#cb116-127" aria-hidden="true" tabindex="-1"></a>        <span class="st">&quot;Volatilitaet&quot;</span>: [<span class="ss">f&quot;</span><span class="sc">{</span>v<span class="op">*</span><span class="dv">100</span><span class="sc">:.1f}</span><span class="ss"> %&quot;</span> <span class="cf">for</span> v <span class="kw">in</span> VOLA],</span>
-<span id="cb116-128"><a href="#cb116-128" aria-hidden="true" tabindex="-1"></a>        <span class="st">&quot;Gewicht&quot;</span>: [<span class="ss">f&quot;</span><span class="sc">{</span>w<span class="op">*</span><span class="dv">100</span><span class="sc">:6.2f}</span><span class="ss"> %&quot;</span> <span class="cf">for</span> w <span class="kw">in</span> w_opt],</span>
-<span id="cb116-129"><a href="#cb116-129" aria-hidden="true" tabindex="-1"></a>    }).to_string(index<span class="op">=</span><span class="va">False</span>))</span>
-<span id="cb116-130"><a href="#cb116-130" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb116-131"><a href="#cb116-131" aria-hidden="true" tabindex="-1"></a>    <span class="co"># --- Vergleich: was passiert ohne Entropieterm? ----------------------</span></span>
-<span id="cb116-132"><a href="#cb116-132" aria-hidden="true" tabindex="-1"></a>    ohne <span class="op">=</span> optimiere(np.ones(n) <span class="op">/</span> n, beta<span class="op">=</span><span class="fl">0.0</span>)</span>
-<span id="cb116-133"><a href="#cb116-133" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;</span><span class="ch">\n</span><span class="st">--- Wirkung des Entropieterms ---&quot;</span>)</span>
-<span id="cb116-134"><a href="#cb116-134" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;  Mit Entropie  (beta=</span><span class="sc">{</span>BETA<span class="sc">}</span><span class="ss">): Gewichte </span><span class="sc">{</span>np<span class="sc">.</span><span class="bu">round</span>(w_opt <span class="op">*</span> <span class="dv">100</span>, <span class="dv">1</span>)<span class="sc">}</span><span class="ss">&quot;</span>)</span>
-<span id="cb116-135"><a href="#cb116-135" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;  Ohne Entropie (beta=0):     Gewichte </span><span class="sc">{</span>np<span class="sc">.</span><span class="bu">round</span>(ohne.x <span class="op">*</span> <span class="dv">100</span>, <span class="dv">1</span>)<span class="sc">}</span><span class="ss">&quot;</span>)</span>
-<span id="cb116-136"><a href="#cb116-136" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;  Der Entropieterm zieht Kapital aus der Spitzenposition heraus,&quot;</span>)</span>
-<span id="cb116-137"><a href="#cb116-137" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;  ohne dass eine harte Obergrenze noetig waere.&quot;</span>)</span>
-<span id="cb116-138"><a href="#cb116-138" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;=&quot;</span> <span class="op">*</span> <span class="dv">74</span>)</span></code></pre></div>
+<div class="sourceCode" id="cb118"><pre class="sourceCode python"><code class="sourceCode python"><span id="cb118-1"><a href="#cb118-1" aria-hidden="true" tabindex="-1"></a><span class="co">#!/usr/bin/env python3</span></span>
+<span id="cb118-2"><a href="#cb118-2" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb118-3"><a href="#cb118-3" aria-hidden="true" tabindex="-1"></a><span class="co"># Entropie_Maximierte_Allokation.py</span></span>
+<span id="cb118-4"><a href="#cb118-4" aria-hidden="true" tabindex="-1"></a><span class="co">&quot;&quot;&quot;</span></span>
+<span id="cb118-5"><a href="#cb118-5" aria-hidden="true" tabindex="-1"></a><span class="co">Kapitel QP/NLP: Nichtlineare Optimierung (NLP) mit scipy SLSQP.</span></span>
+<span id="cb118-6"><a href="#cb118-6" aria-hidden="true" tabindex="-1"></a><span class="co">Modell: Mean-Variance-Portfolio mit Shannon-Entropie-Diversifikation.</span></span>
+<span id="cb118-7"><a href="#cb118-7" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb118-8"><a href="#cb118-8" aria-hidden="true" tabindex="-1"></a><span class="co">Achtung, haeufiger Fehler: Sigma per A@A.T zu erzeugen und anschliessend die</span></span>
+<span id="cb118-9"><a href="#cb118-9" aria-hidden="true" tabindex="-1"></a><span class="co">Diagonale zu ueberschreiben zerstoert die positive Semidefinitheit - die</span></span>
+<span id="cb118-10"><a href="#cb118-10" aria-hidden="true" tabindex="-1"></a><span class="co">Matrix kann dadurch einen negativen Eigenwert bekommen und unmoegliche</span></span>
+<span id="cb118-11"><a href="#cb118-11" aria-hidden="true" tabindex="-1"></a><span class="co">Korrelationen (&gt; 1) implizieren. Dieses Programm baut Sigma stattdessen als</span></span>
+<span id="cb118-12"><a href="#cb118-12" aria-hidden="true" tabindex="-1"></a><span class="co">D * C * D aus Volatilitaeten und einer echten Korrelationsmatrix -</span></span>
+<span id="cb118-13"><a href="#cb118-13" aria-hidden="true" tabindex="-1"></a><span class="co">konstruktionsbedingt immer PSD.</span></span>
+<span id="cb118-14"><a href="#cb118-14" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb118-15"><a href="#cb118-15" aria-hidden="true" tabindex="-1"></a><span class="co">Zusaetzlich: Multistart, weil SLSQP nur lokale Optima findet.</span></span>
+<span id="cb118-16"><a href="#cb118-16" aria-hidden="true" tabindex="-1"></a><span class="co">&quot;&quot;&quot;</span></span>
+<span id="cb118-17"><a href="#cb118-17" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb118-18"><a href="#cb118-18" aria-hidden="true" tabindex="-1"></a><span class="im">import</span> numpy <span class="im">as</span> np</span>
+<span id="cb118-19"><a href="#cb118-19" aria-hidden="true" tabindex="-1"></a><span class="im">import</span> pandas <span class="im">as</span> pd</span>
+<span id="cb118-20"><a href="#cb118-20" aria-hidden="true" tabindex="-1"></a><span class="im">from</span> scipy.optimize <span class="im">import</span> minimize</span>
+<span id="cb118-21"><a href="#cb118-21" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb118-22"><a href="#cb118-22" aria-hidden="true" tabindex="-1"></a>ASSETS <span class="op">=</span> [<span class="st">&quot;Tech-Aktien&quot;</span>, <span class="st">&quot;Rohstoffe&quot;</span>, <span class="st">&quot;US-Treasuries&quot;</span>, <span class="st">&quot;Krypto&quot;</span>]</span>
+<span id="cb118-23"><a href="#cb118-23" aria-hidden="true" tabindex="-1"></a>MU <span class="op">=</span> np.array([<span class="fl">0.14</span>, <span class="fl">0.07</span>, <span class="fl">0.03</span>, <span class="fl">0.22</span>])          <span class="co"># erwartete Jahresrenditen</span></span>
+<span id="cb118-24"><a href="#cb118-24" aria-hidden="true" tabindex="-1"></a>VOLA <span class="op">=</span> np.array([<span class="fl">0.20</span>, <span class="fl">0.14</span>, <span class="fl">0.07</span>, <span class="fl">0.40</span>])        <span class="co"># Volatilitaeten p.a.</span></span>
+<span id="cb118-25"><a href="#cb118-25" aria-hidden="true" tabindex="-1"></a>KORRELATION <span class="op">=</span> np.array([</span>
+<span id="cb118-26"><a href="#cb118-26" aria-hidden="true" tabindex="-1"></a>    [<span class="fl">1.00</span>, <span class="fl">0.25</span>, <span class="op">-</span><span class="fl">0.10</span>, <span class="fl">0.55</span>],</span>
+<span id="cb118-27"><a href="#cb118-27" aria-hidden="true" tabindex="-1"></a>    [<span class="fl">0.25</span>, <span class="fl">1.00</span>, <span class="fl">0.05</span>, <span class="fl">0.20</span>],</span>
+<span id="cb118-28"><a href="#cb118-28" aria-hidden="true" tabindex="-1"></a>    [<span class="op">-</span><span class="fl">0.10</span>, <span class="fl">0.05</span>, <span class="fl">1.00</span>, <span class="op">-</span><span class="fl">0.15</span>],</span>
+<span id="cb118-29"><a href="#cb118-29" aria-hidden="true" tabindex="-1"></a>    [<span class="fl">0.55</span>, <span class="fl">0.20</span>, <span class="op">-</span><span class="fl">0.15</span>, <span class="fl">1.00</span>],</span>
+<span id="cb118-30"><a href="#cb118-30" aria-hidden="true" tabindex="-1"></a>])</span>
+<span id="cb118-31"><a href="#cb118-31" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb118-32"><a href="#cb118-32" aria-hidden="true" tabindex="-1"></a>ALPHA <span class="op">=</span> <span class="fl">1.0</span>        <span class="co"># Gewicht des Ertrags</span></span>
+<span id="cb118-33"><a href="#cb118-33" aria-hidden="true" tabindex="-1"></a>BETA <span class="op">=</span> <span class="fl">0.015</span>       <span class="co"># Gewicht der Entropie-Diversifikation</span></span>
+<span id="cb118-34"><a href="#cb118-34" aria-hidden="true" tabindex="-1"></a>UNTERGRENZE <span class="op">=</span> <span class="fl">0.001</span></span>
+<span id="cb118-35"><a href="#cb118-35" aria-hidden="true" tabindex="-1"></a>OBERGRENZE <span class="op">=</span> <span class="fl">0.80</span></span>
+<span id="cb118-36"><a href="#cb118-36" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb118-37"><a href="#cb118-37" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb118-38"><a href="#cb118-38" aria-hidden="true" tabindex="-1"></a><span class="kw">def</span> baue_kovarianz() <span class="op">-&gt;</span> np.ndarray:</span>
+<span id="cb118-39"><a href="#cb118-39" aria-hidden="true" tabindex="-1"></a>    <span class="co">&quot;&quot;&quot;Sigma = D * C * D. Immer PSD, wenn C eine gueltige Korrelationsmatrix ist.&quot;&quot;&quot;</span></span>
+<span id="cb118-40"><a href="#cb118-40" aria-hidden="true" tabindex="-1"></a>    eig_c <span class="op">=</span> np.linalg.eigvalsh(KORRELATION)</span>
+<span id="cb118-41"><a href="#cb118-41" aria-hidden="true" tabindex="-1"></a>    <span class="cf">if</span> eig_c.<span class="bu">min</span>() <span class="op">&lt;</span> <span class="op">-</span><span class="fl">1e-10</span>:</span>
+<span id="cb118-42"><a href="#cb118-42" aria-hidden="true" tabindex="-1"></a>        <span class="cf">raise</span> <span class="pp">ValueError</span>(<span class="ss">f&quot;Korrelationsmatrix unmoeglich (Eigenwert </span><span class="sc">{</span>eig_c<span class="sc">.</span><span class="bu">min</span>()<span class="sc">:.4f}</span><span class="ss">).&quot;</span>)</span>
+<span id="cb118-43"><a href="#cb118-43" aria-hidden="true" tabindex="-1"></a>    D <span class="op">=</span> np.diag(VOLA)</span>
+<span id="cb118-44"><a href="#cb118-44" aria-hidden="true" tabindex="-1"></a>    Sigma <span class="op">=</span> D <span class="op">@</span> KORRELATION <span class="op">@</span> D</span>
+<span id="cb118-45"><a href="#cb118-45" aria-hidden="true" tabindex="-1"></a>    eig_s <span class="op">=</span> np.linalg.eigvalsh(Sigma)</span>
+<span id="cb118-46"><a href="#cb118-46" aria-hidden="true" tabindex="-1"></a>    <span class="cf">assert</span> eig_s.<span class="bu">min</span>() <span class="op">&gt;</span> <span class="dv">0</span>, <span class="st">&quot;Sigma nicht positiv definit!&quot;</span></span>
+<span id="cb118-47"><a href="#cb118-47" aria-hidden="true" tabindex="-1"></a>    <span class="cf">return</span> Sigma</span>
+<span id="cb118-48"><a href="#cb118-48" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb118-49"><a href="#cb118-49" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb118-50"><a href="#cb118-50" aria-hidden="true" tabindex="-1"></a>SIGMA <span class="op">=</span> baue_kovarianz()</span>
+<span id="cb118-51"><a href="#cb118-51" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb118-52"><a href="#cb118-52" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb118-53"><a href="#cb118-53" aria-hidden="true" tabindex="-1"></a><span class="kw">def</span> zielfunktion(w, alpha<span class="op">=</span>ALPHA, beta<span class="op">=</span>BETA):</span>
+<span id="cb118-54"><a href="#cb118-54" aria-hidden="true" tabindex="-1"></a>    <span class="co">&quot;&quot;&quot;Risiko - Ertrag - Entropiepraemie (wird minimiert).&quot;&quot;&quot;</span></span>
+<span id="cb118-55"><a href="#cb118-55" aria-hidden="true" tabindex="-1"></a>    varianz <span class="op">=</span> <span class="fl">0.5</span> <span class="op">*</span> w <span class="op">@</span> SIGMA <span class="op">@</span> w</span>
+<span id="cb118-56"><a href="#cb118-56" aria-hidden="true" tabindex="-1"></a>    ertrag <span class="op">=</span> MU <span class="op">@</span> w</span>
+<span id="cb118-57"><a href="#cb118-57" aria-hidden="true" tabindex="-1"></a>    entropie <span class="op">=</span> <span class="op">-</span>np.<span class="bu">sum</span>(w <span class="op">*</span> np.log(w <span class="op">+</span> <span class="fl">1e-12</span>))</span>
+<span id="cb118-58"><a href="#cb118-58" aria-hidden="true" tabindex="-1"></a>    <span class="cf">return</span> varianz <span class="op">-</span> alpha <span class="op">*</span> ertrag <span class="op">-</span> beta <span class="op">*</span> entropie</span>
+<span id="cb118-59"><a href="#cb118-59" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb118-60"><a href="#cb118-60" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb118-61"><a href="#cb118-61" aria-hidden="true" tabindex="-1"></a><span class="kw">def</span> gradient(w, alpha<span class="op">=</span>ALPHA, beta<span class="op">=</span>BETA):</span>
+<span id="cb118-62"><a href="#cb118-62" aria-hidden="true" tabindex="-1"></a>    <span class="co">&quot;&quot;&quot;Exakter analytischer Gradient - beschleunigt und stabilisiert SLSQP.&quot;&quot;&quot;</span></span>
+<span id="cb118-63"><a href="#cb118-63" aria-hidden="true" tabindex="-1"></a>    grad_varianz <span class="op">=</span> SIGMA <span class="op">@</span> w                       <span class="co"># d/dw von 0.5 w&#39;Sigma w</span></span>
+<span id="cb118-64"><a href="#cb118-64" aria-hidden="true" tabindex="-1"></a>    grad_ertrag <span class="op">=</span> <span class="op">-</span>alpha <span class="op">*</span> MU</span>
+<span id="cb118-65"><a href="#cb118-65" aria-hidden="true" tabindex="-1"></a>    grad_entropie <span class="op">=</span> beta <span class="op">*</span> (np.log(w <span class="op">+</span> <span class="fl">1e-12</span>) <span class="op">+</span> <span class="fl">1.0</span>)</span>
+<span id="cb118-66"><a href="#cb118-66" aria-hidden="true" tabindex="-1"></a>    <span class="cf">return</span> grad_varianz <span class="op">+</span> grad_ertrag <span class="op">+</span> grad_entropie</span>
+<span id="cb118-67"><a href="#cb118-67" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb118-68"><a href="#cb118-68" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb118-69"><a href="#cb118-69" aria-hidden="true" tabindex="-1"></a><span class="kw">def</span> optimiere(startpunkt, alpha<span class="op">=</span>ALPHA, beta<span class="op">=</span>BETA):</span>
+<span id="cb118-70"><a href="#cb118-70" aria-hidden="true" tabindex="-1"></a>    <span class="co">&quot;&quot;&quot;alpha und beta werden durchgereicht - so bleibt die Funktion seiteneffektfrei.&quot;&quot;&quot;</span></span>
+<span id="cb118-71"><a href="#cb118-71" aria-hidden="true" tabindex="-1"></a>    <span class="cf">return</span> minimize(</span>
+<span id="cb118-72"><a href="#cb118-72" aria-hidden="true" tabindex="-1"></a>        zielfunktion, startpunkt, args<span class="op">=</span>(alpha, beta), jac<span class="op">=</span>gradient,</span>
+<span id="cb118-73"><a href="#cb118-73" aria-hidden="true" tabindex="-1"></a>        method<span class="op">=</span><span class="st">&quot;SLSQP&quot;</span>, bounds<span class="op">=</span>[(UNTERGRENZE, OBERGRENZE)] <span class="op">*</span> <span class="bu">len</span>(MU),</span>
+<span id="cb118-74"><a href="#cb118-74" aria-hidden="true" tabindex="-1"></a>        constraints<span class="op">=</span>({<span class="st">&quot;type&quot;</span>: <span class="st">&quot;eq&quot;</span>,</span>
+<span id="cb118-75"><a href="#cb118-75" aria-hidden="true" tabindex="-1"></a>                      <span class="st">&quot;fun&quot;</span>: <span class="kw">lambda</span> w: np.<span class="bu">sum</span>(w) <span class="op">-</span> <span class="fl">1.0</span>,</span>
+<span id="cb118-76"><a href="#cb118-76" aria-hidden="true" tabindex="-1"></a>                      <span class="st">&quot;jac&quot;</span>: <span class="kw">lambda</span> w: np.ones(<span class="bu">len</span>(MU))}),</span>
+<span id="cb118-77"><a href="#cb118-77" aria-hidden="true" tabindex="-1"></a>        options<span class="op">=</span>{<span class="st">&quot;ftol&quot;</span>: <span class="fl">1e-12</span>, <span class="st">&quot;maxiter&quot;</span>: <span class="dv">300</span>})</span>
+<span id="cb118-78"><a href="#cb118-78" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb118-79"><a href="#cb118-79" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb118-80"><a href="#cb118-80" aria-hidden="true" tabindex="-1"></a><span class="cf">if</span> <span class="va">__name__</span> <span class="op">==</span> <span class="st">&quot;__main__&quot;</span>:</span>
+<span id="cb118-81"><a href="#cb118-81" aria-hidden="true" tabindex="-1"></a>    n <span class="op">=</span> <span class="bu">len</span>(MU)</span>
+<span id="cb118-82"><a href="#cb118-82" aria-hidden="true" tabindex="-1"></a>    eig <span class="op">=</span> np.linalg.eigvalsh(SIGMA)</span>
+<span id="cb118-83"><a href="#cb118-83" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb118-84"><a href="#cb118-84" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;=&quot;</span> <span class="op">*</span> <span class="dv">74</span>)</span>
+<span id="cb118-85"><a href="#cb118-85" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;   NICHTLINEARE ENTROPIE-OPTIMIERTE ASSET-ALLOKATION&quot;</span>)</span>
+<span id="cb118-86"><a href="#cb118-86" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;=&quot;</span> <span class="op">*</span> <span class="dv">74</span>)</span>
+<span id="cb118-87"><a href="#cb118-87" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;Pruefung der Kovarianzmatrix:&quot;</span>)</span>
+<span id="cb118-88"><a href="#cb118-88" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;  Eigenwerte:          </span><span class="sc">{</span>np<span class="sc">.</span><span class="bu">round</span>(eig, <span class="dv">6</span>)<span class="sc">}</span><span class="ss">&quot;</span>)</span>
+<span id="cb118-89"><a href="#cb118-89" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;  Positiv definit:     </span><span class="sc">{</span><span class="bu">bool</span>(eig.<span class="bu">min</span>() <span class="op">&gt;</span> <span class="dv">0</span>)<span class="sc">}</span><span class="ss">&quot;</span>)</span>
+<span id="cb118-90"><a href="#cb118-90" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;  Groesste Korrelation ausserhalb der Diagonale: &quot;</span></span>
+<span id="cb118-91"><a href="#cb118-91" aria-hidden="true" tabindex="-1"></a>          <span class="ss">f&quot;</span><span class="sc">{</span>np<span class="sc">.</span><span class="bu">abs</span>(KORRELATION <span class="op">-</span> np.eye(n))<span class="sc">.</span><span class="bu">max</span>()<span class="sc">:.2f}</span><span class="ss">  (muss &lt;= 1 sein)&quot;</span>)</span>
+<span id="cb118-92"><a href="#cb118-92" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb118-93"><a href="#cb118-93" aria-hidden="true" tabindex="-1"></a>    <span class="co"># --- Multistart: SLSQP findet nur lokale Optima -----------------------</span></span>
+<span id="cb118-94"><a href="#cb118-94" aria-hidden="true" tabindex="-1"></a>    rng <span class="op">=</span> np.random.default_rng(<span class="dv">7</span>)</span>
+<span id="cb118-95"><a href="#cb118-95" aria-hidden="true" tabindex="-1"></a>    startpunkte <span class="op">=</span> [np.ones(n) <span class="op">/</span> n]                                  <span class="co"># Gleichgewichtung</span></span>
+<span id="cb118-96"><a href="#cb118-96" aria-hidden="true" tabindex="-1"></a>    <span class="cf">for</span> _ <span class="kw">in</span> <span class="bu">range</span>(<span class="dv">9</span>):</span>
+<span id="cb118-97"><a href="#cb118-97" aria-hidden="true" tabindex="-1"></a>        z <span class="op">=</span> rng.random(n) <span class="op">+</span> <span class="fl">0.05</span></span>
+<span id="cb118-98"><a href="#cb118-98" aria-hidden="true" tabindex="-1"></a>        startpunkte.append(z <span class="op">/</span> z.<span class="bu">sum</span>())</span>
+<span id="cb118-99"><a href="#cb118-99" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb118-100"><a href="#cb118-100" aria-hidden="true" tabindex="-1"></a>    ergebnisse <span class="op">=</span> [optimiere(s) <span class="cf">for</span> s <span class="kw">in</span> startpunkte]</span>
+<span id="cb118-101"><a href="#cb118-101" aria-hidden="true" tabindex="-1"></a>    erfolgreich <span class="op">=</span> [r <span class="cf">for</span> r <span class="kw">in</span> ergebnisse <span class="cf">if</span> r.success]</span>
+<span id="cb118-102"><a href="#cb118-102" aria-hidden="true" tabindex="-1"></a>    bestes <span class="op">=</span> <span class="bu">min</span>(erfolgreich, key<span class="op">=</span><span class="kw">lambda</span> r: r.fun)</span>
+<span id="cb118-103"><a href="#cb118-103" aria-hidden="true" tabindex="-1"></a>    zielwerte <span class="op">=</span> np.array([r.fun <span class="cf">for</span> r <span class="kw">in</span> erfolgreich])</span>
+<span id="cb118-104"><a href="#cb118-104" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb118-105"><a href="#cb118-105" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;</span><span class="ch">\n</span><span class="ss">Multistart mit </span><span class="sc">{</span><span class="bu">len</span>(startpunkte)<span class="sc">}</span><span class="ss"> Startpunkten:&quot;</span>)</span>
+<span id="cb118-106"><a href="#cb118-106" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;  Erfolgreich konvergiert: </span><span class="sc">{</span><span class="bu">len</span>(erfolgreich)<span class="sc">}</span><span class="ss">&quot;</span>)</span>
+<span id="cb118-107"><a href="#cb118-107" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;  Spannweite der Zielwerte: </span><span class="sc">{</span>zielwerte<span class="sc">.</span><span class="bu">max</span>() <span class="op">-</span> zielwerte<span class="sc">.</span><span class="bu">min</span>()<span class="sc">:.2e}</span><span class="ss">&quot;</span>)</span>
+<span id="cb118-108"><a href="#cb118-108" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;  -&gt; &quot;</span> <span class="op">+</span> (<span class="st">&quot;alle Startpunkte fuehren zum selben Optimum (Indiz fuer Konvexitaet)&quot;</span></span>
+<span id="cb118-109"><a href="#cb118-109" aria-hidden="true" tabindex="-1"></a>                     <span class="cf">if</span> zielwerte.<span class="bu">max</span>() <span class="op">-</span> zielwerte.<span class="bu">min</span>() <span class="op">&lt;</span> <span class="fl">1e-6</span></span>
+<span id="cb118-110"><a href="#cb118-110" aria-hidden="true" tabindex="-1"></a>                     <span class="cf">else</span> <span class="st">&quot;ACHTUNG: verschiedene lokale Optima gefunden!&quot;</span>))</span>
+<span id="cb118-111"><a href="#cb118-111" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb118-112"><a href="#cb118-112" aria-hidden="true" tabindex="-1"></a>    w_opt <span class="op">=</span> bestes.x</span>
+<span id="cb118-113"><a href="#cb118-113" aria-hidden="true" tabindex="-1"></a>    rendite <span class="op">=</span> MU <span class="op">@</span> w_opt</span>
+<span id="cb118-114"><a href="#cb118-114" aria-hidden="true" tabindex="-1"></a>    volatilitaet <span class="op">=</span> np.sqrt(w_opt <span class="op">@</span> SIGMA <span class="op">@</span> w_opt)</span>
+<span id="cb118-115"><a href="#cb118-115" aria-hidden="true" tabindex="-1"></a>    entropie <span class="op">=</span> <span class="op">-</span>np.<span class="bu">sum</span>(w_opt <span class="op">*</span> np.log(w_opt))</span>
+<span id="cb118-116"><a href="#cb118-116" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb118-117"><a href="#cb118-117" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;</span><span class="ch">\n</span><span class="ss">Konvergenz:                </span><span class="sc">{</span>bestes<span class="sc">.</span>message<span class="sc">}</span><span class="ss">&quot;</span>)</span>
+<span id="cb118-118"><a href="#cb118-118" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;Iterationen:               </span><span class="sc">{</span>bestes<span class="sc">.</span>nit<span class="sc">}</span><span class="ss">&quot;</span>)</span>
+<span id="cb118-119"><a href="#cb118-119" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;Erwartete Jahresrendite:   </span><span class="sc">{</span>rendite <span class="op">*</span> <span class="dv">100</span><span class="sc">:6.2f}</span><span class="ss"> %&quot;</span>)</span>
+<span id="cb118-120"><a href="#cb118-120" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;Erwartete Volatilitaet:    </span><span class="sc">{</span>volatilitaet <span class="op">*</span> <span class="dv">100</span><span class="sc">:6.2f}</span><span class="ss"> %&quot;</span>)</span>
+<span id="cb118-121"><a href="#cb118-121" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;Diversifikations-Entropie: </span><span class="sc">{</span>entropie<span class="sc">:.4f}</span><span class="ss"> &quot;</span></span>
+<span id="cb118-122"><a href="#cb118-122" aria-hidden="true" tabindex="-1"></a>          <span class="ss">f&quot;(Maximum bei Gleichgewichtung: </span><span class="sc">{</span>np<span class="sc">.</span>log(n)<span class="sc">:.4f}</span><span class="ss">)&quot;</span>)</span>
+<span id="cb118-123"><a href="#cb118-123" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb118-124"><a href="#cb118-124" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;</span><span class="ch">\n</span><span class="st">&quot;</span> <span class="op">+</span> pd.DataFrame({</span>
+<span id="cb118-125"><a href="#cb118-125" aria-hidden="true" tabindex="-1"></a>        <span class="st">&quot;Asset&quot;</span>: ASSETS,</span>
+<span id="cb118-126"><a href="#cb118-126" aria-hidden="true" tabindex="-1"></a>        <span class="st">&quot;Erw. Rendite&quot;</span>: [<span class="ss">f&quot;</span><span class="sc">{</span>r<span class="op">*</span><span class="dv">100</span><span class="sc">:.1f}</span><span class="ss"> %&quot;</span> <span class="cf">for</span> r <span class="kw">in</span> MU],</span>
+<span id="cb118-127"><a href="#cb118-127" aria-hidden="true" tabindex="-1"></a>        <span class="st">&quot;Volatilitaet&quot;</span>: [<span class="ss">f&quot;</span><span class="sc">{</span>v<span class="op">*</span><span class="dv">100</span><span class="sc">:.1f}</span><span class="ss"> %&quot;</span> <span class="cf">for</span> v <span class="kw">in</span> VOLA],</span>
+<span id="cb118-128"><a href="#cb118-128" aria-hidden="true" tabindex="-1"></a>        <span class="st">&quot;Gewicht&quot;</span>: [<span class="ss">f&quot;</span><span class="sc">{</span>w<span class="op">*</span><span class="dv">100</span><span class="sc">:6.2f}</span><span class="ss"> %&quot;</span> <span class="cf">for</span> w <span class="kw">in</span> w_opt],</span>
+<span id="cb118-129"><a href="#cb118-129" aria-hidden="true" tabindex="-1"></a>    }).to_string(index<span class="op">=</span><span class="va">False</span>))</span>
+<span id="cb118-130"><a href="#cb118-130" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb118-131"><a href="#cb118-131" aria-hidden="true" tabindex="-1"></a>    <span class="co"># --- Vergleich: was passiert ohne Entropieterm? ----------------------</span></span>
+<span id="cb118-132"><a href="#cb118-132" aria-hidden="true" tabindex="-1"></a>    ohne <span class="op">=</span> optimiere(np.ones(n) <span class="op">/</span> n, beta<span class="op">=</span><span class="fl">0.0</span>)</span>
+<span id="cb118-133"><a href="#cb118-133" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;</span><span class="ch">\n</span><span class="st">--- Wirkung des Entropieterms ---&quot;</span>)</span>
+<span id="cb118-134"><a href="#cb118-134" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;  Mit Entropie  (beta=</span><span class="sc">{</span>BETA<span class="sc">}</span><span class="ss">): Gewichte </span><span class="sc">{</span>np<span class="sc">.</span><span class="bu">round</span>(w_opt <span class="op">*</span> <span class="dv">100</span>, <span class="dv">1</span>)<span class="sc">}</span><span class="ss">&quot;</span>)</span>
+<span id="cb118-135"><a href="#cb118-135" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;  Ohne Entropie (beta=0):     Gewichte </span><span class="sc">{</span>np<span class="sc">.</span><span class="bu">round</span>(ohne.x <span class="op">*</span> <span class="dv">100</span>, <span class="dv">1</span>)<span class="sc">}</span><span class="ss">&quot;</span>)</span>
+<span id="cb118-136"><a href="#cb118-136" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;  Der Entropieterm zieht Kapital aus der Spitzenposition heraus,&quot;</span>)</span>
+<span id="cb118-137"><a href="#cb118-137" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;  ohne dass eine harte Obergrenze noetig waere.&quot;</span>)</span>
+<span id="cb118-138"><a href="#cb118-138" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;=&quot;</span> <span class="op">*</span> <span class="dv">74</span>)</span></code></pre></div>
 <p><strong>Erwartete Ausgabe:</strong></p>
 <pre><code>==========================================================================
    NICHTLINEARE ENTROPIE-OPTIMIERTE ASSET-ALLOKATION
@@ -15877,7 +16742,7 @@ US-Treasuries        3.0 %        7.0 %   0.45 %
 <li><strong>Multistart.</strong> Zehn Startpunkte, und die Spannweite der Ergebnisse wird gemessen. Sind alle gleich, ist das ein starkes Indiz für Konvexität. Weichen sie ab, wissen Sie sofort, dass Sie einem lokalen Optimum aufsitzen. Diese fünf Zeilen sollten in jedem SLSQP-Projekt stehen.</li>
 <li><strong>Analytischer Gradient.</strong> <code>jac=gradient</code> spart nicht nur Zeit — die numerische Approximation von Ableitungen ist bei Termen wie <span class="math inline">\ln w</span> nahe null numerisch heikel.</li>
 </ol>
-<p><strong>Zur Skalierung:</strong> Mit <span class="math inline">\alpha = 1</span> ist der Ertragsterm (<span class="math inline">\approx 0{,}1</span>) zehnmal größer als der Varianzterm (<span class="math inline">\approx 0{,}01</span>). Das Modell ist also stark renditegetrieben. Übung 8.5 lässt Sie diese Balance untersuchen — sie ist eine fachliche Entscheidung, keine technische.</p>
+<p><strong>Zur Skalierung:</strong> Mit <span class="math inline">\alpha = 1</span> ist der Ertragsterm (<span class="math inline">\approx 0{,}1</span>) zehnmal größer als der Varianzterm (<span class="math inline">\approx 0{,}01</span>). Das Modell ist also stark renditegetrieben. Die Aufgabe <em>Effekt der Gewichtung untersuchen</em> (<a href="#sec:qp-nlp-uebungsaufgaben">Abschnitt 11.7</a>) lässt Sie diese Balance untersuchen — sie ist eine fachliche Entscheidung, keine technische.</p>
 </blockquote>
 <hr />
 <h2 id="sec:qp-nlp-nichtkonvex">11.6 Jenseits der Konvexität: lokale Optima, Multistart und MINLP</h2>
@@ -15935,174 +16800,174 @@ US-Treasuries        3.0 %        7.0 %   0.45 %
 <p><em>„Ich bin an einer Stelle angekommen, an der es in keine Richtung mehr bergab geht.“</em></p>
 </blockquote>
 <p>Bei einem konvexen Problem ist das dasselbe. Bei einem nicht-konvexen sind es zwei völlig verschiedene Aussagen. Das folgende Programm macht den Unterschied sichtbar.</p>
-<div class="sourceCode" id="cb118"><pre class="sourceCode python"><code class="sourceCode python"><span id="cb118-1"><a href="#cb118-1" aria-hidden="true" tabindex="-1"></a><span class="co">#!/usr/bin/env python3</span></span>
-<span id="cb118-2"><a href="#cb118-2" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb118-3"><a href="#cb118-3" aria-hidden="true" tabindex="-1"></a><span class="co"># Lokale_Optima_Multistart.py</span></span>
-<span id="cb118-4"><a href="#cb118-4" aria-hidden="true" tabindex="-1"></a><span class="co">&quot;&quot;&quot;</span></span>
-<span id="cb118-5"><a href="#cb118-5" aria-hidden="true" tabindex="-1"></a><span class="co">Kapitel QP/NLP: Was passiert, wenn die Konvexitaet fehlt.</span></span>
-<span id="cb118-6"><a href="#cb118-6" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb118-7"><a href="#cb118-7" aria-hidden="true" tabindex="-1"></a><span class="co">CVXPY verweigert nicht-konvexe Probleme - das ist sein Schutzmechanismus.</span></span>
-<span id="cb118-8"><a href="#cb118-8" aria-hidden="true" tabindex="-1"></a><span class="co">scipy.optimize.minimize verweigert nichts. Es rechnet, meldet &#39;success: True&#39;</span></span>
-<span id="cb118-9"><a href="#cb118-9" aria-hidden="true" tabindex="-1"></a><span class="co">und liefert ein Ergebnis. Nur ist das Ergebnis dann kein Optimum, sondern</span></span>
-<span id="cb118-10"><a href="#cb118-10" aria-hidden="true" tabindex="-1"></a><span class="co">irgendein lokales Minimum, das vom Startpunkt abhaengt.</span></span>
-<span id="cb118-11"><a href="#cb118-11" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb118-12"><a href="#cb118-12" aria-hidden="true" tabindex="-1"></a><span class="co">Beispiel aus dem Einkauf: 700 Tonnen Rohstoff werden auf vier Lieferanten</span></span>
-<span id="cb118-13"><a href="#cb118-13" aria-hidden="true" tabindex="-1"></a><span class="co">verteilt. Jeder gewaehrt einen MENGENRABATT - der Stueckpreis faellt, je mehr</span></span>
-<span id="cb118-14"><a href="#cb118-14" aria-hidden="true" tabindex="-1"></a><span class="co">man bei ihm bestellt:</span></span>
-<span id="cb118-15"><a href="#cb118-15" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb118-16"><a href="#cb118-16" aria-hidden="true" tabindex="-1"></a><span class="co">    preis_i(q) = basis_i * (1 - rabatt_i * (1 - exp(-q / skala_i)))</span></span>
-<span id="cb118-17"><a href="#cb118-17" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb118-18"><a href="#cb118-18" aria-hidden="true" tabindex="-1"></a><span class="co">Genau das macht die Zielfunktion nicht-konvex: Grosse Bestellungen lohnen</span></span>
-<span id="cb118-19"><a href="#cb118-19" aria-hidden="true" tabindex="-1"></a><span class="co">sich ueberproportional, es gibt also mehrere sinnvolle &quot;Cluster&quot;-Loesungen -</span></span>
-<span id="cb118-20"><a href="#cb118-20" aria-hidden="true" tabindex="-1"></a><span class="co">und dazwischen schlechtere Taeler.</span></span>
-<span id="cb118-21"><a href="#cb118-21" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb118-22"><a href="#cb118-22" aria-hidden="true" tabindex="-1"></a><span class="co">Das Programm zeigt drei Dinge:</span></span>
-<span id="cb118-23"><a href="#cb118-23" aria-hidden="true" tabindex="-1"></a><span class="co">  1. Ein einzelner Lauf liefert ein plausibles Ergebnis - ohne jede Warnung.</span></span>
-<span id="cb118-24"><a href="#cb118-24" aria-hidden="true" tabindex="-1"></a><span class="co">  2. 200 Startpunkte foerdern mehrere verschiedene lokale Optima zutage.</span></span>
-<span id="cb118-25"><a href="#cb118-25" aria-hidden="true" tabindex="-1"></a><span class="co">  3. Der Unterschied zwischen bestem und schlechtestem betraegt hier 8 %.</span></span>
-<span id="cb118-26"><a href="#cb118-26" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb118-27"><a href="#cb118-27" aria-hidden="true" tabindex="-1"></a><span class="co">Benoetigt: numpy, scipy</span></span>
-<span id="cb118-28"><a href="#cb118-28" aria-hidden="true" tabindex="-1"></a><span class="co">&quot;&quot;&quot;</span></span>
-<span id="cb118-29"><a href="#cb118-29" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb118-30"><a href="#cb118-30" aria-hidden="true" tabindex="-1"></a><span class="im">from</span> __future__ <span class="im">import</span> annotations</span>
-<span id="cb118-31"><a href="#cb118-31" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb118-32"><a href="#cb118-32" aria-hidden="true" tabindex="-1"></a><span class="im">import</span> numpy <span class="im">as</span> np</span>
-<span id="cb118-33"><a href="#cb118-33" aria-hidden="true" tabindex="-1"></a><span class="im">from</span> scipy.optimize <span class="im">import</span> minimize</span>
-<span id="cb118-34"><a href="#cb118-34" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb118-35"><a href="#cb118-35" aria-hidden="true" tabindex="-1"></a><span class="co"># Vier Lieferanten</span></span>
-<span id="cb118-36"><a href="#cb118-36" aria-hidden="true" tabindex="-1"></a>NAMEN <span class="op">=</span> [<span class="st">&quot;Nord AG&quot;</span>, <span class="st">&quot;Ost GmbH&quot;</span>, <span class="st">&quot;Sued KG&quot;</span>, <span class="st">&quot;West SE&quot;</span>]</span>
-<span id="cb118-37"><a href="#cb118-37" aria-hidden="true" tabindex="-1"></a>BASISPREIS <span class="op">=</span> np.array([<span class="fl">50.0</span>, <span class="fl">47.0</span>, <span class="fl">53.0</span>, <span class="fl">45.0</span>])     <span class="co"># EUR je Tonne ohne Rabatt</span></span>
-<span id="cb118-38"><a href="#cb118-38" aria-hidden="true" tabindex="-1"></a>MAX_RABATT <span class="op">=</span> np.array([<span class="fl">0.30</span>, <span class="fl">0.18</span>, <span class="fl">0.35</span>, <span class="fl">0.12</span>])     <span class="co"># hoechstmoeglicher Rabatt</span></span>
-<span id="cb118-39"><a href="#cb118-39" aria-hidden="true" tabindex="-1"></a>RABATT_SKALA <span class="op">=</span> np.array([<span class="fl">120.0</span>, <span class="fl">260.0</span>, <span class="fl">90.0</span>, <span class="fl">300.0</span>])  <span class="co"># wie schnell er greift</span></span>
-<span id="cb118-40"><a href="#cb118-40" aria-hidden="true" tabindex="-1"></a>KAPAZITAET <span class="op">=</span> np.array([<span class="fl">400.0</span>, <span class="fl">400.0</span>, <span class="fl">400.0</span>, <span class="fl">400.0</span>])</span>
-<span id="cb118-41"><a href="#cb118-41" aria-hidden="true" tabindex="-1"></a>BEDARF <span class="op">=</span> <span class="fl">700.0</span></span>
-<span id="cb118-42"><a href="#cb118-42" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb118-43"><a href="#cb118-43" aria-hidden="true" tabindex="-1"></a>RNG <span class="op">=</span> np.random.default_rng(<span class="dv">0</span>)</span>
-<span id="cb118-44"><a href="#cb118-44" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb118-45"><a href="#cb118-45" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb118-46"><a href="#cb118-46" aria-hidden="true" tabindex="-1"></a><span class="kw">def</span> gesamtkosten(menge: np.ndarray) <span class="op">-&gt;</span> <span class="bu">float</span>:</span>
-<span id="cb118-47"><a href="#cb118-47" aria-hidden="true" tabindex="-1"></a>    <span class="co">&quot;&quot;&quot;Einkaufskosten bei mengenabhaengigem Stueckpreis.</span></span>
-<span id="cb118-48"><a href="#cb118-48" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb118-49"><a href="#cb118-49" aria-hidden="true" tabindex="-1"></a><span class="co">    Der Rabatt waechst mit der Bestellmenge und laeuft gegen MAX_RABATT.</span></span>
-<span id="cb118-50"><a href="#cb118-50" aria-hidden="true" tabindex="-1"></a><span class="co">    Dadurch ist der Stueckpreis fallend - und die Gesamtkostenfunktion</span></span>
-<span id="cb118-51"><a href="#cb118-51" aria-hidden="true" tabindex="-1"></a><span class="co">    nicht mehr konvex.</span></span>
-<span id="cb118-52"><a href="#cb118-52" aria-hidden="true" tabindex="-1"></a><span class="co">    &quot;&quot;&quot;</span></span>
-<span id="cb118-53"><a href="#cb118-53" aria-hidden="true" tabindex="-1"></a>    stueckpreis <span class="op">=</span> BASISPREIS <span class="op">*</span> (<span class="dv">1</span> <span class="op">-</span> MAX_RABATT <span class="op">*</span> (<span class="dv">1</span> <span class="op">-</span> np.exp(<span class="op">-</span>menge <span class="op">/</span> RABATT_SKALA)))</span>
-<span id="cb118-54"><a href="#cb118-54" aria-hidden="true" tabindex="-1"></a>    <span class="cf">return</span> <span class="bu">float</span>(stueckpreis <span class="op">@</span> menge)</span>
-<span id="cb118-55"><a href="#cb118-55" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb118-56"><a href="#cb118-56" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb118-57"><a href="#cb118-57" aria-hidden="true" tabindex="-1"></a>NEBENBEDINGUNGEN <span class="op">=</span> [{<span class="st">&quot;type&quot;</span>: <span class="st">&quot;eq&quot;</span>, <span class="st">&quot;fun&quot;</span>: <span class="kw">lambda</span> q: q.<span class="bu">sum</span>() <span class="op">-</span> BEDARF}]</span>
-<span id="cb118-58"><a href="#cb118-58" aria-hidden="true" tabindex="-1"></a>GRENZEN <span class="op">=</span> [(<span class="fl">0.0</span>, k) <span class="cf">for</span> k <span class="kw">in</span> KAPAZITAET]</span>
-<span id="cb118-59"><a href="#cb118-59" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb118-60"><a href="#cb118-60" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb118-61"><a href="#cb118-61" aria-hidden="true" tabindex="-1"></a><span class="kw">def</span> optimiere_von(startpunkt: np.ndarray):</span>
-<span id="cb118-62"><a href="#cb118-62" aria-hidden="true" tabindex="-1"></a>    <span class="co">&quot;&quot;&quot;Ein Lauf von einem gegebenen Startpunkt aus.&quot;&quot;&quot;</span></span>
-<span id="cb118-63"><a href="#cb118-63" aria-hidden="true" tabindex="-1"></a>    <span class="cf">return</span> minimize(gesamtkosten, startpunkt, method<span class="op">=</span><span class="st">&quot;SLSQP&quot;</span>,</span>
-<span id="cb118-64"><a href="#cb118-64" aria-hidden="true" tabindex="-1"></a>                    bounds<span class="op">=</span>GRENZEN, constraints<span class="op">=</span>NEBENBEDINGUNGEN)</span>
-<span id="cb118-65"><a href="#cb118-65" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb118-66"><a href="#cb118-66" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb118-67"><a href="#cb118-67" aria-hidden="true" tabindex="-1"></a><span class="kw">def</span> zufaelliger_start() <span class="op">-&gt;</span> np.ndarray:</span>
-<span id="cb118-68"><a href="#cb118-68" aria-hidden="true" tabindex="-1"></a>    <span class="co">&quot;&quot;&quot;Zufaellige Aufteilung, die den Bedarf bereits erfuellt.&quot;&quot;&quot;</span></span>
-<span id="cb118-69"><a href="#cb118-69" aria-hidden="true" tabindex="-1"></a>    anteil <span class="op">=</span> RNG.random(<span class="bu">len</span>(NAMEN))</span>
-<span id="cb118-70"><a href="#cb118-70" aria-hidden="true" tabindex="-1"></a>    <span class="cf">return</span> anteil <span class="op">/</span> anteil.<span class="bu">sum</span>() <span class="op">*</span> BEDARF</span>
-<span id="cb118-71"><a href="#cb118-71" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb118-72"><a href="#cb118-72" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb118-73"><a href="#cb118-73" aria-hidden="true" tabindex="-1"></a><span class="kw">def</span> zeige_plan(titel: <span class="bu">str</span>, menge: np.ndarray, kosten: <span class="bu">float</span>) <span class="op">-&gt;</span> <span class="va">None</span>:</span>
-<span id="cb118-74"><a href="#cb118-74" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;</span><span class="ch">\n</span><span class="sc">{</span>titel<span class="sc">}</span><span class="ss">&quot;</span>)</span>
-<span id="cb118-75"><a href="#cb118-75" aria-hidden="true" tabindex="-1"></a>    <span class="cf">for</span> name, m <span class="kw">in</span> <span class="bu">zip</span>(NAMEN, menge):</span>
-<span id="cb118-76"><a href="#cb118-76" aria-hidden="true" tabindex="-1"></a>        anteil <span class="op">=</span> m <span class="op">/</span> BEDARF <span class="op">*</span> <span class="dv">100</span></span>
-<span id="cb118-77"><a href="#cb118-77" aria-hidden="true" tabindex="-1"></a>        <span class="bu">print</span>(<span class="ss">f&quot;    </span><span class="sc">{</span>name<span class="sc">:&lt;10}</span><span class="ss"> </span><span class="sc">{</span>m<span class="sc">:7.1f}</span><span class="ss"> t  (</span><span class="sc">{</span>anteil<span class="sc">:4.1f}</span><span class="ss"> %)&quot;</span>)</span>
-<span id="cb118-78"><a href="#cb118-78" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;    </span><span class="sc">{</span><span class="st">&#39;Gesamtkosten&#39;</span><span class="sc">:&lt;10}</span><span class="ss"> </span><span class="sc">{</span>kosten<span class="sc">:9,.2f}</span><span class="ss"> EUR&quot;</span>)</span>
-<span id="cb118-79"><a href="#cb118-79" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb118-80"><a href="#cb118-80" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb118-81"><a href="#cb118-81" aria-hidden="true" tabindex="-1"></a><span class="cf">if</span> <span class="va">__name__</span> <span class="op">==</span> <span class="st">&quot;__main__&quot;</span>:</span>
-<span id="cb118-82"><a href="#cb118-82" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;=&quot;</span> <span class="op">*</span> <span class="dv">78</span>)</span>
-<span id="cb118-83"><a href="#cb118-83" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;  NICHT-KONVEX: DERSELBE CODE, VERSCHIEDENE ERGEBNISSE&quot;</span>)</span>
-<span id="cb118-84"><a href="#cb118-84" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;=&quot;</span> <span class="op">*</span> <span class="dv">78</span>)</span>
-<span id="cb118-85"><a href="#cb118-85" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;</span><span class="sc">{</span>BEDARF<span class="sc">:.0f}</span><span class="ss"> t Rohstoff auf </span><span class="sc">{</span><span class="bu">len</span>(NAMEN)<span class="sc">}</span><span class="ss"> Lieferanten mit Mengenrabatt.&quot;</span>)</span>
-<span id="cb118-86"><a href="#cb118-86" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb118-87"><a href="#cb118-87" aria-hidden="true" tabindex="-1"></a>    <span class="co"># --- 1. Ein einziger Lauf, so wie man es zuerst schreibt --------------</span></span>
-<span id="cb118-88"><a href="#cb118-88" aria-hidden="true" tabindex="-1"></a>    erster <span class="op">=</span> optimiere_von(np.full(<span class="bu">len</span>(NAMEN), BEDARF <span class="op">/</span> <span class="bu">len</span>(NAMEN)))</span>
-<span id="cb118-89"><a href="#cb118-89" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;</span><span class="ch">\n</span><span class="ss">[1] EIN Lauf, Startpunkt &#39;gleichmaessig verteilt&#39;&quot;</span>)</span>
-<span id="cb118-90"><a href="#cb118-90" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;    scipy meldet: success=</span><span class="sc">{</span>erster<span class="sc">.</span>success<span class="sc">}</span><span class="ss">, &quot;</span></span>
-<span id="cb118-91"><a href="#cb118-91" aria-hidden="true" tabindex="-1"></a>          <span class="ss">f&quot;&#39;</span><span class="sc">{</span>erster<span class="sc">.</span>message<span class="sc">}</span><span class="ss">&#39;&quot;</span>)</span>
-<span id="cb118-92"><a href="#cb118-92" aria-hidden="true" tabindex="-1"></a>    zeige_plan(<span class="st">&quot;    Ergebnis:&quot;</span>, erster.x, erster.fun)</span>
-<span id="cb118-93"><a href="#cb118-93" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;</span><span class="ch">\n</span><span class="st">    Nichts an dieser Ausgabe deutet darauf hin, dass etwas fehlt.&quot;</span>)</span>
-<span id="cb118-94"><a href="#cb118-94" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb118-95"><a href="#cb118-95" aria-hidden="true" tabindex="-1"></a>    <span class="co"># --- 1b. Der kaufmaennisch naheliegende Startpunkt --------------------</span></span>
-<span id="cb118-96"><a href="#cb118-96" aria-hidden="true" tabindex="-1"></a>    <span class="co"># &quot;Kaufe bei den beiden Lieferanten mit dem guenstigsten Basispreis&quot; -</span></span>
-<span id="cb118-97"><a href="#cb118-97" aria-hidden="true" tabindex="-1"></a>    <span class="co"># West SE (45) und Ost GmbH (47), jeweils bis zur Kapazitaetsgrenze.</span></span>
-<span id="cb118-98"><a href="#cb118-98" aria-hidden="true" tabindex="-1"></a>    guenstigste <span class="op">=</span> np.argsort(BASISPREIS)[:<span class="dv">2</span>]</span>
-<span id="cb118-99"><a href="#cb118-99" aria-hidden="true" tabindex="-1"></a>    kaufmaennisch <span class="op">=</span> np.zeros(<span class="bu">len</span>(NAMEN))</span>
-<span id="cb118-100"><a href="#cb118-100" aria-hidden="true" tabindex="-1"></a>    rest <span class="op">=</span> BEDARF</span>
-<span id="cb118-101"><a href="#cb118-101" aria-hidden="true" tabindex="-1"></a>    <span class="cf">for</span> i <span class="kw">in</span> guenstigste:</span>
-<span id="cb118-102"><a href="#cb118-102" aria-hidden="true" tabindex="-1"></a>        kaufmaennisch[i] <span class="op">=</span> <span class="bu">min</span>(KAPAZITAET[i], rest)</span>
-<span id="cb118-103"><a href="#cb118-103" aria-hidden="true" tabindex="-1"></a>        rest <span class="op">-=</span> kaufmaennisch[i]</span>
-<span id="cb118-104"><a href="#cb118-104" aria-hidden="true" tabindex="-1"></a>    zweiter <span class="op">=</span> optimiere_von(kaufmaennisch)</span>
-<span id="cb118-105"><a href="#cb118-105" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;</span><span class="ch">\n</span><span class="ss">[1b] EIN Lauf, Startpunkt &#39;die zwei mit dem guenstigsten Basispreis&#39;&quot;</span>)</span>
-<span id="cb118-106"><a href="#cb118-106" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;    scipy meldet: success=</span><span class="sc">{</span>zweiter<span class="sc">.</span>success<span class="sc">}</span><span class="ss">&quot;</span>)</span>
-<span id="cb118-107"><a href="#cb118-107" aria-hidden="true" tabindex="-1"></a>    zeige_plan(<span class="st">&quot;    Ergebnis:&quot;</span>, zweiter.x, zweiter.fun)</span>
-<span id="cb118-108"><a href="#cb118-108" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;</span><span class="ch">\n</span><span class="ss">    Dasselbe Programm, derselbe Aufruf, ein anderer Startpunkt -&quot;</span>)</span>
-<span id="cb118-109"><a href="#cb118-109" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;    und </span><span class="sc">{</span>zweiter<span class="sc">.</span>fun <span class="op">-</span> erster<span class="sc">.</span>fun<span class="sc">:,.2f}</span><span class="ss"> EUR Unterschied &quot;</span></span>
-<span id="cb118-110"><a href="#cb118-110" aria-hidden="true" tabindex="-1"></a>          <span class="ss">f&quot;(</span><span class="sc">{</span>(zweiter.fun <span class="op">/</span> erster.fun <span class="op">-</span> <span class="dv">1</span>) <span class="op">*</span> <span class="dv">100</span><span class="sc">:.1f}</span><span class="ss"> %).&quot;</span>)</span>
-<span id="cb118-111"><a href="#cb118-111" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb118-112"><a href="#cb118-112" aria-hidden="true" tabindex="-1"></a>    <span class="co"># --- 2. Multistart: dasselbe Problem, viele Startpunkte ---------------</span></span>
-<span id="cb118-113"><a href="#cb118-113" aria-hidden="true" tabindex="-1"></a>    laeufe <span class="op">=</span> []</span>
-<span id="cb118-114"><a href="#cb118-114" aria-hidden="true" tabindex="-1"></a>    <span class="cf">for</span> _ <span class="kw">in</span> <span class="bu">range</span>(<span class="dv">200</span>):</span>
-<span id="cb118-115"><a href="#cb118-115" aria-hidden="true" tabindex="-1"></a>        ergebnis <span class="op">=</span> optimiere_von(zufaelliger_start())</span>
-<span id="cb118-116"><a href="#cb118-116" aria-hidden="true" tabindex="-1"></a>        <span class="cf">if</span> ergebnis.success:</span>
-<span id="cb118-117"><a href="#cb118-117" aria-hidden="true" tabindex="-1"></a>            laeufe.append((<span class="bu">float</span>(ergebnis.fun), ergebnis.x))</span>
-<span id="cb118-118"><a href="#cb118-118" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb118-119"><a href="#cb118-119" aria-hidden="true" tabindex="-1"></a>    <span class="co"># Ergebnisse, die sich um weniger als 1 Cent unterscheiden, sind dasselbe</span></span>
-<span id="cb118-120"><a href="#cb118-120" aria-hidden="true" tabindex="-1"></a>    <span class="co"># lokale Optimum - zusammenfassen, sonst zaehlt man Rundungsrauschen.</span></span>
-<span id="cb118-121"><a href="#cb118-121" aria-hidden="true" tabindex="-1"></a>    optima: <span class="bu">list</span>[<span class="bu">tuple</span>[<span class="bu">float</span>, np.ndarray]] <span class="op">=</span> []</span>
-<span id="cb118-122"><a href="#cb118-122" aria-hidden="true" tabindex="-1"></a>    <span class="cf">for</span> wert, plan <span class="kw">in</span> <span class="bu">sorted</span>(laeufe, key<span class="op">=</span><span class="kw">lambda</span> t: t[<span class="dv">0</span>]):</span>
-<span id="cb118-123"><a href="#cb118-123" aria-hidden="true" tabindex="-1"></a>        <span class="cf">if</span> <span class="kw">not</span> optima <span class="kw">or</span> <span class="bu">abs</span>(wert <span class="op">-</span> optima[<span class="op">-</span><span class="dv">1</span>][<span class="dv">0</span>]) <span class="op">&gt;</span> <span class="fl">0.01</span>:</span>
-<span id="cb118-124"><a href="#cb118-124" aria-hidden="true" tabindex="-1"></a>            optima.append((wert, plan))</span>
-<span id="cb118-125"><a href="#cb118-125" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb118-126"><a href="#cb118-126" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;</span><span class="ch">\n</span><span class="st">&quot;</span> <span class="op">+</span> <span class="st">&quot;=&quot;</span> <span class="op">*</span> <span class="dv">78</span>)</span>
-<span id="cb118-127"><a href="#cb118-127" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;[2] 200 zufaellige Startpunkte -&gt; </span><span class="sc">{</span><span class="bu">len</span>(laeufe)<span class="sc">}</span><span class="ss"> erfolgreiche Laeufe&quot;</span>)</span>
-<span id="cb118-128"><a href="#cb118-128" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;    darunter </span><span class="sc">{</span><span class="bu">len</span>(optima)<span class="sc">}</span><span class="ss"> VERSCHIEDENE lokale Optima:&quot;</span>)</span>
-<span id="cb118-129"><a href="#cb118-129" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>()</span>
-<span id="cb118-130"><a href="#cb118-130" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;    </span><span class="sc">{</span><span class="st">&#39;Rang&#39;</span><span class="sc">:&gt;5}</span><span class="ss"> </span><span class="sc">{</span><span class="st">&#39;Kosten&#39;</span><span class="sc">:&gt;13}</span><span class="ss"> </span><span class="sc">{</span><span class="st">&#39;Abstand zum besten&#39;</span><span class="sc">:&gt;20}</span><span class="ss">   Aufteilung (t)&quot;</span>)</span>
-<span id="cb118-131"><a href="#cb118-131" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;    &quot;</span> <span class="op">+</span> <span class="st">&quot;-&quot;</span> <span class="op">*</span> <span class="dv">70</span>)</span>
-<span id="cb118-132"><a href="#cb118-132" aria-hidden="true" tabindex="-1"></a>    bester <span class="op">=</span> optima[<span class="dv">0</span>][<span class="dv">0</span>]</span>
-<span id="cb118-133"><a href="#cb118-133" aria-hidden="true" tabindex="-1"></a>    <span class="cf">for</span> rang, (wert, plan) <span class="kw">in</span> <span class="bu">enumerate</span>(optima, start<span class="op">=</span><span class="dv">1</span>):</span>
-<span id="cb118-134"><a href="#cb118-134" aria-hidden="true" tabindex="-1"></a>        abstand <span class="op">=</span> (wert <span class="op">/</span> bester <span class="op">-</span> <span class="dv">1</span>) <span class="op">*</span> <span class="dv">100</span></span>
-<span id="cb118-135"><a href="#cb118-135" aria-hidden="true" tabindex="-1"></a>        aufteilung <span class="op">=</span> <span class="st">&quot; &quot;</span>.join(<span class="ss">f&quot;</span><span class="sc">{</span>m<span class="sc">:5.0f}</span><span class="ss">&quot;</span> <span class="cf">for</span> m <span class="kw">in</span> plan)</span>
-<span id="cb118-136"><a href="#cb118-136" aria-hidden="true" tabindex="-1"></a>        <span class="bu">print</span>(<span class="ss">f&quot;    </span><span class="sc">{</span>rang<span class="sc">:&gt;5}</span><span class="ss"> </span><span class="sc">{</span>wert<span class="sc">:&gt;13,.2f}</span><span class="ss"> </span><span class="sc">{</span>abstand<span class="sc">:&gt;19.2f}</span><span class="ss"> %   </span><span class="sc">{</span>aufteilung<span class="sc">}</span><span class="ss">&quot;</span>)</span>
-<span id="cb118-137"><a href="#cb118-137" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb118-138"><a href="#cb118-138" aria-hidden="true" tabindex="-1"></a>    <span class="co"># --- 3. Was das kostet ------------------------------------------------</span></span>
-<span id="cb118-139"><a href="#cb118-139" aria-hidden="true" tabindex="-1"></a>    schlechtester <span class="op">=</span> optima[<span class="op">-</span><span class="dv">1</span>]</span>
-<span id="cb118-140"><a href="#cb118-140" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;</span><span class="ch">\n</span><span class="st">&quot;</span> <span class="op">+</span> <span class="st">&quot;=&quot;</span> <span class="op">*</span> <span class="dv">78</span>)</span>
-<span id="cb118-141"><a href="#cb118-141" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;  WAS AUF DEM SPIEL STEHT&quot;</span>)</span>
-<span id="cb118-142"><a href="#cb118-142" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;=&quot;</span> <span class="op">*</span> <span class="dv">78</span>)</span>
-<span id="cb118-143"><a href="#cb118-143" aria-hidden="true" tabindex="-1"></a>    zeige_plan(<span class="st">&quot;Bester gefundener Plan:&quot;</span>, optima[<span class="dv">0</span>][<span class="dv">1</span>], optima[<span class="dv">0</span>][<span class="dv">0</span>])</span>
-<span id="cb118-144"><a href="#cb118-144" aria-hidden="true" tabindex="-1"></a>    zeige_plan(<span class="st">&quot;Schlechtestes lokales Optimum:&quot;</span>, schlechtester[<span class="dv">1</span>], schlechtester[<span class="dv">0</span>])</span>
-<span id="cb118-145"><a href="#cb118-145" aria-hidden="true" tabindex="-1"></a>    unterschied <span class="op">=</span> schlechtester[<span class="dv">0</span>] <span class="op">-</span> optima[<span class="dv">0</span>][<span class="dv">0</span>]</span>
-<span id="cb118-146"><a href="#cb118-146" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;</span><span class="ch">\n</span><span class="ss">  Unterschied: </span><span class="sc">{</span>unterschied<span class="sc">:,.2f}</span><span class="ss"> EUR &quot;</span></span>
-<span id="cb118-147"><a href="#cb118-147" aria-hidden="true" tabindex="-1"></a>          <span class="ss">f&quot;(</span><span class="sc">{</span>unterschied <span class="op">/</span> optima[<span class="dv">0</span>][<span class="dv">0</span>] <span class="op">*</span> <span class="dv">100</span><span class="sc">:.1f}</span><span class="ss"> %)&quot;</span>)</span>
-<span id="cb118-148"><a href="#cb118-148" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;</span><span class="ch">\n</span><span class="ss">  Lauf [1]  (gleichmaessiger Start):     </span><span class="sc">{</span>erster<span class="sc">.</span>fun<span class="sc">:&gt;10,.2f}</span><span class="ss"> EUR&quot;</span>)</span>
-<span id="cb118-149"><a href="#cb118-149" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;  Lauf [1b] (kaufmaennischer Start):    </span><span class="sc">{</span>zweiter<span class="sc">.</span>fun<span class="sc">:&gt;10,.2f}</span><span class="ss"> EUR&quot;</span></span>
-<span id="cb118-150"><a href="#cb118-150" aria-hidden="true" tabindex="-1"></a>          <span class="ss">f&quot;   &lt;- </span><span class="sc">{</span>(zweiter.fun <span class="op">/</span> optima[<span class="dv">0</span>][<span class="dv">0</span>] <span class="op">-</span> <span class="dv">1</span>) <span class="op">*</span> <span class="dv">100</span><span class="sc">:.1f}</span><span class="ss"> % ueber dem besten&quot;</span>)</span>
-<span id="cb118-151"><a href="#cb118-151" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>()</span>
-<span id="cb118-152"><a href="#cb118-152" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;  Bemerkenswert: Der kaufmaennisch NAHELIEGENDE Startpunkt fuehrt in&quot;</span>)</span>
-<span id="cb118-153"><a href="#cb118-153" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;  das schlechteste Ergebnis von allen - schlechter als jedes der 200&quot;</span>)</span>
-<span id="cb118-154"><a href="#cb118-154" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;  zufaellig gefundenen lokalen Optima. Wer beim guenstigsten&quot;</span>)</span>
-<span id="cb118-155"><a href="#cb118-155" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;  Basispreis anfaengt, uebersieht, dass hier der Mengenrabatt&quot;</span>)</span>
-<span id="cb118-156"><a href="#cb118-156" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;  entscheidet und nicht der Listenpreis.&quot;</span>)</span>
-<span id="cb118-157"><a href="#cb118-157" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb118-158"><a href="#cb118-158" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>()</span>
-<span id="cb118-159"><a href="#cb118-159" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;Drei Konsequenzen fuer die Praxis:&quot;</span>)</span>
-<span id="cb118-160"><a href="#cb118-160" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;  1. &#39;success: True&#39; heisst bei nicht-konvexen Problemen NICHT &#39;optimal&#39;.&quot;</span>)</span>
-<span id="cb118-161"><a href="#cb118-161" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;     Es heisst nur: &#39;Ich bin an einer Stelle angekommen, an der es in&quot;</span>)</span>
-<span id="cb118-162"><a href="#cb118-162" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;     keine Richtung mehr bergab geht.&#39;&quot;</span>)</span>
-<span id="cb118-163"><a href="#cb118-163" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;  2. Ein einzelner Lauf ist wertlos. Nehmen Sie viele Startpunkte und&quot;</span>)</span>
-<span id="cb118-164"><a href="#cb118-164" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;     berichten Sie die STREUUNG mit - sie ist Ihre einzige Auskunft&quot;</span>)</span>
-<span id="cb118-165"><a href="#cb118-165" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;     darueber, wie zerklueftet die Landschaft ist.&quot;</span>)</span>
-<span id="cb118-166"><a href="#cb118-166" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;  3. Auch Multistart liefert KEINE Garantie. Dass hier nichts unter&quot;</span>)</span>
-<span id="cb118-167"><a href="#cb118-167" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;     </span><span class="sc">{</span>bester<span class="sc">:,.2f}</span><span class="ss"> EUR gefunden wurde, beweist nicht, dass es nichts gibt.&quot;</span>)</span>
-<span id="cb118-168"><a href="#cb118-168" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;=&quot;</span> <span class="op">*</span> <span class="dv">78</span>)</span></code></pre></div>
+<div class="sourceCode" id="cb120"><pre class="sourceCode python"><code class="sourceCode python"><span id="cb120-1"><a href="#cb120-1" aria-hidden="true" tabindex="-1"></a><span class="co">#!/usr/bin/env python3</span></span>
+<span id="cb120-2"><a href="#cb120-2" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb120-3"><a href="#cb120-3" aria-hidden="true" tabindex="-1"></a><span class="co"># Lokale_Optima_Multistart.py</span></span>
+<span id="cb120-4"><a href="#cb120-4" aria-hidden="true" tabindex="-1"></a><span class="co">&quot;&quot;&quot;</span></span>
+<span id="cb120-5"><a href="#cb120-5" aria-hidden="true" tabindex="-1"></a><span class="co">Kapitel QP/NLP: Was passiert, wenn die Konvexitaet fehlt.</span></span>
+<span id="cb120-6"><a href="#cb120-6" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb120-7"><a href="#cb120-7" aria-hidden="true" tabindex="-1"></a><span class="co">CVXPY verweigert nicht-konvexe Probleme - das ist sein Schutzmechanismus.</span></span>
+<span id="cb120-8"><a href="#cb120-8" aria-hidden="true" tabindex="-1"></a><span class="co">scipy.optimize.minimize verweigert nichts. Es rechnet, meldet &#39;success: True&#39;</span></span>
+<span id="cb120-9"><a href="#cb120-9" aria-hidden="true" tabindex="-1"></a><span class="co">und liefert ein Ergebnis. Nur ist das Ergebnis dann kein Optimum, sondern</span></span>
+<span id="cb120-10"><a href="#cb120-10" aria-hidden="true" tabindex="-1"></a><span class="co">irgendein lokales Minimum, das vom Startpunkt abhaengt.</span></span>
+<span id="cb120-11"><a href="#cb120-11" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb120-12"><a href="#cb120-12" aria-hidden="true" tabindex="-1"></a><span class="co">Beispiel aus dem Einkauf: 700 Tonnen Rohstoff werden auf vier Lieferanten</span></span>
+<span id="cb120-13"><a href="#cb120-13" aria-hidden="true" tabindex="-1"></a><span class="co">verteilt. Jeder gewaehrt einen MENGENRABATT - der Stueckpreis faellt, je mehr</span></span>
+<span id="cb120-14"><a href="#cb120-14" aria-hidden="true" tabindex="-1"></a><span class="co">man bei ihm bestellt:</span></span>
+<span id="cb120-15"><a href="#cb120-15" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb120-16"><a href="#cb120-16" aria-hidden="true" tabindex="-1"></a><span class="co">    preis_i(q) = basis_i * (1 - rabatt_i * (1 - exp(-q / skala_i)))</span></span>
+<span id="cb120-17"><a href="#cb120-17" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb120-18"><a href="#cb120-18" aria-hidden="true" tabindex="-1"></a><span class="co">Genau das macht die Zielfunktion nicht-konvex: Grosse Bestellungen lohnen</span></span>
+<span id="cb120-19"><a href="#cb120-19" aria-hidden="true" tabindex="-1"></a><span class="co">sich ueberproportional, es gibt also mehrere sinnvolle &quot;Cluster&quot;-Loesungen -</span></span>
+<span id="cb120-20"><a href="#cb120-20" aria-hidden="true" tabindex="-1"></a><span class="co">und dazwischen schlechtere Taeler.</span></span>
+<span id="cb120-21"><a href="#cb120-21" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb120-22"><a href="#cb120-22" aria-hidden="true" tabindex="-1"></a><span class="co">Das Programm zeigt drei Dinge:</span></span>
+<span id="cb120-23"><a href="#cb120-23" aria-hidden="true" tabindex="-1"></a><span class="co">  1. Ein einzelner Lauf liefert ein plausibles Ergebnis - ohne jede Warnung.</span></span>
+<span id="cb120-24"><a href="#cb120-24" aria-hidden="true" tabindex="-1"></a><span class="co">  2. 200 Startpunkte foerdern mehrere verschiedene lokale Optima zutage.</span></span>
+<span id="cb120-25"><a href="#cb120-25" aria-hidden="true" tabindex="-1"></a><span class="co">  3. Der Unterschied zwischen bestem und schlechtestem betraegt hier 8 %.</span></span>
+<span id="cb120-26"><a href="#cb120-26" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb120-27"><a href="#cb120-27" aria-hidden="true" tabindex="-1"></a><span class="co">Benoetigt: numpy, scipy</span></span>
+<span id="cb120-28"><a href="#cb120-28" aria-hidden="true" tabindex="-1"></a><span class="co">&quot;&quot;&quot;</span></span>
+<span id="cb120-29"><a href="#cb120-29" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb120-30"><a href="#cb120-30" aria-hidden="true" tabindex="-1"></a><span class="im">from</span> __future__ <span class="im">import</span> annotations</span>
+<span id="cb120-31"><a href="#cb120-31" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb120-32"><a href="#cb120-32" aria-hidden="true" tabindex="-1"></a><span class="im">import</span> numpy <span class="im">as</span> np</span>
+<span id="cb120-33"><a href="#cb120-33" aria-hidden="true" tabindex="-1"></a><span class="im">from</span> scipy.optimize <span class="im">import</span> minimize</span>
+<span id="cb120-34"><a href="#cb120-34" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb120-35"><a href="#cb120-35" aria-hidden="true" tabindex="-1"></a><span class="co"># Vier Lieferanten</span></span>
+<span id="cb120-36"><a href="#cb120-36" aria-hidden="true" tabindex="-1"></a>NAMEN <span class="op">=</span> [<span class="st">&quot;Nord AG&quot;</span>, <span class="st">&quot;Ost GmbH&quot;</span>, <span class="st">&quot;Sued KG&quot;</span>, <span class="st">&quot;West SE&quot;</span>]</span>
+<span id="cb120-37"><a href="#cb120-37" aria-hidden="true" tabindex="-1"></a>BASISPREIS <span class="op">=</span> np.array([<span class="fl">50.0</span>, <span class="fl">47.0</span>, <span class="fl">53.0</span>, <span class="fl">45.0</span>])     <span class="co"># EUR je Tonne ohne Rabatt</span></span>
+<span id="cb120-38"><a href="#cb120-38" aria-hidden="true" tabindex="-1"></a>MAX_RABATT <span class="op">=</span> np.array([<span class="fl">0.30</span>, <span class="fl">0.18</span>, <span class="fl">0.35</span>, <span class="fl">0.12</span>])     <span class="co"># hoechstmoeglicher Rabatt</span></span>
+<span id="cb120-39"><a href="#cb120-39" aria-hidden="true" tabindex="-1"></a>RABATT_SKALA <span class="op">=</span> np.array([<span class="fl">120.0</span>, <span class="fl">260.0</span>, <span class="fl">90.0</span>, <span class="fl">300.0</span>])  <span class="co"># wie schnell er greift</span></span>
+<span id="cb120-40"><a href="#cb120-40" aria-hidden="true" tabindex="-1"></a>KAPAZITAET <span class="op">=</span> np.array([<span class="fl">400.0</span>, <span class="fl">400.0</span>, <span class="fl">400.0</span>, <span class="fl">400.0</span>])</span>
+<span id="cb120-41"><a href="#cb120-41" aria-hidden="true" tabindex="-1"></a>BEDARF <span class="op">=</span> <span class="fl">700.0</span></span>
+<span id="cb120-42"><a href="#cb120-42" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb120-43"><a href="#cb120-43" aria-hidden="true" tabindex="-1"></a>RNG <span class="op">=</span> np.random.default_rng(<span class="dv">0</span>)</span>
+<span id="cb120-44"><a href="#cb120-44" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb120-45"><a href="#cb120-45" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb120-46"><a href="#cb120-46" aria-hidden="true" tabindex="-1"></a><span class="kw">def</span> gesamtkosten(menge: np.ndarray) <span class="op">-&gt;</span> <span class="bu">float</span>:</span>
+<span id="cb120-47"><a href="#cb120-47" aria-hidden="true" tabindex="-1"></a>    <span class="co">&quot;&quot;&quot;Einkaufskosten bei mengenabhaengigem Stueckpreis.</span></span>
+<span id="cb120-48"><a href="#cb120-48" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb120-49"><a href="#cb120-49" aria-hidden="true" tabindex="-1"></a><span class="co">    Der Rabatt waechst mit der Bestellmenge und laeuft gegen MAX_RABATT.</span></span>
+<span id="cb120-50"><a href="#cb120-50" aria-hidden="true" tabindex="-1"></a><span class="co">    Dadurch ist der Stueckpreis fallend - und die Gesamtkostenfunktion</span></span>
+<span id="cb120-51"><a href="#cb120-51" aria-hidden="true" tabindex="-1"></a><span class="co">    nicht mehr konvex.</span></span>
+<span id="cb120-52"><a href="#cb120-52" aria-hidden="true" tabindex="-1"></a><span class="co">    &quot;&quot;&quot;</span></span>
+<span id="cb120-53"><a href="#cb120-53" aria-hidden="true" tabindex="-1"></a>    stueckpreis <span class="op">=</span> BASISPREIS <span class="op">*</span> (<span class="dv">1</span> <span class="op">-</span> MAX_RABATT <span class="op">*</span> (<span class="dv">1</span> <span class="op">-</span> np.exp(<span class="op">-</span>menge <span class="op">/</span> RABATT_SKALA)))</span>
+<span id="cb120-54"><a href="#cb120-54" aria-hidden="true" tabindex="-1"></a>    <span class="cf">return</span> <span class="bu">float</span>(stueckpreis <span class="op">@</span> menge)</span>
+<span id="cb120-55"><a href="#cb120-55" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb120-56"><a href="#cb120-56" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb120-57"><a href="#cb120-57" aria-hidden="true" tabindex="-1"></a>NEBENBEDINGUNGEN <span class="op">=</span> [{<span class="st">&quot;type&quot;</span>: <span class="st">&quot;eq&quot;</span>, <span class="st">&quot;fun&quot;</span>: <span class="kw">lambda</span> q: q.<span class="bu">sum</span>() <span class="op">-</span> BEDARF}]</span>
+<span id="cb120-58"><a href="#cb120-58" aria-hidden="true" tabindex="-1"></a>GRENZEN <span class="op">=</span> [(<span class="fl">0.0</span>, k) <span class="cf">for</span> k <span class="kw">in</span> KAPAZITAET]</span>
+<span id="cb120-59"><a href="#cb120-59" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb120-60"><a href="#cb120-60" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb120-61"><a href="#cb120-61" aria-hidden="true" tabindex="-1"></a><span class="kw">def</span> optimiere_von(startpunkt: np.ndarray):</span>
+<span id="cb120-62"><a href="#cb120-62" aria-hidden="true" tabindex="-1"></a>    <span class="co">&quot;&quot;&quot;Ein Lauf von einem gegebenen Startpunkt aus.&quot;&quot;&quot;</span></span>
+<span id="cb120-63"><a href="#cb120-63" aria-hidden="true" tabindex="-1"></a>    <span class="cf">return</span> minimize(gesamtkosten, startpunkt, method<span class="op">=</span><span class="st">&quot;SLSQP&quot;</span>,</span>
+<span id="cb120-64"><a href="#cb120-64" aria-hidden="true" tabindex="-1"></a>                    bounds<span class="op">=</span>GRENZEN, constraints<span class="op">=</span>NEBENBEDINGUNGEN)</span>
+<span id="cb120-65"><a href="#cb120-65" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb120-66"><a href="#cb120-66" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb120-67"><a href="#cb120-67" aria-hidden="true" tabindex="-1"></a><span class="kw">def</span> zufaelliger_start() <span class="op">-&gt;</span> np.ndarray:</span>
+<span id="cb120-68"><a href="#cb120-68" aria-hidden="true" tabindex="-1"></a>    <span class="co">&quot;&quot;&quot;Zufaellige Aufteilung, die den Bedarf bereits erfuellt.&quot;&quot;&quot;</span></span>
+<span id="cb120-69"><a href="#cb120-69" aria-hidden="true" tabindex="-1"></a>    anteil <span class="op">=</span> RNG.random(<span class="bu">len</span>(NAMEN))</span>
+<span id="cb120-70"><a href="#cb120-70" aria-hidden="true" tabindex="-1"></a>    <span class="cf">return</span> anteil <span class="op">/</span> anteil.<span class="bu">sum</span>() <span class="op">*</span> BEDARF</span>
+<span id="cb120-71"><a href="#cb120-71" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb120-72"><a href="#cb120-72" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb120-73"><a href="#cb120-73" aria-hidden="true" tabindex="-1"></a><span class="kw">def</span> zeige_plan(titel: <span class="bu">str</span>, menge: np.ndarray, kosten: <span class="bu">float</span>) <span class="op">-&gt;</span> <span class="va">None</span>:</span>
+<span id="cb120-74"><a href="#cb120-74" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;</span><span class="ch">\n</span><span class="sc">{</span>titel<span class="sc">}</span><span class="ss">&quot;</span>)</span>
+<span id="cb120-75"><a href="#cb120-75" aria-hidden="true" tabindex="-1"></a>    <span class="cf">for</span> name, m <span class="kw">in</span> <span class="bu">zip</span>(NAMEN, menge):</span>
+<span id="cb120-76"><a href="#cb120-76" aria-hidden="true" tabindex="-1"></a>        anteil <span class="op">=</span> m <span class="op">/</span> BEDARF <span class="op">*</span> <span class="dv">100</span></span>
+<span id="cb120-77"><a href="#cb120-77" aria-hidden="true" tabindex="-1"></a>        <span class="bu">print</span>(<span class="ss">f&quot;    </span><span class="sc">{</span>name<span class="sc">:&lt;10}</span><span class="ss"> </span><span class="sc">{</span>m<span class="sc">:7.1f}</span><span class="ss"> t  (</span><span class="sc">{</span>anteil<span class="sc">:4.1f}</span><span class="ss"> %)&quot;</span>)</span>
+<span id="cb120-78"><a href="#cb120-78" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;    </span><span class="sc">{</span><span class="st">&#39;Gesamtkosten&#39;</span><span class="sc">:&lt;10}</span><span class="ss"> </span><span class="sc">{</span>kosten<span class="sc">:9,.2f}</span><span class="ss"> EUR&quot;</span>)</span>
+<span id="cb120-79"><a href="#cb120-79" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb120-80"><a href="#cb120-80" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb120-81"><a href="#cb120-81" aria-hidden="true" tabindex="-1"></a><span class="cf">if</span> <span class="va">__name__</span> <span class="op">==</span> <span class="st">&quot;__main__&quot;</span>:</span>
+<span id="cb120-82"><a href="#cb120-82" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;=&quot;</span> <span class="op">*</span> <span class="dv">78</span>)</span>
+<span id="cb120-83"><a href="#cb120-83" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;  NICHT-KONVEX: DERSELBE CODE, VERSCHIEDENE ERGEBNISSE&quot;</span>)</span>
+<span id="cb120-84"><a href="#cb120-84" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;=&quot;</span> <span class="op">*</span> <span class="dv">78</span>)</span>
+<span id="cb120-85"><a href="#cb120-85" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;</span><span class="sc">{</span>BEDARF<span class="sc">:.0f}</span><span class="ss"> t Rohstoff auf </span><span class="sc">{</span><span class="bu">len</span>(NAMEN)<span class="sc">}</span><span class="ss"> Lieferanten mit Mengenrabatt.&quot;</span>)</span>
+<span id="cb120-86"><a href="#cb120-86" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb120-87"><a href="#cb120-87" aria-hidden="true" tabindex="-1"></a>    <span class="co"># --- 1. Ein einziger Lauf, so wie man es zuerst schreibt --------------</span></span>
+<span id="cb120-88"><a href="#cb120-88" aria-hidden="true" tabindex="-1"></a>    erster <span class="op">=</span> optimiere_von(np.full(<span class="bu">len</span>(NAMEN), BEDARF <span class="op">/</span> <span class="bu">len</span>(NAMEN)))</span>
+<span id="cb120-89"><a href="#cb120-89" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;</span><span class="ch">\n</span><span class="ss">[1] EIN Lauf, Startpunkt &#39;gleichmaessig verteilt&#39;&quot;</span>)</span>
+<span id="cb120-90"><a href="#cb120-90" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;    scipy meldet: success=</span><span class="sc">{</span>erster<span class="sc">.</span>success<span class="sc">}</span><span class="ss">, &quot;</span></span>
+<span id="cb120-91"><a href="#cb120-91" aria-hidden="true" tabindex="-1"></a>          <span class="ss">f&quot;&#39;</span><span class="sc">{</span>erster<span class="sc">.</span>message<span class="sc">}</span><span class="ss">&#39;&quot;</span>)</span>
+<span id="cb120-92"><a href="#cb120-92" aria-hidden="true" tabindex="-1"></a>    zeige_plan(<span class="st">&quot;    Ergebnis:&quot;</span>, erster.x, erster.fun)</span>
+<span id="cb120-93"><a href="#cb120-93" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;</span><span class="ch">\n</span><span class="st">    Nichts an dieser Ausgabe deutet darauf hin, dass etwas fehlt.&quot;</span>)</span>
+<span id="cb120-94"><a href="#cb120-94" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb120-95"><a href="#cb120-95" aria-hidden="true" tabindex="-1"></a>    <span class="co"># --- 1b. Der kaufmaennisch naheliegende Startpunkt --------------------</span></span>
+<span id="cb120-96"><a href="#cb120-96" aria-hidden="true" tabindex="-1"></a>    <span class="co"># &quot;Kaufe bei den beiden Lieferanten mit dem guenstigsten Basispreis&quot; -</span></span>
+<span id="cb120-97"><a href="#cb120-97" aria-hidden="true" tabindex="-1"></a>    <span class="co"># West SE (45) und Ost GmbH (47), jeweils bis zur Kapazitaetsgrenze.</span></span>
+<span id="cb120-98"><a href="#cb120-98" aria-hidden="true" tabindex="-1"></a>    guenstigste <span class="op">=</span> np.argsort(BASISPREIS)[:<span class="dv">2</span>]</span>
+<span id="cb120-99"><a href="#cb120-99" aria-hidden="true" tabindex="-1"></a>    kaufmaennisch <span class="op">=</span> np.zeros(<span class="bu">len</span>(NAMEN))</span>
+<span id="cb120-100"><a href="#cb120-100" aria-hidden="true" tabindex="-1"></a>    rest <span class="op">=</span> BEDARF</span>
+<span id="cb120-101"><a href="#cb120-101" aria-hidden="true" tabindex="-1"></a>    <span class="cf">for</span> i <span class="kw">in</span> guenstigste:</span>
+<span id="cb120-102"><a href="#cb120-102" aria-hidden="true" tabindex="-1"></a>        kaufmaennisch[i] <span class="op">=</span> <span class="bu">min</span>(KAPAZITAET[i], rest)</span>
+<span id="cb120-103"><a href="#cb120-103" aria-hidden="true" tabindex="-1"></a>        rest <span class="op">-=</span> kaufmaennisch[i]</span>
+<span id="cb120-104"><a href="#cb120-104" aria-hidden="true" tabindex="-1"></a>    zweiter <span class="op">=</span> optimiere_von(kaufmaennisch)</span>
+<span id="cb120-105"><a href="#cb120-105" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;</span><span class="ch">\n</span><span class="ss">[1b] EIN Lauf, Startpunkt &#39;die zwei mit dem guenstigsten Basispreis&#39;&quot;</span>)</span>
+<span id="cb120-106"><a href="#cb120-106" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;    scipy meldet: success=</span><span class="sc">{</span>zweiter<span class="sc">.</span>success<span class="sc">}</span><span class="ss">&quot;</span>)</span>
+<span id="cb120-107"><a href="#cb120-107" aria-hidden="true" tabindex="-1"></a>    zeige_plan(<span class="st">&quot;    Ergebnis:&quot;</span>, zweiter.x, zweiter.fun)</span>
+<span id="cb120-108"><a href="#cb120-108" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;</span><span class="ch">\n</span><span class="ss">    Dasselbe Programm, derselbe Aufruf, ein anderer Startpunkt -&quot;</span>)</span>
+<span id="cb120-109"><a href="#cb120-109" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;    und </span><span class="sc">{</span>zweiter<span class="sc">.</span>fun <span class="op">-</span> erster<span class="sc">.</span>fun<span class="sc">:,.2f}</span><span class="ss"> EUR Unterschied &quot;</span></span>
+<span id="cb120-110"><a href="#cb120-110" aria-hidden="true" tabindex="-1"></a>          <span class="ss">f&quot;(</span><span class="sc">{</span>(zweiter.fun <span class="op">/</span> erster.fun <span class="op">-</span> <span class="dv">1</span>) <span class="op">*</span> <span class="dv">100</span><span class="sc">:.1f}</span><span class="ss"> %).&quot;</span>)</span>
+<span id="cb120-111"><a href="#cb120-111" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb120-112"><a href="#cb120-112" aria-hidden="true" tabindex="-1"></a>    <span class="co"># --- 2. Multistart: dasselbe Problem, viele Startpunkte ---------------</span></span>
+<span id="cb120-113"><a href="#cb120-113" aria-hidden="true" tabindex="-1"></a>    laeufe <span class="op">=</span> []</span>
+<span id="cb120-114"><a href="#cb120-114" aria-hidden="true" tabindex="-1"></a>    <span class="cf">for</span> _ <span class="kw">in</span> <span class="bu">range</span>(<span class="dv">200</span>):</span>
+<span id="cb120-115"><a href="#cb120-115" aria-hidden="true" tabindex="-1"></a>        ergebnis <span class="op">=</span> optimiere_von(zufaelliger_start())</span>
+<span id="cb120-116"><a href="#cb120-116" aria-hidden="true" tabindex="-1"></a>        <span class="cf">if</span> ergebnis.success:</span>
+<span id="cb120-117"><a href="#cb120-117" aria-hidden="true" tabindex="-1"></a>            laeufe.append((<span class="bu">float</span>(ergebnis.fun), ergebnis.x))</span>
+<span id="cb120-118"><a href="#cb120-118" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb120-119"><a href="#cb120-119" aria-hidden="true" tabindex="-1"></a>    <span class="co"># Ergebnisse, die sich um weniger als 1 Cent unterscheiden, sind dasselbe</span></span>
+<span id="cb120-120"><a href="#cb120-120" aria-hidden="true" tabindex="-1"></a>    <span class="co"># lokale Optimum - zusammenfassen, sonst zaehlt man Rundungsrauschen.</span></span>
+<span id="cb120-121"><a href="#cb120-121" aria-hidden="true" tabindex="-1"></a>    optima: <span class="bu">list</span>[<span class="bu">tuple</span>[<span class="bu">float</span>, np.ndarray]] <span class="op">=</span> []</span>
+<span id="cb120-122"><a href="#cb120-122" aria-hidden="true" tabindex="-1"></a>    <span class="cf">for</span> wert, plan <span class="kw">in</span> <span class="bu">sorted</span>(laeufe, key<span class="op">=</span><span class="kw">lambda</span> t: t[<span class="dv">0</span>]):</span>
+<span id="cb120-123"><a href="#cb120-123" aria-hidden="true" tabindex="-1"></a>        <span class="cf">if</span> <span class="kw">not</span> optima <span class="kw">or</span> <span class="bu">abs</span>(wert <span class="op">-</span> optima[<span class="op">-</span><span class="dv">1</span>][<span class="dv">0</span>]) <span class="op">&gt;</span> <span class="fl">0.01</span>:</span>
+<span id="cb120-124"><a href="#cb120-124" aria-hidden="true" tabindex="-1"></a>            optima.append((wert, plan))</span>
+<span id="cb120-125"><a href="#cb120-125" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb120-126"><a href="#cb120-126" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;</span><span class="ch">\n</span><span class="st">&quot;</span> <span class="op">+</span> <span class="st">&quot;=&quot;</span> <span class="op">*</span> <span class="dv">78</span>)</span>
+<span id="cb120-127"><a href="#cb120-127" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;[2] 200 zufaellige Startpunkte -&gt; </span><span class="sc">{</span><span class="bu">len</span>(laeufe)<span class="sc">}</span><span class="ss"> erfolgreiche Laeufe&quot;</span>)</span>
+<span id="cb120-128"><a href="#cb120-128" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;    darunter </span><span class="sc">{</span><span class="bu">len</span>(optima)<span class="sc">}</span><span class="ss"> VERSCHIEDENE lokale Optima:&quot;</span>)</span>
+<span id="cb120-129"><a href="#cb120-129" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>()</span>
+<span id="cb120-130"><a href="#cb120-130" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;    </span><span class="sc">{</span><span class="st">&#39;Rang&#39;</span><span class="sc">:&gt;5}</span><span class="ss"> </span><span class="sc">{</span><span class="st">&#39;Kosten&#39;</span><span class="sc">:&gt;13}</span><span class="ss"> </span><span class="sc">{</span><span class="st">&#39;Abstand zum besten&#39;</span><span class="sc">:&gt;20}</span><span class="ss">   Aufteilung (t)&quot;</span>)</span>
+<span id="cb120-131"><a href="#cb120-131" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;    &quot;</span> <span class="op">+</span> <span class="st">&quot;-&quot;</span> <span class="op">*</span> <span class="dv">70</span>)</span>
+<span id="cb120-132"><a href="#cb120-132" aria-hidden="true" tabindex="-1"></a>    bester <span class="op">=</span> optima[<span class="dv">0</span>][<span class="dv">0</span>]</span>
+<span id="cb120-133"><a href="#cb120-133" aria-hidden="true" tabindex="-1"></a>    <span class="cf">for</span> rang, (wert, plan) <span class="kw">in</span> <span class="bu">enumerate</span>(optima, start<span class="op">=</span><span class="dv">1</span>):</span>
+<span id="cb120-134"><a href="#cb120-134" aria-hidden="true" tabindex="-1"></a>        abstand <span class="op">=</span> (wert <span class="op">/</span> bester <span class="op">-</span> <span class="dv">1</span>) <span class="op">*</span> <span class="dv">100</span></span>
+<span id="cb120-135"><a href="#cb120-135" aria-hidden="true" tabindex="-1"></a>        aufteilung <span class="op">=</span> <span class="st">&quot; &quot;</span>.join(<span class="ss">f&quot;</span><span class="sc">{</span>m<span class="sc">:5.0f}</span><span class="ss">&quot;</span> <span class="cf">for</span> m <span class="kw">in</span> plan)</span>
+<span id="cb120-136"><a href="#cb120-136" aria-hidden="true" tabindex="-1"></a>        <span class="bu">print</span>(<span class="ss">f&quot;    </span><span class="sc">{</span>rang<span class="sc">:&gt;5}</span><span class="ss"> </span><span class="sc">{</span>wert<span class="sc">:&gt;13,.2f}</span><span class="ss"> </span><span class="sc">{</span>abstand<span class="sc">:&gt;19.2f}</span><span class="ss"> %   </span><span class="sc">{</span>aufteilung<span class="sc">}</span><span class="ss">&quot;</span>)</span>
+<span id="cb120-137"><a href="#cb120-137" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb120-138"><a href="#cb120-138" aria-hidden="true" tabindex="-1"></a>    <span class="co"># --- 3. Was das kostet ------------------------------------------------</span></span>
+<span id="cb120-139"><a href="#cb120-139" aria-hidden="true" tabindex="-1"></a>    schlechtester <span class="op">=</span> optima[<span class="op">-</span><span class="dv">1</span>]</span>
+<span id="cb120-140"><a href="#cb120-140" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;</span><span class="ch">\n</span><span class="st">&quot;</span> <span class="op">+</span> <span class="st">&quot;=&quot;</span> <span class="op">*</span> <span class="dv">78</span>)</span>
+<span id="cb120-141"><a href="#cb120-141" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;  WAS AUF DEM SPIEL STEHT&quot;</span>)</span>
+<span id="cb120-142"><a href="#cb120-142" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;=&quot;</span> <span class="op">*</span> <span class="dv">78</span>)</span>
+<span id="cb120-143"><a href="#cb120-143" aria-hidden="true" tabindex="-1"></a>    zeige_plan(<span class="st">&quot;Bester gefundener Plan:&quot;</span>, optima[<span class="dv">0</span>][<span class="dv">1</span>], optima[<span class="dv">0</span>][<span class="dv">0</span>])</span>
+<span id="cb120-144"><a href="#cb120-144" aria-hidden="true" tabindex="-1"></a>    zeige_plan(<span class="st">&quot;Schlechtestes lokales Optimum:&quot;</span>, schlechtester[<span class="dv">1</span>], schlechtester[<span class="dv">0</span>])</span>
+<span id="cb120-145"><a href="#cb120-145" aria-hidden="true" tabindex="-1"></a>    unterschied <span class="op">=</span> schlechtester[<span class="dv">0</span>] <span class="op">-</span> optima[<span class="dv">0</span>][<span class="dv">0</span>]</span>
+<span id="cb120-146"><a href="#cb120-146" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;</span><span class="ch">\n</span><span class="ss">  Unterschied: </span><span class="sc">{</span>unterschied<span class="sc">:,.2f}</span><span class="ss"> EUR &quot;</span></span>
+<span id="cb120-147"><a href="#cb120-147" aria-hidden="true" tabindex="-1"></a>          <span class="ss">f&quot;(</span><span class="sc">{</span>unterschied <span class="op">/</span> optima[<span class="dv">0</span>][<span class="dv">0</span>] <span class="op">*</span> <span class="dv">100</span><span class="sc">:.1f}</span><span class="ss"> %)&quot;</span>)</span>
+<span id="cb120-148"><a href="#cb120-148" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;</span><span class="ch">\n</span><span class="ss">  Lauf [1]  (gleichmaessiger Start):     </span><span class="sc">{</span>erster<span class="sc">.</span>fun<span class="sc">:&gt;10,.2f}</span><span class="ss"> EUR&quot;</span>)</span>
+<span id="cb120-149"><a href="#cb120-149" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;  Lauf [1b] (kaufmaennischer Start):    </span><span class="sc">{</span>zweiter<span class="sc">.</span>fun<span class="sc">:&gt;10,.2f}</span><span class="ss"> EUR&quot;</span></span>
+<span id="cb120-150"><a href="#cb120-150" aria-hidden="true" tabindex="-1"></a>          <span class="ss">f&quot;   &lt;- </span><span class="sc">{</span>(zweiter.fun <span class="op">/</span> optima[<span class="dv">0</span>][<span class="dv">0</span>] <span class="op">-</span> <span class="dv">1</span>) <span class="op">*</span> <span class="dv">100</span><span class="sc">:.1f}</span><span class="ss"> % ueber dem besten&quot;</span>)</span>
+<span id="cb120-151"><a href="#cb120-151" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>()</span>
+<span id="cb120-152"><a href="#cb120-152" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;  Bemerkenswert: Der kaufmaennisch NAHELIEGENDE Startpunkt fuehrt in&quot;</span>)</span>
+<span id="cb120-153"><a href="#cb120-153" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;  das schlechteste Ergebnis von allen - schlechter als jedes der 200&quot;</span>)</span>
+<span id="cb120-154"><a href="#cb120-154" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;  zufaellig gefundenen lokalen Optima. Wer beim guenstigsten&quot;</span>)</span>
+<span id="cb120-155"><a href="#cb120-155" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;  Basispreis anfaengt, uebersieht, dass hier der Mengenrabatt&quot;</span>)</span>
+<span id="cb120-156"><a href="#cb120-156" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;  entscheidet und nicht der Listenpreis.&quot;</span>)</span>
+<span id="cb120-157"><a href="#cb120-157" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb120-158"><a href="#cb120-158" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>()</span>
+<span id="cb120-159"><a href="#cb120-159" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;Drei Konsequenzen fuer die Praxis:&quot;</span>)</span>
+<span id="cb120-160"><a href="#cb120-160" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;  1. &#39;success: True&#39; heisst bei nicht-konvexen Problemen NICHT &#39;optimal&#39;.&quot;</span>)</span>
+<span id="cb120-161"><a href="#cb120-161" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;     Es heisst nur: &#39;Ich bin an einer Stelle angekommen, an der es in&quot;</span>)</span>
+<span id="cb120-162"><a href="#cb120-162" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;     keine Richtung mehr bergab geht.&#39;&quot;</span>)</span>
+<span id="cb120-163"><a href="#cb120-163" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;  2. Ein einzelner Lauf ist wertlos. Nehmen Sie viele Startpunkte und&quot;</span>)</span>
+<span id="cb120-164"><a href="#cb120-164" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;     berichten Sie die STREUUNG mit - sie ist Ihre einzige Auskunft&quot;</span>)</span>
+<span id="cb120-165"><a href="#cb120-165" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;     darueber, wie zerklueftet die Landschaft ist.&quot;</span>)</span>
+<span id="cb120-166"><a href="#cb120-166" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;  3. Auch Multistart liefert KEINE Garantie. Dass hier nichts unter&quot;</span>)</span>
+<span id="cb120-167"><a href="#cb120-167" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;     </span><span class="sc">{</span>bester<span class="sc">:,.2f}</span><span class="ss"> EUR gefunden wurde, beweist nicht, dass es nichts gibt.&quot;</span>)</span>
+<span id="cb120-168"><a href="#cb120-168" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;=&quot;</span> <span class="op">*</span> <span class="dv">78</span>)</span></code></pre></div>
 <p><strong>Erwartete Ausgabe:</strong></p>
 <pre><code>==============================================================================
   NICHT-KONVEX: DERSELBE CODE, VERSCHIEDENE ERGEBNISSE
@@ -16281,25 +17146,25 @@ Drei Konsequenzen fuer die Praxis:
 <blockquote>
 <p><strong>⚠️ Zu diesem Abschnitt gehört kein lauffähiges Programm.</strong> Ipopt, Bonmin und Couenne sind C++-Pakete, die über die Python-Installation hinaus systemweit eingerichtet werden müssen (<code>conda install -c conda-forge ipopt cyipopt</code> oder eine Distributionspaketquelle). Anders als bei allen übrigen Programmen dieses Buches konnten wir den Code deshalb nicht auf jedem Zielsystem ausführen — und drucken hier bewusst <strong>keine</strong> Ausgabe ab, die wir nicht selbst erzeugt haben. Der folgende Ausschnitt zeigt die Anbindung; prüfen Sie das Ergebnis auf Ihrem System selbst nach.</p>
 </blockquote>
-<div class="sourceCode" id="cb120"><pre class="sourceCode python"><code class="sourceCode python"><span id="cb120-1"><a href="#cb120-1" aria-hidden="true" tabindex="-1"></a><span class="co"># Ipopt ueber Pyomo - Anbindungsmuster, NICHT ausgefuehrt.</span></span>
-<span id="cb120-2"><a href="#cb120-2" aria-hidden="true" tabindex="-1"></a><span class="co"># Voraussetzung:  conda install -c conda-forge ipopt</span></span>
-<span id="cb120-3"><a href="#cb120-3" aria-hidden="true" tabindex="-1"></a><span class="im">import</span> pyomo.environ <span class="im">as</span> pyo</span>
-<span id="cb120-4"><a href="#cb120-4" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb120-5"><a href="#cb120-5" aria-hidden="true" tabindex="-1"></a>modell <span class="op">=</span> pyo.ConcreteModel()</span>
-<span id="cb120-6"><a href="#cb120-6" aria-hidden="true" tabindex="-1"></a>modell.q <span class="op">=</span> pyo.Var(<span class="bu">range</span>(<span class="dv">4</span>), domain<span class="op">=</span>pyo.NonNegativeReals, bounds<span class="op">=</span>(<span class="dv">0</span>, <span class="dv">400</span>))</span>
-<span id="cb120-7"><a href="#cb120-7" aria-hidden="true" tabindex="-1"></a>modell.bedarf <span class="op">=</span> pyo.Constraint(expr<span class="op">=</span><span class="bu">sum</span>(modell.q[i] <span class="cf">for</span> i <span class="kw">in</span> <span class="bu">range</span>(<span class="dv">4</span>)) <span class="op">==</span> <span class="dv">700</span>)</span>
-<span id="cb120-8"><a href="#cb120-8" aria-hidden="true" tabindex="-1"></a>modell.ziel <span class="op">=</span> pyo.Objective(</span>
-<span id="cb120-9"><a href="#cb120-9" aria-hidden="true" tabindex="-1"></a>    expr<span class="op">=</span><span class="bu">sum</span>(BASISPREIS[i] <span class="op">*</span> (<span class="dv">1</span> <span class="op">-</span> MAX_RABATT[i]</span>
-<span id="cb120-10"><a href="#cb120-10" aria-hidden="true" tabindex="-1"></a>                              <span class="op">*</span> (<span class="dv">1</span> <span class="op">-</span> pyo.exp(<span class="op">-</span>modell.q[i] <span class="op">/</span> RABATT_SKALA[i])))</span>
-<span id="cb120-11"><a href="#cb120-11" aria-hidden="true" tabindex="-1"></a>             <span class="op">*</span> modell.q[i] <span class="cf">for</span> i <span class="kw">in</span> <span class="bu">range</span>(<span class="dv">4</span>)),</span>
-<span id="cb120-12"><a href="#cb120-12" aria-hidden="true" tabindex="-1"></a>    sense<span class="op">=</span>pyo.minimize)</span>
-<span id="cb120-13"><a href="#cb120-13" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb120-14"><a href="#cb120-14" aria-hidden="true" tabindex="-1"></a>loeser <span class="op">=</span> pyo.SolverFactory(<span class="st">&quot;ipopt&quot;</span>)</span>
-<span id="cb120-15"><a href="#cb120-15" aria-hidden="true" tabindex="-1"></a><span class="cf">if</span> loeser.available(exception_flag<span class="op">=</span><span class="va">False</span>):</span>
-<span id="cb120-16"><a href="#cb120-16" aria-hidden="true" tabindex="-1"></a>    ergebnis <span class="op">=</span> loeser.solve(modell)</span>
-<span id="cb120-17"><a href="#cb120-17" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(ergebnis.solver.termination_condition)</span>
-<span id="cb120-18"><a href="#cb120-18" aria-hidden="true" tabindex="-1"></a><span class="cf">else</span>:</span>
-<span id="cb120-19"><a href="#cb120-19" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;Ipopt ist nicht installiert - siehe Hinweis oben.&quot;</span>)</span></code></pre></div>
+<div class="sourceCode" id="cb122"><pre class="sourceCode python"><code class="sourceCode python"><span id="cb122-1"><a href="#cb122-1" aria-hidden="true" tabindex="-1"></a><span class="co"># Ipopt ueber Pyomo - Anbindungsmuster, NICHT ausgefuehrt.</span></span>
+<span id="cb122-2"><a href="#cb122-2" aria-hidden="true" tabindex="-1"></a><span class="co"># Voraussetzung:  conda install -c conda-forge ipopt</span></span>
+<span id="cb122-3"><a href="#cb122-3" aria-hidden="true" tabindex="-1"></a><span class="im">import</span> pyomo.environ <span class="im">as</span> pyo</span>
+<span id="cb122-4"><a href="#cb122-4" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb122-5"><a href="#cb122-5" aria-hidden="true" tabindex="-1"></a>modell <span class="op">=</span> pyo.ConcreteModel()</span>
+<span id="cb122-6"><a href="#cb122-6" aria-hidden="true" tabindex="-1"></a>modell.q <span class="op">=</span> pyo.Var(<span class="bu">range</span>(<span class="dv">4</span>), domain<span class="op">=</span>pyo.NonNegativeReals, bounds<span class="op">=</span>(<span class="dv">0</span>, <span class="dv">400</span>))</span>
+<span id="cb122-7"><a href="#cb122-7" aria-hidden="true" tabindex="-1"></a>modell.bedarf <span class="op">=</span> pyo.Constraint(expr<span class="op">=</span><span class="bu">sum</span>(modell.q[i] <span class="cf">for</span> i <span class="kw">in</span> <span class="bu">range</span>(<span class="dv">4</span>)) <span class="op">==</span> <span class="dv">700</span>)</span>
+<span id="cb122-8"><a href="#cb122-8" aria-hidden="true" tabindex="-1"></a>modell.ziel <span class="op">=</span> pyo.Objective(</span>
+<span id="cb122-9"><a href="#cb122-9" aria-hidden="true" tabindex="-1"></a>    expr<span class="op">=</span><span class="bu">sum</span>(BASISPREIS[i] <span class="op">*</span> (<span class="dv">1</span> <span class="op">-</span> MAX_RABATT[i]</span>
+<span id="cb122-10"><a href="#cb122-10" aria-hidden="true" tabindex="-1"></a>                              <span class="op">*</span> (<span class="dv">1</span> <span class="op">-</span> pyo.exp(<span class="op">-</span>modell.q[i] <span class="op">/</span> RABATT_SKALA[i])))</span>
+<span id="cb122-11"><a href="#cb122-11" aria-hidden="true" tabindex="-1"></a>             <span class="op">*</span> modell.q[i] <span class="cf">for</span> i <span class="kw">in</span> <span class="bu">range</span>(<span class="dv">4</span>)),</span>
+<span id="cb122-12"><a href="#cb122-12" aria-hidden="true" tabindex="-1"></a>    sense<span class="op">=</span>pyo.minimize)</span>
+<span id="cb122-13"><a href="#cb122-13" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb122-14"><a href="#cb122-14" aria-hidden="true" tabindex="-1"></a>loeser <span class="op">=</span> pyo.SolverFactory(<span class="st">&quot;ipopt&quot;</span>)</span>
+<span id="cb122-15"><a href="#cb122-15" aria-hidden="true" tabindex="-1"></a><span class="cf">if</span> loeser.available(exception_flag<span class="op">=</span><span class="va">False</span>):</span>
+<span id="cb122-16"><a href="#cb122-16" aria-hidden="true" tabindex="-1"></a>    ergebnis <span class="op">=</span> loeser.solve(modell)</span>
+<span id="cb122-17"><a href="#cb122-17" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(ergebnis.solver.termination_condition)</span>
+<span id="cb122-18"><a href="#cb122-18" aria-hidden="true" tabindex="-1"></a><span class="cf">else</span>:</span>
+<span id="cb122-19"><a href="#cb122-19" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;Ipopt ist nicht installiert - siehe Hinweis oben.&quot;</span>)</span></code></pre></div>
 <p><strong>Die Strategie bleibt in jedem Fall dieselbe:</strong> Ein lokaler Solver wie Ipopt löst <em>schneller</em> und <em>größer</em> als <code>scipy</code> — er löst aber nicht <em>globaler</em>. Multistart bleibt nötig. Erst ein globaler Solver (SCIP, Couenne, BARON) ersetzt ihn, und den bezahlt man mit Rechenzeit, die um Größenordnungen höher liegt.</p>
 <blockquote>
 <p><strong>🎯 Merksatz</strong> Bei nicht-konvexen Problemen ist die ehrliche Berichterstattung wichtiger als die letzte Nachkommastelle: <em>„Bester gefundener Wert 24 724 € aus 200 Startpunkten; die Streuung reicht bis 26 690 €.“</em> Das ist eine belastbare Aussage. <em>„Das Optimum liegt bei 24 724,19 €“</em> ist es nicht.</p>
@@ -16318,7 +17183,7 @@ Drei Konsequenzen fuer die Praxis:
 <hr />
 <h2 id="sec:qp-nlp-denkfehler">11.8 Finde den Denkfehler</h2>
 <blockquote>
-<p><strong>🐛 Finde den Denkfehler 8.1: Die Kovarianzmatrix aus dem Controlling</strong></p>
+<p><strong>🐛 Finde den Denkfehler: Die Kovarianzmatrix aus dem Controlling</strong></p>
 <p>Ein Analyst soll das Risiko eines Portfolios aus drei Anlagen minimieren. Die Korrelationen hat er aus drei verschiedenen Quartalsberichten zusammengetragen — jede für sich plausibel:</p>
 <ul>
 <li>A und B laufen stark gleich: <span class="math inline">\rho_{AB} = 0{,}9</span></li>
@@ -16330,19 +17195,19 @@ Drei Konsequenzen fuer die Praxis:
 <pre><code>DCPError: Problem does not follow DCP rules.
 The objective is not DCP. Its following subexpressions are not: QuadForm(...)</code></pre>
 <p>Er hält das für eine Einschränkung der Bibliothek und weicht auf <code>scipy</code> aus:</p>
-<div class="sourceCode" id="cb122"><pre class="sourceCode python"><code class="sourceCode python"><span id="cb122-1"><a href="#cb122-1" aria-hidden="true" tabindex="-1"></a><span class="im">import</span> numpy <span class="im">as</span> np</span>
-<span id="cb122-2"><a href="#cb122-2" aria-hidden="true" tabindex="-1"></a><span class="im">from</span> scipy.optimize <span class="im">import</span> minimize</span>
-<span id="cb122-3"><a href="#cb122-3" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb122-4"><a href="#cb122-4" aria-hidden="true" tabindex="-1"></a>R <span class="op">=</span> np.array([[ <span class="fl">1.0</span>,  <span class="fl">0.9</span>, <span class="op">-</span><span class="fl">0.9</span>],</span>
-<span id="cb122-5"><a href="#cb122-5" aria-hidden="true" tabindex="-1"></a>              [ <span class="fl">0.9</span>,  <span class="fl">1.0</span>,  <span class="fl">0.9</span>],</span>
-<span id="cb122-6"><a href="#cb122-6" aria-hidden="true" tabindex="-1"></a>              [<span class="op">-</span><span class="fl">0.9</span>,  <span class="fl">0.9</span>,  <span class="fl">1.0</span>]])</span>
-<span id="cb122-7"><a href="#cb122-7" aria-hidden="true" tabindex="-1"></a>S <span class="op">=</span> <span class="fl">0.20</span><span class="op">**</span><span class="dv">2</span> <span class="op">*</span> R</span>
-<span id="cb122-8"><a href="#cb122-8" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb122-9"><a href="#cb122-9" aria-hidden="true" tabindex="-1"></a>varianz <span class="op">=</span> <span class="kw">lambda</span> w: <span class="bu">float</span>(w <span class="op">@</span> S <span class="op">@</span> w)</span>
-<span id="cb122-10"><a href="#cb122-10" aria-hidden="true" tabindex="-1"></a>ergebnis <span class="op">=</span> minimize(varianz, np.array([<span class="fl">0.4</span>, <span class="fl">0.3</span>, <span class="fl">0.3</span>]),</span>
-<span id="cb122-11"><a href="#cb122-11" aria-hidden="true" tabindex="-1"></a>                    constraints<span class="op">=</span>[{<span class="st">&quot;type&quot;</span>: <span class="st">&quot;eq&quot;</span>, <span class="st">&quot;fun&quot;</span>: <span class="kw">lambda</span> w: w.<span class="bu">sum</span>() <span class="op">-</span> <span class="dv">1</span>}],</span>
-<span id="cb122-12"><a href="#cb122-12" aria-hidden="true" tabindex="-1"></a>                    bounds<span class="op">=</span>[(<span class="op">-</span><span class="dv">2</span>, <span class="dv">3</span>)] <span class="op">*</span> <span class="dv">3</span>)</span>
-<span id="cb122-13"><a href="#cb122-13" aria-hidden="true" tabindex="-1"></a><span class="bu">print</span>(np.<span class="bu">round</span>(ergebnis.x, <span class="dv">3</span>), <span class="bu">round</span>(ergebnis.fun, <span class="dv">4</span>), ergebnis.success)</span></code></pre></div>
+<div class="sourceCode" id="cb124"><pre class="sourceCode python"><code class="sourceCode python"><span id="cb124-1"><a href="#cb124-1" aria-hidden="true" tabindex="-1"></a><span class="im">import</span> numpy <span class="im">as</span> np</span>
+<span id="cb124-2"><a href="#cb124-2" aria-hidden="true" tabindex="-1"></a><span class="im">from</span> scipy.optimize <span class="im">import</span> minimize</span>
+<span id="cb124-3"><a href="#cb124-3" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb124-4"><a href="#cb124-4" aria-hidden="true" tabindex="-1"></a>R <span class="op">=</span> np.array([[ <span class="fl">1.0</span>,  <span class="fl">0.9</span>, <span class="op">-</span><span class="fl">0.9</span>],</span>
+<span id="cb124-5"><a href="#cb124-5" aria-hidden="true" tabindex="-1"></a>              [ <span class="fl">0.9</span>,  <span class="fl">1.0</span>,  <span class="fl">0.9</span>],</span>
+<span id="cb124-6"><a href="#cb124-6" aria-hidden="true" tabindex="-1"></a>              [<span class="op">-</span><span class="fl">0.9</span>,  <span class="fl">0.9</span>,  <span class="fl">1.0</span>]])</span>
+<span id="cb124-7"><a href="#cb124-7" aria-hidden="true" tabindex="-1"></a>S <span class="op">=</span> <span class="fl">0.20</span><span class="op">**</span><span class="dv">2</span> <span class="op">*</span> R</span>
+<span id="cb124-8"><a href="#cb124-8" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb124-9"><a href="#cb124-9" aria-hidden="true" tabindex="-1"></a>varianz <span class="op">=</span> <span class="kw">lambda</span> w: <span class="bu">float</span>(w <span class="op">@</span> S <span class="op">@</span> w)</span>
+<span id="cb124-10"><a href="#cb124-10" aria-hidden="true" tabindex="-1"></a>ergebnis <span class="op">=</span> minimize(varianz, np.array([<span class="fl">0.4</span>, <span class="fl">0.3</span>, <span class="fl">0.3</span>]),</span>
+<span id="cb124-11"><a href="#cb124-11" aria-hidden="true" tabindex="-1"></a>                    constraints<span class="op">=</span>[{<span class="st">&quot;type&quot;</span>: <span class="st">&quot;eq&quot;</span>, <span class="st">&quot;fun&quot;</span>: <span class="kw">lambda</span> w: w.<span class="bu">sum</span>() <span class="op">-</span> <span class="dv">1</span>}],</span>
+<span id="cb124-12"><a href="#cb124-12" aria-hidden="true" tabindex="-1"></a>                    bounds<span class="op">=</span>[(<span class="op">-</span><span class="dv">2</span>, <span class="dv">3</span>)] <span class="op">*</span> <span class="dv">3</span>)</span>
+<span id="cb124-13"><a href="#cb124-13" aria-hidden="true" tabindex="-1"></a><span class="bu">print</span>(np.<span class="bu">round</span>(ergebnis.x, <span class="dv">3</span>), <span class="bu">round</span>(ergebnis.fun, <span class="dv">4</span>), ergebnis.success)</span></code></pre></div>
 <p><strong>Ausgabe:</strong></p>
 <pre><code>[ 1.5 -2.   1.5] -0.254 True</code></pre>
 <p>Ein Portfolio mit einer <strong>Varianz von <span class="math inline">-0{,}254</span></strong>. Der Analyst notiert erfreut ein „risikofreies Portfolio mit negativer Schwankung“.</p>
@@ -16355,7 +17220,7 @@ The objective is not DCP. Its following subexpressions are not: QuadForm(...)</c
 <hr />
 <h2 id="sec:qp-nlp-quiz">11.9 Micro-Quiz</h2>
 <blockquote>
-<p><strong>❓ Micro-Quiz 8: Drei Fragen zum Selbstcheck</strong></p>
+<p><strong>❓ Micro-Quiz 11: Drei Fragen zum Selbstcheck</strong></p>
 <p>Genau eine Antwort ist jeweils richtig. Auflösung in <a href="#quiz-loesung-qp-nlp">Anhang A</a>.</p>
 <p><strong>1. CVXPY lehnt Ihr Modell mit <code>DCPError: Problem does not follow DCP rules</code> ab. Was ist die richtige Reaktion?</strong> (a) Auf <code>scipy.optimize.minimize</code> ausweichen, das die Formulierung akzeptiert. (b) Die Meldung ernst nehmen: CVXPY sagt, dass es für diese Formulierung <strong>keine Optimalitätsgarantie</strong> geben kann. Entweder das Problem konvex umformulieren — oder bewusst auf ein lokales Verfahren mit Multistart wechseln. (c) Die Toleranzen lockern.</p>
 <p><strong>2. <code>scipy.optimize.minimize</code> meldet für ein Modell mit Mengenrabatten <code>success: True</code>. Was wissen Sie damit über die gefundene Lösung?</strong> (a) Sie ist optimal. (b) Sie ist ein lokales Minimum — es geht von dort in keine Richtung mehr bergab. Ob es anderswo ein besseres gibt, ist damit offen. (c) Sie ist zulässig, aber möglicherweise nicht einmal ein lokales Minimum.</p>
@@ -16431,20 +17296,20 @@ The objective is not DCP. Its following subexpressions are not: QuadForm(...)</c
 </tbody>
 </table>
 <p>Wie viele bestellen Sie?</p>
-<div class="sourceCode" id="cb124"><pre class="sourceCode python"><code class="sourceCode python"><span id="cb124-1"><a href="#cb124-1" aria-hidden="true" tabindex="-1"></a><span class="im">import</span> numpy <span class="im">as</span> np</span>
-<span id="cb124-2"><a href="#cb124-2" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb124-3"><a href="#cb124-3" aria-hidden="true" tabindex="-1"></a>KOSTEN_ZUVIEL, KOSTEN_ZUWENIG <span class="op">=</span> <span class="fl">120.0</span>, <span class="fl">1400.0</span></span>
-<span id="cb124-4"><a href="#cb124-4" aria-hidden="true" tabindex="-1"></a>bedarf <span class="op">=</span> np.random.default_rng(<span class="dv">7</span>).poisson(<span class="dv">30</span>, <span class="dv">200_000</span>)     <span class="co"># 200.000 Winter</span></span>
-<span id="cb124-5"><a href="#cb124-5" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb124-6"><a href="#cb124-6" aria-hidden="true" tabindex="-1"></a><span class="kw">def</span> kosten(menge):</span>
-<span id="cb124-7"><a href="#cb124-7" aria-hidden="true" tabindex="-1"></a>    zuviel <span class="op">=</span> np.maximum(menge <span class="op">-</span> bedarf, <span class="dv">0</span>)</span>
-<span id="cb124-8"><a href="#cb124-8" aria-hidden="true" tabindex="-1"></a>    zuwenig <span class="op">=</span> np.maximum(bedarf <span class="op">-</span> menge, <span class="dv">0</span>)</span>
-<span id="cb124-9"><a href="#cb124-9" aria-hidden="true" tabindex="-1"></a>    <span class="cf">return</span> (KOSTEN_ZUVIEL <span class="op">*</span> zuviel <span class="op">+</span> KOSTEN_ZUWENIG <span class="op">*</span> zuwenig).mean()</span>
-<span id="cb124-10"><a href="#cb124-10" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb124-11"><a href="#cb124-11" aria-hidden="true" tabindex="-1"></a>kandidaten <span class="op">=</span> np.arange(<span class="dv">20</span>, <span class="dv">61</span>)</span>
-<span id="cb124-12"><a href="#cb124-12" aria-hidden="true" tabindex="-1"></a>werte <span class="op">=</span> np.array([kosten(m) <span class="cf">for</span> m <span class="kw">in</span> kandidaten])</span>
-<span id="cb124-13"><a href="#cb124-13" aria-hidden="true" tabindex="-1"></a><span class="bu">print</span>(<span class="st">&quot;Optimum:&quot;</span>, kandidaten[werte.argmin()], <span class="st">&quot;Stueck,&quot;</span>, <span class="ss">f&quot;</span><span class="sc">{</span>werte<span class="sc">.</span><span class="bu">min</span>()<span class="sc">:,.0f}</span><span class="ss"> EUR&quot;</span>)</span>
-<span id="cb124-14"><a href="#cb124-14" aria-hidden="true" tabindex="-1"></a><span class="bu">print</span>(<span class="st">&quot;Mittlerer Bedarf 30:&quot;</span>, <span class="ss">f&quot;</span><span class="sc">{</span>kosten(<span class="dv">30</span>)<span class="sc">:,.0f}</span><span class="ss"> EUR&quot;</span>)</span></code></pre></div>
+<div class="sourceCode" id="cb126"><pre class="sourceCode python"><code class="sourceCode python"><span id="cb126-1"><a href="#cb126-1" aria-hidden="true" tabindex="-1"></a><span class="im">import</span> numpy <span class="im">as</span> np</span>
+<span id="cb126-2"><a href="#cb126-2" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb126-3"><a href="#cb126-3" aria-hidden="true" tabindex="-1"></a>KOSTEN_ZUVIEL, KOSTEN_ZUWENIG <span class="op">=</span> <span class="fl">120.0</span>, <span class="fl">1400.0</span></span>
+<span id="cb126-4"><a href="#cb126-4" aria-hidden="true" tabindex="-1"></a>bedarf <span class="op">=</span> np.random.default_rng(<span class="dv">7</span>).poisson(<span class="dv">30</span>, <span class="dv">200_000</span>)     <span class="co"># 200.000 Winter</span></span>
+<span id="cb126-5"><a href="#cb126-5" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb126-6"><a href="#cb126-6" aria-hidden="true" tabindex="-1"></a><span class="kw">def</span> kosten(menge):</span>
+<span id="cb126-7"><a href="#cb126-7" aria-hidden="true" tabindex="-1"></a>    zuviel <span class="op">=</span> np.maximum(menge <span class="op">-</span> bedarf, <span class="dv">0</span>)</span>
+<span id="cb126-8"><a href="#cb126-8" aria-hidden="true" tabindex="-1"></a>    zuwenig <span class="op">=</span> np.maximum(bedarf <span class="op">-</span> menge, <span class="dv">0</span>)</span>
+<span id="cb126-9"><a href="#cb126-9" aria-hidden="true" tabindex="-1"></a>    <span class="cf">return</span> (KOSTEN_ZUVIEL <span class="op">*</span> zuviel <span class="op">+</span> KOSTEN_ZUWENIG <span class="op">*</span> zuwenig).mean()</span>
+<span id="cb126-10"><a href="#cb126-10" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb126-11"><a href="#cb126-11" aria-hidden="true" tabindex="-1"></a>kandidaten <span class="op">=</span> np.arange(<span class="dv">20</span>, <span class="dv">61</span>)</span>
+<span id="cb126-12"><a href="#cb126-12" aria-hidden="true" tabindex="-1"></a>werte <span class="op">=</span> np.array([kosten(m) <span class="cf">for</span> m <span class="kw">in</span> kandidaten])</span>
+<span id="cb126-13"><a href="#cb126-13" aria-hidden="true" tabindex="-1"></a><span class="bu">print</span>(<span class="st">&quot;Optimum:&quot;</span>, kandidaten[werte.argmin()], <span class="st">&quot;Stueck,&quot;</span>, <span class="ss">f&quot;</span><span class="sc">{</span>werte<span class="sc">.</span><span class="bu">min</span>()<span class="sc">:,.0f}</span><span class="ss"> EUR&quot;</span>)</span>
+<span id="cb126-14"><a href="#cb126-14" aria-hidden="true" tabindex="-1"></a><span class="bu">print</span>(<span class="st">&quot;Mittlerer Bedarf 30:&quot;</span>, <span class="ss">f&quot;</span><span class="sc">{</span>kosten(<span class="dv">30</span>)<span class="sc">:,.0f}</span><span class="ss"> EUR&quot;</span>)</span></code></pre></div>
 <p><strong>Ausgabe:</strong></p>
 <pre><code>Optimum: 38 Stueck, 1,270 EUR
 Mittlerer Bedarf 30: 3,306 EUR</code></pre>
@@ -16547,59 +17412,59 @@ q^{*} = \frac{c_{\text{zu wenig}}}{c_{\text{zu wenig}} + c_{\text{zu viel}}}
 <p><strong>Die naive Planung kostet 437,50 € mehr — rund 2,7 % Aufschlag</strong> für das Einsetzen eines Mittelwerts, den es als Szenario gar nicht gibt. Beachten Sie: Der Aufschlag wirkt klein, weil bei nur drei Szenarien 225 und 250 nahe beieinanderliegen. Entscheidend ist die <strong>Richtung</strong>: Das Optimum liegt systematisch <strong>über</strong> dem Mittelwert, und zwar bei genau jenem Szenariowert, an dem die Kostenbalance kippt.</p>
 </blockquote>
 <p>Dass <span class="math inline">x = 250</span> tatsächlich das Minimum ist und nicht nur eine plausible Vermutung, zeigt ein vollständiger Scan über alle möglichen Kapazitäten:</p>
-<div class="sourceCode" id="cb126"><pre class="sourceCode python"><code class="sourceCode python"><span id="cb126-1"><a href="#cb126-1" aria-hidden="true" tabindex="-1"></a><span class="co">#!/usr/bin/env python3</span></span>
-<span id="cb126-2"><a href="#cb126-2" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb126-3"><a href="#cb126-3" aria-hidden="true" tabindex="-1"></a><span class="co"># Fluch_des_Durchschnitts.py</span></span>
-<span id="cb126-4"><a href="#cb126-4" aria-hidden="true" tabindex="-1"></a><span class="co">&quot;&quot;&quot;</span></span>
-<span id="cb126-5"><a href="#cb126-5" aria-hidden="true" tabindex="-1"></a><span class="co">Kapitel Unsicherheit: Der Fluch des Durchschnitts (die Handrechnung dazu) als Scan ueber alle</span></span>
-<span id="cb126-6"><a href="#cb126-6" aria-hidden="true" tabindex="-1"></a><span class="co">moeglichen Kapazitaeten - zeigt, dass das Optimum nicht beim Mittelwert liegt.</span></span>
-<span id="cb126-7"><a href="#cb126-7" aria-hidden="true" tabindex="-1"></a><span class="co">&quot;&quot;&quot;</span></span>
-<span id="cb126-8"><a href="#cb126-8" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb126-9"><a href="#cb126-9" aria-hidden="true" tabindex="-1"></a><span class="im">import</span> numpy <span class="im">as</span> np</span>
-<span id="cb126-10"><a href="#cb126-10" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb126-11"><a href="#cb126-11" aria-hidden="true" tabindex="-1"></a>SZENARIEN <span class="op">=</span> np.array([<span class="dv">100</span>, <span class="dv">250</span>, <span class="dv">500</span>])</span>
-<span id="cb126-12"><a href="#cb126-12" aria-hidden="true" tabindex="-1"></a>WAHRSCHEINLICHKEITEN <span class="op">=</span> np.array([<span class="fl">0.5</span>, <span class="fl">0.3</span>, <span class="fl">0.2</span>])</span>
-<span id="cb126-13"><a href="#cb126-13" aria-hidden="true" tabindex="-1"></a>PREIS_VORAB <span class="op">=</span> <span class="fl">40.0</span></span>
-<span id="cb126-14"><a href="#cb126-14" aria-hidden="true" tabindex="-1"></a>PREIS_ZUKAUF <span class="op">=</span> <span class="fl">120.0</span></span>
-<span id="cb126-15"><a href="#cb126-15" aria-hidden="true" tabindex="-1"></a>PREIS_VERWALTUNG <span class="op">=</span> <span class="fl">5.0</span></span>
-<span id="cb126-16"><a href="#cb126-16" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb126-17"><a href="#cb126-17" aria-hidden="true" tabindex="-1"></a>ERWARTUNGSWERT <span class="op">=</span> <span class="bu">float</span>(SZENARIEN <span class="op">@</span> WAHRSCHEINLICHKEITEN)</span>
-<span id="cb126-18"><a href="#cb126-18" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb126-19"><a href="#cb126-19" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb126-20"><a href="#cb126-20" aria-hidden="true" tabindex="-1"></a><span class="kw">def</span> erwartete_kosten(x):</span>
-<span id="cb126-21"><a href="#cb126-21" aria-hidden="true" tabindex="-1"></a>    kosten <span class="op">=</span> np.where(</span>
-<span id="cb126-22"><a href="#cb126-22" aria-hidden="true" tabindex="-1"></a>        SZENARIEN <span class="op">&gt;=</span> x,</span>
-<span id="cb126-23"><a href="#cb126-23" aria-hidden="true" tabindex="-1"></a>        PREIS_VORAB <span class="op">*</span> x <span class="op">+</span> PREIS_ZUKAUF <span class="op">*</span> (SZENARIEN <span class="op">-</span> x),</span>
-<span id="cb126-24"><a href="#cb126-24" aria-hidden="true" tabindex="-1"></a>        PREIS_VORAB <span class="op">*</span> x <span class="op">+</span> PREIS_VERWALTUNG <span class="op">*</span> (x <span class="op">-</span> SZENARIEN),</span>
-<span id="cb126-25"><a href="#cb126-25" aria-hidden="true" tabindex="-1"></a>    )</span>
-<span id="cb126-26"><a href="#cb126-26" aria-hidden="true" tabindex="-1"></a>    <span class="cf">return</span> <span class="bu">float</span>(kosten <span class="op">@</span> WAHRSCHEINLICHKEITEN)</span>
-<span id="cb126-27"><a href="#cb126-27" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb126-28"><a href="#cb126-28" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb126-29"><a href="#cb126-29" aria-hidden="true" tabindex="-1"></a><span class="cf">if</span> <span class="va">__name__</span> <span class="op">==</span> <span class="st">&quot;__main__&quot;</span>:</span>
-<span id="cb126-30"><a href="#cb126-30" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;=&quot;</span> <span class="op">*</span> <span class="dv">70</span>)</span>
-<span id="cb126-31"><a href="#cb126-31" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;  DER FLUCH DES DURCHSCHNITTS&quot;</span>)</span>
-<span id="cb126-32"><a href="#cb126-32" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;=&quot;</span> <span class="op">*</span> <span class="dv">70</span>)</span>
-<span id="cb126-33"><a href="#cb126-33" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;Erwarteter Bedarf (Mittelwert): </span><span class="sc">{</span>ERWARTUNGSWERT<span class="sc">:.1f}</span><span class="ss">&quot;</span>)</span>
-<span id="cb126-34"><a href="#cb126-34" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;Kosten bei naiver Planung x=</span><span class="sc">{</span>ERWARTUNGSWERT<span class="sc">:.0f}</span><span class="ss">: &quot;</span></span>
-<span id="cb126-35"><a href="#cb126-35" aria-hidden="true" tabindex="-1"></a>          <span class="ss">f&quot;</span><span class="sc">{</span>erwartete_kosten(ERWARTUNGSWERT)<span class="sc">:,.2f}</span><span class="ss"> EUR</span><span class="ch">\n</span><span class="ss">&quot;</span>)</span>
-<span id="cb126-36"><a href="#cb126-36" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb126-37"><a href="#cb126-37" aria-hidden="true" tabindex="-1"></a>    x_werte <span class="op">=</span> np.arange(<span class="dv">0</span>, <span class="dv">501</span>, <span class="dv">1</span>)</span>
-<span id="cb126-38"><a href="#cb126-38" aria-hidden="true" tabindex="-1"></a>    kosten_werte <span class="op">=</span> np.array([erwartete_kosten(x) <span class="cf">for</span> x <span class="kw">in</span> x_werte])</span>
-<span id="cb126-39"><a href="#cb126-39" aria-hidden="true" tabindex="-1"></a>    x_optimal <span class="op">=</span> x_werte[np.argmin(kosten_werte)]</span>
-<span id="cb126-40"><a href="#cb126-40" aria-hidden="true" tabindex="-1"></a>    kosten_optimal <span class="op">=</span> kosten_werte.<span class="bu">min</span>()</span>
-<span id="cb126-41"><a href="#cb126-41" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb126-42"><a href="#cb126-42" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;Optimales x (durch Scan gefunden): </span><span class="sc">{</span>x_optimal<span class="sc">}</span><span class="ss">&quot;</span>)</span>
-<span id="cb126-43"><a href="#cb126-43" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;Kosten beim Optimum:                </span><span class="sc">{</span>kosten_optimal<span class="sc">:,.2f}</span><span class="ss"> EUR&quot;</span>)</span>
-<span id="cb126-44"><a href="#cb126-44" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;Ersparnis gegenueber naiver Planung: &quot;</span></span>
-<span id="cb126-45"><a href="#cb126-45" aria-hidden="true" tabindex="-1"></a>          <span class="ss">f&quot;</span><span class="sc">{</span>erwartete_kosten(ERWARTUNGSWERT) <span class="op">-</span> kosten_optimal<span class="sc">:,.2f}</span><span class="ss"> EUR</span><span class="ch">\n</span><span class="ss">&quot;</span>)</span>
-<span id="cb126-46"><a href="#cb126-46" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb126-47"><a href="#cb126-47" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;Kosten fuer ausgewaehlte x zum Vergleich:&quot;</span>)</span>
-<span id="cb126-48"><a href="#cb126-48" aria-hidden="true" tabindex="-1"></a>    <span class="cf">for</span> x <span class="kw">in</span> [<span class="dv">100</span>, <span class="dv">225</span>, <span class="dv">250</span>, <span class="dv">300</span>, <span class="dv">500</span>]:</span>
-<span id="cb126-49"><a href="#cb126-49" aria-hidden="true" tabindex="-1"></a>        markierung <span class="op">=</span> <span class="st">&quot;  &lt;- Mittelwert&quot;</span> <span class="cf">if</span> x <span class="op">==</span> <span class="dv">225</span> <span class="cf">else</span> (<span class="st">&quot;  &lt;- Optimum&quot;</span> <span class="cf">if</span> x <span class="op">==</span> <span class="dv">250</span> <span class="cf">else</span> <span class="st">&quot;&quot;</span>)</span>
-<span id="cb126-50"><a href="#cb126-50" aria-hidden="true" tabindex="-1"></a>        <span class="bu">print</span>(<span class="ss">f&quot;  x=</span><span class="sc">{</span>x<span class="sc">:4d}</span><span class="ss">: </span><span class="sc">{</span>erwartete_kosten(x)<span class="sc">:&gt;12,.2f}</span><span class="ss"> EUR</span><span class="sc">{</span>markierung<span class="sc">}</span><span class="ss">&quot;</span>)</span>
-<span id="cb126-51"><a href="#cb126-51" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb126-52"><a href="#cb126-52" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;</span><span class="ch">\n</span><span class="st">Das Optimum liegt exakt auf einem Szenariowert (250 = &#39;Volatil&#39;),&quot;</span>)</span>
-<span id="cb126-53"><a href="#cb126-53" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;nicht beim Mittelwert 225 - typisch fuer asymmetrische Kostenfunktionen.&quot;</span>)</span></code></pre></div>
+<div class="sourceCode" id="cb128"><pre class="sourceCode python"><code class="sourceCode python"><span id="cb128-1"><a href="#cb128-1" aria-hidden="true" tabindex="-1"></a><span class="co">#!/usr/bin/env python3</span></span>
+<span id="cb128-2"><a href="#cb128-2" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb128-3"><a href="#cb128-3" aria-hidden="true" tabindex="-1"></a><span class="co"># Fluch_des_Durchschnitts.py</span></span>
+<span id="cb128-4"><a href="#cb128-4" aria-hidden="true" tabindex="-1"></a><span class="co">&quot;&quot;&quot;</span></span>
+<span id="cb128-5"><a href="#cb128-5" aria-hidden="true" tabindex="-1"></a><span class="co">Kapitel Unsicherheit: Der Fluch des Durchschnitts (die Handrechnung dazu) als Scan ueber alle</span></span>
+<span id="cb128-6"><a href="#cb128-6" aria-hidden="true" tabindex="-1"></a><span class="co">moeglichen Kapazitaeten - zeigt, dass das Optimum nicht beim Mittelwert liegt.</span></span>
+<span id="cb128-7"><a href="#cb128-7" aria-hidden="true" tabindex="-1"></a><span class="co">&quot;&quot;&quot;</span></span>
+<span id="cb128-8"><a href="#cb128-8" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb128-9"><a href="#cb128-9" aria-hidden="true" tabindex="-1"></a><span class="im">import</span> numpy <span class="im">as</span> np</span>
+<span id="cb128-10"><a href="#cb128-10" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb128-11"><a href="#cb128-11" aria-hidden="true" tabindex="-1"></a>SZENARIEN <span class="op">=</span> np.array([<span class="dv">100</span>, <span class="dv">250</span>, <span class="dv">500</span>])</span>
+<span id="cb128-12"><a href="#cb128-12" aria-hidden="true" tabindex="-1"></a>WAHRSCHEINLICHKEITEN <span class="op">=</span> np.array([<span class="fl">0.5</span>, <span class="fl">0.3</span>, <span class="fl">0.2</span>])</span>
+<span id="cb128-13"><a href="#cb128-13" aria-hidden="true" tabindex="-1"></a>PREIS_VORAB <span class="op">=</span> <span class="fl">40.0</span></span>
+<span id="cb128-14"><a href="#cb128-14" aria-hidden="true" tabindex="-1"></a>PREIS_ZUKAUF <span class="op">=</span> <span class="fl">120.0</span></span>
+<span id="cb128-15"><a href="#cb128-15" aria-hidden="true" tabindex="-1"></a>PREIS_VERWALTUNG <span class="op">=</span> <span class="fl">5.0</span></span>
+<span id="cb128-16"><a href="#cb128-16" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb128-17"><a href="#cb128-17" aria-hidden="true" tabindex="-1"></a>ERWARTUNGSWERT <span class="op">=</span> <span class="bu">float</span>(SZENARIEN <span class="op">@</span> WAHRSCHEINLICHKEITEN)</span>
+<span id="cb128-18"><a href="#cb128-18" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb128-19"><a href="#cb128-19" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb128-20"><a href="#cb128-20" aria-hidden="true" tabindex="-1"></a><span class="kw">def</span> erwartete_kosten(x):</span>
+<span id="cb128-21"><a href="#cb128-21" aria-hidden="true" tabindex="-1"></a>    kosten <span class="op">=</span> np.where(</span>
+<span id="cb128-22"><a href="#cb128-22" aria-hidden="true" tabindex="-1"></a>        SZENARIEN <span class="op">&gt;=</span> x,</span>
+<span id="cb128-23"><a href="#cb128-23" aria-hidden="true" tabindex="-1"></a>        PREIS_VORAB <span class="op">*</span> x <span class="op">+</span> PREIS_ZUKAUF <span class="op">*</span> (SZENARIEN <span class="op">-</span> x),</span>
+<span id="cb128-24"><a href="#cb128-24" aria-hidden="true" tabindex="-1"></a>        PREIS_VORAB <span class="op">*</span> x <span class="op">+</span> PREIS_VERWALTUNG <span class="op">*</span> (x <span class="op">-</span> SZENARIEN),</span>
+<span id="cb128-25"><a href="#cb128-25" aria-hidden="true" tabindex="-1"></a>    )</span>
+<span id="cb128-26"><a href="#cb128-26" aria-hidden="true" tabindex="-1"></a>    <span class="cf">return</span> <span class="bu">float</span>(kosten <span class="op">@</span> WAHRSCHEINLICHKEITEN)</span>
+<span id="cb128-27"><a href="#cb128-27" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb128-28"><a href="#cb128-28" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb128-29"><a href="#cb128-29" aria-hidden="true" tabindex="-1"></a><span class="cf">if</span> <span class="va">__name__</span> <span class="op">==</span> <span class="st">&quot;__main__&quot;</span>:</span>
+<span id="cb128-30"><a href="#cb128-30" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;=&quot;</span> <span class="op">*</span> <span class="dv">70</span>)</span>
+<span id="cb128-31"><a href="#cb128-31" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;  DER FLUCH DES DURCHSCHNITTS&quot;</span>)</span>
+<span id="cb128-32"><a href="#cb128-32" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;=&quot;</span> <span class="op">*</span> <span class="dv">70</span>)</span>
+<span id="cb128-33"><a href="#cb128-33" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;Erwarteter Bedarf (Mittelwert): </span><span class="sc">{</span>ERWARTUNGSWERT<span class="sc">:.1f}</span><span class="ss">&quot;</span>)</span>
+<span id="cb128-34"><a href="#cb128-34" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;Kosten bei naiver Planung x=</span><span class="sc">{</span>ERWARTUNGSWERT<span class="sc">:.0f}</span><span class="ss">: &quot;</span></span>
+<span id="cb128-35"><a href="#cb128-35" aria-hidden="true" tabindex="-1"></a>          <span class="ss">f&quot;</span><span class="sc">{</span>erwartete_kosten(ERWARTUNGSWERT)<span class="sc">:,.2f}</span><span class="ss"> EUR</span><span class="ch">\n</span><span class="ss">&quot;</span>)</span>
+<span id="cb128-36"><a href="#cb128-36" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb128-37"><a href="#cb128-37" aria-hidden="true" tabindex="-1"></a>    x_werte <span class="op">=</span> np.arange(<span class="dv">0</span>, <span class="dv">501</span>, <span class="dv">1</span>)</span>
+<span id="cb128-38"><a href="#cb128-38" aria-hidden="true" tabindex="-1"></a>    kosten_werte <span class="op">=</span> np.array([erwartete_kosten(x) <span class="cf">for</span> x <span class="kw">in</span> x_werte])</span>
+<span id="cb128-39"><a href="#cb128-39" aria-hidden="true" tabindex="-1"></a>    x_optimal <span class="op">=</span> x_werte[np.argmin(kosten_werte)]</span>
+<span id="cb128-40"><a href="#cb128-40" aria-hidden="true" tabindex="-1"></a>    kosten_optimal <span class="op">=</span> kosten_werte.<span class="bu">min</span>()</span>
+<span id="cb128-41"><a href="#cb128-41" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb128-42"><a href="#cb128-42" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;Optimales x (durch Scan gefunden): </span><span class="sc">{</span>x_optimal<span class="sc">}</span><span class="ss">&quot;</span>)</span>
+<span id="cb128-43"><a href="#cb128-43" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;Kosten beim Optimum:                </span><span class="sc">{</span>kosten_optimal<span class="sc">:,.2f}</span><span class="ss"> EUR&quot;</span>)</span>
+<span id="cb128-44"><a href="#cb128-44" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;Ersparnis gegenueber naiver Planung: &quot;</span></span>
+<span id="cb128-45"><a href="#cb128-45" aria-hidden="true" tabindex="-1"></a>          <span class="ss">f&quot;</span><span class="sc">{</span>erwartete_kosten(ERWARTUNGSWERT) <span class="op">-</span> kosten_optimal<span class="sc">:,.2f}</span><span class="ss"> EUR</span><span class="ch">\n</span><span class="ss">&quot;</span>)</span>
+<span id="cb128-46"><a href="#cb128-46" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb128-47"><a href="#cb128-47" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;Kosten fuer ausgewaehlte x zum Vergleich:&quot;</span>)</span>
+<span id="cb128-48"><a href="#cb128-48" aria-hidden="true" tabindex="-1"></a>    <span class="cf">for</span> x <span class="kw">in</span> [<span class="dv">100</span>, <span class="dv">225</span>, <span class="dv">250</span>, <span class="dv">300</span>, <span class="dv">500</span>]:</span>
+<span id="cb128-49"><a href="#cb128-49" aria-hidden="true" tabindex="-1"></a>        markierung <span class="op">=</span> <span class="st">&quot;  &lt;- Mittelwert&quot;</span> <span class="cf">if</span> x <span class="op">==</span> <span class="dv">225</span> <span class="cf">else</span> (<span class="st">&quot;  &lt;- Optimum&quot;</span> <span class="cf">if</span> x <span class="op">==</span> <span class="dv">250</span> <span class="cf">else</span> <span class="st">&quot;&quot;</span>)</span>
+<span id="cb128-50"><a href="#cb128-50" aria-hidden="true" tabindex="-1"></a>        <span class="bu">print</span>(<span class="ss">f&quot;  x=</span><span class="sc">{</span>x<span class="sc">:4d}</span><span class="ss">: </span><span class="sc">{</span>erwartete_kosten(x)<span class="sc">:&gt;12,.2f}</span><span class="ss"> EUR</span><span class="sc">{</span>markierung<span class="sc">}</span><span class="ss">&quot;</span>)</span>
+<span id="cb128-51"><a href="#cb128-51" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb128-52"><a href="#cb128-52" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;</span><span class="ch">\n</span><span class="st">Das Optimum liegt exakt auf einem Szenariowert (250 = &#39;Volatil&#39;),&quot;</span>)</span>
+<span id="cb128-53"><a href="#cb128-53" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;nicht beim Mittelwert 225 - typisch fuer asymmetrische Kostenfunktionen.&quot;</span>)</span></code></pre></div>
 <p><strong>Erwartete Ausgabe:</strong></p>
 <pre><code>======================================================================
   DER FLUCH DES DURCHSCHNITTS
@@ -16696,98 +17561,98 @@ nicht beim Mittelwert 225 - typisch fuer asymmetrische Kostenfunktionen.</code><
 <hr />
 <h2 id="sec:unsicherheit-monte-carlo-simulation">12.4 Monte-Carlo-Simulation</h2>
 <p><strong>Monte-Carlo</strong> heißt schlicht: Ziehe sehr viele Zufallsszenarien, werte für jedes den Plan aus, und betrachte die <strong>Verteilung</strong> der Ergebnisse statt eines einzigen Werts.</p>
-<div class="sourceCode" id="cb128"><pre class="sourceCode python"><code class="sourceCode python"><span id="cb128-1"><a href="#cb128-1" aria-hidden="true" tabindex="-1"></a><span class="co">#!/usr/bin/env python3</span></span>
-<span id="cb128-2"><a href="#cb128-2" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb128-3"><a href="#cb128-3" aria-hidden="true" tabindex="-1"></a><span class="co"># Monte_Carlo.py</span></span>
-<span id="cb128-4"><a href="#cb128-4" aria-hidden="true" tabindex="-1"></a><span class="co">&quot;&quot;&quot;</span></span>
-<span id="cb128-5"><a href="#cb128-5" aria-hidden="true" tabindex="-1"></a><span class="co">Kapitel Unsicherheit: Monte-Carlo-Bewertung von Kapazitaetsplaenen.</span></span>
-<span id="cb128-6"><a href="#cb128-6" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb128-7"><a href="#cb128-7" aria-hidden="true" tabindex="-1"></a><span class="co">Monte Carlo OPTIMIERT nicht - es BEWERTET. Der Nutzen liegt darin, dass man</span></span>
-<span id="cb128-8"><a href="#cb128-8" aria-hidden="true" tabindex="-1"></a><span class="co">beliebige Kennzahlen ablesen kann: Erwartungswert, Quantile, Ausfallwahr-</span></span>
-<span id="cb128-9"><a href="#cb128-9" aria-hidden="true" tabindex="-1"></a><span class="co">scheinlichkeit, Worst Case. Genau diese Groessen braucht man, um zwischen</span></span>
-<span id="cb128-10"><a href="#cb128-10" aria-hidden="true" tabindex="-1"></a><span class="co">Plaenen zu entscheiden.</span></span>
-<span id="cb128-11"><a href="#cb128-11" aria-hidden="true" tabindex="-1"></a><span class="co">&quot;&quot;&quot;</span></span>
-<span id="cb128-12"><a href="#cb128-12" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb128-13"><a href="#cb128-13" aria-hidden="true" tabindex="-1"></a><span class="im">import</span> numpy <span class="im">as</span> np</span>
-<span id="cb128-14"><a href="#cb128-14" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb128-15"><a href="#cb128-15" aria-hidden="true" tabindex="-1"></a>KOSTEN_VORAB <span class="op">=</span> <span class="fl">40.0</span>        <span class="co"># EUR je Einheit, im Voraus gekauft</span></span>
-<span id="cb128-16"><a href="#cb128-16" aria-hidden="true" tabindex="-1"></a>KOSTEN_SPOT <span class="op">=</span> <span class="fl">120.0</span>        <span class="co"># EUR je Einheit, kurzfristig zugekauft</span></span>
-<span id="cb128-17"><a href="#cb128-17" aria-hidden="true" tabindex="-1"></a>KOSTEN_LEERLAUF <span class="op">=</span> <span class="fl">5.0</span>      <span class="co"># EUR je ungenutzter Einheit</span></span>
-<span id="cb128-18"><a href="#cb128-18" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb128-19"><a href="#cb128-19" aria-hidden="true" tabindex="-1"></a>ANZAHL_ZIEHUNGEN <span class="op">=</span> <span class="dv">100_000</span></span>
-<span id="cb128-20"><a href="#cb128-20" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb128-21"><a href="#cb128-21" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb128-22"><a href="#cb128-22" aria-hidden="true" tabindex="-1"></a><span class="kw">def</span> ziehe_bedarf(rng, ziehungen):</span>
-<span id="cb128-23"><a href="#cb128-23" aria-hidden="true" tabindex="-1"></a>    <span class="co">&quot;&quot;&quot;</span></span>
-<span id="cb128-24"><a href="#cb128-24" aria-hidden="true" tabindex="-1"></a><span class="co">    Bedarfsmodell: Mischverteilung aus Normalbetrieb und seltenen Lastspitzen.</span></span>
-<span id="cb128-25"><a href="#cb128-25" aria-hidden="true" tabindex="-1"></a><span class="co">    Realistischer als eine reine Normalverteilung - Krisen sind selten,</span></span>
-<span id="cb128-26"><a href="#cb128-26" aria-hidden="true" tabindex="-1"></a><span class="co">    aber extrem (fat tail).</span></span>
-<span id="cb128-27"><a href="#cb128-27" aria-hidden="true" tabindex="-1"></a><span class="co">    &quot;&quot;&quot;</span></span>
-<span id="cb128-28"><a href="#cb128-28" aria-hidden="true" tabindex="-1"></a>    normal <span class="op">=</span> rng.normal(loc<span class="op">=</span><span class="dv">150</span>, scale<span class="op">=</span><span class="dv">40</span>, size<span class="op">=</span>ziehungen)</span>
-<span id="cb128-29"><a href="#cb128-29" aria-hidden="true" tabindex="-1"></a>    spitze <span class="op">=</span> rng.normal(loc<span class="op">=</span><span class="dv">450</span>, scale<span class="op">=</span><span class="dv">80</span>, size<span class="op">=</span>ziehungen)</span>
-<span id="cb128-30"><a href="#cb128-30" aria-hidden="true" tabindex="-1"></a>    ist_spitze <span class="op">=</span> rng.random(ziehungen) <span class="op">&lt;</span> <span class="fl">0.15</span>            <span class="co"># 15 % Lastspitzen</span></span>
-<span id="cb128-31"><a href="#cb128-31" aria-hidden="true" tabindex="-1"></a>    <span class="cf">return</span> np.maximum(np.where(ist_spitze, spitze, normal), <span class="fl">0.0</span>)</span>
-<span id="cb128-32"><a href="#cb128-32" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb128-33"><a href="#cb128-33" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb128-34"><a href="#cb128-34" aria-hidden="true" tabindex="-1"></a><span class="kw">def</span> kosten_fuer(kapazitaet, bedarf):</span>
-<span id="cb128-35"><a href="#cb128-35" aria-hidden="true" tabindex="-1"></a>    <span class="co">&quot;&quot;&quot;Gesamtkosten je Szenario fuer eine gegebene Vorabkapazitaet.&quot;&quot;&quot;</span></span>
-<span id="cb128-36"><a href="#cb128-36" aria-hidden="true" tabindex="-1"></a>    unterdeckung <span class="op">=</span> np.maximum(bedarf <span class="op">-</span> kapazitaet, <span class="fl">0.0</span>)</span>
-<span id="cb128-37"><a href="#cb128-37" aria-hidden="true" tabindex="-1"></a>    ueberdeckung <span class="op">=</span> np.maximum(kapazitaet <span class="op">-</span> bedarf, <span class="fl">0.0</span>)</span>
-<span id="cb128-38"><a href="#cb128-38" aria-hidden="true" tabindex="-1"></a>    <span class="cf">return</span> (KOSTEN_VORAB <span class="op">*</span> kapazitaet</span>
-<span id="cb128-39"><a href="#cb128-39" aria-hidden="true" tabindex="-1"></a>            <span class="op">+</span> KOSTEN_SPOT <span class="op">*</span> unterdeckung</span>
-<span id="cb128-40"><a href="#cb128-40" aria-hidden="true" tabindex="-1"></a>            <span class="op">+</span> KOSTEN_LEERLAUF <span class="op">*</span> ueberdeckung)</span>
-<span id="cb128-41"><a href="#cb128-41" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb128-42"><a href="#cb128-42" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb128-43"><a href="#cb128-43" aria-hidden="true" tabindex="-1"></a><span class="cf">if</span> <span class="va">__name__</span> <span class="op">==</span> <span class="st">&quot;__main__&quot;</span>:</span>
-<span id="cb128-44"><a href="#cb128-44" aria-hidden="true" tabindex="-1"></a>    rng <span class="op">=</span> np.random.default_rng(<span class="dv">2026</span>)</span>
-<span id="cb128-45"><a href="#cb128-45" aria-hidden="true" tabindex="-1"></a>    bedarf <span class="op">=</span> ziehe_bedarf(rng, ANZAHL_ZIEHUNGEN)</span>
-<span id="cb128-46"><a href="#cb128-46" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb128-47"><a href="#cb128-47" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;=&quot;</span> <span class="op">*</span> <span class="dv">88</span>)</span>
-<span id="cb128-48"><a href="#cb128-48" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;  MONTE-CARLO-BEWERTUNG (</span><span class="sc">{</span>ANZAHL_ZIEHUNGEN<span class="sc">:,}</span><span class="ss"> Szenarien)&quot;</span>)</span>
-<span id="cb128-49"><a href="#cb128-49" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;=&quot;</span> <span class="op">*</span> <span class="dv">88</span>)</span>
-<span id="cb128-50"><a href="#cb128-50" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;Bedarfsverteilung: Mittelwert </span><span class="sc">{</span>bedarf<span class="sc">.</span>mean()<span class="sc">:.1f}</span><span class="ss"> | &quot;</span></span>
-<span id="cb128-51"><a href="#cb128-51" aria-hidden="true" tabindex="-1"></a>          <span class="ss">f&quot;Median </span><span class="sc">{</span>np<span class="sc">.</span>median(bedarf)<span class="sc">:.1f}</span><span class="ss"> | &quot;</span></span>
-<span id="cb128-52"><a href="#cb128-52" aria-hidden="true" tabindex="-1"></a>          <span class="ss">f&quot;95%-Quantil </span><span class="sc">{</span>np<span class="sc">.</span>percentile(bedarf, <span class="dv">95</span>)<span class="sc">:.1f}</span><span class="ss"> | &quot;</span></span>
-<span id="cb128-53"><a href="#cb128-53" aria-hidden="true" tabindex="-1"></a>          <span class="ss">f&quot;Maximum </span><span class="sc">{</span>bedarf<span class="sc">.</span><span class="bu">max</span>()<span class="sc">:.1f}</span><span class="ss">&quot;</span>)</span>
-<span id="cb128-54"><a href="#cb128-54" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;Der Median liegt deutlich unter dem Mittelwert - die Verteilung ist&quot;</span>)</span>
-<span id="cb128-55"><a href="#cb128-55" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;rechtsschief. Genau hier fuehrt Planung mit dem Mittelwert in die Irre.</span><span class="ch">\n</span><span class="st">&quot;</span>)</span>
-<span id="cb128-56"><a href="#cb128-56" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb128-57"><a href="#cb128-57" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;</span><span class="sc">{</span><span class="st">&#39;Kapazitaet&#39;</span><span class="sc">:&gt;10}</span><span class="ss"> | </span><span class="sc">{</span><span class="st">&#39;Erw. Kosten&#39;</span><span class="sc">:&gt;12}</span><span class="ss"> | </span><span class="sc">{</span><span class="st">&#39;Median&#39;</span><span class="sc">:&gt;10}</span><span class="ss"> | &quot;</span></span>
-<span id="cb128-58"><a href="#cb128-58" aria-hidden="true" tabindex="-1"></a>          <span class="ss">f&quot;</span><span class="sc">{</span><span class="st">&#39;95%-Quantil&#39;</span><span class="sc">:&gt;12}</span><span class="ss"> | </span><span class="sc">{</span><span class="st">&#39;Unterdeckung&#39;</span><span class="sc">:&gt;12}</span><span class="ss">&quot;</span>)</span>
-<span id="cb128-59"><a href="#cb128-59" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;-&quot;</span> <span class="op">*</span> <span class="dv">88</span>)</span>
-<span id="cb128-60"><a href="#cb128-60" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb128-61"><a href="#cb128-61" aria-hidden="true" tabindex="-1"></a>    kandidaten <span class="op">=</span> [<span class="dv">150</span>, <span class="dv">200</span>, <span class="dv">225</span>, <span class="dv">250</span>, <span class="dv">300</span>, <span class="dv">350</span>, <span class="dv">400</span>]</span>
-<span id="cb128-62"><a href="#cb128-62" aria-hidden="true" tabindex="-1"></a>    ergebnisse <span class="op">=</span> []</span>
-<span id="cb128-63"><a href="#cb128-63" aria-hidden="true" tabindex="-1"></a>    <span class="cf">for</span> kapazitaet <span class="kw">in</span> kandidaten:</span>
-<span id="cb128-64"><a href="#cb128-64" aria-hidden="true" tabindex="-1"></a>        kosten <span class="op">=</span> kosten_fuer(kapazitaet, bedarf)</span>
-<span id="cb128-65"><a href="#cb128-65" aria-hidden="true" tabindex="-1"></a>        p_unterdeckung <span class="op">=</span> <span class="bu">float</span>(np.mean(bedarf <span class="op">&gt;</span> kapazitaet))</span>
-<span id="cb128-66"><a href="#cb128-66" aria-hidden="true" tabindex="-1"></a>        ergebnisse.append((kapazitaet, kosten.mean(), p_unterdeckung))</span>
-<span id="cb128-67"><a href="#cb128-67" aria-hidden="true" tabindex="-1"></a>        <span class="bu">print</span>(<span class="ss">f&quot;</span><span class="sc">{</span>kapazitaet<span class="sc">:&gt;10}</span><span class="ss"> | </span><span class="sc">{</span>kosten<span class="sc">.</span>mean()<span class="sc">:&gt;12,.0f}</span><span class="ss"> | &quot;</span></span>
-<span id="cb128-68"><a href="#cb128-68" aria-hidden="true" tabindex="-1"></a>              <span class="ss">f&quot;</span><span class="sc">{</span>np<span class="sc">.</span>median(kosten)<span class="sc">:&gt;10,.0f}</span><span class="ss"> | </span><span class="sc">{</span>np<span class="sc">.</span>percentile(kosten, <span class="dv">95</span>)<span class="sc">:&gt;12,.0f}</span><span class="ss"> | &quot;</span></span>
-<span id="cb128-69"><a href="#cb128-69" aria-hidden="true" tabindex="-1"></a>              <span class="ss">f&quot;</span><span class="sc">{</span>p_unterdeckung<span class="op">*</span><span class="dv">100</span><span class="sc">:&gt;11.1f}</span><span class="ss"> %&quot;</span>)</span>
-<span id="cb128-70"><a href="#cb128-70" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb128-71"><a href="#cb128-71" aria-hidden="true" tabindex="-1"></a>    beste <span class="op">=</span> <span class="bu">min</span>(ergebnisse, key<span class="op">=</span><span class="kw">lambda</span> t: t[<span class="dv">1</span>])</span>
-<span id="cb128-72"><a href="#cb128-72" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;-&quot;</span> <span class="op">*</span> <span class="dv">88</span>)</span>
-<span id="cb128-73"><a href="#cb128-73" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;Bester Kandidat: Kapazitaet </span><span class="sc">{</span>beste[<span class="dv">0</span>]<span class="sc">}</span><span class="ss"> mit erwarteten Kosten &quot;</span></span>
-<span id="cb128-74"><a href="#cb128-74" aria-hidden="true" tabindex="-1"></a>          <span class="ss">f&quot;</span><span class="sc">{</span>beste[<span class="dv">1</span>]<span class="sc">:,.0f}</span><span class="ss"> EUR&quot;</span>)</span>
-<span id="cb128-75"><a href="#cb128-75" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb128-76"><a href="#cb128-76" aria-hidden="true" tabindex="-1"></a>    <span class="co"># --- Feinsuche ueber ein Raster ---------------------------------------</span></span>
-<span id="cb128-77"><a href="#cb128-77" aria-hidden="true" tabindex="-1"></a>    raster <span class="op">=</span> np.arange(<span class="dv">100</span>, <span class="dv">500</span>, <span class="dv">5</span>)</span>
-<span id="cb128-78"><a href="#cb128-78" aria-hidden="true" tabindex="-1"></a>    erwartete <span class="op">=</span> np.array([kosten_fuer(k, bedarf).mean() <span class="cf">for</span> k <span class="kw">in</span> raster])</span>
-<span id="cb128-79"><a href="#cb128-79" aria-hidden="true" tabindex="-1"></a>    optimum <span class="op">=</span> raster[<span class="bu">int</span>(np.argmin(erwartete))]</span>
-<span id="cb128-80"><a href="#cb128-80" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;Feinsuche (Raster 100..500): Optimum bei Kapazitaet </span><span class="sc">{</span>optimum<span class="sc">}</span><span class="ss">, &quot;</span></span>
-<span id="cb128-81"><a href="#cb128-81" aria-hidden="true" tabindex="-1"></a>          <span class="ss">f&quot;Kosten </span><span class="sc">{</span>erwartete<span class="sc">.</span><span class="bu">min</span>()<span class="sc">:,.0f}</span><span class="ss"> EUR&quot;</span>)</span>
-<span id="cb128-82"><a href="#cb128-82" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb128-83"><a href="#cb128-83" aria-hidden="true" tabindex="-1"></a>    <span class="co"># --- Vergleich mit der naiven Mittelwertplanung ----------------------</span></span>
-<span id="cb128-84"><a href="#cb128-84" aria-hidden="true" tabindex="-1"></a>    naiv <span class="op">=</span> <span class="bu">int</span>(<span class="bu">round</span>(bedarf.mean()))</span>
-<span id="cb128-85"><a href="#cb128-85" aria-hidden="true" tabindex="-1"></a>    kosten_naiv <span class="op">=</span> kosten_fuer(naiv, bedarf).mean()</span>
-<span id="cb128-86"><a href="#cb128-86" aria-hidden="true" tabindex="-1"></a>    kosten_opt <span class="op">=</span> kosten_fuer(optimum, bedarf).mean()</span>
-<span id="cb128-87"><a href="#cb128-87" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;</span><span class="ch">\n</span><span class="st">--- Fluch des Durchschnitts, gemessen ---&quot;</span>)</span>
-<span id="cb128-88"><a href="#cb128-88" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;  Planung mit Mittelwert (</span><span class="sc">{</span>naiv<span class="sc">}</span><span class="ss">):  </span><span class="sc">{</span>kosten_naiv<span class="sc">:,.0f}</span><span class="ss"> EUR&quot;</span>)</span>
-<span id="cb128-89"><a href="#cb128-89" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;  Monte-Carlo-Optimum    (</span><span class="sc">{</span>optimum<span class="sc">}</span><span class="ss">):  </span><span class="sc">{</span>kosten_opt<span class="sc">:,.0f}</span><span class="ss"> EUR&quot;</span>)</span>
-<span id="cb128-90"><a href="#cb128-90" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;  Mehrkosten der naiven Planung:  </span><span class="sc">{</span>kosten_naiv <span class="op">-</span> kosten_opt<span class="sc">:,.0f}</span><span class="ss"> EUR &quot;</span></span>
-<span id="cb128-91"><a href="#cb128-91" aria-hidden="true" tabindex="-1"></a>          <span class="ss">f&quot;(</span><span class="sc">{</span>(kosten_naiv<span class="op">/</span>kosten_opt <span class="op">-</span> <span class="dv">1</span>)<span class="op">*</span><span class="dv">100</span><span class="sc">:.1f}</span><span class="ss"> %)&quot;</span>)</span>
-<span id="cb128-92"><a href="#cb128-92" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;=&quot;</span> <span class="op">*</span> <span class="dv">88</span>)</span></code></pre></div>
+<div class="sourceCode" id="cb130"><pre class="sourceCode python"><code class="sourceCode python"><span id="cb130-1"><a href="#cb130-1" aria-hidden="true" tabindex="-1"></a><span class="co">#!/usr/bin/env python3</span></span>
+<span id="cb130-2"><a href="#cb130-2" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb130-3"><a href="#cb130-3" aria-hidden="true" tabindex="-1"></a><span class="co"># Monte_Carlo.py</span></span>
+<span id="cb130-4"><a href="#cb130-4" aria-hidden="true" tabindex="-1"></a><span class="co">&quot;&quot;&quot;</span></span>
+<span id="cb130-5"><a href="#cb130-5" aria-hidden="true" tabindex="-1"></a><span class="co">Kapitel Unsicherheit: Monte-Carlo-Bewertung von Kapazitaetsplaenen.</span></span>
+<span id="cb130-6"><a href="#cb130-6" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb130-7"><a href="#cb130-7" aria-hidden="true" tabindex="-1"></a><span class="co">Monte Carlo OPTIMIERT nicht - es BEWERTET. Der Nutzen liegt darin, dass man</span></span>
+<span id="cb130-8"><a href="#cb130-8" aria-hidden="true" tabindex="-1"></a><span class="co">beliebige Kennzahlen ablesen kann: Erwartungswert, Quantile, Ausfallwahr-</span></span>
+<span id="cb130-9"><a href="#cb130-9" aria-hidden="true" tabindex="-1"></a><span class="co">scheinlichkeit, Worst Case. Genau diese Groessen braucht man, um zwischen</span></span>
+<span id="cb130-10"><a href="#cb130-10" aria-hidden="true" tabindex="-1"></a><span class="co">Plaenen zu entscheiden.</span></span>
+<span id="cb130-11"><a href="#cb130-11" aria-hidden="true" tabindex="-1"></a><span class="co">&quot;&quot;&quot;</span></span>
+<span id="cb130-12"><a href="#cb130-12" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb130-13"><a href="#cb130-13" aria-hidden="true" tabindex="-1"></a><span class="im">import</span> numpy <span class="im">as</span> np</span>
+<span id="cb130-14"><a href="#cb130-14" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb130-15"><a href="#cb130-15" aria-hidden="true" tabindex="-1"></a>KOSTEN_VORAB <span class="op">=</span> <span class="fl">40.0</span>        <span class="co"># EUR je Einheit, im Voraus gekauft</span></span>
+<span id="cb130-16"><a href="#cb130-16" aria-hidden="true" tabindex="-1"></a>KOSTEN_SPOT <span class="op">=</span> <span class="fl">120.0</span>        <span class="co"># EUR je Einheit, kurzfristig zugekauft</span></span>
+<span id="cb130-17"><a href="#cb130-17" aria-hidden="true" tabindex="-1"></a>KOSTEN_LEERLAUF <span class="op">=</span> <span class="fl">5.0</span>      <span class="co"># EUR je ungenutzter Einheit</span></span>
+<span id="cb130-18"><a href="#cb130-18" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb130-19"><a href="#cb130-19" aria-hidden="true" tabindex="-1"></a>ANZAHL_ZIEHUNGEN <span class="op">=</span> <span class="dv">100_000</span></span>
+<span id="cb130-20"><a href="#cb130-20" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb130-21"><a href="#cb130-21" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb130-22"><a href="#cb130-22" aria-hidden="true" tabindex="-1"></a><span class="kw">def</span> ziehe_bedarf(rng, ziehungen):</span>
+<span id="cb130-23"><a href="#cb130-23" aria-hidden="true" tabindex="-1"></a>    <span class="co">&quot;&quot;&quot;</span></span>
+<span id="cb130-24"><a href="#cb130-24" aria-hidden="true" tabindex="-1"></a><span class="co">    Bedarfsmodell: Mischverteilung aus Normalbetrieb und seltenen Lastspitzen.</span></span>
+<span id="cb130-25"><a href="#cb130-25" aria-hidden="true" tabindex="-1"></a><span class="co">    Realistischer als eine reine Normalverteilung - Krisen sind selten,</span></span>
+<span id="cb130-26"><a href="#cb130-26" aria-hidden="true" tabindex="-1"></a><span class="co">    aber extrem (fat tail).</span></span>
+<span id="cb130-27"><a href="#cb130-27" aria-hidden="true" tabindex="-1"></a><span class="co">    &quot;&quot;&quot;</span></span>
+<span id="cb130-28"><a href="#cb130-28" aria-hidden="true" tabindex="-1"></a>    normal <span class="op">=</span> rng.normal(loc<span class="op">=</span><span class="dv">150</span>, scale<span class="op">=</span><span class="dv">40</span>, size<span class="op">=</span>ziehungen)</span>
+<span id="cb130-29"><a href="#cb130-29" aria-hidden="true" tabindex="-1"></a>    spitze <span class="op">=</span> rng.normal(loc<span class="op">=</span><span class="dv">450</span>, scale<span class="op">=</span><span class="dv">80</span>, size<span class="op">=</span>ziehungen)</span>
+<span id="cb130-30"><a href="#cb130-30" aria-hidden="true" tabindex="-1"></a>    ist_spitze <span class="op">=</span> rng.random(ziehungen) <span class="op">&lt;</span> <span class="fl">0.15</span>            <span class="co"># 15 % Lastspitzen</span></span>
+<span id="cb130-31"><a href="#cb130-31" aria-hidden="true" tabindex="-1"></a>    <span class="cf">return</span> np.maximum(np.where(ist_spitze, spitze, normal), <span class="fl">0.0</span>)</span>
+<span id="cb130-32"><a href="#cb130-32" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb130-33"><a href="#cb130-33" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb130-34"><a href="#cb130-34" aria-hidden="true" tabindex="-1"></a><span class="kw">def</span> kosten_fuer(kapazitaet, bedarf):</span>
+<span id="cb130-35"><a href="#cb130-35" aria-hidden="true" tabindex="-1"></a>    <span class="co">&quot;&quot;&quot;Gesamtkosten je Szenario fuer eine gegebene Vorabkapazitaet.&quot;&quot;&quot;</span></span>
+<span id="cb130-36"><a href="#cb130-36" aria-hidden="true" tabindex="-1"></a>    unterdeckung <span class="op">=</span> np.maximum(bedarf <span class="op">-</span> kapazitaet, <span class="fl">0.0</span>)</span>
+<span id="cb130-37"><a href="#cb130-37" aria-hidden="true" tabindex="-1"></a>    ueberdeckung <span class="op">=</span> np.maximum(kapazitaet <span class="op">-</span> bedarf, <span class="fl">0.0</span>)</span>
+<span id="cb130-38"><a href="#cb130-38" aria-hidden="true" tabindex="-1"></a>    <span class="cf">return</span> (KOSTEN_VORAB <span class="op">*</span> kapazitaet</span>
+<span id="cb130-39"><a href="#cb130-39" aria-hidden="true" tabindex="-1"></a>            <span class="op">+</span> KOSTEN_SPOT <span class="op">*</span> unterdeckung</span>
+<span id="cb130-40"><a href="#cb130-40" aria-hidden="true" tabindex="-1"></a>            <span class="op">+</span> KOSTEN_LEERLAUF <span class="op">*</span> ueberdeckung)</span>
+<span id="cb130-41"><a href="#cb130-41" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb130-42"><a href="#cb130-42" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb130-43"><a href="#cb130-43" aria-hidden="true" tabindex="-1"></a><span class="cf">if</span> <span class="va">__name__</span> <span class="op">==</span> <span class="st">&quot;__main__&quot;</span>:</span>
+<span id="cb130-44"><a href="#cb130-44" aria-hidden="true" tabindex="-1"></a>    rng <span class="op">=</span> np.random.default_rng(<span class="dv">2026</span>)</span>
+<span id="cb130-45"><a href="#cb130-45" aria-hidden="true" tabindex="-1"></a>    bedarf <span class="op">=</span> ziehe_bedarf(rng, ANZAHL_ZIEHUNGEN)</span>
+<span id="cb130-46"><a href="#cb130-46" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb130-47"><a href="#cb130-47" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;=&quot;</span> <span class="op">*</span> <span class="dv">88</span>)</span>
+<span id="cb130-48"><a href="#cb130-48" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;  MONTE-CARLO-BEWERTUNG (</span><span class="sc">{</span>ANZAHL_ZIEHUNGEN<span class="sc">:,}</span><span class="ss"> Szenarien)&quot;</span>)</span>
+<span id="cb130-49"><a href="#cb130-49" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;=&quot;</span> <span class="op">*</span> <span class="dv">88</span>)</span>
+<span id="cb130-50"><a href="#cb130-50" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;Bedarfsverteilung: Mittelwert </span><span class="sc">{</span>bedarf<span class="sc">.</span>mean()<span class="sc">:.1f}</span><span class="ss"> | &quot;</span></span>
+<span id="cb130-51"><a href="#cb130-51" aria-hidden="true" tabindex="-1"></a>          <span class="ss">f&quot;Median </span><span class="sc">{</span>np<span class="sc">.</span>median(bedarf)<span class="sc">:.1f}</span><span class="ss"> | &quot;</span></span>
+<span id="cb130-52"><a href="#cb130-52" aria-hidden="true" tabindex="-1"></a>          <span class="ss">f&quot;95%-Quantil </span><span class="sc">{</span>np<span class="sc">.</span>percentile(bedarf, <span class="dv">95</span>)<span class="sc">:.1f}</span><span class="ss"> | &quot;</span></span>
+<span id="cb130-53"><a href="#cb130-53" aria-hidden="true" tabindex="-1"></a>          <span class="ss">f&quot;Maximum </span><span class="sc">{</span>bedarf<span class="sc">.</span><span class="bu">max</span>()<span class="sc">:.1f}</span><span class="ss">&quot;</span>)</span>
+<span id="cb130-54"><a href="#cb130-54" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;Der Median liegt deutlich unter dem Mittelwert - die Verteilung ist&quot;</span>)</span>
+<span id="cb130-55"><a href="#cb130-55" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;rechtsschief. Genau hier fuehrt Planung mit dem Mittelwert in die Irre.</span><span class="ch">\n</span><span class="st">&quot;</span>)</span>
+<span id="cb130-56"><a href="#cb130-56" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb130-57"><a href="#cb130-57" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;</span><span class="sc">{</span><span class="st">&#39;Kapazitaet&#39;</span><span class="sc">:&gt;10}</span><span class="ss"> | </span><span class="sc">{</span><span class="st">&#39;Erw. Kosten&#39;</span><span class="sc">:&gt;12}</span><span class="ss"> | </span><span class="sc">{</span><span class="st">&#39;Median&#39;</span><span class="sc">:&gt;10}</span><span class="ss"> | &quot;</span></span>
+<span id="cb130-58"><a href="#cb130-58" aria-hidden="true" tabindex="-1"></a>          <span class="ss">f&quot;</span><span class="sc">{</span><span class="st">&#39;95%-Quantil&#39;</span><span class="sc">:&gt;12}</span><span class="ss"> | </span><span class="sc">{</span><span class="st">&#39;Unterdeckung&#39;</span><span class="sc">:&gt;12}</span><span class="ss">&quot;</span>)</span>
+<span id="cb130-59"><a href="#cb130-59" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;-&quot;</span> <span class="op">*</span> <span class="dv">88</span>)</span>
+<span id="cb130-60"><a href="#cb130-60" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb130-61"><a href="#cb130-61" aria-hidden="true" tabindex="-1"></a>    kandidaten <span class="op">=</span> [<span class="dv">150</span>, <span class="dv">200</span>, <span class="dv">225</span>, <span class="dv">250</span>, <span class="dv">300</span>, <span class="dv">350</span>, <span class="dv">400</span>]</span>
+<span id="cb130-62"><a href="#cb130-62" aria-hidden="true" tabindex="-1"></a>    ergebnisse <span class="op">=</span> []</span>
+<span id="cb130-63"><a href="#cb130-63" aria-hidden="true" tabindex="-1"></a>    <span class="cf">for</span> kapazitaet <span class="kw">in</span> kandidaten:</span>
+<span id="cb130-64"><a href="#cb130-64" aria-hidden="true" tabindex="-1"></a>        kosten <span class="op">=</span> kosten_fuer(kapazitaet, bedarf)</span>
+<span id="cb130-65"><a href="#cb130-65" aria-hidden="true" tabindex="-1"></a>        p_unterdeckung <span class="op">=</span> <span class="bu">float</span>(np.mean(bedarf <span class="op">&gt;</span> kapazitaet))</span>
+<span id="cb130-66"><a href="#cb130-66" aria-hidden="true" tabindex="-1"></a>        ergebnisse.append((kapazitaet, kosten.mean(), p_unterdeckung))</span>
+<span id="cb130-67"><a href="#cb130-67" aria-hidden="true" tabindex="-1"></a>        <span class="bu">print</span>(<span class="ss">f&quot;</span><span class="sc">{</span>kapazitaet<span class="sc">:&gt;10}</span><span class="ss"> | </span><span class="sc">{</span>kosten<span class="sc">.</span>mean()<span class="sc">:&gt;12,.0f}</span><span class="ss"> | &quot;</span></span>
+<span id="cb130-68"><a href="#cb130-68" aria-hidden="true" tabindex="-1"></a>              <span class="ss">f&quot;</span><span class="sc">{</span>np<span class="sc">.</span>median(kosten)<span class="sc">:&gt;10,.0f}</span><span class="ss"> | </span><span class="sc">{</span>np<span class="sc">.</span>percentile(kosten, <span class="dv">95</span>)<span class="sc">:&gt;12,.0f}</span><span class="ss"> | &quot;</span></span>
+<span id="cb130-69"><a href="#cb130-69" aria-hidden="true" tabindex="-1"></a>              <span class="ss">f&quot;</span><span class="sc">{</span>p_unterdeckung<span class="op">*</span><span class="dv">100</span><span class="sc">:&gt;11.1f}</span><span class="ss"> %&quot;</span>)</span>
+<span id="cb130-70"><a href="#cb130-70" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb130-71"><a href="#cb130-71" aria-hidden="true" tabindex="-1"></a>    beste <span class="op">=</span> <span class="bu">min</span>(ergebnisse, key<span class="op">=</span><span class="kw">lambda</span> t: t[<span class="dv">1</span>])</span>
+<span id="cb130-72"><a href="#cb130-72" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;-&quot;</span> <span class="op">*</span> <span class="dv">88</span>)</span>
+<span id="cb130-73"><a href="#cb130-73" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;Bester Kandidat: Kapazitaet </span><span class="sc">{</span>beste[<span class="dv">0</span>]<span class="sc">}</span><span class="ss"> mit erwarteten Kosten &quot;</span></span>
+<span id="cb130-74"><a href="#cb130-74" aria-hidden="true" tabindex="-1"></a>          <span class="ss">f&quot;</span><span class="sc">{</span>beste[<span class="dv">1</span>]<span class="sc">:,.0f}</span><span class="ss"> EUR&quot;</span>)</span>
+<span id="cb130-75"><a href="#cb130-75" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb130-76"><a href="#cb130-76" aria-hidden="true" tabindex="-1"></a>    <span class="co"># --- Feinsuche ueber ein Raster ---------------------------------------</span></span>
+<span id="cb130-77"><a href="#cb130-77" aria-hidden="true" tabindex="-1"></a>    raster <span class="op">=</span> np.arange(<span class="dv">100</span>, <span class="dv">500</span>, <span class="dv">5</span>)</span>
+<span id="cb130-78"><a href="#cb130-78" aria-hidden="true" tabindex="-1"></a>    erwartete <span class="op">=</span> np.array([kosten_fuer(k, bedarf).mean() <span class="cf">for</span> k <span class="kw">in</span> raster])</span>
+<span id="cb130-79"><a href="#cb130-79" aria-hidden="true" tabindex="-1"></a>    optimum <span class="op">=</span> raster[<span class="bu">int</span>(np.argmin(erwartete))]</span>
+<span id="cb130-80"><a href="#cb130-80" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;Feinsuche (Raster 100..500): Optimum bei Kapazitaet </span><span class="sc">{</span>optimum<span class="sc">}</span><span class="ss">, &quot;</span></span>
+<span id="cb130-81"><a href="#cb130-81" aria-hidden="true" tabindex="-1"></a>          <span class="ss">f&quot;Kosten </span><span class="sc">{</span>erwartete<span class="sc">.</span><span class="bu">min</span>()<span class="sc">:,.0f}</span><span class="ss"> EUR&quot;</span>)</span>
+<span id="cb130-82"><a href="#cb130-82" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb130-83"><a href="#cb130-83" aria-hidden="true" tabindex="-1"></a>    <span class="co"># --- Vergleich mit der naiven Mittelwertplanung ----------------------</span></span>
+<span id="cb130-84"><a href="#cb130-84" aria-hidden="true" tabindex="-1"></a>    naiv <span class="op">=</span> <span class="bu">int</span>(<span class="bu">round</span>(bedarf.mean()))</span>
+<span id="cb130-85"><a href="#cb130-85" aria-hidden="true" tabindex="-1"></a>    kosten_naiv <span class="op">=</span> kosten_fuer(naiv, bedarf).mean()</span>
+<span id="cb130-86"><a href="#cb130-86" aria-hidden="true" tabindex="-1"></a>    kosten_opt <span class="op">=</span> kosten_fuer(optimum, bedarf).mean()</span>
+<span id="cb130-87"><a href="#cb130-87" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;</span><span class="ch">\n</span><span class="st">--- Fluch des Durchschnitts, gemessen ---&quot;</span>)</span>
+<span id="cb130-88"><a href="#cb130-88" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;  Planung mit Mittelwert (</span><span class="sc">{</span>naiv<span class="sc">}</span><span class="ss">):  </span><span class="sc">{</span>kosten_naiv<span class="sc">:,.0f}</span><span class="ss"> EUR&quot;</span>)</span>
+<span id="cb130-89"><a href="#cb130-89" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;  Monte-Carlo-Optimum    (</span><span class="sc">{</span>optimum<span class="sc">}</span><span class="ss">):  </span><span class="sc">{</span>kosten_opt<span class="sc">:,.0f}</span><span class="ss"> EUR&quot;</span>)</span>
+<span id="cb130-90"><a href="#cb130-90" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;  Mehrkosten der naiven Planung:  </span><span class="sc">{</span>kosten_naiv <span class="op">-</span> kosten_opt<span class="sc">:,.0f}</span><span class="ss"> EUR &quot;</span></span>
+<span id="cb130-91"><a href="#cb130-91" aria-hidden="true" tabindex="-1"></a>          <span class="ss">f&quot;(</span><span class="sc">{</span>(kosten_naiv<span class="op">/</span>kosten_opt <span class="op">-</span> <span class="dv">1</span>)<span class="op">*</span><span class="dv">100</span><span class="sc">:.1f}</span><span class="ss"> %)&quot;</span>)</span>
+<span id="cb130-92"><a href="#cb130-92" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;=&quot;</span> <span class="op">*</span> <span class="dv">88</span>)</span></code></pre></div>
 <p><strong>Erwartete Ausgabe (gekürzt):</strong></p>
 <pre><code>========================================================================================
   MONTE-CARLO-BEWERTUNG (100,000 Szenarien)
@@ -16818,7 +17683,7 @@ Feinsuche (Raster 100..500): Optimum bei Kapazitaet 180, Kosten 12,810 EUR
 <p><strong>🎯 Eine wichtige Einschränkung — und was man daraus lernt</strong></p>
 <p>Hier kostet die naive Mittelwertplanung nur <strong>1 %</strong>. In der Handrechnung zum Fluch des Durchschnitts waren es 2,7 %, in Lehrbüchern liest man von 20 % und mehr. <strong>Wie groß der Effekt ist, hängt von der Verteilung ab</strong> — und das ist selbst die Lektion.</p>
 <p>Bei dieser Mischverteilung liegt zwischen dem Normalbetrieb (um 150) und den Lastspitzen (um 450) ein Bereich, in dem kaum Wahrscheinlichkeitsmasse liegt. Zusätzliche Kapazität zwischen 200 und 400 nützt daher wenig: Sie ist im Normalfall Leerlauf und reicht im Krisenfall trotzdem nicht. Deshalb ist die Kostenkurve dort flach, und die Wahl zwischen 180 und 196 macht kaum einen Unterschied.</p>
-<p><strong>Was Sie mitnehmen sollten:</strong> Die Frage „Wie teuer ist Mittelwertplanung?“ hat keine allgemeine Antwort — <strong>rechnen Sie es aus.</strong> Genau dafür ist Monte-Carlo da. Und beachten Sie die Spalte „Unterdeckung“: Bei Kapazität 200 wird in <strong>24 % der Fälle</strong> nachgekauft. Ob das akzeptabel ist, entscheidet kein Optimierer, sondern ein Servicelevel-Ziel (Übung 9.5).</p>
+<p><strong>Was Sie mitnehmen sollten:</strong> Die Frage „Wie teuer ist Mittelwertplanung?“ hat keine allgemeine Antwort — <strong>rechnen Sie es aus.</strong> Genau dafür ist Monte-Carlo da. Und beachten Sie die Spalte „Unterdeckung“: Bei Kapazität 200 wird in <strong>24 % der Fälle</strong> nachgekauft. Ob das akzeptabel ist, entscheidet kein Optimierer, sondern ein Servicelevel-Ziel (Aufgabe <em>Monte-Carlo erweitern</em>, <a href="#sec:unsicherheit-uebungsaufgaben">Abschnitt 12.8</a>).</p>
 </blockquote>
 <blockquote>
 <p><strong>💡 Wann Monte-Carlo das richtige Werkzeug ist</strong> Immer dann, wenn Sie <strong>eine Kennzahl brauchen, die keine Formel hat</strong>: die Wahrscheinlichkeit, ein Servicelevel zu verfehlen; der erwartete Verlust in den schlechtesten 5 % der Fälle; die Verteilung der Projektdauer. Der Preis ist, dass Monte-Carlo nur <strong>bewertet</strong> — die Optimierung müssen Sie durch Rastersuche oder ein eigenes Modell ergänzen.</p>
@@ -16846,125 +17711,125 @@ Feinsuche (Raster 100..500): Optimum bei Kapazitaet 180, Kosten 12,810 EUR
 <p><strong>Ohne Formel gesagt:</strong> „Entscheide jetzt so, dass die Summe aus heutigen Kosten und <strong>durchschnittlich zu erwartenden</strong> Nachbesserungskosten minimal wird.“</p>
 <p><strong>Der entscheidende Punkt:</strong> Es gibt <strong>ein</strong> <span class="math inline">\mathbf{x}</span>, aber <strong>je Szenario ein eigenes</strong> <span class="math inline">\mathbf{y}_s</span>. Das ist keine Rechentrickserei, sondern bildet die Realität ab: Man legt sich einmal fest und reagiert dann unterschiedlich.</p>
 </blockquote>
-<div class="sourceCode" id="cb130"><pre class="sourceCode python"><code class="sourceCode python"><span id="cb130-1"><a href="#cb130-1" aria-hidden="true" tabindex="-1"></a><span class="co">#!/usr/bin/env python3</span></span>
-<span id="cb130-2"><a href="#cb130-2" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb130-3"><a href="#cb130-3" aria-hidden="true" tabindex="-1"></a><span class="co"># Stochastische_Optimierung.py</span></span>
-<span id="cb130-4"><a href="#cb130-4" aria-hidden="true" tabindex="-1"></a><span class="co">&quot;&quot;&quot;</span></span>
-<span id="cb130-5"><a href="#cb130-5" aria-hidden="true" tabindex="-1"></a><span class="co">Kapitel Unsicherheit: Two-Stage Stochastic Programming mit CVXPY.</span></span>
-<span id="cb130-6"><a href="#cb130-6" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb130-7"><a href="#cb130-7" aria-hidden="true" tabindex="-1"></a><span class="co">Eigenschaften:</span></span>
-<span id="cb130-8"><a href="#cb130-8" aria-hidden="true" tabindex="-1"></a><span class="co">  * Die Analyse am Ende wird BERECHNET statt fest verdrahtet</span></span>
-<span id="cb130-9"><a href="#cb130-9" aria-hidden="true" tabindex="-1"></a><span class="co">  * Vergleich gegen drei Alternativen: Mittelwert, Worst Case, perfekte Voraussicht</span></span>
-<span id="cb130-10"><a href="#cb130-10" aria-hidden="true" tabindex="-1"></a><span class="co">  * Kennzahl EVPI (Wert perfekter Information) wird ausgewiesen</span></span>
-<span id="cb130-11"><a href="#cb130-11" aria-hidden="true" tabindex="-1"></a><span class="co">&quot;&quot;&quot;</span></span>
-<span id="cb130-12"><a href="#cb130-12" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb130-13"><a href="#cb130-13" aria-hidden="true" tabindex="-1"></a><span class="im">import</span> cvxpy <span class="im">as</span> cp</span>
-<span id="cb130-14"><a href="#cb130-14" aria-hidden="true" tabindex="-1"></a><span class="im">import</span> numpy <span class="im">as</span> np</span>
-<span id="cb130-15"><a href="#cb130-15" aria-hidden="true" tabindex="-1"></a><span class="im">import</span> pandas <span class="im">as</span> pd</span>
-<span id="cb130-16"><a href="#cb130-16" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb130-17"><a href="#cb130-17" aria-hidden="true" tabindex="-1"></a>SZENARIEN <span class="op">=</span> [<span class="st">&quot;Ruhig&quot;</span>, <span class="st">&quot;Volatil&quot;</span>, <span class="st">&quot;Crash&quot;</span>]</span>
-<span id="cb130-18"><a href="#cb130-18" aria-hidden="true" tabindex="-1"></a>WAHRSCHEINLICHKEIT <span class="op">=</span> np.array([<span class="fl">0.50</span>, <span class="fl">0.30</span>, <span class="fl">0.20</span>])</span>
-<span id="cb130-19"><a href="#cb130-19" aria-hidden="true" tabindex="-1"></a>BEDARF <span class="op">=</span> np.array([<span class="fl">100.0</span>, <span class="fl">250.0</span>, <span class="fl">500.0</span>])</span>
-<span id="cb130-20"><a href="#cb130-20" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb130-21"><a href="#cb130-21" aria-hidden="true" tabindex="-1"></a>KOSTEN_VORAB <span class="op">=</span> <span class="fl">40.0</span></span>
-<span id="cb130-22"><a href="#cb130-22" aria-hidden="true" tabindex="-1"></a>KOSTEN_SPOT <span class="op">=</span> <span class="fl">120.0</span></span>
-<span id="cb130-23"><a href="#cb130-23" aria-hidden="true" tabindex="-1"></a>KOSTEN_LEERLAUF <span class="op">=</span> <span class="fl">5.0</span></span>
-<span id="cb130-24"><a href="#cb130-24" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb130-25"><a href="#cb130-25" aria-hidden="true" tabindex="-1"></a>S <span class="op">=</span> <span class="bu">len</span>(SZENARIEN)</span>
-<span id="cb130-26"><a href="#cb130-26" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb130-27"><a href="#cb130-27" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb130-28"><a href="#cb130-28" aria-hidden="true" tabindex="-1"></a><span class="kw">def</span> loese_stochastisch():</span>
-<span id="cb130-29"><a href="#cb130-29" aria-hidden="true" tabindex="-1"></a>    <span class="co">&quot;&quot;&quot;Zweistufiges Modell: eine Vorabentscheidung, szenarioabhaengige Korrektur.&quot;&quot;&quot;</span></span>
-<span id="cb130-30"><a href="#cb130-30" aria-hidden="true" tabindex="-1"></a>    x <span class="op">=</span> cp.Variable(nonneg<span class="op">=</span><span class="va">True</span>, name<span class="op">=</span><span class="st">&quot;Basiskapazitaet&quot;</span>)        <span class="co"># Stufe 1</span></span>
-<span id="cb130-31"><a href="#cb130-31" aria-hidden="true" tabindex="-1"></a>    y_spot <span class="op">=</span> cp.Variable(S, nonneg<span class="op">=</span><span class="va">True</span>, name<span class="op">=</span><span class="st">&quot;Spot_Zukauf&quot;</span>)    <span class="co"># Stufe 2</span></span>
-<span id="cb130-32"><a href="#cb130-32" aria-hidden="true" tabindex="-1"></a>    y_leer <span class="op">=</span> cp.Variable(S, nonneg<span class="op">=</span><span class="va">True</span>, name<span class="op">=</span><span class="st">&quot;Leerlauf&quot;</span>)       <span class="co"># Stufe 2</span></span>
-<span id="cb130-33"><a href="#cb130-33" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb130-34"><a href="#cb130-34" aria-hidden="true" tabindex="-1"></a>    <span class="co"># Kopplung: Basis + Zukauf - Leerlauf == Bedarf (je Szenario)</span></span>
-<span id="cb130-35"><a href="#cb130-35" aria-hidden="true" tabindex="-1"></a>    nebenbedingungen <span class="op">=</span> [x <span class="op">+</span> y_spot[s] <span class="op">-</span> y_leer[s] <span class="op">==</span> BEDARF[s] <span class="cf">for</span> s <span class="kw">in</span> <span class="bu">range</span>(S)]</span>
-<span id="cb130-36"><a href="#cb130-36" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb130-37"><a href="#cb130-37" aria-hidden="true" tabindex="-1"></a>    erwartete_korrektur <span class="op">=</span> <span class="bu">sum</span>(</span>
-<span id="cb130-38"><a href="#cb130-38" aria-hidden="true" tabindex="-1"></a>        WAHRSCHEINLICHKEIT[s] <span class="op">*</span> (KOSTEN_SPOT <span class="op">*</span> y_spot[s] <span class="op">+</span> KOSTEN_LEERLAUF <span class="op">*</span> y_leer[s])</span>
-<span id="cb130-39"><a href="#cb130-39" aria-hidden="true" tabindex="-1"></a>        <span class="cf">for</span> s <span class="kw">in</span> <span class="bu">range</span>(S))</span>
-<span id="cb130-40"><a href="#cb130-40" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb130-41"><a href="#cb130-41" aria-hidden="true" tabindex="-1"></a>    problem <span class="op">=</span> cp.Problem(cp.Minimize(KOSTEN_VORAB <span class="op">*</span> x <span class="op">+</span> erwartete_korrektur),</span>
-<span id="cb130-42"><a href="#cb130-42" aria-hidden="true" tabindex="-1"></a>                         nebenbedingungen)</span>
-<span id="cb130-43"><a href="#cb130-43" aria-hidden="true" tabindex="-1"></a>    problem.solve()</span>
-<span id="cb130-44"><a href="#cb130-44" aria-hidden="true" tabindex="-1"></a>    <span class="cf">return</span> problem, x, y_spot, y_leer</span>
-<span id="cb130-45"><a href="#cb130-45" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb130-46"><a href="#cb130-46" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb130-47"><a href="#cb130-47" aria-hidden="true" tabindex="-1"></a><span class="kw">def</span> kosten_bei(kapazitaet):</span>
-<span id="cb130-48"><a href="#cb130-48" aria-hidden="true" tabindex="-1"></a>    <span class="co">&quot;&quot;&quot;Erwartete Gesamtkosten fuer eine fest vorgegebene Kapazitaet.&quot;&quot;&quot;</span></span>
-<span id="cb130-49"><a href="#cb130-49" aria-hidden="true" tabindex="-1"></a>    unter <span class="op">=</span> np.maximum(BEDARF <span class="op">-</span> kapazitaet, <span class="fl">0.0</span>)</span>
-<span id="cb130-50"><a href="#cb130-50" aria-hidden="true" tabindex="-1"></a>    ueber <span class="op">=</span> np.maximum(kapazitaet <span class="op">-</span> BEDARF, <span class="fl">0.0</span>)</span>
-<span id="cb130-51"><a href="#cb130-51" aria-hidden="true" tabindex="-1"></a>    je_szenario <span class="op">=</span> KOSTEN_VORAB <span class="op">*</span> kapazitaet <span class="op">+</span> KOSTEN_SPOT <span class="op">*</span> unter <span class="op">+</span> KOSTEN_LEERLAUF <span class="op">*</span> ueber</span>
-<span id="cb130-52"><a href="#cb130-52" aria-hidden="true" tabindex="-1"></a>    <span class="cf">return</span> <span class="bu">float</span>(WAHRSCHEINLICHKEIT <span class="op">@</span> je_szenario)</span>
-<span id="cb130-53"><a href="#cb130-53" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb130-54"><a href="#cb130-54" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb130-55"><a href="#cb130-55" aria-hidden="true" tabindex="-1"></a><span class="cf">if</span> <span class="va">__name__</span> <span class="op">==</span> <span class="st">&quot;__main__&quot;</span>:</span>
-<span id="cb130-56"><a href="#cb130-56" aria-hidden="true" tabindex="-1"></a>    problem, x, y_spot, y_leer <span class="op">=</span> loese_stochastisch()</span>
-<span id="cb130-57"><a href="#cb130-57" aria-hidden="true" tabindex="-1"></a>    kapazitaet <span class="op">=</span> <span class="bu">float</span>(x.value)</span>
-<span id="cb130-58"><a href="#cb130-58" aria-hidden="true" tabindex="-1"></a>    mittelwert <span class="op">=</span> <span class="bu">float</span>(WAHRSCHEINLICHKEIT <span class="op">@</span> BEDARF)</span>
-<span id="cb130-59"><a href="#cb130-59" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb130-60"><a href="#cb130-60" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;=&quot;</span> <span class="op">*</span> <span class="dv">82</span>)</span>
-<span id="cb130-61"><a href="#cb130-61" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;     STOCHASTISCHE TWO-STAGE OPTIMIERUNG (KAPAZITAETSPLANUNG)&quot;</span>)</span>
-<span id="cb130-62"><a href="#cb130-62" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;=&quot;</span> <span class="op">*</span> <span class="dv">82</span>)</span>
-<span id="cb130-63"><a href="#cb130-63" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;Status: </span><span class="sc">{</span>problem<span class="sc">.</span>status<span class="sc">}</span><span class="ss">&quot;</span>)</span>
-<span id="cb130-64"><a href="#cb130-64" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;Erwarteter Bedarf (Mittelwert):   </span><span class="sc">{</span>mittelwert<span class="sc">:.1f}</span><span class="ss"> Einheiten&quot;</span>)</span>
-<span id="cb130-65"><a href="#cb130-65" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;Optimale Stufe-1-Kapazitaet x*:   </span><span class="sc">{</span>kapazitaet<span class="sc">:.1f}</span><span class="ss"> Einheiten&quot;</span>)</span>
-<span id="cb130-66"><a href="#cb130-66" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;Minimale erwartete Gesamtkosten:  </span><span class="sc">{</span>problem<span class="sc">.</span>value<span class="sc">:,.2f}</span><span class="ss"> EUR</span><span class="ch">\n</span><span class="ss">&quot;</span>)</span>
-<span id="cb130-67"><a href="#cb130-67" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb130-68"><a href="#cb130-68" aria-hidden="true" tabindex="-1"></a>    tabelle <span class="op">=</span> pd.DataFrame({</span>
-<span id="cb130-69"><a href="#cb130-69" aria-hidden="true" tabindex="-1"></a>        <span class="st">&quot;Szenario&quot;</span>: SZENARIEN,</span>
-<span id="cb130-70"><a href="#cb130-70" aria-hidden="true" tabindex="-1"></a>        <span class="st">&quot;Wahrsch.&quot;</span>: [<span class="ss">f&quot;</span><span class="sc">{</span>p<span class="op">*</span><span class="dv">100</span><span class="sc">:.0f}</span><span class="ss"> %&quot;</span> <span class="cf">for</span> p <span class="kw">in</span> WAHRSCHEINLICHKEIT],</span>
-<span id="cb130-71"><a href="#cb130-71" aria-hidden="true" tabindex="-1"></a>        <span class="st">&quot;Bedarf&quot;</span>: BEDARF,</span>
-<span id="cb130-72"><a href="#cb130-72" aria-hidden="true" tabindex="-1"></a>        <span class="st">&quot;Basis genutzt&quot;</span>: [<span class="bu">min</span>(kapazitaet, b) <span class="cf">for</span> b <span class="kw">in</span> BEDARF],</span>
-<span id="cb130-73"><a href="#cb130-73" aria-hidden="true" tabindex="-1"></a>        <span class="st">&quot;Spot-Zukauf&quot;</span>: np.<span class="bu">round</span>(y_spot.value, <span class="dv">1</span>),</span>
-<span id="cb130-74"><a href="#cb130-74" aria-hidden="true" tabindex="-1"></a>        <span class="st">&quot;Leerlauf&quot;</span>: np.<span class="bu">round</span>(y_leer.value, <span class="dv">1</span>),</span>
-<span id="cb130-75"><a href="#cb130-75" aria-hidden="true" tabindex="-1"></a>        <span class="st">&quot;Kosten (EUR)&quot;</span>: [<span class="ss">f&quot;</span><span class="sc">{</span>KOSTEN_VORAB<span class="op">*</span>kapazitaet <span class="op">+</span> KOSTEN_SPOT<span class="op">*</span>y_spot<span class="sc">.</span>value[s] <span class="op">+</span> KOSTEN_LEERLAUF<span class="op">*</span>y_leer<span class="sc">.</span>value[s]<span class="sc">:,.0f}</span><span class="ss">&quot;</span></span>
-<span id="cb130-76"><a href="#cb130-76" aria-hidden="true" tabindex="-1"></a>                         <span class="cf">for</span> s <span class="kw">in</span> <span class="bu">range</span>(S)],</span>
-<span id="cb130-77"><a href="#cb130-77" aria-hidden="true" tabindex="-1"></a>    })</span>
-<span id="cb130-78"><a href="#cb130-78" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(tabelle.to_string(index<span class="op">=</span><span class="va">False</span>))</span>
-<span id="cb130-79"><a href="#cb130-79" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb130-80"><a href="#cb130-80" aria-hidden="true" tabindex="-1"></a>    <span class="co"># --- Vergleich mit Alternativstrategien (berechnet, nicht behauptet) --</span></span>
-<span id="cb130-81"><a href="#cb130-81" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;</span><span class="ch">\n</span><span class="st">&quot;</span> <span class="op">+</span> <span class="st">&quot;-&quot;</span> <span class="op">*</span> <span class="dv">82</span>)</span>
-<span id="cb130-82"><a href="#cb130-82" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;Vergleich verschiedener Planungsstrategien:&quot;</span>)</span>
-<span id="cb130-83"><a href="#cb130-83" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;</span><span class="sc">{</span><span class="st">&#39;Strategie&#39;</span><span class="sc">:&lt;34}</span><span class="ss"> </span><span class="sc">{</span><span class="st">&#39;Kapazitaet&#39;</span><span class="sc">:&gt;11}</span><span class="ss"> </span><span class="sc">{</span><span class="st">&#39;Erw. Kosten&#39;</span><span class="sc">:&gt;14}</span><span class="ss"> </span><span class="sc">{</span><span class="st">&#39;Mehrkosten&#39;</span><span class="sc">:&gt;13}</span><span class="ss">&quot;</span>)</span>
-<span id="cb130-84"><a href="#cb130-84" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;-&quot;</span> <span class="op">*</span> <span class="dv">82</span>)</span>
-<span id="cb130-85"><a href="#cb130-85" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb130-86"><a href="#cb130-86" aria-hidden="true" tabindex="-1"></a>    optimal <span class="op">=</span> problem.value</span>
-<span id="cb130-87"><a href="#cb130-87" aria-hidden="true" tabindex="-1"></a>    strategien <span class="op">=</span> [</span>
-<span id="cb130-88"><a href="#cb130-88" aria-hidden="true" tabindex="-1"></a>        (<span class="st">&quot;Stochastisch optimal&quot;</span>, kapazitaet),</span>
-<span id="cb130-89"><a href="#cb130-89" aria-hidden="true" tabindex="-1"></a>        (<span class="st">&quot;Naiv: Mittelwert einsetzen&quot;</span>, mittelwert),</span>
-<span id="cb130-90"><a href="#cb130-90" aria-hidden="true" tabindex="-1"></a>        (<span class="st">&quot;Vorsichtig: Worst Case abdecken&quot;</span>, <span class="bu">float</span>(BEDARF.<span class="bu">max</span>())),</span>
-<span id="cb130-91"><a href="#cb130-91" aria-hidden="true" tabindex="-1"></a>        (<span class="st">&quot;Optimistisch: Bestfall&quot;</span>, <span class="bu">float</span>(BEDARF.<span class="bu">min</span>())),</span>
-<span id="cb130-92"><a href="#cb130-92" aria-hidden="true" tabindex="-1"></a>    ]</span>
-<span id="cb130-93"><a href="#cb130-93" aria-hidden="true" tabindex="-1"></a>    <span class="cf">for</span> name, kap <span class="kw">in</span> strategien:</span>
-<span id="cb130-94"><a href="#cb130-94" aria-hidden="true" tabindex="-1"></a>        kosten <span class="op">=</span> kosten_bei(kap)</span>
-<span id="cb130-95"><a href="#cb130-95" aria-hidden="true" tabindex="-1"></a>        <span class="bu">print</span>(<span class="ss">f&quot;</span><span class="sc">{</span>name<span class="sc">:&lt;34}</span><span class="ss"> </span><span class="sc">{</span>kap<span class="sc">:&gt;11.1f}</span><span class="ss"> </span><span class="sc">{</span>kosten<span class="sc">:&gt;14,.0f}</span><span class="ss"> &quot;</span></span>
-<span id="cb130-96"><a href="#cb130-96" aria-hidden="true" tabindex="-1"></a>              <span class="ss">f&quot;</span><span class="sc">{</span>kosten <span class="op">-</span> optimal<span class="sc">:&gt;+13,.0f}</span><span class="ss">&quot;</span>)</span>
-<span id="cb130-97"><a href="#cb130-97" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb130-98"><a href="#cb130-98" aria-hidden="true" tabindex="-1"></a>    <span class="co"># --- EVPI: Was waere perfekte Voraussicht wert? ----------------------</span></span>
-<span id="cb130-99"><a href="#cb130-99" aria-hidden="true" tabindex="-1"></a>    <span class="co"># Bei perfekter Information wuerde man je Szenario genau den Bedarf kaufen.</span></span>
-<span id="cb130-100"><a href="#cb130-100" aria-hidden="true" tabindex="-1"></a>    kosten_perfekt <span class="op">=</span> <span class="bu">float</span>(WAHRSCHEINLICHKEIT <span class="op">@</span> (KOSTEN_VORAB <span class="op">*</span> BEDARF))</span>
-<span id="cb130-101"><a href="#cb130-101" aria-hidden="true" tabindex="-1"></a>    evpi <span class="op">=</span> optimal <span class="op">-</span> kosten_perfekt</span>
-<span id="cb130-102"><a href="#cb130-102" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;-&quot;</span> <span class="op">*</span> <span class="dv">82</span>)</span>
-<span id="cb130-103"><a href="#cb130-103" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;Kosten bei perfekter Voraussicht:      </span><span class="sc">{</span>kosten_perfekt<span class="sc">:&gt;10,.0f}</span><span class="ss"> EUR&quot;</span>)</span>
-<span id="cb130-104"><a href="#cb130-104" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;Wert perfekter Information (EVPI):     </span><span class="sc">{</span>evpi<span class="sc">:&gt;10,.0f}</span><span class="ss"> EUR &quot;</span></span>
-<span id="cb130-105"><a href="#cb130-105" aria-hidden="true" tabindex="-1"></a>          <span class="ss">f&quot;(</span><span class="sc">{</span>evpi<span class="op">/</span>optimal<span class="op">*</span><span class="dv">100</span><span class="sc">:.1f}</span><span class="ss"> % der Kosten)&quot;</span>)</span>
-<span id="cb130-106"><a href="#cb130-106" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;  -&gt; So viel duerfte eine perfekte Bedarfsprognose hoechstens kosten.&quot;</span>)</span>
-<span id="cb130-107"><a href="#cb130-107" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb130-108"><a href="#cb130-108" aria-hidden="true" tabindex="-1"></a>    <span class="co"># --- Automatische Interpretation --------------------------------------</span></span>
-<span id="cb130-109"><a href="#cb130-109" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;-&quot;</span> <span class="op">*</span> <span class="dv">82</span>)</span>
-<span id="cb130-110"><a href="#cb130-110" aria-hidden="true" tabindex="-1"></a>    <span class="cf">if</span> kapazitaet <span class="op">&gt;</span> mittelwert <span class="op">+</span> <span class="fl">1e-6</span>:</span>
-<span id="cb130-111"><a href="#cb130-111" aria-hidden="true" tabindex="-1"></a>        <span class="bu">print</span>(<span class="ss">f&quot;Analyse: Der Solver waehlt </span><span class="sc">{</span>kapazitaet<span class="sc">:.0f}</span><span class="ss"> Einheiten und damit MEHR als&quot;</span>)</span>
-<span id="cb130-112"><a href="#cb130-112" aria-hidden="true" tabindex="-1"></a>        <span class="bu">print</span>(<span class="ss">f&quot;den Mittelwert (</span><span class="sc">{</span>mittelwert<span class="sc">:.0f}</span><span class="ss">), weil Unterdeckung (</span><span class="sc">{</span>KOSTEN_SPOT<span class="sc">:.0f}</span><span class="ss"> EUR)&quot;</span>)</span>
-<span id="cb130-113"><a href="#cb130-113" aria-hidden="true" tabindex="-1"></a>        <span class="bu">print</span>(<span class="ss">f&quot;deutlich teurer ist als Leerlauf (</span><span class="sc">{</span>KOSTEN_LEERLAUF<span class="sc">:.0f}</span><span class="ss"> EUR).&quot;</span>)</span>
-<span id="cb130-114"><a href="#cb130-114" aria-hidden="true" tabindex="-1"></a>    <span class="cf">elif</span> kapazitaet <span class="op">&lt;</span> mittelwert <span class="op">-</span> <span class="fl">1e-6</span>:</span>
-<span id="cb130-115"><a href="#cb130-115" aria-hidden="true" tabindex="-1"></a>        <span class="bu">print</span>(<span class="ss">f&quot;Analyse: Der Solver waehlt </span><span class="sc">{</span>kapazitaet<span class="sc">:.0f}</span><span class="ss"> und damit WENIGER als den&quot;</span>)</span>
-<span id="cb130-116"><a href="#cb130-116" aria-hidden="true" tabindex="-1"></a>        <span class="bu">print</span>(<span class="ss">f&quot;Mittelwert (</span><span class="sc">{</span>mittelwert<span class="sc">:.0f}</span><span class="ss">) - Leerlauf ist hier teurer als Zukauf.&quot;</span>)</span>
-<span id="cb130-117"><a href="#cb130-117" aria-hidden="true" tabindex="-1"></a>    <span class="cf">else</span>:</span>
-<span id="cb130-118"><a href="#cb130-118" aria-hidden="true" tabindex="-1"></a>        <span class="bu">print</span>(<span class="st">&quot;Analyse: Kapazitaet entspricht dem Mittelwert (symmetrische Kosten).&quot;</span>)</span>
-<span id="cb130-119"><a href="#cb130-119" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;=&quot;</span> <span class="op">*</span> <span class="dv">82</span>)</span></code></pre></div>
+<div class="sourceCode" id="cb132"><pre class="sourceCode python"><code class="sourceCode python"><span id="cb132-1"><a href="#cb132-1" aria-hidden="true" tabindex="-1"></a><span class="co">#!/usr/bin/env python3</span></span>
+<span id="cb132-2"><a href="#cb132-2" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb132-3"><a href="#cb132-3" aria-hidden="true" tabindex="-1"></a><span class="co"># Stochastische_Optimierung.py</span></span>
+<span id="cb132-4"><a href="#cb132-4" aria-hidden="true" tabindex="-1"></a><span class="co">&quot;&quot;&quot;</span></span>
+<span id="cb132-5"><a href="#cb132-5" aria-hidden="true" tabindex="-1"></a><span class="co">Kapitel Unsicherheit: Two-Stage Stochastic Programming mit CVXPY.</span></span>
+<span id="cb132-6"><a href="#cb132-6" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb132-7"><a href="#cb132-7" aria-hidden="true" tabindex="-1"></a><span class="co">Eigenschaften:</span></span>
+<span id="cb132-8"><a href="#cb132-8" aria-hidden="true" tabindex="-1"></a><span class="co">  * Die Analyse am Ende wird BERECHNET statt fest verdrahtet</span></span>
+<span id="cb132-9"><a href="#cb132-9" aria-hidden="true" tabindex="-1"></a><span class="co">  * Vergleich gegen drei Alternativen: Mittelwert, Worst Case, perfekte Voraussicht</span></span>
+<span id="cb132-10"><a href="#cb132-10" aria-hidden="true" tabindex="-1"></a><span class="co">  * Kennzahl EVPI (Wert perfekter Information) wird ausgewiesen</span></span>
+<span id="cb132-11"><a href="#cb132-11" aria-hidden="true" tabindex="-1"></a><span class="co">&quot;&quot;&quot;</span></span>
+<span id="cb132-12"><a href="#cb132-12" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb132-13"><a href="#cb132-13" aria-hidden="true" tabindex="-1"></a><span class="im">import</span> cvxpy <span class="im">as</span> cp</span>
+<span id="cb132-14"><a href="#cb132-14" aria-hidden="true" tabindex="-1"></a><span class="im">import</span> numpy <span class="im">as</span> np</span>
+<span id="cb132-15"><a href="#cb132-15" aria-hidden="true" tabindex="-1"></a><span class="im">import</span> pandas <span class="im">as</span> pd</span>
+<span id="cb132-16"><a href="#cb132-16" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb132-17"><a href="#cb132-17" aria-hidden="true" tabindex="-1"></a>SZENARIEN <span class="op">=</span> [<span class="st">&quot;Ruhig&quot;</span>, <span class="st">&quot;Volatil&quot;</span>, <span class="st">&quot;Crash&quot;</span>]</span>
+<span id="cb132-18"><a href="#cb132-18" aria-hidden="true" tabindex="-1"></a>WAHRSCHEINLICHKEIT <span class="op">=</span> np.array([<span class="fl">0.50</span>, <span class="fl">0.30</span>, <span class="fl">0.20</span>])</span>
+<span id="cb132-19"><a href="#cb132-19" aria-hidden="true" tabindex="-1"></a>BEDARF <span class="op">=</span> np.array([<span class="fl">100.0</span>, <span class="fl">250.0</span>, <span class="fl">500.0</span>])</span>
+<span id="cb132-20"><a href="#cb132-20" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb132-21"><a href="#cb132-21" aria-hidden="true" tabindex="-1"></a>KOSTEN_VORAB <span class="op">=</span> <span class="fl">40.0</span></span>
+<span id="cb132-22"><a href="#cb132-22" aria-hidden="true" tabindex="-1"></a>KOSTEN_SPOT <span class="op">=</span> <span class="fl">120.0</span></span>
+<span id="cb132-23"><a href="#cb132-23" aria-hidden="true" tabindex="-1"></a>KOSTEN_LEERLAUF <span class="op">=</span> <span class="fl">5.0</span></span>
+<span id="cb132-24"><a href="#cb132-24" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb132-25"><a href="#cb132-25" aria-hidden="true" tabindex="-1"></a>S <span class="op">=</span> <span class="bu">len</span>(SZENARIEN)</span>
+<span id="cb132-26"><a href="#cb132-26" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb132-27"><a href="#cb132-27" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb132-28"><a href="#cb132-28" aria-hidden="true" tabindex="-1"></a><span class="kw">def</span> loese_stochastisch():</span>
+<span id="cb132-29"><a href="#cb132-29" aria-hidden="true" tabindex="-1"></a>    <span class="co">&quot;&quot;&quot;Zweistufiges Modell: eine Vorabentscheidung, szenarioabhaengige Korrektur.&quot;&quot;&quot;</span></span>
+<span id="cb132-30"><a href="#cb132-30" aria-hidden="true" tabindex="-1"></a>    x <span class="op">=</span> cp.Variable(nonneg<span class="op">=</span><span class="va">True</span>, name<span class="op">=</span><span class="st">&quot;Basiskapazitaet&quot;</span>)        <span class="co"># Stufe 1</span></span>
+<span id="cb132-31"><a href="#cb132-31" aria-hidden="true" tabindex="-1"></a>    y_spot <span class="op">=</span> cp.Variable(S, nonneg<span class="op">=</span><span class="va">True</span>, name<span class="op">=</span><span class="st">&quot;Spot_Zukauf&quot;</span>)    <span class="co"># Stufe 2</span></span>
+<span id="cb132-32"><a href="#cb132-32" aria-hidden="true" tabindex="-1"></a>    y_leer <span class="op">=</span> cp.Variable(S, nonneg<span class="op">=</span><span class="va">True</span>, name<span class="op">=</span><span class="st">&quot;Leerlauf&quot;</span>)       <span class="co"># Stufe 2</span></span>
+<span id="cb132-33"><a href="#cb132-33" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb132-34"><a href="#cb132-34" aria-hidden="true" tabindex="-1"></a>    <span class="co"># Kopplung: Basis + Zukauf - Leerlauf == Bedarf (je Szenario)</span></span>
+<span id="cb132-35"><a href="#cb132-35" aria-hidden="true" tabindex="-1"></a>    nebenbedingungen <span class="op">=</span> [x <span class="op">+</span> y_spot[s] <span class="op">-</span> y_leer[s] <span class="op">==</span> BEDARF[s] <span class="cf">for</span> s <span class="kw">in</span> <span class="bu">range</span>(S)]</span>
+<span id="cb132-36"><a href="#cb132-36" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb132-37"><a href="#cb132-37" aria-hidden="true" tabindex="-1"></a>    erwartete_korrektur <span class="op">=</span> <span class="bu">sum</span>(</span>
+<span id="cb132-38"><a href="#cb132-38" aria-hidden="true" tabindex="-1"></a>        WAHRSCHEINLICHKEIT[s] <span class="op">*</span> (KOSTEN_SPOT <span class="op">*</span> y_spot[s] <span class="op">+</span> KOSTEN_LEERLAUF <span class="op">*</span> y_leer[s])</span>
+<span id="cb132-39"><a href="#cb132-39" aria-hidden="true" tabindex="-1"></a>        <span class="cf">for</span> s <span class="kw">in</span> <span class="bu">range</span>(S))</span>
+<span id="cb132-40"><a href="#cb132-40" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb132-41"><a href="#cb132-41" aria-hidden="true" tabindex="-1"></a>    problem <span class="op">=</span> cp.Problem(cp.Minimize(KOSTEN_VORAB <span class="op">*</span> x <span class="op">+</span> erwartete_korrektur),</span>
+<span id="cb132-42"><a href="#cb132-42" aria-hidden="true" tabindex="-1"></a>                         nebenbedingungen)</span>
+<span id="cb132-43"><a href="#cb132-43" aria-hidden="true" tabindex="-1"></a>    problem.solve()</span>
+<span id="cb132-44"><a href="#cb132-44" aria-hidden="true" tabindex="-1"></a>    <span class="cf">return</span> problem, x, y_spot, y_leer</span>
+<span id="cb132-45"><a href="#cb132-45" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb132-46"><a href="#cb132-46" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb132-47"><a href="#cb132-47" aria-hidden="true" tabindex="-1"></a><span class="kw">def</span> kosten_bei(kapazitaet):</span>
+<span id="cb132-48"><a href="#cb132-48" aria-hidden="true" tabindex="-1"></a>    <span class="co">&quot;&quot;&quot;Erwartete Gesamtkosten fuer eine fest vorgegebene Kapazitaet.&quot;&quot;&quot;</span></span>
+<span id="cb132-49"><a href="#cb132-49" aria-hidden="true" tabindex="-1"></a>    unter <span class="op">=</span> np.maximum(BEDARF <span class="op">-</span> kapazitaet, <span class="fl">0.0</span>)</span>
+<span id="cb132-50"><a href="#cb132-50" aria-hidden="true" tabindex="-1"></a>    ueber <span class="op">=</span> np.maximum(kapazitaet <span class="op">-</span> BEDARF, <span class="fl">0.0</span>)</span>
+<span id="cb132-51"><a href="#cb132-51" aria-hidden="true" tabindex="-1"></a>    je_szenario <span class="op">=</span> KOSTEN_VORAB <span class="op">*</span> kapazitaet <span class="op">+</span> KOSTEN_SPOT <span class="op">*</span> unter <span class="op">+</span> KOSTEN_LEERLAUF <span class="op">*</span> ueber</span>
+<span id="cb132-52"><a href="#cb132-52" aria-hidden="true" tabindex="-1"></a>    <span class="cf">return</span> <span class="bu">float</span>(WAHRSCHEINLICHKEIT <span class="op">@</span> je_szenario)</span>
+<span id="cb132-53"><a href="#cb132-53" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb132-54"><a href="#cb132-54" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb132-55"><a href="#cb132-55" aria-hidden="true" tabindex="-1"></a><span class="cf">if</span> <span class="va">__name__</span> <span class="op">==</span> <span class="st">&quot;__main__&quot;</span>:</span>
+<span id="cb132-56"><a href="#cb132-56" aria-hidden="true" tabindex="-1"></a>    problem, x, y_spot, y_leer <span class="op">=</span> loese_stochastisch()</span>
+<span id="cb132-57"><a href="#cb132-57" aria-hidden="true" tabindex="-1"></a>    kapazitaet <span class="op">=</span> <span class="bu">float</span>(x.value)</span>
+<span id="cb132-58"><a href="#cb132-58" aria-hidden="true" tabindex="-1"></a>    mittelwert <span class="op">=</span> <span class="bu">float</span>(WAHRSCHEINLICHKEIT <span class="op">@</span> BEDARF)</span>
+<span id="cb132-59"><a href="#cb132-59" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb132-60"><a href="#cb132-60" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;=&quot;</span> <span class="op">*</span> <span class="dv">82</span>)</span>
+<span id="cb132-61"><a href="#cb132-61" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;     STOCHASTISCHE TWO-STAGE OPTIMIERUNG (KAPAZITAETSPLANUNG)&quot;</span>)</span>
+<span id="cb132-62"><a href="#cb132-62" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;=&quot;</span> <span class="op">*</span> <span class="dv">82</span>)</span>
+<span id="cb132-63"><a href="#cb132-63" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;Status: </span><span class="sc">{</span>problem<span class="sc">.</span>status<span class="sc">}</span><span class="ss">&quot;</span>)</span>
+<span id="cb132-64"><a href="#cb132-64" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;Erwarteter Bedarf (Mittelwert):   </span><span class="sc">{</span>mittelwert<span class="sc">:.1f}</span><span class="ss"> Einheiten&quot;</span>)</span>
+<span id="cb132-65"><a href="#cb132-65" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;Optimale Stufe-1-Kapazitaet x*:   </span><span class="sc">{</span>kapazitaet<span class="sc">:.1f}</span><span class="ss"> Einheiten&quot;</span>)</span>
+<span id="cb132-66"><a href="#cb132-66" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;Minimale erwartete Gesamtkosten:  </span><span class="sc">{</span>problem<span class="sc">.</span>value<span class="sc">:,.2f}</span><span class="ss"> EUR</span><span class="ch">\n</span><span class="ss">&quot;</span>)</span>
+<span id="cb132-67"><a href="#cb132-67" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb132-68"><a href="#cb132-68" aria-hidden="true" tabindex="-1"></a>    tabelle <span class="op">=</span> pd.DataFrame({</span>
+<span id="cb132-69"><a href="#cb132-69" aria-hidden="true" tabindex="-1"></a>        <span class="st">&quot;Szenario&quot;</span>: SZENARIEN,</span>
+<span id="cb132-70"><a href="#cb132-70" aria-hidden="true" tabindex="-1"></a>        <span class="st">&quot;Wahrsch.&quot;</span>: [<span class="ss">f&quot;</span><span class="sc">{</span>p<span class="op">*</span><span class="dv">100</span><span class="sc">:.0f}</span><span class="ss"> %&quot;</span> <span class="cf">for</span> p <span class="kw">in</span> WAHRSCHEINLICHKEIT],</span>
+<span id="cb132-71"><a href="#cb132-71" aria-hidden="true" tabindex="-1"></a>        <span class="st">&quot;Bedarf&quot;</span>: BEDARF,</span>
+<span id="cb132-72"><a href="#cb132-72" aria-hidden="true" tabindex="-1"></a>        <span class="st">&quot;Basis genutzt&quot;</span>: [<span class="bu">min</span>(kapazitaet, b) <span class="cf">for</span> b <span class="kw">in</span> BEDARF],</span>
+<span id="cb132-73"><a href="#cb132-73" aria-hidden="true" tabindex="-1"></a>        <span class="st">&quot;Spot-Zukauf&quot;</span>: np.<span class="bu">round</span>(y_spot.value, <span class="dv">1</span>),</span>
+<span id="cb132-74"><a href="#cb132-74" aria-hidden="true" tabindex="-1"></a>        <span class="st">&quot;Leerlauf&quot;</span>: np.<span class="bu">round</span>(y_leer.value, <span class="dv">1</span>),</span>
+<span id="cb132-75"><a href="#cb132-75" aria-hidden="true" tabindex="-1"></a>        <span class="st">&quot;Kosten (EUR)&quot;</span>: [<span class="ss">f&quot;</span><span class="sc">{</span>KOSTEN_VORAB<span class="op">*</span>kapazitaet <span class="op">+</span> KOSTEN_SPOT<span class="op">*</span>y_spot<span class="sc">.</span>value[s] <span class="op">+</span> KOSTEN_LEERLAUF<span class="op">*</span>y_leer<span class="sc">.</span>value[s]<span class="sc">:,.0f}</span><span class="ss">&quot;</span></span>
+<span id="cb132-76"><a href="#cb132-76" aria-hidden="true" tabindex="-1"></a>                         <span class="cf">for</span> s <span class="kw">in</span> <span class="bu">range</span>(S)],</span>
+<span id="cb132-77"><a href="#cb132-77" aria-hidden="true" tabindex="-1"></a>    })</span>
+<span id="cb132-78"><a href="#cb132-78" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(tabelle.to_string(index<span class="op">=</span><span class="va">False</span>))</span>
+<span id="cb132-79"><a href="#cb132-79" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb132-80"><a href="#cb132-80" aria-hidden="true" tabindex="-1"></a>    <span class="co"># --- Vergleich mit Alternativstrategien (berechnet, nicht behauptet) --</span></span>
+<span id="cb132-81"><a href="#cb132-81" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;</span><span class="ch">\n</span><span class="st">&quot;</span> <span class="op">+</span> <span class="st">&quot;-&quot;</span> <span class="op">*</span> <span class="dv">82</span>)</span>
+<span id="cb132-82"><a href="#cb132-82" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;Vergleich verschiedener Planungsstrategien:&quot;</span>)</span>
+<span id="cb132-83"><a href="#cb132-83" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;</span><span class="sc">{</span><span class="st">&#39;Strategie&#39;</span><span class="sc">:&lt;34}</span><span class="ss"> </span><span class="sc">{</span><span class="st">&#39;Kapazitaet&#39;</span><span class="sc">:&gt;11}</span><span class="ss"> </span><span class="sc">{</span><span class="st">&#39;Erw. Kosten&#39;</span><span class="sc">:&gt;14}</span><span class="ss"> </span><span class="sc">{</span><span class="st">&#39;Mehrkosten&#39;</span><span class="sc">:&gt;13}</span><span class="ss">&quot;</span>)</span>
+<span id="cb132-84"><a href="#cb132-84" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;-&quot;</span> <span class="op">*</span> <span class="dv">82</span>)</span>
+<span id="cb132-85"><a href="#cb132-85" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb132-86"><a href="#cb132-86" aria-hidden="true" tabindex="-1"></a>    optimal <span class="op">=</span> problem.value</span>
+<span id="cb132-87"><a href="#cb132-87" aria-hidden="true" tabindex="-1"></a>    strategien <span class="op">=</span> [</span>
+<span id="cb132-88"><a href="#cb132-88" aria-hidden="true" tabindex="-1"></a>        (<span class="st">&quot;Stochastisch optimal&quot;</span>, kapazitaet),</span>
+<span id="cb132-89"><a href="#cb132-89" aria-hidden="true" tabindex="-1"></a>        (<span class="st">&quot;Naiv: Mittelwert einsetzen&quot;</span>, mittelwert),</span>
+<span id="cb132-90"><a href="#cb132-90" aria-hidden="true" tabindex="-1"></a>        (<span class="st">&quot;Vorsichtig: Worst Case abdecken&quot;</span>, <span class="bu">float</span>(BEDARF.<span class="bu">max</span>())),</span>
+<span id="cb132-91"><a href="#cb132-91" aria-hidden="true" tabindex="-1"></a>        (<span class="st">&quot;Optimistisch: Bestfall&quot;</span>, <span class="bu">float</span>(BEDARF.<span class="bu">min</span>())),</span>
+<span id="cb132-92"><a href="#cb132-92" aria-hidden="true" tabindex="-1"></a>    ]</span>
+<span id="cb132-93"><a href="#cb132-93" aria-hidden="true" tabindex="-1"></a>    <span class="cf">for</span> name, kap <span class="kw">in</span> strategien:</span>
+<span id="cb132-94"><a href="#cb132-94" aria-hidden="true" tabindex="-1"></a>        kosten <span class="op">=</span> kosten_bei(kap)</span>
+<span id="cb132-95"><a href="#cb132-95" aria-hidden="true" tabindex="-1"></a>        <span class="bu">print</span>(<span class="ss">f&quot;</span><span class="sc">{</span>name<span class="sc">:&lt;34}</span><span class="ss"> </span><span class="sc">{</span>kap<span class="sc">:&gt;11.1f}</span><span class="ss"> </span><span class="sc">{</span>kosten<span class="sc">:&gt;14,.0f}</span><span class="ss"> &quot;</span></span>
+<span id="cb132-96"><a href="#cb132-96" aria-hidden="true" tabindex="-1"></a>              <span class="ss">f&quot;</span><span class="sc">{</span>kosten <span class="op">-</span> optimal<span class="sc">:&gt;+13,.0f}</span><span class="ss">&quot;</span>)</span>
+<span id="cb132-97"><a href="#cb132-97" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb132-98"><a href="#cb132-98" aria-hidden="true" tabindex="-1"></a>    <span class="co"># --- EVPI: Was waere perfekte Voraussicht wert? ----------------------</span></span>
+<span id="cb132-99"><a href="#cb132-99" aria-hidden="true" tabindex="-1"></a>    <span class="co"># Bei perfekter Information wuerde man je Szenario genau den Bedarf kaufen.</span></span>
+<span id="cb132-100"><a href="#cb132-100" aria-hidden="true" tabindex="-1"></a>    kosten_perfekt <span class="op">=</span> <span class="bu">float</span>(WAHRSCHEINLICHKEIT <span class="op">@</span> (KOSTEN_VORAB <span class="op">*</span> BEDARF))</span>
+<span id="cb132-101"><a href="#cb132-101" aria-hidden="true" tabindex="-1"></a>    evpi <span class="op">=</span> optimal <span class="op">-</span> kosten_perfekt</span>
+<span id="cb132-102"><a href="#cb132-102" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;-&quot;</span> <span class="op">*</span> <span class="dv">82</span>)</span>
+<span id="cb132-103"><a href="#cb132-103" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;Kosten bei perfekter Voraussicht:      </span><span class="sc">{</span>kosten_perfekt<span class="sc">:&gt;10,.0f}</span><span class="ss"> EUR&quot;</span>)</span>
+<span id="cb132-104"><a href="#cb132-104" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;Wert perfekter Information (EVPI):     </span><span class="sc">{</span>evpi<span class="sc">:&gt;10,.0f}</span><span class="ss"> EUR &quot;</span></span>
+<span id="cb132-105"><a href="#cb132-105" aria-hidden="true" tabindex="-1"></a>          <span class="ss">f&quot;(</span><span class="sc">{</span>evpi<span class="op">/</span>optimal<span class="op">*</span><span class="dv">100</span><span class="sc">:.1f}</span><span class="ss"> % der Kosten)&quot;</span>)</span>
+<span id="cb132-106"><a href="#cb132-106" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;  -&gt; So viel duerfte eine perfekte Bedarfsprognose hoechstens kosten.&quot;</span>)</span>
+<span id="cb132-107"><a href="#cb132-107" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb132-108"><a href="#cb132-108" aria-hidden="true" tabindex="-1"></a>    <span class="co"># --- Automatische Interpretation --------------------------------------</span></span>
+<span id="cb132-109"><a href="#cb132-109" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;-&quot;</span> <span class="op">*</span> <span class="dv">82</span>)</span>
+<span id="cb132-110"><a href="#cb132-110" aria-hidden="true" tabindex="-1"></a>    <span class="cf">if</span> kapazitaet <span class="op">&gt;</span> mittelwert <span class="op">+</span> <span class="fl">1e-6</span>:</span>
+<span id="cb132-111"><a href="#cb132-111" aria-hidden="true" tabindex="-1"></a>        <span class="bu">print</span>(<span class="ss">f&quot;Analyse: Der Solver waehlt </span><span class="sc">{</span>kapazitaet<span class="sc">:.0f}</span><span class="ss"> Einheiten und damit MEHR als&quot;</span>)</span>
+<span id="cb132-112"><a href="#cb132-112" aria-hidden="true" tabindex="-1"></a>        <span class="bu">print</span>(<span class="ss">f&quot;den Mittelwert (</span><span class="sc">{</span>mittelwert<span class="sc">:.0f}</span><span class="ss">), weil Unterdeckung (</span><span class="sc">{</span>KOSTEN_SPOT<span class="sc">:.0f}</span><span class="ss"> EUR)&quot;</span>)</span>
+<span id="cb132-113"><a href="#cb132-113" aria-hidden="true" tabindex="-1"></a>        <span class="bu">print</span>(<span class="ss">f&quot;deutlich teurer ist als Leerlauf (</span><span class="sc">{</span>KOSTEN_LEERLAUF<span class="sc">:.0f}</span><span class="ss"> EUR).&quot;</span>)</span>
+<span id="cb132-114"><a href="#cb132-114" aria-hidden="true" tabindex="-1"></a>    <span class="cf">elif</span> kapazitaet <span class="op">&lt;</span> mittelwert <span class="op">-</span> <span class="fl">1e-6</span>:</span>
+<span id="cb132-115"><a href="#cb132-115" aria-hidden="true" tabindex="-1"></a>        <span class="bu">print</span>(<span class="ss">f&quot;Analyse: Der Solver waehlt </span><span class="sc">{</span>kapazitaet<span class="sc">:.0f}</span><span class="ss"> und damit WENIGER als den&quot;</span>)</span>
+<span id="cb132-116"><a href="#cb132-116" aria-hidden="true" tabindex="-1"></a>        <span class="bu">print</span>(<span class="ss">f&quot;Mittelwert (</span><span class="sc">{</span>mittelwert<span class="sc">:.0f}</span><span class="ss">) - Leerlauf ist hier teurer als Zukauf.&quot;</span>)</span>
+<span id="cb132-117"><a href="#cb132-117" aria-hidden="true" tabindex="-1"></a>    <span class="cf">else</span>:</span>
+<span id="cb132-118"><a href="#cb132-118" aria-hidden="true" tabindex="-1"></a>        <span class="bu">print</span>(<span class="st">&quot;Analyse: Kapazitaet entspricht dem Mittelwert (symmetrische Kosten).&quot;</span>)</span>
+<span id="cb132-119"><a href="#cb132-119" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;=&quot;</span> <span class="op">*</span> <span class="dv">82</span>)</span></code></pre></div>
 <p><strong>Erwartete Ausgabe:</strong></p>
 <pre><code>==================================================================================
      STOCHASTISCHE TWO-STAGE OPTIMIERUNG (KAPAZITAETSPLANUNG)
@@ -16997,7 +17862,7 @@ den Mittelwert (225), weil Unterdeckung (120 EUR)
 deutlich teurer ist als Leerlauf (5 EUR).
 ==================================================================================</code></pre>
 <p><strong>Lesen Sie die Vergleichstabelle von unten nach oben.</strong> Die beiden extremen Haltungen sind die teuersten: Wer den Worst Case abdeckt (500 Einheiten), zahlt 5 000 € zu viel für Kapazität, die in 80 % der Fälle brachliegt. Wer optimistisch plant (100), zahlt 2 625 € Strafe für ständige Notzukäufe. Die naive Mittelwertplanung liegt dazwischen — aber eben auch nicht optimal.</p>
-<p>Der <strong>EVPI von 7 375 €</strong> ist bemerkenswert hoch: 45 % der Gesamtkosten entstehen allein daraus, dass man die Zukunft nicht kennt. In so einem Fall lohnt sich Investition in bessere Prognosen tatsächlich — anders als in dem Beispiel aus Übung 9.4.</p>
+<p>Der <strong>EVPI von 7 375 €</strong> ist bemerkenswert hoch: 45 % der Gesamtkosten entstehen allein daraus, dass man die Zukunft nicht kennt. In so einem Fall lohnt sich Investition in bessere Prognosen tatsächlich — anders als in dem Beispiel aus der Aufgabe <em>EVPI interpretieren</em> (<a href="#sec:unsicherheit-uebungsaufgaben">Abschnitt 12.8</a>).</p>
 <blockquote>
 <p><strong>💡 Was ist der EVPI?</strong> Der <strong>Expected Value of Perfect Information</strong> beziffert, wie viel eine perfekte Prognose wert wäre: die Differenz zwischen den Kosten unter Unsicherheit und den Kosten bei vollständigem Wissen. Er ist eine <strong>Obergrenze für jedes Prognoseprojekt</strong>. Wenn der EVPI bei 12 000 € pro Jahr liegt, lohnt sich keine Prognosesoftware für 50 000 € — selbst wenn sie perfekt wäre. Diese Zahl bewahrt Projekte vor teuren Fehlinvestitionen.</p>
 </blockquote>
@@ -17018,105 +17883,105 @@ deutlich teurer ist als Leerlauf (5 EUR).
 = \hat{\boldsymbol{\mu}}^\top\mathbf{w} - \boldsymbol{\delta}^\top\mathbf{w}
 </span></p>
 <p>Das Min-Max-Problem wird damit zu einem <strong>gewöhnlichen</strong> Optimierungsproblem mit einem Abzugsterm. Genau das macht robuste Optimierung praktikabel.</p>
-<div class="sourceCode" id="cb132"><pre class="sourceCode python"><code class="sourceCode python"><span id="cb132-1"><a href="#cb132-1" aria-hidden="true" tabindex="-1"></a><span class="co">#!/usr/bin/env python3</span></span>
-<span id="cb132-2"><a href="#cb132-2" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb132-3"><a href="#cb132-3" aria-hidden="true" tabindex="-1"></a><span class="co"># Robuste_Optimierung.py</span></span>
-<span id="cb132-4"><a href="#cb132-4" aria-hidden="true" tabindex="-1"></a><span class="co">&quot;&quot;&quot;</span></span>
-<span id="cb132-5"><a href="#cb132-5" aria-hidden="true" tabindex="-1"></a><span class="co">Kapitel Unsicherheit: Robuste Portfolio-Optimierung.</span></span>
-<span id="cb132-6"><a href="#cb132-6" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb132-7"><a href="#cb132-7" aria-hidden="true" tabindex="-1"></a><span class="co">Vergleicht drei Haltungen zur Unsicherheit:</span></span>
-<span id="cb132-8"><a href="#cb132-8" aria-hidden="true" tabindex="-1"></a><span class="co">  (a) nominal   - vertraut den Punktschaetzungen blind</span></span>
-<span id="cb132-9"><a href="#cb132-9" aria-hidden="true" tabindex="-1"></a><span class="co">  (b) robust    - sichert gegen Box-Unsicherheit ab (Worst Case)</span></span>
-<span id="cb132-10"><a href="#cb132-10" aria-hidden="true" tabindex="-1"></a><span class="co">  (c) stochastisch - optimiert den Erwartungswert ueber Szenarien</span></span>
-<span id="cb132-11"><a href="#cb132-11" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb132-12"><a href="#cb132-12" aria-hidden="true" tabindex="-1"></a><span class="co">und misst den &quot;Preis der Robustheit&quot;: Wie viel Ertrag kostet die Absicherung</span></span>
-<span id="cb132-13"><a href="#cb132-13" aria-hidden="true" tabindex="-1"></a><span class="co">im Normalfall - und wie viel Verlust erspart sie im Ernstfall?</span></span>
-<span id="cb132-14"><a href="#cb132-14" aria-hidden="true" tabindex="-1"></a><span class="co">&quot;&quot;&quot;</span></span>
-<span id="cb132-15"><a href="#cb132-15" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb132-16"><a href="#cb132-16" aria-hidden="true" tabindex="-1"></a><span class="im">import</span> cvxpy <span class="im">as</span> cp</span>
-<span id="cb132-17"><a href="#cb132-17" aria-hidden="true" tabindex="-1"></a><span class="im">import</span> numpy <span class="im">as</span> np</span>
-<span id="cb132-18"><a href="#cb132-18" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb132-19"><a href="#cb132-19" aria-hidden="true" tabindex="-1"></a>ASSETS <span class="op">=</span> [<span class="st">&quot;Aktien Welt&quot;</span>, <span class="st">&quot;Anleihen&quot;</span>, <span class="st">&quot;Rohstoffe&quot;</span>, <span class="st">&quot;Immobilien&quot;</span>]</span>
-<span id="cb132-20"><a href="#cb132-20" aria-hidden="true" tabindex="-1"></a>MU_SCHAETZUNG <span class="op">=</span> np.array([<span class="fl">0.085</span>, <span class="fl">0.030</span>, <span class="fl">0.055</span>, <span class="fl">0.060</span>])   <span class="co"># Punktschaetzung</span></span>
-<span id="cb132-21"><a href="#cb132-21" aria-hidden="true" tabindex="-1"></a>UNSICHERHEIT <span class="op">=</span> np.array([<span class="fl">0.040</span>, <span class="fl">0.008</span>, <span class="fl">0.045</span>, <span class="fl">0.025</span>])    <span class="co"># +/- delta je Titel</span></span>
-<span id="cb132-22"><a href="#cb132-22" aria-hidden="true" tabindex="-1"></a>VOLA <span class="op">=</span> np.array([<span class="fl">0.17</span>, <span class="fl">0.05</span>, <span class="fl">0.22</span>, <span class="fl">0.12</span>])</span>
-<span id="cb132-23"><a href="#cb132-23" aria-hidden="true" tabindex="-1"></a>KORR <span class="op">=</span> np.array([</span>
-<span id="cb132-24"><a href="#cb132-24" aria-hidden="true" tabindex="-1"></a>    [<span class="fl">1.00</span>, <span class="op">-</span><span class="fl">0.15</span>, <span class="fl">0.35</span>, <span class="fl">0.55</span>],</span>
-<span id="cb132-25"><a href="#cb132-25" aria-hidden="true" tabindex="-1"></a>    [<span class="op">-</span><span class="fl">0.15</span>, <span class="fl">1.00</span>, <span class="op">-</span><span class="fl">0.05</span>, <span class="fl">0.10</span>],</span>
-<span id="cb132-26"><a href="#cb132-26" aria-hidden="true" tabindex="-1"></a>    [<span class="fl">0.35</span>, <span class="op">-</span><span class="fl">0.05</span>, <span class="fl">1.00</span>, <span class="fl">0.25</span>],</span>
-<span id="cb132-27"><a href="#cb132-27" aria-hidden="true" tabindex="-1"></a>    [<span class="fl">0.55</span>, <span class="fl">0.10</span>, <span class="fl">0.25</span>, <span class="fl">1.00</span>],</span>
-<span id="cb132-28"><a href="#cb132-28" aria-hidden="true" tabindex="-1"></a>])</span>
-<span id="cb132-29"><a href="#cb132-29" aria-hidden="true" tabindex="-1"></a>SIGMA <span class="op">=</span> np.diag(VOLA) <span class="op">@</span> KORR <span class="op">@</span> np.diag(VOLA)</span>
-<span id="cb132-30"><a href="#cb132-30" aria-hidden="true" tabindex="-1"></a>LAMBDA <span class="op">=</span> <span class="fl">4.0</span>        <span class="co"># Risikoaversion</span></span>
-<span id="cb132-31"><a href="#cb132-31" aria-hidden="true" tabindex="-1"></a>N <span class="op">=</span> <span class="bu">len</span>(ASSETS)</span>
-<span id="cb132-32"><a href="#cb132-32" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb132-33"><a href="#cb132-33" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb132-34"><a href="#cb132-34" aria-hidden="true" tabindex="-1"></a><span class="kw">def</span> optimiere(mu_effektiv):</span>
-<span id="cb132-35"><a href="#cb132-35" aria-hidden="true" tabindex="-1"></a>    <span class="co">&quot;&quot;&quot;Standard-Mean-Variance mit vorgegebenem Renditevektor.&quot;&quot;&quot;</span></span>
-<span id="cb132-36"><a href="#cb132-36" aria-hidden="true" tabindex="-1"></a>    w <span class="op">=</span> cp.Variable(N, nonneg<span class="op">=</span><span class="va">True</span>)</span>
-<span id="cb132-37"><a href="#cb132-37" aria-hidden="true" tabindex="-1"></a>    ziel <span class="op">=</span> cp.Maximize(mu_effektiv <span class="op">@</span> w <span class="op">-</span> <span class="fl">0.5</span> <span class="op">*</span> LAMBDA <span class="op">*</span> cp.quad_form(w, SIGMA))</span>
-<span id="cb132-38"><a href="#cb132-38" aria-hidden="true" tabindex="-1"></a>    problem <span class="op">=</span> cp.Problem(ziel, [cp.<span class="bu">sum</span>(w) <span class="op">==</span> <span class="dv">1</span>])</span>
-<span id="cb132-39"><a href="#cb132-39" aria-hidden="true" tabindex="-1"></a>    problem.solve()</span>
-<span id="cb132-40"><a href="#cb132-40" aria-hidden="true" tabindex="-1"></a>    <span class="cf">return</span> w.value</span>
-<span id="cb132-41"><a href="#cb132-41" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb132-42"><a href="#cb132-42" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb132-43"><a href="#cb132-43" aria-hidden="true" tabindex="-1"></a><span class="kw">def</span> kennzahlen(w, mu):</span>
-<span id="cb132-44"><a href="#cb132-44" aria-hidden="true" tabindex="-1"></a>    ertrag <span class="op">=</span> <span class="bu">float</span>(mu <span class="op">@</span> w)</span>
-<span id="cb132-45"><a href="#cb132-45" aria-hidden="true" tabindex="-1"></a>    risiko <span class="op">=</span> <span class="bu">float</span>(np.sqrt(w <span class="op">@</span> SIGMA <span class="op">@</span> w))</span>
-<span id="cb132-46"><a href="#cb132-46" aria-hidden="true" tabindex="-1"></a>    <span class="cf">return</span> ertrag, risiko</span>
-<span id="cb132-47"><a href="#cb132-47" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb132-48"><a href="#cb132-48" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb132-49"><a href="#cb132-49" aria-hidden="true" tabindex="-1"></a><span class="cf">if</span> <span class="va">__name__</span> <span class="op">==</span> <span class="st">&quot;__main__&quot;</span>:</span>
-<span id="cb132-50"><a href="#cb132-50" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;=&quot;</span> <span class="op">*</span> <span class="dv">88</span>)</span>
-<span id="cb132-51"><a href="#cb132-51" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;  ROBUSTE vs. NOMINALE PORTFOLIO-OPTIMIERUNG&quot;</span>)</span>
-<span id="cb132-52"><a href="#cb132-52" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;=&quot;</span> <span class="op">*</span> <span class="dv">88</span>)</span>
-<span id="cb132-53"><a href="#cb132-53" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;</span><span class="sc">{</span><span class="st">&#39;Asset&#39;</span><span class="sc">:&lt;14}</span><span class="ss"> </span><span class="sc">{</span><span class="st">&#39;Erw. Rendite&#39;</span><span class="sc">:&gt;14}</span><span class="ss"> </span><span class="sc">{</span><span class="st">&#39;Unsicherheit&#39;</span><span class="sc">:&gt;14}</span><span class="ss"> &quot;</span></span>
-<span id="cb132-54"><a href="#cb132-54" aria-hidden="true" tabindex="-1"></a>          <span class="ss">f&quot;</span><span class="sc">{</span><span class="st">&#39;Worst Case&#39;</span><span class="sc">:&gt;12}</span><span class="ss"> </span><span class="sc">{</span><span class="st">&#39;Volatilitaet&#39;</span><span class="sc">:&gt;13}</span><span class="ss">&quot;</span>)</span>
-<span id="cb132-55"><a href="#cb132-55" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;-&quot;</span> <span class="op">*</span> <span class="dv">88</span>)</span>
-<span id="cb132-56"><a href="#cb132-56" aria-hidden="true" tabindex="-1"></a>    <span class="cf">for</span> i, name <span class="kw">in</span> <span class="bu">enumerate</span>(ASSETS):</span>
-<span id="cb132-57"><a href="#cb132-57" aria-hidden="true" tabindex="-1"></a>        <span class="bu">print</span>(<span class="ss">f&quot;</span><span class="sc">{</span>name<span class="sc">:&lt;14}</span><span class="ss"> </span><span class="sc">{</span>MU_SCHAETZUNG[i]<span class="op">*</span><span class="dv">100</span><span class="sc">:&gt;13.1f}</span><span class="ss"> % &quot;</span></span>
-<span id="cb132-58"><a href="#cb132-58" aria-hidden="true" tabindex="-1"></a>              <span class="ss">f&quot;</span><span class="sc">{</span><span class="st">&#39;+/- &#39;</span> <span class="op">+</span> <span class="bu">format</span>(UNSICHERHEIT[i]<span class="op">*</span><span class="dv">100</span>, <span class="st">&#39;.1f&#39;</span>) <span class="op">+</span> <span class="st">&#39; %&#39;</span><span class="sc">:&gt;14}</span><span class="ss"> &quot;</span></span>
-<span id="cb132-59"><a href="#cb132-59" aria-hidden="true" tabindex="-1"></a>              <span class="ss">f&quot;</span><span class="sc">{</span>(MU_SCHAETZUNG[i]<span class="op">-</span>UNSICHERHEIT[i])<span class="op">*</span><span class="dv">100</span><span class="sc">:&gt;11.1f}</span><span class="ss"> % &quot;</span></span>
-<span id="cb132-60"><a href="#cb132-60" aria-hidden="true" tabindex="-1"></a>              <span class="ss">f&quot;</span><span class="sc">{</span>VOLA[i]<span class="op">*</span><span class="dv">100</span><span class="sc">:&gt;12.1f}</span><span class="ss"> %&quot;</span>)</span>
-<span id="cb132-61"><a href="#cb132-61" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb132-62"><a href="#cb132-62" aria-hidden="true" tabindex="-1"></a>    <span class="co"># (a) nominal: vertraut den Schaetzungen</span></span>
-<span id="cb132-63"><a href="#cb132-63" aria-hidden="true" tabindex="-1"></a>    w_nominal <span class="op">=</span> optimiere(MU_SCHAETZUNG)</span>
-<span id="cb132-64"><a href="#cb132-64" aria-hidden="true" tabindex="-1"></a>    <span class="co"># (b) robust: rechnet mit dem Worst Case der Box-Unsicherheitsmenge</span></span>
-<span id="cb132-65"><a href="#cb132-65" aria-hidden="true" tabindex="-1"></a>    w_robust <span class="op">=</span> optimiere(MU_SCHAETZUNG <span class="op">-</span> UNSICHERHEIT)</span>
-<span id="cb132-66"><a href="#cb132-66" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb132-67"><a href="#cb132-67" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;</span><span class="ch">\n</span><span class="st">&quot;</span> <span class="op">+</span> <span class="st">&quot;-&quot;</span> <span class="op">*</span> <span class="dv">88</span>)</span>
-<span id="cb132-68"><a href="#cb132-68" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;</span><span class="sc">{</span><span class="st">&#39;&#39;</span><span class="sc">:&lt;14}</span><span class="ss"> </span><span class="sc">{</span><span class="st">&#39;nominal&#39;</span><span class="sc">:&gt;22}</span><span class="ss"> </span><span class="sc">{</span><span class="st">&#39;robust&#39;</span><span class="sc">:&gt;22}</span><span class="ss">&quot;</span>)</span>
-<span id="cb132-69"><a href="#cb132-69" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;-&quot;</span> <span class="op">*</span> <span class="dv">88</span>)</span>
-<span id="cb132-70"><a href="#cb132-70" aria-hidden="true" tabindex="-1"></a>    <span class="cf">for</span> i, name <span class="kw">in</span> <span class="bu">enumerate</span>(ASSETS):</span>
-<span id="cb132-71"><a href="#cb132-71" aria-hidden="true" tabindex="-1"></a>        <span class="bu">print</span>(<span class="ss">f&quot;</span><span class="sc">{</span>name<span class="sc">:&lt;14}</span><span class="ss"> </span><span class="sc">{</span>w_nominal[i]<span class="op">*</span><span class="dv">100</span><span class="sc">:&gt;21.1f}</span><span class="ss"> % </span><span class="sc">{</span>w_robust[i]<span class="op">*</span><span class="dv">100</span><span class="sc">:&gt;21.1f}</span><span class="ss"> %&quot;</span>)</span>
-<span id="cb132-72"><a href="#cb132-72" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb132-73"><a href="#cb132-73" aria-hidden="true" tabindex="-1"></a>    <span class="co"># --- Bewertung in beiden Welten --------------------------------------</span></span>
-<span id="cb132-74"><a href="#cb132-74" aria-hidden="true" tabindex="-1"></a>    mu_worst <span class="op">=</span> MU_SCHAETZUNG <span class="op">-</span> UNSICHERHEIT</span>
-<span id="cb132-75"><a href="#cb132-75" aria-hidden="true" tabindex="-1"></a>    e_nom_gut, r_nom <span class="op">=</span> kennzahlen(w_nominal, MU_SCHAETZUNG)</span>
-<span id="cb132-76"><a href="#cb132-76" aria-hidden="true" tabindex="-1"></a>    e_rob_gut, r_rob <span class="op">=</span> kennzahlen(w_robust, MU_SCHAETZUNG)</span>
-<span id="cb132-77"><a href="#cb132-77" aria-hidden="true" tabindex="-1"></a>    e_nom_schlecht, _ <span class="op">=</span> kennzahlen(w_nominal, mu_worst)</span>
-<span id="cb132-78"><a href="#cb132-78" aria-hidden="true" tabindex="-1"></a>    e_rob_schlecht, _ <span class="op">=</span> kennzahlen(w_robust, mu_worst)</span>
-<span id="cb132-79"><a href="#cb132-79" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb132-80"><a href="#cb132-80" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;</span><span class="ch">\n</span><span class="st">&quot;</span> <span class="op">+</span> <span class="st">&quot;-&quot;</span> <span class="op">*</span> <span class="dv">88</span>)</span>
-<span id="cb132-81"><a href="#cb132-81" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;</span><span class="sc">{</span><span class="st">&#39;Bewertung&#39;</span><span class="sc">:&lt;34}</span><span class="ss"> </span><span class="sc">{</span><span class="st">&#39;nominales Portfolio&#39;</span><span class="sc">:&gt;22}</span><span class="ss"> </span><span class="sc">{</span><span class="st">&#39;robustes Portfolio&#39;</span><span class="sc">:&gt;22}</span><span class="ss">&quot;</span>)</span>
-<span id="cb132-82"><a href="#cb132-82" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;-&quot;</span> <span class="op">*</span> <span class="dv">88</span>)</span>
-<span id="cb132-83"><a href="#cb132-83" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;</span><span class="sc">{</span><span class="st">&#39;Ertrag, wenn Schaetzung stimmt&#39;</span><span class="sc">:&lt;34}</span><span class="ss"> </span><span class="sc">{</span>e_nom_gut<span class="op">*</span><span class="dv">100</span><span class="sc">:&gt;21.2f}</span><span class="ss"> % &quot;</span></span>
-<span id="cb132-84"><a href="#cb132-84" aria-hidden="true" tabindex="-1"></a>          <span class="ss">f&quot;</span><span class="sc">{</span>e_rob_gut<span class="op">*</span><span class="dv">100</span><span class="sc">:&gt;21.2f}</span><span class="ss"> %&quot;</span>)</span>
-<span id="cb132-85"><a href="#cb132-85" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;</span><span class="sc">{</span><span class="st">&#39;Ertrag im Worst Case&#39;</span><span class="sc">:&lt;34}</span><span class="ss"> </span><span class="sc">{</span>e_nom_schlecht<span class="op">*</span><span class="dv">100</span><span class="sc">:&gt;21.2f}</span><span class="ss"> % &quot;</span></span>
-<span id="cb132-86"><a href="#cb132-86" aria-hidden="true" tabindex="-1"></a>          <span class="ss">f&quot;</span><span class="sc">{</span>e_rob_schlecht<span class="op">*</span><span class="dv">100</span><span class="sc">:&gt;21.2f}</span><span class="ss"> %&quot;</span>)</span>
-<span id="cb132-87"><a href="#cb132-87" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;</span><span class="sc">{</span><span class="st">&#39;Volatilitaet&#39;</span><span class="sc">:&lt;34}</span><span class="ss"> </span><span class="sc">{</span>r_nom<span class="op">*</span><span class="dv">100</span><span class="sc">:&gt;21.2f}</span><span class="ss"> % </span><span class="sc">{</span>r_rob<span class="op">*</span><span class="dv">100</span><span class="sc">:&gt;21.2f}</span><span class="ss"> %&quot;</span>)</span>
-<span id="cb132-88"><a href="#cb132-88" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb132-89"><a href="#cb132-89" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;</span><span class="ch">\n</span><span class="st">&quot;</span> <span class="op">+</span> <span class="st">&quot;-&quot;</span> <span class="op">*</span> <span class="dv">88</span>)</span>
-<span id="cb132-90"><a href="#cb132-90" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;Preis der Robustheit (Ertragsverzicht im Normalfall): &quot;</span></span>
-<span id="cb132-91"><a href="#cb132-91" aria-hidden="true" tabindex="-1"></a>          <span class="ss">f&quot;</span><span class="sc">{</span>(e_nom_gut <span class="op">-</span> e_rob_gut)<span class="op">*</span><span class="dv">100</span><span class="sc">:+.2f}</span><span class="ss"> Prozentpunkte&quot;</span>)</span>
-<span id="cb132-92"><a href="#cb132-92" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;Nutzen der Robustheit (Vorteil im Worst Case):        &quot;</span></span>
-<span id="cb132-93"><a href="#cb132-93" aria-hidden="true" tabindex="-1"></a>          <span class="ss">f&quot;</span><span class="sc">{</span>(e_rob_schlecht <span class="op">-</span> e_nom_schlecht)<span class="op">*</span><span class="dv">100</span><span class="sc">:+.2f}</span><span class="ss"> Prozentpunkte&quot;</span>)</span>
-<span id="cb132-94"><a href="#cb132-94" aria-hidden="true" tabindex="-1"></a>    verhaeltnis <span class="op">=</span> ((e_rob_schlecht <span class="op">-</span> e_nom_schlecht)</span>
-<span id="cb132-95"><a href="#cb132-95" aria-hidden="true" tabindex="-1"></a>                   <span class="op">/</span> <span class="bu">max</span>(e_nom_gut <span class="op">-</span> e_rob_gut, <span class="fl">1e-9</span>))</span>
-<span id="cb132-96"><a href="#cb132-96" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;Verhaeltnis Nutzen/Preis: </span><span class="sc">{</span>verhaeltnis<span class="sc">:.2f}</span><span class="ss">&quot;</span>)</span>
-<span id="cb132-97"><a href="#cb132-97" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;  -&gt; Werte &gt; 1 bedeuten: Die Absicherung bringt im Ernstfall mehr,&quot;</span>)</span>
-<span id="cb132-98"><a href="#cb132-98" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;     als sie im Normalfall kostet.&quot;</span>)</span>
-<span id="cb132-99"><a href="#cb132-99" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;=&quot;</span> <span class="op">*</span> <span class="dv">88</span>)</span></code></pre></div>
+<div class="sourceCode" id="cb134"><pre class="sourceCode python"><code class="sourceCode python"><span id="cb134-1"><a href="#cb134-1" aria-hidden="true" tabindex="-1"></a><span class="co">#!/usr/bin/env python3</span></span>
+<span id="cb134-2"><a href="#cb134-2" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb134-3"><a href="#cb134-3" aria-hidden="true" tabindex="-1"></a><span class="co"># Robuste_Optimierung.py</span></span>
+<span id="cb134-4"><a href="#cb134-4" aria-hidden="true" tabindex="-1"></a><span class="co">&quot;&quot;&quot;</span></span>
+<span id="cb134-5"><a href="#cb134-5" aria-hidden="true" tabindex="-1"></a><span class="co">Kapitel Unsicherheit: Robuste Portfolio-Optimierung.</span></span>
+<span id="cb134-6"><a href="#cb134-6" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb134-7"><a href="#cb134-7" aria-hidden="true" tabindex="-1"></a><span class="co">Vergleicht drei Haltungen zur Unsicherheit:</span></span>
+<span id="cb134-8"><a href="#cb134-8" aria-hidden="true" tabindex="-1"></a><span class="co">  (a) nominal   - vertraut den Punktschaetzungen blind</span></span>
+<span id="cb134-9"><a href="#cb134-9" aria-hidden="true" tabindex="-1"></a><span class="co">  (b) robust    - sichert gegen Box-Unsicherheit ab (Worst Case)</span></span>
+<span id="cb134-10"><a href="#cb134-10" aria-hidden="true" tabindex="-1"></a><span class="co">  (c) stochastisch - optimiert den Erwartungswert ueber Szenarien</span></span>
+<span id="cb134-11"><a href="#cb134-11" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb134-12"><a href="#cb134-12" aria-hidden="true" tabindex="-1"></a><span class="co">und misst den &quot;Preis der Robustheit&quot;: Wie viel Ertrag kostet die Absicherung</span></span>
+<span id="cb134-13"><a href="#cb134-13" aria-hidden="true" tabindex="-1"></a><span class="co">im Normalfall - und wie viel Verlust erspart sie im Ernstfall?</span></span>
+<span id="cb134-14"><a href="#cb134-14" aria-hidden="true" tabindex="-1"></a><span class="co">&quot;&quot;&quot;</span></span>
+<span id="cb134-15"><a href="#cb134-15" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb134-16"><a href="#cb134-16" aria-hidden="true" tabindex="-1"></a><span class="im">import</span> cvxpy <span class="im">as</span> cp</span>
+<span id="cb134-17"><a href="#cb134-17" aria-hidden="true" tabindex="-1"></a><span class="im">import</span> numpy <span class="im">as</span> np</span>
+<span id="cb134-18"><a href="#cb134-18" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb134-19"><a href="#cb134-19" aria-hidden="true" tabindex="-1"></a>ASSETS <span class="op">=</span> [<span class="st">&quot;Aktien Welt&quot;</span>, <span class="st">&quot;Anleihen&quot;</span>, <span class="st">&quot;Rohstoffe&quot;</span>, <span class="st">&quot;Immobilien&quot;</span>]</span>
+<span id="cb134-20"><a href="#cb134-20" aria-hidden="true" tabindex="-1"></a>MU_SCHAETZUNG <span class="op">=</span> np.array([<span class="fl">0.085</span>, <span class="fl">0.030</span>, <span class="fl">0.055</span>, <span class="fl">0.060</span>])   <span class="co"># Punktschaetzung</span></span>
+<span id="cb134-21"><a href="#cb134-21" aria-hidden="true" tabindex="-1"></a>UNSICHERHEIT <span class="op">=</span> np.array([<span class="fl">0.040</span>, <span class="fl">0.008</span>, <span class="fl">0.045</span>, <span class="fl">0.025</span>])    <span class="co"># +/- delta je Titel</span></span>
+<span id="cb134-22"><a href="#cb134-22" aria-hidden="true" tabindex="-1"></a>VOLA <span class="op">=</span> np.array([<span class="fl">0.17</span>, <span class="fl">0.05</span>, <span class="fl">0.22</span>, <span class="fl">0.12</span>])</span>
+<span id="cb134-23"><a href="#cb134-23" aria-hidden="true" tabindex="-1"></a>KORR <span class="op">=</span> np.array([</span>
+<span id="cb134-24"><a href="#cb134-24" aria-hidden="true" tabindex="-1"></a>    [<span class="fl">1.00</span>, <span class="op">-</span><span class="fl">0.15</span>, <span class="fl">0.35</span>, <span class="fl">0.55</span>],</span>
+<span id="cb134-25"><a href="#cb134-25" aria-hidden="true" tabindex="-1"></a>    [<span class="op">-</span><span class="fl">0.15</span>, <span class="fl">1.00</span>, <span class="op">-</span><span class="fl">0.05</span>, <span class="fl">0.10</span>],</span>
+<span id="cb134-26"><a href="#cb134-26" aria-hidden="true" tabindex="-1"></a>    [<span class="fl">0.35</span>, <span class="op">-</span><span class="fl">0.05</span>, <span class="fl">1.00</span>, <span class="fl">0.25</span>],</span>
+<span id="cb134-27"><a href="#cb134-27" aria-hidden="true" tabindex="-1"></a>    [<span class="fl">0.55</span>, <span class="fl">0.10</span>, <span class="fl">0.25</span>, <span class="fl">1.00</span>],</span>
+<span id="cb134-28"><a href="#cb134-28" aria-hidden="true" tabindex="-1"></a>])</span>
+<span id="cb134-29"><a href="#cb134-29" aria-hidden="true" tabindex="-1"></a>SIGMA <span class="op">=</span> np.diag(VOLA) <span class="op">@</span> KORR <span class="op">@</span> np.diag(VOLA)</span>
+<span id="cb134-30"><a href="#cb134-30" aria-hidden="true" tabindex="-1"></a>LAMBDA <span class="op">=</span> <span class="fl">4.0</span>        <span class="co"># Risikoaversion</span></span>
+<span id="cb134-31"><a href="#cb134-31" aria-hidden="true" tabindex="-1"></a>N <span class="op">=</span> <span class="bu">len</span>(ASSETS)</span>
+<span id="cb134-32"><a href="#cb134-32" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb134-33"><a href="#cb134-33" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb134-34"><a href="#cb134-34" aria-hidden="true" tabindex="-1"></a><span class="kw">def</span> optimiere(mu_effektiv):</span>
+<span id="cb134-35"><a href="#cb134-35" aria-hidden="true" tabindex="-1"></a>    <span class="co">&quot;&quot;&quot;Standard-Mean-Variance mit vorgegebenem Renditevektor.&quot;&quot;&quot;</span></span>
+<span id="cb134-36"><a href="#cb134-36" aria-hidden="true" tabindex="-1"></a>    w <span class="op">=</span> cp.Variable(N, nonneg<span class="op">=</span><span class="va">True</span>)</span>
+<span id="cb134-37"><a href="#cb134-37" aria-hidden="true" tabindex="-1"></a>    ziel <span class="op">=</span> cp.Maximize(mu_effektiv <span class="op">@</span> w <span class="op">-</span> <span class="fl">0.5</span> <span class="op">*</span> LAMBDA <span class="op">*</span> cp.quad_form(w, SIGMA))</span>
+<span id="cb134-38"><a href="#cb134-38" aria-hidden="true" tabindex="-1"></a>    problem <span class="op">=</span> cp.Problem(ziel, [cp.<span class="bu">sum</span>(w) <span class="op">==</span> <span class="dv">1</span>])</span>
+<span id="cb134-39"><a href="#cb134-39" aria-hidden="true" tabindex="-1"></a>    problem.solve()</span>
+<span id="cb134-40"><a href="#cb134-40" aria-hidden="true" tabindex="-1"></a>    <span class="cf">return</span> w.value</span>
+<span id="cb134-41"><a href="#cb134-41" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb134-42"><a href="#cb134-42" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb134-43"><a href="#cb134-43" aria-hidden="true" tabindex="-1"></a><span class="kw">def</span> kennzahlen(w, mu):</span>
+<span id="cb134-44"><a href="#cb134-44" aria-hidden="true" tabindex="-1"></a>    ertrag <span class="op">=</span> <span class="bu">float</span>(mu <span class="op">@</span> w)</span>
+<span id="cb134-45"><a href="#cb134-45" aria-hidden="true" tabindex="-1"></a>    risiko <span class="op">=</span> <span class="bu">float</span>(np.sqrt(w <span class="op">@</span> SIGMA <span class="op">@</span> w))</span>
+<span id="cb134-46"><a href="#cb134-46" aria-hidden="true" tabindex="-1"></a>    <span class="cf">return</span> ertrag, risiko</span>
+<span id="cb134-47"><a href="#cb134-47" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb134-48"><a href="#cb134-48" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb134-49"><a href="#cb134-49" aria-hidden="true" tabindex="-1"></a><span class="cf">if</span> <span class="va">__name__</span> <span class="op">==</span> <span class="st">&quot;__main__&quot;</span>:</span>
+<span id="cb134-50"><a href="#cb134-50" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;=&quot;</span> <span class="op">*</span> <span class="dv">88</span>)</span>
+<span id="cb134-51"><a href="#cb134-51" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;  ROBUSTE vs. NOMINALE PORTFOLIO-OPTIMIERUNG&quot;</span>)</span>
+<span id="cb134-52"><a href="#cb134-52" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;=&quot;</span> <span class="op">*</span> <span class="dv">88</span>)</span>
+<span id="cb134-53"><a href="#cb134-53" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;</span><span class="sc">{</span><span class="st">&#39;Asset&#39;</span><span class="sc">:&lt;14}</span><span class="ss"> </span><span class="sc">{</span><span class="st">&#39;Erw. Rendite&#39;</span><span class="sc">:&gt;14}</span><span class="ss"> </span><span class="sc">{</span><span class="st">&#39;Unsicherheit&#39;</span><span class="sc">:&gt;14}</span><span class="ss"> &quot;</span></span>
+<span id="cb134-54"><a href="#cb134-54" aria-hidden="true" tabindex="-1"></a>          <span class="ss">f&quot;</span><span class="sc">{</span><span class="st">&#39;Worst Case&#39;</span><span class="sc">:&gt;12}</span><span class="ss"> </span><span class="sc">{</span><span class="st">&#39;Volatilitaet&#39;</span><span class="sc">:&gt;13}</span><span class="ss">&quot;</span>)</span>
+<span id="cb134-55"><a href="#cb134-55" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;-&quot;</span> <span class="op">*</span> <span class="dv">88</span>)</span>
+<span id="cb134-56"><a href="#cb134-56" aria-hidden="true" tabindex="-1"></a>    <span class="cf">for</span> i, name <span class="kw">in</span> <span class="bu">enumerate</span>(ASSETS):</span>
+<span id="cb134-57"><a href="#cb134-57" aria-hidden="true" tabindex="-1"></a>        <span class="bu">print</span>(<span class="ss">f&quot;</span><span class="sc">{</span>name<span class="sc">:&lt;14}</span><span class="ss"> </span><span class="sc">{</span>MU_SCHAETZUNG[i]<span class="op">*</span><span class="dv">100</span><span class="sc">:&gt;13.1f}</span><span class="ss"> % &quot;</span></span>
+<span id="cb134-58"><a href="#cb134-58" aria-hidden="true" tabindex="-1"></a>              <span class="ss">f&quot;</span><span class="sc">{</span><span class="st">&#39;+/- &#39;</span> <span class="op">+</span> <span class="bu">format</span>(UNSICHERHEIT[i]<span class="op">*</span><span class="dv">100</span>, <span class="st">&#39;.1f&#39;</span>) <span class="op">+</span> <span class="st">&#39; %&#39;</span><span class="sc">:&gt;14}</span><span class="ss"> &quot;</span></span>
+<span id="cb134-59"><a href="#cb134-59" aria-hidden="true" tabindex="-1"></a>              <span class="ss">f&quot;</span><span class="sc">{</span>(MU_SCHAETZUNG[i]<span class="op">-</span>UNSICHERHEIT[i])<span class="op">*</span><span class="dv">100</span><span class="sc">:&gt;11.1f}</span><span class="ss"> % &quot;</span></span>
+<span id="cb134-60"><a href="#cb134-60" aria-hidden="true" tabindex="-1"></a>              <span class="ss">f&quot;</span><span class="sc">{</span>VOLA[i]<span class="op">*</span><span class="dv">100</span><span class="sc">:&gt;12.1f}</span><span class="ss"> %&quot;</span>)</span>
+<span id="cb134-61"><a href="#cb134-61" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb134-62"><a href="#cb134-62" aria-hidden="true" tabindex="-1"></a>    <span class="co"># (a) nominal: vertraut den Schaetzungen</span></span>
+<span id="cb134-63"><a href="#cb134-63" aria-hidden="true" tabindex="-1"></a>    w_nominal <span class="op">=</span> optimiere(MU_SCHAETZUNG)</span>
+<span id="cb134-64"><a href="#cb134-64" aria-hidden="true" tabindex="-1"></a>    <span class="co"># (b) robust: rechnet mit dem Worst Case der Box-Unsicherheitsmenge</span></span>
+<span id="cb134-65"><a href="#cb134-65" aria-hidden="true" tabindex="-1"></a>    w_robust <span class="op">=</span> optimiere(MU_SCHAETZUNG <span class="op">-</span> UNSICHERHEIT)</span>
+<span id="cb134-66"><a href="#cb134-66" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb134-67"><a href="#cb134-67" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;</span><span class="ch">\n</span><span class="st">&quot;</span> <span class="op">+</span> <span class="st">&quot;-&quot;</span> <span class="op">*</span> <span class="dv">88</span>)</span>
+<span id="cb134-68"><a href="#cb134-68" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;</span><span class="sc">{</span><span class="st">&#39;&#39;</span><span class="sc">:&lt;14}</span><span class="ss"> </span><span class="sc">{</span><span class="st">&#39;nominal&#39;</span><span class="sc">:&gt;22}</span><span class="ss"> </span><span class="sc">{</span><span class="st">&#39;robust&#39;</span><span class="sc">:&gt;22}</span><span class="ss">&quot;</span>)</span>
+<span id="cb134-69"><a href="#cb134-69" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;-&quot;</span> <span class="op">*</span> <span class="dv">88</span>)</span>
+<span id="cb134-70"><a href="#cb134-70" aria-hidden="true" tabindex="-1"></a>    <span class="cf">for</span> i, name <span class="kw">in</span> <span class="bu">enumerate</span>(ASSETS):</span>
+<span id="cb134-71"><a href="#cb134-71" aria-hidden="true" tabindex="-1"></a>        <span class="bu">print</span>(<span class="ss">f&quot;</span><span class="sc">{</span>name<span class="sc">:&lt;14}</span><span class="ss"> </span><span class="sc">{</span>w_nominal[i]<span class="op">*</span><span class="dv">100</span><span class="sc">:&gt;21.1f}</span><span class="ss"> % </span><span class="sc">{</span>w_robust[i]<span class="op">*</span><span class="dv">100</span><span class="sc">:&gt;21.1f}</span><span class="ss"> %&quot;</span>)</span>
+<span id="cb134-72"><a href="#cb134-72" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb134-73"><a href="#cb134-73" aria-hidden="true" tabindex="-1"></a>    <span class="co"># --- Bewertung in beiden Welten --------------------------------------</span></span>
+<span id="cb134-74"><a href="#cb134-74" aria-hidden="true" tabindex="-1"></a>    mu_worst <span class="op">=</span> MU_SCHAETZUNG <span class="op">-</span> UNSICHERHEIT</span>
+<span id="cb134-75"><a href="#cb134-75" aria-hidden="true" tabindex="-1"></a>    e_nom_gut, r_nom <span class="op">=</span> kennzahlen(w_nominal, MU_SCHAETZUNG)</span>
+<span id="cb134-76"><a href="#cb134-76" aria-hidden="true" tabindex="-1"></a>    e_rob_gut, r_rob <span class="op">=</span> kennzahlen(w_robust, MU_SCHAETZUNG)</span>
+<span id="cb134-77"><a href="#cb134-77" aria-hidden="true" tabindex="-1"></a>    e_nom_schlecht, _ <span class="op">=</span> kennzahlen(w_nominal, mu_worst)</span>
+<span id="cb134-78"><a href="#cb134-78" aria-hidden="true" tabindex="-1"></a>    e_rob_schlecht, _ <span class="op">=</span> kennzahlen(w_robust, mu_worst)</span>
+<span id="cb134-79"><a href="#cb134-79" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb134-80"><a href="#cb134-80" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;</span><span class="ch">\n</span><span class="st">&quot;</span> <span class="op">+</span> <span class="st">&quot;-&quot;</span> <span class="op">*</span> <span class="dv">88</span>)</span>
+<span id="cb134-81"><a href="#cb134-81" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;</span><span class="sc">{</span><span class="st">&#39;Bewertung&#39;</span><span class="sc">:&lt;34}</span><span class="ss"> </span><span class="sc">{</span><span class="st">&#39;nominales Portfolio&#39;</span><span class="sc">:&gt;22}</span><span class="ss"> </span><span class="sc">{</span><span class="st">&#39;robustes Portfolio&#39;</span><span class="sc">:&gt;22}</span><span class="ss">&quot;</span>)</span>
+<span id="cb134-82"><a href="#cb134-82" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;-&quot;</span> <span class="op">*</span> <span class="dv">88</span>)</span>
+<span id="cb134-83"><a href="#cb134-83" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;</span><span class="sc">{</span><span class="st">&#39;Ertrag, wenn Schaetzung stimmt&#39;</span><span class="sc">:&lt;34}</span><span class="ss"> </span><span class="sc">{</span>e_nom_gut<span class="op">*</span><span class="dv">100</span><span class="sc">:&gt;21.2f}</span><span class="ss"> % &quot;</span></span>
+<span id="cb134-84"><a href="#cb134-84" aria-hidden="true" tabindex="-1"></a>          <span class="ss">f&quot;</span><span class="sc">{</span>e_rob_gut<span class="op">*</span><span class="dv">100</span><span class="sc">:&gt;21.2f}</span><span class="ss"> %&quot;</span>)</span>
+<span id="cb134-85"><a href="#cb134-85" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;</span><span class="sc">{</span><span class="st">&#39;Ertrag im Worst Case&#39;</span><span class="sc">:&lt;34}</span><span class="ss"> </span><span class="sc">{</span>e_nom_schlecht<span class="op">*</span><span class="dv">100</span><span class="sc">:&gt;21.2f}</span><span class="ss"> % &quot;</span></span>
+<span id="cb134-86"><a href="#cb134-86" aria-hidden="true" tabindex="-1"></a>          <span class="ss">f&quot;</span><span class="sc">{</span>e_rob_schlecht<span class="op">*</span><span class="dv">100</span><span class="sc">:&gt;21.2f}</span><span class="ss"> %&quot;</span>)</span>
+<span id="cb134-87"><a href="#cb134-87" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;</span><span class="sc">{</span><span class="st">&#39;Volatilitaet&#39;</span><span class="sc">:&lt;34}</span><span class="ss"> </span><span class="sc">{</span>r_nom<span class="op">*</span><span class="dv">100</span><span class="sc">:&gt;21.2f}</span><span class="ss"> % </span><span class="sc">{</span>r_rob<span class="op">*</span><span class="dv">100</span><span class="sc">:&gt;21.2f}</span><span class="ss"> %&quot;</span>)</span>
+<span id="cb134-88"><a href="#cb134-88" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb134-89"><a href="#cb134-89" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;</span><span class="ch">\n</span><span class="st">&quot;</span> <span class="op">+</span> <span class="st">&quot;-&quot;</span> <span class="op">*</span> <span class="dv">88</span>)</span>
+<span id="cb134-90"><a href="#cb134-90" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;Preis der Robustheit (Ertragsverzicht im Normalfall): &quot;</span></span>
+<span id="cb134-91"><a href="#cb134-91" aria-hidden="true" tabindex="-1"></a>          <span class="ss">f&quot;</span><span class="sc">{</span>(e_nom_gut <span class="op">-</span> e_rob_gut)<span class="op">*</span><span class="dv">100</span><span class="sc">:+.2f}</span><span class="ss"> Prozentpunkte&quot;</span>)</span>
+<span id="cb134-92"><a href="#cb134-92" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;Nutzen der Robustheit (Vorteil im Worst Case):        &quot;</span></span>
+<span id="cb134-93"><a href="#cb134-93" aria-hidden="true" tabindex="-1"></a>          <span class="ss">f&quot;</span><span class="sc">{</span>(e_rob_schlecht <span class="op">-</span> e_nom_schlecht)<span class="op">*</span><span class="dv">100</span><span class="sc">:+.2f}</span><span class="ss"> Prozentpunkte&quot;</span>)</span>
+<span id="cb134-94"><a href="#cb134-94" aria-hidden="true" tabindex="-1"></a>    verhaeltnis <span class="op">=</span> ((e_rob_schlecht <span class="op">-</span> e_nom_schlecht)</span>
+<span id="cb134-95"><a href="#cb134-95" aria-hidden="true" tabindex="-1"></a>                   <span class="op">/</span> <span class="bu">max</span>(e_nom_gut <span class="op">-</span> e_rob_gut, <span class="fl">1e-9</span>))</span>
+<span id="cb134-96"><a href="#cb134-96" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;Verhaeltnis Nutzen/Preis: </span><span class="sc">{</span>verhaeltnis<span class="sc">:.2f}</span><span class="ss">&quot;</span>)</span>
+<span id="cb134-97"><a href="#cb134-97" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;  -&gt; Werte &gt; 1 bedeuten: Die Absicherung bringt im Ernstfall mehr,&quot;</span>)</span>
+<span id="cb134-98"><a href="#cb134-98" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;     als sie im Normalfall kostet.&quot;</span>)</span>
+<span id="cb134-99"><a href="#cb134-99" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;=&quot;</span> <span class="op">*</span> <span class="dv">88</span>)</span></code></pre></div>
 <blockquote>
 <p><strong>⚠️ Der Preis der Robustheit</strong> Robuste Modelle sind <strong>konservativ</strong>. Wer gegen den absoluten Worst Case absichert, zahlt im Normalfall drauf — oft erheblich. Drei Gegenmittel: 1. <strong>Unsicherheitsmenge realistisch wählen.</strong> Nicht „alles kann passieren“, sondern „Abweichungen bis zu einer Standardabweichung“. 2. <strong>Budgeted Uncertainty (Bertsimas/Sim)</strong>: Man nimmt an, dass höchstens <span class="math inline">\Gamma</span> von <span class="math inline">n</span> Parametern gleichzeitig ihren Worst Case annehmen. <span class="math inline">\Gamma</span> steuert die Vorsicht stufenlos. 3. <strong>Nutzen und Preis immer beziffern</strong> — genau wie im Programm oben. Ohne diese zwei Zahlen ist die Diskussion „robust oder nicht“ Glaubenssache.</p>
 </blockquote>
@@ -17156,234 +18021,234 @@ z_s &amp;\in \{0,1\}
 </span></p>
 <p>Aus dem Kegelproblem wird ein MILP mit <span class="math inline">S</span> Binärvariablen. Für <span class="math inline">M</span> gilt, was <a href="#kap-milp">Kapitel 6</a> über die Big-M-Falle sagt: <strong>so klein wie möglich</strong>. Hier ist <span class="math inline">M = b</span> die kleinste gültige Schranke, denn <span class="math inline">\mathbf{a}_s^\top\mathbf{x} \ge 0</span> — größer kann eine Verletzung gar nicht ausfallen.</p>
 <h3 id="der-fall-ein-kraftwerkspark-mit-500-mw-zusage">Der Fall: ein Kraftwerkspark mit 500 MW Zusage</h3>
-<div class="sourceCode" id="cb133"><pre class="sourceCode python"><code class="sourceCode python"><span id="cb133-1"><a href="#cb133-1" aria-hidden="true" tabindex="-1"></a><span class="co">#!/usr/bin/env python3</span></span>
-<span id="cb133-2"><a href="#cb133-2" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb133-3"><a href="#cb133-3" aria-hidden="true" tabindex="-1"></a><span class="co"># Chance_Constraints.py</span></span>
-<span id="cb133-4"><a href="#cb133-4" aria-hidden="true" tabindex="-1"></a><span class="co">&quot;&quot;&quot;</span></span>
-<span id="cb133-5"><a href="#cb133-5" aria-hidden="true" tabindex="-1"></a><span class="co">Kapitel Unsicherheit: Wahrscheinlichkeitsbeschraenkungen.</span></span>
-<span id="cb133-6"><a href="#cb133-6" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb133-7"><a href="#cb133-7" aria-hidden="true" tabindex="-1"></a><span class="co">Das Management fragt selten &quot;was ist im Mittel am besten?&quot;, sondern &quot;mit</span></span>
-<span id="cb133-8"><a href="#cb133-8" aria-hidden="true" tabindex="-1"></a><span class="co">welcher Sicherheit haelt der Plan?&quot;. Genau das formuliert eine Chance</span></span>
-<span id="cb133-9"><a href="#cb133-9" aria-hidden="true" tabindex="-1"></a><span class="co">Constraint:  P(Versorgung &gt;= Bedarf) &gt;= 1 - alpha.</span></span>
-<span id="cb133-10"><a href="#cb133-10" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb133-11"><a href="#cb133-11" aria-hidden="true" tabindex="-1"></a><span class="co">Gezeigt werden beide Wege dorthin, an derselben Instanz:</span></span>
-<span id="cb133-12"><a href="#cb133-12" aria-hidden="true" tabindex="-1"></a><span class="co">  (a) analytisch      - unter Normalverteilungsannahme wird daraus eine</span></span>
-<span id="cb133-13"><a href="#cb133-13" aria-hidden="true" tabindex="-1"></a><span class="co">                        Second-Order-Cone-Bedingung, loesbar mit CVXPY</span></span>
-<span id="cb133-14"><a href="#cb133-14" aria-hidden="true" tabindex="-1"></a><span class="co">  (b) szenariobasiert - Big-M mit Binaervariablen, fuer beliebige</span></span>
-<span id="cb133-15"><a href="#cb133-15" aria-hidden="true" tabindex="-1"></a><span class="co">                        empirische Verteilungen</span></span>
-<span id="cb133-16"><a href="#cb133-16" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb133-17"><a href="#cb133-17" aria-hidden="true" tabindex="-1"></a><span class="co">Und die beiden Messungen, auf die es ankommt: Was kostet ein Prozentpunkt</span></span>
-<span id="cb133-18"><a href="#cb133-18" aria-hidden="true" tabindex="-1"></a><span class="co">Versorgungssicherheit - und haelt die Zusage auch dann, wenn die Verteilung</span></span>
-<span id="cb133-19"><a href="#cb133-19" aria-hidden="true" tabindex="-1"></a><span class="co">nicht normal ist?</span></span>
-<span id="cb133-20"><a href="#cb133-20" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb133-21"><a href="#cb133-21" aria-hidden="true" tabindex="-1"></a><span class="co">Solver: CLARABEL (Kegel) und SciPy/HiGHS (gemischt-ganzzahlig). Weder ortools</span></span>
-<span id="cb133-22"><a href="#cb133-22" aria-hidden="true" tabindex="-1"></a><span class="co">noch ein direkter highspy-Import, damit alles in einem Prozess laeuft.</span></span>
-<span id="cb133-23"><a href="#cb133-23" aria-hidden="true" tabindex="-1"></a><span class="co">&quot;&quot;&quot;</span></span>
-<span id="cb133-24"><a href="#cb133-24" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb133-25"><a href="#cb133-25" aria-hidden="true" tabindex="-1"></a><span class="im">import</span> cvxpy <span class="im">as</span> cp</span>
-<span id="cb133-26"><a href="#cb133-26" aria-hidden="true" tabindex="-1"></a><span class="im">import</span> numpy <span class="im">as</span> np</span>
-<span id="cb133-27"><a href="#cb133-27" aria-hidden="true" tabindex="-1"></a><span class="im">from</span> scipy.stats <span class="im">import</span> norm</span>
-<span id="cb133-28"><a href="#cb133-28" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb133-29"><a href="#cb133-29" aria-hidden="true" tabindex="-1"></a><span class="co"># --- Der Kraftwerkspark ----------------------------------------------------</span></span>
-<span id="cb133-30"><a href="#cb133-30" aria-hidden="true" tabindex="-1"></a><span class="co"># Die Verfuegbarkeit ist der Anteil, den eine installierte MW im Mittel</span></span>
-<span id="cb133-31"><a href="#cb133-31" aria-hidden="true" tabindex="-1"></a><span class="co"># wirklich liefert: bei Wind und Sonne klein und stark schwankend, bei Gas und</span></span>
-<span id="cb133-32"><a href="#cb133-32" aria-hidden="true" tabindex="-1"></a><span class="co"># Biomasse gross und stabil. Die Ausbaugrenze ist der Standort - Flaeche,</span></span>
-<span id="cb133-33"><a href="#cb133-33" aria-hidden="true" tabindex="-1"></a><span class="co"># Genehmigung, Brennstoffversorgung.</span></span>
-<span id="cb133-34"><a href="#cb133-34" aria-hidden="true" tabindex="-1"></a>TECHNIK <span class="op">=</span> [<span class="st">&quot;Gaskraftwerk&quot;</span>, <span class="st">&quot;Windpark&quot;</span>, <span class="st">&quot;Solarpark&quot;</span>, <span class="st">&quot;Biomasse&quot;</span>]</span>
-<span id="cb133-35"><a href="#cb133-35" aria-hidden="true" tabindex="-1"></a>KOSTEN <span class="op">=</span> np.array([<span class="fl">65_000.0</span>, <span class="fl">24_000.0</span>, <span class="fl">12_000.0</span>, <span class="fl">60_000.0</span>])   <span class="co"># EUR je MW und Jahr</span></span>
-<span id="cb133-36"><a href="#cb133-36" aria-hidden="true" tabindex="-1"></a>VERFUEGBAR <span class="op">=</span> np.array([<span class="fl">0.92</span>, <span class="fl">0.35</span>, <span class="fl">0.18</span>, <span class="fl">0.85</span>])</span>
-<span id="cb133-37"><a href="#cb133-37" aria-hidden="true" tabindex="-1"></a>STREUUNG <span class="op">=</span> np.array([<span class="fl">0.05</span>, <span class="fl">0.16</span>, <span class="fl">0.10</span>, <span class="fl">0.04</span>])</span>
-<span id="cb133-38"><a href="#cb133-38" aria-hidden="true" tabindex="-1"></a>GRENZE <span class="op">=</span> np.array([<span class="fl">400.0</span>, <span class="fl">250.0</span>, <span class="fl">600.0</span>, <span class="fl">350.0</span>])               <span class="co"># MW</span></span>
-<span id="cb133-39"><a href="#cb133-39" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb133-40"><a href="#cb133-40" aria-hidden="true" tabindex="-1"></a><span class="co"># Wind und Sonne sind leicht gegenlaeufig: Ein Tiefdruckgebiet bringt Wind und</span></span>
-<span id="cb133-41"><a href="#cb133-41" aria-hidden="true" tabindex="-1"></a><span class="co"># Wolken zugleich. Genau diese Korrelation macht die Bedingung zu einem Kegel</span></span>
-<span id="cb133-42"><a href="#cb133-42" aria-hidden="true" tabindex="-1"></a><span class="co"># und nicht zu einer Summe unabhaengiger Einzelzuschlaege.</span></span>
-<span id="cb133-43"><a href="#cb133-43" aria-hidden="true" tabindex="-1"></a>KORRELATION <span class="op">=</span> np.array([</span>
-<span id="cb133-44"><a href="#cb133-44" aria-hidden="true" tabindex="-1"></a>    [<span class="fl">1.00</span>,  <span class="fl">0.00</span>,  <span class="fl">0.00</span>, <span class="fl">0.05</span>],</span>
-<span id="cb133-45"><a href="#cb133-45" aria-hidden="true" tabindex="-1"></a>    [<span class="fl">0.00</span>,  <span class="fl">1.00</span>, <span class="op">-</span><span class="fl">0.25</span>, <span class="fl">0.00</span>],</span>
-<span id="cb133-46"><a href="#cb133-46" aria-hidden="true" tabindex="-1"></a>    [<span class="fl">0.00</span>, <span class="op">-</span><span class="fl">0.25</span>,  <span class="fl">1.00</span>, <span class="fl">0.00</span>],</span>
-<span id="cb133-47"><a href="#cb133-47" aria-hidden="true" tabindex="-1"></a>    [<span class="fl">0.05</span>,  <span class="fl">0.00</span>,  <span class="fl">0.00</span>, <span class="fl">1.00</span>],</span>
-<span id="cb133-48"><a href="#cb133-48" aria-hidden="true" tabindex="-1"></a>])</span>
-<span id="cb133-49"><a href="#cb133-49" aria-hidden="true" tabindex="-1"></a>SIGMA <span class="op">=</span> np.diag(STREUUNG) <span class="op">@</span> KORRELATION <span class="op">@</span> np.diag(STREUUNG)</span>
-<span id="cb133-50"><a href="#cb133-50" aria-hidden="true" tabindex="-1"></a>WURZEL <span class="op">=</span> np.linalg.cholesky(SIGMA)          <span class="co"># L mit L @ L.T == SIGMA</span></span>
-<span id="cb133-51"><a href="#cb133-51" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb133-52"><a href="#cb133-52" aria-hidden="true" tabindex="-1"></a>BEDARF <span class="op">=</span> <span class="fl">500.0</span>          <span class="co"># MW, die gesichert bereitstehen muessen</span></span>
-<span id="cb133-53"><a href="#cb133-53" aria-hidden="true" tabindex="-1"></a>N <span class="op">=</span> <span class="bu">len</span>(TECHNIK)</span>
-<span id="cb133-54"><a href="#cb133-54" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb133-55"><a href="#cb133-55" aria-hidden="true" tabindex="-1"></a><span class="co"># Die Kaeltewelle mit Dunkelflaute: selten, aber sie trifft alles zugleich.</span></span>
-<span id="cb133-56"><a href="#cb133-56" aria-hidden="true" tabindex="-1"></a><span class="co"># Wind und Sonne brechen fast vollstaendig weg - und, das ist der Punkt, das</span></span>
-<span id="cb133-57"><a href="#cb133-57" aria-hidden="true" tabindex="-1"></a><span class="co"># Gaskraftwerk liefert ebenfalls weniger, weil bei Frost der Netzdruck faellt.</span></span>
-<span id="cb133-58"><a href="#cb133-58" aria-hidden="true" tabindex="-1"></a><span class="co"># Eine Kovarianzmatrix mit Korrelationen um null kann das nicht ausdruecken.</span></span>
-<span id="cb133-59"><a href="#cb133-59" aria-hidden="true" tabindex="-1"></a>P_KAELTEWELLE <span class="op">=</span> <span class="fl">0.08</span></span>
-<span id="cb133-60"><a href="#cb133-60" aria-hidden="true" tabindex="-1"></a>EINBRUCH <span class="op">=</span> np.array([<span class="fl">0.72</span>, <span class="fl">0.10</span>, <span class="fl">0.15</span>, <span class="fl">0.88</span>])</span>
-<span id="cb133-61"><a href="#cb133-61" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb133-62"><a href="#cb133-62" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb133-63"><a href="#cb133-63" aria-hidden="true" tabindex="-1"></a><span class="kw">def</span> mittelwertplan():</span>
-<span id="cb133-64"><a href="#cb133-64" aria-hidden="true" tabindex="-1"></a>    <span class="co">&quot;&quot;&quot;Plant mit den Erwartungswerten - ignoriert die Streuung vollstaendig.&quot;&quot;&quot;</span></span>
-<span id="cb133-65"><a href="#cb133-65" aria-hidden="true" tabindex="-1"></a>    x <span class="op">=</span> cp.Variable(N, nonneg<span class="op">=</span><span class="va">True</span>)</span>
-<span id="cb133-66"><a href="#cb133-66" aria-hidden="true" tabindex="-1"></a>    problem <span class="op">=</span> cp.Problem(cp.Minimize(KOSTEN <span class="op">@</span> x),</span>
-<span id="cb133-67"><a href="#cb133-67" aria-hidden="true" tabindex="-1"></a>                         [VERFUEGBAR <span class="op">@</span> x <span class="op">&gt;=</span> BEDARF, x <span class="op">&lt;=</span> GRENZE])</span>
-<span id="cb133-68"><a href="#cb133-68" aria-hidden="true" tabindex="-1"></a>    problem.solve(solver<span class="op">=</span>cp.CLARABEL)</span>
-<span id="cb133-69"><a href="#cb133-69" aria-hidden="true" tabindex="-1"></a>    <span class="cf">return</span> problem.value, x.value</span>
-<span id="cb133-70"><a href="#cb133-70" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb133-71"><a href="#cb133-71" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb133-72"><a href="#cb133-72" aria-hidden="true" tabindex="-1"></a><span class="kw">def</span> chance_constraint_analytisch(alpha):</span>
-<span id="cb133-73"><a href="#cb133-73" aria-hidden="true" tabindex="-1"></a>    <span class="co">&quot;&quot;&quot;</span></span>
-<span id="cb133-74"><a href="#cb133-74" aria-hidden="true" tabindex="-1"></a><span class="co">    P(a^T x &gt;= BEDARF) &gt;= 1 - alpha  unter a ~ N(VERFUEGBAR, SIGMA).</span></span>
-<span id="cb133-75"><a href="#cb133-75" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb133-76"><a href="#cb133-76" aria-hidden="true" tabindex="-1"></a><span class="co">    Aequivalent zu:  VERFUEGBAR^T x - z * ||L^T x||_2 &gt;= BEDARF</span></span>
-<span id="cb133-77"><a href="#cb133-77" aria-hidden="true" tabindex="-1"></a><span class="co">    mit z = Phi^-1(1 - alpha). Das ist eine Second-Order-Cone-Bedingung: Der</span></span>
-<span id="cb133-78"><a href="#cb133-78" aria-hidden="true" tabindex="-1"></a><span class="co">    Sicherheitszuschlag ist eine Norm ueber x, kein fester Aufschlag je Anlage.</span></span>
-<span id="cb133-79"><a href="#cb133-79" aria-hidden="true" tabindex="-1"></a><span class="co">    Deshalb belohnt sie Mischung - zwei gegenlaeufige Quellen schwanken</span></span>
-<span id="cb133-80"><a href="#cb133-80" aria-hidden="true" tabindex="-1"></a><span class="co">    gemeinsam weniger als jede fuer sich.</span></span>
-<span id="cb133-81"><a href="#cb133-81" aria-hidden="true" tabindex="-1"></a><span class="co">    &quot;&quot;&quot;</span></span>
-<span id="cb133-82"><a href="#cb133-82" aria-hidden="true" tabindex="-1"></a>    x <span class="op">=</span> cp.Variable(N, nonneg<span class="op">=</span><span class="va">True</span>)</span>
-<span id="cb133-83"><a href="#cb133-83" aria-hidden="true" tabindex="-1"></a>    z <span class="op">=</span> norm.ppf(<span class="dv">1</span> <span class="op">-</span> alpha)</span>
-<span id="cb133-84"><a href="#cb133-84" aria-hidden="true" tabindex="-1"></a>    bedingung <span class="op">=</span> VERFUEGBAR <span class="op">@</span> x <span class="op">-</span> z <span class="op">*</span> cp.norm(WURZEL.T <span class="op">@</span> x, <span class="dv">2</span>) <span class="op">&gt;=</span> BEDARF</span>
-<span id="cb133-85"><a href="#cb133-85" aria-hidden="true" tabindex="-1"></a>    problem <span class="op">=</span> cp.Problem(cp.Minimize(KOSTEN <span class="op">@</span> x), [bedingung, x <span class="op">&lt;=</span> GRENZE])</span>
-<span id="cb133-86"><a href="#cb133-86" aria-hidden="true" tabindex="-1"></a>    problem.solve(solver<span class="op">=</span>cp.CLARABEL)</span>
-<span id="cb133-87"><a href="#cb133-87" aria-hidden="true" tabindex="-1"></a>    <span class="cf">return</span> problem.value, x.value</span>
-<span id="cb133-88"><a href="#cb133-88" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb133-89"><a href="#cb133-89" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb133-90"><a href="#cb133-90" aria-hidden="true" tabindex="-1"></a><span class="kw">def</span> chance_constraint_szenarien(a, alpha):</span>
-<span id="cb133-91"><a href="#cb133-91" aria-hidden="true" tabindex="-1"></a>    <span class="co">&quot;&quot;&quot;</span></span>
-<span id="cb133-92"><a href="#cb133-92" aria-hidden="true" tabindex="-1"></a><span class="co">    Dieselbe Zusage ohne Verteilungsannahme: Fuer jedes Szenario s sagt eine</span></span>
-<span id="cb133-93"><a href="#cb133-93" aria-hidden="true" tabindex="-1"></a><span class="co">    Binaervariable z_s, ob es verletzt werden darf.</span></span>
-<span id="cb133-94"><a href="#cb133-94" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb133-95"><a href="#cb133-95" aria-hidden="true" tabindex="-1"></a><span class="co">        a_s^T x &gt;= BEDARF - M * z_s        fuer alle s</span></span>
-<span id="cb133-96"><a href="#cb133-96" aria-hidden="true" tabindex="-1"></a><span class="co">        sum_s z_s &lt;= alpha * S</span></span>
-<span id="cb133-97"><a href="#cb133-97" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb133-98"><a href="#cb133-98" aria-hidden="true" tabindex="-1"></a><span class="co">    M = BEDARF ist die kleinstmoegliche gueltige Schranke, denn a_s^T x &gt;= 0:</span></span>
-<span id="cb133-99"><a href="#cb133-99" aria-hidden="true" tabindex="-1"></a><span class="co">    Groesser kann eine Verletzung gar nicht ausfallen. Ein unnoetig grosses M</span></span>
-<span id="cb133-100"><a href="#cb133-100" aria-hidden="true" tabindex="-1"></a><span class="co">    wuerde die LP-Relaxierung aufweichen und die Suche verlangsamen - die</span></span>
-<span id="cb133-101"><a href="#cb133-101" aria-hidden="true" tabindex="-1"></a><span class="co">    Big-M-Falle aus dem Kapitel Gemischt-ganzzahlige Optimierung.</span></span>
-<span id="cb133-102"><a href="#cb133-102" aria-hidden="true" tabindex="-1"></a><span class="co">    &quot;&quot;&quot;</span></span>
-<span id="cb133-103"><a href="#cb133-103" aria-hidden="true" tabindex="-1"></a>    S <span class="op">=</span> <span class="bu">len</span>(a)</span>
-<span id="cb133-104"><a href="#cb133-104" aria-hidden="true" tabindex="-1"></a>    x <span class="op">=</span> cp.Variable(N, nonneg<span class="op">=</span><span class="va">True</span>)</span>
-<span id="cb133-105"><a href="#cb133-105" aria-hidden="true" tabindex="-1"></a>    z <span class="op">=</span> cp.Variable(S, boolean<span class="op">=</span><span class="va">True</span>)</span>
-<span id="cb133-106"><a href="#cb133-106" aria-hidden="true" tabindex="-1"></a>    problem <span class="op">=</span> cp.Problem(</span>
-<span id="cb133-107"><a href="#cb133-107" aria-hidden="true" tabindex="-1"></a>        cp.Minimize(KOSTEN <span class="op">@</span> x),</span>
-<span id="cb133-108"><a href="#cb133-108" aria-hidden="true" tabindex="-1"></a>        [a <span class="op">@</span> x <span class="op">&gt;=</span> BEDARF <span class="op">-</span> BEDARF <span class="op">*</span> z, cp.<span class="bu">sum</span>(z) <span class="op">&lt;=</span> alpha <span class="op">*</span> S, x <span class="op">&lt;=</span> GRENZE])</span>
-<span id="cb133-109"><a href="#cb133-109" aria-hidden="true" tabindex="-1"></a>    problem.solve(solver<span class="op">=</span>cp.SCIPY)</span>
-<span id="cb133-110"><a href="#cb133-110" aria-hidden="true" tabindex="-1"></a>    <span class="cf">return</span> problem.value, x.value</span>
-<span id="cb133-111"><a href="#cb133-111" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb133-112"><a href="#cb133-112" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb133-113"><a href="#cb133-113" aria-hidden="true" tabindex="-1"></a><span class="kw">def</span> ziehe_wetter(anzahl, seed):</span>
-<span id="cb133-114"><a href="#cb133-114" aria-hidden="true" tabindex="-1"></a>    <span class="co">&quot;&quot;&quot;Mischverteilung: normales Wetter, mit P_KAELTEWELLE ein Einbruch.&quot;&quot;&quot;</span></span>
-<span id="cb133-115"><a href="#cb133-115" aria-hidden="true" tabindex="-1"></a>    rng <span class="op">=</span> np.random.default_rng(seed)</span>
-<span id="cb133-116"><a href="#cb133-116" aria-hidden="true" tabindex="-1"></a>    a <span class="op">=</span> rng.multivariate_normal(VERFUEGBAR, SIGMA, size<span class="op">=</span>anzahl)</span>
-<span id="cb133-117"><a href="#cb133-117" aria-hidden="true" tabindex="-1"></a>    getroffen <span class="op">=</span> rng.random(anzahl) <span class="op">&lt;</span> P_KAELTEWELLE</span>
-<span id="cb133-118"><a href="#cb133-118" aria-hidden="true" tabindex="-1"></a>    a[getroffen] <span class="op">*=</span> EINBRUCH</span>
-<span id="cb133-119"><a href="#cb133-119" aria-hidden="true" tabindex="-1"></a>    <span class="cf">return</span> np.clip(a, <span class="fl">0.0</span>, <span class="fl">1.0</span>)</span>
-<span id="cb133-120"><a href="#cb133-120" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb133-121"><a href="#cb133-121" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb133-122"><a href="#cb133-122" aria-hidden="true" tabindex="-1"></a><span class="kw">def</span> sicherheit(x, a):</span>
-<span id="cb133-123"><a href="#cb133-123" aria-hidden="true" tabindex="-1"></a>    <span class="co">&quot;&quot;&quot;Anteil der Szenarien, in denen der Plan den Bedarf deckt.&quot;&quot;&quot;</span></span>
-<span id="cb133-124"><a href="#cb133-124" aria-hidden="true" tabindex="-1"></a>    <span class="cf">return</span> <span class="bu">float</span>(np.mean(a <span class="op">@</span> x <span class="op">&gt;=</span> BEDARF))</span>
-<span id="cb133-125"><a href="#cb133-125" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb133-126"><a href="#cb133-126" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb133-127"><a href="#cb133-127" aria-hidden="true" tabindex="-1"></a>KOPF <span class="op">=</span> (<span class="ss">f&quot;</span><span class="sc">{</span><span class="st">&#39;Plan&#39;</span><span class="sc">:&lt;20}</span><span class="ss"> </span><span class="sc">{</span><span class="st">&#39;Kosten (EUR)&#39;</span><span class="sc">:&gt;13}</span><span class="ss">  </span><span class="sc">{</span><span class="st">&#39;Gas&#39;</span><span class="sc">:&gt;4}</span><span class="ss"> </span><span class="sc">{</span><span class="st">&#39;Wind&#39;</span><span class="sc">:&gt;4}</span><span class="ss"> &quot;</span></span>
-<span id="cb133-128"><a href="#cb133-128" aria-hidden="true" tabindex="-1"></a>        <span class="ss">f&quot;</span><span class="sc">{</span><span class="st">&#39;Sol&#39;</span><span class="sc">:&gt;4}</span><span class="ss"> </span><span class="sc">{</span><span class="st">&#39;Bio&#39;</span><span class="sc">:&gt;4}</span><span class="ss">  </span><span class="sc">{</span><span class="st">&#39;Normalwelt&#39;</span><span class="sc">:&gt;11}</span><span class="ss"> </span><span class="sc">{</span><span class="st">&#39;echte Welt&#39;</span><span class="sc">:&gt;11}</span><span class="ss">&quot;</span>)</span>
-<span id="cb133-129"><a href="#cb133-129" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb133-130"><a href="#cb133-130" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb133-131"><a href="#cb133-131" aria-hidden="true" tabindex="-1"></a><span class="kw">def</span> zeile(name, kosten, x, in_normal, in_echt):</span>
-<span id="cb133-132"><a href="#cb133-132" aria-hidden="true" tabindex="-1"></a>    mix <span class="op">=</span> <span class="st">&quot; &quot;</span>.join(<span class="ss">f&quot;</span><span class="sc">{</span>w<span class="sc">:4.0f}</span><span class="ss">&quot;</span> <span class="cf">for</span> w <span class="kw">in</span> x)</span>
-<span id="cb133-133"><a href="#cb133-133" aria-hidden="true" tabindex="-1"></a>    <span class="cf">return</span> (<span class="ss">f&quot;</span><span class="sc">{</span>name<span class="sc">:&lt;20}</span><span class="ss"> </span><span class="sc">{</span>kosten<span class="sc">:&gt;13,.0f}</span><span class="ss">  </span><span class="sc">{</span>mix<span class="sc">}</span><span class="ss">  &quot;</span></span>
-<span id="cb133-134"><a href="#cb133-134" aria-hidden="true" tabindex="-1"></a>            <span class="ss">f&quot;</span><span class="sc">{</span>in_normal <span class="op">*</span> <span class="dv">100</span><span class="sc">:&gt;9.2f}</span><span class="ss"> % </span><span class="sc">{</span>in_echt <span class="op">*</span> <span class="dv">100</span><span class="sc">:&gt;9.2f}</span><span class="ss"> %&quot;</span>)</span>
-<span id="cb133-135"><a href="#cb133-135" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb133-136"><a href="#cb133-136" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb133-137"><a href="#cb133-137" aria-hidden="true" tabindex="-1"></a><span class="cf">if</span> <span class="va">__name__</span> <span class="op">==</span> <span class="st">&quot;__main__&quot;</span>:</span>
-<span id="cb133-138"><a href="#cb133-138" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;=&quot;</span> <span class="op">*</span> <span class="dv">78</span>)</span>
-<span id="cb133-139"><a href="#cb133-139" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;  WAHRSCHEINLICHKEITSBESCHRAENKUNGEN IM KRAFTWERKSPARK&quot;</span>)</span>
-<span id="cb133-140"><a href="#cb133-140" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;=&quot;</span> <span class="op">*</span> <span class="dv">78</span>)</span>
-<span id="cb133-141"><a href="#cb133-141" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;Gesichert bereitzustellen: </span><span class="sc">{</span>BEDARF<span class="sc">:.0f}</span><span class="ss"> MW</span><span class="ch">\n</span><span class="ss">&quot;</span>)</span>
-<span id="cb133-142"><a href="#cb133-142" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;</span><span class="sc">{</span><span class="st">&#39;Technologie&#39;</span><span class="sc">:&lt;14}</span><span class="ss"> </span><span class="sc">{</span><span class="st">&#39;EUR/MW&#39;</span><span class="sc">:&gt;8}</span><span class="ss"> </span><span class="sc">{</span><span class="st">&#39;verfuegbar&#39;</span><span class="sc">:&gt;11}</span><span class="ss"> </span><span class="sc">{</span><span class="st">&#39;Streuung&#39;</span><span class="sc">:&gt;9}</span><span class="ss"> &quot;</span></span>
-<span id="cb133-143"><a href="#cb133-143" aria-hidden="true" tabindex="-1"></a>          <span class="ss">f&quot;</span><span class="sc">{</span><span class="st">&#39;Grenze&#39;</span><span class="sc">:&gt;8}</span><span class="ss"> </span><span class="sc">{</span><span class="st">&#39;EUR je erw. MW&#39;</span><span class="sc">:&gt;15}</span><span class="ss">&quot;</span>)</span>
-<span id="cb133-144"><a href="#cb133-144" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;-&quot;</span> <span class="op">*</span> <span class="dv">78</span>)</span>
-<span id="cb133-145"><a href="#cb133-145" aria-hidden="true" tabindex="-1"></a>    <span class="cf">for</span> i, name <span class="kw">in</span> <span class="bu">enumerate</span>(TECHNIK):</span>
-<span id="cb133-146"><a href="#cb133-146" aria-hidden="true" tabindex="-1"></a>        <span class="bu">print</span>(<span class="ss">f&quot;</span><span class="sc">{</span>name<span class="sc">:&lt;14}</span><span class="ss"> </span><span class="sc">{</span>KOSTEN[i]<span class="sc">:&gt;8,.0f}</span><span class="ss"> </span><span class="sc">{</span>VERFUEGBAR[i]<span class="sc">:&gt;10.2f}</span><span class="ss">  &quot;</span></span>
-<span id="cb133-147"><a href="#cb133-147" aria-hidden="true" tabindex="-1"></a>              <span class="ss">f&quot;</span><span class="sc">{</span>STREUUNG[i]<span class="sc">:&gt;8.2f}</span><span class="ss"> </span><span class="sc">{</span>GRENZE[i]<span class="sc">:&gt;7.0f}</span><span class="ss"> &quot;</span></span>
-<span id="cb133-148"><a href="#cb133-148" aria-hidden="true" tabindex="-1"></a>              <span class="ss">f&quot;</span><span class="sc">{</span>KOSTEN[i] <span class="op">/</span> VERFUEGBAR[i]<span class="sc">:&gt;15,.0f}</span><span class="ss">&quot;</span>)</span>
-<span id="cb133-149"><a href="#cb133-149" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;</span><span class="ch">\n</span><span class="ss">Vollausbau liefert im Mittel </span><span class="sc">{</span>VERFUEGBAR <span class="op">@</span> GRENZE<span class="sc">:.0f}</span><span class="ss"> MW, &quot;</span></span>
-<span id="cb133-150"><a href="#cb133-150" aria-hidden="true" tabindex="-1"></a>          <span class="ss">f&quot;in der Kaeltewelle </span><span class="sc">{</span>(VERFUEGBAR <span class="op">*</span> EINBRUCH) <span class="op">@</span> GRENZE<span class="sc">:.0f}</span><span class="ss"> MW.&quot;</span>)</span>
-<span id="cb133-151"><a href="#cb133-151" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb133-152"><a href="#cb133-152" aria-hidden="true" tabindex="-1"></a>    <span class="co"># Zwei grosse, unabhaengige Testmengen. An ihnen wird JEDER Plan gemessen -</span></span>
-<span id="cb133-153"><a href="#cb133-153" aria-hidden="true" tabindex="-1"></a>    <span class="co"># einmal in der unterstellten Normalwelt, einmal in der echten Verteilung.</span></span>
-<span id="cb133-154"><a href="#cb133-154" aria-hidden="true" tabindex="-1"></a>    echt <span class="op">=</span> ziehe_wetter(<span class="dv">200_000</span>, seed<span class="op">=</span><span class="dv">771</span>)</span>
-<span id="cb133-155"><a href="#cb133-155" aria-hidden="true" tabindex="-1"></a>    normalwelt <span class="op">=</span> np.random.default_rng(<span class="dv">4711</span>).multivariate_normal(</span>
-<span id="cb133-156"><a href="#cb133-156" aria-hidden="true" tabindex="-1"></a>        VERFUEGBAR, SIGMA, size<span class="op">=</span><span class="dv">200_000</span>)</span>
-<span id="cb133-157"><a href="#cb133-157" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb133-158"><a href="#cb133-158" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;</span><span class="ch">\n</span><span class="st">&quot;</span> <span class="op">+</span> <span class="st">&quot;=&quot;</span> <span class="op">*</span> <span class="dv">78</span>)</span>
-<span id="cb133-159"><a href="#cb133-159" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;  (1) Mittelwertplan und Chance Constraints im Vergleich&quot;</span>)</span>
-<span id="cb133-160"><a href="#cb133-160" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;=&quot;</span> <span class="op">*</span> <span class="dv">78</span>)</span>
-<span id="cb133-161"><a href="#cb133-161" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(KOPF)</span>
-<span id="cb133-162"><a href="#cb133-162" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;-&quot;</span> <span class="op">*</span> <span class="dv">78</span>)</span>
-<span id="cb133-163"><a href="#cb133-163" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb133-164"><a href="#cb133-164" aria-hidden="true" tabindex="-1"></a>    k_mittel, x_mittel <span class="op">=</span> mittelwertplan()</span>
-<span id="cb133-165"><a href="#cb133-165" aria-hidden="true" tabindex="-1"></a>    stufen <span class="op">=</span> [(<span class="st">&quot;Mittelwert&quot;</span>, k_mittel, sicherheit(x_mittel, normalwelt))]</span>
-<span id="cb133-166"><a href="#cb133-166" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(zeile(<span class="st">&quot;Mittelwert&quot;</span>, k_mittel, x_mittel,</span>
-<span id="cb133-167"><a href="#cb133-167" aria-hidden="true" tabindex="-1"></a>                sicherheit(x_mittel, normalwelt), sicherheit(x_mittel, echt)))</span>
-<span id="cb133-168"><a href="#cb133-168" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb133-169"><a href="#cb133-169" aria-hidden="true" tabindex="-1"></a>    plaene <span class="op">=</span> {}</span>
-<span id="cb133-170"><a href="#cb133-170" aria-hidden="true" tabindex="-1"></a>    <span class="cf">for</span> alpha <span class="kw">in</span> (<span class="fl">0.20</span>, <span class="fl">0.10</span>, <span class="fl">0.05</span>, <span class="fl">0.01</span>):</span>
-<span id="cb133-171"><a href="#cb133-171" aria-hidden="true" tabindex="-1"></a>        kosten, x <span class="op">=</span> chance_constraint_analytisch(alpha)</span>
-<span id="cb133-172"><a href="#cb133-172" aria-hidden="true" tabindex="-1"></a>        plaene[alpha] <span class="op">=</span> (kosten, x)</span>
-<span id="cb133-173"><a href="#cb133-173" aria-hidden="true" tabindex="-1"></a>        quote_normal <span class="op">=</span> sicherheit(x, normalwelt)</span>
-<span id="cb133-174"><a href="#cb133-174" aria-hidden="true" tabindex="-1"></a>        stufen.append((<span class="ss">f&quot;Zusage </span><span class="sc">{</span>(<span class="dv">1</span> <span class="op">-</span> alpha) <span class="op">*</span> <span class="dv">100</span><span class="sc">:.0f}</span><span class="ss"> %&quot;</span>, kosten, quote_normal))</span>
-<span id="cb133-175"><a href="#cb133-175" aria-hidden="true" tabindex="-1"></a>        <span class="bu">print</span>(zeile(<span class="ss">f&quot;Zusage </span><span class="sc">{</span>(<span class="dv">1</span> <span class="op">-</span> alpha) <span class="op">*</span> <span class="dv">100</span><span class="sc">:.0f}</span><span class="ss"> %&quot;</span>, kosten, x,</span>
-<span id="cb133-176"><a href="#cb133-176" aria-hidden="true" tabindex="-1"></a>                    quote_normal, sicherheit(x, echt)))</span>
-<span id="cb133-177"><a href="#cb133-177" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb133-178"><a href="#cb133-178" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;</span><span class="ch">\n</span><span class="st">  In der Normalwelt trifft jede Zusage ihren Wert - das Verfahren&quot;</span>)</span>
-<span id="cb133-179"><a href="#cb133-179" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;  rechnet richtig. Die Spalte &#39;echte Welt&#39; kommt in Teil (3).&quot;</span>)</span>
-<span id="cb133-180"><a href="#cb133-180" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb133-181"><a href="#cb133-181" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;</span><span class="ch">\n</span><span class="st">&quot;</span> <span class="op">+</span> <span class="st">&quot;=&quot;</span> <span class="op">*</span> <span class="dv">78</span>)</span>
-<span id="cb133-182"><a href="#cb133-182" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;  (2) Was kostet ein Prozentpunkt Versorgungssicherheit?&quot;</span>)</span>
-<span id="cb133-183"><a href="#cb133-183" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;=&quot;</span> <span class="op">*</span> <span class="dv">78</span>)</span>
-<span id="cb133-184"><a href="#cb133-184" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;</span><span class="sc">{</span><span class="st">&#39;von -&gt; nach&#39;</span><span class="sc">:&lt;26}</span><span class="ss"> </span><span class="sc">{</span><span class="st">&#39;Prozentpunkte&#39;</span><span class="sc">:&gt;13}</span><span class="ss"> </span><span class="sc">{</span><span class="st">&#39;Mehrkosten&#39;</span><span class="sc">:&gt;13}</span><span class="ss"> &quot;</span></span>
-<span id="cb133-185"><a href="#cb133-185" aria-hidden="true" tabindex="-1"></a>          <span class="ss">f&quot;</span><span class="sc">{</span><span class="st">&#39;EUR je Punkt&#39;</span><span class="sc">:&gt;13}</span><span class="ss">&quot;</span>)</span>
-<span id="cb133-186"><a href="#cb133-186" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;-&quot;</span> <span class="op">*</span> <span class="dv">78</span>)</span>
-<span id="cb133-187"><a href="#cb133-187" aria-hidden="true" tabindex="-1"></a>    <span class="cf">for</span> (n1, k1, q1), (n2, k2, q2) <span class="kw">in</span> <span class="bu">zip</span>(stufen, stufen[<span class="dv">1</span>:]):</span>
-<span id="cb133-188"><a href="#cb133-188" aria-hidden="true" tabindex="-1"></a>        d_punkte <span class="op">=</span> (q2 <span class="op">-</span> q1) <span class="op">*</span> <span class="dv">100</span></span>
-<span id="cb133-189"><a href="#cb133-189" aria-hidden="true" tabindex="-1"></a>        d_kosten <span class="op">=</span> k2 <span class="op">-</span> k1</span>
-<span id="cb133-190"><a href="#cb133-190" aria-hidden="true" tabindex="-1"></a>        <span class="bu">print</span>(<span class="ss">f&quot;</span><span class="sc">{</span>n1 <span class="op">+</span> <span class="st">&#39; -&gt; &#39;</span> <span class="op">+</span> n2<span class="sc">:&lt;26}</span><span class="ss"> </span><span class="sc">{</span>d_punkte<span class="sc">:&gt;13.2f}</span><span class="ss"> </span><span class="sc">{</span>d_kosten<span class="sc">:&gt;13,.0f}</span><span class="ss"> &quot;</span></span>
-<span id="cb133-191"><a href="#cb133-191" aria-hidden="true" tabindex="-1"></a>              <span class="ss">f&quot;</span><span class="sc">{</span>d_kosten <span class="op">/</span> d_punkte<span class="sc">:&gt;13,.0f}</span><span class="ss">&quot;</span>)</span>
-<span id="cb133-192"><a href="#cb133-192" aria-hidden="true" tabindex="-1"></a>    erst <span class="op">=</span> (stufen[<span class="dv">1</span>][<span class="dv">1</span>] <span class="op">-</span> stufen[<span class="dv">0</span>][<span class="dv">1</span>]) <span class="op">/</span> ((stufen[<span class="dv">1</span>][<span class="dv">2</span>] <span class="op">-</span> stufen[<span class="dv">0</span>][<span class="dv">2</span>]) <span class="op">*</span> <span class="dv">100</span>)</span>
-<span id="cb133-193"><a href="#cb133-193" aria-hidden="true" tabindex="-1"></a>    letzt <span class="op">=</span> (stufen[<span class="op">-</span><span class="dv">1</span>][<span class="dv">1</span>] <span class="op">-</span> stufen[<span class="op">-</span><span class="dv">2</span>][<span class="dv">1</span>]) <span class="op">/</span> ((stufen[<span class="op">-</span><span class="dv">1</span>][<span class="dv">2</span>] <span class="op">-</span> stufen[<span class="op">-</span><span class="dv">2</span>][<span class="dv">2</span>]) <span class="op">*</span> <span class="dv">100</span>)</span>
-<span id="cb133-194"><a href="#cb133-194" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;</span><span class="ch">\n</span><span class="ss">  Der letzte Prozentpunkt kostet das </span><span class="sc">{</span>letzt <span class="op">/</span> erst<span class="sc">:.1f}</span><span class="ss">-fache des ersten.&quot;</span>)</span>
-<span id="cb133-195"><a href="#cb133-195" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;  Sicherheit ist konvex bepreist - genau deshalb muss jemand&quot;</span>)</span>
-<span id="cb133-196"><a href="#cb133-196" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;  entscheiden, wie viel davon das Unternehmen kaufen will.&quot;</span>)</span>
-<span id="cb133-197"><a href="#cb133-197" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb133-198"><a href="#cb133-198" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;</span><span class="ch">\n</span><span class="st">&quot;</span> <span class="op">+</span> <span class="st">&quot;=&quot;</span> <span class="op">*</span> <span class="dv">78</span>)</span>
-<span id="cb133-199"><a href="#cb133-199" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;  (3) Und wenn die Verteilung nicht normal ist?&quot;</span>)</span>
-<span id="cb133-200"><a href="#cb133-200" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;=&quot;</span> <span class="op">*</span> <span class="dv">78</span>)</span>
-<span id="cb133-201"><a href="#cb133-201" aria-hidden="true" tabindex="-1"></a>    k_soc, x_soc <span class="op">=</span> plaene[<span class="fl">0.05</span>]</span>
-<span id="cb133-202"><a href="#cb133-202" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;Die echte Welt kennt die Kaeltewelle mit Dunkelflaute: in &quot;</span></span>
-<span id="cb133-203"><a href="#cb133-203" aria-hidden="true" tabindex="-1"></a>          <span class="ss">f&quot;</span><span class="sc">{</span>P_KAELTEWELLE <span class="op">*</span> <span class="dv">100</span><span class="sc">:.0f}</span><span class="ss"> % der Faelle liefern&quot;</span>)</span>
-<span id="cb133-204"><a href="#cb133-204" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;Wind </span><span class="sc">{</span>EINBRUCH[<span class="dv">1</span>] <span class="op">*</span> <span class="dv">100</span><span class="sc">:.0f}</span><span class="ss"> %, Sonne </span><span class="sc">{</span>EINBRUCH[<span class="dv">2</span>] <span class="op">*</span> <span class="dv">100</span><span class="sc">:.0f}</span><span class="ss"> % &quot;</span></span>
-<span id="cb133-205"><a href="#cb133-205" aria-hidden="true" tabindex="-1"></a>          <span class="ss">f&quot;und - entscheidend - auch das Gaskraftwerk nur &quot;</span></span>
-<span id="cb133-206"><a href="#cb133-206" aria-hidden="true" tabindex="-1"></a>          <span class="ss">f&quot;</span><span class="sc">{</span>EINBRUCH[<span class="dv">0</span>] <span class="op">*</span> <span class="dv">100</span><span class="sc">:.0f}</span><span class="ss"> %&quot;</span>)</span>
-<span id="cb133-207"><a href="#cb133-207" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;des Ueblichen. Alles bricht gleichzeitig ein.</span><span class="ch">\n</span><span class="st">&quot;</span>)</span>
-<span id="cb133-208"><a href="#cb133-208" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb133-209"><a href="#cb133-209" aria-hidden="true" tabindex="-1"></a>    a_bau <span class="op">=</span> ziehe_wetter(<span class="dv">400</span>, seed<span class="op">=</span><span class="dv">20260908</span>)</span>
-<span id="cb133-210"><a href="#cb133-210" aria-hidden="true" tabindex="-1"></a>    k_sz, x_sz <span class="op">=</span> chance_constraint_szenarien(a_bau, <span class="fl">0.05</span>)</span>
-<span id="cb133-211"><a href="#cb133-211" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb133-212"><a href="#cb133-212" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(KOPF)</span>
-<span id="cb133-213"><a href="#cb133-213" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;-&quot;</span> <span class="op">*</span> <span class="dv">78</span>)</span>
-<span id="cb133-214"><a href="#cb133-214" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(zeile(<span class="st">&quot;SOC, Zusage 95 %&quot;</span>, k_soc, x_soc,</span>
-<span id="cb133-215"><a href="#cb133-215" aria-hidden="true" tabindex="-1"></a>                sicherheit(x_soc, normalwelt), sicherheit(x_soc, echt)))</span>
-<span id="cb133-216"><a href="#cb133-216" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(zeile(<span class="st">&quot;Szenarien, 95 %&quot;</span>, k_sz, x_sz,</span>
-<span id="cb133-217"><a href="#cb133-217" aria-hidden="true" tabindex="-1"></a>                sicherheit(x_sz, normalwelt), sicherheit(x_sz, echt)))</span>
-<span id="cb133-218"><a href="#cb133-218" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb133-219"><a href="#cb133-219" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;</span><span class="ch">\n</span><span class="ss">  Der SOC-Plan verspricht 95 % und haelt &quot;</span></span>
-<span id="cb133-220"><a href="#cb133-220" aria-hidden="true" tabindex="-1"></a>          <span class="ss">f&quot;</span><span class="sc">{</span>sicherheit(x_soc, echt) <span class="op">*</span> <span class="dv">100</span><span class="sc">:.1f}</span><span class="ss"> %. Nicht das Verfahren ist&quot;</span>)</span>
-<span id="cb133-221"><a href="#cb133-221" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;  falsch, sondern die Annahme: In der Normalwelt liefert derselbe&quot;</span>)</span>
-<span id="cb133-222"><a href="#cb133-222" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;  Plan </span><span class="sc">{</span>sicherheit(x_soc, normalwelt) <span class="op">*</span> <span class="dv">100</span><span class="sc">:.1f}</span><span class="ss"> %.&quot;</span>)</span>
-<span id="cb133-223"><a href="#cb133-223" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;</span><span class="ch">\n</span><span class="ss">  Der Szenarioplan (</span><span class="sc">{</span><span class="bu">len</span>(a_bau)<span class="sc">}</span><span class="ss"> Szenarien, </span><span class="sc">{</span><span class="bu">len</span>(a_bau)<span class="sc">}</span><span class="ss"> &quot;</span></span>
-<span id="cb133-224"><a href="#cb133-224" aria-hidden="true" tabindex="-1"></a>          <span class="ss">f&quot;Binaervariablen) kommt auf&quot;</span>)</span>
-<span id="cb133-225"><a href="#cb133-225" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;  </span><span class="sc">{</span>sicherheit(x_sz, echt) <span class="op">*</span> <span class="dv">100</span><span class="sc">:.1f}</span><span class="ss"> % - und kostet dafuer &quot;</span></span>
-<span id="cb133-226"><a href="#cb133-226" aria-hidden="true" tabindex="-1"></a>          <span class="ss">f&quot;</span><span class="sc">{</span>(k_sz <span class="op">/</span> k_soc <span class="op">-</span> <span class="dv">1</span>) <span class="op">*</span> <span class="dv">100</span><span class="sc">:+.1f}</span><span class="ss"> %. Er kauft keine Windkraft mehr:&quot;</span>)</span>
-<span id="cb133-227"><a href="#cb133-227" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;  Was im Ernstfall ausfaellt, hilft der Zusage nicht.&quot;</span>)</span>
-<span id="cb133-228"><a href="#cb133-228" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;=&quot;</span> <span class="op">*</span> <span class="dv">78</span>)</span></code></pre></div>
+<div class="sourceCode" id="cb135"><pre class="sourceCode python"><code class="sourceCode python"><span id="cb135-1"><a href="#cb135-1" aria-hidden="true" tabindex="-1"></a><span class="co">#!/usr/bin/env python3</span></span>
+<span id="cb135-2"><a href="#cb135-2" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb135-3"><a href="#cb135-3" aria-hidden="true" tabindex="-1"></a><span class="co"># Chance_Constraints.py</span></span>
+<span id="cb135-4"><a href="#cb135-4" aria-hidden="true" tabindex="-1"></a><span class="co">&quot;&quot;&quot;</span></span>
+<span id="cb135-5"><a href="#cb135-5" aria-hidden="true" tabindex="-1"></a><span class="co">Kapitel Unsicherheit: Wahrscheinlichkeitsbeschraenkungen.</span></span>
+<span id="cb135-6"><a href="#cb135-6" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb135-7"><a href="#cb135-7" aria-hidden="true" tabindex="-1"></a><span class="co">Das Management fragt selten &quot;was ist im Mittel am besten?&quot;, sondern &quot;mit</span></span>
+<span id="cb135-8"><a href="#cb135-8" aria-hidden="true" tabindex="-1"></a><span class="co">welcher Sicherheit haelt der Plan?&quot;. Genau das formuliert eine Chance</span></span>
+<span id="cb135-9"><a href="#cb135-9" aria-hidden="true" tabindex="-1"></a><span class="co">Constraint:  P(Versorgung &gt;= Bedarf) &gt;= 1 - alpha.</span></span>
+<span id="cb135-10"><a href="#cb135-10" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb135-11"><a href="#cb135-11" aria-hidden="true" tabindex="-1"></a><span class="co">Gezeigt werden beide Wege dorthin, an derselben Instanz:</span></span>
+<span id="cb135-12"><a href="#cb135-12" aria-hidden="true" tabindex="-1"></a><span class="co">  (a) analytisch      - unter Normalverteilungsannahme wird daraus eine</span></span>
+<span id="cb135-13"><a href="#cb135-13" aria-hidden="true" tabindex="-1"></a><span class="co">                        Second-Order-Cone-Bedingung, loesbar mit CVXPY</span></span>
+<span id="cb135-14"><a href="#cb135-14" aria-hidden="true" tabindex="-1"></a><span class="co">  (b) szenariobasiert - Big-M mit Binaervariablen, fuer beliebige</span></span>
+<span id="cb135-15"><a href="#cb135-15" aria-hidden="true" tabindex="-1"></a><span class="co">                        empirische Verteilungen</span></span>
+<span id="cb135-16"><a href="#cb135-16" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb135-17"><a href="#cb135-17" aria-hidden="true" tabindex="-1"></a><span class="co">Und die beiden Messungen, auf die es ankommt: Was kostet ein Prozentpunkt</span></span>
+<span id="cb135-18"><a href="#cb135-18" aria-hidden="true" tabindex="-1"></a><span class="co">Versorgungssicherheit - und haelt die Zusage auch dann, wenn die Verteilung</span></span>
+<span id="cb135-19"><a href="#cb135-19" aria-hidden="true" tabindex="-1"></a><span class="co">nicht normal ist?</span></span>
+<span id="cb135-20"><a href="#cb135-20" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb135-21"><a href="#cb135-21" aria-hidden="true" tabindex="-1"></a><span class="co">Solver: CLARABEL (Kegel) und SciPy/HiGHS (gemischt-ganzzahlig). Weder ortools</span></span>
+<span id="cb135-22"><a href="#cb135-22" aria-hidden="true" tabindex="-1"></a><span class="co">noch ein direkter highspy-Import, damit alles in einem Prozess laeuft.</span></span>
+<span id="cb135-23"><a href="#cb135-23" aria-hidden="true" tabindex="-1"></a><span class="co">&quot;&quot;&quot;</span></span>
+<span id="cb135-24"><a href="#cb135-24" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb135-25"><a href="#cb135-25" aria-hidden="true" tabindex="-1"></a><span class="im">import</span> cvxpy <span class="im">as</span> cp</span>
+<span id="cb135-26"><a href="#cb135-26" aria-hidden="true" tabindex="-1"></a><span class="im">import</span> numpy <span class="im">as</span> np</span>
+<span id="cb135-27"><a href="#cb135-27" aria-hidden="true" tabindex="-1"></a><span class="im">from</span> scipy.stats <span class="im">import</span> norm</span>
+<span id="cb135-28"><a href="#cb135-28" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb135-29"><a href="#cb135-29" aria-hidden="true" tabindex="-1"></a><span class="co"># --- Der Kraftwerkspark ----------------------------------------------------</span></span>
+<span id="cb135-30"><a href="#cb135-30" aria-hidden="true" tabindex="-1"></a><span class="co"># Die Verfuegbarkeit ist der Anteil, den eine installierte MW im Mittel</span></span>
+<span id="cb135-31"><a href="#cb135-31" aria-hidden="true" tabindex="-1"></a><span class="co"># wirklich liefert: bei Wind und Sonne klein und stark schwankend, bei Gas und</span></span>
+<span id="cb135-32"><a href="#cb135-32" aria-hidden="true" tabindex="-1"></a><span class="co"># Biomasse gross und stabil. Die Ausbaugrenze ist der Standort - Flaeche,</span></span>
+<span id="cb135-33"><a href="#cb135-33" aria-hidden="true" tabindex="-1"></a><span class="co"># Genehmigung, Brennstoffversorgung.</span></span>
+<span id="cb135-34"><a href="#cb135-34" aria-hidden="true" tabindex="-1"></a>TECHNIK <span class="op">=</span> [<span class="st">&quot;Gaskraftwerk&quot;</span>, <span class="st">&quot;Windpark&quot;</span>, <span class="st">&quot;Solarpark&quot;</span>, <span class="st">&quot;Biomasse&quot;</span>]</span>
+<span id="cb135-35"><a href="#cb135-35" aria-hidden="true" tabindex="-1"></a>KOSTEN <span class="op">=</span> np.array([<span class="fl">65_000.0</span>, <span class="fl">24_000.0</span>, <span class="fl">12_000.0</span>, <span class="fl">60_000.0</span>])   <span class="co"># EUR je MW und Jahr</span></span>
+<span id="cb135-36"><a href="#cb135-36" aria-hidden="true" tabindex="-1"></a>VERFUEGBAR <span class="op">=</span> np.array([<span class="fl">0.92</span>, <span class="fl">0.35</span>, <span class="fl">0.18</span>, <span class="fl">0.85</span>])</span>
+<span id="cb135-37"><a href="#cb135-37" aria-hidden="true" tabindex="-1"></a>STREUUNG <span class="op">=</span> np.array([<span class="fl">0.05</span>, <span class="fl">0.16</span>, <span class="fl">0.10</span>, <span class="fl">0.04</span>])</span>
+<span id="cb135-38"><a href="#cb135-38" aria-hidden="true" tabindex="-1"></a>GRENZE <span class="op">=</span> np.array([<span class="fl">400.0</span>, <span class="fl">250.0</span>, <span class="fl">600.0</span>, <span class="fl">350.0</span>])               <span class="co"># MW</span></span>
+<span id="cb135-39"><a href="#cb135-39" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb135-40"><a href="#cb135-40" aria-hidden="true" tabindex="-1"></a><span class="co"># Wind und Sonne sind leicht gegenlaeufig: Ein Tiefdruckgebiet bringt Wind und</span></span>
+<span id="cb135-41"><a href="#cb135-41" aria-hidden="true" tabindex="-1"></a><span class="co"># Wolken zugleich. Genau diese Korrelation macht die Bedingung zu einem Kegel</span></span>
+<span id="cb135-42"><a href="#cb135-42" aria-hidden="true" tabindex="-1"></a><span class="co"># und nicht zu einer Summe unabhaengiger Einzelzuschlaege.</span></span>
+<span id="cb135-43"><a href="#cb135-43" aria-hidden="true" tabindex="-1"></a>KORRELATION <span class="op">=</span> np.array([</span>
+<span id="cb135-44"><a href="#cb135-44" aria-hidden="true" tabindex="-1"></a>    [<span class="fl">1.00</span>,  <span class="fl">0.00</span>,  <span class="fl">0.00</span>, <span class="fl">0.05</span>],</span>
+<span id="cb135-45"><a href="#cb135-45" aria-hidden="true" tabindex="-1"></a>    [<span class="fl">0.00</span>,  <span class="fl">1.00</span>, <span class="op">-</span><span class="fl">0.25</span>, <span class="fl">0.00</span>],</span>
+<span id="cb135-46"><a href="#cb135-46" aria-hidden="true" tabindex="-1"></a>    [<span class="fl">0.00</span>, <span class="op">-</span><span class="fl">0.25</span>,  <span class="fl">1.00</span>, <span class="fl">0.00</span>],</span>
+<span id="cb135-47"><a href="#cb135-47" aria-hidden="true" tabindex="-1"></a>    [<span class="fl">0.05</span>,  <span class="fl">0.00</span>,  <span class="fl">0.00</span>, <span class="fl">1.00</span>],</span>
+<span id="cb135-48"><a href="#cb135-48" aria-hidden="true" tabindex="-1"></a>])</span>
+<span id="cb135-49"><a href="#cb135-49" aria-hidden="true" tabindex="-1"></a>SIGMA <span class="op">=</span> np.diag(STREUUNG) <span class="op">@</span> KORRELATION <span class="op">@</span> np.diag(STREUUNG)</span>
+<span id="cb135-50"><a href="#cb135-50" aria-hidden="true" tabindex="-1"></a>WURZEL <span class="op">=</span> np.linalg.cholesky(SIGMA)          <span class="co"># L mit L @ L.T == SIGMA</span></span>
+<span id="cb135-51"><a href="#cb135-51" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb135-52"><a href="#cb135-52" aria-hidden="true" tabindex="-1"></a>BEDARF <span class="op">=</span> <span class="fl">500.0</span>          <span class="co"># MW, die gesichert bereitstehen muessen</span></span>
+<span id="cb135-53"><a href="#cb135-53" aria-hidden="true" tabindex="-1"></a>N <span class="op">=</span> <span class="bu">len</span>(TECHNIK)</span>
+<span id="cb135-54"><a href="#cb135-54" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb135-55"><a href="#cb135-55" aria-hidden="true" tabindex="-1"></a><span class="co"># Die Kaeltewelle mit Dunkelflaute: selten, aber sie trifft alles zugleich.</span></span>
+<span id="cb135-56"><a href="#cb135-56" aria-hidden="true" tabindex="-1"></a><span class="co"># Wind und Sonne brechen fast vollstaendig weg - und, das ist der Punkt, das</span></span>
+<span id="cb135-57"><a href="#cb135-57" aria-hidden="true" tabindex="-1"></a><span class="co"># Gaskraftwerk liefert ebenfalls weniger, weil bei Frost der Netzdruck faellt.</span></span>
+<span id="cb135-58"><a href="#cb135-58" aria-hidden="true" tabindex="-1"></a><span class="co"># Eine Kovarianzmatrix mit Korrelationen um null kann das nicht ausdruecken.</span></span>
+<span id="cb135-59"><a href="#cb135-59" aria-hidden="true" tabindex="-1"></a>P_KAELTEWELLE <span class="op">=</span> <span class="fl">0.08</span></span>
+<span id="cb135-60"><a href="#cb135-60" aria-hidden="true" tabindex="-1"></a>EINBRUCH <span class="op">=</span> np.array([<span class="fl">0.72</span>, <span class="fl">0.10</span>, <span class="fl">0.15</span>, <span class="fl">0.88</span>])</span>
+<span id="cb135-61"><a href="#cb135-61" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb135-62"><a href="#cb135-62" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb135-63"><a href="#cb135-63" aria-hidden="true" tabindex="-1"></a><span class="kw">def</span> mittelwertplan():</span>
+<span id="cb135-64"><a href="#cb135-64" aria-hidden="true" tabindex="-1"></a>    <span class="co">&quot;&quot;&quot;Plant mit den Erwartungswerten - ignoriert die Streuung vollstaendig.&quot;&quot;&quot;</span></span>
+<span id="cb135-65"><a href="#cb135-65" aria-hidden="true" tabindex="-1"></a>    x <span class="op">=</span> cp.Variable(N, nonneg<span class="op">=</span><span class="va">True</span>)</span>
+<span id="cb135-66"><a href="#cb135-66" aria-hidden="true" tabindex="-1"></a>    problem <span class="op">=</span> cp.Problem(cp.Minimize(KOSTEN <span class="op">@</span> x),</span>
+<span id="cb135-67"><a href="#cb135-67" aria-hidden="true" tabindex="-1"></a>                         [VERFUEGBAR <span class="op">@</span> x <span class="op">&gt;=</span> BEDARF, x <span class="op">&lt;=</span> GRENZE])</span>
+<span id="cb135-68"><a href="#cb135-68" aria-hidden="true" tabindex="-1"></a>    problem.solve(solver<span class="op">=</span>cp.CLARABEL)</span>
+<span id="cb135-69"><a href="#cb135-69" aria-hidden="true" tabindex="-1"></a>    <span class="cf">return</span> problem.value, x.value</span>
+<span id="cb135-70"><a href="#cb135-70" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb135-71"><a href="#cb135-71" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb135-72"><a href="#cb135-72" aria-hidden="true" tabindex="-1"></a><span class="kw">def</span> chance_constraint_analytisch(alpha):</span>
+<span id="cb135-73"><a href="#cb135-73" aria-hidden="true" tabindex="-1"></a>    <span class="co">&quot;&quot;&quot;</span></span>
+<span id="cb135-74"><a href="#cb135-74" aria-hidden="true" tabindex="-1"></a><span class="co">    P(a^T x &gt;= BEDARF) &gt;= 1 - alpha  unter a ~ N(VERFUEGBAR, SIGMA).</span></span>
+<span id="cb135-75"><a href="#cb135-75" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb135-76"><a href="#cb135-76" aria-hidden="true" tabindex="-1"></a><span class="co">    Aequivalent zu:  VERFUEGBAR^T x - z * ||L^T x||_2 &gt;= BEDARF</span></span>
+<span id="cb135-77"><a href="#cb135-77" aria-hidden="true" tabindex="-1"></a><span class="co">    mit z = Phi^-1(1 - alpha). Das ist eine Second-Order-Cone-Bedingung: Der</span></span>
+<span id="cb135-78"><a href="#cb135-78" aria-hidden="true" tabindex="-1"></a><span class="co">    Sicherheitszuschlag ist eine Norm ueber x, kein fester Aufschlag je Anlage.</span></span>
+<span id="cb135-79"><a href="#cb135-79" aria-hidden="true" tabindex="-1"></a><span class="co">    Deshalb belohnt sie Mischung - zwei gegenlaeufige Quellen schwanken</span></span>
+<span id="cb135-80"><a href="#cb135-80" aria-hidden="true" tabindex="-1"></a><span class="co">    gemeinsam weniger als jede fuer sich.</span></span>
+<span id="cb135-81"><a href="#cb135-81" aria-hidden="true" tabindex="-1"></a><span class="co">    &quot;&quot;&quot;</span></span>
+<span id="cb135-82"><a href="#cb135-82" aria-hidden="true" tabindex="-1"></a>    x <span class="op">=</span> cp.Variable(N, nonneg<span class="op">=</span><span class="va">True</span>)</span>
+<span id="cb135-83"><a href="#cb135-83" aria-hidden="true" tabindex="-1"></a>    z <span class="op">=</span> norm.ppf(<span class="dv">1</span> <span class="op">-</span> alpha)</span>
+<span id="cb135-84"><a href="#cb135-84" aria-hidden="true" tabindex="-1"></a>    bedingung <span class="op">=</span> VERFUEGBAR <span class="op">@</span> x <span class="op">-</span> z <span class="op">*</span> cp.norm(WURZEL.T <span class="op">@</span> x, <span class="dv">2</span>) <span class="op">&gt;=</span> BEDARF</span>
+<span id="cb135-85"><a href="#cb135-85" aria-hidden="true" tabindex="-1"></a>    problem <span class="op">=</span> cp.Problem(cp.Minimize(KOSTEN <span class="op">@</span> x), [bedingung, x <span class="op">&lt;=</span> GRENZE])</span>
+<span id="cb135-86"><a href="#cb135-86" aria-hidden="true" tabindex="-1"></a>    problem.solve(solver<span class="op">=</span>cp.CLARABEL)</span>
+<span id="cb135-87"><a href="#cb135-87" aria-hidden="true" tabindex="-1"></a>    <span class="cf">return</span> problem.value, x.value</span>
+<span id="cb135-88"><a href="#cb135-88" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb135-89"><a href="#cb135-89" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb135-90"><a href="#cb135-90" aria-hidden="true" tabindex="-1"></a><span class="kw">def</span> chance_constraint_szenarien(a, alpha):</span>
+<span id="cb135-91"><a href="#cb135-91" aria-hidden="true" tabindex="-1"></a>    <span class="co">&quot;&quot;&quot;</span></span>
+<span id="cb135-92"><a href="#cb135-92" aria-hidden="true" tabindex="-1"></a><span class="co">    Dieselbe Zusage ohne Verteilungsannahme: Fuer jedes Szenario s sagt eine</span></span>
+<span id="cb135-93"><a href="#cb135-93" aria-hidden="true" tabindex="-1"></a><span class="co">    Binaervariable z_s, ob es verletzt werden darf.</span></span>
+<span id="cb135-94"><a href="#cb135-94" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb135-95"><a href="#cb135-95" aria-hidden="true" tabindex="-1"></a><span class="co">        a_s^T x &gt;= BEDARF - M * z_s        fuer alle s</span></span>
+<span id="cb135-96"><a href="#cb135-96" aria-hidden="true" tabindex="-1"></a><span class="co">        sum_s z_s &lt;= alpha * S</span></span>
+<span id="cb135-97"><a href="#cb135-97" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb135-98"><a href="#cb135-98" aria-hidden="true" tabindex="-1"></a><span class="co">    M = BEDARF ist die kleinstmoegliche gueltige Schranke, denn a_s^T x &gt;= 0:</span></span>
+<span id="cb135-99"><a href="#cb135-99" aria-hidden="true" tabindex="-1"></a><span class="co">    Groesser kann eine Verletzung gar nicht ausfallen. Ein unnoetig grosses M</span></span>
+<span id="cb135-100"><a href="#cb135-100" aria-hidden="true" tabindex="-1"></a><span class="co">    wuerde die LP-Relaxierung aufweichen und die Suche verlangsamen - die</span></span>
+<span id="cb135-101"><a href="#cb135-101" aria-hidden="true" tabindex="-1"></a><span class="co">    Big-M-Falle aus dem Kapitel Gemischt-ganzzahlige Optimierung.</span></span>
+<span id="cb135-102"><a href="#cb135-102" aria-hidden="true" tabindex="-1"></a><span class="co">    &quot;&quot;&quot;</span></span>
+<span id="cb135-103"><a href="#cb135-103" aria-hidden="true" tabindex="-1"></a>    S <span class="op">=</span> <span class="bu">len</span>(a)</span>
+<span id="cb135-104"><a href="#cb135-104" aria-hidden="true" tabindex="-1"></a>    x <span class="op">=</span> cp.Variable(N, nonneg<span class="op">=</span><span class="va">True</span>)</span>
+<span id="cb135-105"><a href="#cb135-105" aria-hidden="true" tabindex="-1"></a>    z <span class="op">=</span> cp.Variable(S, boolean<span class="op">=</span><span class="va">True</span>)</span>
+<span id="cb135-106"><a href="#cb135-106" aria-hidden="true" tabindex="-1"></a>    problem <span class="op">=</span> cp.Problem(</span>
+<span id="cb135-107"><a href="#cb135-107" aria-hidden="true" tabindex="-1"></a>        cp.Minimize(KOSTEN <span class="op">@</span> x),</span>
+<span id="cb135-108"><a href="#cb135-108" aria-hidden="true" tabindex="-1"></a>        [a <span class="op">@</span> x <span class="op">&gt;=</span> BEDARF <span class="op">-</span> BEDARF <span class="op">*</span> z, cp.<span class="bu">sum</span>(z) <span class="op">&lt;=</span> alpha <span class="op">*</span> S, x <span class="op">&lt;=</span> GRENZE])</span>
+<span id="cb135-109"><a href="#cb135-109" aria-hidden="true" tabindex="-1"></a>    problem.solve(solver<span class="op">=</span>cp.SCIPY)</span>
+<span id="cb135-110"><a href="#cb135-110" aria-hidden="true" tabindex="-1"></a>    <span class="cf">return</span> problem.value, x.value</span>
+<span id="cb135-111"><a href="#cb135-111" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb135-112"><a href="#cb135-112" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb135-113"><a href="#cb135-113" aria-hidden="true" tabindex="-1"></a><span class="kw">def</span> ziehe_wetter(anzahl, seed):</span>
+<span id="cb135-114"><a href="#cb135-114" aria-hidden="true" tabindex="-1"></a>    <span class="co">&quot;&quot;&quot;Mischverteilung: normales Wetter, mit P_KAELTEWELLE ein Einbruch.&quot;&quot;&quot;</span></span>
+<span id="cb135-115"><a href="#cb135-115" aria-hidden="true" tabindex="-1"></a>    rng <span class="op">=</span> np.random.default_rng(seed)</span>
+<span id="cb135-116"><a href="#cb135-116" aria-hidden="true" tabindex="-1"></a>    a <span class="op">=</span> rng.multivariate_normal(VERFUEGBAR, SIGMA, size<span class="op">=</span>anzahl)</span>
+<span id="cb135-117"><a href="#cb135-117" aria-hidden="true" tabindex="-1"></a>    getroffen <span class="op">=</span> rng.random(anzahl) <span class="op">&lt;</span> P_KAELTEWELLE</span>
+<span id="cb135-118"><a href="#cb135-118" aria-hidden="true" tabindex="-1"></a>    a[getroffen] <span class="op">*=</span> EINBRUCH</span>
+<span id="cb135-119"><a href="#cb135-119" aria-hidden="true" tabindex="-1"></a>    <span class="cf">return</span> np.clip(a, <span class="fl">0.0</span>, <span class="fl">1.0</span>)</span>
+<span id="cb135-120"><a href="#cb135-120" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb135-121"><a href="#cb135-121" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb135-122"><a href="#cb135-122" aria-hidden="true" tabindex="-1"></a><span class="kw">def</span> sicherheit(x, a):</span>
+<span id="cb135-123"><a href="#cb135-123" aria-hidden="true" tabindex="-1"></a>    <span class="co">&quot;&quot;&quot;Anteil der Szenarien, in denen der Plan den Bedarf deckt.&quot;&quot;&quot;</span></span>
+<span id="cb135-124"><a href="#cb135-124" aria-hidden="true" tabindex="-1"></a>    <span class="cf">return</span> <span class="bu">float</span>(np.mean(a <span class="op">@</span> x <span class="op">&gt;=</span> BEDARF))</span>
+<span id="cb135-125"><a href="#cb135-125" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb135-126"><a href="#cb135-126" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb135-127"><a href="#cb135-127" aria-hidden="true" tabindex="-1"></a>KOPF <span class="op">=</span> (<span class="ss">f&quot;</span><span class="sc">{</span><span class="st">&#39;Plan&#39;</span><span class="sc">:&lt;20}</span><span class="ss"> </span><span class="sc">{</span><span class="st">&#39;Kosten (EUR)&#39;</span><span class="sc">:&gt;13}</span><span class="ss">  </span><span class="sc">{</span><span class="st">&#39;Gas&#39;</span><span class="sc">:&gt;4}</span><span class="ss"> </span><span class="sc">{</span><span class="st">&#39;Wind&#39;</span><span class="sc">:&gt;4}</span><span class="ss"> &quot;</span></span>
+<span id="cb135-128"><a href="#cb135-128" aria-hidden="true" tabindex="-1"></a>        <span class="ss">f&quot;</span><span class="sc">{</span><span class="st">&#39;Sol&#39;</span><span class="sc">:&gt;4}</span><span class="ss"> </span><span class="sc">{</span><span class="st">&#39;Bio&#39;</span><span class="sc">:&gt;4}</span><span class="ss">  </span><span class="sc">{</span><span class="st">&#39;Normalwelt&#39;</span><span class="sc">:&gt;11}</span><span class="ss"> </span><span class="sc">{</span><span class="st">&#39;echte Welt&#39;</span><span class="sc">:&gt;11}</span><span class="ss">&quot;</span>)</span>
+<span id="cb135-129"><a href="#cb135-129" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb135-130"><a href="#cb135-130" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb135-131"><a href="#cb135-131" aria-hidden="true" tabindex="-1"></a><span class="kw">def</span> zeile(name, kosten, x, in_normal, in_echt):</span>
+<span id="cb135-132"><a href="#cb135-132" aria-hidden="true" tabindex="-1"></a>    mix <span class="op">=</span> <span class="st">&quot; &quot;</span>.join(<span class="ss">f&quot;</span><span class="sc">{</span>w<span class="sc">:4.0f}</span><span class="ss">&quot;</span> <span class="cf">for</span> w <span class="kw">in</span> x)</span>
+<span id="cb135-133"><a href="#cb135-133" aria-hidden="true" tabindex="-1"></a>    <span class="cf">return</span> (<span class="ss">f&quot;</span><span class="sc">{</span>name<span class="sc">:&lt;20}</span><span class="ss"> </span><span class="sc">{</span>kosten<span class="sc">:&gt;13,.0f}</span><span class="ss">  </span><span class="sc">{</span>mix<span class="sc">}</span><span class="ss">  &quot;</span></span>
+<span id="cb135-134"><a href="#cb135-134" aria-hidden="true" tabindex="-1"></a>            <span class="ss">f&quot;</span><span class="sc">{</span>in_normal <span class="op">*</span> <span class="dv">100</span><span class="sc">:&gt;9.2f}</span><span class="ss"> % </span><span class="sc">{</span>in_echt <span class="op">*</span> <span class="dv">100</span><span class="sc">:&gt;9.2f}</span><span class="ss"> %&quot;</span>)</span>
+<span id="cb135-135"><a href="#cb135-135" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb135-136"><a href="#cb135-136" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb135-137"><a href="#cb135-137" aria-hidden="true" tabindex="-1"></a><span class="cf">if</span> <span class="va">__name__</span> <span class="op">==</span> <span class="st">&quot;__main__&quot;</span>:</span>
+<span id="cb135-138"><a href="#cb135-138" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;=&quot;</span> <span class="op">*</span> <span class="dv">78</span>)</span>
+<span id="cb135-139"><a href="#cb135-139" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;  WAHRSCHEINLICHKEITSBESCHRAENKUNGEN IM KRAFTWERKSPARK&quot;</span>)</span>
+<span id="cb135-140"><a href="#cb135-140" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;=&quot;</span> <span class="op">*</span> <span class="dv">78</span>)</span>
+<span id="cb135-141"><a href="#cb135-141" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;Gesichert bereitzustellen: </span><span class="sc">{</span>BEDARF<span class="sc">:.0f}</span><span class="ss"> MW</span><span class="ch">\n</span><span class="ss">&quot;</span>)</span>
+<span id="cb135-142"><a href="#cb135-142" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;</span><span class="sc">{</span><span class="st">&#39;Technologie&#39;</span><span class="sc">:&lt;14}</span><span class="ss"> </span><span class="sc">{</span><span class="st">&#39;EUR/MW&#39;</span><span class="sc">:&gt;8}</span><span class="ss"> </span><span class="sc">{</span><span class="st">&#39;verfuegbar&#39;</span><span class="sc">:&gt;11}</span><span class="ss"> </span><span class="sc">{</span><span class="st">&#39;Streuung&#39;</span><span class="sc">:&gt;9}</span><span class="ss"> &quot;</span></span>
+<span id="cb135-143"><a href="#cb135-143" aria-hidden="true" tabindex="-1"></a>          <span class="ss">f&quot;</span><span class="sc">{</span><span class="st">&#39;Grenze&#39;</span><span class="sc">:&gt;8}</span><span class="ss"> </span><span class="sc">{</span><span class="st">&#39;EUR je erw. MW&#39;</span><span class="sc">:&gt;15}</span><span class="ss">&quot;</span>)</span>
+<span id="cb135-144"><a href="#cb135-144" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;-&quot;</span> <span class="op">*</span> <span class="dv">78</span>)</span>
+<span id="cb135-145"><a href="#cb135-145" aria-hidden="true" tabindex="-1"></a>    <span class="cf">for</span> i, name <span class="kw">in</span> <span class="bu">enumerate</span>(TECHNIK):</span>
+<span id="cb135-146"><a href="#cb135-146" aria-hidden="true" tabindex="-1"></a>        <span class="bu">print</span>(<span class="ss">f&quot;</span><span class="sc">{</span>name<span class="sc">:&lt;14}</span><span class="ss"> </span><span class="sc">{</span>KOSTEN[i]<span class="sc">:&gt;8,.0f}</span><span class="ss"> </span><span class="sc">{</span>VERFUEGBAR[i]<span class="sc">:&gt;10.2f}</span><span class="ss">  &quot;</span></span>
+<span id="cb135-147"><a href="#cb135-147" aria-hidden="true" tabindex="-1"></a>              <span class="ss">f&quot;</span><span class="sc">{</span>STREUUNG[i]<span class="sc">:&gt;8.2f}</span><span class="ss"> </span><span class="sc">{</span>GRENZE[i]<span class="sc">:&gt;7.0f}</span><span class="ss"> &quot;</span></span>
+<span id="cb135-148"><a href="#cb135-148" aria-hidden="true" tabindex="-1"></a>              <span class="ss">f&quot;</span><span class="sc">{</span>KOSTEN[i] <span class="op">/</span> VERFUEGBAR[i]<span class="sc">:&gt;15,.0f}</span><span class="ss">&quot;</span>)</span>
+<span id="cb135-149"><a href="#cb135-149" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;</span><span class="ch">\n</span><span class="ss">Vollausbau liefert im Mittel </span><span class="sc">{</span>VERFUEGBAR <span class="op">@</span> GRENZE<span class="sc">:.0f}</span><span class="ss"> MW, &quot;</span></span>
+<span id="cb135-150"><a href="#cb135-150" aria-hidden="true" tabindex="-1"></a>          <span class="ss">f&quot;in der Kaeltewelle </span><span class="sc">{</span>(VERFUEGBAR <span class="op">*</span> EINBRUCH) <span class="op">@</span> GRENZE<span class="sc">:.0f}</span><span class="ss"> MW.&quot;</span>)</span>
+<span id="cb135-151"><a href="#cb135-151" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb135-152"><a href="#cb135-152" aria-hidden="true" tabindex="-1"></a>    <span class="co"># Zwei grosse, unabhaengige Testmengen. An ihnen wird JEDER Plan gemessen -</span></span>
+<span id="cb135-153"><a href="#cb135-153" aria-hidden="true" tabindex="-1"></a>    <span class="co"># einmal in der unterstellten Normalwelt, einmal in der echten Verteilung.</span></span>
+<span id="cb135-154"><a href="#cb135-154" aria-hidden="true" tabindex="-1"></a>    echt <span class="op">=</span> ziehe_wetter(<span class="dv">200_000</span>, seed<span class="op">=</span><span class="dv">771</span>)</span>
+<span id="cb135-155"><a href="#cb135-155" aria-hidden="true" tabindex="-1"></a>    normalwelt <span class="op">=</span> np.random.default_rng(<span class="dv">4711</span>).multivariate_normal(</span>
+<span id="cb135-156"><a href="#cb135-156" aria-hidden="true" tabindex="-1"></a>        VERFUEGBAR, SIGMA, size<span class="op">=</span><span class="dv">200_000</span>)</span>
+<span id="cb135-157"><a href="#cb135-157" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb135-158"><a href="#cb135-158" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;</span><span class="ch">\n</span><span class="st">&quot;</span> <span class="op">+</span> <span class="st">&quot;=&quot;</span> <span class="op">*</span> <span class="dv">78</span>)</span>
+<span id="cb135-159"><a href="#cb135-159" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;  (1) Mittelwertplan und Chance Constraints im Vergleich&quot;</span>)</span>
+<span id="cb135-160"><a href="#cb135-160" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;=&quot;</span> <span class="op">*</span> <span class="dv">78</span>)</span>
+<span id="cb135-161"><a href="#cb135-161" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(KOPF)</span>
+<span id="cb135-162"><a href="#cb135-162" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;-&quot;</span> <span class="op">*</span> <span class="dv">78</span>)</span>
+<span id="cb135-163"><a href="#cb135-163" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb135-164"><a href="#cb135-164" aria-hidden="true" tabindex="-1"></a>    k_mittel, x_mittel <span class="op">=</span> mittelwertplan()</span>
+<span id="cb135-165"><a href="#cb135-165" aria-hidden="true" tabindex="-1"></a>    stufen <span class="op">=</span> [(<span class="st">&quot;Mittelwert&quot;</span>, k_mittel, sicherheit(x_mittel, normalwelt))]</span>
+<span id="cb135-166"><a href="#cb135-166" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(zeile(<span class="st">&quot;Mittelwert&quot;</span>, k_mittel, x_mittel,</span>
+<span id="cb135-167"><a href="#cb135-167" aria-hidden="true" tabindex="-1"></a>                sicherheit(x_mittel, normalwelt), sicherheit(x_mittel, echt)))</span>
+<span id="cb135-168"><a href="#cb135-168" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb135-169"><a href="#cb135-169" aria-hidden="true" tabindex="-1"></a>    plaene <span class="op">=</span> {}</span>
+<span id="cb135-170"><a href="#cb135-170" aria-hidden="true" tabindex="-1"></a>    <span class="cf">for</span> alpha <span class="kw">in</span> (<span class="fl">0.20</span>, <span class="fl">0.10</span>, <span class="fl">0.05</span>, <span class="fl">0.01</span>):</span>
+<span id="cb135-171"><a href="#cb135-171" aria-hidden="true" tabindex="-1"></a>        kosten, x <span class="op">=</span> chance_constraint_analytisch(alpha)</span>
+<span id="cb135-172"><a href="#cb135-172" aria-hidden="true" tabindex="-1"></a>        plaene[alpha] <span class="op">=</span> (kosten, x)</span>
+<span id="cb135-173"><a href="#cb135-173" aria-hidden="true" tabindex="-1"></a>        quote_normal <span class="op">=</span> sicherheit(x, normalwelt)</span>
+<span id="cb135-174"><a href="#cb135-174" aria-hidden="true" tabindex="-1"></a>        stufen.append((<span class="ss">f&quot;Zusage </span><span class="sc">{</span>(<span class="dv">1</span> <span class="op">-</span> alpha) <span class="op">*</span> <span class="dv">100</span><span class="sc">:.0f}</span><span class="ss"> %&quot;</span>, kosten, quote_normal))</span>
+<span id="cb135-175"><a href="#cb135-175" aria-hidden="true" tabindex="-1"></a>        <span class="bu">print</span>(zeile(<span class="ss">f&quot;Zusage </span><span class="sc">{</span>(<span class="dv">1</span> <span class="op">-</span> alpha) <span class="op">*</span> <span class="dv">100</span><span class="sc">:.0f}</span><span class="ss"> %&quot;</span>, kosten, x,</span>
+<span id="cb135-176"><a href="#cb135-176" aria-hidden="true" tabindex="-1"></a>                    quote_normal, sicherheit(x, echt)))</span>
+<span id="cb135-177"><a href="#cb135-177" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb135-178"><a href="#cb135-178" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;</span><span class="ch">\n</span><span class="st">  In der Normalwelt trifft jede Zusage ihren Wert - das Verfahren&quot;</span>)</span>
+<span id="cb135-179"><a href="#cb135-179" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;  rechnet richtig. Die Spalte &#39;echte Welt&#39; kommt in Teil (3).&quot;</span>)</span>
+<span id="cb135-180"><a href="#cb135-180" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb135-181"><a href="#cb135-181" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;</span><span class="ch">\n</span><span class="st">&quot;</span> <span class="op">+</span> <span class="st">&quot;=&quot;</span> <span class="op">*</span> <span class="dv">78</span>)</span>
+<span id="cb135-182"><a href="#cb135-182" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;  (2) Was kostet ein Prozentpunkt Versorgungssicherheit?&quot;</span>)</span>
+<span id="cb135-183"><a href="#cb135-183" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;=&quot;</span> <span class="op">*</span> <span class="dv">78</span>)</span>
+<span id="cb135-184"><a href="#cb135-184" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;</span><span class="sc">{</span><span class="st">&#39;von -&gt; nach&#39;</span><span class="sc">:&lt;26}</span><span class="ss"> </span><span class="sc">{</span><span class="st">&#39;Prozentpunkte&#39;</span><span class="sc">:&gt;13}</span><span class="ss"> </span><span class="sc">{</span><span class="st">&#39;Mehrkosten&#39;</span><span class="sc">:&gt;13}</span><span class="ss"> &quot;</span></span>
+<span id="cb135-185"><a href="#cb135-185" aria-hidden="true" tabindex="-1"></a>          <span class="ss">f&quot;</span><span class="sc">{</span><span class="st">&#39;EUR je Punkt&#39;</span><span class="sc">:&gt;13}</span><span class="ss">&quot;</span>)</span>
+<span id="cb135-186"><a href="#cb135-186" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;-&quot;</span> <span class="op">*</span> <span class="dv">78</span>)</span>
+<span id="cb135-187"><a href="#cb135-187" aria-hidden="true" tabindex="-1"></a>    <span class="cf">for</span> (n1, k1, q1), (n2, k2, q2) <span class="kw">in</span> <span class="bu">zip</span>(stufen, stufen[<span class="dv">1</span>:]):</span>
+<span id="cb135-188"><a href="#cb135-188" aria-hidden="true" tabindex="-1"></a>        d_punkte <span class="op">=</span> (q2 <span class="op">-</span> q1) <span class="op">*</span> <span class="dv">100</span></span>
+<span id="cb135-189"><a href="#cb135-189" aria-hidden="true" tabindex="-1"></a>        d_kosten <span class="op">=</span> k2 <span class="op">-</span> k1</span>
+<span id="cb135-190"><a href="#cb135-190" aria-hidden="true" tabindex="-1"></a>        <span class="bu">print</span>(<span class="ss">f&quot;</span><span class="sc">{</span>n1 <span class="op">+</span> <span class="st">&#39; -&gt; &#39;</span> <span class="op">+</span> n2<span class="sc">:&lt;26}</span><span class="ss"> </span><span class="sc">{</span>d_punkte<span class="sc">:&gt;13.2f}</span><span class="ss"> </span><span class="sc">{</span>d_kosten<span class="sc">:&gt;13,.0f}</span><span class="ss"> &quot;</span></span>
+<span id="cb135-191"><a href="#cb135-191" aria-hidden="true" tabindex="-1"></a>              <span class="ss">f&quot;</span><span class="sc">{</span>d_kosten <span class="op">/</span> d_punkte<span class="sc">:&gt;13,.0f}</span><span class="ss">&quot;</span>)</span>
+<span id="cb135-192"><a href="#cb135-192" aria-hidden="true" tabindex="-1"></a>    erst <span class="op">=</span> (stufen[<span class="dv">1</span>][<span class="dv">1</span>] <span class="op">-</span> stufen[<span class="dv">0</span>][<span class="dv">1</span>]) <span class="op">/</span> ((stufen[<span class="dv">1</span>][<span class="dv">2</span>] <span class="op">-</span> stufen[<span class="dv">0</span>][<span class="dv">2</span>]) <span class="op">*</span> <span class="dv">100</span>)</span>
+<span id="cb135-193"><a href="#cb135-193" aria-hidden="true" tabindex="-1"></a>    letzt <span class="op">=</span> (stufen[<span class="op">-</span><span class="dv">1</span>][<span class="dv">1</span>] <span class="op">-</span> stufen[<span class="op">-</span><span class="dv">2</span>][<span class="dv">1</span>]) <span class="op">/</span> ((stufen[<span class="op">-</span><span class="dv">1</span>][<span class="dv">2</span>] <span class="op">-</span> stufen[<span class="op">-</span><span class="dv">2</span>][<span class="dv">2</span>]) <span class="op">*</span> <span class="dv">100</span>)</span>
+<span id="cb135-194"><a href="#cb135-194" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;</span><span class="ch">\n</span><span class="ss">  Der letzte Prozentpunkt kostet das </span><span class="sc">{</span>letzt <span class="op">/</span> erst<span class="sc">:.1f}</span><span class="ss">-fache des ersten.&quot;</span>)</span>
+<span id="cb135-195"><a href="#cb135-195" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;  Sicherheit ist konvex bepreist - genau deshalb muss jemand&quot;</span>)</span>
+<span id="cb135-196"><a href="#cb135-196" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;  entscheiden, wie viel davon das Unternehmen kaufen will.&quot;</span>)</span>
+<span id="cb135-197"><a href="#cb135-197" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb135-198"><a href="#cb135-198" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;</span><span class="ch">\n</span><span class="st">&quot;</span> <span class="op">+</span> <span class="st">&quot;=&quot;</span> <span class="op">*</span> <span class="dv">78</span>)</span>
+<span id="cb135-199"><a href="#cb135-199" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;  (3) Und wenn die Verteilung nicht normal ist?&quot;</span>)</span>
+<span id="cb135-200"><a href="#cb135-200" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;=&quot;</span> <span class="op">*</span> <span class="dv">78</span>)</span>
+<span id="cb135-201"><a href="#cb135-201" aria-hidden="true" tabindex="-1"></a>    k_soc, x_soc <span class="op">=</span> plaene[<span class="fl">0.05</span>]</span>
+<span id="cb135-202"><a href="#cb135-202" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;Die echte Welt kennt die Kaeltewelle mit Dunkelflaute: in &quot;</span></span>
+<span id="cb135-203"><a href="#cb135-203" aria-hidden="true" tabindex="-1"></a>          <span class="ss">f&quot;</span><span class="sc">{</span>P_KAELTEWELLE <span class="op">*</span> <span class="dv">100</span><span class="sc">:.0f}</span><span class="ss"> % der Faelle liefern&quot;</span>)</span>
+<span id="cb135-204"><a href="#cb135-204" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;Wind </span><span class="sc">{</span>EINBRUCH[<span class="dv">1</span>] <span class="op">*</span> <span class="dv">100</span><span class="sc">:.0f}</span><span class="ss"> %, Sonne </span><span class="sc">{</span>EINBRUCH[<span class="dv">2</span>] <span class="op">*</span> <span class="dv">100</span><span class="sc">:.0f}</span><span class="ss"> % &quot;</span></span>
+<span id="cb135-205"><a href="#cb135-205" aria-hidden="true" tabindex="-1"></a>          <span class="ss">f&quot;und - entscheidend - auch das Gaskraftwerk nur &quot;</span></span>
+<span id="cb135-206"><a href="#cb135-206" aria-hidden="true" tabindex="-1"></a>          <span class="ss">f&quot;</span><span class="sc">{</span>EINBRUCH[<span class="dv">0</span>] <span class="op">*</span> <span class="dv">100</span><span class="sc">:.0f}</span><span class="ss"> %&quot;</span>)</span>
+<span id="cb135-207"><a href="#cb135-207" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;des Ueblichen. Alles bricht gleichzeitig ein.</span><span class="ch">\n</span><span class="st">&quot;</span>)</span>
+<span id="cb135-208"><a href="#cb135-208" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb135-209"><a href="#cb135-209" aria-hidden="true" tabindex="-1"></a>    a_bau <span class="op">=</span> ziehe_wetter(<span class="dv">400</span>, seed<span class="op">=</span><span class="dv">20260908</span>)</span>
+<span id="cb135-210"><a href="#cb135-210" aria-hidden="true" tabindex="-1"></a>    k_sz, x_sz <span class="op">=</span> chance_constraint_szenarien(a_bau, <span class="fl">0.05</span>)</span>
+<span id="cb135-211"><a href="#cb135-211" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb135-212"><a href="#cb135-212" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(KOPF)</span>
+<span id="cb135-213"><a href="#cb135-213" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;-&quot;</span> <span class="op">*</span> <span class="dv">78</span>)</span>
+<span id="cb135-214"><a href="#cb135-214" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(zeile(<span class="st">&quot;SOC, Zusage 95 %&quot;</span>, k_soc, x_soc,</span>
+<span id="cb135-215"><a href="#cb135-215" aria-hidden="true" tabindex="-1"></a>                sicherheit(x_soc, normalwelt), sicherheit(x_soc, echt)))</span>
+<span id="cb135-216"><a href="#cb135-216" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(zeile(<span class="st">&quot;Szenarien, 95 %&quot;</span>, k_sz, x_sz,</span>
+<span id="cb135-217"><a href="#cb135-217" aria-hidden="true" tabindex="-1"></a>                sicherheit(x_sz, normalwelt), sicherheit(x_sz, echt)))</span>
+<span id="cb135-218"><a href="#cb135-218" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb135-219"><a href="#cb135-219" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;</span><span class="ch">\n</span><span class="ss">  Der SOC-Plan verspricht 95 % und haelt &quot;</span></span>
+<span id="cb135-220"><a href="#cb135-220" aria-hidden="true" tabindex="-1"></a>          <span class="ss">f&quot;</span><span class="sc">{</span>sicherheit(x_soc, echt) <span class="op">*</span> <span class="dv">100</span><span class="sc">:.1f}</span><span class="ss"> %. Nicht das Verfahren ist&quot;</span>)</span>
+<span id="cb135-221"><a href="#cb135-221" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;  falsch, sondern die Annahme: In der Normalwelt liefert derselbe&quot;</span>)</span>
+<span id="cb135-222"><a href="#cb135-222" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;  Plan </span><span class="sc">{</span>sicherheit(x_soc, normalwelt) <span class="op">*</span> <span class="dv">100</span><span class="sc">:.1f}</span><span class="ss"> %.&quot;</span>)</span>
+<span id="cb135-223"><a href="#cb135-223" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;</span><span class="ch">\n</span><span class="ss">  Der Szenarioplan (</span><span class="sc">{</span><span class="bu">len</span>(a_bau)<span class="sc">}</span><span class="ss"> Szenarien, </span><span class="sc">{</span><span class="bu">len</span>(a_bau)<span class="sc">}</span><span class="ss"> &quot;</span></span>
+<span id="cb135-224"><a href="#cb135-224" aria-hidden="true" tabindex="-1"></a>          <span class="ss">f&quot;Binaervariablen) kommt auf&quot;</span>)</span>
+<span id="cb135-225"><a href="#cb135-225" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;  </span><span class="sc">{</span>sicherheit(x_sz, echt) <span class="op">*</span> <span class="dv">100</span><span class="sc">:.1f}</span><span class="ss"> % - und kostet dafuer &quot;</span></span>
+<span id="cb135-226"><a href="#cb135-226" aria-hidden="true" tabindex="-1"></a>          <span class="ss">f&quot;</span><span class="sc">{</span>(k_sz <span class="op">/</span> k_soc <span class="op">-</span> <span class="dv">1</span>) <span class="op">*</span> <span class="dv">100</span><span class="sc">:+.1f}</span><span class="ss"> %. Er kauft keine Windkraft mehr:&quot;</span>)</span>
+<span id="cb135-227"><a href="#cb135-227" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;  Was im Ernstfall ausfaellt, hilft der Zusage nicht.&quot;</span>)</span>
+<span id="cb135-228"><a href="#cb135-228" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;=&quot;</span> <span class="op">*</span> <span class="dv">78</span>)</span></code></pre></div>
 <p><strong>Ausgabe:</strong></p>
 <pre><code>==============================================================================
   WAHRSCHEINLICHKEITSBESCHRAENKUNGEN IM KRAFTWERKSPARK
@@ -17475,20 +18340,20 @@ Szenarien, 95 %         43,760,709   350    0    0  350     100.00 %     94.84 %
 <hr />
 <h2 id="sec:unsicherheit-denkfehler">12.9 Finde den Denkfehler</h2>
 <blockquote>
-<p><strong>🐛 Finde den Denkfehler 9.1: Warum jedes Projekt zu spät fertig wird</strong></p>
+<p><strong>🐛 Finde den Denkfehler: Warum jedes Projekt zu spät fertig wird</strong></p>
 <p>Ein Projektleiter plant eine Umbaumaßnahme. Fünf Gewerke arbeiten <strong>parallel</strong> und unabhängig voneinander; fertig ist der Umbau, wenn das letzte fertig ist. Für jedes Gewerk liegt eine Schätzung vor: mindestens 6 Tage, wahrscheinlich 10, im schlechtesten Fall 18.</p>
 <p>Er rechnet: <em>„Jedes Gewerk braucht im Mittel <span class="math inline">(6 + 10 + 18)/3 = 11{,}3</span> Tage. Alle laufen gleichzeitig. Also ist der Umbau nach 11,3 Tagen fertig — ich plane großzügig 12 ein.“</em></p>
 <p>Nachgerechnet mit 200 000 simulierten Umbauten:</p>
-<div class="sourceCode" id="cb135"><pre class="sourceCode python"><code class="sourceCode python"><span id="cb135-1"><a href="#cb135-1" aria-hidden="true" tabindex="-1"></a><span class="im">import</span> numpy <span class="im">as</span> np</span>
-<span id="cb135-2"><a href="#cb135-2" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb135-3"><a href="#cb135-3" aria-hidden="true" tabindex="-1"></a>rng <span class="op">=</span> np.random.default_rng(<span class="dv">3</span>)</span>
-<span id="cb135-4"><a href="#cb135-4" aria-hidden="true" tabindex="-1"></a>dauer <span class="op">=</span> rng.triangular(<span class="dv">6</span>, <span class="dv">10</span>, <span class="dv">18</span>, size<span class="op">=</span>(<span class="dv">200_000</span>, <span class="dv">5</span>))    <span class="co"># 5 Gewerke, je eine Schaetzung</span></span>
-<span id="cb135-5"><a href="#cb135-5" aria-hidden="true" tabindex="-1"></a>projekt <span class="op">=</span> dauer.<span class="bu">max</span>(axis<span class="op">=</span><span class="dv">1</span>)                             <span class="co"># fertig, wenn das LETZTE fertig ist</span></span>
-<span id="cb135-6"><a href="#cb135-6" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb135-7"><a href="#cb135-7" aria-hidden="true" tabindex="-1"></a><span class="bu">print</span>(<span class="ss">f&quot;Mittelwert einer Einzeldauer:  </span><span class="sc">{</span>dauer<span class="sc">.</span>mean()<span class="sc">:.2f}</span><span class="ss"> Tage&quot;</span>)</span>
-<span id="cb135-8"><a href="#cb135-8" aria-hidden="true" tabindex="-1"></a><span class="bu">print</span>(<span class="ss">f&quot;Tatsaechliche Projektdauer:    </span><span class="sc">{</span>projekt<span class="sc">.</span>mean()<span class="sc">:.2f}</span><span class="ss"> Tage&quot;</span>)</span>
-<span id="cb135-9"><a href="#cb135-9" aria-hidden="true" tabindex="-1"></a><span class="bu">print</span>(<span class="ss">f&quot;90-%-Quantil:                  </span><span class="sc">{</span>np<span class="sc">.</span>quantile(projekt, <span class="fl">0.9</span>)<span class="sc">:.2f}</span><span class="ss"> Tage&quot;</span>)</span>
-<span id="cb135-10"><a href="#cb135-10" aria-hidden="true" tabindex="-1"></a><span class="bu">print</span>(<span class="ss">f&quot;Anteil ueber 11,34 Tage:       </span><span class="sc">{</span>(projekt <span class="op">&gt;</span> <span class="fl">11.34</span>)<span class="sc">.</span>mean() <span class="op">*</span> <span class="dv">100</span><span class="sc">:.1f}</span><span class="ss"> %&quot;</span>)</span></code></pre></div>
+<div class="sourceCode" id="cb137"><pre class="sourceCode python"><code class="sourceCode python"><span id="cb137-1"><a href="#cb137-1" aria-hidden="true" tabindex="-1"></a><span class="im">import</span> numpy <span class="im">as</span> np</span>
+<span id="cb137-2"><a href="#cb137-2" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb137-3"><a href="#cb137-3" aria-hidden="true" tabindex="-1"></a>rng <span class="op">=</span> np.random.default_rng(<span class="dv">3</span>)</span>
+<span id="cb137-4"><a href="#cb137-4" aria-hidden="true" tabindex="-1"></a>dauer <span class="op">=</span> rng.triangular(<span class="dv">6</span>, <span class="dv">10</span>, <span class="dv">18</span>, size<span class="op">=</span>(<span class="dv">200_000</span>, <span class="dv">5</span>))    <span class="co"># 5 Gewerke, je eine Schaetzung</span></span>
+<span id="cb137-5"><a href="#cb137-5" aria-hidden="true" tabindex="-1"></a>projekt <span class="op">=</span> dauer.<span class="bu">max</span>(axis<span class="op">=</span><span class="dv">1</span>)                             <span class="co"># fertig, wenn das LETZTE fertig ist</span></span>
+<span id="cb137-6"><a href="#cb137-6" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb137-7"><a href="#cb137-7" aria-hidden="true" tabindex="-1"></a><span class="bu">print</span>(<span class="ss">f&quot;Mittelwert einer Einzeldauer:  </span><span class="sc">{</span>dauer<span class="sc">.</span>mean()<span class="sc">:.2f}</span><span class="ss"> Tage&quot;</span>)</span>
+<span id="cb137-8"><a href="#cb137-8" aria-hidden="true" tabindex="-1"></a><span class="bu">print</span>(<span class="ss">f&quot;Tatsaechliche Projektdauer:    </span><span class="sc">{</span>projekt<span class="sc">.</span>mean()<span class="sc">:.2f}</span><span class="ss"> Tage&quot;</span>)</span>
+<span id="cb137-9"><a href="#cb137-9" aria-hidden="true" tabindex="-1"></a><span class="bu">print</span>(<span class="ss">f&quot;90-%-Quantil:                  </span><span class="sc">{</span>np<span class="sc">.</span>quantile(projekt, <span class="fl">0.9</span>)<span class="sc">:.2f}</span><span class="ss"> Tage&quot;</span>)</span>
+<span id="cb137-10"><a href="#cb137-10" aria-hidden="true" tabindex="-1"></a><span class="bu">print</span>(<span class="ss">f&quot;Anteil ueber 11,34 Tage:       </span><span class="sc">{</span>(projekt <span class="op">&gt;</span> <span class="fl">11.34</span>)<span class="sc">.</span>mean() <span class="op">*</span> <span class="dv">100</span><span class="sc">:.1f}</span><span class="ss"> %&quot;</span>)</span></code></pre></div>
 <p><strong>Ausgabe:</strong></p>
 <pre><code>Mittelwert einer Einzeldauer:  11.34 Tage
 Tatsaechliche Projektdauer:    14.38 Tage
@@ -17503,7 +18368,7 @@ Anteil ueber 11,34 Tage:       95.5 %</code></pre>
 <hr />
 <h2 id="sec:unsicherheit-quiz">12.10 Micro-Quiz</h2>
 <blockquote>
-<p><strong>❓ Micro-Quiz 9: Drei Fragen zum Selbstcheck</strong></p>
+<p><strong>❓ Micro-Quiz 12: Drei Fragen zum Selbstcheck</strong></p>
 <p>Genau eine Antwort ist jeweils richtig. Auflösung in <a href="#quiz-loesung-unsicherheit">Anhang A</a>.</p>
 <p><strong>1. Bei einem Ersatzteil kostet ein Stück zu wenig 1 400 €, ein Stück zu viel 120 €. Der Bedarf beträgt im Mittel 30 Stück. Wie viel bestellen Sie?</strong> (a) 30 — das ist der Erwartungswert des Bedarfs. (b) Deutlich mehr als 30, nämlich das 92,1-%-Quantil des Bedarfs. Das kritische Verhältnis <span class="math inline">1400/(1400+120)</span> sagt, wie weit man sich auf die günstigere Fehlerseite stellen soll. (c) Weniger als 30, weil Lagerhaltung Kapital bindet.</p>
 <p><strong>2. Was unterscheidet </strong>stochastische** von <strong>robuster</strong> Optimierung?** (a) Stochastische Optimierung ist genauer, robuste ist eine Näherung für schnelle Rechnungen. (b) Stochastische Optimierung braucht <strong>Wahrscheinlichkeiten</strong> und optimiert den Erwartungswert; robuste Optimierung braucht nur <strong>Bandbreiten</strong> und sichert den schlechtesten Fall darin ab. (c) Robuste Optimierung berücksichtigt mehr Szenarien.</p>
@@ -17608,25 +18473,25 @@ Anteil ueber 11,34 Tage:       95.5 %</code></pre>
 </tr>
 </tbody>
 </table>
-<div class="sourceCode" id="cb137"><pre class="sourceCode python"><code class="sourceCode python"><span id="cb137-1"><a href="#cb137-1" aria-hidden="true" tabindex="-1"></a>kanten <span class="op">=</span> {</span>
-<span id="cb137-2"><a href="#cb137-2" aria-hidden="true" tabindex="-1"></a>    <span class="st">&quot;Start&quot;</span>: {<span class="st">&quot;Nord&quot;</span>: <span class="dv">4</span>, <span class="st">&quot;Sued&quot;</span>: <span class="dv">6</span>},</span>
-<span id="cb137-3"><a href="#cb137-3" aria-hidden="true" tabindex="-1"></a>    <span class="st">&quot;Nord&quot;</span>:  {<span class="st">&quot;Ost&quot;</span>: <span class="dv">14</span>, <span class="st">&quot;West&quot;</span>: <span class="dv">9</span>},</span>
-<span id="cb137-4"><a href="#cb137-4" aria-hidden="true" tabindex="-1"></a>    <span class="st">&quot;Sued&quot;</span>:  {<span class="st">&quot;Ost&quot;</span>: <span class="dv">3</span>,  <span class="st">&quot;West&quot;</span>: <span class="dv">7</span>},</span>
-<span id="cb137-5"><a href="#cb137-5" aria-hidden="true" tabindex="-1"></a>    <span class="st">&quot;Ost&quot;</span>:   {<span class="st">&quot;Ziel&quot;</span>: <span class="dv">5</span>},</span>
-<span id="cb137-6"><a href="#cb137-6" aria-hidden="true" tabindex="-1"></a>    <span class="st">&quot;West&quot;</span>:  {<span class="st">&quot;Ziel&quot;</span>: <span class="dv">8</span>},</span>
-<span id="cb137-7"><a href="#cb137-7" aria-hidden="true" tabindex="-1"></a>    <span class="st">&quot;Ziel&quot;</span>:  {},</span>
-<span id="cb137-8"><a href="#cb137-8" aria-hidden="true" tabindex="-1"></a>}</span>
-<span id="cb137-9"><a href="#cb137-9" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb137-10"><a href="#cb137-10" aria-hidden="true" tabindex="-1"></a>wert, plan <span class="op">=</span> {<span class="st">&quot;Ziel&quot;</span>: <span class="dv">0</span>}, {}                       <span class="co"># Restkosten ab jedem Ort</span></span>
-<span id="cb137-11"><a href="#cb137-11" aria-hidden="true" tabindex="-1"></a><span class="cf">for</span> ort <span class="kw">in</span> [<span class="st">&quot;Ost&quot;</span>, <span class="st">&quot;West&quot;</span>, <span class="st">&quot;Nord&quot;</span>, <span class="st">&quot;Sued&quot;</span>, <span class="st">&quot;Start&quot;</span>]:      <span class="co"># RUECKWAERTS!</span></span>
-<span id="cb137-12"><a href="#cb137-12" aria-hidden="true" tabindex="-1"></a>    wert[ort], plan[ort] <span class="op">=</span> <span class="bu">min</span>((k <span class="op">+</span> wert[z], z) <span class="cf">for</span> z, k <span class="kw">in</span> kanten[ort].items())</span>
-<span id="cb137-13"><a href="#cb137-13" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb137-14"><a href="#cb137-14" aria-hidden="true" tabindex="-1"></a>weg, ort <span class="op">=</span> [<span class="st">&quot;Start&quot;</span>], <span class="st">&quot;Start&quot;</span></span>
-<span id="cb137-15"><a href="#cb137-15" aria-hidden="true" tabindex="-1"></a><span class="cf">while</span> ort <span class="op">!=</span> <span class="st">&quot;Ziel&quot;</span>:</span>
-<span id="cb137-16"><a href="#cb137-16" aria-hidden="true" tabindex="-1"></a>    ort <span class="op">=</span> plan[ort]</span>
-<span id="cb137-17"><a href="#cb137-17" aria-hidden="true" tabindex="-1"></a>    weg.append(ort)</span>
-<span id="cb137-18"><a href="#cb137-18" aria-hidden="true" tabindex="-1"></a><span class="bu">print</span>(<span class="st">&quot; -&gt; &quot;</span>.join(weg), <span class="st">&quot;=&quot;</span>, wert[<span class="st">&quot;Start&quot;</span>], <span class="st">&quot;min&quot;</span>)</span>
-<span id="cb137-19"><a href="#cb137-19" aria-hidden="true" tabindex="-1"></a><span class="bu">print</span>(<span class="st">&quot;Restkosten je Ort:&quot;</span>, wert)</span></code></pre></div>
+<div class="sourceCode" id="cb139"><pre class="sourceCode python"><code class="sourceCode python"><span id="cb139-1"><a href="#cb139-1" aria-hidden="true" tabindex="-1"></a>kanten <span class="op">=</span> {</span>
+<span id="cb139-2"><a href="#cb139-2" aria-hidden="true" tabindex="-1"></a>    <span class="st">&quot;Start&quot;</span>: {<span class="st">&quot;Nord&quot;</span>: <span class="dv">4</span>, <span class="st">&quot;Sued&quot;</span>: <span class="dv">6</span>},</span>
+<span id="cb139-3"><a href="#cb139-3" aria-hidden="true" tabindex="-1"></a>    <span class="st">&quot;Nord&quot;</span>:  {<span class="st">&quot;Ost&quot;</span>: <span class="dv">14</span>, <span class="st">&quot;West&quot;</span>: <span class="dv">9</span>},</span>
+<span id="cb139-4"><a href="#cb139-4" aria-hidden="true" tabindex="-1"></a>    <span class="st">&quot;Sued&quot;</span>:  {<span class="st">&quot;Ost&quot;</span>: <span class="dv">3</span>,  <span class="st">&quot;West&quot;</span>: <span class="dv">7</span>},</span>
+<span id="cb139-5"><a href="#cb139-5" aria-hidden="true" tabindex="-1"></a>    <span class="st">&quot;Ost&quot;</span>:   {<span class="st">&quot;Ziel&quot;</span>: <span class="dv">5</span>},</span>
+<span id="cb139-6"><a href="#cb139-6" aria-hidden="true" tabindex="-1"></a>    <span class="st">&quot;West&quot;</span>:  {<span class="st">&quot;Ziel&quot;</span>: <span class="dv">8</span>},</span>
+<span id="cb139-7"><a href="#cb139-7" aria-hidden="true" tabindex="-1"></a>    <span class="st">&quot;Ziel&quot;</span>:  {},</span>
+<span id="cb139-8"><a href="#cb139-8" aria-hidden="true" tabindex="-1"></a>}</span>
+<span id="cb139-9"><a href="#cb139-9" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb139-10"><a href="#cb139-10" aria-hidden="true" tabindex="-1"></a>wert, plan <span class="op">=</span> {<span class="st">&quot;Ziel&quot;</span>: <span class="dv">0</span>}, {}                       <span class="co"># Restkosten ab jedem Ort</span></span>
+<span id="cb139-11"><a href="#cb139-11" aria-hidden="true" tabindex="-1"></a><span class="cf">for</span> ort <span class="kw">in</span> [<span class="st">&quot;Ost&quot;</span>, <span class="st">&quot;West&quot;</span>, <span class="st">&quot;Nord&quot;</span>, <span class="st">&quot;Sued&quot;</span>, <span class="st">&quot;Start&quot;</span>]:      <span class="co"># RUECKWAERTS!</span></span>
+<span id="cb139-12"><a href="#cb139-12" aria-hidden="true" tabindex="-1"></a>    wert[ort], plan[ort] <span class="op">=</span> <span class="bu">min</span>((k <span class="op">+</span> wert[z], z) <span class="cf">for</span> z, k <span class="kw">in</span> kanten[ort].items())</span>
+<span id="cb139-13"><a href="#cb139-13" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb139-14"><a href="#cb139-14" aria-hidden="true" tabindex="-1"></a>weg, ort <span class="op">=</span> [<span class="st">&quot;Start&quot;</span>], <span class="st">&quot;Start&quot;</span></span>
+<span id="cb139-15"><a href="#cb139-15" aria-hidden="true" tabindex="-1"></a><span class="cf">while</span> ort <span class="op">!=</span> <span class="st">&quot;Ziel&quot;</span>:</span>
+<span id="cb139-16"><a href="#cb139-16" aria-hidden="true" tabindex="-1"></a>    ort <span class="op">=</span> plan[ort]</span>
+<span id="cb139-17"><a href="#cb139-17" aria-hidden="true" tabindex="-1"></a>    weg.append(ort)</span>
+<span id="cb139-18"><a href="#cb139-18" aria-hidden="true" tabindex="-1"></a><span class="bu">print</span>(<span class="st">&quot; -&gt; &quot;</span>.join(weg), <span class="st">&quot;=&quot;</span>, wert[<span class="st">&quot;Start&quot;</span>], <span class="st">&quot;min&quot;</span>)</span>
+<span id="cb139-19"><a href="#cb139-19" aria-hidden="true" tabindex="-1"></a><span class="bu">print</span>(<span class="st">&quot;Restkosten je Ort:&quot;</span>, wert)</span></code></pre></div>
 <p><strong>Ausgabe:</strong></p>
 <pre><code>Start -&gt; Sued -&gt; Ost -&gt; Ziel = 14 min
 Restkosten je Ort: {&#39;Ziel&#39;: 0, &#39;Ost&#39;: 5, &#39;West&#39;: 8, &#39;Nord&#39;: 17, &#39;Sued&#39;: 8, &#39;Start&#39;: 14}</code></pre>
@@ -17890,91 +18755,91 @@ V_t(S_t) = \min_{a_t\in\mathcal{A}(S_t)}\Big\{\,C(S_t,a_t) \;+\; \gamma\cdot\mat
 <p><strong>Ergebnis:</strong> <span class="math inline">V_0(3) = 5</span>, erreicht durch <span class="math inline">n_0 = 1</span> (dann <span class="math inline">n_1 = 2</span>) <strong>oder</strong> <span class="math inline">n_0 = 2</span> (dann <span class="math inline">n_1 = 1</span>). Zwei gleichwertige Optima.</p>
 <p><strong>Die Lehre:</strong> Alles auf einmal zu verkaufen kostet 9, gleichmäßiges Aufteilen nur 5. Das ist der Kern des Ausführungsproblems: <strong>Bei überproportionalen Kosten lohnt sich Stückelung.</strong> Und beachten Sie, dass wir nur <span class="math inline">4 + 4 = 8</span> Kombinationen bewertet haben statt aller Verkaufspfade — bei größeren Problemen ist dieser Unterschied dramatisch.</p>
 </blockquote>
-<div class="sourceCode" id="cb139"><pre class="sourceCode python"><code class="sourceCode python"><span id="cb139-1"><a href="#cb139-1" aria-hidden="true" tabindex="-1"></a><span class="co">#!/usr/bin/env python3</span></span>
-<span id="cb139-2"><a href="#cb139-2" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb139-3"><a href="#cb139-3" aria-hidden="true" tabindex="-1"></a><span class="co"># Bellman_Minimalbeispiel.py</span></span>
-<span id="cb139-4"><a href="#cb139-4" aria-hidden="true" tabindex="-1"></a><span class="co">&quot;&quot;&quot;</span></span>
-<span id="cb139-5"><a href="#cb139-5" aria-hidden="true" tabindex="-1"></a><span class="co">Kapitel Dynamische Programmierung: Die Handrechnung zur Rueckwaertsinduktion als Code.</span></span>
-<span id="cb139-6"><a href="#cb139-6" aria-hidden="true" tabindex="-1"></a><span class="co">Zeigt die Wertfunktionstabelle und die optimale Politik Schritt fuer Schritt.</span></span>
-<span id="cb139-7"><a href="#cb139-7" aria-hidden="true" tabindex="-1"></a><span class="co">&quot;&quot;&quot;</span></span>
-<span id="cb139-8"><a href="#cb139-8" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb139-9"><a href="#cb139-9" aria-hidden="true" tabindex="-1"></a><span class="im">import</span> numpy <span class="im">as</span> np</span>
-<span id="cb139-10"><a href="#cb139-10" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb139-11"><a href="#cb139-11" aria-hidden="true" tabindex="-1"></a>GESAMT <span class="op">=</span> <span class="dv">3</span>          <span class="co"># zu verkaufende Einheiten</span></span>
-<span id="cb139-12"><a href="#cb139-12" aria-hidden="true" tabindex="-1"></a>PERIODEN <span class="op">=</span> <span class="dv">2</span>        <span class="co"># Anzahl Verkaufsperioden</span></span>
-<span id="cb139-13"><a href="#cb139-13" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb139-14"><a href="#cb139-14" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb139-15"><a href="#cb139-15" aria-hidden="true" tabindex="-1"></a><span class="kw">def</span> kosten(menge: <span class="bu">int</span>) <span class="op">-&gt;</span> <span class="bu">float</span>:</span>
-<span id="cb139-16"><a href="#cb139-16" aria-hidden="true" tabindex="-1"></a>    <span class="co">&quot;&quot;&quot;Ueberproportionale Marktauswirkung: doppelte Menge kostet vierfach.&quot;&quot;&quot;</span></span>
-<span id="cb139-17"><a href="#cb139-17" aria-hidden="true" tabindex="-1"></a>    <span class="cf">return</span> <span class="bu">float</span>(menge <span class="op">**</span> <span class="dv">2</span>)</span>
-<span id="cb139-18"><a href="#cb139-18" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb139-19"><a href="#cb139-19" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb139-20"><a href="#cb139-20" aria-hidden="true" tabindex="-1"></a><span class="kw">def</span> loese_rueckwaerts():</span>
-<span id="cb139-21"><a href="#cb139-21" aria-hidden="true" tabindex="-1"></a>    <span class="co"># V[t, x] = minimale Restkosten, wenn zu Beginn von Periode t noch x Stueck offen sind</span></span>
-<span id="cb139-22"><a href="#cb139-22" aria-hidden="true" tabindex="-1"></a>    V <span class="op">=</span> np.full((PERIODEN <span class="op">+</span> <span class="dv">1</span>, GESAMT <span class="op">+</span> <span class="dv">1</span>), np.inf)</span>
-<span id="cb139-23"><a href="#cb139-23" aria-hidden="true" tabindex="-1"></a>    politik <span class="op">=</span> np.zeros((PERIODEN, GESAMT <span class="op">+</span> <span class="dv">1</span>), dtype<span class="op">=</span><span class="bu">int</span>)</span>
-<span id="cb139-24"><a href="#cb139-24" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb139-25"><a href="#cb139-25" aria-hidden="true" tabindex="-1"></a>    <span class="co"># Endbedingung: nach der letzten Periode darf nichts mehr offen sein</span></span>
-<span id="cb139-26"><a href="#cb139-26" aria-hidden="true" tabindex="-1"></a>    V[PERIODEN, <span class="dv">0</span>] <span class="op">=</span> <span class="fl">0.0</span></span>
-<span id="cb139-27"><a href="#cb139-27" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb139-28"><a href="#cb139-28" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;=&quot;</span> <span class="op">*</span> <span class="dv">70</span>)</span>
-<span id="cb139-29"><a href="#cb139-29" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;  RUECKWAERTSINDUKTION SCHRITT FUER SCHRITT&quot;</span>)</span>
-<span id="cb139-30"><a href="#cb139-30" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;=&quot;</span> <span class="op">*</span> <span class="dv">70</span>)</span>
-<span id="cb139-31"><a href="#cb139-31" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb139-32"><a href="#cb139-32" aria-hidden="true" tabindex="-1"></a>    <span class="cf">for</span> t <span class="kw">in</span> <span class="bu">range</span>(PERIODEN <span class="op">-</span> <span class="dv">1</span>, <span class="op">-</span><span class="dv">1</span>, <span class="op">-</span><span class="dv">1</span>):</span>
-<span id="cb139-33"><a href="#cb139-33" aria-hidden="true" tabindex="-1"></a>        letzte_periode <span class="op">=</span> (t <span class="op">==</span> PERIODEN <span class="op">-</span> <span class="dv">1</span>)</span>
-<span id="cb139-34"><a href="#cb139-34" aria-hidden="true" tabindex="-1"></a>        <span class="bu">print</span>(<span class="ss">f&quot;</span><span class="ch">\n</span><span class="ss">Stufe t = </span><span class="sc">{</span>t<span class="sc">}</span><span class="ss">&quot;</span> <span class="op">+</span> (<span class="st">&quot;  (letzte Periode: alles muss weg)&quot;</span> <span class="cf">if</span> letzte_periode</span>
-<span id="cb139-35"><a href="#cb139-35" aria-hidden="true" tabindex="-1"></a>                                    <span class="cf">else</span> <span class="st">&quot;  (freie Wahl der Menge)&quot;</span>))</span>
-<span id="cb139-36"><a href="#cb139-36" aria-hidden="true" tabindex="-1"></a>        <span class="bu">print</span>(<span class="ss">f&quot;  </span><span class="sc">{</span><span class="st">&#39;Zustand x&#39;</span><span class="sc">:&gt;10}</span><span class="ss"> | </span><span class="sc">{</span><span class="st">&#39;beste Aktion&#39;</span><span class="sc">:&gt;12}</span><span class="ss"> | </span><span class="sc">{</span><span class="st">&#39;Sofortkosten&#39;</span><span class="sc">:&gt;13}</span><span class="ss"> | &quot;</span></span>
-<span id="cb139-37"><a href="#cb139-37" aria-hidden="true" tabindex="-1"></a>              <span class="ss">f&quot;</span><span class="sc">{</span><span class="st">&#39;V[t+1]&#39;</span><span class="sc">:&gt;9}</span><span class="ss"> | </span><span class="sc">{</span><span class="st">&#39;V[t]&#39;</span><span class="sc">:&gt;8}</span><span class="ss">&quot;</span>)</span>
-<span id="cb139-38"><a href="#cb139-38" aria-hidden="true" tabindex="-1"></a>        <span class="bu">print</span>(<span class="st">&quot;  &quot;</span> <span class="op">+</span> <span class="st">&quot;-&quot;</span> <span class="op">*</span> <span class="dv">62</span>)</span>
-<span id="cb139-39"><a href="#cb139-39" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb139-40"><a href="#cb139-40" aria-hidden="true" tabindex="-1"></a>        <span class="cf">for</span> x <span class="kw">in</span> <span class="bu">range</span>(GESAMT <span class="op">+</span> <span class="dv">1</span>):</span>
-<span id="cb139-41"><a href="#cb139-41" aria-hidden="true" tabindex="-1"></a>            aktionen <span class="op">=</span> [x] <span class="cf">if</span> letzte_periode <span class="cf">else</span> <span class="bu">range</span>(x <span class="op">+</span> <span class="dv">1</span>)</span>
-<span id="cb139-42"><a href="#cb139-42" aria-hidden="true" tabindex="-1"></a>            bester_wert, beste_aktion, beste_teile <span class="op">=</span> np.inf, <span class="dv">0</span>, (<span class="fl">0.0</span>, <span class="fl">0.0</span>)</span>
-<span id="cb139-43"><a href="#cb139-43" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb139-44"><a href="#cb139-44" aria-hidden="true" tabindex="-1"></a>            <span class="cf">for</span> n <span class="kw">in</span> aktionen:</span>
-<span id="cb139-45"><a href="#cb139-45" aria-hidden="true" tabindex="-1"></a>                rest <span class="op">=</span> x <span class="op">-</span> n</span>
-<span id="cb139-46"><a href="#cb139-46" aria-hidden="true" tabindex="-1"></a>                sofort <span class="op">=</span> kosten(n)</span>
-<span id="cb139-47"><a href="#cb139-47" aria-hidden="true" tabindex="-1"></a>                zukunft <span class="op">=</span> V[t <span class="op">+</span> <span class="dv">1</span>, rest]</span>
-<span id="cb139-48"><a href="#cb139-48" aria-hidden="true" tabindex="-1"></a>                gesamt <span class="op">=</span> sofort <span class="op">+</span> zukunft</span>
-<span id="cb139-49"><a href="#cb139-49" aria-hidden="true" tabindex="-1"></a>                <span class="cf">if</span> gesamt <span class="op">&lt;</span> bester_wert:</span>
-<span id="cb139-50"><a href="#cb139-50" aria-hidden="true" tabindex="-1"></a>                    bester_wert, beste_aktion <span class="op">=</span> gesamt, n</span>
-<span id="cb139-51"><a href="#cb139-51" aria-hidden="true" tabindex="-1"></a>                    beste_teile <span class="op">=</span> (sofort, zukunft)</span>
-<span id="cb139-52"><a href="#cb139-52" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb139-53"><a href="#cb139-53" aria-hidden="true" tabindex="-1"></a>            V[t, x] <span class="op">=</span> bester_wert</span>
-<span id="cb139-54"><a href="#cb139-54" aria-hidden="true" tabindex="-1"></a>            politik[t, x] <span class="op">=</span> beste_aktion</span>
-<span id="cb139-55"><a href="#cb139-55" aria-hidden="true" tabindex="-1"></a>            <span class="bu">print</span>(<span class="ss">f&quot;  </span><span class="sc">{</span>x<span class="sc">:&gt;10}</span><span class="ss"> | </span><span class="sc">{</span>beste_aktion<span class="sc">:&gt;12}</span><span class="ss"> | </span><span class="sc">{</span>beste_teile[<span class="dv">0</span>]<span class="sc">:&gt;13.1f}</span><span class="ss"> | &quot;</span></span>
-<span id="cb139-56"><a href="#cb139-56" aria-hidden="true" tabindex="-1"></a>                  <span class="ss">f&quot;</span><span class="sc">{</span>beste_teile[<span class="dv">1</span>]<span class="sc">:&gt;9.1f}</span><span class="ss"> | </span><span class="sc">{</span>bester_wert<span class="sc">:&gt;8.1f}</span><span class="ss">&quot;</span>)</span>
-<span id="cb139-57"><a href="#cb139-57" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb139-58"><a href="#cb139-58" aria-hidden="true" tabindex="-1"></a>    <span class="cf">return</span> V, politik</span>
-<span id="cb139-59"><a href="#cb139-59" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb139-60"><a href="#cb139-60" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb139-61"><a href="#cb139-61" aria-hidden="true" tabindex="-1"></a><span class="cf">if</span> <span class="va">__name__</span> <span class="op">==</span> <span class="st">&quot;__main__&quot;</span>:</span>
-<span id="cb139-62"><a href="#cb139-62" aria-hidden="true" tabindex="-1"></a>    V, politik <span class="op">=</span> loese_rueckwaerts()</span>
-<span id="cb139-63"><a href="#cb139-63" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb139-64"><a href="#cb139-64" aria-hidden="true" tabindex="-1"></a>    <span class="co"># --- Vorwaertspfad: der optimalen Politik folgen ---------------------</span></span>
-<span id="cb139-65"><a href="#cb139-65" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;</span><span class="ch">\n</span><span class="st">&quot;</span> <span class="op">+</span> <span class="st">&quot;=&quot;</span> <span class="op">*</span> <span class="dv">70</span>)</span>
-<span id="cb139-66"><a href="#cb139-66" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;  OPTIMALER PFAD (Vorwaertssimulation)&quot;</span>)</span>
-<span id="cb139-67"><a href="#cb139-67" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;=&quot;</span> <span class="op">*</span> <span class="dv">70</span>)</span>
-<span id="cb139-68"><a href="#cb139-68" aria-hidden="true" tabindex="-1"></a>    bestand <span class="op">=</span> GESAMT</span>
-<span id="cb139-69"><a href="#cb139-69" aria-hidden="true" tabindex="-1"></a>    gesamtkosten <span class="op">=</span> <span class="fl">0.0</span></span>
-<span id="cb139-70"><a href="#cb139-70" aria-hidden="true" tabindex="-1"></a>    <span class="cf">for</span> t <span class="kw">in</span> <span class="bu">range</span>(PERIODEN):</span>
-<span id="cb139-71"><a href="#cb139-71" aria-hidden="true" tabindex="-1"></a>        aktion <span class="op">=</span> politik[t, bestand]</span>
-<span id="cb139-72"><a href="#cb139-72" aria-hidden="true" tabindex="-1"></a>        gesamtkosten <span class="op">+=</span> kosten(aktion)</span>
-<span id="cb139-73"><a href="#cb139-73" aria-hidden="true" tabindex="-1"></a>        <span class="bu">print</span>(<span class="ss">f&quot;  Periode </span><span class="sc">{</span>t<span class="sc">}</span><span class="ss">: Bestand </span><span class="sc">{</span>bestand<span class="sc">}</span><span class="ss"> -&gt; verkaufe </span><span class="sc">{</span>aktion<span class="sc">}</span><span class="ss"> &quot;</span></span>
-<span id="cb139-74"><a href="#cb139-74" aria-hidden="true" tabindex="-1"></a>              <span class="ss">f&quot;(Kosten </span><span class="sc">{</span>kosten(aktion)<span class="sc">:.1f}</span><span class="ss">) -&gt; Rest </span><span class="sc">{</span>bestand <span class="op">-</span> aktion<span class="sc">}</span><span class="ss">&quot;</span>)</span>
-<span id="cb139-75"><a href="#cb139-75" aria-hidden="true" tabindex="-1"></a>        bestand <span class="op">-=</span> aktion</span>
-<span id="cb139-76"><a href="#cb139-76" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb139-77"><a href="#cb139-77" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;</span><span class="ch">\n</span><span class="ss">  Gesamtkosten: </span><span class="sc">{</span>gesamtkosten<span class="sc">:.1f}</span><span class="ss">  (V[0, </span><span class="sc">{</span>GESAMT<span class="sc">}</span><span class="ss">] = </span><span class="sc">{</span>V[<span class="dv">0</span>, GESAMT]<span class="sc">:.1f}</span><span class="ss">)&quot;</span>)</span>
-<span id="cb139-78"><a href="#cb139-78" aria-hidden="true" tabindex="-1"></a>    <span class="cf">assert</span> <span class="bu">abs</span>(gesamtkosten <span class="op">-</span> V[<span class="dv">0</span>, GESAMT]) <span class="op">&lt;</span> <span class="fl">1e-9</span>, <span class="st">&quot;Pfadkosten != Wertfunktion!&quot;</span></span>
-<span id="cb139-79"><a href="#cb139-79" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb139-80"><a href="#cb139-80" aria-hidden="true" tabindex="-1"></a>    <span class="co"># --- Vergleich mit naiven Strategien ---------------------------------</span></span>
-<span id="cb139-81"><a href="#cb139-81" aria-hidden="true" tabindex="-1"></a>    alles_sofort <span class="op">=</span> kosten(GESAMT)</span>
-<span id="cb139-82"><a href="#cb139-82" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;</span><span class="ch">\n</span><span class="ss">  Zum Vergleich - alles in Periode 0 verkaufen: </span><span class="sc">{</span>alles_sofort<span class="sc">:.1f}</span><span class="ss">&quot;</span>)</span>
-<span id="cb139-83"><a href="#cb139-83" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;  Ersparnis durch Stueckelung: </span><span class="sc">{</span>alles_sofort <span class="op">-</span> gesamtkosten<span class="sc">:.1f}</span><span class="ss"> &quot;</span></span>
-<span id="cb139-84"><a href="#cb139-84" aria-hidden="true" tabindex="-1"></a>          <span class="ss">f&quot;(</span><span class="sc">{</span>(<span class="dv">1</span> <span class="op">-</span> gesamtkosten<span class="op">/</span>alles_sofort)<span class="op">*</span><span class="dv">100</span><span class="sc">:.0f}</span><span class="ss"> %)&quot;</span>)</span>
-<span id="cb139-85"><a href="#cb139-85" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;=&quot;</span> <span class="op">*</span> <span class="dv">70</span>)</span></code></pre></div>
+<div class="sourceCode" id="cb141"><pre class="sourceCode python"><code class="sourceCode python"><span id="cb141-1"><a href="#cb141-1" aria-hidden="true" tabindex="-1"></a><span class="co">#!/usr/bin/env python3</span></span>
+<span id="cb141-2"><a href="#cb141-2" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb141-3"><a href="#cb141-3" aria-hidden="true" tabindex="-1"></a><span class="co"># Bellman_Minimalbeispiel.py</span></span>
+<span id="cb141-4"><a href="#cb141-4" aria-hidden="true" tabindex="-1"></a><span class="co">&quot;&quot;&quot;</span></span>
+<span id="cb141-5"><a href="#cb141-5" aria-hidden="true" tabindex="-1"></a><span class="co">Kapitel Dynamische Programmierung: Die Handrechnung zur Rueckwaertsinduktion als Code.</span></span>
+<span id="cb141-6"><a href="#cb141-6" aria-hidden="true" tabindex="-1"></a><span class="co">Zeigt die Wertfunktionstabelle und die optimale Politik Schritt fuer Schritt.</span></span>
+<span id="cb141-7"><a href="#cb141-7" aria-hidden="true" tabindex="-1"></a><span class="co">&quot;&quot;&quot;</span></span>
+<span id="cb141-8"><a href="#cb141-8" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb141-9"><a href="#cb141-9" aria-hidden="true" tabindex="-1"></a><span class="im">import</span> numpy <span class="im">as</span> np</span>
+<span id="cb141-10"><a href="#cb141-10" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb141-11"><a href="#cb141-11" aria-hidden="true" tabindex="-1"></a>GESAMT <span class="op">=</span> <span class="dv">3</span>          <span class="co"># zu verkaufende Einheiten</span></span>
+<span id="cb141-12"><a href="#cb141-12" aria-hidden="true" tabindex="-1"></a>PERIODEN <span class="op">=</span> <span class="dv">2</span>        <span class="co"># Anzahl Verkaufsperioden</span></span>
+<span id="cb141-13"><a href="#cb141-13" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb141-14"><a href="#cb141-14" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb141-15"><a href="#cb141-15" aria-hidden="true" tabindex="-1"></a><span class="kw">def</span> kosten(menge: <span class="bu">int</span>) <span class="op">-&gt;</span> <span class="bu">float</span>:</span>
+<span id="cb141-16"><a href="#cb141-16" aria-hidden="true" tabindex="-1"></a>    <span class="co">&quot;&quot;&quot;Ueberproportionale Marktauswirkung: doppelte Menge kostet vierfach.&quot;&quot;&quot;</span></span>
+<span id="cb141-17"><a href="#cb141-17" aria-hidden="true" tabindex="-1"></a>    <span class="cf">return</span> <span class="bu">float</span>(menge <span class="op">**</span> <span class="dv">2</span>)</span>
+<span id="cb141-18"><a href="#cb141-18" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb141-19"><a href="#cb141-19" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb141-20"><a href="#cb141-20" aria-hidden="true" tabindex="-1"></a><span class="kw">def</span> loese_rueckwaerts():</span>
+<span id="cb141-21"><a href="#cb141-21" aria-hidden="true" tabindex="-1"></a>    <span class="co"># V[t, x] = minimale Restkosten, wenn zu Beginn von Periode t noch x Stueck offen sind</span></span>
+<span id="cb141-22"><a href="#cb141-22" aria-hidden="true" tabindex="-1"></a>    V <span class="op">=</span> np.full((PERIODEN <span class="op">+</span> <span class="dv">1</span>, GESAMT <span class="op">+</span> <span class="dv">1</span>), np.inf)</span>
+<span id="cb141-23"><a href="#cb141-23" aria-hidden="true" tabindex="-1"></a>    politik <span class="op">=</span> np.zeros((PERIODEN, GESAMT <span class="op">+</span> <span class="dv">1</span>), dtype<span class="op">=</span><span class="bu">int</span>)</span>
+<span id="cb141-24"><a href="#cb141-24" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb141-25"><a href="#cb141-25" aria-hidden="true" tabindex="-1"></a>    <span class="co"># Endbedingung: nach der letzten Periode darf nichts mehr offen sein</span></span>
+<span id="cb141-26"><a href="#cb141-26" aria-hidden="true" tabindex="-1"></a>    V[PERIODEN, <span class="dv">0</span>] <span class="op">=</span> <span class="fl">0.0</span></span>
+<span id="cb141-27"><a href="#cb141-27" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb141-28"><a href="#cb141-28" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;=&quot;</span> <span class="op">*</span> <span class="dv">70</span>)</span>
+<span id="cb141-29"><a href="#cb141-29" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;  RUECKWAERTSINDUKTION SCHRITT FUER SCHRITT&quot;</span>)</span>
+<span id="cb141-30"><a href="#cb141-30" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;=&quot;</span> <span class="op">*</span> <span class="dv">70</span>)</span>
+<span id="cb141-31"><a href="#cb141-31" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb141-32"><a href="#cb141-32" aria-hidden="true" tabindex="-1"></a>    <span class="cf">for</span> t <span class="kw">in</span> <span class="bu">range</span>(PERIODEN <span class="op">-</span> <span class="dv">1</span>, <span class="op">-</span><span class="dv">1</span>, <span class="op">-</span><span class="dv">1</span>):</span>
+<span id="cb141-33"><a href="#cb141-33" aria-hidden="true" tabindex="-1"></a>        letzte_periode <span class="op">=</span> (t <span class="op">==</span> PERIODEN <span class="op">-</span> <span class="dv">1</span>)</span>
+<span id="cb141-34"><a href="#cb141-34" aria-hidden="true" tabindex="-1"></a>        <span class="bu">print</span>(<span class="ss">f&quot;</span><span class="ch">\n</span><span class="ss">Stufe t = </span><span class="sc">{</span>t<span class="sc">}</span><span class="ss">&quot;</span> <span class="op">+</span> (<span class="st">&quot;  (letzte Periode: alles muss weg)&quot;</span> <span class="cf">if</span> letzte_periode</span>
+<span id="cb141-35"><a href="#cb141-35" aria-hidden="true" tabindex="-1"></a>                                    <span class="cf">else</span> <span class="st">&quot;  (freie Wahl der Menge)&quot;</span>))</span>
+<span id="cb141-36"><a href="#cb141-36" aria-hidden="true" tabindex="-1"></a>        <span class="bu">print</span>(<span class="ss">f&quot;  </span><span class="sc">{</span><span class="st">&#39;Zustand x&#39;</span><span class="sc">:&gt;10}</span><span class="ss"> | </span><span class="sc">{</span><span class="st">&#39;beste Aktion&#39;</span><span class="sc">:&gt;12}</span><span class="ss"> | </span><span class="sc">{</span><span class="st">&#39;Sofortkosten&#39;</span><span class="sc">:&gt;13}</span><span class="ss"> | &quot;</span></span>
+<span id="cb141-37"><a href="#cb141-37" aria-hidden="true" tabindex="-1"></a>              <span class="ss">f&quot;</span><span class="sc">{</span><span class="st">&#39;V[t+1]&#39;</span><span class="sc">:&gt;9}</span><span class="ss"> | </span><span class="sc">{</span><span class="st">&#39;V[t]&#39;</span><span class="sc">:&gt;8}</span><span class="ss">&quot;</span>)</span>
+<span id="cb141-38"><a href="#cb141-38" aria-hidden="true" tabindex="-1"></a>        <span class="bu">print</span>(<span class="st">&quot;  &quot;</span> <span class="op">+</span> <span class="st">&quot;-&quot;</span> <span class="op">*</span> <span class="dv">62</span>)</span>
+<span id="cb141-39"><a href="#cb141-39" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb141-40"><a href="#cb141-40" aria-hidden="true" tabindex="-1"></a>        <span class="cf">for</span> x <span class="kw">in</span> <span class="bu">range</span>(GESAMT <span class="op">+</span> <span class="dv">1</span>):</span>
+<span id="cb141-41"><a href="#cb141-41" aria-hidden="true" tabindex="-1"></a>            aktionen <span class="op">=</span> [x] <span class="cf">if</span> letzte_periode <span class="cf">else</span> <span class="bu">range</span>(x <span class="op">+</span> <span class="dv">1</span>)</span>
+<span id="cb141-42"><a href="#cb141-42" aria-hidden="true" tabindex="-1"></a>            bester_wert, beste_aktion, beste_teile <span class="op">=</span> np.inf, <span class="dv">0</span>, (<span class="fl">0.0</span>, <span class="fl">0.0</span>)</span>
+<span id="cb141-43"><a href="#cb141-43" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb141-44"><a href="#cb141-44" aria-hidden="true" tabindex="-1"></a>            <span class="cf">for</span> n <span class="kw">in</span> aktionen:</span>
+<span id="cb141-45"><a href="#cb141-45" aria-hidden="true" tabindex="-1"></a>                rest <span class="op">=</span> x <span class="op">-</span> n</span>
+<span id="cb141-46"><a href="#cb141-46" aria-hidden="true" tabindex="-1"></a>                sofort <span class="op">=</span> kosten(n)</span>
+<span id="cb141-47"><a href="#cb141-47" aria-hidden="true" tabindex="-1"></a>                zukunft <span class="op">=</span> V[t <span class="op">+</span> <span class="dv">1</span>, rest]</span>
+<span id="cb141-48"><a href="#cb141-48" aria-hidden="true" tabindex="-1"></a>                gesamt <span class="op">=</span> sofort <span class="op">+</span> zukunft</span>
+<span id="cb141-49"><a href="#cb141-49" aria-hidden="true" tabindex="-1"></a>                <span class="cf">if</span> gesamt <span class="op">&lt;</span> bester_wert:</span>
+<span id="cb141-50"><a href="#cb141-50" aria-hidden="true" tabindex="-1"></a>                    bester_wert, beste_aktion <span class="op">=</span> gesamt, n</span>
+<span id="cb141-51"><a href="#cb141-51" aria-hidden="true" tabindex="-1"></a>                    beste_teile <span class="op">=</span> (sofort, zukunft)</span>
+<span id="cb141-52"><a href="#cb141-52" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb141-53"><a href="#cb141-53" aria-hidden="true" tabindex="-1"></a>            V[t, x] <span class="op">=</span> bester_wert</span>
+<span id="cb141-54"><a href="#cb141-54" aria-hidden="true" tabindex="-1"></a>            politik[t, x] <span class="op">=</span> beste_aktion</span>
+<span id="cb141-55"><a href="#cb141-55" aria-hidden="true" tabindex="-1"></a>            <span class="bu">print</span>(<span class="ss">f&quot;  </span><span class="sc">{</span>x<span class="sc">:&gt;10}</span><span class="ss"> | </span><span class="sc">{</span>beste_aktion<span class="sc">:&gt;12}</span><span class="ss"> | </span><span class="sc">{</span>beste_teile[<span class="dv">0</span>]<span class="sc">:&gt;13.1f}</span><span class="ss"> | &quot;</span></span>
+<span id="cb141-56"><a href="#cb141-56" aria-hidden="true" tabindex="-1"></a>                  <span class="ss">f&quot;</span><span class="sc">{</span>beste_teile[<span class="dv">1</span>]<span class="sc">:&gt;9.1f}</span><span class="ss"> | </span><span class="sc">{</span>bester_wert<span class="sc">:&gt;8.1f}</span><span class="ss">&quot;</span>)</span>
+<span id="cb141-57"><a href="#cb141-57" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb141-58"><a href="#cb141-58" aria-hidden="true" tabindex="-1"></a>    <span class="cf">return</span> V, politik</span>
+<span id="cb141-59"><a href="#cb141-59" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb141-60"><a href="#cb141-60" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb141-61"><a href="#cb141-61" aria-hidden="true" tabindex="-1"></a><span class="cf">if</span> <span class="va">__name__</span> <span class="op">==</span> <span class="st">&quot;__main__&quot;</span>:</span>
+<span id="cb141-62"><a href="#cb141-62" aria-hidden="true" tabindex="-1"></a>    V, politik <span class="op">=</span> loese_rueckwaerts()</span>
+<span id="cb141-63"><a href="#cb141-63" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb141-64"><a href="#cb141-64" aria-hidden="true" tabindex="-1"></a>    <span class="co"># --- Vorwaertspfad: der optimalen Politik folgen ---------------------</span></span>
+<span id="cb141-65"><a href="#cb141-65" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;</span><span class="ch">\n</span><span class="st">&quot;</span> <span class="op">+</span> <span class="st">&quot;=&quot;</span> <span class="op">*</span> <span class="dv">70</span>)</span>
+<span id="cb141-66"><a href="#cb141-66" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;  OPTIMALER PFAD (Vorwaertssimulation)&quot;</span>)</span>
+<span id="cb141-67"><a href="#cb141-67" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;=&quot;</span> <span class="op">*</span> <span class="dv">70</span>)</span>
+<span id="cb141-68"><a href="#cb141-68" aria-hidden="true" tabindex="-1"></a>    bestand <span class="op">=</span> GESAMT</span>
+<span id="cb141-69"><a href="#cb141-69" aria-hidden="true" tabindex="-1"></a>    gesamtkosten <span class="op">=</span> <span class="fl">0.0</span></span>
+<span id="cb141-70"><a href="#cb141-70" aria-hidden="true" tabindex="-1"></a>    <span class="cf">for</span> t <span class="kw">in</span> <span class="bu">range</span>(PERIODEN):</span>
+<span id="cb141-71"><a href="#cb141-71" aria-hidden="true" tabindex="-1"></a>        aktion <span class="op">=</span> politik[t, bestand]</span>
+<span id="cb141-72"><a href="#cb141-72" aria-hidden="true" tabindex="-1"></a>        gesamtkosten <span class="op">+=</span> kosten(aktion)</span>
+<span id="cb141-73"><a href="#cb141-73" aria-hidden="true" tabindex="-1"></a>        <span class="bu">print</span>(<span class="ss">f&quot;  Periode </span><span class="sc">{</span>t<span class="sc">}</span><span class="ss">: Bestand </span><span class="sc">{</span>bestand<span class="sc">}</span><span class="ss"> -&gt; verkaufe </span><span class="sc">{</span>aktion<span class="sc">}</span><span class="ss"> &quot;</span></span>
+<span id="cb141-74"><a href="#cb141-74" aria-hidden="true" tabindex="-1"></a>              <span class="ss">f&quot;(Kosten </span><span class="sc">{</span>kosten(aktion)<span class="sc">:.1f}</span><span class="ss">) -&gt; Rest </span><span class="sc">{</span>bestand <span class="op">-</span> aktion<span class="sc">}</span><span class="ss">&quot;</span>)</span>
+<span id="cb141-75"><a href="#cb141-75" aria-hidden="true" tabindex="-1"></a>        bestand <span class="op">-=</span> aktion</span>
+<span id="cb141-76"><a href="#cb141-76" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb141-77"><a href="#cb141-77" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;</span><span class="ch">\n</span><span class="ss">  Gesamtkosten: </span><span class="sc">{</span>gesamtkosten<span class="sc">:.1f}</span><span class="ss">  (V[0, </span><span class="sc">{</span>GESAMT<span class="sc">}</span><span class="ss">] = </span><span class="sc">{</span>V[<span class="dv">0</span>, GESAMT]<span class="sc">:.1f}</span><span class="ss">)&quot;</span>)</span>
+<span id="cb141-78"><a href="#cb141-78" aria-hidden="true" tabindex="-1"></a>    <span class="cf">assert</span> <span class="bu">abs</span>(gesamtkosten <span class="op">-</span> V[<span class="dv">0</span>, GESAMT]) <span class="op">&lt;</span> <span class="fl">1e-9</span>, <span class="st">&quot;Pfadkosten != Wertfunktion!&quot;</span></span>
+<span id="cb141-79"><a href="#cb141-79" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb141-80"><a href="#cb141-80" aria-hidden="true" tabindex="-1"></a>    <span class="co"># --- Vergleich mit naiven Strategien ---------------------------------</span></span>
+<span id="cb141-81"><a href="#cb141-81" aria-hidden="true" tabindex="-1"></a>    alles_sofort <span class="op">=</span> kosten(GESAMT)</span>
+<span id="cb141-82"><a href="#cb141-82" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;</span><span class="ch">\n</span><span class="ss">  Zum Vergleich - alles in Periode 0 verkaufen: </span><span class="sc">{</span>alles_sofort<span class="sc">:.1f}</span><span class="ss">&quot;</span>)</span>
+<span id="cb141-83"><a href="#cb141-83" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;  Ersparnis durch Stueckelung: </span><span class="sc">{</span>alles_sofort <span class="op">-</span> gesamtkosten<span class="sc">:.1f}</span><span class="ss"> &quot;</span></span>
+<span id="cb141-84"><a href="#cb141-84" aria-hidden="true" tabindex="-1"></a>          <span class="ss">f&quot;(</span><span class="sc">{</span>(<span class="dv">1</span> <span class="op">-</span> gesamtkosten<span class="op">/</span>alles_sofort)<span class="op">*</span><span class="dv">100</span><span class="sc">:.0f}</span><span class="ss"> %)&quot;</span>)</span>
+<span id="cb141-85"><a href="#cb141-85" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;=&quot;</span> <span class="op">*</span> <span class="dv">70</span>)</span></code></pre></div>
 <hr />
 <h2 id="sec:dynamische-programmierung-das-almgren-chriss-problem-optimale-orderausfuehrung">13.4 Das Almgren-Chriss-Problem: optimale Orderausführung</h2>
 <p>Ein klassisches OR-Problem an Börsen: Ein institutioneller Händler muss <span class="math inline">X_0 = 100\,000</span> Aktien innerhalb von <span class="math inline">T</span> Handelsperioden verkaufen.</p>
@@ -17995,222 +18860,222 @@ C(n_t, X_t) = \underbrace{\eta\,n_t^2}_{\text{Marktauswirkung}} \;+\; \underbrac
 <blockquote>
 <p><strong>⚠️ Zur Kalibrierung des Risikoparameters</strong></p>
 <p>Ein häufiger Fehler ist ein undokumentierter Skalierungsfaktor im Risikoterm, etwa:</p>
-<div class="sourceCode" id="cb140"><pre class="sourceCode python"><code class="sourceCode python"><span id="cb140-1"><a href="#cb140-1" aria-hidden="true" tabindex="-1"></a>holding_risk <span class="op">=</span> risk_aversion <span class="op">*</span> (sigma_period <span class="op">**</span> <span class="dv">2</span>) <span class="op">*</span> (remaining <span class="op">**</span> <span class="dv">2</span>) <span class="op">*</span> <span class="fl">1e5</span></span></code></pre></div>
+<div class="sourceCode" id="cb142"><pre class="sourceCode python"><code class="sourceCode python"><span id="cb142-1"><a href="#cb142-1" aria-hidden="true" tabindex="-1"></a>holding_risk <span class="op">=</span> risk_aversion <span class="op">*</span> (sigma_period <span class="op">**</span> <span class="dv">2</span>) <span class="op">*</span> (remaining <span class="op">**</span> <span class="dv">2</span>) <span class="op">*</span> <span class="fl">1e5</span></span></code></pre></div>
 <p>Woher eine solche Zahl kommt, bleibt dann unklar. Faktisch wirkt sie als versteckte Erhöhung der Risikoaversion um fünf Größenordnungen — ein Parameter wie <code>risk_aversion = 1e-6</code> würde dann in Wahrheit <span class="math inline">0{,}1</span> bedeuten. Solche „magischen Zahlen“ machen ein Modell unkalibrierbar: Niemand kann sagen, ob 1e-6 viel oder wenig ist.</p>
 <p><strong>Der Parameter lässt sich stattdessen herleiten.</strong> Beide Kostenterme werden in <strong>Euro</strong> gerechnet: * Marktauswirkung: <span class="math inline">\eta \cdot n_t^2</span> mit <span class="math inline">\eta</span> in €/Stück². * Risiko: <span class="math inline">\tfrac{\lambda}{2}\cdot \sigma_{\text{Periode}}^2 \cdot P_0^2 \cdot X_t^2</span> — die Varianz des Werts der offenen Position, multipliziert mit der Risikoaversion.</p>
 <p>Durch die Multiplikation mit <span class="math inline">P_0^2</span> (dem Quadrat des Aktienkurses) stimmen die Einheiten, und <span class="math inline">\lambda</span> wird interpretierbar: Es ist der Preis, den man je Einheit Wertvarianz zu zahlen bereit ist.</p>
 </blockquote>
-<div class="sourceCode" id="cb141"><pre class="sourceCode python"><code class="sourceCode python"><span id="cb141-1"><a href="#cb141-1" aria-hidden="true" tabindex="-1"></a><span class="co">#!/usr/bin/env python3</span></span>
-<span id="cb141-2"><a href="#cb141-2" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb141-3"><a href="#cb141-3" aria-hidden="true" tabindex="-1"></a><span class="co"># Mehrperiodige_Order_Execution.py</span></span>
-<span id="cb141-4"><a href="#cb141-4" aria-hidden="true" tabindex="-1"></a><span class="co">&quot;&quot;&quot;</span></span>
-<span id="cb141-5"><a href="#cb141-5" aria-hidden="true" tabindex="-1"></a><span class="co">Kapitel Dynamische Programmierung: Dynamische Programmierung fuer optimale Orderausfuehrung</span></span>
-<span id="cb141-6"><a href="#cb141-6" aria-hidden="true" tabindex="-1"></a><span class="co">(Almgren-Chriss-Rahmen, geloest per Rueckwaertsinduktion).</span></span>
-<span id="cb141-7"><a href="#cb141-7" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb141-8"><a href="#cb141-8" aria-hidden="true" tabindex="-1"></a><span class="co">Eigenschaften:</span></span>
-<span id="cb141-9"><a href="#cb141-9" aria-hidden="true" tabindex="-1"></a><span class="co">  * Risikoterm sauber hergeleitet ueber den Aktienkurs P0 (Einheiten: EUR),</span></span>
-<span id="cb141-10"><a href="#cb141-10" aria-hidden="true" tabindex="-1"></a><span class="co">    ohne undokumentierte Skalierungsfaktoren</span></span>
-<span id="cb141-11"><a href="#cb141-11" aria-hidden="true" tabindex="-1"></a><span class="co">  * Vergleich mit der analytischen Almgren-Chriss-Loesung</span></span>
-<span id="cb141-12"><a href="#cb141-12" aria-hidden="true" tabindex="-1"></a><span class="co">  * Vergleich mit naiven Strategien (alles sofort / gleichmaessig)</span></span>
-<span id="cb141-13"><a href="#cb141-13" aria-hidden="true" tabindex="-1"></a><span class="co">  * Sensitivitaet gegenueber der Risikoaversion</span></span>
-<span id="cb141-14"><a href="#cb141-14" aria-hidden="true" tabindex="-1"></a><span class="co">&quot;&quot;&quot;</span></span>
-<span id="cb141-15"><a href="#cb141-15" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb141-16"><a href="#cb141-16" aria-hidden="true" tabindex="-1"></a><span class="im">import</span> os</span>
-<span id="cb141-17"><a href="#cb141-17" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb141-18"><a href="#cb141-18" aria-hidden="true" tabindex="-1"></a><span class="im">import</span> numpy <span class="im">as</span> np</span>
-<span id="cb141-19"><a href="#cb141-19" aria-hidden="true" tabindex="-1"></a><span class="im">import</span> pandas <span class="im">as</span> pd</span>
-<span id="cb141-20"><a href="#cb141-20" aria-hidden="true" tabindex="-1"></a><span class="im">import</span> matplotlib</span>
-<span id="cb141-21"><a href="#cb141-21" aria-hidden="true" tabindex="-1"></a>matplotlib.use(<span class="st">&quot;Agg&quot;</span>)</span>
-<span id="cb141-22"><a href="#cb141-22" aria-hidden="true" tabindex="-1"></a><span class="im">import</span> matplotlib.pyplot <span class="im">as</span> plt</span>
-<span id="cb141-23"><a href="#cb141-23" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb141-24"><a href="#cb141-24" aria-hidden="true" tabindex="-1"></a>OUTPUT_DIR <span class="op">=</span> os.path.join(os.path.dirname(os.path.abspath(<span class="va">__file__</span>)), <span class="st">&quot;output&quot;</span>)</span>
-<span id="cb141-25"><a href="#cb141-25" aria-hidden="true" tabindex="-1"></a>os.makedirs(OUTPUT_DIR, exist_ok<span class="op">=</span><span class="va">True</span>)</span>
-<span id="cb141-26"><a href="#cb141-26" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb141-27"><a href="#cb141-27" aria-hidden="true" tabindex="-1"></a><span class="co"># --- Parameter -------------------------------------------------------------</span></span>
-<span id="cb141-28"><a href="#cb141-28" aria-hidden="true" tabindex="-1"></a>GESAMTBESTAND <span class="op">=</span> <span class="dv">100_000</span>        <span class="co"># X_0, zu verkaufende Aktien</span></span>
-<span id="cb141-29"><a href="#cb141-29" aria-hidden="true" tabindex="-1"></a>PERIODEN <span class="op">=</span> <span class="dv">5</span>                   <span class="co"># T Handelsperioden</span></span>
-<span id="cb141-30"><a href="#cb141-30" aria-hidden="true" tabindex="-1"></a>KURS <span class="op">=</span> <span class="fl">50.0</span>                    <span class="co"># P_0 in EUR, zur Skalierung des Risikoterms</span></span>
-<span id="cb141-31"><a href="#cb141-31" aria-hidden="true" tabindex="-1"></a>ETA <span class="op">=</span> <span class="fl">2.5e-6</span>                   <span class="co"># EUR je Stueck^2 (Slippage-Koeffizient)</span></span>
-<span id="cb141-32"><a href="#cb141-32" aria-hidden="true" tabindex="-1"></a>VOLA_JAHR <span class="op">=</span> <span class="fl">0.30</span>               <span class="co"># 30 % p.a.</span></span>
-<span id="cb141-33"><a href="#cb141-33" aria-hidden="true" tabindex="-1"></a>HANDELSSTUNDEN_JAHR <span class="op">=</span> <span class="dv">252</span> <span class="op">*</span> <span class="fl">6.5</span></span>
-<span id="cb141-34"><a href="#cb141-34" aria-hidden="true" tabindex="-1"></a>RISIKOAVERSION <span class="op">=</span> <span class="fl">1e-5</span>          <span class="co"># 1/EUR; kalibriert, siehe Kommentar unten</span></span>
-<span id="cb141-35"><a href="#cb141-35" aria-hidden="true" tabindex="-1"></a>SCHRITTWEITE <span class="op">=</span> <span class="dv">1000</span>            <span class="co"># Diskretisierung des Zustandsraums</span></span>
-<span id="cb141-36"><a href="#cb141-36" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb141-37"><a href="#cb141-37" aria-hidden="true" tabindex="-1"></a><span class="co"># Kalibrierungshinweis: Die dimensionslose Kennzahl des Modells ist</span></span>
-<span id="cb141-38"><a href="#cb141-38" aria-hidden="true" tabindex="-1"></a><span class="co">#     kappa_tilde^2 = lambda * sigma_periode^2 * P0^2 / eta</span></span>
-<span id="cb141-39"><a href="#cb141-39" aria-hidden="true" tabindex="-1"></a><span class="co"># Sie entscheidet ueber den Charakter der Loesung:</span></span>
-<span id="cb141-40"><a href="#cb141-40" aria-hidden="true" tabindex="-1"></a><span class="co">#     &lt;&lt; 1  -&gt; praktisch gleichmaessige Aufteilung (Risiko spielt keine Rolle)</span></span>
-<span id="cb141-41"><a href="#cb141-41" aria-hidden="true" tabindex="-1"></a><span class="co">#     ~  1  -&gt; ausgewogener Kompromiss  &lt;- hier: 0.55</span></span>
-<span id="cb141-42"><a href="#cb141-42" aria-hidden="true" tabindex="-1"></a><span class="co">#     &gt;&gt; 1  -&gt; fast alles sofort verkaufen</span></span>
-<span id="cb141-43"><a href="#cb141-43" aria-hidden="true" tabindex="-1"></a><span class="co"># Genau diese Interpretierbarkeit geht mit einem undokumentierten</span></span>
-<span id="cb141-44"><a href="#cb141-44" aria-hidden="true" tabindex="-1"></a><span class="co"># Skalierungsfaktor verloren.</span></span>
-<span id="cb141-45"><a href="#cb141-45" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb141-46"><a href="#cb141-46" aria-hidden="true" tabindex="-1"></a>VOLA_PERIODE <span class="op">=</span> VOLA_JAHR <span class="op">/</span> np.sqrt(HANDELSSTUNDEN_JAHR)</span>
-<span id="cb141-47"><a href="#cb141-47" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb141-48"><a href="#cb141-48" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb141-49"><a href="#cb141-49" aria-hidden="true" tabindex="-1"></a><span class="kw">def</span> periodenkosten(verkauf: <span class="bu">float</span>, restbestand: <span class="bu">float</span>) <span class="op">-&gt;</span> <span class="bu">float</span>:</span>
-<span id="cb141-50"><a href="#cb141-50" aria-hidden="true" tabindex="-1"></a>    <span class="co">&quot;&quot;&quot;</span></span>
-<span id="cb141-51"><a href="#cb141-51" aria-hidden="true" tabindex="-1"></a><span class="co">    Sofortkosten einer Periode in EUR:</span></span>
-<span id="cb141-52"><a href="#cb141-52" aria-hidden="true" tabindex="-1"></a><span class="co">      (1) Marktauswirkung: eta * n^2</span></span>
-<span id="cb141-53"><a href="#cb141-53" aria-hidden="true" tabindex="-1"></a><span class="co">      (2) Risiko des Restbestands: lambda/2 * sigma^2 * P0^2 * X^2</span></span>
-<span id="cb141-54"><a href="#cb141-54" aria-hidden="true" tabindex="-1"></a><span class="co">          -&gt; P0^2 macht aus &quot;Stueck^2&quot; einen EUR^2-Wert; lambda hat damit</span></span>
-<span id="cb141-55"><a href="#cb141-55" aria-hidden="true" tabindex="-1"></a><span class="co">             die Einheit 1/EUR und ist interpretierbar.</span></span>
-<span id="cb141-56"><a href="#cb141-56" aria-hidden="true" tabindex="-1"></a><span class="co">    &quot;&quot;&quot;</span></span>
-<span id="cb141-57"><a href="#cb141-57" aria-hidden="true" tabindex="-1"></a>    marktauswirkung <span class="op">=</span> ETA <span class="op">*</span> verkauf <span class="op">**</span> <span class="dv">2</span></span>
-<span id="cb141-58"><a href="#cb141-58" aria-hidden="true" tabindex="-1"></a>    wertvarianz <span class="op">=</span> (VOLA_PERIODE <span class="op">**</span> <span class="dv">2</span>) <span class="op">*</span> (KURS <span class="op">**</span> <span class="dv">2</span>) <span class="op">*</span> (restbestand <span class="op">**</span> <span class="dv">2</span>)</span>
-<span id="cb141-59"><a href="#cb141-59" aria-hidden="true" tabindex="-1"></a>    risiko <span class="op">=</span> <span class="fl">0.5</span> <span class="op">*</span> RISIKOAVERSION <span class="op">*</span> wertvarianz</span>
-<span id="cb141-60"><a href="#cb141-60" aria-hidden="true" tabindex="-1"></a>    <span class="cf">return</span> marktauswirkung <span class="op">+</span> risiko</span>
-<span id="cb141-61"><a href="#cb141-61" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb141-62"><a href="#cb141-62" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb141-63"><a href="#cb141-63" aria-hidden="true" tabindex="-1"></a><span class="kw">def</span> loese_dp():</span>
-<span id="cb141-64"><a href="#cb141-64" aria-hidden="true" tabindex="-1"></a>    <span class="co">&quot;&quot;&quot;Rueckwaertsinduktion ueber den diskretisierten Zustandsraum.&quot;&quot;&quot;</span></span>
-<span id="cb141-65"><a href="#cb141-65" aria-hidden="true" tabindex="-1"></a>    zustaende <span class="op">=</span> np.arange(<span class="dv">0</span>, GESAMTBESTAND <span class="op">+</span> SCHRITTWEITE, SCHRITTWEITE)</span>
-<span id="cb141-66"><a href="#cb141-66" aria-hidden="true" tabindex="-1"></a>    anzahl <span class="op">=</span> <span class="bu">len</span>(zustaende)</span>
-<span id="cb141-67"><a href="#cb141-67" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb141-68"><a href="#cb141-68" aria-hidden="true" tabindex="-1"></a>    V <span class="op">=</span> np.full((PERIODEN <span class="op">+</span> <span class="dv">1</span>, anzahl), np.inf)</span>
-<span id="cb141-69"><a href="#cb141-69" aria-hidden="true" tabindex="-1"></a>    politik <span class="op">=</span> np.zeros((PERIODEN, anzahl), dtype<span class="op">=</span><span class="bu">int</span>)</span>
-<span id="cb141-70"><a href="#cb141-70" aria-hidden="true" tabindex="-1"></a>    V[PERIODEN, <span class="dv">0</span>] <span class="op">=</span> <span class="fl">0.0</span>                     <span class="co"># am Ende muss alles verkauft sein</span></span>
-<span id="cb141-71"><a href="#cb141-71" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb141-72"><a href="#cb141-72" aria-hidden="true" tabindex="-1"></a>    <span class="cf">for</span> t <span class="kw">in</span> <span class="bu">range</span>(PERIODEN <span class="op">-</span> <span class="dv">1</span>, <span class="op">-</span><span class="dv">1</span>, <span class="op">-</span><span class="dv">1</span>):</span>
-<span id="cb141-73"><a href="#cb141-73" aria-hidden="true" tabindex="-1"></a>        <span class="cf">for</span> idx, bestand <span class="kw">in</span> <span class="bu">enumerate</span>(zustaende):</span>
-<span id="cb141-74"><a href="#cb141-74" aria-hidden="true" tabindex="-1"></a>            <span class="cf">if</span> t <span class="op">==</span> PERIODEN <span class="op">-</span> <span class="dv">1</span>:</span>
-<span id="cb141-75"><a href="#cb141-75" aria-hidden="true" tabindex="-1"></a>                moegliche <span class="op">=</span> [bestand]        <span class="co"># letzte Periode: Rest muss weg</span></span>
-<span id="cb141-76"><a href="#cb141-76" aria-hidden="true" tabindex="-1"></a>            <span class="cf">else</span>:</span>
-<span id="cb141-77"><a href="#cb141-77" aria-hidden="true" tabindex="-1"></a>                moegliche <span class="op">=</span> zustaende[zustaende <span class="op">&lt;=</span> bestand]</span>
-<span id="cb141-78"><a href="#cb141-78" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb141-79"><a href="#cb141-79" aria-hidden="true" tabindex="-1"></a>            bester_wert, beste_aktion <span class="op">=</span> np.inf, <span class="dv">0</span></span>
-<span id="cb141-80"><a href="#cb141-80" aria-hidden="true" tabindex="-1"></a>            <span class="cf">for</span> verkauf <span class="kw">in</span> moegliche:</span>
-<span id="cb141-81"><a href="#cb141-81" aria-hidden="true" tabindex="-1"></a>                rest <span class="op">=</span> bestand <span class="op">-</span> verkauf</span>
-<span id="cb141-82"><a href="#cb141-82" aria-hidden="true" tabindex="-1"></a>                rest_idx <span class="op">=</span> <span class="bu">int</span>(<span class="bu">round</span>(rest <span class="op">/</span> SCHRITTWEITE))</span>
-<span id="cb141-83"><a href="#cb141-83" aria-hidden="true" tabindex="-1"></a>                gesamt <span class="op">=</span> periodenkosten(verkauf, rest) <span class="op">+</span> V[t <span class="op">+</span> <span class="dv">1</span>, rest_idx]</span>
-<span id="cb141-84"><a href="#cb141-84" aria-hidden="true" tabindex="-1"></a>                <span class="cf">if</span> gesamt <span class="op">&lt;</span> bester_wert:</span>
-<span id="cb141-85"><a href="#cb141-85" aria-hidden="true" tabindex="-1"></a>                    bester_wert, beste_aktion <span class="op">=</span> gesamt, <span class="bu">int</span>(verkauf)</span>
-<span id="cb141-86"><a href="#cb141-86" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb141-87"><a href="#cb141-87" aria-hidden="true" tabindex="-1"></a>            V[t, idx] <span class="op">=</span> bester_wert</span>
-<span id="cb141-88"><a href="#cb141-88" aria-hidden="true" tabindex="-1"></a>            politik[t, idx] <span class="op">=</span> beste_aktion</span>
-<span id="cb141-89"><a href="#cb141-89" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb141-90"><a href="#cb141-90" aria-hidden="true" tabindex="-1"></a>    <span class="cf">return</span> zustaende, V, politik</span>
-<span id="cb141-91"><a href="#cb141-91" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb141-92"><a href="#cb141-92" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb141-93"><a href="#cb141-93" aria-hidden="true" tabindex="-1"></a><span class="kw">def</span> analytische_loesung():</span>
-<span id="cb141-94"><a href="#cb141-94" aria-hidden="true" tabindex="-1"></a>    <span class="co">&quot;&quot;&quot;</span></span>
-<span id="cb141-95"><a href="#cb141-95" aria-hidden="true" tabindex="-1"></a><span class="co">    Geschlossene Almgren-Chriss-Loesung fuer den kontinuierlichen Fall.</span></span>
-<span id="cb141-96"><a href="#cb141-96" aria-hidden="true" tabindex="-1"></a><span class="co">    Der optimale Pfad ist X_t = X_0 * sinh(kappa*(T-t)) / sinh(kappa*T)</span></span>
-<span id="cb141-97"><a href="#cb141-97" aria-hidden="true" tabindex="-1"></a><span class="co">    mit kappa = arccosh(tilde_kappa^2/2 + 1), tilde_kappa^2 = lambda*sigma^2*P0^2/eta.</span></span>
-<span id="cb141-98"><a href="#cb141-98" aria-hidden="true" tabindex="-1"></a><span class="co">    Dient hier als unabhaengige Kontrolle des DP-Ergebnisses.</span></span>
-<span id="cb141-99"><a href="#cb141-99" aria-hidden="true" tabindex="-1"></a><span class="co">    &quot;&quot;&quot;</span></span>
-<span id="cb141-100"><a href="#cb141-100" aria-hidden="true" tabindex="-1"></a>    kappa_tilde_quadrat <span class="op">=</span> (RISIKOAVERSION <span class="op">*</span> (VOLA_PERIODE <span class="op">**</span> <span class="dv">2</span>) <span class="op">*</span> (KURS <span class="op">**</span> <span class="dv">2</span>)) <span class="op">/</span> ETA</span>
-<span id="cb141-101"><a href="#cb141-101" aria-hidden="true" tabindex="-1"></a>    kappa <span class="op">=</span> np.arccosh(kappa_tilde_quadrat <span class="op">/</span> <span class="fl">2.0</span> <span class="op">+</span> <span class="fl">1.0</span>)</span>
-<span id="cb141-102"><a href="#cb141-102" aria-hidden="true" tabindex="-1"></a>    <span class="cf">if</span> kappa <span class="op">&lt;</span> <span class="fl">1e-12</span>:                        <span class="co"># Grenzfall: risikoneutral -&gt; linear</span></span>
-<span id="cb141-103"><a href="#cb141-103" aria-hidden="true" tabindex="-1"></a>        <span class="cf">return</span> np.linspace(GESAMTBESTAND, <span class="dv">0</span>, PERIODEN <span class="op">+</span> <span class="dv">1</span>)</span>
-<span id="cb141-104"><a href="#cb141-104" aria-hidden="true" tabindex="-1"></a>    t <span class="op">=</span> np.arange(PERIODEN <span class="op">+</span> <span class="dv">1</span>)</span>
-<span id="cb141-105"><a href="#cb141-105" aria-hidden="true" tabindex="-1"></a>    <span class="cf">return</span> GESAMTBESTAND <span class="op">*</span> np.sinh(kappa <span class="op">*</span> (PERIODEN <span class="op">-</span> t)) <span class="op">/</span> np.sinh(kappa <span class="op">*</span> PERIODEN)</span>
-<span id="cb141-106"><a href="#cb141-106" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb141-107"><a href="#cb141-107" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb141-108"><a href="#cb141-108" aria-hidden="true" tabindex="-1"></a><span class="kw">def</span> bewerte_pfad(bestaende):</span>
-<span id="cb141-109"><a href="#cb141-109" aria-hidden="true" tabindex="-1"></a>    <span class="co">&quot;&quot;&quot;Gesamtkosten eines beliebigen Bestandspfades.&quot;&quot;&quot;</span></span>
-<span id="cb141-110"><a href="#cb141-110" aria-hidden="true" tabindex="-1"></a>    summe <span class="op">=</span> <span class="fl">0.0</span></span>
-<span id="cb141-111"><a href="#cb141-111" aria-hidden="true" tabindex="-1"></a>    <span class="cf">for</span> t <span class="kw">in</span> <span class="bu">range</span>(<span class="bu">len</span>(bestaende) <span class="op">-</span> <span class="dv">1</span>):</span>
-<span id="cb141-112"><a href="#cb141-112" aria-hidden="true" tabindex="-1"></a>        verkauf <span class="op">=</span> bestaende[t] <span class="op">-</span> bestaende[t <span class="op">+</span> <span class="dv">1</span>]</span>
-<span id="cb141-113"><a href="#cb141-113" aria-hidden="true" tabindex="-1"></a>        summe <span class="op">+=</span> periodenkosten(verkauf, bestaende[t <span class="op">+</span> <span class="dv">1</span>])</span>
-<span id="cb141-114"><a href="#cb141-114" aria-hidden="true" tabindex="-1"></a>    <span class="cf">return</span> summe</span>
-<span id="cb141-115"><a href="#cb141-115" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb141-116"><a href="#cb141-116" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb141-117"><a href="#cb141-117" aria-hidden="true" tabindex="-1"></a><span class="cf">if</span> <span class="va">__name__</span> <span class="op">==</span> <span class="st">&quot;__main__&quot;</span>:</span>
-<span id="cb141-118"><a href="#cb141-118" aria-hidden="true" tabindex="-1"></a>    zustaende, V, politik <span class="op">=</span> loese_dp()</span>
-<span id="cb141-119"><a href="#cb141-119" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb141-120"><a href="#cb141-120" aria-hidden="true" tabindex="-1"></a>    <span class="co"># --- Vorwaertspfad der optimalen Politik -----------------------------</span></span>
-<span id="cb141-121"><a href="#cb141-121" aria-hidden="true" tabindex="-1"></a>    bestand <span class="op">=</span> GESAMTBESTAND</span>
-<span id="cb141-122"><a href="#cb141-122" aria-hidden="true" tabindex="-1"></a>    verlauf <span class="op">=</span> [bestand]</span>
-<span id="cb141-123"><a href="#cb141-123" aria-hidden="true" tabindex="-1"></a>    verkaeufe <span class="op">=</span> []</span>
-<span id="cb141-124"><a href="#cb141-124" aria-hidden="true" tabindex="-1"></a>    <span class="cf">for</span> t <span class="kw">in</span> <span class="bu">range</span>(PERIODEN):</span>
-<span id="cb141-125"><a href="#cb141-125" aria-hidden="true" tabindex="-1"></a>        idx <span class="op">=</span> <span class="bu">int</span>(<span class="bu">round</span>(bestand <span class="op">/</span> SCHRITTWEITE))</span>
-<span id="cb141-126"><a href="#cb141-126" aria-hidden="true" tabindex="-1"></a>        verkauf <span class="op">=</span> politik[t, idx]</span>
-<span id="cb141-127"><a href="#cb141-127" aria-hidden="true" tabindex="-1"></a>        verkaeufe.append(verkauf)</span>
-<span id="cb141-128"><a href="#cb141-128" aria-hidden="true" tabindex="-1"></a>        bestand <span class="op">-=</span> verkauf</span>
-<span id="cb141-129"><a href="#cb141-129" aria-hidden="true" tabindex="-1"></a>        verlauf.append(bestand)</span>
-<span id="cb141-130"><a href="#cb141-130" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb141-131"><a href="#cb141-131" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;=&quot;</span> <span class="op">*</span> <span class="dv">84</span>)</span>
-<span id="cb141-132"><a href="#cb141-132" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;   OPTIMALE MEHRPERIODIGE ORDER-EXECUTION (BELLMAN DP)&quot;</span>)</span>
-<span id="cb141-133"><a href="#cb141-133" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;=&quot;</span> <span class="op">*</span> <span class="dv">84</span>)</span>
-<span id="cb141-134"><a href="#cb141-134" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;Gesamtvolumen:       </span><span class="sc">{</span>GESAMTBESTAND<span class="sc">:,}</span><span class="ss"> Stueck zu </span><span class="sc">{</span>KURS<span class="sc">:.2f}</span><span class="ss"> EUR &quot;</span></span>
-<span id="cb141-135"><a href="#cb141-135" aria-hidden="true" tabindex="-1"></a>          <span class="ss">f&quot;= </span><span class="sc">{</span>GESAMTBESTAND<span class="op">*</span>KURS<span class="sc">:,.0f}</span><span class="ss"> EUR Positionswert&quot;</span>)</span>
-<span id="cb141-136"><a href="#cb141-136" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;Zeithorizont:        </span><span class="sc">{</span>PERIODEN<span class="sc">}</span><span class="ss"> Handelsperioden&quot;</span>)</span>
-<span id="cb141-137"><a href="#cb141-137" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;Volatilitaet:        </span><span class="sc">{</span>VOLA_JAHR<span class="op">*</span><span class="dv">100</span><span class="sc">:.0f}</span><span class="ss"> % p.a. &quot;</span></span>
-<span id="cb141-138"><a href="#cb141-138" aria-hidden="true" tabindex="-1"></a>          <span class="ss">f&quot;= </span><span class="sc">{</span>VOLA_PERIODE<span class="op">*</span><span class="dv">100</span><span class="sc">:.3f}</span><span class="ss"> % je Periode&quot;</span>)</span>
-<span id="cb141-139"><a href="#cb141-139" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;Slippage eta:        </span><span class="sc">{</span>ETA<span class="sc">:.2e}</span><span class="ss"> EUR/Stueck^2&quot;</span>)</span>
-<span id="cb141-140"><a href="#cb141-140" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;Risikoaversion:      </span><span class="sc">{</span>RISIKOAVERSION<span class="sc">:.2e}</span><span class="ss"> 1/EUR&quot;</span>)</span>
-<span id="cb141-141"><a href="#cb141-141" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;Erwartete Gesamtreibung: </span><span class="sc">{</span>V[<span class="dv">0</span>, <span class="op">-</span><span class="dv">1</span>]<span class="sc">:,.2f}</span><span class="ss"> EUR &quot;</span></span>
-<span id="cb141-142"><a href="#cb141-142" aria-hidden="true" tabindex="-1"></a>          <span class="ss">f&quot;(</span><span class="sc">{</span>V[<span class="dv">0</span>, <span class="op">-</span><span class="dv">1</span>]<span class="op">/</span>(GESAMTBESTAND<span class="op">*</span>KURS)<span class="op">*</span><span class="dv">10000</span><span class="sc">:.1f}</span><span class="ss"> Basispunkte)</span><span class="ch">\n</span><span class="ss">&quot;</span>)</span>
-<span id="cb141-143"><a href="#cb141-143" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb141-144"><a href="#cb141-144" aria-hidden="true" tabindex="-1"></a>    plan <span class="op">=</span> pd.DataFrame([{</span>
-<span id="cb141-145"><a href="#cb141-145" aria-hidden="true" tabindex="-1"></a>        <span class="st">&quot;Periode&quot;</span>: <span class="ss">f&quot;t = </span><span class="sc">{</span>t<span class="sc">}</span><span class="ss"> -&gt; </span><span class="sc">{</span>t<span class="op">+</span><span class="dv">1</span><span class="sc">}</span><span class="ss">&quot;</span>,</span>
-<span id="cb141-146"><a href="#cb141-146" aria-hidden="true" tabindex="-1"></a>        <span class="st">&quot;Startbestand&quot;</span>: <span class="ss">f&quot;</span><span class="sc">{</span>verlauf[t]<span class="sc">:,}</span><span class="ss">&quot;</span>,</span>
-<span id="cb141-147"><a href="#cb141-147" aria-hidden="true" tabindex="-1"></a>        <span class="st">&quot;Verkauf n_t&quot;</span>: <span class="ss">f&quot;</span><span class="sc">{</span>verkaeufe[t]<span class="sc">:,}</span><span class="ss">&quot;</span>,</span>
-<span id="cb141-148"><a href="#cb141-148" aria-hidden="true" tabindex="-1"></a>        <span class="st">&quot;Restbestand&quot;</span>: <span class="ss">f&quot;</span><span class="sc">{</span>verlauf[t<span class="op">+</span><span class="dv">1</span>]<span class="sc">:,}</span><span class="ss">&quot;</span>,</span>
-<span id="cb141-149"><a href="#cb141-149" aria-hidden="true" tabindex="-1"></a>        <span class="st">&quot;Anteil&quot;</span>: <span class="ss">f&quot;</span><span class="sc">{</span>verkaeufe[t]<span class="op">/</span>GESAMTBESTAND<span class="op">*</span><span class="dv">100</span><span class="sc">:5.1f}</span><span class="ss"> %&quot;</span>,</span>
-<span id="cb141-150"><a href="#cb141-150" aria-hidden="true" tabindex="-1"></a>        <span class="st">&quot;Kosten (EUR)&quot;</span>: <span class="ss">f&quot;</span><span class="sc">{</span>periodenkosten(verkaeufe[t], verlauf[t<span class="op">+</span><span class="dv">1</span>])<span class="sc">:,.0f}</span><span class="ss">&quot;</span>,</span>
-<span id="cb141-151"><a href="#cb141-151" aria-hidden="true" tabindex="-1"></a>    } <span class="cf">for</span> t <span class="kw">in</span> <span class="bu">range</span>(PERIODEN)])</span>
-<span id="cb141-152"><a href="#cb141-152" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(plan.to_string(index<span class="op">=</span><span class="va">False</span>))</span>
-<span id="cb141-153"><a href="#cb141-153" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb141-154"><a href="#cb141-154" aria-hidden="true" tabindex="-1"></a>    <span class="co"># --- Vergleich mit Alternativen und der analytischen Loesung ---------</span></span>
-<span id="cb141-155"><a href="#cb141-155" aria-hidden="true" tabindex="-1"></a>    sofort <span class="op">=</span> [GESAMTBESTAND] <span class="op">+</span> [<span class="dv">0</span>] <span class="op">*</span> PERIODEN</span>
-<span id="cb141-156"><a href="#cb141-156" aria-hidden="true" tabindex="-1"></a>    gleichmaessig <span class="op">=</span> [GESAMTBESTAND <span class="op">*</span> (<span class="dv">1</span> <span class="op">-</span> t <span class="op">/</span> PERIODEN) <span class="cf">for</span> t <span class="kw">in</span> <span class="bu">range</span>(PERIODEN <span class="op">+</span> <span class="dv">1</span>)]</span>
-<span id="cb141-157"><a href="#cb141-157" aria-hidden="true" tabindex="-1"></a>    analytisch <span class="op">=</span> analytische_loesung()</span>
-<span id="cb141-158"><a href="#cb141-158" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb141-159"><a href="#cb141-159" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;</span><span class="ch">\n</span><span class="st">&quot;</span> <span class="op">+</span> <span class="st">&quot;-&quot;</span> <span class="op">*</span> <span class="dv">84</span>)</span>
-<span id="cb141-160"><a href="#cb141-160" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;</span><span class="sc">{</span><span class="st">&#39;Strategie&#39;</span><span class="sc">:&lt;34}</span><span class="ss"> </span><span class="sc">{</span><span class="st">&#39;Kosten (EUR)&#39;</span><span class="sc">:&gt;15}</span><span class="ss"> </span><span class="sc">{</span><span class="st">&#39;Basispunkte&#39;</span><span class="sc">:&gt;13}</span><span class="ss"> &quot;</span></span>
-<span id="cb141-161"><a href="#cb141-161" aria-hidden="true" tabindex="-1"></a>          <span class="ss">f&quot;</span><span class="sc">{</span><span class="st">&#39;ggue. Optimum&#39;</span><span class="sc">:&gt;16}</span><span class="ss">&quot;</span>)</span>
-<span id="cb141-162"><a href="#cb141-162" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;-&quot;</span> <span class="op">*</span> <span class="dv">84</span>)</span>
-<span id="cb141-163"><a href="#cb141-163" aria-hidden="true" tabindex="-1"></a>    optimum <span class="op">=</span> V[<span class="dv">0</span>, <span class="op">-</span><span class="dv">1</span>]</span>
-<span id="cb141-164"><a href="#cb141-164" aria-hidden="true" tabindex="-1"></a>    <span class="cf">for</span> name, pfad <span class="kw">in</span> [(<span class="st">&quot;DP-Optimum&quot;</span>, verlauf),</span>
-<span id="cb141-165"><a href="#cb141-165" aria-hidden="true" tabindex="-1"></a>                       (<span class="st">&quot;Analytisch (Almgren-Chriss)&quot;</span>, <span class="bu">list</span>(analytisch)),</span>
-<span id="cb141-166"><a href="#cb141-166" aria-hidden="true" tabindex="-1"></a>                       (<span class="st">&quot;Gleichmaessig (TWAP)&quot;</span>, gleichmaessig),</span>
-<span id="cb141-167"><a href="#cb141-167" aria-hidden="true" tabindex="-1"></a>                       (<span class="st">&quot;Alles sofort&quot;</span>, sofort)]:</span>
-<span id="cb141-168"><a href="#cb141-168" aria-hidden="true" tabindex="-1"></a>        kosten <span class="op">=</span> bewerte_pfad(pfad)</span>
-<span id="cb141-169"><a href="#cb141-169" aria-hidden="true" tabindex="-1"></a>        bp <span class="op">=</span> kosten <span class="op">/</span> (GESAMTBESTAND <span class="op">*</span> KURS) <span class="op">*</span> <span class="dv">10000</span></span>
-<span id="cb141-170"><a href="#cb141-170" aria-hidden="true" tabindex="-1"></a>        <span class="bu">print</span>(<span class="ss">f&quot;</span><span class="sc">{</span>name<span class="sc">:&lt;34}</span><span class="ss"> </span><span class="sc">{</span>kosten<span class="sc">:&gt;15,.0f}</span><span class="ss"> </span><span class="sc">{</span>bp<span class="sc">:&gt;12.1f}</span><span class="ss"> &quot;</span></span>
-<span id="cb141-171"><a href="#cb141-171" aria-hidden="true" tabindex="-1"></a>              <span class="ss">f&quot;</span><span class="sc">{</span>kosten <span class="op">-</span> optimum<span class="sc">:&gt;+15,.0f}</span><span class="ss">&quot;</span>)</span>
-<span id="cb141-172"><a href="#cb141-172" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb141-173"><a href="#cb141-173" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;-&quot;</span> <span class="op">*</span> <span class="dv">84</span>)</span>
-<span id="cb141-174"><a href="#cb141-174" aria-hidden="true" tabindex="-1"></a>    abweichung <span class="op">=</span> <span class="bu">abs</span>(bewerte_pfad(<span class="bu">list</span>(analytisch)) <span class="op">-</span> optimum) <span class="op">/</span> optimum</span>
-<span id="cb141-175"><a href="#cb141-175" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;Abweichung DP zur analytischen Loesung: </span><span class="sc">{</span>abweichung<span class="op">*</span><span class="dv">100</span><span class="sc">:.3f}</span><span class="ss"> % &quot;</span></span>
-<span id="cb141-176"><a href="#cb141-176" aria-hidden="true" tabindex="-1"></a>          <span class="ss">f&quot;(Diskretisierung: </span><span class="sc">{</span>SCHRITTWEITE<span class="sc">}</span><span class="ss"> Stueck)&quot;</span>)</span>
-<span id="cb141-177"><a href="#cb141-177" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb141-178"><a href="#cb141-178" aria-hidden="true" tabindex="-1"></a>    <span class="co"># --- Sensitivitaet gegenueber der Risikoaversion ---------------------</span></span>
-<span id="cb141-179"><a href="#cb141-179" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;</span><span class="ch">\n</span><span class="st">--- Wie wirkt die Risikoaversion? ---&quot;</span>)</span>
-<span id="cb141-180"><a href="#cb141-180" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;</span><span class="sc">{</span><span class="st">&#39;lambda&#39;</span><span class="sc">:&gt;10}</span><span class="ss"> | </span><span class="sc">{</span><span class="st">&#39;Verkauf in Periode 0&#39;</span><span class="sc">:&gt;22}</span><span class="ss"> | </span><span class="sc">{</span><span class="st">&#39;Charakter&#39;</span><span class="sc">:&lt;28}</span><span class="ss">&quot;</span>)</span>
-<span id="cb141-181"><a href="#cb141-181" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;-&quot;</span> <span class="op">*</span> <span class="dv">70</span>)</span>
-<span id="cb141-182"><a href="#cb141-182" aria-hidden="true" tabindex="-1"></a>    <span class="cf">for</span> lam <span class="kw">in</span> [<span class="fl">1e-7</span>, <span class="fl">1e-6</span>, <span class="fl">1e-5</span>, <span class="fl">1e-4</span>, <span class="fl">1e-3</span>]:</span>
-<span id="cb141-183"><a href="#cb141-183" aria-hidden="true" tabindex="-1"></a>        <span class="bu">globals</span>()[<span class="st">&quot;RISIKOAVERSION&quot;</span>] <span class="op">=</span> lam</span>
-<span id="cb141-184"><a href="#cb141-184" aria-hidden="true" tabindex="-1"></a>        _, V_l, pol_l <span class="op">=</span> loese_dp()</span>
-<span id="cb141-185"><a href="#cb141-185" aria-hidden="true" tabindex="-1"></a>        erste <span class="op">=</span> pol_l[<span class="dv">0</span>, <span class="op">-</span><span class="dv">1</span>]</span>
-<span id="cb141-186"><a href="#cb141-186" aria-hidden="true" tabindex="-1"></a>        anteil <span class="op">=</span> erste <span class="op">/</span> GESAMTBESTAND <span class="op">*</span> <span class="dv">100</span></span>
-<span id="cb141-187"><a href="#cb141-187" aria-hidden="true" tabindex="-1"></a>        charakter <span class="op">=</span> (<span class="st">&quot;nahezu gleichmaessig&quot;</span> <span class="cf">if</span> anteil <span class="op">&lt;</span> <span class="dv">25</span> <span class="cf">else</span></span>
-<span id="cb141-188"><a href="#cb141-188" aria-hidden="true" tabindex="-1"></a>                     <span class="st">&quot;front-loaded&quot;</span> <span class="cf">if</span> anteil <span class="op">&lt;</span> <span class="dv">60</span> <span class="cf">else</span> <span class="st">&quot;fast alles sofort&quot;</span>)</span>
-<span id="cb141-189"><a href="#cb141-189" aria-hidden="true" tabindex="-1"></a>        <span class="bu">print</span>(<span class="ss">f&quot;</span><span class="sc">{</span>lam<span class="sc">:&gt;10.0e}</span><span class="ss"> | </span><span class="sc">{</span>erste<span class="sc">:&gt;13,}</span><span class="ss"> (</span><span class="sc">{</span>anteil<span class="sc">:5.1f}</span><span class="ss"> %) | </span><span class="sc">{</span>charakter<span class="sc">:&lt;28}</span><span class="ss">&quot;</span>)</span>
-<span id="cb141-190"><a href="#cb141-190" aria-hidden="true" tabindex="-1"></a>    <span class="bu">globals</span>()[<span class="st">&quot;RISIKOAVERSION&quot;</span>] <span class="op">=</span> <span class="fl">1e-5</span>       <span class="co"># zuruecksetzen</span></span>
-<span id="cb141-191"><a href="#cb141-191" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb141-192"><a href="#cb141-192" aria-hidden="true" tabindex="-1"></a>    <span class="co"># --- Diagramm ---------------------------------------------------------</span></span>
-<span id="cb141-193"><a href="#cb141-193" aria-hidden="true" tabindex="-1"></a>    plt.figure(figsize<span class="op">=</span>(<span class="dv">10</span>, <span class="fl">5.5</span>))</span>
-<span id="cb141-194"><a href="#cb141-194" aria-hidden="true" tabindex="-1"></a>    plt.plot(<span class="bu">range</span>(PERIODEN <span class="op">+</span> <span class="dv">1</span>), verlauf, <span class="st">&quot;o-&quot;</span>, lw<span class="op">=</span><span class="fl">2.5</span>, label<span class="op">=</span><span class="st">&quot;DP-Optimum&quot;</span>)</span>
-<span id="cb141-195"><a href="#cb141-195" aria-hidden="true" tabindex="-1"></a>    plt.plot(<span class="bu">range</span>(PERIODEN <span class="op">+</span> <span class="dv">1</span>), analytisch, <span class="st">&quot;s--&quot;</span>, lw<span class="op">=</span><span class="fl">1.8</span>, alpha<span class="op">=</span><span class="fl">0.8</span>,</span>
-<span id="cb141-196"><a href="#cb141-196" aria-hidden="true" tabindex="-1"></a>             label<span class="op">=</span><span class="st">&quot;Analytisch (Almgren-Chriss)&quot;</span>)</span>
-<span id="cb141-197"><a href="#cb141-197" aria-hidden="true" tabindex="-1"></a>    plt.plot(<span class="bu">range</span>(PERIODEN <span class="op">+</span> <span class="dv">1</span>), gleichmaessig, <span class="st">&quot;^:&quot;</span>, lw<span class="op">=</span><span class="fl">1.8</span>, alpha<span class="op">=</span><span class="fl">0.8</span>,</span>
-<span id="cb141-198"><a href="#cb141-198" aria-hidden="true" tabindex="-1"></a>             label<span class="op">=</span><span class="st">&quot;Gleichmaessig (TWAP)&quot;</span>)</span>
-<span id="cb141-199"><a href="#cb141-199" aria-hidden="true" tabindex="-1"></a>    plt.bar(<span class="bu">range</span>(PERIODEN), verkaeufe, alpha<span class="op">=</span><span class="fl">0.25</span>, color<span class="op">=</span><span class="st">&quot;orange&quot;</span>, width<span class="op">=</span><span class="fl">0.45</span>,</span>
-<span id="cb141-200"><a href="#cb141-200" aria-hidden="true" tabindex="-1"></a>            label<span class="op">=</span><span class="st">&quot;Verkaufstranche $n_t$&quot;</span>)</span>
-<span id="cb141-201"><a href="#cb141-201" aria-hidden="true" tabindex="-1"></a>    plt.title(<span class="st">&quot;Optimaler Liquidationspfad ueber diskrete Perioden&quot;</span>, fontsize<span class="op">=</span><span class="dv">12</span>)</span>
-<span id="cb141-202"><a href="#cb141-202" aria-hidden="true" tabindex="-1"></a>    plt.xlabel(<span class="st">&quot;Handelsperiode $t$&quot;</span>)</span>
-<span id="cb141-203"><a href="#cb141-203" aria-hidden="true" tabindex="-1"></a>    plt.ylabel(<span class="st">&quot;Verbleibender Bestand $X_t$&quot;</span>)</span>
-<span id="cb141-204"><a href="#cb141-204" aria-hidden="true" tabindex="-1"></a>    plt.xticks(<span class="bu">range</span>(PERIODEN <span class="op">+</span> <span class="dv">1</span>))</span>
-<span id="cb141-205"><a href="#cb141-205" aria-hidden="true" tabindex="-1"></a>    plt.grid(<span class="va">True</span>, linestyle<span class="op">=</span><span class="st">&quot;:&quot;</span>, alpha<span class="op">=</span><span class="fl">0.6</span>)</span>
-<span id="cb141-206"><a href="#cb141-206" aria-hidden="true" tabindex="-1"></a>    plt.legend()</span>
-<span id="cb141-207"><a href="#cb141-207" aria-hidden="true" tabindex="-1"></a>    plt.tight_layout()</span>
-<span id="cb141-208"><a href="#cb141-208" aria-hidden="true" tabindex="-1"></a>    ziel <span class="op">=</span> os.path.join(OUTPUT_DIR, <span class="st">&quot;optimal_execution_dp.png&quot;</span>)</span>
-<span id="cb141-209"><a href="#cb141-209" aria-hidden="true" tabindex="-1"></a>    plt.savefig(ziel, dpi<span class="op">=</span><span class="dv">150</span>)</span>
-<span id="cb141-210"><a href="#cb141-210" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;</span><span class="ch">\n</span><span class="ss">Diagramm gespeichert unter &#39;</span><span class="sc">{</span>ziel<span class="sc">}</span><span class="ss">&#39;&quot;</span>)</span>
-<span id="cb141-211"><a href="#cb141-211" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;=&quot;</span> <span class="op">*</span> <span class="dv">84</span>)</span></code></pre></div>
+<div class="sourceCode" id="cb143"><pre class="sourceCode python"><code class="sourceCode python"><span id="cb143-1"><a href="#cb143-1" aria-hidden="true" tabindex="-1"></a><span class="co">#!/usr/bin/env python3</span></span>
+<span id="cb143-2"><a href="#cb143-2" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb143-3"><a href="#cb143-3" aria-hidden="true" tabindex="-1"></a><span class="co"># Mehrperiodige_Order_Execution.py</span></span>
+<span id="cb143-4"><a href="#cb143-4" aria-hidden="true" tabindex="-1"></a><span class="co">&quot;&quot;&quot;</span></span>
+<span id="cb143-5"><a href="#cb143-5" aria-hidden="true" tabindex="-1"></a><span class="co">Kapitel Dynamische Programmierung: Dynamische Programmierung fuer optimale Orderausfuehrung</span></span>
+<span id="cb143-6"><a href="#cb143-6" aria-hidden="true" tabindex="-1"></a><span class="co">(Almgren-Chriss-Rahmen, geloest per Rueckwaertsinduktion).</span></span>
+<span id="cb143-7"><a href="#cb143-7" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb143-8"><a href="#cb143-8" aria-hidden="true" tabindex="-1"></a><span class="co">Eigenschaften:</span></span>
+<span id="cb143-9"><a href="#cb143-9" aria-hidden="true" tabindex="-1"></a><span class="co">  * Risikoterm sauber hergeleitet ueber den Aktienkurs P0 (Einheiten: EUR),</span></span>
+<span id="cb143-10"><a href="#cb143-10" aria-hidden="true" tabindex="-1"></a><span class="co">    ohne undokumentierte Skalierungsfaktoren</span></span>
+<span id="cb143-11"><a href="#cb143-11" aria-hidden="true" tabindex="-1"></a><span class="co">  * Vergleich mit der analytischen Almgren-Chriss-Loesung</span></span>
+<span id="cb143-12"><a href="#cb143-12" aria-hidden="true" tabindex="-1"></a><span class="co">  * Vergleich mit naiven Strategien (alles sofort / gleichmaessig)</span></span>
+<span id="cb143-13"><a href="#cb143-13" aria-hidden="true" tabindex="-1"></a><span class="co">  * Sensitivitaet gegenueber der Risikoaversion</span></span>
+<span id="cb143-14"><a href="#cb143-14" aria-hidden="true" tabindex="-1"></a><span class="co">&quot;&quot;&quot;</span></span>
+<span id="cb143-15"><a href="#cb143-15" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb143-16"><a href="#cb143-16" aria-hidden="true" tabindex="-1"></a><span class="im">import</span> os</span>
+<span id="cb143-17"><a href="#cb143-17" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb143-18"><a href="#cb143-18" aria-hidden="true" tabindex="-1"></a><span class="im">import</span> numpy <span class="im">as</span> np</span>
+<span id="cb143-19"><a href="#cb143-19" aria-hidden="true" tabindex="-1"></a><span class="im">import</span> pandas <span class="im">as</span> pd</span>
+<span id="cb143-20"><a href="#cb143-20" aria-hidden="true" tabindex="-1"></a><span class="im">import</span> matplotlib</span>
+<span id="cb143-21"><a href="#cb143-21" aria-hidden="true" tabindex="-1"></a>matplotlib.use(<span class="st">&quot;Agg&quot;</span>)</span>
+<span id="cb143-22"><a href="#cb143-22" aria-hidden="true" tabindex="-1"></a><span class="im">import</span> matplotlib.pyplot <span class="im">as</span> plt</span>
+<span id="cb143-23"><a href="#cb143-23" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb143-24"><a href="#cb143-24" aria-hidden="true" tabindex="-1"></a>OUTPUT_DIR <span class="op">=</span> os.path.join(os.path.dirname(os.path.abspath(<span class="va">__file__</span>)), <span class="st">&quot;output&quot;</span>)</span>
+<span id="cb143-25"><a href="#cb143-25" aria-hidden="true" tabindex="-1"></a>os.makedirs(OUTPUT_DIR, exist_ok<span class="op">=</span><span class="va">True</span>)</span>
+<span id="cb143-26"><a href="#cb143-26" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb143-27"><a href="#cb143-27" aria-hidden="true" tabindex="-1"></a><span class="co"># --- Parameter -------------------------------------------------------------</span></span>
+<span id="cb143-28"><a href="#cb143-28" aria-hidden="true" tabindex="-1"></a>GESAMTBESTAND <span class="op">=</span> <span class="dv">100_000</span>        <span class="co"># X_0, zu verkaufende Aktien</span></span>
+<span id="cb143-29"><a href="#cb143-29" aria-hidden="true" tabindex="-1"></a>PERIODEN <span class="op">=</span> <span class="dv">5</span>                   <span class="co"># T Handelsperioden</span></span>
+<span id="cb143-30"><a href="#cb143-30" aria-hidden="true" tabindex="-1"></a>KURS <span class="op">=</span> <span class="fl">50.0</span>                    <span class="co"># P_0 in EUR, zur Skalierung des Risikoterms</span></span>
+<span id="cb143-31"><a href="#cb143-31" aria-hidden="true" tabindex="-1"></a>ETA <span class="op">=</span> <span class="fl">2.5e-6</span>                   <span class="co"># EUR je Stueck^2 (Slippage-Koeffizient)</span></span>
+<span id="cb143-32"><a href="#cb143-32" aria-hidden="true" tabindex="-1"></a>VOLA_JAHR <span class="op">=</span> <span class="fl">0.30</span>               <span class="co"># 30 % p.a.</span></span>
+<span id="cb143-33"><a href="#cb143-33" aria-hidden="true" tabindex="-1"></a>HANDELSSTUNDEN_JAHR <span class="op">=</span> <span class="dv">252</span> <span class="op">*</span> <span class="fl">6.5</span></span>
+<span id="cb143-34"><a href="#cb143-34" aria-hidden="true" tabindex="-1"></a>RISIKOAVERSION <span class="op">=</span> <span class="fl">1e-5</span>          <span class="co"># 1/EUR; kalibriert, siehe Kommentar unten</span></span>
+<span id="cb143-35"><a href="#cb143-35" aria-hidden="true" tabindex="-1"></a>SCHRITTWEITE <span class="op">=</span> <span class="dv">1000</span>            <span class="co"># Diskretisierung des Zustandsraums</span></span>
+<span id="cb143-36"><a href="#cb143-36" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb143-37"><a href="#cb143-37" aria-hidden="true" tabindex="-1"></a><span class="co"># Kalibrierungshinweis: Die dimensionslose Kennzahl des Modells ist</span></span>
+<span id="cb143-38"><a href="#cb143-38" aria-hidden="true" tabindex="-1"></a><span class="co">#     kappa_tilde^2 = lambda * sigma_periode^2 * P0^2 / eta</span></span>
+<span id="cb143-39"><a href="#cb143-39" aria-hidden="true" tabindex="-1"></a><span class="co"># Sie entscheidet ueber den Charakter der Loesung:</span></span>
+<span id="cb143-40"><a href="#cb143-40" aria-hidden="true" tabindex="-1"></a><span class="co">#     &lt;&lt; 1  -&gt; praktisch gleichmaessige Aufteilung (Risiko spielt keine Rolle)</span></span>
+<span id="cb143-41"><a href="#cb143-41" aria-hidden="true" tabindex="-1"></a><span class="co">#     ~  1  -&gt; ausgewogener Kompromiss  &lt;- hier: 0.55</span></span>
+<span id="cb143-42"><a href="#cb143-42" aria-hidden="true" tabindex="-1"></a><span class="co">#     &gt;&gt; 1  -&gt; fast alles sofort verkaufen</span></span>
+<span id="cb143-43"><a href="#cb143-43" aria-hidden="true" tabindex="-1"></a><span class="co"># Genau diese Interpretierbarkeit geht mit einem undokumentierten</span></span>
+<span id="cb143-44"><a href="#cb143-44" aria-hidden="true" tabindex="-1"></a><span class="co"># Skalierungsfaktor verloren.</span></span>
+<span id="cb143-45"><a href="#cb143-45" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb143-46"><a href="#cb143-46" aria-hidden="true" tabindex="-1"></a>VOLA_PERIODE <span class="op">=</span> VOLA_JAHR <span class="op">/</span> np.sqrt(HANDELSSTUNDEN_JAHR)</span>
+<span id="cb143-47"><a href="#cb143-47" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb143-48"><a href="#cb143-48" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb143-49"><a href="#cb143-49" aria-hidden="true" tabindex="-1"></a><span class="kw">def</span> periodenkosten(verkauf: <span class="bu">float</span>, restbestand: <span class="bu">float</span>) <span class="op">-&gt;</span> <span class="bu">float</span>:</span>
+<span id="cb143-50"><a href="#cb143-50" aria-hidden="true" tabindex="-1"></a>    <span class="co">&quot;&quot;&quot;</span></span>
+<span id="cb143-51"><a href="#cb143-51" aria-hidden="true" tabindex="-1"></a><span class="co">    Sofortkosten einer Periode in EUR:</span></span>
+<span id="cb143-52"><a href="#cb143-52" aria-hidden="true" tabindex="-1"></a><span class="co">      (1) Marktauswirkung: eta * n^2</span></span>
+<span id="cb143-53"><a href="#cb143-53" aria-hidden="true" tabindex="-1"></a><span class="co">      (2) Risiko des Restbestands: lambda/2 * sigma^2 * P0^2 * X^2</span></span>
+<span id="cb143-54"><a href="#cb143-54" aria-hidden="true" tabindex="-1"></a><span class="co">          -&gt; P0^2 macht aus &quot;Stueck^2&quot; einen EUR^2-Wert; lambda hat damit</span></span>
+<span id="cb143-55"><a href="#cb143-55" aria-hidden="true" tabindex="-1"></a><span class="co">             die Einheit 1/EUR und ist interpretierbar.</span></span>
+<span id="cb143-56"><a href="#cb143-56" aria-hidden="true" tabindex="-1"></a><span class="co">    &quot;&quot;&quot;</span></span>
+<span id="cb143-57"><a href="#cb143-57" aria-hidden="true" tabindex="-1"></a>    marktauswirkung <span class="op">=</span> ETA <span class="op">*</span> verkauf <span class="op">**</span> <span class="dv">2</span></span>
+<span id="cb143-58"><a href="#cb143-58" aria-hidden="true" tabindex="-1"></a>    wertvarianz <span class="op">=</span> (VOLA_PERIODE <span class="op">**</span> <span class="dv">2</span>) <span class="op">*</span> (KURS <span class="op">**</span> <span class="dv">2</span>) <span class="op">*</span> (restbestand <span class="op">**</span> <span class="dv">2</span>)</span>
+<span id="cb143-59"><a href="#cb143-59" aria-hidden="true" tabindex="-1"></a>    risiko <span class="op">=</span> <span class="fl">0.5</span> <span class="op">*</span> RISIKOAVERSION <span class="op">*</span> wertvarianz</span>
+<span id="cb143-60"><a href="#cb143-60" aria-hidden="true" tabindex="-1"></a>    <span class="cf">return</span> marktauswirkung <span class="op">+</span> risiko</span>
+<span id="cb143-61"><a href="#cb143-61" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb143-62"><a href="#cb143-62" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb143-63"><a href="#cb143-63" aria-hidden="true" tabindex="-1"></a><span class="kw">def</span> loese_dp():</span>
+<span id="cb143-64"><a href="#cb143-64" aria-hidden="true" tabindex="-1"></a>    <span class="co">&quot;&quot;&quot;Rueckwaertsinduktion ueber den diskretisierten Zustandsraum.&quot;&quot;&quot;</span></span>
+<span id="cb143-65"><a href="#cb143-65" aria-hidden="true" tabindex="-1"></a>    zustaende <span class="op">=</span> np.arange(<span class="dv">0</span>, GESAMTBESTAND <span class="op">+</span> SCHRITTWEITE, SCHRITTWEITE)</span>
+<span id="cb143-66"><a href="#cb143-66" aria-hidden="true" tabindex="-1"></a>    anzahl <span class="op">=</span> <span class="bu">len</span>(zustaende)</span>
+<span id="cb143-67"><a href="#cb143-67" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb143-68"><a href="#cb143-68" aria-hidden="true" tabindex="-1"></a>    V <span class="op">=</span> np.full((PERIODEN <span class="op">+</span> <span class="dv">1</span>, anzahl), np.inf)</span>
+<span id="cb143-69"><a href="#cb143-69" aria-hidden="true" tabindex="-1"></a>    politik <span class="op">=</span> np.zeros((PERIODEN, anzahl), dtype<span class="op">=</span><span class="bu">int</span>)</span>
+<span id="cb143-70"><a href="#cb143-70" aria-hidden="true" tabindex="-1"></a>    V[PERIODEN, <span class="dv">0</span>] <span class="op">=</span> <span class="fl">0.0</span>                     <span class="co"># am Ende muss alles verkauft sein</span></span>
+<span id="cb143-71"><a href="#cb143-71" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb143-72"><a href="#cb143-72" aria-hidden="true" tabindex="-1"></a>    <span class="cf">for</span> t <span class="kw">in</span> <span class="bu">range</span>(PERIODEN <span class="op">-</span> <span class="dv">1</span>, <span class="op">-</span><span class="dv">1</span>, <span class="op">-</span><span class="dv">1</span>):</span>
+<span id="cb143-73"><a href="#cb143-73" aria-hidden="true" tabindex="-1"></a>        <span class="cf">for</span> idx, bestand <span class="kw">in</span> <span class="bu">enumerate</span>(zustaende):</span>
+<span id="cb143-74"><a href="#cb143-74" aria-hidden="true" tabindex="-1"></a>            <span class="cf">if</span> t <span class="op">==</span> PERIODEN <span class="op">-</span> <span class="dv">1</span>:</span>
+<span id="cb143-75"><a href="#cb143-75" aria-hidden="true" tabindex="-1"></a>                moegliche <span class="op">=</span> [bestand]        <span class="co"># letzte Periode: Rest muss weg</span></span>
+<span id="cb143-76"><a href="#cb143-76" aria-hidden="true" tabindex="-1"></a>            <span class="cf">else</span>:</span>
+<span id="cb143-77"><a href="#cb143-77" aria-hidden="true" tabindex="-1"></a>                moegliche <span class="op">=</span> zustaende[zustaende <span class="op">&lt;=</span> bestand]</span>
+<span id="cb143-78"><a href="#cb143-78" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb143-79"><a href="#cb143-79" aria-hidden="true" tabindex="-1"></a>            bester_wert, beste_aktion <span class="op">=</span> np.inf, <span class="dv">0</span></span>
+<span id="cb143-80"><a href="#cb143-80" aria-hidden="true" tabindex="-1"></a>            <span class="cf">for</span> verkauf <span class="kw">in</span> moegliche:</span>
+<span id="cb143-81"><a href="#cb143-81" aria-hidden="true" tabindex="-1"></a>                rest <span class="op">=</span> bestand <span class="op">-</span> verkauf</span>
+<span id="cb143-82"><a href="#cb143-82" aria-hidden="true" tabindex="-1"></a>                rest_idx <span class="op">=</span> <span class="bu">int</span>(<span class="bu">round</span>(rest <span class="op">/</span> SCHRITTWEITE))</span>
+<span id="cb143-83"><a href="#cb143-83" aria-hidden="true" tabindex="-1"></a>                gesamt <span class="op">=</span> periodenkosten(verkauf, rest) <span class="op">+</span> V[t <span class="op">+</span> <span class="dv">1</span>, rest_idx]</span>
+<span id="cb143-84"><a href="#cb143-84" aria-hidden="true" tabindex="-1"></a>                <span class="cf">if</span> gesamt <span class="op">&lt;</span> bester_wert:</span>
+<span id="cb143-85"><a href="#cb143-85" aria-hidden="true" tabindex="-1"></a>                    bester_wert, beste_aktion <span class="op">=</span> gesamt, <span class="bu">int</span>(verkauf)</span>
+<span id="cb143-86"><a href="#cb143-86" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb143-87"><a href="#cb143-87" aria-hidden="true" tabindex="-1"></a>            V[t, idx] <span class="op">=</span> bester_wert</span>
+<span id="cb143-88"><a href="#cb143-88" aria-hidden="true" tabindex="-1"></a>            politik[t, idx] <span class="op">=</span> beste_aktion</span>
+<span id="cb143-89"><a href="#cb143-89" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb143-90"><a href="#cb143-90" aria-hidden="true" tabindex="-1"></a>    <span class="cf">return</span> zustaende, V, politik</span>
+<span id="cb143-91"><a href="#cb143-91" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb143-92"><a href="#cb143-92" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb143-93"><a href="#cb143-93" aria-hidden="true" tabindex="-1"></a><span class="kw">def</span> analytische_loesung():</span>
+<span id="cb143-94"><a href="#cb143-94" aria-hidden="true" tabindex="-1"></a>    <span class="co">&quot;&quot;&quot;</span></span>
+<span id="cb143-95"><a href="#cb143-95" aria-hidden="true" tabindex="-1"></a><span class="co">    Geschlossene Almgren-Chriss-Loesung fuer den kontinuierlichen Fall.</span></span>
+<span id="cb143-96"><a href="#cb143-96" aria-hidden="true" tabindex="-1"></a><span class="co">    Der optimale Pfad ist X_t = X_0 * sinh(kappa*(T-t)) / sinh(kappa*T)</span></span>
+<span id="cb143-97"><a href="#cb143-97" aria-hidden="true" tabindex="-1"></a><span class="co">    mit kappa = arccosh(tilde_kappa^2/2 + 1), tilde_kappa^2 = lambda*sigma^2*P0^2/eta.</span></span>
+<span id="cb143-98"><a href="#cb143-98" aria-hidden="true" tabindex="-1"></a><span class="co">    Dient hier als unabhaengige Kontrolle des DP-Ergebnisses.</span></span>
+<span id="cb143-99"><a href="#cb143-99" aria-hidden="true" tabindex="-1"></a><span class="co">    &quot;&quot;&quot;</span></span>
+<span id="cb143-100"><a href="#cb143-100" aria-hidden="true" tabindex="-1"></a>    kappa_tilde_quadrat <span class="op">=</span> (RISIKOAVERSION <span class="op">*</span> (VOLA_PERIODE <span class="op">**</span> <span class="dv">2</span>) <span class="op">*</span> (KURS <span class="op">**</span> <span class="dv">2</span>)) <span class="op">/</span> ETA</span>
+<span id="cb143-101"><a href="#cb143-101" aria-hidden="true" tabindex="-1"></a>    kappa <span class="op">=</span> np.arccosh(kappa_tilde_quadrat <span class="op">/</span> <span class="fl">2.0</span> <span class="op">+</span> <span class="fl">1.0</span>)</span>
+<span id="cb143-102"><a href="#cb143-102" aria-hidden="true" tabindex="-1"></a>    <span class="cf">if</span> kappa <span class="op">&lt;</span> <span class="fl">1e-12</span>:                        <span class="co"># Grenzfall: risikoneutral -&gt; linear</span></span>
+<span id="cb143-103"><a href="#cb143-103" aria-hidden="true" tabindex="-1"></a>        <span class="cf">return</span> np.linspace(GESAMTBESTAND, <span class="dv">0</span>, PERIODEN <span class="op">+</span> <span class="dv">1</span>)</span>
+<span id="cb143-104"><a href="#cb143-104" aria-hidden="true" tabindex="-1"></a>    t <span class="op">=</span> np.arange(PERIODEN <span class="op">+</span> <span class="dv">1</span>)</span>
+<span id="cb143-105"><a href="#cb143-105" aria-hidden="true" tabindex="-1"></a>    <span class="cf">return</span> GESAMTBESTAND <span class="op">*</span> np.sinh(kappa <span class="op">*</span> (PERIODEN <span class="op">-</span> t)) <span class="op">/</span> np.sinh(kappa <span class="op">*</span> PERIODEN)</span>
+<span id="cb143-106"><a href="#cb143-106" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb143-107"><a href="#cb143-107" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb143-108"><a href="#cb143-108" aria-hidden="true" tabindex="-1"></a><span class="kw">def</span> bewerte_pfad(bestaende):</span>
+<span id="cb143-109"><a href="#cb143-109" aria-hidden="true" tabindex="-1"></a>    <span class="co">&quot;&quot;&quot;Gesamtkosten eines beliebigen Bestandspfades.&quot;&quot;&quot;</span></span>
+<span id="cb143-110"><a href="#cb143-110" aria-hidden="true" tabindex="-1"></a>    summe <span class="op">=</span> <span class="fl">0.0</span></span>
+<span id="cb143-111"><a href="#cb143-111" aria-hidden="true" tabindex="-1"></a>    <span class="cf">for</span> t <span class="kw">in</span> <span class="bu">range</span>(<span class="bu">len</span>(bestaende) <span class="op">-</span> <span class="dv">1</span>):</span>
+<span id="cb143-112"><a href="#cb143-112" aria-hidden="true" tabindex="-1"></a>        verkauf <span class="op">=</span> bestaende[t] <span class="op">-</span> bestaende[t <span class="op">+</span> <span class="dv">1</span>]</span>
+<span id="cb143-113"><a href="#cb143-113" aria-hidden="true" tabindex="-1"></a>        summe <span class="op">+=</span> periodenkosten(verkauf, bestaende[t <span class="op">+</span> <span class="dv">1</span>])</span>
+<span id="cb143-114"><a href="#cb143-114" aria-hidden="true" tabindex="-1"></a>    <span class="cf">return</span> summe</span>
+<span id="cb143-115"><a href="#cb143-115" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb143-116"><a href="#cb143-116" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb143-117"><a href="#cb143-117" aria-hidden="true" tabindex="-1"></a><span class="cf">if</span> <span class="va">__name__</span> <span class="op">==</span> <span class="st">&quot;__main__&quot;</span>:</span>
+<span id="cb143-118"><a href="#cb143-118" aria-hidden="true" tabindex="-1"></a>    zustaende, V, politik <span class="op">=</span> loese_dp()</span>
+<span id="cb143-119"><a href="#cb143-119" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb143-120"><a href="#cb143-120" aria-hidden="true" tabindex="-1"></a>    <span class="co"># --- Vorwaertspfad der optimalen Politik -----------------------------</span></span>
+<span id="cb143-121"><a href="#cb143-121" aria-hidden="true" tabindex="-1"></a>    bestand <span class="op">=</span> GESAMTBESTAND</span>
+<span id="cb143-122"><a href="#cb143-122" aria-hidden="true" tabindex="-1"></a>    verlauf <span class="op">=</span> [bestand]</span>
+<span id="cb143-123"><a href="#cb143-123" aria-hidden="true" tabindex="-1"></a>    verkaeufe <span class="op">=</span> []</span>
+<span id="cb143-124"><a href="#cb143-124" aria-hidden="true" tabindex="-1"></a>    <span class="cf">for</span> t <span class="kw">in</span> <span class="bu">range</span>(PERIODEN):</span>
+<span id="cb143-125"><a href="#cb143-125" aria-hidden="true" tabindex="-1"></a>        idx <span class="op">=</span> <span class="bu">int</span>(<span class="bu">round</span>(bestand <span class="op">/</span> SCHRITTWEITE))</span>
+<span id="cb143-126"><a href="#cb143-126" aria-hidden="true" tabindex="-1"></a>        verkauf <span class="op">=</span> politik[t, idx]</span>
+<span id="cb143-127"><a href="#cb143-127" aria-hidden="true" tabindex="-1"></a>        verkaeufe.append(verkauf)</span>
+<span id="cb143-128"><a href="#cb143-128" aria-hidden="true" tabindex="-1"></a>        bestand <span class="op">-=</span> verkauf</span>
+<span id="cb143-129"><a href="#cb143-129" aria-hidden="true" tabindex="-1"></a>        verlauf.append(bestand)</span>
+<span id="cb143-130"><a href="#cb143-130" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb143-131"><a href="#cb143-131" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;=&quot;</span> <span class="op">*</span> <span class="dv">84</span>)</span>
+<span id="cb143-132"><a href="#cb143-132" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;   OPTIMALE MEHRPERIODIGE ORDER-EXECUTION (BELLMAN DP)&quot;</span>)</span>
+<span id="cb143-133"><a href="#cb143-133" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;=&quot;</span> <span class="op">*</span> <span class="dv">84</span>)</span>
+<span id="cb143-134"><a href="#cb143-134" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;Gesamtvolumen:       </span><span class="sc">{</span>GESAMTBESTAND<span class="sc">:,}</span><span class="ss"> Stueck zu </span><span class="sc">{</span>KURS<span class="sc">:.2f}</span><span class="ss"> EUR &quot;</span></span>
+<span id="cb143-135"><a href="#cb143-135" aria-hidden="true" tabindex="-1"></a>          <span class="ss">f&quot;= </span><span class="sc">{</span>GESAMTBESTAND<span class="op">*</span>KURS<span class="sc">:,.0f}</span><span class="ss"> EUR Positionswert&quot;</span>)</span>
+<span id="cb143-136"><a href="#cb143-136" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;Zeithorizont:        </span><span class="sc">{</span>PERIODEN<span class="sc">}</span><span class="ss"> Handelsperioden&quot;</span>)</span>
+<span id="cb143-137"><a href="#cb143-137" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;Volatilitaet:        </span><span class="sc">{</span>VOLA_JAHR<span class="op">*</span><span class="dv">100</span><span class="sc">:.0f}</span><span class="ss"> % p.a. &quot;</span></span>
+<span id="cb143-138"><a href="#cb143-138" aria-hidden="true" tabindex="-1"></a>          <span class="ss">f&quot;= </span><span class="sc">{</span>VOLA_PERIODE<span class="op">*</span><span class="dv">100</span><span class="sc">:.3f}</span><span class="ss"> % je Periode&quot;</span>)</span>
+<span id="cb143-139"><a href="#cb143-139" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;Slippage eta:        </span><span class="sc">{</span>ETA<span class="sc">:.2e}</span><span class="ss"> EUR/Stueck^2&quot;</span>)</span>
+<span id="cb143-140"><a href="#cb143-140" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;Risikoaversion:      </span><span class="sc">{</span>RISIKOAVERSION<span class="sc">:.2e}</span><span class="ss"> 1/EUR&quot;</span>)</span>
+<span id="cb143-141"><a href="#cb143-141" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;Erwartete Gesamtreibung: </span><span class="sc">{</span>V[<span class="dv">0</span>, <span class="op">-</span><span class="dv">1</span>]<span class="sc">:,.2f}</span><span class="ss"> EUR &quot;</span></span>
+<span id="cb143-142"><a href="#cb143-142" aria-hidden="true" tabindex="-1"></a>          <span class="ss">f&quot;(</span><span class="sc">{</span>V[<span class="dv">0</span>, <span class="op">-</span><span class="dv">1</span>]<span class="op">/</span>(GESAMTBESTAND<span class="op">*</span>KURS)<span class="op">*</span><span class="dv">10000</span><span class="sc">:.1f}</span><span class="ss"> Basispunkte)</span><span class="ch">\n</span><span class="ss">&quot;</span>)</span>
+<span id="cb143-143"><a href="#cb143-143" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb143-144"><a href="#cb143-144" aria-hidden="true" tabindex="-1"></a>    plan <span class="op">=</span> pd.DataFrame([{</span>
+<span id="cb143-145"><a href="#cb143-145" aria-hidden="true" tabindex="-1"></a>        <span class="st">&quot;Periode&quot;</span>: <span class="ss">f&quot;t = </span><span class="sc">{</span>t<span class="sc">}</span><span class="ss"> -&gt; </span><span class="sc">{</span>t<span class="op">+</span><span class="dv">1</span><span class="sc">}</span><span class="ss">&quot;</span>,</span>
+<span id="cb143-146"><a href="#cb143-146" aria-hidden="true" tabindex="-1"></a>        <span class="st">&quot;Startbestand&quot;</span>: <span class="ss">f&quot;</span><span class="sc">{</span>verlauf[t]<span class="sc">:,}</span><span class="ss">&quot;</span>,</span>
+<span id="cb143-147"><a href="#cb143-147" aria-hidden="true" tabindex="-1"></a>        <span class="st">&quot;Verkauf n_t&quot;</span>: <span class="ss">f&quot;</span><span class="sc">{</span>verkaeufe[t]<span class="sc">:,}</span><span class="ss">&quot;</span>,</span>
+<span id="cb143-148"><a href="#cb143-148" aria-hidden="true" tabindex="-1"></a>        <span class="st">&quot;Restbestand&quot;</span>: <span class="ss">f&quot;</span><span class="sc">{</span>verlauf[t<span class="op">+</span><span class="dv">1</span>]<span class="sc">:,}</span><span class="ss">&quot;</span>,</span>
+<span id="cb143-149"><a href="#cb143-149" aria-hidden="true" tabindex="-1"></a>        <span class="st">&quot;Anteil&quot;</span>: <span class="ss">f&quot;</span><span class="sc">{</span>verkaeufe[t]<span class="op">/</span>GESAMTBESTAND<span class="op">*</span><span class="dv">100</span><span class="sc">:5.1f}</span><span class="ss"> %&quot;</span>,</span>
+<span id="cb143-150"><a href="#cb143-150" aria-hidden="true" tabindex="-1"></a>        <span class="st">&quot;Kosten (EUR)&quot;</span>: <span class="ss">f&quot;</span><span class="sc">{</span>periodenkosten(verkaeufe[t], verlauf[t<span class="op">+</span><span class="dv">1</span>])<span class="sc">:,.0f}</span><span class="ss">&quot;</span>,</span>
+<span id="cb143-151"><a href="#cb143-151" aria-hidden="true" tabindex="-1"></a>    } <span class="cf">for</span> t <span class="kw">in</span> <span class="bu">range</span>(PERIODEN)])</span>
+<span id="cb143-152"><a href="#cb143-152" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(plan.to_string(index<span class="op">=</span><span class="va">False</span>))</span>
+<span id="cb143-153"><a href="#cb143-153" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb143-154"><a href="#cb143-154" aria-hidden="true" tabindex="-1"></a>    <span class="co"># --- Vergleich mit Alternativen und der analytischen Loesung ---------</span></span>
+<span id="cb143-155"><a href="#cb143-155" aria-hidden="true" tabindex="-1"></a>    sofort <span class="op">=</span> [GESAMTBESTAND] <span class="op">+</span> [<span class="dv">0</span>] <span class="op">*</span> PERIODEN</span>
+<span id="cb143-156"><a href="#cb143-156" aria-hidden="true" tabindex="-1"></a>    gleichmaessig <span class="op">=</span> [GESAMTBESTAND <span class="op">*</span> (<span class="dv">1</span> <span class="op">-</span> t <span class="op">/</span> PERIODEN) <span class="cf">for</span> t <span class="kw">in</span> <span class="bu">range</span>(PERIODEN <span class="op">+</span> <span class="dv">1</span>)]</span>
+<span id="cb143-157"><a href="#cb143-157" aria-hidden="true" tabindex="-1"></a>    analytisch <span class="op">=</span> analytische_loesung()</span>
+<span id="cb143-158"><a href="#cb143-158" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb143-159"><a href="#cb143-159" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;</span><span class="ch">\n</span><span class="st">&quot;</span> <span class="op">+</span> <span class="st">&quot;-&quot;</span> <span class="op">*</span> <span class="dv">84</span>)</span>
+<span id="cb143-160"><a href="#cb143-160" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;</span><span class="sc">{</span><span class="st">&#39;Strategie&#39;</span><span class="sc">:&lt;34}</span><span class="ss"> </span><span class="sc">{</span><span class="st">&#39;Kosten (EUR)&#39;</span><span class="sc">:&gt;15}</span><span class="ss"> </span><span class="sc">{</span><span class="st">&#39;Basispunkte&#39;</span><span class="sc">:&gt;13}</span><span class="ss"> &quot;</span></span>
+<span id="cb143-161"><a href="#cb143-161" aria-hidden="true" tabindex="-1"></a>          <span class="ss">f&quot;</span><span class="sc">{</span><span class="st">&#39;ggue. Optimum&#39;</span><span class="sc">:&gt;16}</span><span class="ss">&quot;</span>)</span>
+<span id="cb143-162"><a href="#cb143-162" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;-&quot;</span> <span class="op">*</span> <span class="dv">84</span>)</span>
+<span id="cb143-163"><a href="#cb143-163" aria-hidden="true" tabindex="-1"></a>    optimum <span class="op">=</span> V[<span class="dv">0</span>, <span class="op">-</span><span class="dv">1</span>]</span>
+<span id="cb143-164"><a href="#cb143-164" aria-hidden="true" tabindex="-1"></a>    <span class="cf">for</span> name, pfad <span class="kw">in</span> [(<span class="st">&quot;DP-Optimum&quot;</span>, verlauf),</span>
+<span id="cb143-165"><a href="#cb143-165" aria-hidden="true" tabindex="-1"></a>                       (<span class="st">&quot;Analytisch (Almgren-Chriss)&quot;</span>, <span class="bu">list</span>(analytisch)),</span>
+<span id="cb143-166"><a href="#cb143-166" aria-hidden="true" tabindex="-1"></a>                       (<span class="st">&quot;Gleichmaessig (TWAP)&quot;</span>, gleichmaessig),</span>
+<span id="cb143-167"><a href="#cb143-167" aria-hidden="true" tabindex="-1"></a>                       (<span class="st">&quot;Alles sofort&quot;</span>, sofort)]:</span>
+<span id="cb143-168"><a href="#cb143-168" aria-hidden="true" tabindex="-1"></a>        kosten <span class="op">=</span> bewerte_pfad(pfad)</span>
+<span id="cb143-169"><a href="#cb143-169" aria-hidden="true" tabindex="-1"></a>        bp <span class="op">=</span> kosten <span class="op">/</span> (GESAMTBESTAND <span class="op">*</span> KURS) <span class="op">*</span> <span class="dv">10000</span></span>
+<span id="cb143-170"><a href="#cb143-170" aria-hidden="true" tabindex="-1"></a>        <span class="bu">print</span>(<span class="ss">f&quot;</span><span class="sc">{</span>name<span class="sc">:&lt;34}</span><span class="ss"> </span><span class="sc">{</span>kosten<span class="sc">:&gt;15,.0f}</span><span class="ss"> </span><span class="sc">{</span>bp<span class="sc">:&gt;12.1f}</span><span class="ss"> &quot;</span></span>
+<span id="cb143-171"><a href="#cb143-171" aria-hidden="true" tabindex="-1"></a>              <span class="ss">f&quot;</span><span class="sc">{</span>kosten <span class="op">-</span> optimum<span class="sc">:&gt;+15,.0f}</span><span class="ss">&quot;</span>)</span>
+<span id="cb143-172"><a href="#cb143-172" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb143-173"><a href="#cb143-173" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;-&quot;</span> <span class="op">*</span> <span class="dv">84</span>)</span>
+<span id="cb143-174"><a href="#cb143-174" aria-hidden="true" tabindex="-1"></a>    abweichung <span class="op">=</span> <span class="bu">abs</span>(bewerte_pfad(<span class="bu">list</span>(analytisch)) <span class="op">-</span> optimum) <span class="op">/</span> optimum</span>
+<span id="cb143-175"><a href="#cb143-175" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;Abweichung DP zur analytischen Loesung: </span><span class="sc">{</span>abweichung<span class="op">*</span><span class="dv">100</span><span class="sc">:.3f}</span><span class="ss"> % &quot;</span></span>
+<span id="cb143-176"><a href="#cb143-176" aria-hidden="true" tabindex="-1"></a>          <span class="ss">f&quot;(Diskretisierung: </span><span class="sc">{</span>SCHRITTWEITE<span class="sc">}</span><span class="ss"> Stueck)&quot;</span>)</span>
+<span id="cb143-177"><a href="#cb143-177" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb143-178"><a href="#cb143-178" aria-hidden="true" tabindex="-1"></a>    <span class="co"># --- Sensitivitaet gegenueber der Risikoaversion ---------------------</span></span>
+<span id="cb143-179"><a href="#cb143-179" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;</span><span class="ch">\n</span><span class="st">--- Wie wirkt die Risikoaversion? ---&quot;</span>)</span>
+<span id="cb143-180"><a href="#cb143-180" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;</span><span class="sc">{</span><span class="st">&#39;lambda&#39;</span><span class="sc">:&gt;10}</span><span class="ss"> | </span><span class="sc">{</span><span class="st">&#39;Verkauf in Periode 0&#39;</span><span class="sc">:&gt;22}</span><span class="ss"> | </span><span class="sc">{</span><span class="st">&#39;Charakter&#39;</span><span class="sc">:&lt;28}</span><span class="ss">&quot;</span>)</span>
+<span id="cb143-181"><a href="#cb143-181" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;-&quot;</span> <span class="op">*</span> <span class="dv">70</span>)</span>
+<span id="cb143-182"><a href="#cb143-182" aria-hidden="true" tabindex="-1"></a>    <span class="cf">for</span> lam <span class="kw">in</span> [<span class="fl">1e-7</span>, <span class="fl">1e-6</span>, <span class="fl">1e-5</span>, <span class="fl">1e-4</span>, <span class="fl">1e-3</span>]:</span>
+<span id="cb143-183"><a href="#cb143-183" aria-hidden="true" tabindex="-1"></a>        <span class="bu">globals</span>()[<span class="st">&quot;RISIKOAVERSION&quot;</span>] <span class="op">=</span> lam</span>
+<span id="cb143-184"><a href="#cb143-184" aria-hidden="true" tabindex="-1"></a>        _, V_l, pol_l <span class="op">=</span> loese_dp()</span>
+<span id="cb143-185"><a href="#cb143-185" aria-hidden="true" tabindex="-1"></a>        erste <span class="op">=</span> pol_l[<span class="dv">0</span>, <span class="op">-</span><span class="dv">1</span>]</span>
+<span id="cb143-186"><a href="#cb143-186" aria-hidden="true" tabindex="-1"></a>        anteil <span class="op">=</span> erste <span class="op">/</span> GESAMTBESTAND <span class="op">*</span> <span class="dv">100</span></span>
+<span id="cb143-187"><a href="#cb143-187" aria-hidden="true" tabindex="-1"></a>        charakter <span class="op">=</span> (<span class="st">&quot;nahezu gleichmaessig&quot;</span> <span class="cf">if</span> anteil <span class="op">&lt;</span> <span class="dv">25</span> <span class="cf">else</span></span>
+<span id="cb143-188"><a href="#cb143-188" aria-hidden="true" tabindex="-1"></a>                     <span class="st">&quot;front-loaded&quot;</span> <span class="cf">if</span> anteil <span class="op">&lt;</span> <span class="dv">60</span> <span class="cf">else</span> <span class="st">&quot;fast alles sofort&quot;</span>)</span>
+<span id="cb143-189"><a href="#cb143-189" aria-hidden="true" tabindex="-1"></a>        <span class="bu">print</span>(<span class="ss">f&quot;</span><span class="sc">{</span>lam<span class="sc">:&gt;10.0e}</span><span class="ss"> | </span><span class="sc">{</span>erste<span class="sc">:&gt;13,}</span><span class="ss"> (</span><span class="sc">{</span>anteil<span class="sc">:5.1f}</span><span class="ss"> %) | </span><span class="sc">{</span>charakter<span class="sc">:&lt;28}</span><span class="ss">&quot;</span>)</span>
+<span id="cb143-190"><a href="#cb143-190" aria-hidden="true" tabindex="-1"></a>    <span class="bu">globals</span>()[<span class="st">&quot;RISIKOAVERSION&quot;</span>] <span class="op">=</span> <span class="fl">1e-5</span>       <span class="co"># zuruecksetzen</span></span>
+<span id="cb143-191"><a href="#cb143-191" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb143-192"><a href="#cb143-192" aria-hidden="true" tabindex="-1"></a>    <span class="co"># --- Diagramm ---------------------------------------------------------</span></span>
+<span id="cb143-193"><a href="#cb143-193" aria-hidden="true" tabindex="-1"></a>    plt.figure(figsize<span class="op">=</span>(<span class="dv">10</span>, <span class="fl">5.5</span>))</span>
+<span id="cb143-194"><a href="#cb143-194" aria-hidden="true" tabindex="-1"></a>    plt.plot(<span class="bu">range</span>(PERIODEN <span class="op">+</span> <span class="dv">1</span>), verlauf, <span class="st">&quot;o-&quot;</span>, lw<span class="op">=</span><span class="fl">2.5</span>, label<span class="op">=</span><span class="st">&quot;DP-Optimum&quot;</span>)</span>
+<span id="cb143-195"><a href="#cb143-195" aria-hidden="true" tabindex="-1"></a>    plt.plot(<span class="bu">range</span>(PERIODEN <span class="op">+</span> <span class="dv">1</span>), analytisch, <span class="st">&quot;s--&quot;</span>, lw<span class="op">=</span><span class="fl">1.8</span>, alpha<span class="op">=</span><span class="fl">0.8</span>,</span>
+<span id="cb143-196"><a href="#cb143-196" aria-hidden="true" tabindex="-1"></a>             label<span class="op">=</span><span class="st">&quot;Analytisch (Almgren-Chriss)&quot;</span>)</span>
+<span id="cb143-197"><a href="#cb143-197" aria-hidden="true" tabindex="-1"></a>    plt.plot(<span class="bu">range</span>(PERIODEN <span class="op">+</span> <span class="dv">1</span>), gleichmaessig, <span class="st">&quot;^:&quot;</span>, lw<span class="op">=</span><span class="fl">1.8</span>, alpha<span class="op">=</span><span class="fl">0.8</span>,</span>
+<span id="cb143-198"><a href="#cb143-198" aria-hidden="true" tabindex="-1"></a>             label<span class="op">=</span><span class="st">&quot;Gleichmaessig (TWAP)&quot;</span>)</span>
+<span id="cb143-199"><a href="#cb143-199" aria-hidden="true" tabindex="-1"></a>    plt.bar(<span class="bu">range</span>(PERIODEN), verkaeufe, alpha<span class="op">=</span><span class="fl">0.25</span>, color<span class="op">=</span><span class="st">&quot;orange&quot;</span>, width<span class="op">=</span><span class="fl">0.45</span>,</span>
+<span id="cb143-200"><a href="#cb143-200" aria-hidden="true" tabindex="-1"></a>            label<span class="op">=</span><span class="st">&quot;Verkaufstranche $n_t$&quot;</span>)</span>
+<span id="cb143-201"><a href="#cb143-201" aria-hidden="true" tabindex="-1"></a>    plt.title(<span class="st">&quot;Optimaler Liquidationspfad ueber diskrete Perioden&quot;</span>, fontsize<span class="op">=</span><span class="dv">12</span>)</span>
+<span id="cb143-202"><a href="#cb143-202" aria-hidden="true" tabindex="-1"></a>    plt.xlabel(<span class="st">&quot;Handelsperiode $t$&quot;</span>)</span>
+<span id="cb143-203"><a href="#cb143-203" aria-hidden="true" tabindex="-1"></a>    plt.ylabel(<span class="st">&quot;Verbleibender Bestand $X_t$&quot;</span>)</span>
+<span id="cb143-204"><a href="#cb143-204" aria-hidden="true" tabindex="-1"></a>    plt.xticks(<span class="bu">range</span>(PERIODEN <span class="op">+</span> <span class="dv">1</span>))</span>
+<span id="cb143-205"><a href="#cb143-205" aria-hidden="true" tabindex="-1"></a>    plt.grid(<span class="va">True</span>, linestyle<span class="op">=</span><span class="st">&quot;:&quot;</span>, alpha<span class="op">=</span><span class="fl">0.6</span>)</span>
+<span id="cb143-206"><a href="#cb143-206" aria-hidden="true" tabindex="-1"></a>    plt.legend()</span>
+<span id="cb143-207"><a href="#cb143-207" aria-hidden="true" tabindex="-1"></a>    plt.tight_layout()</span>
+<span id="cb143-208"><a href="#cb143-208" aria-hidden="true" tabindex="-1"></a>    ziel <span class="op">=</span> os.path.join(OUTPUT_DIR, <span class="st">&quot;optimal_execution_dp.png&quot;</span>)</span>
+<span id="cb143-209"><a href="#cb143-209" aria-hidden="true" tabindex="-1"></a>    plt.savefig(ziel, dpi<span class="op">=</span><span class="dv">150</span>)</span>
+<span id="cb143-210"><a href="#cb143-210" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;</span><span class="ch">\n</span><span class="ss">Diagramm gespeichert unter &#39;</span><span class="sc">{</span>ziel<span class="sc">}</span><span class="ss">&#39;&quot;</span>)</span>
+<span id="cb143-211"><a href="#cb143-211" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;=&quot;</span> <span class="op">*</span> <span class="dv">84</span>)</span></code></pre></div>
 <p><strong>Erwartete Ausgabe:</strong></p>
 <pre><code>====================================================================================
    OPTIMALE MEHRPERIODIGE ORDER-EXECUTION (BELLMAN DP)
@@ -18322,7 +19187,7 @@ Abweichung DP zur analytischen Loesung: 5.788 % (Diskretisierung: 1000 Stueck)
 <h2 id="sec:dynamische-programmierung-denkfehler">13.7 Finde den Denkfehler</h2>
 <p>Bei dynamischer Programmierung entscheidet eine einzige Frage über Erfolg oder Misserfolg: <strong>Was gehört in den Zustand?</strong> Ist er zu klein, rechnet das Verfahren völlig korrekt — nur eben an einem anderen Problem.</p>
 <blockquote>
-<p><strong>🐛 Finde den Denkfehler 10.1: Der Zustand, der zu wenig weiß</strong></p>
+<p><strong>🐛 Finde den Denkfehler: Der Zustand, der zu wenig weiß</strong></p>
 <p>Eine Werkstatt plant vier Perioden. Der Bedarf beträgt 3, 1, 4, 2 Stück; produziert werden können höchstens 5 je Periode, gelagert höchstens 6 Stück.</p>
 <table>
 <colgroup>
@@ -18351,22 +19216,22 @@ Abweichung DP zur analytischen Loesung: 5.788 % (Diskretisierung: 1000 Stueck)
 </tbody>
 </table>
 <p>Der Entwickler überlegt: <em>„Für die Zukunft zählt nur, wie viel ich auf Lager habe. Also ist der Lagerbestand mein Zustand.“</em></p>
-<div class="sourceCode" id="cb143"><pre class="sourceCode python"><code class="sourceCode python"><span id="cb143-1"><a href="#cb143-1" aria-hidden="true" tabindex="-1"></a><span class="im">import</span> functools</span>
-<span id="cb143-2"><a href="#cb143-2" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb143-3"><a href="#cb143-3" aria-hidden="true" tabindex="-1"></a><span class="at">@functools.lru_cache</span>(<span class="va">None</span>)</span>
-<span id="cb143-4"><a href="#cb143-4" aria-hidden="true" tabindex="-1"></a><span class="kw">def</span> V(t, lager):</span>
-<span id="cb143-5"><a href="#cb143-5" aria-hidden="true" tabindex="-1"></a>    <span class="cf">if</span> t <span class="op">==</span> <span class="dv">4</span>:</span>
-<span id="cb143-6"><a href="#cb143-6" aria-hidden="true" tabindex="-1"></a>        <span class="cf">return</span> (<span class="fl">0.0</span>, ())</span>
-<span id="cb143-7"><a href="#cb143-7" aria-hidden="true" tabindex="-1"></a>    best <span class="op">=</span> (<span class="bu">float</span>(<span class="st">&quot;inf&quot;</span>), ())</span>
-<span id="cb143-8"><a href="#cb143-8" aria-hidden="true" tabindex="-1"></a>    <span class="cf">for</span> p <span class="kw">in</span> <span class="bu">range</span>(KAP <span class="op">+</span> <span class="dv">1</span>):</span>
-<span id="cb143-9"><a href="#cb143-9" aria-hidden="true" tabindex="-1"></a>        neu <span class="op">=</span> lager <span class="op">+</span> p <span class="op">-</span> BEDARF[t]</span>
-<span id="cb143-10"><a href="#cb143-10" aria-hidden="true" tabindex="-1"></a>        <span class="cf">if</span> neu <span class="op">&lt;</span> <span class="dv">0</span> <span class="kw">or</span> neu <span class="op">&gt;</span> LAGER_MAX:</span>
-<span id="cb143-11"><a href="#cb143-11" aria-hidden="true" tabindex="-1"></a>            <span class="cf">continue</span></span>
-<span id="cb143-12"><a href="#cb143-12" aria-hidden="true" tabindex="-1"></a>        kosten <span class="op">=</span> (RUESTKOSTEN <span class="cf">if</span> p <span class="op">&gt;</span> <span class="dv">0</span> <span class="cf">else</span> <span class="dv">0</span>) <span class="op">+</span> STUECKKOSTEN <span class="op">*</span> p <span class="op">+</span> LAGERKOSTEN <span class="op">*</span> neu</span>
-<span id="cb143-13"><a href="#cb143-13" aria-hidden="true" tabindex="-1"></a>        rest, plan <span class="op">=</span> V(t <span class="op">+</span> <span class="dv">1</span>, neu)</span>
-<span id="cb143-14"><a href="#cb143-14" aria-hidden="true" tabindex="-1"></a>        <span class="cf">if</span> kosten <span class="op">+</span> rest <span class="op">&lt;</span> best[<span class="dv">0</span>]:</span>
-<span id="cb143-15"><a href="#cb143-15" aria-hidden="true" tabindex="-1"></a>            best <span class="op">=</span> (kosten <span class="op">+</span> rest, (p,) <span class="op">+</span> plan)</span>
-<span id="cb143-16"><a href="#cb143-16" aria-hidden="true" tabindex="-1"></a>    <span class="cf">return</span> best</span></code></pre></div>
+<div class="sourceCode" id="cb145"><pre class="sourceCode python"><code class="sourceCode python"><span id="cb145-1"><a href="#cb145-1" aria-hidden="true" tabindex="-1"></a><span class="im">import</span> functools</span>
+<span id="cb145-2"><a href="#cb145-2" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb145-3"><a href="#cb145-3" aria-hidden="true" tabindex="-1"></a><span class="at">@functools.lru_cache</span>(<span class="va">None</span>)</span>
+<span id="cb145-4"><a href="#cb145-4" aria-hidden="true" tabindex="-1"></a><span class="kw">def</span> V(t, lager):</span>
+<span id="cb145-5"><a href="#cb145-5" aria-hidden="true" tabindex="-1"></a>    <span class="cf">if</span> t <span class="op">==</span> <span class="dv">4</span>:</span>
+<span id="cb145-6"><a href="#cb145-6" aria-hidden="true" tabindex="-1"></a>        <span class="cf">return</span> (<span class="fl">0.0</span>, ())</span>
+<span id="cb145-7"><a href="#cb145-7" aria-hidden="true" tabindex="-1"></a>    best <span class="op">=</span> (<span class="bu">float</span>(<span class="st">&quot;inf&quot;</span>), ())</span>
+<span id="cb145-8"><a href="#cb145-8" aria-hidden="true" tabindex="-1"></a>    <span class="cf">for</span> p <span class="kw">in</span> <span class="bu">range</span>(KAP <span class="op">+</span> <span class="dv">1</span>):</span>
+<span id="cb145-9"><a href="#cb145-9" aria-hidden="true" tabindex="-1"></a>        neu <span class="op">=</span> lager <span class="op">+</span> p <span class="op">-</span> BEDARF[t]</span>
+<span id="cb145-10"><a href="#cb145-10" aria-hidden="true" tabindex="-1"></a>        <span class="cf">if</span> neu <span class="op">&lt;</span> <span class="dv">0</span> <span class="kw">or</span> neu <span class="op">&gt;</span> LAGER_MAX:</span>
+<span id="cb145-11"><a href="#cb145-11" aria-hidden="true" tabindex="-1"></a>            <span class="cf">continue</span></span>
+<span id="cb145-12"><a href="#cb145-12" aria-hidden="true" tabindex="-1"></a>        kosten <span class="op">=</span> (RUESTKOSTEN <span class="cf">if</span> p <span class="op">&gt;</span> <span class="dv">0</span> <span class="cf">else</span> <span class="dv">0</span>) <span class="op">+</span> STUECKKOSTEN <span class="op">*</span> p <span class="op">+</span> LAGERKOSTEN <span class="op">*</span> neu</span>
+<span id="cb145-13"><a href="#cb145-13" aria-hidden="true" tabindex="-1"></a>        rest, plan <span class="op">=</span> V(t <span class="op">+</span> <span class="dv">1</span>, neu)</span>
+<span id="cb145-14"><a href="#cb145-14" aria-hidden="true" tabindex="-1"></a>        <span class="cf">if</span> kosten <span class="op">+</span> rest <span class="op">&lt;</span> best[<span class="dv">0</span>]:</span>
+<span id="cb145-15"><a href="#cb145-15" aria-hidden="true" tabindex="-1"></a>            best <span class="op">=</span> (kosten <span class="op">+</span> rest, (p,) <span class="op">+</span> plan)</span>
+<span id="cb145-16"><a href="#cb145-16" aria-hidden="true" tabindex="-1"></a>    <span class="cf">return</span> best</span></code></pre></div>
 <p><strong>Ergebnis:</strong> Plan <span class="math inline">(5, 0, 5, 0)</span> für <strong>110 €</strong>. Nachgerechnet stimmt der Betrag sogar — dieser Plan kostet tatsächlich 110 €. Das wahre Optimum lautet aber <span class="math inline">(3, 1, 4, 2)</span> und kostet <strong>70 €</strong>.</p>
 <p><strong>Ihre Aufgabe:</strong> (a) Sehen Sie sich die Zeile mit den Rüstkosten an. Welche Information bräuchte sie, die im Zustand <code>(t, lager)</code> nicht enthalten ist? (b) Welchen Vorteil des Plans <span class="math inline">(3,1,4,2)</span> kann dieses Modell prinzipiell nicht erkennen? (c) Wie lautet der korrigierte Zustand, und um welchen Faktor wächst der Zustandsraum dadurch? (d) Warum ist es besonders tückisch, dass der ausgegebene Kostenbetrag <em>richtig</em> war?</p>
 <p><em>Auflösung: <a href="#sec:loesungen-dynamische-programmierung">Abschnitt A.13</a>.</em></p>
@@ -18377,7 +19242,7 @@ Abweichung DP zur analytischen Loesung: 5.788 % (Diskretisierung: 1000 Stueck)
 <hr />
 <h2 id="sec:dynamische-programmierung-quiz">13.8 Micro-Quiz</h2>
 <blockquote>
-<p><strong>❓ Micro-Quiz 10: Drei Fragen zum Selbstcheck</strong></p>
+<p><strong>❓ Micro-Quiz 13: Drei Fragen zum Selbstcheck</strong></p>
 <p>Genau eine Antwort ist jeweils richtig. Auflösung in <a href="#quiz-loesung-dynamische-programmierung">Anhang A</a>.</p>
 <p><strong>1. Warum rechnet dynamische Programmierung rückwärts?</strong> (a) Weil Rekursion in Python rückwärts effizienter ist. (b) Weil <span class="math inline">V_t</span> den Wert <span class="math inline">V_{t+1}</span> voraussetzt: Man kann eine Entscheidung erst bewerten, wenn man weiß, was sie für die Zukunft bedeutet. Am Ende ist dieser Wert bekannt — dort beginnt man. (c) Weil die Kosten in späteren Perioden höher sind.</p>
 <p><strong>2. Was besagt das Bellmansche Optimalitätsprinzip?</strong> (a) Jede optimale Lösung besteht aus lauter einzeln optimalen Schritten — man kann also gierig vorgehen. (b) Ist ein Weg insgesamt optimal, so ist auch sein <strong>Reststück</strong> ab jedem Zwischenzustand optimal. Deshalb genügt es, je Zustand einen einzigen Wert zu speichern. (c) Bei genügend Rechenzeit findet man das Optimum immer.</p>
@@ -18427,30 +19292,30 @@ Abweichung DP zur analytischen Loesung: 5.788 % (Diskretisierung: 1000 Stueck)
 <p><strong>🚀 In 5 Minuten gelöst: Was kostet ein Kilogramm CO₂?</strong></p>
 <p>Eine Spedition vergibt fünf Sendungen an LKW, Bahn oder Kombinierten Verkehr. Der LKW ist billig und schmutzig, die Bahn teuer und sauber — und es sind nur zwei Trassen frei.</p>
 <p>Statt zu fragen „wie wichtig ist uns CO₂?” fragen wir: <strong>Was bekommen wir für zwei Prozent mehr Geld?</strong></p>
-<div class="sourceCode" id="cb144"><pre class="sourceCode python"><code class="sourceCode python"><span id="cb144-1"><a href="#cb144-1" aria-hidden="true" tabindex="-1"></a><span class="im">import</span> numpy <span class="im">as</span> np</span>
-<span id="cb144-2"><a href="#cb144-2" aria-hidden="true" tabindex="-1"></a><span class="im">from</span> scipy.optimize <span class="im">import</span> linprog</span>
-<span id="cb144-3"><a href="#cb144-3" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb144-4"><a href="#cb144-4" aria-hidden="true" tabindex="-1"></a><span class="co">#                       LKW   Bahn  Kombi     LKW billig+schmutzig, Bahn teuer+sauber</span></span>
-<span id="cb144-5"><a href="#cb144-5" aria-hidden="true" tabindex="-1"></a>kosten <span class="op">=</span> np.array([[  <span class="dv">900</span>, <span class="dv">1150</span>, <span class="dv">1020</span>], [ <span class="dv">620</span>,  <span class="dv">790</span>,  <span class="dv">700</span>], [<span class="dv">1300</span>, <span class="dv">1660</span>, <span class="dv">1470</span>],</span>
-<span id="cb144-6"><a href="#cb144-6" aria-hidden="true" tabindex="-1"></a>                   [  <span class="dv">480</span>,  <span class="dv">610</span>,  <span class="dv">545</span>], [<span class="dv">1050</span>, <span class="dv">1340</span>, <span class="dv">1180</span>]], dtype<span class="op">=</span><span class="bu">float</span>)</span>
-<span id="cb144-7"><a href="#cb144-7" aria-hidden="true" tabindex="-1"></a>co2    <span class="op">=</span> np.array([[ <span class="dv">1400</span>,  <span class="dv">310</span>,  <span class="dv">760</span>], [ <span class="dv">980</span>,  <span class="dv">220</span>,  <span class="dv">530</span>], [<span class="dv">2000</span>,  <span class="dv">440</span>, <span class="dv">1080</span>],</span>
-<span id="cb144-8"><a href="#cb144-8" aria-hidden="true" tabindex="-1"></a>                   [  <span class="dv">760</span>,  <span class="dv">170</span>,  <span class="dv">410</span>], [<span class="dv">1620</span>,  <span class="dv">360</span>,  <span class="dv">880</span>]], dtype<span class="op">=</span><span class="bu">float</span>)</span>
-<span id="cb144-9"><a href="#cb144-9" aria-hidden="true" tabindex="-1"></a>eine_pro_sendung <span class="op">=</span> np.repeat(np.eye(<span class="dv">5</span>), <span class="dv">3</span>, axis<span class="op">=</span><span class="dv">1</span>)</span>
-<span id="cb144-10"><a href="#cb144-10" aria-hidden="true" tabindex="-1"></a>bahn_trassen     <span class="op">=</span> [[<span class="fl">1.0</span> <span class="cf">if</span> j <span class="op">==</span> <span class="dv">1</span> <span class="cf">else</span> <span class="fl">0.0</span> <span class="cf">for</span> _ <span class="kw">in</span> <span class="bu">range</span>(<span class="dv">5</span>) <span class="cf">for</span> j <span class="kw">in</span> <span class="bu">range</span>(<span class="dv">3</span>)]]</span>
-<span id="cb144-11"><a href="#cb144-11" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb144-12"><a href="#cb144-12" aria-hidden="true" tabindex="-1"></a><span class="kw">def</span> plane(ziel, kostenbudget<span class="op">=</span><span class="va">None</span>):</span>
-<span id="cb144-13"><a href="#cb144-13" aria-hidden="true" tabindex="-1"></a>    A, b <span class="op">=</span> <span class="bu">list</span>(bahn_trassen), [<span class="fl">2.0</span>]                       <span class="co"># nur zwei Trassen frei</span></span>
-<span id="cb144-14"><a href="#cb144-14" aria-hidden="true" tabindex="-1"></a>    <span class="cf">if</span> kostenbudget <span class="kw">is</span> <span class="kw">not</span> <span class="va">None</span>:</span>
-<span id="cb144-15"><a href="#cb144-15" aria-hidden="true" tabindex="-1"></a>        A.append(kosten.reshape(<span class="op">-</span><span class="dv">1</span>))<span class="op">;</span> b.append(kostenbudget)</span>
-<span id="cb144-16"><a href="#cb144-16" aria-hidden="true" tabindex="-1"></a>    x <span class="op">=</span> linprog(ziel.reshape(<span class="op">-</span><span class="dv">1</span>), A_ub<span class="op">=</span>A, b_ub<span class="op">=</span>b, A_eq<span class="op">=</span>eine_pro_sendung,</span>
-<span id="cb144-17"><a href="#cb144-17" aria-hidden="true" tabindex="-1"></a>                b_eq<span class="op">=</span>np.ones(<span class="dv">5</span>), bounds<span class="op">=</span>(<span class="dv">0</span>, <span class="dv">1</span>), integrality<span class="op">=</span><span class="dv">1</span>, method<span class="op">=</span><span class="st">&quot;highs&quot;</span>).x</span>
-<span id="cb144-18"><a href="#cb144-18" aria-hidden="true" tabindex="-1"></a>    <span class="cf">return</span> kosten.reshape(<span class="op">-</span><span class="dv">1</span>) <span class="op">@</span> x, co2.reshape(<span class="op">-</span><span class="dv">1</span>) <span class="op">@</span> x</span>
-<span id="cb144-19"><a href="#cb144-19" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb144-20"><a href="#cb144-20" aria-hidden="true" tabindex="-1"></a>k0, c0 <span class="op">=</span> plane(kosten)                                     <span class="co"># nur Kosten minimieren</span></span>
-<span id="cb144-21"><a href="#cb144-21" aria-hidden="true" tabindex="-1"></a>k1, c1 <span class="op">=</span> plane(co2, kostenbudget<span class="op">=</span>k0 <span class="op">*</span> <span class="fl">1.02</span>)                <span class="co"># 2 % mehr ausgeben</span></span>
-<span id="cb144-22"><a href="#cb144-22" aria-hidden="true" tabindex="-1"></a><span class="bu">print</span>(<span class="ss">f&quot;guenstigster Plan:  </span><span class="sc">{</span>k0<span class="sc">:&gt;7,.0f}</span><span class="ss"> EUR   </span><span class="sc">{</span>c0<span class="sc">:&gt;6,.0f}</span><span class="ss"> kg CO2&quot;</span>)</span>
-<span id="cb144-23"><a href="#cb144-23" aria-hidden="true" tabindex="-1"></a><span class="bu">print</span>(<span class="ss">f&quot;mit 2 % Aufpreis:   </span><span class="sc">{</span>k1<span class="sc">:&gt;7,.0f}</span><span class="ss"> EUR   </span><span class="sc">{</span>c1<span class="sc">:&gt;6,.0f}</span><span class="ss"> kg CO2   &quot;</span></span>
-<span id="cb144-24"><a href="#cb144-24" aria-hidden="true" tabindex="-1"></a>      <span class="ss">f&quot;(</span><span class="sc">{</span>(c0<span class="op">-</span>c1)<span class="op">/</span>c0<span class="sc">:.0%}</span><span class="ss"> weniger, </span><span class="sc">{</span>(k1<span class="op">-</span>k0)<span class="op">/</span>(c0<span class="op">-</span>c1)<span class="sc">:.2f}</span><span class="ss"> EUR je kg)&quot;</span>)</span></code></pre></div>
+<div class="sourceCode" id="cb146"><pre class="sourceCode python"><code class="sourceCode python"><span id="cb146-1"><a href="#cb146-1" aria-hidden="true" tabindex="-1"></a><span class="im">import</span> numpy <span class="im">as</span> np</span>
+<span id="cb146-2"><a href="#cb146-2" aria-hidden="true" tabindex="-1"></a><span class="im">from</span> scipy.optimize <span class="im">import</span> linprog</span>
+<span id="cb146-3"><a href="#cb146-3" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb146-4"><a href="#cb146-4" aria-hidden="true" tabindex="-1"></a><span class="co">#                       LKW   Bahn  Kombi     LKW billig+schmutzig, Bahn teuer+sauber</span></span>
+<span id="cb146-5"><a href="#cb146-5" aria-hidden="true" tabindex="-1"></a>kosten <span class="op">=</span> np.array([[  <span class="dv">900</span>, <span class="dv">1150</span>, <span class="dv">1020</span>], [ <span class="dv">620</span>,  <span class="dv">790</span>,  <span class="dv">700</span>], [<span class="dv">1300</span>, <span class="dv">1660</span>, <span class="dv">1470</span>],</span>
+<span id="cb146-6"><a href="#cb146-6" aria-hidden="true" tabindex="-1"></a>                   [  <span class="dv">480</span>,  <span class="dv">610</span>,  <span class="dv">545</span>], [<span class="dv">1050</span>, <span class="dv">1340</span>, <span class="dv">1180</span>]], dtype<span class="op">=</span><span class="bu">float</span>)</span>
+<span id="cb146-7"><a href="#cb146-7" aria-hidden="true" tabindex="-1"></a>co2    <span class="op">=</span> np.array([[ <span class="dv">1400</span>,  <span class="dv">310</span>,  <span class="dv">760</span>], [ <span class="dv">980</span>,  <span class="dv">220</span>,  <span class="dv">530</span>], [<span class="dv">2000</span>,  <span class="dv">440</span>, <span class="dv">1080</span>],</span>
+<span id="cb146-8"><a href="#cb146-8" aria-hidden="true" tabindex="-1"></a>                   [  <span class="dv">760</span>,  <span class="dv">170</span>,  <span class="dv">410</span>], [<span class="dv">1620</span>,  <span class="dv">360</span>,  <span class="dv">880</span>]], dtype<span class="op">=</span><span class="bu">float</span>)</span>
+<span id="cb146-9"><a href="#cb146-9" aria-hidden="true" tabindex="-1"></a>eine_pro_sendung <span class="op">=</span> np.repeat(np.eye(<span class="dv">5</span>), <span class="dv">3</span>, axis<span class="op">=</span><span class="dv">1</span>)</span>
+<span id="cb146-10"><a href="#cb146-10" aria-hidden="true" tabindex="-1"></a>bahn_trassen     <span class="op">=</span> [[<span class="fl">1.0</span> <span class="cf">if</span> j <span class="op">==</span> <span class="dv">1</span> <span class="cf">else</span> <span class="fl">0.0</span> <span class="cf">for</span> _ <span class="kw">in</span> <span class="bu">range</span>(<span class="dv">5</span>) <span class="cf">for</span> j <span class="kw">in</span> <span class="bu">range</span>(<span class="dv">3</span>)]]</span>
+<span id="cb146-11"><a href="#cb146-11" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb146-12"><a href="#cb146-12" aria-hidden="true" tabindex="-1"></a><span class="kw">def</span> plane(ziel, kostenbudget<span class="op">=</span><span class="va">None</span>):</span>
+<span id="cb146-13"><a href="#cb146-13" aria-hidden="true" tabindex="-1"></a>    A, b <span class="op">=</span> <span class="bu">list</span>(bahn_trassen), [<span class="fl">2.0</span>]                       <span class="co"># nur zwei Trassen frei</span></span>
+<span id="cb146-14"><a href="#cb146-14" aria-hidden="true" tabindex="-1"></a>    <span class="cf">if</span> kostenbudget <span class="kw">is</span> <span class="kw">not</span> <span class="va">None</span>:</span>
+<span id="cb146-15"><a href="#cb146-15" aria-hidden="true" tabindex="-1"></a>        A.append(kosten.reshape(<span class="op">-</span><span class="dv">1</span>))<span class="op">;</span> b.append(kostenbudget)</span>
+<span id="cb146-16"><a href="#cb146-16" aria-hidden="true" tabindex="-1"></a>    x <span class="op">=</span> linprog(ziel.reshape(<span class="op">-</span><span class="dv">1</span>), A_ub<span class="op">=</span>A, b_ub<span class="op">=</span>b, A_eq<span class="op">=</span>eine_pro_sendung,</span>
+<span id="cb146-17"><a href="#cb146-17" aria-hidden="true" tabindex="-1"></a>                b_eq<span class="op">=</span>np.ones(<span class="dv">5</span>), bounds<span class="op">=</span>(<span class="dv">0</span>, <span class="dv">1</span>), integrality<span class="op">=</span><span class="dv">1</span>, method<span class="op">=</span><span class="st">&quot;highs&quot;</span>).x</span>
+<span id="cb146-18"><a href="#cb146-18" aria-hidden="true" tabindex="-1"></a>    <span class="cf">return</span> kosten.reshape(<span class="op">-</span><span class="dv">1</span>) <span class="op">@</span> x, co2.reshape(<span class="op">-</span><span class="dv">1</span>) <span class="op">@</span> x</span>
+<span id="cb146-19"><a href="#cb146-19" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb146-20"><a href="#cb146-20" aria-hidden="true" tabindex="-1"></a>k0, c0 <span class="op">=</span> plane(kosten)                                     <span class="co"># nur Kosten minimieren</span></span>
+<span id="cb146-21"><a href="#cb146-21" aria-hidden="true" tabindex="-1"></a>k1, c1 <span class="op">=</span> plane(co2, kostenbudget<span class="op">=</span>k0 <span class="op">*</span> <span class="fl">1.02</span>)                <span class="co"># 2 % mehr ausgeben</span></span>
+<span id="cb146-22"><a href="#cb146-22" aria-hidden="true" tabindex="-1"></a><span class="bu">print</span>(<span class="ss">f&quot;guenstigster Plan:  </span><span class="sc">{</span>k0<span class="sc">:&gt;7,.0f}</span><span class="ss"> EUR   </span><span class="sc">{</span>c0<span class="sc">:&gt;6,.0f}</span><span class="ss"> kg CO2&quot;</span>)</span>
+<span id="cb146-23"><a href="#cb146-23" aria-hidden="true" tabindex="-1"></a><span class="bu">print</span>(<span class="ss">f&quot;mit 2 % Aufpreis:   </span><span class="sc">{</span>k1<span class="sc">:&gt;7,.0f}</span><span class="ss"> EUR   </span><span class="sc">{</span>c1<span class="sc">:&gt;6,.0f}</span><span class="ss"> kg CO2   &quot;</span></span>
+<span id="cb146-24"><a href="#cb146-24" aria-hidden="true" tabindex="-1"></a>      <span class="ss">f&quot;(</span><span class="sc">{</span>(c0<span class="op">-</span>c1)<span class="op">/</span>c0<span class="sc">:.0%}</span><span class="ss"> weniger, </span><span class="sc">{</span>(k1<span class="op">-</span>k0)<span class="op">/</span>(c0<span class="op">-</span>c1)<span class="sc">:.2f}</span><span class="ss"> EUR je kg)&quot;</span>)</span></code></pre></div>
 <p><strong>Ausgabe:</strong></p>
 <pre><code>guenstigster Plan:    4,350 EUR    6,760 kg CO2
 mit 2 % Aufpreis:     4,430 EUR    6,310 kg CO2   (7% weniger, 0.18 EUR je kg)</code></pre>
@@ -18555,7 +19420,7 @@ f_j(x) &lt; f_j(y)\ \text{ für mindestens ein } j
 </tr>
 <tr class="odd">
 <td><span class="math inline">w</span></td>
-<td>„So viele Euro ist mir ein Kilogramm CO₂ wert.“ Ein <strong>Wechselkurs</strong>, kein Wichtigkeitsregler (<a href="#sec:cpsat-denkfehler">Abschnitt 7.9</a>).</td>
+<td>„So viele Euro ist mir ein Kilogramm CO₂ wert.“ Ein <strong>Wechselkurs</strong>, kein Wichtigkeitsregler (<a href="#sec:cpsat-denkfehler">Abschnitt 7.10</a>).</td>
 </tr>
 <tr class="even">
 <td><span class="math inline">\min_{x \in X}</span></td>
@@ -18569,266 +19434,266 @@ f_j(x) &lt; f_j(y)\ \text{ für mindestens ein } j
 <hr />
 <h2 id="sec:mehrziel-programm">14.5 Das Programm</h2>
 <p>Zwölf Sendungen, drei Verkehrsträger, fünf freie Bahntrassen. Der Zielkonflikt entsteht nicht zwischen den Trägern — die Bahn ist immer billiger <em>und</em> sauberer als der LKW —, sondern durch die <strong>Knappheit</strong> der Trassen. Genau so sieht es in der Praxis aus.</p>
-<div class="sourceCode" id="cb146"><pre class="sourceCode python"><code class="sourceCode python"><span id="cb146-1"><a href="#cb146-1" aria-hidden="true" tabindex="-1"></a><span class="co">#!/usr/bin/env python3</span></span>
-<span id="cb146-2"><a href="#cb146-2" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb146-3"><a href="#cb146-3" aria-hidden="true" tabindex="-1"></a><span class="co"># Mehrziel_Pareto.py</span></span>
-<span id="cb146-4"><a href="#cb146-4" aria-hidden="true" tabindex="-1"></a><span class="co">&quot;&quot;&quot;</span></span>
-<span id="cb146-5"><a href="#cb146-5" aria-hidden="true" tabindex="-1"></a><span class="co">Kapitel Mehrziel: Kosten gegen CO2 - und warum Gewichte nicht genuegen.</span></span>
-<span id="cb146-6"><a href="#cb146-6" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb146-7"><a href="#cb146-7" aria-hidden="true" tabindex="-1"></a><span class="co">Eine Spedition vergibt zwoelf Sendungen an drei Verkehrstraeger: LKW (schnell,</span></span>
-<span id="cb146-8"><a href="#cb146-8" aria-hidden="true" tabindex="-1"></a><span class="co">teuer, schmutzig), Bahn (billig und sauber, aber nur fuenf Trassen frei) und</span></span>
-<span id="cb146-9"><a href="#cb146-9" aria-hidden="true" tabindex="-1"></a><span class="co">Kombinierten Verkehr (dazwischen). Zwei Ziele stehen gegeneinander:</span></span>
-<span id="cb146-10"><a href="#cb146-10" aria-hidden="true" tabindex="-1"></a><span class="co">Transportkosten und CO2-Ausstoss.</span></span>
-<span id="cb146-11"><a href="#cb146-11" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb146-12"><a href="#cb146-12" aria-hidden="true" tabindex="-1"></a><span class="co">Der uebliche Reflex ist, beide Ziele zu einem zusammenzuruehren:</span></span>
-<span id="cb146-13"><a href="#cb146-13" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb146-14"><a href="#cb146-14" aria-hidden="true" tabindex="-1"></a><span class="co">    minimiere   Kosten + w * CO2</span></span>
-<span id="cb146-15"><a href="#cb146-15" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb146-16"><a href="#cb146-16" aria-hidden="true" tabindex="-1"></a><span class="co">Das ist bequem, liefert zulaessige Loesungen - und ist unvollstaendig. Bei</span></span>
-<span id="cb146-17"><a href="#cb146-17" aria-hidden="true" tabindex="-1"></a><span class="co">ganzzahligen Entscheidungen gibt es Kompromisse, die auf diesem Weg</span></span>
-<span id="cb146-18"><a href="#cb146-18" aria-hidden="true" tabindex="-1"></a><span class="co">GRUNDSAETZLICH nicht erreichbar sind, egal welches w man waehlt. Nicht &quot;schwer</span></span>
-<span id="cb146-19"><a href="#cb146-19" aria-hidden="true" tabindex="-1"></a><span class="co">zu finden&quot;, sondern beweisbar unerreichbar.</span></span>
-<span id="cb146-20"><a href="#cb146-20" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb146-21"><a href="#cb146-21" aria-hidden="true" tabindex="-1"></a><span class="co">Das Programm zeigt in vier Teilen:</span></span>
-<span id="cb146-22"><a href="#cb146-22" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb146-23"><a href="#cb146-23" aria-hidden="true" tabindex="-1"></a><span class="co">  1. Die beiden Extreme - was jedes Ziel allein kostet.</span></span>
-<span id="cb146-24"><a href="#cb146-24" aria-hidden="true" tabindex="-1"></a><span class="co">  2. Die lineare Skalarisierung ueber ein feines Gewichtsraster.</span></span>
-<span id="cb146-25"><a href="#cb146-25" aria-hidden="true" tabindex="-1"></a><span class="co">  3. Die vollstaendige Pareto-Front ueber das eps-Constraint-Verfahren.</span></span>
-<span id="cb146-26"><a href="#cb146-26" aria-hidden="true" tabindex="-1"></a><span class="co">  4. Den Nachweis, dass die Luecke keine Frage des Rasters ist, sondern</span></span>
-<span id="cb146-27"><a href="#cb146-27" aria-hidden="true" tabindex="-1"></a><span class="co">     Geometrie: Die fehlenden Punkte liegen strikt oberhalb der konvexen</span></span>
-<span id="cb146-28"><a href="#cb146-28" aria-hidden="true" tabindex="-1"></a><span class="co">     Huelle und koennen deshalb von keiner Geraden gestuetzt werden.</span></span>
-<span id="cb146-29"><a href="#cb146-29" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb146-30"><a href="#cb146-30" aria-hidden="true" tabindex="-1"></a><span class="co">Benoetigt: numpy, scipy</span></span>
-<span id="cb146-31"><a href="#cb146-31" aria-hidden="true" tabindex="-1"></a><span class="co">&quot;&quot;&quot;</span></span>
-<span id="cb146-32"><a href="#cb146-32" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb146-33"><a href="#cb146-33" aria-hidden="true" tabindex="-1"></a><span class="im">from</span> __future__ <span class="im">import</span> annotations</span>
-<span id="cb146-34"><a href="#cb146-34" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb146-35"><a href="#cb146-35" aria-hidden="true" tabindex="-1"></a><span class="im">import</span> numpy <span class="im">as</span> np</span>
-<span id="cb146-36"><a href="#cb146-36" aria-hidden="true" tabindex="-1"></a><span class="im">from</span> scipy.optimize <span class="im">import</span> linprog</span>
-<span id="cb146-37"><a href="#cb146-37" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb146-38"><a href="#cb146-38" aria-hidden="true" tabindex="-1"></a>TRAEGER <span class="op">=</span> [<span class="st">&quot;LKW&quot;</span>, <span class="st">&quot;Bahn&quot;</span>, <span class="st">&quot;Kombiniert&quot;</span>]</span>
-<span id="cb146-39"><a href="#cb146-39" aria-hidden="true" tabindex="-1"></a>BAHN_TRASSEN <span class="op">=</span> <span class="dv">5</span>          <span class="co"># so viele Sendungen passen hoechstens auf die Bahn</span></span>
-<span id="cb146-40"><a href="#cb146-40" aria-hidden="true" tabindex="-1"></a>SAAT <span class="op">=</span> <span class="dv">5</span></span>
-<span id="cb146-41"><a href="#cb146-41" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb146-42"><a href="#cb146-42" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb146-43"><a href="#cb146-43" aria-hidden="true" tabindex="-1"></a><span class="kw">def</span> erzeuge_sendungen(anzahl: <span class="bu">int</span> <span class="op">=</span> <span class="dv">12</span>, saat: <span class="bu">int</span> <span class="op">=</span> SAAT):</span>
-<span id="cb146-44"><a href="#cb146-44" aria-hidden="true" tabindex="-1"></a>    <span class="co">&quot;&quot;&quot;Kosten und CO2 je Sendung und Verkehrstraeger.</span></span>
-<span id="cb146-45"><a href="#cb146-45" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb146-46"><a href="#cb146-46" aria-hidden="true" tabindex="-1"></a><span class="co">    Die Bahn ist immer billiger und sauberer als der LKW - der Zielkonflikt</span></span>
-<span id="cb146-47"><a href="#cb146-47" aria-hidden="true" tabindex="-1"></a><span class="co">    entsteht nicht zwischen den Traegern, sondern durch die KNAPPHEIT der</span></span>
-<span id="cb146-48"><a href="#cb146-48" aria-hidden="true" tabindex="-1"></a><span class="co">    Trassen. Genau so sieht es in der Praxis aus.</span></span>
-<span id="cb146-49"><a href="#cb146-49" aria-hidden="true" tabindex="-1"></a><span class="co">    &quot;&quot;&quot;</span></span>
-<span id="cb146-50"><a href="#cb146-50" aria-hidden="true" tabindex="-1"></a>    rng <span class="op">=</span> np.random.default_rng(saat)</span>
-<span id="cb146-51"><a href="#cb146-51" aria-hidden="true" tabindex="-1"></a>    kosten <span class="op">=</span> np.zeros((anzahl, <span class="dv">3</span>))</span>
-<span id="cb146-52"><a href="#cb146-52" aria-hidden="true" tabindex="-1"></a>    co2 <span class="op">=</span> np.zeros((anzahl, <span class="dv">3</span>))</span>
-<span id="cb146-53"><a href="#cb146-53" aria-hidden="true" tabindex="-1"></a>    <span class="cf">for</span> i <span class="kw">in</span> <span class="bu">range</span>(anzahl):</span>
-<span id="cb146-54"><a href="#cb146-54" aria-hidden="true" tabindex="-1"></a>        grund_kosten <span class="op">=</span> rng.integers(<span class="dv">600</span>, <span class="dv">2400</span>)</span>
-<span id="cb146-55"><a href="#cb146-55" aria-hidden="true" tabindex="-1"></a>        grund_co2 <span class="op">=</span> rng.integers(<span class="dv">400</span>, <span class="dv">1800</span>)</span>
-<span id="cb146-56"><a href="#cb146-56" aria-hidden="true" tabindex="-1"></a>        kosten[i] <span class="op">=</span> [grund_kosten,</span>
-<span id="cb146-57"><a href="#cb146-57" aria-hidden="true" tabindex="-1"></a>                     grund_kosten <span class="op">*</span> rng.uniform(<span class="fl">0.55</span>, <span class="fl">0.85</span>),</span>
-<span id="cb146-58"><a href="#cb146-58" aria-hidden="true" tabindex="-1"></a>                     grund_kosten <span class="op">*</span> rng.uniform(<span class="fl">0.70</span>, <span class="fl">1.00</span>)]</span>
-<span id="cb146-59"><a href="#cb146-59" aria-hidden="true" tabindex="-1"></a>        co2[i] <span class="op">=</span> [grund_co2,</span>
-<span id="cb146-60"><a href="#cb146-60" aria-hidden="true" tabindex="-1"></a>                  grund_co2 <span class="op">*</span> rng.uniform(<span class="fl">0.15</span>, <span class="fl">0.35</span>),</span>
-<span id="cb146-61"><a href="#cb146-61" aria-hidden="true" tabindex="-1"></a>                  grund_co2 <span class="op">*</span> rng.uniform(<span class="fl">0.40</span>, <span class="fl">0.70</span>)]</span>
-<span id="cb146-62"><a href="#cb146-62" aria-hidden="true" tabindex="-1"></a>    <span class="cf">return</span> np.<span class="bu">round</span>(kosten).astype(<span class="bu">int</span>), np.<span class="bu">round</span>(co2).astype(<span class="bu">int</span>)</span>
-<span id="cb146-63"><a href="#cb146-63" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb146-64"><a href="#cb146-64" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb146-65"><a href="#cb146-65" aria-hidden="true" tabindex="-1"></a>KOSTEN, CO2 <span class="op">=</span> erzeuge_sendungen()</span>
-<span id="cb146-66"><a href="#cb146-66" aria-hidden="true" tabindex="-1"></a>N <span class="op">=</span> <span class="bu">len</span>(KOSTEN)</span>
-<span id="cb146-67"><a href="#cb146-67" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb146-68"><a href="#cb146-68" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb146-69"><a href="#cb146-69" aria-hidden="true" tabindex="-1"></a><span class="kw">def</span> plane(ziel: np.ndarray, co2_grenze: <span class="bu">float</span> <span class="op">|</span> <span class="va">None</span> <span class="op">=</span> <span class="va">None</span>,</span>
-<span id="cb146-70"><a href="#cb146-70" aria-hidden="true" tabindex="-1"></a>          kosten_grenze: <span class="bu">float</span> <span class="op">|</span> <span class="va">None</span> <span class="op">=</span> <span class="va">None</span>):</span>
-<span id="cb146-71"><a href="#cb146-71" aria-hidden="true" tabindex="-1"></a>    <span class="co">&quot;&quot;&quot;Jede Sendung genau einem Traeger zuordnen; Trassen sind knapp.</span></span>
-<span id="cb146-72"><a href="#cb146-72" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb146-73"><a href="#cb146-73" aria-hidden="true" tabindex="-1"></a><span class="co">    &#39;ziel&#39; ist die zu minimierende Matrix (Kosten, CO2 oder eine Mischung).</span></span>
-<span id="cb146-74"><a href="#cb146-74" aria-hidden="true" tabindex="-1"></a><span class="co">    Die beiden Grenzen sind das Werkzeug fuer eps-Constraint und</span></span>
-<span id="cb146-75"><a href="#cb146-75" aria-hidden="true" tabindex="-1"></a><span class="co">    lexikografische Optimierung - sie machen aus einem Ziel eine Schranke.</span></span>
-<span id="cb146-76"><a href="#cb146-76" aria-hidden="true" tabindex="-1"></a><span class="co">    &quot;&quot;&quot;</span></span>
-<span id="cb146-77"><a href="#cb146-77" aria-hidden="true" tabindex="-1"></a>    gleichungen <span class="op">=</span> np.zeros((N, N <span class="op">*</span> <span class="dv">3</span>))</span>
-<span id="cb146-78"><a href="#cb146-78" aria-hidden="true" tabindex="-1"></a>    <span class="cf">for</span> i <span class="kw">in</span> <span class="bu">range</span>(N):</span>
-<span id="cb146-79"><a href="#cb146-79" aria-hidden="true" tabindex="-1"></a>        gleichungen[i, i <span class="op">*</span> <span class="dv">3</span>:(i <span class="op">+</span> <span class="dv">1</span>) <span class="op">*</span> <span class="dv">3</span>] <span class="op">=</span> <span class="fl">1.0</span>        <span class="co"># genau ein Traeger</span></span>
-<span id="cb146-80"><a href="#cb146-80" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb146-81"><a href="#cb146-81" aria-hidden="true" tabindex="-1"></a>    ungleichungen <span class="op">=</span> [[<span class="fl">1.0</span> <span class="cf">if</span> j <span class="op">==</span> <span class="dv">1</span> <span class="cf">else</span> <span class="fl">0.0</span> <span class="cf">for</span> _ <span class="kw">in</span> <span class="bu">range</span>(N) <span class="cf">for</span> j <span class="kw">in</span> <span class="bu">range</span>(<span class="dv">3</span>)]]</span>
-<span id="cb146-82"><a href="#cb146-82" aria-hidden="true" tabindex="-1"></a>    grenzen <span class="op">=</span> [<span class="bu">float</span>(BAHN_TRASSEN)]</span>
-<span id="cb146-83"><a href="#cb146-83" aria-hidden="true" tabindex="-1"></a>    <span class="cf">if</span> co2_grenze <span class="kw">is</span> <span class="kw">not</span> <span class="va">None</span>:</span>
-<span id="cb146-84"><a href="#cb146-84" aria-hidden="true" tabindex="-1"></a>        ungleichungen.append(CO2.reshape(<span class="op">-</span><span class="dv">1</span>).astype(<span class="bu">float</span>))</span>
-<span id="cb146-85"><a href="#cb146-85" aria-hidden="true" tabindex="-1"></a>        grenzen.append(<span class="bu">float</span>(co2_grenze))</span>
-<span id="cb146-86"><a href="#cb146-86" aria-hidden="true" tabindex="-1"></a>    <span class="cf">if</span> kosten_grenze <span class="kw">is</span> <span class="kw">not</span> <span class="va">None</span>:</span>
-<span id="cb146-87"><a href="#cb146-87" aria-hidden="true" tabindex="-1"></a>        ungleichungen.append(KOSTEN.reshape(<span class="op">-</span><span class="dv">1</span>).astype(<span class="bu">float</span>))</span>
-<span id="cb146-88"><a href="#cb146-88" aria-hidden="true" tabindex="-1"></a>        grenzen.append(<span class="bu">float</span>(kosten_grenze))</span>
-<span id="cb146-89"><a href="#cb146-89" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb146-90"><a href="#cb146-90" aria-hidden="true" tabindex="-1"></a>    ergebnis <span class="op">=</span> linprog(ziel.reshape(<span class="op">-</span><span class="dv">1</span>).astype(<span class="bu">float</span>),</span>
-<span id="cb146-91"><a href="#cb146-91" aria-hidden="true" tabindex="-1"></a>                       A_ub<span class="op">=</span>ungleichungen, b_ub<span class="op">=</span>grenzen,</span>
-<span id="cb146-92"><a href="#cb146-92" aria-hidden="true" tabindex="-1"></a>                       A_eq<span class="op">=</span>gleichungen, b_eq<span class="op">=</span>np.ones(N),</span>
-<span id="cb146-93"><a href="#cb146-93" aria-hidden="true" tabindex="-1"></a>                       bounds<span class="op">=</span>(<span class="dv">0</span>, <span class="dv">1</span>), integrality<span class="op">=</span><span class="dv">1</span>, method<span class="op">=</span><span class="st">&quot;highs&quot;</span>)</span>
-<span id="cb146-94"><a href="#cb146-94" aria-hidden="true" tabindex="-1"></a>    <span class="cf">if</span> <span class="kw">not</span> ergebnis.success:</span>
-<span id="cb146-95"><a href="#cb146-95" aria-hidden="true" tabindex="-1"></a>        <span class="cf">return</span> <span class="va">None</span></span>
-<span id="cb146-96"><a href="#cb146-96" aria-hidden="true" tabindex="-1"></a>    plan <span class="op">=</span> np.<span class="bu">round</span>(ergebnis.x).astype(<span class="bu">int</span>)</span>
-<span id="cb146-97"><a href="#cb146-97" aria-hidden="true" tabindex="-1"></a>    <span class="cf">return</span> (<span class="bu">int</span>(KOSTEN.reshape(<span class="op">-</span><span class="dv">1</span>) <span class="op">@</span> plan), <span class="bu">int</span>(CO2.reshape(<span class="op">-</span><span class="dv">1</span>) <span class="op">@</span> plan), plan)</span>
-<span id="cb146-98"><a href="#cb146-98" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb146-99"><a href="#cb146-99" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb146-100"><a href="#cb146-100" aria-hidden="true" tabindex="-1"></a><span class="kw">def</span> pareto_front():</span>
-<span id="cb146-101"><a href="#cb146-101" aria-hidden="true" tabindex="-1"></a>    <span class="co">&quot;&quot;&quot;Vollstaendige Front ueber das eps-Constraint-Verfahren.</span></span>
-<span id="cb146-102"><a href="#cb146-102" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb146-103"><a href="#cb146-103" aria-hidden="true" tabindex="-1"></a><span class="co">    Der Ablauf ist der eigentliche Inhalt dieser Funktion: Erst das</span></span>
-<span id="cb146-104"><a href="#cb146-104" aria-hidden="true" tabindex="-1"></a><span class="co">    Kostenminimum bestimmen (der eine Rand der Front), dann die CO2-Schranke</span></span>
-<span id="cb146-105"><a href="#cb146-105" aria-hidden="true" tabindex="-1"></a><span class="co">    schrittweise um genau ein Kilogramm unter den zuletzt erreichten Wert</span></span>
-<span id="cb146-106"><a href="#cb146-106" aria-hidden="true" tabindex="-1"></a><span class="co">    druecken. Jeder Lauf liefert den naechsten Punkt - und wenn keiner mehr</span></span>
-<span id="cb146-107"><a href="#cb146-107" aria-hidden="true" tabindex="-1"></a><span class="co">    zulaessig ist, ist die Front vollstaendig.</span></span>
-<span id="cb146-108"><a href="#cb146-108" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb146-109"><a href="#cb146-109" aria-hidden="true" tabindex="-1"></a><span class="co">    Das braucht so viele Solveraufrufe, wie die Front Punkte hat. Ein Raster</span></span>
-<span id="cb146-110"><a href="#cb146-110" aria-hidden="true" tabindex="-1"></a><span class="co">    ueber alle moeglichen CO2-Werte braeuchte hier fast tausend.</span></span>
-<span id="cb146-111"><a href="#cb146-111" aria-hidden="true" tabindex="-1"></a><span class="co">    &quot;&quot;&quot;</span></span>
-<span id="cb146-112"><a href="#cb146-112" aria-hidden="true" tabindex="-1"></a>    front <span class="op">=</span> []</span>
-<span id="cb146-113"><a href="#cb146-113" aria-hidden="true" tabindex="-1"></a>    start <span class="op">=</span> plane(KOSTEN)</span>
-<span id="cb146-114"><a href="#cb146-114" aria-hidden="true" tabindex="-1"></a>    grenze <span class="op">=</span> start[<span class="dv">1</span>]</span>
-<span id="cb146-115"><a href="#cb146-115" aria-hidden="true" tabindex="-1"></a>    <span class="cf">while</span> <span class="va">True</span>:</span>
-<span id="cb146-116"><a href="#cb146-116" aria-hidden="true" tabindex="-1"></a>        ergebnis <span class="op">=</span> plane(KOSTEN, co2_grenze<span class="op">=</span>grenze)</span>
-<span id="cb146-117"><a href="#cb146-117" aria-hidden="true" tabindex="-1"></a>        <span class="cf">if</span> ergebnis <span class="kw">is</span> <span class="va">None</span>:</span>
-<span id="cb146-118"><a href="#cb146-118" aria-hidden="true" tabindex="-1"></a>            <span class="cf">break</span></span>
-<span id="cb146-119"><a href="#cb146-119" aria-hidden="true" tabindex="-1"></a>        front.append((ergebnis[<span class="dv">0</span>], ergebnis[<span class="dv">1</span>]))</span>
-<span id="cb146-120"><a href="#cb146-120" aria-hidden="true" tabindex="-1"></a>        grenze <span class="op">=</span> ergebnis[<span class="dv">1</span>] <span class="op">-</span> <span class="dv">1</span></span>
-<span id="cb146-121"><a href="#cb146-121" aria-hidden="true" tabindex="-1"></a>    <span class="cf">return</span> front</span>
-<span id="cb146-122"><a href="#cb146-122" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb146-123"><a href="#cb146-123" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb146-124"><a href="#cb146-124" aria-hidden="true" tabindex="-1"></a><span class="kw">def</span> skalarisierung(gewichte):</span>
-<span id="cb146-125"><a href="#cb146-125" aria-hidden="true" tabindex="-1"></a>    <span class="co">&quot;&quot;&quot;Was &#39;Kosten + w * CO2&#39; fuer viele w hergibt - als Menge von Punkten.&quot;&quot;&quot;</span></span>
-<span id="cb146-126"><a href="#cb146-126" aria-hidden="true" tabindex="-1"></a>    gefunden <span class="op">=</span> {}</span>
-<span id="cb146-127"><a href="#cb146-127" aria-hidden="true" tabindex="-1"></a>    <span class="cf">for</span> w <span class="kw">in</span> gewichte:</span>
-<span id="cb146-128"><a href="#cb146-128" aria-hidden="true" tabindex="-1"></a>        ergebnis <span class="op">=</span> plane(KOSTEN <span class="op">+</span> w <span class="op">*</span> CO2)</span>
-<span id="cb146-129"><a href="#cb146-129" aria-hidden="true" tabindex="-1"></a>        <span class="cf">if</span> ergebnis:</span>
-<span id="cb146-130"><a href="#cb146-130" aria-hidden="true" tabindex="-1"></a>            gefunden.setdefault((ergebnis[<span class="dv">0</span>], ergebnis[<span class="dv">1</span>]), []).append(w)</span>
-<span id="cb146-131"><a href="#cb146-131" aria-hidden="true" tabindex="-1"></a>    <span class="cf">return</span> gefunden</span>
-<span id="cb146-132"><a href="#cb146-132" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb146-133"><a href="#cb146-133" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb146-134"><a href="#cb146-134" aria-hidden="true" tabindex="-1"></a><span class="kw">def</span> untere_huelle(punkte):</span>
-<span id="cb146-135"><a href="#cb146-135" aria-hidden="true" tabindex="-1"></a>    <span class="co">&quot;&quot;&quot;Untere linke konvexe Huelle - genau die Punkte, die eine Gerade stuetzt.</span></span>
-<span id="cb146-136"><a href="#cb146-136" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb146-137"><a href="#cb146-137" aria-hidden="true" tabindex="-1"></a><span class="co">    Der Zusammenhang, um den es geht: &#39;Kosten + w*CO2 minimieren&#39; heisst</span></span>
-<span id="cb146-138"><a href="#cb146-138" aria-hidden="true" tabindex="-1"></a><span class="co">    geometrisch, eine Gerade der Steigung -1/w von links unten an die</span></span>
-<span id="cb146-139"><a href="#cb146-139" aria-hidden="true" tabindex="-1"></a><span class="co">    Punktwolke zu schieben. Sie beruehrt immer einen Eckpunkt der konvexen</span></span>
-<span id="cb146-140"><a href="#cb146-140" aria-hidden="true" tabindex="-1"></a><span class="co">    Huelle. Punkte, die oberhalb liegen, werden nie beruehrt - fuer kein w.</span></span>
-<span id="cb146-141"><a href="#cb146-141" aria-hidden="true" tabindex="-1"></a><span class="co">    &quot;&quot;&quot;</span></span>
-<span id="cb146-142"><a href="#cb146-142" aria-hidden="true" tabindex="-1"></a>    huelle <span class="op">=</span> []</span>
-<span id="cb146-143"><a href="#cb146-143" aria-hidden="true" tabindex="-1"></a>    <span class="cf">for</span> punkt <span class="kw">in</span> <span class="bu">sorted</span>(punkte):</span>
-<span id="cb146-144"><a href="#cb146-144" aria-hidden="true" tabindex="-1"></a>        <span class="cf">while</span> <span class="bu">len</span>(huelle) <span class="op">&gt;=</span> <span class="dv">2</span>:</span>
-<span id="cb146-145"><a href="#cb146-145" aria-hidden="true" tabindex="-1"></a>            (x1, y1), (x2, y2) <span class="op">=</span> huelle[<span class="op">-</span><span class="dv">2</span>], huelle[<span class="op">-</span><span class="dv">1</span>]</span>
-<span id="cb146-146"><a href="#cb146-146" aria-hidden="true" tabindex="-1"></a>            <span class="cf">if</span> (x2 <span class="op">-</span> x1) <span class="op">*</span> (punkt[<span class="dv">1</span>] <span class="op">-</span> y1) <span class="op">-</span> (y2 <span class="op">-</span> y1) <span class="op">*</span> (punkt[<span class="dv">0</span>] <span class="op">-</span> x1) <span class="op">&lt;=</span> <span class="dv">0</span>:</span>
-<span id="cb146-147"><a href="#cb146-147" aria-hidden="true" tabindex="-1"></a>                huelle.pop()</span>
-<span id="cb146-148"><a href="#cb146-148" aria-hidden="true" tabindex="-1"></a>            <span class="cf">else</span>:</span>
-<span id="cb146-149"><a href="#cb146-149" aria-hidden="true" tabindex="-1"></a>                <span class="cf">break</span></span>
-<span id="cb146-150"><a href="#cb146-150" aria-hidden="true" tabindex="-1"></a>        huelle.append(punkt)</span>
-<span id="cb146-151"><a href="#cb146-151" aria-hidden="true" tabindex="-1"></a>    <span class="cf">return</span> huelle</span>
-<span id="cb146-152"><a href="#cb146-152" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb146-153"><a href="#cb146-153" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb146-154"><a href="#cb146-154" aria-hidden="true" tabindex="-1"></a><span class="cf">if</span> <span class="va">__name__</span> <span class="op">==</span> <span class="st">&quot;__main__&quot;</span>:</span>
-<span id="cb146-155"><a href="#cb146-155" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;=&quot;</span> <span class="op">*</span> <span class="dv">80</span>)</span>
-<span id="cb146-156"><a href="#cb146-156" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;  KOSTEN GEGEN CO2 - UND WARUM GEWICHTE NICHT GENUEGEN&quot;</span>)</span>
-<span id="cb146-157"><a href="#cb146-157" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;=&quot;</span> <span class="op">*</span> <span class="dv">80</span>)</span>
-<span id="cb146-158"><a href="#cb146-158" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;</span><span class="sc">{</span>N<span class="sc">}</span><span class="ss"> Sendungen, </span><span class="sc">{</span><span class="bu">len</span>(TRAEGER)<span class="sc">}</span><span class="ss"> Verkehrstraeger, &quot;</span></span>
-<span id="cb146-159"><a href="#cb146-159" aria-hidden="true" tabindex="-1"></a>          <span class="ss">f&quot;</span><span class="sc">{</span>BAHN_TRASSEN<span class="sc">}</span><span class="ss"> freie Bahntrassen.</span><span class="ch">\n</span><span class="ss">&quot;</span>)</span>
-<span id="cb146-160"><a href="#cb146-160" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb146-161"><a href="#cb146-161" aria-hidden="true" tabindex="-1"></a>    <span class="co"># --- 1. Die beiden Extreme -------------------------------------------</span></span>
-<span id="cb146-162"><a href="#cb146-162" aria-hidden="true" tabindex="-1"></a>    guenstigst <span class="op">=</span> plane(KOSTEN)</span>
-<span id="cb146-163"><a href="#cb146-163" aria-hidden="true" tabindex="-1"></a>    saubersten <span class="op">=</span> plane(CO2)</span>
-<span id="cb146-164"><a href="#cb146-164" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;1. Was jedes Ziel allein ergibt</span><span class="ch">\n</span><span class="st">&quot;</span>)</span>
-<span id="cb146-165"><a href="#cb146-165" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;  </span><span class="sc">{</span><span class="st">&#39;&#39;</span><span class="sc">:&lt;22}</span><span class="ss"> </span><span class="sc">{</span><span class="st">&#39;Kosten&#39;</span><span class="sc">:&gt;10}</span><span class="ss"> </span><span class="sc">{</span><span class="st">&#39;CO2&#39;</span><span class="sc">:&gt;10}</span><span class="ss">&quot;</span>)</span>
-<span id="cb146-166"><a href="#cb146-166" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;  &quot;</span> <span class="op">+</span> <span class="st">&quot;-&quot;</span> <span class="op">*</span> <span class="dv">44</span>)</span>
-<span id="cb146-167"><a href="#cb146-167" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;  </span><span class="sc">{</span><span class="st">&#39;nur Kosten minimal&#39;</span><span class="sc">:&lt;22}</span><span class="ss"> </span><span class="sc">{</span>guenstigst[<span class="dv">0</span>]<span class="sc">:&gt;10,}</span><span class="ss"> </span><span class="sc">{</span>guenstigst[<span class="dv">1</span>]<span class="sc">:&gt;9,}</span><span class="ss"> kg&quot;</span>)</span>
-<span id="cb146-168"><a href="#cb146-168" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;  </span><span class="sc">{</span><span class="st">&#39;nur CO2 minimal&#39;</span><span class="sc">:&lt;22}</span><span class="ss"> </span><span class="sc">{</span>saubersten[<span class="dv">0</span>]<span class="sc">:&gt;10,}</span><span class="ss"> </span><span class="sc">{</span>saubersten[<span class="dv">1</span>]<span class="sc">:&gt;9,}</span><span class="ss"> kg&quot;</span>)</span>
-<span id="cb146-169"><a href="#cb146-169" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;</span><span class="ch">\n</span><span class="ss">  Der Zielkonflikt ist echt, aber klein: &quot;</span></span>
-<span id="cb146-170"><a href="#cb146-170" aria-hidden="true" tabindex="-1"></a>          <span class="ss">f&quot;</span><span class="sc">{</span>saubersten[<span class="dv">0</span>] <span class="op">-</span> guenstigst[<span class="dv">0</span>]<span class="sc">:,}</span><span class="ss"> EUR mehr&quot;</span>)</span>
-<span id="cb146-171"><a href="#cb146-171" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;  (</span><span class="sc">{</span>(saubersten[<span class="dv">0</span>] <span class="op">-</span> guenstigst[<span class="dv">0</span>]) <span class="op">/</span> guenstigst[<span class="dv">0</span>] <span class="op">*</span> <span class="dv">100</span><span class="sc">:.1f}</span><span class="ss"> %) sparen &quot;</span></span>
-<span id="cb146-172"><a href="#cb146-172" aria-hidden="true" tabindex="-1"></a>          <span class="ss">f&quot;</span><span class="sc">{</span>guenstigst[<span class="dv">1</span>] <span class="op">-</span> saubersten[<span class="dv">1</span>]<span class="sc">:,}</span><span class="ss"> kg CO2 &quot;</span></span>
-<span id="cb146-173"><a href="#cb146-173" aria-hidden="true" tabindex="-1"></a>          <span class="ss">f&quot;(</span><span class="sc">{</span>(guenstigst[<span class="dv">1</span>] <span class="op">-</span> saubersten[<span class="dv">1</span>]) <span class="op">/</span> guenstigst[<span class="dv">1</span>] <span class="op">*</span> <span class="dv">100</span><span class="sc">:.1f}</span><span class="ss"> %).&quot;</span>)</span>
-<span id="cb146-174"><a href="#cb146-174" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;  Genau solche Zahlen will die Geschaeftsfuehrung sehen - nicht ein&quot;</span>)</span>
-<span id="cb146-175"><a href="#cb146-175" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;  Gewicht, das niemand interpretieren kann.&quot;</span>)</span>
-<span id="cb146-176"><a href="#cb146-176" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb146-177"><a href="#cb146-177" aria-hidden="true" tabindex="-1"></a>    <span class="co"># --- 2. Die lineare Skalarisierung -----------------------------------</span></span>
-<span id="cb146-178"><a href="#cb146-178" aria-hidden="true" tabindex="-1"></a>    gewichte <span class="op">=</span> np.concatenate([np.linspace(<span class="fl">0.0</span>, <span class="fl">3.0</span>, <span class="dv">1201</span>),</span>
-<span id="cb146-179"><a href="#cb146-179" aria-hidden="true" tabindex="-1"></a>                               np.geomspace(<span class="fl">3.0</span>, <span class="fl">1000.0</span>, <span class="dv">200</span>)])</span>
-<span id="cb146-180"><a href="#cb146-180" aria-hidden="true" tabindex="-1"></a>    gefunden <span class="op">=</span> skalarisierung(gewichte)</span>
-<span id="cb146-181"><a href="#cb146-181" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;</span><span class="ch">\n</span><span class="st">&quot;</span> <span class="op">+</span> <span class="st">&quot;-&quot;</span> <span class="op">*</span> <span class="dv">80</span>)</span>
-<span id="cb146-182"><a href="#cb146-182" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;2. Lineare Skalarisierung: &#39;Kosten + w * CO2&#39; fuer &quot;</span></span>
-<span id="cb146-183"><a href="#cb146-183" aria-hidden="true" tabindex="-1"></a>          <span class="ss">f&quot;</span><span class="sc">{</span><span class="bu">len</span>(gewichte)<span class="sc">:,}</span><span class="ss"> Gewichte</span><span class="ch">\n</span><span class="ss">&quot;</span>)</span>
-<span id="cb146-184"><a href="#cb146-184" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;  </span><span class="sc">{</span><span class="st">&#39;Kosten&#39;</span><span class="sc">:&gt;10}</span><span class="ss"> </span><span class="sc">{</span><span class="st">&#39;CO2&#39;</span><span class="sc">:&gt;10}</span><span class="ss">   </span><span class="sc">{</span><span class="st">&#39;gefunden bei w&#39;</span><span class="sc">:&gt;16}</span><span class="ss">&quot;</span>)</span>
-<span id="cb146-185"><a href="#cb146-185" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;  &quot;</span> <span class="op">+</span> <span class="st">&quot;-&quot;</span> <span class="op">*</span> <span class="dv">46</span>)</span>
-<span id="cb146-186"><a href="#cb146-186" aria-hidden="true" tabindex="-1"></a>    <span class="cf">for</span> (k, c), ws <span class="kw">in</span> <span class="bu">sorted</span>(gefunden.items()):</span>
-<span id="cb146-187"><a href="#cb146-187" aria-hidden="true" tabindex="-1"></a>        <span class="bu">print</span>(<span class="ss">f&quot;  </span><span class="sc">{</span>k<span class="sc">:&gt;10,}</span><span class="ss"> </span><span class="sc">{</span>c<span class="sc">:&gt;9,}</span><span class="ss"> kg   </span><span class="sc">{</span><span class="bu">min</span>(ws)<span class="sc">:&gt;7.3f}</span><span class="ss"> bis </span><span class="sc">{</span><span class="bu">max</span>(ws)<span class="sc">:&gt;7.3f}</span><span class="ss">&quot;</span>)</span>
-<span id="cb146-188"><a href="#cb146-188" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;</span><span class="ch">\n</span><span class="ss">  </span><span class="sc">{</span><span class="bu">len</span>(gefunden)<span class="sc">}</span><span class="ss"> verschiedene Plaene - fuer </span><span class="sc">{</span><span class="bu">len</span>(gewichte)<span class="sc">:,}</span><span class="ss"> Gewichte.&quot;</span>)</span>
-<span id="cb146-189"><a href="#cb146-189" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;  Das Gewicht ist also gar keine Feineinstellung: Weite Bereiche&quot;</span>)</span>
-<span id="cb146-190"><a href="#cb146-190" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;  liefern dasselbe Ergebnis, und dazwischen springt es.&quot;</span>)</span>
-<span id="cb146-191"><a href="#cb146-191" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb146-192"><a href="#cb146-192" aria-hidden="true" tabindex="-1"></a>    <span class="co"># --- 3. Die vollstaendige Front --------------------------------------</span></span>
-<span id="cb146-193"><a href="#cb146-193" aria-hidden="true" tabindex="-1"></a>    front <span class="op">=</span> pareto_front()</span>
-<span id="cb146-194"><a href="#cb146-194" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;</span><span class="ch">\n</span><span class="st">&quot;</span> <span class="op">+</span> <span class="st">&quot;-&quot;</span> <span class="op">*</span> <span class="dv">80</span>)</span>
-<span id="cb146-195"><a href="#cb146-195" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;3. Die vollstaendige Pareto-Front ueber eps-Constraint &quot;</span></span>
-<span id="cb146-196"><a href="#cb146-196" aria-hidden="true" tabindex="-1"></a>          <span class="ss">f&quot;(</span><span class="sc">{</span><span class="bu">len</span>(front)<span class="sc">}</span><span class="ss"> Solverlaeufe)</span><span class="ch">\n</span><span class="ss">&quot;</span>)</span>
-<span id="cb146-197"><a href="#cb146-197" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;  </span><span class="sc">{</span><span class="st">&#39;Kosten&#39;</span><span class="sc">:&gt;10}</span><span class="ss"> </span><span class="sc">{</span><span class="st">&#39;CO2&#39;</span><span class="sc">:&gt;10}</span><span class="ss">   </span><span class="sc">{</span><span class="st">&#39;Aufpreis&#39;</span><span class="sc">:&gt;9}</span><span class="ss"> </span><span class="sc">{</span><span class="st">&#39;CO2-Ersparnis&#39;</span><span class="sc">:&gt;14}</span><span class="ss"> &quot;</span></span>
-<span id="cb146-198"><a href="#cb146-198" aria-hidden="true" tabindex="-1"></a>          <span class="ss">f&quot;</span><span class="sc">{</span><span class="st">&#39;EUR je kg&#39;</span><span class="sc">:&gt;10}</span><span class="ss">&quot;</span>)</span>
-<span id="cb146-199"><a href="#cb146-199" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;  &quot;</span> <span class="op">+</span> <span class="st">&quot;-&quot;</span> <span class="op">*</span> <span class="dv">60</span>)</span>
-<span id="cb146-200"><a href="#cb146-200" aria-hidden="true" tabindex="-1"></a>    <span class="cf">for</span> k, c <span class="kw">in</span> front:</span>
-<span id="cb146-201"><a href="#cb146-201" aria-hidden="true" tabindex="-1"></a>        auf <span class="op">=</span> k <span class="op">-</span> guenstigst[<span class="dv">0</span>]</span>
-<span id="cb146-202"><a href="#cb146-202" aria-hidden="true" tabindex="-1"></a>        ersparnis <span class="op">=</span> guenstigst[<span class="dv">1</span>] <span class="op">-</span> c</span>
-<span id="cb146-203"><a href="#cb146-203" aria-hidden="true" tabindex="-1"></a>        preis <span class="op">=</span> auf <span class="op">/</span> ersparnis <span class="cf">if</span> ersparnis <span class="cf">else</span> <span class="fl">0.0</span></span>
-<span id="cb146-204"><a href="#cb146-204" aria-hidden="true" tabindex="-1"></a>        <span class="bu">print</span>(<span class="ss">f&quot;  </span><span class="sc">{</span>k<span class="sc">:&gt;10,}</span><span class="ss"> </span><span class="sc">{</span>c<span class="sc">:&gt;9,}</span><span class="ss"> kg   </span><span class="sc">{</span>auf<span class="sc">:&gt;8,}</span><span class="ss"> </span><span class="sc">{</span>ersparnis<span class="sc">:&gt;13,}</span><span class="ss"> &quot;</span></span>
-<span id="cb146-205"><a href="#cb146-205" aria-hidden="true" tabindex="-1"></a>              <span class="ss">f&quot;</span><span class="sc">{</span>preis<span class="sc">:&gt;10.2f}</span><span class="ss">&quot;</span>)</span>
-<span id="cb146-206"><a href="#cb146-206" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb146-207"><a href="#cb146-207" aria-hidden="true" tabindex="-1"></a>    <span class="co"># --- 4. Der Nachweis --------------------------------------------------</span></span>
-<span id="cb146-208"><a href="#cb146-208" aria-hidden="true" tabindex="-1"></a>    huelle <span class="op">=</span> untere_huelle(front)</span>
-<span id="cb146-209"><a href="#cb146-209" aria-hidden="true" tabindex="-1"></a>    unerreichbar <span class="op">=</span> [p <span class="cf">for</span> p <span class="kw">in</span> front <span class="cf">if</span> p <span class="kw">not</span> <span class="kw">in</span> huelle]</span>
-<span id="cb146-210"><a href="#cb146-210" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;</span><span class="ch">\n</span><span class="st">&quot;</span> <span class="op">+</span> <span class="st">&quot;-&quot;</span> <span class="op">*</span> <span class="dv">80</span>)</span>
-<span id="cb146-211"><a href="#cb146-211" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;4. Was die Skalarisierung nicht findet</span><span class="ch">\n</span><span class="st">&quot;</span>)</span>
-<span id="cb146-212"><a href="#cb146-212" aria-hidden="true" tabindex="-1"></a>    erreicht <span class="op">=</span> [p <span class="cf">for</span> p <span class="kw">in</span> front <span class="cf">if</span> p <span class="kw">in</span> gefunden]</span>
-<span id="cb146-213"><a href="#cb146-213" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;  Pareto-Punkte insgesamt:              </span><span class="sc">{</span><span class="bu">len</span>(front)<span class="sc">}</span><span class="ss">&quot;</span>)</span>
-<span id="cb146-214"><a href="#cb146-214" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;  davon von der Skalarisierung gefunden: </span><span class="sc">{</span><span class="bu">len</span>(erreicht)<span class="sc">}</span><span class="ss">&quot;</span>)</span>
-<span id="cb146-215"><a href="#cb146-215" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;  nie gefunden:                          </span><span class="sc">{</span><span class="bu">len</span>(front) <span class="op">-</span> <span class="bu">len</span>(erreicht)<span class="sc">}</span><span class="ss">&quot;</span>)</span>
-<span id="cb146-216"><a href="#cb146-216" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>()</span>
-<span id="cb146-217"><a href="#cb146-217" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;  Diese Kompromisse sind fuer KEIN Gewicht erreichbar:</span><span class="ch">\n</span><span class="st">&quot;</span>)</span>
-<span id="cb146-218"><a href="#cb146-218" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;  </span><span class="sc">{</span><span class="st">&#39;Kosten&#39;</span><span class="sc">:&gt;10}</span><span class="ss"> </span><span class="sc">{</span><span class="st">&#39;CO2&#39;</span><span class="sc">:&gt;10}</span><span class="ss">   </span><span class="sc">{</span><span class="st">&#39;Aufpreis&#39;</span><span class="sc">:&gt;9}</span><span class="ss"> </span><span class="sc">{</span><span class="st">&#39;CO2-Ersparnis&#39;</span><span class="sc">:&gt;14}</span><span class="ss">&quot;</span>)</span>
-<span id="cb146-219"><a href="#cb146-219" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;  &quot;</span> <span class="op">+</span> <span class="st">&quot;-&quot;</span> <span class="op">*</span> <span class="dv">50</span>)</span>
-<span id="cb146-220"><a href="#cb146-220" aria-hidden="true" tabindex="-1"></a>    <span class="cf">for</span> k, c <span class="kw">in</span> unerreichbar:</span>
-<span id="cb146-221"><a href="#cb146-221" aria-hidden="true" tabindex="-1"></a>        <span class="bu">print</span>(<span class="ss">f&quot;  </span><span class="sc">{</span>k<span class="sc">:&gt;10,}</span><span class="ss"> </span><span class="sc">{</span>c<span class="sc">:&gt;9,}</span><span class="ss"> kg   </span><span class="sc">{</span>k <span class="op">-</span> guenstigst[<span class="dv">0</span>]<span class="sc">:&gt;8,}</span><span class="ss"> &quot;</span></span>
-<span id="cb146-222"><a href="#cb146-222" aria-hidden="true" tabindex="-1"></a>              <span class="ss">f&quot;</span><span class="sc">{</span>guenstigst[<span class="dv">1</span>] <span class="op">-</span> c<span class="sc">:&gt;13,}</span><span class="ss">&quot;</span>)</span>
-<span id="cb146-223"><a href="#cb146-223" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb146-224"><a href="#cb146-224" aria-hidden="true" tabindex="-1"></a>    stimmt <span class="op">=</span> <span class="bu">sorted</span>(unerreichbar) <span class="op">==</span> <span class="bu">sorted</span>(p <span class="cf">for</span> p <span class="kw">in</span> front <span class="cf">if</span> p <span class="kw">not</span> <span class="kw">in</span> gefunden)</span>
-<span id="cb146-225"><a href="#cb146-225" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;</span><span class="ch">\n</span><span class="ss">  Gegenprobe ueber die Geometrie: </span><span class="sc">{</span><span class="st">&#39;bestanden&#39;</span> <span class="cf">if</span> stimmt <span class="cf">else</span> <span class="st">&#39;ABWEICHUNG&#39;</span><span class="sc">}</span><span class="ss">&quot;</span>)</span>
-<span id="cb146-226"><a href="#cb146-226" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;  Genau die Punkte, die das Gewichtsraster verfehlt, liegen strikt&quot;</span>)</span>
-<span id="cb146-227"><a href="#cb146-227" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;  oberhalb der unteren konvexen Huelle. Das ist kein Rasterproblem -&quot;</span>)</span>
-<span id="cb146-228"><a href="#cb146-228" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;  eine Gerade, die von links unten an die Wolke geschoben wird,&quot;</span>)</span>
-<span id="cb146-229"><a href="#cb146-229" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;  beruehrt immer einen Eckpunkt der Huelle und nie einen Punkt&quot;</span>)</span>
-<span id="cb146-230"><a href="#cb146-230" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;  darueber. Ein feineres Raster aendert daran nichts.&quot;</span>)</span>
-<span id="cb146-231"><a href="#cb146-231" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb146-232"><a href="#cb146-232" aria-hidden="true" tabindex="-1"></a>    <span class="co"># --- 5. Lexikografisch -------------------------------------------------</span></span>
-<span id="cb146-233"><a href="#cb146-233" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;</span><span class="ch">\n</span><span class="st">&quot;</span> <span class="op">+</span> <span class="st">&quot;-&quot;</span> <span class="op">*</span> <span class="dv">80</span>)</span>
-<span id="cb146-234"><a href="#cb146-234" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;5. Lexikografisch: erst Kosten, dann CO2 im Rahmen eines Budgets</span><span class="ch">\n</span><span class="st">&quot;</span>)</span>
-<span id="cb146-235"><a href="#cb146-235" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;  </span><span class="sc">{</span><span class="st">&#39;Kostenbudget&#39;</span><span class="sc">:&gt;14}</span><span class="ss"> </span><span class="sc">{</span><span class="st">&#39;Kosten&#39;</span><span class="sc">:&gt;10}</span><span class="ss"> </span><span class="sc">{</span><span class="st">&#39;CO2&#39;</span><span class="sc">:&gt;10}</span><span class="ss"> </span><span class="sc">{</span><span class="st">&#39;gegenueber Minimum&#39;</span><span class="sc">:&gt;20}</span><span class="ss">&quot;</span>)</span>
-<span id="cb146-236"><a href="#cb146-236" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;  &quot;</span> <span class="op">+</span> <span class="st">&quot;-&quot;</span> <span class="op">*</span> <span class="dv">58</span>)</span>
-<span id="cb146-237"><a href="#cb146-237" aria-hidden="true" tabindex="-1"></a>    <span class="cf">for</span> aufschlag <span class="kw">in</span> (<span class="fl">0.00</span>, <span class="fl">0.01</span>, <span class="fl">0.02</span>, <span class="fl">0.05</span>, <span class="fl">0.10</span>):</span>
-<span id="cb146-238"><a href="#cb146-238" aria-hidden="true" tabindex="-1"></a>        budget <span class="op">=</span> guenstigst[<span class="dv">0</span>] <span class="op">*</span> (<span class="dv">1</span> <span class="op">+</span> aufschlag)</span>
-<span id="cb146-239"><a href="#cb146-239" aria-hidden="true" tabindex="-1"></a>        ergebnis <span class="op">=</span> plane(CO2, kosten_grenze<span class="op">=</span>budget)</span>
-<span id="cb146-240"><a href="#cb146-240" aria-hidden="true" tabindex="-1"></a>        <span class="cf">if</span> ergebnis <span class="kw">is</span> <span class="va">None</span>:</span>
-<span id="cb146-241"><a href="#cb146-241" aria-hidden="true" tabindex="-1"></a>            <span class="bu">print</span>(<span class="ss">f&quot;  </span><span class="sc">{</span>aufschlag<span class="sc">:&gt;13.0%}</span><span class="ss"> unzulaessig&quot;</span>)</span>
-<span id="cb146-242"><a href="#cb146-242" aria-hidden="true" tabindex="-1"></a>            <span class="cf">continue</span></span>
-<span id="cb146-243"><a href="#cb146-243" aria-hidden="true" tabindex="-1"></a>        <span class="bu">print</span>(<span class="ss">f&quot;  </span><span class="sc">{</span>aufschlag<span class="sc">:&gt;13.0%}</span><span class="ss"> </span><span class="sc">{</span>ergebnis[<span class="dv">0</span>]<span class="sc">:&gt;10,}</span><span class="ss"> </span><span class="sc">{</span>ergebnis[<span class="dv">1</span>]<span class="sc">:&gt;9,}</span><span class="ss"> kg &quot;</span></span>
-<span id="cb146-244"><a href="#cb146-244" aria-hidden="true" tabindex="-1"></a>              <span class="ss">f&quot;</span><span class="sc">{</span>guenstigst[<span class="dv">1</span>] <span class="op">-</span> ergebnis[<span class="dv">1</span>]<span class="sc">:&gt;15,}</span><span class="ss"> kg weniger&quot;</span>)</span>
-<span id="cb146-245"><a href="#cb146-245" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb146-246"><a href="#cb146-246" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;</span><span class="ch">\n</span><span class="st">  Das ist die Form, die im Betrieb am ehesten trifft: Nicht &#39;wie&quot;</span>)</span>
-<span id="cb146-247"><a href="#cb146-247" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;  wichtig ist CO2?&#39;, sondern &#39;wir geben zwei Prozent mehr aus - was&quot;</span>)</span>
-<span id="cb146-248"><a href="#cb146-248" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;  bringt das?&#39;. Die Frage kann ein Kaufmann beantworten.&quot;</span>)</span>
-<span id="cb146-249"><a href="#cb146-249" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb146-250"><a href="#cb146-250" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;</span><span class="ch">\n</span><span class="st">&quot;</span> <span class="op">+</span> <span class="st">&quot;=&quot;</span> <span class="op">*</span> <span class="dv">80</span>)</span>
-<span id="cb146-251"><a href="#cb146-251" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;  WAS MAN DARAUS MITNIMMT&quot;</span>)</span>
-<span id="cb146-252"><a href="#cb146-252" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;=&quot;</span> <span class="op">*</span> <span class="dv">80</span>)</span>
-<span id="cb146-253"><a href="#cb146-253" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;Ein Gewicht zu setzen heisst, die Entscheidung heimlich zu treffen -&quot;</span>)</span>
-<span id="cb146-254"><a href="#cb146-254" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;und dabei einen Teil der Moeglichkeiten gar nicht erst zu sehen.&quot;</span>)</span>
-<span id="cb146-255"><a href="#cb146-255" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>()</span>
-<span id="cb146-256"><a href="#cb146-256" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;Die Pareto-Front ist die ehrlichere Antwort: Sie legt dem Betrieb&quot;</span>)</span>
-<span id="cb146-257"><a href="#cb146-257" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;alle sinnvollen Kompromisse vor und ueberlaesst ihm die Wahl. Die&quot;</span>)</span>
-<span id="cb146-258"><a href="#cb146-258" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;Spalte &#39;EUR je kg&#39; macht sie entscheidbar - man vergleicht sie mit&quot;</span>)</span>
-<span id="cb146-259"><a href="#cb146-259" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;dem CO2-Preis, den das Unternehmen ohnehin ansetzt.&quot;</span>)</span>
-<span id="cb146-260"><a href="#cb146-260" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;=&quot;</span> <span class="op">*</span> <span class="dv">80</span>)</span></code></pre></div>
+<div class="sourceCode" id="cb148"><pre class="sourceCode python"><code class="sourceCode python"><span id="cb148-1"><a href="#cb148-1" aria-hidden="true" tabindex="-1"></a><span class="co">#!/usr/bin/env python3</span></span>
+<span id="cb148-2"><a href="#cb148-2" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb148-3"><a href="#cb148-3" aria-hidden="true" tabindex="-1"></a><span class="co"># Mehrziel_Pareto.py</span></span>
+<span id="cb148-4"><a href="#cb148-4" aria-hidden="true" tabindex="-1"></a><span class="co">&quot;&quot;&quot;</span></span>
+<span id="cb148-5"><a href="#cb148-5" aria-hidden="true" tabindex="-1"></a><span class="co">Kapitel Mehrziel: Kosten gegen CO2 - und warum Gewichte nicht genuegen.</span></span>
+<span id="cb148-6"><a href="#cb148-6" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb148-7"><a href="#cb148-7" aria-hidden="true" tabindex="-1"></a><span class="co">Eine Spedition vergibt zwoelf Sendungen an drei Verkehrstraeger: LKW (schnell,</span></span>
+<span id="cb148-8"><a href="#cb148-8" aria-hidden="true" tabindex="-1"></a><span class="co">teuer, schmutzig), Bahn (billig und sauber, aber nur fuenf Trassen frei) und</span></span>
+<span id="cb148-9"><a href="#cb148-9" aria-hidden="true" tabindex="-1"></a><span class="co">Kombinierten Verkehr (dazwischen). Zwei Ziele stehen gegeneinander:</span></span>
+<span id="cb148-10"><a href="#cb148-10" aria-hidden="true" tabindex="-1"></a><span class="co">Transportkosten und CO2-Ausstoss.</span></span>
+<span id="cb148-11"><a href="#cb148-11" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb148-12"><a href="#cb148-12" aria-hidden="true" tabindex="-1"></a><span class="co">Der uebliche Reflex ist, beide Ziele zu einem zusammenzuruehren:</span></span>
+<span id="cb148-13"><a href="#cb148-13" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb148-14"><a href="#cb148-14" aria-hidden="true" tabindex="-1"></a><span class="co">    minimiere   Kosten + w * CO2</span></span>
+<span id="cb148-15"><a href="#cb148-15" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb148-16"><a href="#cb148-16" aria-hidden="true" tabindex="-1"></a><span class="co">Das ist bequem, liefert zulaessige Loesungen - und ist unvollstaendig. Bei</span></span>
+<span id="cb148-17"><a href="#cb148-17" aria-hidden="true" tabindex="-1"></a><span class="co">ganzzahligen Entscheidungen gibt es Kompromisse, die auf diesem Weg</span></span>
+<span id="cb148-18"><a href="#cb148-18" aria-hidden="true" tabindex="-1"></a><span class="co">GRUNDSAETZLICH nicht erreichbar sind, egal welches w man waehlt. Nicht &quot;schwer</span></span>
+<span id="cb148-19"><a href="#cb148-19" aria-hidden="true" tabindex="-1"></a><span class="co">zu finden&quot;, sondern beweisbar unerreichbar.</span></span>
+<span id="cb148-20"><a href="#cb148-20" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb148-21"><a href="#cb148-21" aria-hidden="true" tabindex="-1"></a><span class="co">Das Programm zeigt in vier Teilen:</span></span>
+<span id="cb148-22"><a href="#cb148-22" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb148-23"><a href="#cb148-23" aria-hidden="true" tabindex="-1"></a><span class="co">  1. Die beiden Extreme - was jedes Ziel allein kostet.</span></span>
+<span id="cb148-24"><a href="#cb148-24" aria-hidden="true" tabindex="-1"></a><span class="co">  2. Die lineare Skalarisierung ueber ein feines Gewichtsraster.</span></span>
+<span id="cb148-25"><a href="#cb148-25" aria-hidden="true" tabindex="-1"></a><span class="co">  3. Die vollstaendige Pareto-Front ueber das eps-Constraint-Verfahren.</span></span>
+<span id="cb148-26"><a href="#cb148-26" aria-hidden="true" tabindex="-1"></a><span class="co">  4. Den Nachweis, dass die Luecke keine Frage des Rasters ist, sondern</span></span>
+<span id="cb148-27"><a href="#cb148-27" aria-hidden="true" tabindex="-1"></a><span class="co">     Geometrie: Die fehlenden Punkte liegen strikt oberhalb der konvexen</span></span>
+<span id="cb148-28"><a href="#cb148-28" aria-hidden="true" tabindex="-1"></a><span class="co">     Huelle und koennen deshalb von keiner Geraden gestuetzt werden.</span></span>
+<span id="cb148-29"><a href="#cb148-29" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb148-30"><a href="#cb148-30" aria-hidden="true" tabindex="-1"></a><span class="co">Benoetigt: numpy, scipy</span></span>
+<span id="cb148-31"><a href="#cb148-31" aria-hidden="true" tabindex="-1"></a><span class="co">&quot;&quot;&quot;</span></span>
+<span id="cb148-32"><a href="#cb148-32" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb148-33"><a href="#cb148-33" aria-hidden="true" tabindex="-1"></a><span class="im">from</span> __future__ <span class="im">import</span> annotations</span>
+<span id="cb148-34"><a href="#cb148-34" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb148-35"><a href="#cb148-35" aria-hidden="true" tabindex="-1"></a><span class="im">import</span> numpy <span class="im">as</span> np</span>
+<span id="cb148-36"><a href="#cb148-36" aria-hidden="true" tabindex="-1"></a><span class="im">from</span> scipy.optimize <span class="im">import</span> linprog</span>
+<span id="cb148-37"><a href="#cb148-37" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb148-38"><a href="#cb148-38" aria-hidden="true" tabindex="-1"></a>TRAEGER <span class="op">=</span> [<span class="st">&quot;LKW&quot;</span>, <span class="st">&quot;Bahn&quot;</span>, <span class="st">&quot;Kombiniert&quot;</span>]</span>
+<span id="cb148-39"><a href="#cb148-39" aria-hidden="true" tabindex="-1"></a>BAHN_TRASSEN <span class="op">=</span> <span class="dv">5</span>          <span class="co"># so viele Sendungen passen hoechstens auf die Bahn</span></span>
+<span id="cb148-40"><a href="#cb148-40" aria-hidden="true" tabindex="-1"></a>SAAT <span class="op">=</span> <span class="dv">5</span></span>
+<span id="cb148-41"><a href="#cb148-41" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb148-42"><a href="#cb148-42" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb148-43"><a href="#cb148-43" aria-hidden="true" tabindex="-1"></a><span class="kw">def</span> erzeuge_sendungen(anzahl: <span class="bu">int</span> <span class="op">=</span> <span class="dv">12</span>, saat: <span class="bu">int</span> <span class="op">=</span> SAAT):</span>
+<span id="cb148-44"><a href="#cb148-44" aria-hidden="true" tabindex="-1"></a>    <span class="co">&quot;&quot;&quot;Kosten und CO2 je Sendung und Verkehrstraeger.</span></span>
+<span id="cb148-45"><a href="#cb148-45" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb148-46"><a href="#cb148-46" aria-hidden="true" tabindex="-1"></a><span class="co">    Die Bahn ist immer billiger und sauberer als der LKW - der Zielkonflikt</span></span>
+<span id="cb148-47"><a href="#cb148-47" aria-hidden="true" tabindex="-1"></a><span class="co">    entsteht nicht zwischen den Traegern, sondern durch die KNAPPHEIT der</span></span>
+<span id="cb148-48"><a href="#cb148-48" aria-hidden="true" tabindex="-1"></a><span class="co">    Trassen. Genau so sieht es in der Praxis aus.</span></span>
+<span id="cb148-49"><a href="#cb148-49" aria-hidden="true" tabindex="-1"></a><span class="co">    &quot;&quot;&quot;</span></span>
+<span id="cb148-50"><a href="#cb148-50" aria-hidden="true" tabindex="-1"></a>    rng <span class="op">=</span> np.random.default_rng(saat)</span>
+<span id="cb148-51"><a href="#cb148-51" aria-hidden="true" tabindex="-1"></a>    kosten <span class="op">=</span> np.zeros((anzahl, <span class="dv">3</span>))</span>
+<span id="cb148-52"><a href="#cb148-52" aria-hidden="true" tabindex="-1"></a>    co2 <span class="op">=</span> np.zeros((anzahl, <span class="dv">3</span>))</span>
+<span id="cb148-53"><a href="#cb148-53" aria-hidden="true" tabindex="-1"></a>    <span class="cf">for</span> i <span class="kw">in</span> <span class="bu">range</span>(anzahl):</span>
+<span id="cb148-54"><a href="#cb148-54" aria-hidden="true" tabindex="-1"></a>        grund_kosten <span class="op">=</span> rng.integers(<span class="dv">600</span>, <span class="dv">2400</span>)</span>
+<span id="cb148-55"><a href="#cb148-55" aria-hidden="true" tabindex="-1"></a>        grund_co2 <span class="op">=</span> rng.integers(<span class="dv">400</span>, <span class="dv">1800</span>)</span>
+<span id="cb148-56"><a href="#cb148-56" aria-hidden="true" tabindex="-1"></a>        kosten[i] <span class="op">=</span> [grund_kosten,</span>
+<span id="cb148-57"><a href="#cb148-57" aria-hidden="true" tabindex="-1"></a>                     grund_kosten <span class="op">*</span> rng.uniform(<span class="fl">0.55</span>, <span class="fl">0.85</span>),</span>
+<span id="cb148-58"><a href="#cb148-58" aria-hidden="true" tabindex="-1"></a>                     grund_kosten <span class="op">*</span> rng.uniform(<span class="fl">0.70</span>, <span class="fl">1.00</span>)]</span>
+<span id="cb148-59"><a href="#cb148-59" aria-hidden="true" tabindex="-1"></a>        co2[i] <span class="op">=</span> [grund_co2,</span>
+<span id="cb148-60"><a href="#cb148-60" aria-hidden="true" tabindex="-1"></a>                  grund_co2 <span class="op">*</span> rng.uniform(<span class="fl">0.15</span>, <span class="fl">0.35</span>),</span>
+<span id="cb148-61"><a href="#cb148-61" aria-hidden="true" tabindex="-1"></a>                  grund_co2 <span class="op">*</span> rng.uniform(<span class="fl">0.40</span>, <span class="fl">0.70</span>)]</span>
+<span id="cb148-62"><a href="#cb148-62" aria-hidden="true" tabindex="-1"></a>    <span class="cf">return</span> np.<span class="bu">round</span>(kosten).astype(<span class="bu">int</span>), np.<span class="bu">round</span>(co2).astype(<span class="bu">int</span>)</span>
+<span id="cb148-63"><a href="#cb148-63" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb148-64"><a href="#cb148-64" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb148-65"><a href="#cb148-65" aria-hidden="true" tabindex="-1"></a>KOSTEN, CO2 <span class="op">=</span> erzeuge_sendungen()</span>
+<span id="cb148-66"><a href="#cb148-66" aria-hidden="true" tabindex="-1"></a>N <span class="op">=</span> <span class="bu">len</span>(KOSTEN)</span>
+<span id="cb148-67"><a href="#cb148-67" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb148-68"><a href="#cb148-68" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb148-69"><a href="#cb148-69" aria-hidden="true" tabindex="-1"></a><span class="kw">def</span> plane(ziel: np.ndarray, co2_grenze: <span class="bu">float</span> <span class="op">|</span> <span class="va">None</span> <span class="op">=</span> <span class="va">None</span>,</span>
+<span id="cb148-70"><a href="#cb148-70" aria-hidden="true" tabindex="-1"></a>          kosten_grenze: <span class="bu">float</span> <span class="op">|</span> <span class="va">None</span> <span class="op">=</span> <span class="va">None</span>):</span>
+<span id="cb148-71"><a href="#cb148-71" aria-hidden="true" tabindex="-1"></a>    <span class="co">&quot;&quot;&quot;Jede Sendung genau einem Traeger zuordnen; Trassen sind knapp.</span></span>
+<span id="cb148-72"><a href="#cb148-72" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb148-73"><a href="#cb148-73" aria-hidden="true" tabindex="-1"></a><span class="co">    &#39;ziel&#39; ist die zu minimierende Matrix (Kosten, CO2 oder eine Mischung).</span></span>
+<span id="cb148-74"><a href="#cb148-74" aria-hidden="true" tabindex="-1"></a><span class="co">    Die beiden Grenzen sind das Werkzeug fuer eps-Constraint und</span></span>
+<span id="cb148-75"><a href="#cb148-75" aria-hidden="true" tabindex="-1"></a><span class="co">    lexikografische Optimierung - sie machen aus einem Ziel eine Schranke.</span></span>
+<span id="cb148-76"><a href="#cb148-76" aria-hidden="true" tabindex="-1"></a><span class="co">    &quot;&quot;&quot;</span></span>
+<span id="cb148-77"><a href="#cb148-77" aria-hidden="true" tabindex="-1"></a>    gleichungen <span class="op">=</span> np.zeros((N, N <span class="op">*</span> <span class="dv">3</span>))</span>
+<span id="cb148-78"><a href="#cb148-78" aria-hidden="true" tabindex="-1"></a>    <span class="cf">for</span> i <span class="kw">in</span> <span class="bu">range</span>(N):</span>
+<span id="cb148-79"><a href="#cb148-79" aria-hidden="true" tabindex="-1"></a>        gleichungen[i, i <span class="op">*</span> <span class="dv">3</span>:(i <span class="op">+</span> <span class="dv">1</span>) <span class="op">*</span> <span class="dv">3</span>] <span class="op">=</span> <span class="fl">1.0</span>        <span class="co"># genau ein Traeger</span></span>
+<span id="cb148-80"><a href="#cb148-80" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb148-81"><a href="#cb148-81" aria-hidden="true" tabindex="-1"></a>    ungleichungen <span class="op">=</span> [[<span class="fl">1.0</span> <span class="cf">if</span> j <span class="op">==</span> <span class="dv">1</span> <span class="cf">else</span> <span class="fl">0.0</span> <span class="cf">for</span> _ <span class="kw">in</span> <span class="bu">range</span>(N) <span class="cf">for</span> j <span class="kw">in</span> <span class="bu">range</span>(<span class="dv">3</span>)]]</span>
+<span id="cb148-82"><a href="#cb148-82" aria-hidden="true" tabindex="-1"></a>    grenzen <span class="op">=</span> [<span class="bu">float</span>(BAHN_TRASSEN)]</span>
+<span id="cb148-83"><a href="#cb148-83" aria-hidden="true" tabindex="-1"></a>    <span class="cf">if</span> co2_grenze <span class="kw">is</span> <span class="kw">not</span> <span class="va">None</span>:</span>
+<span id="cb148-84"><a href="#cb148-84" aria-hidden="true" tabindex="-1"></a>        ungleichungen.append(CO2.reshape(<span class="op">-</span><span class="dv">1</span>).astype(<span class="bu">float</span>))</span>
+<span id="cb148-85"><a href="#cb148-85" aria-hidden="true" tabindex="-1"></a>        grenzen.append(<span class="bu">float</span>(co2_grenze))</span>
+<span id="cb148-86"><a href="#cb148-86" aria-hidden="true" tabindex="-1"></a>    <span class="cf">if</span> kosten_grenze <span class="kw">is</span> <span class="kw">not</span> <span class="va">None</span>:</span>
+<span id="cb148-87"><a href="#cb148-87" aria-hidden="true" tabindex="-1"></a>        ungleichungen.append(KOSTEN.reshape(<span class="op">-</span><span class="dv">1</span>).astype(<span class="bu">float</span>))</span>
+<span id="cb148-88"><a href="#cb148-88" aria-hidden="true" tabindex="-1"></a>        grenzen.append(<span class="bu">float</span>(kosten_grenze))</span>
+<span id="cb148-89"><a href="#cb148-89" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb148-90"><a href="#cb148-90" aria-hidden="true" tabindex="-1"></a>    ergebnis <span class="op">=</span> linprog(ziel.reshape(<span class="op">-</span><span class="dv">1</span>).astype(<span class="bu">float</span>),</span>
+<span id="cb148-91"><a href="#cb148-91" aria-hidden="true" tabindex="-1"></a>                       A_ub<span class="op">=</span>ungleichungen, b_ub<span class="op">=</span>grenzen,</span>
+<span id="cb148-92"><a href="#cb148-92" aria-hidden="true" tabindex="-1"></a>                       A_eq<span class="op">=</span>gleichungen, b_eq<span class="op">=</span>np.ones(N),</span>
+<span id="cb148-93"><a href="#cb148-93" aria-hidden="true" tabindex="-1"></a>                       bounds<span class="op">=</span>(<span class="dv">0</span>, <span class="dv">1</span>), integrality<span class="op">=</span><span class="dv">1</span>, method<span class="op">=</span><span class="st">&quot;highs&quot;</span>)</span>
+<span id="cb148-94"><a href="#cb148-94" aria-hidden="true" tabindex="-1"></a>    <span class="cf">if</span> <span class="kw">not</span> ergebnis.success:</span>
+<span id="cb148-95"><a href="#cb148-95" aria-hidden="true" tabindex="-1"></a>        <span class="cf">return</span> <span class="va">None</span></span>
+<span id="cb148-96"><a href="#cb148-96" aria-hidden="true" tabindex="-1"></a>    plan <span class="op">=</span> np.<span class="bu">round</span>(ergebnis.x).astype(<span class="bu">int</span>)</span>
+<span id="cb148-97"><a href="#cb148-97" aria-hidden="true" tabindex="-1"></a>    <span class="cf">return</span> (<span class="bu">int</span>(KOSTEN.reshape(<span class="op">-</span><span class="dv">1</span>) <span class="op">@</span> plan), <span class="bu">int</span>(CO2.reshape(<span class="op">-</span><span class="dv">1</span>) <span class="op">@</span> plan), plan)</span>
+<span id="cb148-98"><a href="#cb148-98" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb148-99"><a href="#cb148-99" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb148-100"><a href="#cb148-100" aria-hidden="true" tabindex="-1"></a><span class="kw">def</span> pareto_front():</span>
+<span id="cb148-101"><a href="#cb148-101" aria-hidden="true" tabindex="-1"></a>    <span class="co">&quot;&quot;&quot;Vollstaendige Front ueber das eps-Constraint-Verfahren.</span></span>
+<span id="cb148-102"><a href="#cb148-102" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb148-103"><a href="#cb148-103" aria-hidden="true" tabindex="-1"></a><span class="co">    Der Ablauf ist der eigentliche Inhalt dieser Funktion: Erst das</span></span>
+<span id="cb148-104"><a href="#cb148-104" aria-hidden="true" tabindex="-1"></a><span class="co">    Kostenminimum bestimmen (der eine Rand der Front), dann die CO2-Schranke</span></span>
+<span id="cb148-105"><a href="#cb148-105" aria-hidden="true" tabindex="-1"></a><span class="co">    schrittweise um genau ein Kilogramm unter den zuletzt erreichten Wert</span></span>
+<span id="cb148-106"><a href="#cb148-106" aria-hidden="true" tabindex="-1"></a><span class="co">    druecken. Jeder Lauf liefert den naechsten Punkt - und wenn keiner mehr</span></span>
+<span id="cb148-107"><a href="#cb148-107" aria-hidden="true" tabindex="-1"></a><span class="co">    zulaessig ist, ist die Front vollstaendig.</span></span>
+<span id="cb148-108"><a href="#cb148-108" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb148-109"><a href="#cb148-109" aria-hidden="true" tabindex="-1"></a><span class="co">    Das braucht so viele Solveraufrufe, wie die Front Punkte hat. Ein Raster</span></span>
+<span id="cb148-110"><a href="#cb148-110" aria-hidden="true" tabindex="-1"></a><span class="co">    ueber alle moeglichen CO2-Werte braeuchte hier fast tausend.</span></span>
+<span id="cb148-111"><a href="#cb148-111" aria-hidden="true" tabindex="-1"></a><span class="co">    &quot;&quot;&quot;</span></span>
+<span id="cb148-112"><a href="#cb148-112" aria-hidden="true" tabindex="-1"></a>    front <span class="op">=</span> []</span>
+<span id="cb148-113"><a href="#cb148-113" aria-hidden="true" tabindex="-1"></a>    start <span class="op">=</span> plane(KOSTEN)</span>
+<span id="cb148-114"><a href="#cb148-114" aria-hidden="true" tabindex="-1"></a>    grenze <span class="op">=</span> start[<span class="dv">1</span>]</span>
+<span id="cb148-115"><a href="#cb148-115" aria-hidden="true" tabindex="-1"></a>    <span class="cf">while</span> <span class="va">True</span>:</span>
+<span id="cb148-116"><a href="#cb148-116" aria-hidden="true" tabindex="-1"></a>        ergebnis <span class="op">=</span> plane(KOSTEN, co2_grenze<span class="op">=</span>grenze)</span>
+<span id="cb148-117"><a href="#cb148-117" aria-hidden="true" tabindex="-1"></a>        <span class="cf">if</span> ergebnis <span class="kw">is</span> <span class="va">None</span>:</span>
+<span id="cb148-118"><a href="#cb148-118" aria-hidden="true" tabindex="-1"></a>            <span class="cf">break</span></span>
+<span id="cb148-119"><a href="#cb148-119" aria-hidden="true" tabindex="-1"></a>        front.append((ergebnis[<span class="dv">0</span>], ergebnis[<span class="dv">1</span>]))</span>
+<span id="cb148-120"><a href="#cb148-120" aria-hidden="true" tabindex="-1"></a>        grenze <span class="op">=</span> ergebnis[<span class="dv">1</span>] <span class="op">-</span> <span class="dv">1</span></span>
+<span id="cb148-121"><a href="#cb148-121" aria-hidden="true" tabindex="-1"></a>    <span class="cf">return</span> front</span>
+<span id="cb148-122"><a href="#cb148-122" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb148-123"><a href="#cb148-123" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb148-124"><a href="#cb148-124" aria-hidden="true" tabindex="-1"></a><span class="kw">def</span> skalarisierung(gewichte):</span>
+<span id="cb148-125"><a href="#cb148-125" aria-hidden="true" tabindex="-1"></a>    <span class="co">&quot;&quot;&quot;Was &#39;Kosten + w * CO2&#39; fuer viele w hergibt - als Menge von Punkten.&quot;&quot;&quot;</span></span>
+<span id="cb148-126"><a href="#cb148-126" aria-hidden="true" tabindex="-1"></a>    gefunden <span class="op">=</span> {}</span>
+<span id="cb148-127"><a href="#cb148-127" aria-hidden="true" tabindex="-1"></a>    <span class="cf">for</span> w <span class="kw">in</span> gewichte:</span>
+<span id="cb148-128"><a href="#cb148-128" aria-hidden="true" tabindex="-1"></a>        ergebnis <span class="op">=</span> plane(KOSTEN <span class="op">+</span> w <span class="op">*</span> CO2)</span>
+<span id="cb148-129"><a href="#cb148-129" aria-hidden="true" tabindex="-1"></a>        <span class="cf">if</span> ergebnis:</span>
+<span id="cb148-130"><a href="#cb148-130" aria-hidden="true" tabindex="-1"></a>            gefunden.setdefault((ergebnis[<span class="dv">0</span>], ergebnis[<span class="dv">1</span>]), []).append(w)</span>
+<span id="cb148-131"><a href="#cb148-131" aria-hidden="true" tabindex="-1"></a>    <span class="cf">return</span> gefunden</span>
+<span id="cb148-132"><a href="#cb148-132" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb148-133"><a href="#cb148-133" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb148-134"><a href="#cb148-134" aria-hidden="true" tabindex="-1"></a><span class="kw">def</span> untere_huelle(punkte):</span>
+<span id="cb148-135"><a href="#cb148-135" aria-hidden="true" tabindex="-1"></a>    <span class="co">&quot;&quot;&quot;Untere linke konvexe Huelle - genau die Punkte, die eine Gerade stuetzt.</span></span>
+<span id="cb148-136"><a href="#cb148-136" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb148-137"><a href="#cb148-137" aria-hidden="true" tabindex="-1"></a><span class="co">    Der Zusammenhang, um den es geht: &#39;Kosten + w*CO2 minimieren&#39; heisst</span></span>
+<span id="cb148-138"><a href="#cb148-138" aria-hidden="true" tabindex="-1"></a><span class="co">    geometrisch, eine Gerade der Steigung -1/w von links unten an die</span></span>
+<span id="cb148-139"><a href="#cb148-139" aria-hidden="true" tabindex="-1"></a><span class="co">    Punktwolke zu schieben. Sie beruehrt immer einen Eckpunkt der konvexen</span></span>
+<span id="cb148-140"><a href="#cb148-140" aria-hidden="true" tabindex="-1"></a><span class="co">    Huelle. Punkte, die oberhalb liegen, werden nie beruehrt - fuer kein w.</span></span>
+<span id="cb148-141"><a href="#cb148-141" aria-hidden="true" tabindex="-1"></a><span class="co">    &quot;&quot;&quot;</span></span>
+<span id="cb148-142"><a href="#cb148-142" aria-hidden="true" tabindex="-1"></a>    huelle <span class="op">=</span> []</span>
+<span id="cb148-143"><a href="#cb148-143" aria-hidden="true" tabindex="-1"></a>    <span class="cf">for</span> punkt <span class="kw">in</span> <span class="bu">sorted</span>(punkte):</span>
+<span id="cb148-144"><a href="#cb148-144" aria-hidden="true" tabindex="-1"></a>        <span class="cf">while</span> <span class="bu">len</span>(huelle) <span class="op">&gt;=</span> <span class="dv">2</span>:</span>
+<span id="cb148-145"><a href="#cb148-145" aria-hidden="true" tabindex="-1"></a>            (x1, y1), (x2, y2) <span class="op">=</span> huelle[<span class="op">-</span><span class="dv">2</span>], huelle[<span class="op">-</span><span class="dv">1</span>]</span>
+<span id="cb148-146"><a href="#cb148-146" aria-hidden="true" tabindex="-1"></a>            <span class="cf">if</span> (x2 <span class="op">-</span> x1) <span class="op">*</span> (punkt[<span class="dv">1</span>] <span class="op">-</span> y1) <span class="op">-</span> (y2 <span class="op">-</span> y1) <span class="op">*</span> (punkt[<span class="dv">0</span>] <span class="op">-</span> x1) <span class="op">&lt;=</span> <span class="dv">0</span>:</span>
+<span id="cb148-147"><a href="#cb148-147" aria-hidden="true" tabindex="-1"></a>                huelle.pop()</span>
+<span id="cb148-148"><a href="#cb148-148" aria-hidden="true" tabindex="-1"></a>            <span class="cf">else</span>:</span>
+<span id="cb148-149"><a href="#cb148-149" aria-hidden="true" tabindex="-1"></a>                <span class="cf">break</span></span>
+<span id="cb148-150"><a href="#cb148-150" aria-hidden="true" tabindex="-1"></a>        huelle.append(punkt)</span>
+<span id="cb148-151"><a href="#cb148-151" aria-hidden="true" tabindex="-1"></a>    <span class="cf">return</span> huelle</span>
+<span id="cb148-152"><a href="#cb148-152" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb148-153"><a href="#cb148-153" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb148-154"><a href="#cb148-154" aria-hidden="true" tabindex="-1"></a><span class="cf">if</span> <span class="va">__name__</span> <span class="op">==</span> <span class="st">&quot;__main__&quot;</span>:</span>
+<span id="cb148-155"><a href="#cb148-155" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;=&quot;</span> <span class="op">*</span> <span class="dv">80</span>)</span>
+<span id="cb148-156"><a href="#cb148-156" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;  KOSTEN GEGEN CO2 - UND WARUM GEWICHTE NICHT GENUEGEN&quot;</span>)</span>
+<span id="cb148-157"><a href="#cb148-157" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;=&quot;</span> <span class="op">*</span> <span class="dv">80</span>)</span>
+<span id="cb148-158"><a href="#cb148-158" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;</span><span class="sc">{</span>N<span class="sc">}</span><span class="ss"> Sendungen, </span><span class="sc">{</span><span class="bu">len</span>(TRAEGER)<span class="sc">}</span><span class="ss"> Verkehrstraeger, &quot;</span></span>
+<span id="cb148-159"><a href="#cb148-159" aria-hidden="true" tabindex="-1"></a>          <span class="ss">f&quot;</span><span class="sc">{</span>BAHN_TRASSEN<span class="sc">}</span><span class="ss"> freie Bahntrassen.</span><span class="ch">\n</span><span class="ss">&quot;</span>)</span>
+<span id="cb148-160"><a href="#cb148-160" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb148-161"><a href="#cb148-161" aria-hidden="true" tabindex="-1"></a>    <span class="co"># --- 1. Die beiden Extreme -------------------------------------------</span></span>
+<span id="cb148-162"><a href="#cb148-162" aria-hidden="true" tabindex="-1"></a>    guenstigst <span class="op">=</span> plane(KOSTEN)</span>
+<span id="cb148-163"><a href="#cb148-163" aria-hidden="true" tabindex="-1"></a>    saubersten <span class="op">=</span> plane(CO2)</span>
+<span id="cb148-164"><a href="#cb148-164" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;1. Was jedes Ziel allein ergibt</span><span class="ch">\n</span><span class="st">&quot;</span>)</span>
+<span id="cb148-165"><a href="#cb148-165" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;  </span><span class="sc">{</span><span class="st">&#39;&#39;</span><span class="sc">:&lt;22}</span><span class="ss"> </span><span class="sc">{</span><span class="st">&#39;Kosten&#39;</span><span class="sc">:&gt;10}</span><span class="ss"> </span><span class="sc">{</span><span class="st">&#39;CO2&#39;</span><span class="sc">:&gt;10}</span><span class="ss">&quot;</span>)</span>
+<span id="cb148-166"><a href="#cb148-166" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;  &quot;</span> <span class="op">+</span> <span class="st">&quot;-&quot;</span> <span class="op">*</span> <span class="dv">44</span>)</span>
+<span id="cb148-167"><a href="#cb148-167" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;  </span><span class="sc">{</span><span class="st">&#39;nur Kosten minimal&#39;</span><span class="sc">:&lt;22}</span><span class="ss"> </span><span class="sc">{</span>guenstigst[<span class="dv">0</span>]<span class="sc">:&gt;10,}</span><span class="ss"> </span><span class="sc">{</span>guenstigst[<span class="dv">1</span>]<span class="sc">:&gt;9,}</span><span class="ss"> kg&quot;</span>)</span>
+<span id="cb148-168"><a href="#cb148-168" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;  </span><span class="sc">{</span><span class="st">&#39;nur CO2 minimal&#39;</span><span class="sc">:&lt;22}</span><span class="ss"> </span><span class="sc">{</span>saubersten[<span class="dv">0</span>]<span class="sc">:&gt;10,}</span><span class="ss"> </span><span class="sc">{</span>saubersten[<span class="dv">1</span>]<span class="sc">:&gt;9,}</span><span class="ss"> kg&quot;</span>)</span>
+<span id="cb148-169"><a href="#cb148-169" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;</span><span class="ch">\n</span><span class="ss">  Der Zielkonflikt ist echt, aber klein: &quot;</span></span>
+<span id="cb148-170"><a href="#cb148-170" aria-hidden="true" tabindex="-1"></a>          <span class="ss">f&quot;</span><span class="sc">{</span>saubersten[<span class="dv">0</span>] <span class="op">-</span> guenstigst[<span class="dv">0</span>]<span class="sc">:,}</span><span class="ss"> EUR mehr&quot;</span>)</span>
+<span id="cb148-171"><a href="#cb148-171" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;  (</span><span class="sc">{</span>(saubersten[<span class="dv">0</span>] <span class="op">-</span> guenstigst[<span class="dv">0</span>]) <span class="op">/</span> guenstigst[<span class="dv">0</span>] <span class="op">*</span> <span class="dv">100</span><span class="sc">:.1f}</span><span class="ss"> %) sparen &quot;</span></span>
+<span id="cb148-172"><a href="#cb148-172" aria-hidden="true" tabindex="-1"></a>          <span class="ss">f&quot;</span><span class="sc">{</span>guenstigst[<span class="dv">1</span>] <span class="op">-</span> saubersten[<span class="dv">1</span>]<span class="sc">:,}</span><span class="ss"> kg CO2 &quot;</span></span>
+<span id="cb148-173"><a href="#cb148-173" aria-hidden="true" tabindex="-1"></a>          <span class="ss">f&quot;(</span><span class="sc">{</span>(guenstigst[<span class="dv">1</span>] <span class="op">-</span> saubersten[<span class="dv">1</span>]) <span class="op">/</span> guenstigst[<span class="dv">1</span>] <span class="op">*</span> <span class="dv">100</span><span class="sc">:.1f}</span><span class="ss"> %).&quot;</span>)</span>
+<span id="cb148-174"><a href="#cb148-174" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;  Genau solche Zahlen will die Geschaeftsfuehrung sehen - nicht ein&quot;</span>)</span>
+<span id="cb148-175"><a href="#cb148-175" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;  Gewicht, das niemand interpretieren kann.&quot;</span>)</span>
+<span id="cb148-176"><a href="#cb148-176" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb148-177"><a href="#cb148-177" aria-hidden="true" tabindex="-1"></a>    <span class="co"># --- 2. Die lineare Skalarisierung -----------------------------------</span></span>
+<span id="cb148-178"><a href="#cb148-178" aria-hidden="true" tabindex="-1"></a>    gewichte <span class="op">=</span> np.concatenate([np.linspace(<span class="fl">0.0</span>, <span class="fl">3.0</span>, <span class="dv">1201</span>),</span>
+<span id="cb148-179"><a href="#cb148-179" aria-hidden="true" tabindex="-1"></a>                               np.geomspace(<span class="fl">3.0</span>, <span class="fl">1000.0</span>, <span class="dv">200</span>)])</span>
+<span id="cb148-180"><a href="#cb148-180" aria-hidden="true" tabindex="-1"></a>    gefunden <span class="op">=</span> skalarisierung(gewichte)</span>
+<span id="cb148-181"><a href="#cb148-181" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;</span><span class="ch">\n</span><span class="st">&quot;</span> <span class="op">+</span> <span class="st">&quot;-&quot;</span> <span class="op">*</span> <span class="dv">80</span>)</span>
+<span id="cb148-182"><a href="#cb148-182" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;2. Lineare Skalarisierung: &#39;Kosten + w * CO2&#39; fuer &quot;</span></span>
+<span id="cb148-183"><a href="#cb148-183" aria-hidden="true" tabindex="-1"></a>          <span class="ss">f&quot;</span><span class="sc">{</span><span class="bu">len</span>(gewichte)<span class="sc">:,}</span><span class="ss"> Gewichte</span><span class="ch">\n</span><span class="ss">&quot;</span>)</span>
+<span id="cb148-184"><a href="#cb148-184" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;  </span><span class="sc">{</span><span class="st">&#39;Kosten&#39;</span><span class="sc">:&gt;10}</span><span class="ss"> </span><span class="sc">{</span><span class="st">&#39;CO2&#39;</span><span class="sc">:&gt;10}</span><span class="ss">   </span><span class="sc">{</span><span class="st">&#39;gefunden bei w&#39;</span><span class="sc">:&gt;16}</span><span class="ss">&quot;</span>)</span>
+<span id="cb148-185"><a href="#cb148-185" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;  &quot;</span> <span class="op">+</span> <span class="st">&quot;-&quot;</span> <span class="op">*</span> <span class="dv">46</span>)</span>
+<span id="cb148-186"><a href="#cb148-186" aria-hidden="true" tabindex="-1"></a>    <span class="cf">for</span> (k, c), ws <span class="kw">in</span> <span class="bu">sorted</span>(gefunden.items()):</span>
+<span id="cb148-187"><a href="#cb148-187" aria-hidden="true" tabindex="-1"></a>        <span class="bu">print</span>(<span class="ss">f&quot;  </span><span class="sc">{</span>k<span class="sc">:&gt;10,}</span><span class="ss"> </span><span class="sc">{</span>c<span class="sc">:&gt;9,}</span><span class="ss"> kg   </span><span class="sc">{</span><span class="bu">min</span>(ws)<span class="sc">:&gt;7.3f}</span><span class="ss"> bis </span><span class="sc">{</span><span class="bu">max</span>(ws)<span class="sc">:&gt;7.3f}</span><span class="ss">&quot;</span>)</span>
+<span id="cb148-188"><a href="#cb148-188" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;</span><span class="ch">\n</span><span class="ss">  </span><span class="sc">{</span><span class="bu">len</span>(gefunden)<span class="sc">}</span><span class="ss"> verschiedene Plaene - fuer </span><span class="sc">{</span><span class="bu">len</span>(gewichte)<span class="sc">:,}</span><span class="ss"> Gewichte.&quot;</span>)</span>
+<span id="cb148-189"><a href="#cb148-189" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;  Das Gewicht ist also gar keine Feineinstellung: Weite Bereiche&quot;</span>)</span>
+<span id="cb148-190"><a href="#cb148-190" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;  liefern dasselbe Ergebnis, und dazwischen springt es.&quot;</span>)</span>
+<span id="cb148-191"><a href="#cb148-191" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb148-192"><a href="#cb148-192" aria-hidden="true" tabindex="-1"></a>    <span class="co"># --- 3. Die vollstaendige Front --------------------------------------</span></span>
+<span id="cb148-193"><a href="#cb148-193" aria-hidden="true" tabindex="-1"></a>    front <span class="op">=</span> pareto_front()</span>
+<span id="cb148-194"><a href="#cb148-194" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;</span><span class="ch">\n</span><span class="st">&quot;</span> <span class="op">+</span> <span class="st">&quot;-&quot;</span> <span class="op">*</span> <span class="dv">80</span>)</span>
+<span id="cb148-195"><a href="#cb148-195" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;3. Die vollstaendige Pareto-Front ueber eps-Constraint &quot;</span></span>
+<span id="cb148-196"><a href="#cb148-196" aria-hidden="true" tabindex="-1"></a>          <span class="ss">f&quot;(</span><span class="sc">{</span><span class="bu">len</span>(front)<span class="sc">}</span><span class="ss"> Solverlaeufe)</span><span class="ch">\n</span><span class="ss">&quot;</span>)</span>
+<span id="cb148-197"><a href="#cb148-197" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;  </span><span class="sc">{</span><span class="st">&#39;Kosten&#39;</span><span class="sc">:&gt;10}</span><span class="ss"> </span><span class="sc">{</span><span class="st">&#39;CO2&#39;</span><span class="sc">:&gt;10}</span><span class="ss">   </span><span class="sc">{</span><span class="st">&#39;Aufpreis&#39;</span><span class="sc">:&gt;9}</span><span class="ss"> </span><span class="sc">{</span><span class="st">&#39;CO2-Ersparnis&#39;</span><span class="sc">:&gt;14}</span><span class="ss"> &quot;</span></span>
+<span id="cb148-198"><a href="#cb148-198" aria-hidden="true" tabindex="-1"></a>          <span class="ss">f&quot;</span><span class="sc">{</span><span class="st">&#39;EUR je kg&#39;</span><span class="sc">:&gt;10}</span><span class="ss">&quot;</span>)</span>
+<span id="cb148-199"><a href="#cb148-199" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;  &quot;</span> <span class="op">+</span> <span class="st">&quot;-&quot;</span> <span class="op">*</span> <span class="dv">60</span>)</span>
+<span id="cb148-200"><a href="#cb148-200" aria-hidden="true" tabindex="-1"></a>    <span class="cf">for</span> k, c <span class="kw">in</span> front:</span>
+<span id="cb148-201"><a href="#cb148-201" aria-hidden="true" tabindex="-1"></a>        auf <span class="op">=</span> k <span class="op">-</span> guenstigst[<span class="dv">0</span>]</span>
+<span id="cb148-202"><a href="#cb148-202" aria-hidden="true" tabindex="-1"></a>        ersparnis <span class="op">=</span> guenstigst[<span class="dv">1</span>] <span class="op">-</span> c</span>
+<span id="cb148-203"><a href="#cb148-203" aria-hidden="true" tabindex="-1"></a>        preis <span class="op">=</span> auf <span class="op">/</span> ersparnis <span class="cf">if</span> ersparnis <span class="cf">else</span> <span class="fl">0.0</span></span>
+<span id="cb148-204"><a href="#cb148-204" aria-hidden="true" tabindex="-1"></a>        <span class="bu">print</span>(<span class="ss">f&quot;  </span><span class="sc">{</span>k<span class="sc">:&gt;10,}</span><span class="ss"> </span><span class="sc">{</span>c<span class="sc">:&gt;9,}</span><span class="ss"> kg   </span><span class="sc">{</span>auf<span class="sc">:&gt;8,}</span><span class="ss"> </span><span class="sc">{</span>ersparnis<span class="sc">:&gt;13,}</span><span class="ss"> &quot;</span></span>
+<span id="cb148-205"><a href="#cb148-205" aria-hidden="true" tabindex="-1"></a>              <span class="ss">f&quot;</span><span class="sc">{</span>preis<span class="sc">:&gt;10.2f}</span><span class="ss">&quot;</span>)</span>
+<span id="cb148-206"><a href="#cb148-206" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb148-207"><a href="#cb148-207" aria-hidden="true" tabindex="-1"></a>    <span class="co"># --- 4. Der Nachweis --------------------------------------------------</span></span>
+<span id="cb148-208"><a href="#cb148-208" aria-hidden="true" tabindex="-1"></a>    huelle <span class="op">=</span> untere_huelle(front)</span>
+<span id="cb148-209"><a href="#cb148-209" aria-hidden="true" tabindex="-1"></a>    unerreichbar <span class="op">=</span> [p <span class="cf">for</span> p <span class="kw">in</span> front <span class="cf">if</span> p <span class="kw">not</span> <span class="kw">in</span> huelle]</span>
+<span id="cb148-210"><a href="#cb148-210" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;</span><span class="ch">\n</span><span class="st">&quot;</span> <span class="op">+</span> <span class="st">&quot;-&quot;</span> <span class="op">*</span> <span class="dv">80</span>)</span>
+<span id="cb148-211"><a href="#cb148-211" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;4. Was die Skalarisierung nicht findet</span><span class="ch">\n</span><span class="st">&quot;</span>)</span>
+<span id="cb148-212"><a href="#cb148-212" aria-hidden="true" tabindex="-1"></a>    erreicht <span class="op">=</span> [p <span class="cf">for</span> p <span class="kw">in</span> front <span class="cf">if</span> p <span class="kw">in</span> gefunden]</span>
+<span id="cb148-213"><a href="#cb148-213" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;  Pareto-Punkte insgesamt:              </span><span class="sc">{</span><span class="bu">len</span>(front)<span class="sc">}</span><span class="ss">&quot;</span>)</span>
+<span id="cb148-214"><a href="#cb148-214" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;  davon von der Skalarisierung gefunden: </span><span class="sc">{</span><span class="bu">len</span>(erreicht)<span class="sc">}</span><span class="ss">&quot;</span>)</span>
+<span id="cb148-215"><a href="#cb148-215" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;  nie gefunden:                          </span><span class="sc">{</span><span class="bu">len</span>(front) <span class="op">-</span> <span class="bu">len</span>(erreicht)<span class="sc">}</span><span class="ss">&quot;</span>)</span>
+<span id="cb148-216"><a href="#cb148-216" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>()</span>
+<span id="cb148-217"><a href="#cb148-217" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;  Diese Kompromisse sind fuer KEIN Gewicht erreichbar:</span><span class="ch">\n</span><span class="st">&quot;</span>)</span>
+<span id="cb148-218"><a href="#cb148-218" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;  </span><span class="sc">{</span><span class="st">&#39;Kosten&#39;</span><span class="sc">:&gt;10}</span><span class="ss"> </span><span class="sc">{</span><span class="st">&#39;CO2&#39;</span><span class="sc">:&gt;10}</span><span class="ss">   </span><span class="sc">{</span><span class="st">&#39;Aufpreis&#39;</span><span class="sc">:&gt;9}</span><span class="ss"> </span><span class="sc">{</span><span class="st">&#39;CO2-Ersparnis&#39;</span><span class="sc">:&gt;14}</span><span class="ss">&quot;</span>)</span>
+<span id="cb148-219"><a href="#cb148-219" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;  &quot;</span> <span class="op">+</span> <span class="st">&quot;-&quot;</span> <span class="op">*</span> <span class="dv">50</span>)</span>
+<span id="cb148-220"><a href="#cb148-220" aria-hidden="true" tabindex="-1"></a>    <span class="cf">for</span> k, c <span class="kw">in</span> unerreichbar:</span>
+<span id="cb148-221"><a href="#cb148-221" aria-hidden="true" tabindex="-1"></a>        <span class="bu">print</span>(<span class="ss">f&quot;  </span><span class="sc">{</span>k<span class="sc">:&gt;10,}</span><span class="ss"> </span><span class="sc">{</span>c<span class="sc">:&gt;9,}</span><span class="ss"> kg   </span><span class="sc">{</span>k <span class="op">-</span> guenstigst[<span class="dv">0</span>]<span class="sc">:&gt;8,}</span><span class="ss"> &quot;</span></span>
+<span id="cb148-222"><a href="#cb148-222" aria-hidden="true" tabindex="-1"></a>              <span class="ss">f&quot;</span><span class="sc">{</span>guenstigst[<span class="dv">1</span>] <span class="op">-</span> c<span class="sc">:&gt;13,}</span><span class="ss">&quot;</span>)</span>
+<span id="cb148-223"><a href="#cb148-223" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb148-224"><a href="#cb148-224" aria-hidden="true" tabindex="-1"></a>    stimmt <span class="op">=</span> <span class="bu">sorted</span>(unerreichbar) <span class="op">==</span> <span class="bu">sorted</span>(p <span class="cf">for</span> p <span class="kw">in</span> front <span class="cf">if</span> p <span class="kw">not</span> <span class="kw">in</span> gefunden)</span>
+<span id="cb148-225"><a href="#cb148-225" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;</span><span class="ch">\n</span><span class="ss">  Gegenprobe ueber die Geometrie: </span><span class="sc">{</span><span class="st">&#39;bestanden&#39;</span> <span class="cf">if</span> stimmt <span class="cf">else</span> <span class="st">&#39;ABWEICHUNG&#39;</span><span class="sc">}</span><span class="ss">&quot;</span>)</span>
+<span id="cb148-226"><a href="#cb148-226" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;  Genau die Punkte, die das Gewichtsraster verfehlt, liegen strikt&quot;</span>)</span>
+<span id="cb148-227"><a href="#cb148-227" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;  oberhalb der unteren konvexen Huelle. Das ist kein Rasterproblem -&quot;</span>)</span>
+<span id="cb148-228"><a href="#cb148-228" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;  eine Gerade, die von links unten an die Wolke geschoben wird,&quot;</span>)</span>
+<span id="cb148-229"><a href="#cb148-229" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;  beruehrt immer einen Eckpunkt der Huelle und nie einen Punkt&quot;</span>)</span>
+<span id="cb148-230"><a href="#cb148-230" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;  darueber. Ein feineres Raster aendert daran nichts.&quot;</span>)</span>
+<span id="cb148-231"><a href="#cb148-231" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb148-232"><a href="#cb148-232" aria-hidden="true" tabindex="-1"></a>    <span class="co"># --- 5. Lexikografisch -------------------------------------------------</span></span>
+<span id="cb148-233"><a href="#cb148-233" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;</span><span class="ch">\n</span><span class="st">&quot;</span> <span class="op">+</span> <span class="st">&quot;-&quot;</span> <span class="op">*</span> <span class="dv">80</span>)</span>
+<span id="cb148-234"><a href="#cb148-234" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;5. Lexikografisch: erst Kosten, dann CO2 im Rahmen eines Budgets</span><span class="ch">\n</span><span class="st">&quot;</span>)</span>
+<span id="cb148-235"><a href="#cb148-235" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;  </span><span class="sc">{</span><span class="st">&#39;Kostenbudget&#39;</span><span class="sc">:&gt;14}</span><span class="ss"> </span><span class="sc">{</span><span class="st">&#39;Kosten&#39;</span><span class="sc">:&gt;10}</span><span class="ss"> </span><span class="sc">{</span><span class="st">&#39;CO2&#39;</span><span class="sc">:&gt;10}</span><span class="ss"> </span><span class="sc">{</span><span class="st">&#39;gegenueber Minimum&#39;</span><span class="sc">:&gt;20}</span><span class="ss">&quot;</span>)</span>
+<span id="cb148-236"><a href="#cb148-236" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;  &quot;</span> <span class="op">+</span> <span class="st">&quot;-&quot;</span> <span class="op">*</span> <span class="dv">58</span>)</span>
+<span id="cb148-237"><a href="#cb148-237" aria-hidden="true" tabindex="-1"></a>    <span class="cf">for</span> aufschlag <span class="kw">in</span> (<span class="fl">0.00</span>, <span class="fl">0.01</span>, <span class="fl">0.02</span>, <span class="fl">0.05</span>, <span class="fl">0.10</span>):</span>
+<span id="cb148-238"><a href="#cb148-238" aria-hidden="true" tabindex="-1"></a>        budget <span class="op">=</span> guenstigst[<span class="dv">0</span>] <span class="op">*</span> (<span class="dv">1</span> <span class="op">+</span> aufschlag)</span>
+<span id="cb148-239"><a href="#cb148-239" aria-hidden="true" tabindex="-1"></a>        ergebnis <span class="op">=</span> plane(CO2, kosten_grenze<span class="op">=</span>budget)</span>
+<span id="cb148-240"><a href="#cb148-240" aria-hidden="true" tabindex="-1"></a>        <span class="cf">if</span> ergebnis <span class="kw">is</span> <span class="va">None</span>:</span>
+<span id="cb148-241"><a href="#cb148-241" aria-hidden="true" tabindex="-1"></a>            <span class="bu">print</span>(<span class="ss">f&quot;  </span><span class="sc">{</span>aufschlag<span class="sc">:&gt;13.0%}</span><span class="ss"> unzulaessig&quot;</span>)</span>
+<span id="cb148-242"><a href="#cb148-242" aria-hidden="true" tabindex="-1"></a>            <span class="cf">continue</span></span>
+<span id="cb148-243"><a href="#cb148-243" aria-hidden="true" tabindex="-1"></a>        <span class="bu">print</span>(<span class="ss">f&quot;  </span><span class="sc">{</span>aufschlag<span class="sc">:&gt;13.0%}</span><span class="ss"> </span><span class="sc">{</span>ergebnis[<span class="dv">0</span>]<span class="sc">:&gt;10,}</span><span class="ss"> </span><span class="sc">{</span>ergebnis[<span class="dv">1</span>]<span class="sc">:&gt;9,}</span><span class="ss"> kg &quot;</span></span>
+<span id="cb148-244"><a href="#cb148-244" aria-hidden="true" tabindex="-1"></a>              <span class="ss">f&quot;</span><span class="sc">{</span>guenstigst[<span class="dv">1</span>] <span class="op">-</span> ergebnis[<span class="dv">1</span>]<span class="sc">:&gt;15,}</span><span class="ss"> kg weniger&quot;</span>)</span>
+<span id="cb148-245"><a href="#cb148-245" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb148-246"><a href="#cb148-246" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;</span><span class="ch">\n</span><span class="st">  Das ist die Form, die im Betrieb am ehesten trifft: Nicht &#39;wie&quot;</span>)</span>
+<span id="cb148-247"><a href="#cb148-247" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;  wichtig ist CO2?&#39;, sondern &#39;wir geben zwei Prozent mehr aus - was&quot;</span>)</span>
+<span id="cb148-248"><a href="#cb148-248" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;  bringt das?&#39;. Die Frage kann ein Kaufmann beantworten.&quot;</span>)</span>
+<span id="cb148-249"><a href="#cb148-249" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb148-250"><a href="#cb148-250" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;</span><span class="ch">\n</span><span class="st">&quot;</span> <span class="op">+</span> <span class="st">&quot;=&quot;</span> <span class="op">*</span> <span class="dv">80</span>)</span>
+<span id="cb148-251"><a href="#cb148-251" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;  WAS MAN DARAUS MITNIMMT&quot;</span>)</span>
+<span id="cb148-252"><a href="#cb148-252" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;=&quot;</span> <span class="op">*</span> <span class="dv">80</span>)</span>
+<span id="cb148-253"><a href="#cb148-253" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;Ein Gewicht zu setzen heisst, die Entscheidung heimlich zu treffen -&quot;</span>)</span>
+<span id="cb148-254"><a href="#cb148-254" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;und dabei einen Teil der Moeglichkeiten gar nicht erst zu sehen.&quot;</span>)</span>
+<span id="cb148-255"><a href="#cb148-255" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>()</span>
+<span id="cb148-256"><a href="#cb148-256" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;Die Pareto-Front ist die ehrlichere Antwort: Sie legt dem Betrieb&quot;</span>)</span>
+<span id="cb148-257"><a href="#cb148-257" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;alle sinnvollen Kompromisse vor und ueberlaesst ihm die Wahl. Die&quot;</span>)</span>
+<span id="cb148-258"><a href="#cb148-258" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;Spalte &#39;EUR je kg&#39; macht sie entscheidbar - man vergleicht sie mit&quot;</span>)</span>
+<span id="cb148-259"><a href="#cb148-259" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;dem CO2-Preis, den das Unternehmen ohnehin ansetzt.&quot;</span>)</span>
+<span id="cb148-260"><a href="#cb148-260" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;=&quot;</span> <span class="op">*</span> <span class="dv">80</span>)</span></code></pre></div>
 <p><strong>Erwartete Ausgabe:</strong></p>
 <pre><code>================================================================================
   KOSTEN GEGEN CO2 - UND WARUM GEWICHTE NICHT GENUEGEN
@@ -19116,22 +19981,22 @@ e(x) \le \varepsilon
 <p><strong>🚀 In 5 Minuten gelöst: Der Durchschnitt ist die falsche Zahl</strong></p>
 <p>Eine Bäckerei kennt die Nachfrage der letzten 20 Tage. Ein Brot bringt 6 € Marge, ein übriges kostet 3 € Einkauf. Wie viele soll sie ansetzen?</p>
 <p>Die naheliegende Antwort — den Durchschnitt — ist nachweislich falsch:</p>
-<div class="sourceCode" id="cb148"><pre class="sourceCode python"><code class="sourceCode python"><span id="cb148-1"><a href="#cb148-1" aria-hidden="true" tabindex="-1"></a><span class="im">import</span> numpy <span class="im">as</span> np</span>
-<span id="cb148-2"><a href="#cb148-2" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb148-3"><a href="#cb148-3" aria-hidden="true" tabindex="-1"></a>nachfrage <span class="op">=</span> np.array([<span class="dv">104</span>, <span class="dv">138</span>, <span class="dv">96</span>, <span class="dv">151</span>, <span class="dv">118</span>, <span class="dv">127</span>, <span class="dv">143</span>, <span class="dv">109</span>, <span class="dv">162</span>, <span class="dv">121</span>,   <span class="co"># 20 Tage</span></span>
-<span id="cb148-4"><a href="#cb148-4" aria-hidden="true" tabindex="-1"></a>                      <span class="dv">133</span>, <span class="dv">115</span>, <span class="dv">148</span>, <span class="dv">102</span>, <span class="dv">129</span>, <span class="dv">156</span>, <span class="dv">111</span>, <span class="dv">140</span>, <span class="dv">124</span>, <span class="dv">135</span>])</span>
-<span id="cb148-5"><a href="#cb148-5" aria-hidden="true" tabindex="-1"></a>preis, einkauf <span class="op">=</span> <span class="fl">9.0</span>, <span class="fl">3.0</span></span>
-<span id="cb148-6"><a href="#cb148-6" aria-hidden="true" tabindex="-1"></a>fehl, ueber <span class="op">=</span> preis <span class="op">-</span> einkauf, einkauf          <span class="co"># 6 EUR zu wenig, 3 EUR zu viel</span></span>
-<span id="cb148-7"><a href="#cb148-7" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb148-8"><a href="#cb148-8" aria-hidden="true" tabindex="-1"></a>kosten <span class="op">=</span> <span class="kw">lambda</span> menge: (fehl <span class="op">*</span> np.maximum(<span class="dv">0</span>, nachfrage <span class="op">-</span> menge)</span>
-<span id="cb148-9"><a href="#cb148-9" aria-hidden="true" tabindex="-1"></a>                        <span class="op">+</span> ueber <span class="op">*</span> np.maximum(<span class="dv">0</span>, menge <span class="op">-</span> nachfrage)).mean()</span>
-<span id="cb148-10"><a href="#cb148-10" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb148-11"><a href="#cb148-11" aria-hidden="true" tabindex="-1"></a>erwartungswert <span class="op">=</span> <span class="bu">round</span>(nachfrage.mean())</span>
-<span id="cb148-12"><a href="#cb148-12" aria-hidden="true" tabindex="-1"></a>kritisch <span class="op">=</span> <span class="bu">round</span>(np.quantile(nachfrage, fehl <span class="op">/</span> (fehl <span class="op">+</span> ueber)))</span>
-<span id="cb148-13"><a href="#cb148-13" aria-hidden="true" tabindex="-1"></a><span class="bu">print</span>(<span class="ss">f&quot;Erwartungswert bestellen: </span><span class="sc">{</span>erwartungswert<span class="sc">}</span><span class="ss"> Stueck -&gt; </span><span class="sc">{</span>kosten(erwartungswert)<span class="sc">:5.2f}</span><span class="ss"> EUR/Tag&quot;</span>)</span>
-<span id="cb148-14"><a href="#cb148-14" aria-hidden="true" tabindex="-1"></a><span class="bu">print</span>(<span class="ss">f&quot;kritisches Quantil      : </span><span class="sc">{</span>kritisch<span class="sc">}</span><span class="ss"> Stueck -&gt; </span><span class="sc">{</span>kosten(kritisch)<span class="sc">:5.2f}</span><span class="ss"> EUR/Tag&quot;</span>)</span>
-<span id="cb148-15"><a href="#cb148-15" aria-hidden="true" tabindex="-1"></a><span class="bu">print</span>(<span class="ss">f&quot;bestmoegliche feste Menge: </span><span class="sc">{</span><span class="bu">int</span>(np.argmin([kosten(m) <span class="cf">for</span> m <span class="kw">in</span> <span class="bu">range</span>(<span class="dv">200</span>)]))<span class="sc">}</span><span class="ss"> Stueck&quot;</span></span>
-<span id="cb148-16"><a href="#cb148-16" aria-hidden="true" tabindex="-1"></a>      <span class="ss">f&quot; -&gt; </span><span class="sc">{</span><span class="bu">min</span>(kosten(m) <span class="cf">for</span> m <span class="kw">in</span> <span class="bu">range</span>(<span class="dv">200</span>))<span class="sc">:5.2f}</span><span class="ss"> EUR/Tag&quot;</span>)</span></code></pre></div>
+<div class="sourceCode" id="cb150"><pre class="sourceCode python"><code class="sourceCode python"><span id="cb150-1"><a href="#cb150-1" aria-hidden="true" tabindex="-1"></a><span class="im">import</span> numpy <span class="im">as</span> np</span>
+<span id="cb150-2"><a href="#cb150-2" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb150-3"><a href="#cb150-3" aria-hidden="true" tabindex="-1"></a>nachfrage <span class="op">=</span> np.array([<span class="dv">104</span>, <span class="dv">138</span>, <span class="dv">96</span>, <span class="dv">151</span>, <span class="dv">118</span>, <span class="dv">127</span>, <span class="dv">143</span>, <span class="dv">109</span>, <span class="dv">162</span>, <span class="dv">121</span>,   <span class="co"># 20 Tage</span></span>
+<span id="cb150-4"><a href="#cb150-4" aria-hidden="true" tabindex="-1"></a>                      <span class="dv">133</span>, <span class="dv">115</span>, <span class="dv">148</span>, <span class="dv">102</span>, <span class="dv">129</span>, <span class="dv">156</span>, <span class="dv">111</span>, <span class="dv">140</span>, <span class="dv">124</span>, <span class="dv">135</span>])</span>
+<span id="cb150-5"><a href="#cb150-5" aria-hidden="true" tabindex="-1"></a>preis, einkauf <span class="op">=</span> <span class="fl">9.0</span>, <span class="fl">3.0</span></span>
+<span id="cb150-6"><a href="#cb150-6" aria-hidden="true" tabindex="-1"></a>fehl, ueber <span class="op">=</span> preis <span class="op">-</span> einkauf, einkauf          <span class="co"># 6 EUR zu wenig, 3 EUR zu viel</span></span>
+<span id="cb150-7"><a href="#cb150-7" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb150-8"><a href="#cb150-8" aria-hidden="true" tabindex="-1"></a>kosten <span class="op">=</span> <span class="kw">lambda</span> menge: (fehl <span class="op">*</span> np.maximum(<span class="dv">0</span>, nachfrage <span class="op">-</span> menge)</span>
+<span id="cb150-9"><a href="#cb150-9" aria-hidden="true" tabindex="-1"></a>                        <span class="op">+</span> ueber <span class="op">*</span> np.maximum(<span class="dv">0</span>, menge <span class="op">-</span> nachfrage)).mean()</span>
+<span id="cb150-10"><a href="#cb150-10" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb150-11"><a href="#cb150-11" aria-hidden="true" tabindex="-1"></a>erwartungswert <span class="op">=</span> <span class="bu">round</span>(nachfrage.mean())</span>
+<span id="cb150-12"><a href="#cb150-12" aria-hidden="true" tabindex="-1"></a>kritisch <span class="op">=</span> <span class="bu">round</span>(np.quantile(nachfrage, fehl <span class="op">/</span> (fehl <span class="op">+</span> ueber)))</span>
+<span id="cb150-13"><a href="#cb150-13" aria-hidden="true" tabindex="-1"></a><span class="bu">print</span>(<span class="ss">f&quot;Erwartungswert bestellen: </span><span class="sc">{</span>erwartungswert<span class="sc">}</span><span class="ss"> Stueck -&gt; </span><span class="sc">{</span>kosten(erwartungswert)<span class="sc">:5.2f}</span><span class="ss"> EUR/Tag&quot;</span>)</span>
+<span id="cb150-14"><a href="#cb150-14" aria-hidden="true" tabindex="-1"></a><span class="bu">print</span>(<span class="ss">f&quot;kritisches Quantil      : </span><span class="sc">{</span>kritisch<span class="sc">}</span><span class="ss"> Stueck -&gt; </span><span class="sc">{</span>kosten(kritisch)<span class="sc">:5.2f}</span><span class="ss"> EUR/Tag&quot;</span>)</span>
+<span id="cb150-15"><a href="#cb150-15" aria-hidden="true" tabindex="-1"></a><span class="bu">print</span>(<span class="ss">f&quot;bestmoegliche feste Menge: </span><span class="sc">{</span><span class="bu">int</span>(np.argmin([kosten(m) <span class="cf">for</span> m <span class="kw">in</span> <span class="bu">range</span>(<span class="dv">200</span>)]))<span class="sc">}</span><span class="ss"> Stueck&quot;</span></span>
+<span id="cb150-16"><a href="#cb150-16" aria-hidden="true" tabindex="-1"></a>      <span class="ss">f&quot; -&gt; </span><span class="sc">{</span><span class="bu">min</span>(kosten(m) <span class="cf">for</span> m <span class="kw">in</span> <span class="bu">range</span>(<span class="dv">200</span>))<span class="sc">:5.2f}</span><span class="ss"> EUR/Tag&quot;</span>)</span></code></pre></div>
 <p><strong>Ausgabe:</strong></p>
 <pre><code>Erwartungswert bestellen: 128 Stueck -&gt; 69.45 EUR/Tag
 kritisches Quantil      : 137 Stueck -&gt; 62.25 EUR/Tag
@@ -19175,236 +20040,236 @@ bestmoegliche feste Menge: 138 Stueck -&gt; 62.10 EUR/Tag</code></pre>
 <h2 id="sec:prognose-programm">15.4 Das Programm</h2>
 <p>Dieselbe Bäckerei, aber mit Merkmalen: Wochentag, Temperatur, Aktionstage. Die Nachfrage muss jetzt <strong>modelliert</strong> werden.</p>
 <p>Eine Eigenschaft der Daten ist dabei entscheidend und in der Praxis der Normalfall: An Aktionstagen ist die Nachfrage nicht nur höher, sondern auch <strong>viel unsicherer</strong> (heteroskedastisch).</p>
-<div class="sourceCode" id="cb151"><pre class="sourceCode python"><code class="sourceCode python"><span id="cb151-1"><a href="#cb151-1" aria-hidden="true" tabindex="-1"></a><span class="co">#!/usr/bin/env python3</span></span>
-<span id="cb151-2"><a href="#cb151-2" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb151-3"><a href="#cb151-3" aria-hidden="true" tabindex="-1"></a><span class="co"># Predict_then_Optimize.py</span></span>
-<span id="cb151-4"><a href="#cb151-4" aria-hidden="true" tabindex="-1"></a><span class="co">&quot;&quot;&quot;</span></span>
-<span id="cb151-5"><a href="#cb151-5" aria-hidden="true" tabindex="-1"></a><span class="co">Kapitel Prognose: Die bessere Prognose trifft die schlechtere Entscheidung.</span></span>
-<span id="cb151-6"><a href="#cb151-6" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb151-7"><a href="#cb151-7" aria-hidden="true" tabindex="-1"></a><span class="co">Eine Baeckerei muss jeden Abend entscheiden, wie viel sie fuer den naechsten Tag</span></span>
-<span id="cb151-8"><a href="#cb151-8" aria-hidden="true" tabindex="-1"></a><span class="co">ansetzt. Zu wenig kostet die Marge des entgangenen Verkaufs, zu viel kostet den</span></span>
-<span id="cb151-9"><a href="#cb151-9" aria-hidden="true" tabindex="-1"></a><span class="co">Einkaufspreis der Retoure. Das ist das Newsvendor-Problem aus dem Kapitel</span></span>
-<span id="cb151-10"><a href="#cb151-10" aria-hidden="true" tabindex="-1"></a><span class="co">Unsicherheit - nur dass die Nachfrage diesmal nicht aus einer Verteilung kommt,</span></span>
-<span id="cb151-11"><a href="#cb151-11" aria-hidden="true" tabindex="-1"></a><span class="co">sondern PROGNOSTIZIERT werden muss: aus Wochentag, Temperatur und Aktionstagen.</span></span>
-<span id="cb151-12"><a href="#cb151-12" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb151-13"><a href="#cb151-13" aria-hidden="true" tabindex="-1"></a><span class="co">Damit zerfaellt die Aufgabe in zwei Schritte, und genau an der Naht entsteht der</span></span>
-<span id="cb151-14"><a href="#cb151-14" aria-hidden="true" tabindex="-1"></a><span class="co">Fehler, um den es hier geht:</span></span>
-<span id="cb151-15"><a href="#cb151-15" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb151-16"><a href="#cb151-16" aria-hidden="true" tabindex="-1"></a><span class="co">    PREDICT     ein Modell schaetzt die Nachfrage</span></span>
-<span id="cb151-17"><a href="#cb151-17" aria-hidden="true" tabindex="-1"></a><span class="co">    OPTIMIZE    daraus wird eine Bestellmenge</span></span>
-<span id="cb151-18"><a href="#cb151-18" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb151-19"><a href="#cb151-19" aria-hidden="true" tabindex="-1"></a><span class="co">Der Prognostiker optimiert seinen Modellfehler, meist den MSE. Der Planer traegt</span></span>
-<span id="cb151-20"><a href="#cb151-20" aria-hidden="true" tabindex="-1"></a><span class="co">die Kosten. Beide messen etwas anderes - und die beiden Masse widersprechen</span></span>
-<span id="cb151-21"><a href="#cb151-21" aria-hidden="true" tabindex="-1"></a><span class="co">einander. Das Programm zeigt:</span></span>
-<span id="cb151-22"><a href="#cb151-22" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb151-23"><a href="#cb151-23" aria-hidden="true" tabindex="-1"></a><span class="co">  1. Vier Verfahren, verglichen nach MSE UND nach Entscheidungskosten. Das</span></span>
-<span id="cb151-24"><a href="#cb151-24" aria-hidden="true" tabindex="-1"></a><span class="co">     Verfahren mit dem BESTEN MSE hat die HOECHSTEN Kosten.</span></span>
-<span id="cb151-25"><a href="#cb151-25" aria-hidden="true" tabindex="-1"></a><span class="co">  2. Warum ein pauschaler Sicherheitszuschlag zu kurz greift - die Streuung der</span></span>
-<span id="cb151-26"><a href="#cb151-26" aria-hidden="true" tabindex="-1"></a><span class="co">     Nachfrage haengt selbst von den Merkmalen ab.</span></span>
-<span id="cb151-27"><a href="#cb151-27" aria-hidden="true" tabindex="-1"></a><span class="co">  3. Eine Messfalle, in die der Autor dieses Programms zuerst selbst getappt</span></span>
-<span id="cb151-28"><a href="#cb151-28" aria-hidden="true" tabindex="-1"></a><span class="co">     ist: Bei kurzen Testzeitraeumen ist der MSE-Vergleich nicht stabil.</span></span>
-<span id="cb151-29"><a href="#cb151-29" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb151-30"><a href="#cb151-30" aria-hidden="true" tabindex="-1"></a><span class="co">Benoetigt: numpy, scipy, scikit-learn</span></span>
-<span id="cb151-31"><a href="#cb151-31" aria-hidden="true" tabindex="-1"></a><span class="co">&quot;&quot;&quot;</span></span>
-<span id="cb151-32"><a href="#cb151-32" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb151-33"><a href="#cb151-33" aria-hidden="true" tabindex="-1"></a><span class="im">from</span> __future__ <span class="im">import</span> annotations</span>
-<span id="cb151-34"><a href="#cb151-34" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb151-35"><a href="#cb151-35" aria-hidden="true" tabindex="-1"></a><span class="im">import</span> numpy <span class="im">as</span> np</span>
-<span id="cb151-36"><a href="#cb151-36" aria-hidden="true" tabindex="-1"></a><span class="im">from</span> scipy.stats <span class="im">import</span> norm</span>
-<span id="cb151-37"><a href="#cb151-37" aria-hidden="true" tabindex="-1"></a><span class="im">from</span> sklearn.linear_model <span class="im">import</span> LinearRegression, QuantileRegressor</span>
-<span id="cb151-38"><a href="#cb151-38" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb151-39"><a href="#cb151-39" aria-hidden="true" tabindex="-1"></a>VERKAUFSPREIS <span class="op">=</span> <span class="fl">9.0</span></span>
-<span id="cb151-40"><a href="#cb151-40" aria-hidden="true" tabindex="-1"></a>EINKAUFSPREIS <span class="op">=</span> <span class="fl">3.0</span></span>
-<span id="cb151-41"><a href="#cb151-41" aria-hidden="true" tabindex="-1"></a>KOSTEN_FEHLMENGE <span class="op">=</span> VERKAUFSPREIS <span class="op">-</span> EINKAUFSPREIS      <span class="co"># entgangene Marge: 6 EUR</span></span>
-<span id="cb151-42"><a href="#cb151-42" aria-hidden="true" tabindex="-1"></a>KOSTEN_UEBERHANG <span class="op">=</span> EINKAUFSPREIS                      <span class="co"># Retoure:           3 EUR</span></span>
-<span id="cb151-43"><a href="#cb151-43" aria-hidden="true" tabindex="-1"></a>KRITISCHES_VERHAELTNIS <span class="op">=</span> KOSTEN_FEHLMENGE <span class="op">/</span> (KOSTEN_FEHLMENGE <span class="op">+</span> KOSTEN_UEBERHANG)</span>
-<span id="cb151-44"><a href="#cb151-44" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb151-45"><a href="#cb151-45" aria-hidden="true" tabindex="-1"></a>TAGE <span class="op">=</span> <span class="dv">5000</span>               <span class="co"># Simulation, siehe Hinweis unten</span></span>
-<span id="cb151-46"><a href="#cb151-46" aria-hidden="true" tabindex="-1"></a>TRAINING <span class="op">=</span> <span class="dv">1000</span></span>
-<span id="cb151-47"><a href="#cb151-47" aria-hidden="true" tabindex="-1"></a>SAAT <span class="op">=</span> <span class="dv">11</span></span>
-<span id="cb151-48"><a href="#cb151-48" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb151-49"><a href="#cb151-49" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb151-50"><a href="#cb151-50" aria-hidden="true" tabindex="-1"></a><span class="kw">def</span> erzeuge_daten(tage: <span class="bu">int</span> <span class="op">=</span> TAGE, saat: <span class="bu">int</span> <span class="op">=</span> SAAT):</span>
-<span id="cb151-51"><a href="#cb151-51" aria-hidden="true" tabindex="-1"></a>    <span class="co">&quot;&quot;&quot;Taegliche Nachfrage mit Wochentag, Temperatur und Aktionstagen.</span></span>
-<span id="cb151-52"><a href="#cb151-52" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb151-53"><a href="#cb151-53" aria-hidden="true" tabindex="-1"></a><span class="co">    Die entscheidende Eigenschaft steckt in &#39;streuung&#39;: An Aktionstagen ist die</span></span>
-<span id="cb151-54"><a href="#cb151-54" aria-hidden="true" tabindex="-1"></a><span class="co">    Nachfrage nicht nur hoeher, sondern auch viel UNSICHERER. Solche</span></span>
-<span id="cb151-55"><a href="#cb151-55" aria-hidden="true" tabindex="-1"></a><span class="co">    heteroskedastischen Daten sind der Normalfall - und der Grund, warum ein</span></span>
-<span id="cb151-56"><a href="#cb151-56" aria-hidden="true" tabindex="-1"></a><span class="co">    pauschaler Sicherheitszuschlag nicht genuegt.</span></span>
-<span id="cb151-57"><a href="#cb151-57" aria-hidden="true" tabindex="-1"></a><span class="co">    &quot;&quot;&quot;</span></span>
-<span id="cb151-58"><a href="#cb151-58" aria-hidden="true" tabindex="-1"></a>    rng <span class="op">=</span> np.random.default_rng(saat)</span>
-<span id="cb151-59"><a href="#cb151-59" aria-hidden="true" tabindex="-1"></a>    wochentag <span class="op">=</span> np.arange(tage) <span class="op">%</span> <span class="dv">7</span></span>
-<span id="cb151-60"><a href="#cb151-60" aria-hidden="true" tabindex="-1"></a>    temperatur <span class="op">=</span> (<span class="dv">12</span> <span class="op">+</span> <span class="dv">10</span> <span class="op">*</span> np.sin(<span class="dv">2</span> <span class="op">*</span> np.pi <span class="op">*</span> np.arange(tage) <span class="op">/</span> <span class="dv">365</span>)</span>
-<span id="cb151-61"><a href="#cb151-61" aria-hidden="true" tabindex="-1"></a>                  <span class="op">+</span> rng.normal(<span class="dv">0</span>, <span class="dv">3</span>, tage))</span>
-<span id="cb151-62"><a href="#cb151-62" aria-hidden="true" tabindex="-1"></a>    aktion <span class="op">=</span> (rng.random(tage) <span class="op">&lt;</span> <span class="fl">0.15</span>).astype(<span class="bu">float</span>)</span>
-<span id="cb151-63"><a href="#cb151-63" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb151-64"><a href="#cb151-64" aria-hidden="true" tabindex="-1"></a>    merkmale <span class="op">=</span> np.column_stack([np.eye(<span class="dv">7</span>)[wochentag][:, <span class="dv">1</span>:], temperatur, aktion])</span>
-<span id="cb151-65"><a href="#cb151-65" aria-hidden="true" tabindex="-1"></a>    erwartung <span class="op">=</span> (<span class="dv">120</span></span>
-<span id="cb151-66"><a href="#cb151-66" aria-hidden="true" tabindex="-1"></a>                 <span class="op">+</span> np.eye(<span class="dv">7</span>)[wochentag] <span class="op">@</span> np.array([<span class="dv">0</span>, <span class="dv">10</span>, <span class="dv">12</span>, <span class="dv">14</span>, <span class="dv">18</span>, <span class="dv">35</span>, <span class="op">-</span><span class="dv">40</span>])</span>
-<span id="cb151-67"><a href="#cb151-67" aria-hidden="true" tabindex="-1"></a>                 <span class="op">+</span> <span class="fl">1.8</span> <span class="op">*</span> temperatur <span class="op">+</span> <span class="dv">45</span> <span class="op">*</span> aktion)</span>
-<span id="cb151-68"><a href="#cb151-68" aria-hidden="true" tabindex="-1"></a>    streuung <span class="op">=</span> <span class="dv">8</span> <span class="op">+</span> <span class="dv">22</span> <span class="op">*</span> aktion</span>
-<span id="cb151-69"><a href="#cb151-69" aria-hidden="true" tabindex="-1"></a>    nachfrage <span class="op">=</span> np.maximum(<span class="fl">0.0</span>, erwartung <span class="op">+</span> rng.normal(<span class="dv">0</span>, <span class="dv">1</span>, tage) <span class="op">*</span> streuung)</span>
-<span id="cb151-70"><a href="#cb151-70" aria-hidden="true" tabindex="-1"></a>    <span class="cf">return</span> merkmale, nachfrage, aktion</span>
-<span id="cb151-71"><a href="#cb151-71" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb151-72"><a href="#cb151-72" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb151-73"><a href="#cb151-73" aria-hidden="true" tabindex="-1"></a><span class="kw">def</span> tageskosten(bestellung: np.ndarray, nachfrage: np.ndarray) <span class="op">-&gt;</span> <span class="bu">float</span>:</span>
-<span id="cb151-74"><a href="#cb151-74" aria-hidden="true" tabindex="-1"></a>    <span class="co">&quot;&quot;&quot;Die Zahl, auf die es ankommt - und die kein Prognosemass kennt.&quot;&quot;&quot;</span></span>
-<span id="cb151-75"><a href="#cb151-75" aria-hidden="true" tabindex="-1"></a>    fehlmenge <span class="op">=</span> np.maximum(<span class="fl">0.0</span>, nachfrage <span class="op">-</span> bestellung)</span>
-<span id="cb151-76"><a href="#cb151-76" aria-hidden="true" tabindex="-1"></a>    ueberhang <span class="op">=</span> np.maximum(<span class="fl">0.0</span>, bestellung <span class="op">-</span> nachfrage)</span>
-<span id="cb151-77"><a href="#cb151-77" aria-hidden="true" tabindex="-1"></a>    <span class="cf">return</span> <span class="bu">float</span>((KOSTEN_FEHLMENGE <span class="op">*</span> fehlmenge</span>
-<span id="cb151-78"><a href="#cb151-78" aria-hidden="true" tabindex="-1"></a>                  <span class="op">+</span> KOSTEN_UEBERHANG <span class="op">*</span> ueberhang).mean())</span>
-<span id="cb151-79"><a href="#cb151-79" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb151-80"><a href="#cb151-80" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb151-81"><a href="#cb151-81" aria-hidden="true" tabindex="-1"></a><span class="cf">if</span> <span class="va">__name__</span> <span class="op">==</span> <span class="st">&quot;__main__&quot;</span>:</span>
-<span id="cb151-82"><a href="#cb151-82" aria-hidden="true" tabindex="-1"></a>    merkmale, nachfrage, aktion <span class="op">=</span> erzeuge_daten()</span>
-<span id="cb151-83"><a href="#cb151-83" aria-hidden="true" tabindex="-1"></a>    lernen <span class="op">=</span> <span class="bu">slice</span>(<span class="dv">0</span>, TRAINING)</span>
-<span id="cb151-84"><a href="#cb151-84" aria-hidden="true" tabindex="-1"></a>    pruefen <span class="op">=</span> <span class="bu">slice</span>(TRAINING, TAGE)</span>
-<span id="cb151-85"><a href="#cb151-85" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb151-86"><a href="#cb151-86" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;=&quot;</span> <span class="op">*</span> <span class="dv">84</span>)</span>
-<span id="cb151-87"><a href="#cb151-87" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;  DIE BESSERE PROGNOSE TRIFFT DIE SCHLECHTERE ENTSCHEIDUNG&quot;</span>)</span>
-<span id="cb151-88"><a href="#cb151-88" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;=&quot;</span> <span class="op">*</span> <span class="dv">84</span>)</span>
-<span id="cb151-89"><a href="#cb151-89" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;Verkaufspreis </span><span class="sc">{</span>VERKAUFSPREIS<span class="sc">:.0f}</span><span class="ss"> EUR, Einkauf </span><span class="sc">{</span>EINKAUFSPREIS<span class="sc">:.0f}</span><span class="ss"> EUR.&quot;</span>)</span>
-<span id="cb151-90"><a href="#cb151-90" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;Fehlmenge kostet </span><span class="sc">{</span>KOSTEN_FEHLMENGE<span class="sc">:.0f}</span><span class="ss"> EUR, Ueberhang &quot;</span></span>
-<span id="cb151-91"><a href="#cb151-91" aria-hidden="true" tabindex="-1"></a>          <span class="ss">f&quot;</span><span class="sc">{</span>KOSTEN_UEBERHANG<span class="sc">:.0f}</span><span class="ss"> EUR je Stueck.&quot;</span>)</span>
-<span id="cb151-92"><a href="#cb151-92" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;Kritisches Verhaeltnis: </span><span class="sc">{</span>KRITISCHES_VERHAELTNIS<span class="sc">:.3f}</span><span class="ss"> - der Planer sollte &quot;</span></span>
-<span id="cb151-93"><a href="#cb151-93" aria-hidden="true" tabindex="-1"></a>          <span class="ss">f&quot;also das&quot;</span>)</span>
-<span id="cb151-94"><a href="#cb151-94" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;</span><span class="sc">{</span>KRITISCHES_VERHAELTNIS<span class="sc">:.1%}</span><span class="ss">-Quantil der Nachfrage bestellen, nicht ihren &quot;</span></span>
-<span id="cb151-95"><a href="#cb151-95" aria-hidden="true" tabindex="-1"></a>          <span class="ss">f&quot;Erwartungswert.&quot;</span>)</span>
-<span id="cb151-96"><a href="#cb151-96" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;</span><span class="ch">\n</span><span class="ss">Training: Tag 1 bis </span><span class="sc">{</span>TRAINING<span class="sc">}</span><span class="ss">. Bewertung: die restlichen &quot;</span></span>
-<span id="cb151-97"><a href="#cb151-97" aria-hidden="true" tabindex="-1"></a>          <span class="ss">f&quot;</span><span class="sc">{</span>TAGE <span class="op">-</span> TRAINING<span class="sc">}</span><span class="ss"> Tage.</span><span class="ch">\n</span><span class="ss">&quot;</span>)</span>
-<span id="cb151-98"><a href="#cb151-98" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb151-99"><a href="#cb151-99" aria-hidden="true" tabindex="-1"></a>    <span class="co"># --- Die vier Verfahren ----------------------------------------------</span></span>
-<span id="cb151-100"><a href="#cb151-100" aria-hidden="true" tabindex="-1"></a>    kleinste_quadrate <span class="op">=</span> LinearRegression().fit(merkmale[lernen], nachfrage[lernen])</span>
-<span id="cb151-101"><a href="#cb151-101" aria-hidden="true" tabindex="-1"></a>    punktprognose <span class="op">=</span> kleinste_quadrate.predict(merkmale[pruefen])</span>
-<span id="cb151-102"><a href="#cb151-102" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb151-103"><a href="#cb151-103" aria-hidden="true" tabindex="-1"></a>    restfehler <span class="op">=</span> nachfrage[lernen] <span class="op">-</span> kleinste_quadrate.predict(merkmale[lernen])</span>
-<span id="cb151-104"><a href="#cb151-104" aria-hidden="true" tabindex="-1"></a>    pauschalzuschlag <span class="op">=</span> norm.ppf(KRITISCHES_VERHAELTNIS) <span class="op">*</span> restfehler.std()</span>
-<span id="cb151-105"><a href="#cb151-105" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb151-106"><a href="#cb151-106" aria-hidden="true" tabindex="-1"></a>    <span class="co"># Ein Zuschlag, der nicht aus der Normalverteilung kommt, sondern direkt</span></span>
-<span id="cb151-107"><a href="#cb151-107" aria-hidden="true" tabindex="-1"></a>    <span class="co"># auf den Trainingsdaten die Kosten minimiert.</span></span>
-<span id="cb151-108"><a href="#cb151-108" aria-hidden="true" tabindex="-1"></a>    kandidaten <span class="op">=</span> np.linspace(<span class="op">-</span><span class="fl">10.0</span>, <span class="fl">30.0</span>, <span class="dv">401</span>)</span>
-<span id="cb151-109"><a href="#cb151-109" aria-hidden="true" tabindex="-1"></a>    trainingsprognose <span class="op">=</span> kleinste_quadrate.predict(merkmale[lernen])</span>
-<span id="cb151-110"><a href="#cb151-110" aria-hidden="true" tabindex="-1"></a>    kostenzuschlag <span class="op">=</span> <span class="bu">float</span>(kandidaten[np.argmin(</span>
-<span id="cb151-111"><a href="#cb151-111" aria-hidden="true" tabindex="-1"></a>        [tageskosten(trainingsprognose <span class="op">+</span> z, nachfrage[lernen]) <span class="cf">for</span> z <span class="kw">in</span> kandidaten])])</span>
-<span id="cb151-112"><a href="#cb151-112" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb151-113"><a href="#cb151-113" aria-hidden="true" tabindex="-1"></a>    <span class="co"># Und das Verfahren, das von vornherein das richtige Quantil schaetzt.</span></span>
-<span id="cb151-114"><a href="#cb151-114" aria-hidden="true" tabindex="-1"></a>    quantilmodell <span class="op">=</span> QuantileRegressor(quantile<span class="op">=</span>KRITISCHES_VERHAELTNIS,</span>
-<span id="cb151-115"><a href="#cb151-115" aria-hidden="true" tabindex="-1"></a>                                      alpha<span class="op">=</span><span class="fl">0.0</span>, solver<span class="op">=</span><span class="st">&quot;highs&quot;</span>)</span>
-<span id="cb151-116"><a href="#cb151-116" aria-hidden="true" tabindex="-1"></a>    quantilmodell.fit(merkmale[lernen], nachfrage[lernen])</span>
-<span id="cb151-117"><a href="#cb151-117" aria-hidden="true" tabindex="-1"></a>    quantilprognose <span class="op">=</span> quantilmodell.predict(merkmale[pruefen])</span>
-<span id="cb151-118"><a href="#cb151-118" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb151-119"><a href="#cb151-119" aria-hidden="true" tabindex="-1"></a>    verfahren <span class="op">=</span> [</span>
-<span id="cb151-120"><a href="#cb151-120" aria-hidden="true" tabindex="-1"></a>        (<span class="st">&quot;bestelle die Punktprognose&quot;</span>, punktprognose, punktprognose),</span>
-<span id="cb151-121"><a href="#cb151-121" aria-hidden="true" tabindex="-1"></a>        (<span class="st">&quot;+ Zuschlag aus der Normalverteilung&quot;</span>,</span>
-<span id="cb151-122"><a href="#cb151-122" aria-hidden="true" tabindex="-1"></a>         punktprognose, punktprognose <span class="op">+</span> pauschalzuschlag),</span>
-<span id="cb151-123"><a href="#cb151-123" aria-hidden="true" tabindex="-1"></a>        (<span class="st">&quot;+ Zuschlag auf Kosten trainiert&quot;</span>,</span>
-<span id="cb151-124"><a href="#cb151-124" aria-hidden="true" tabindex="-1"></a>         punktprognose, punktprognose <span class="op">+</span> kostenzuschlag),</span>
-<span id="cb151-125"><a href="#cb151-125" aria-hidden="true" tabindex="-1"></a>        (<span class="st">&quot;Quantilregression aufs kritische Quantil&quot;</span>,</span>
-<span id="cb151-126"><a href="#cb151-126" aria-hidden="true" tabindex="-1"></a>         quantilprognose, quantilprognose),</span>
-<span id="cb151-127"><a href="#cb151-127" aria-hidden="true" tabindex="-1"></a>    ]</span>
-<span id="cb151-128"><a href="#cb151-128" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb151-129"><a href="#cb151-129" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;  </span><span class="sc">{</span><span class="st">&#39;Verfahren&#39;</span><span class="sc">:&lt;42}</span><span class="ss"> </span><span class="sc">{</span><span class="st">&#39;MSE&#39;</span><span class="sc">:&gt;9}</span><span class="ss"> </span><span class="sc">{</span><span class="st">&#39;Kosten/Tag&#39;</span><span class="sc">:&gt;12}</span><span class="ss"> </span><span class="sc">{</span><span class="st">&#39;gegen Zeile 1&#39;</span><span class="sc">:&gt;14}</span><span class="ss">&quot;</span>)</span>
-<span id="cb151-130"><a href="#cb151-130" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;  &quot;</span> <span class="op">+</span> <span class="st">&quot;-&quot;</span> <span class="op">*</span> <span class="dv">80</span>)</span>
-<span id="cb151-131"><a href="#cb151-131" aria-hidden="true" tabindex="-1"></a>    ergebnisse <span class="op">=</span> {}</span>
-<span id="cb151-132"><a href="#cb151-132" aria-hidden="true" tabindex="-1"></a>    <span class="cf">for</span> name, prognose, bestellung <span class="kw">in</span> verfahren:</span>
-<span id="cb151-133"><a href="#cb151-133" aria-hidden="true" tabindex="-1"></a>        mse <span class="op">=</span> <span class="bu">float</span>(((prognose <span class="op">-</span> nachfrage[pruefen]) <span class="op">**</span> <span class="dv">2</span>).mean())</span>
-<span id="cb151-134"><a href="#cb151-134" aria-hidden="true" tabindex="-1"></a>        kosten <span class="op">=</span> tageskosten(bestellung, nachfrage[pruefen])</span>
-<span id="cb151-135"><a href="#cb151-135" aria-hidden="true" tabindex="-1"></a>        ergebnisse[name] <span class="op">=</span> (mse, kosten)</span>
-<span id="cb151-136"><a href="#cb151-136" aria-hidden="true" tabindex="-1"></a>        basis <span class="op">=</span> ergebnisse[verfahren[<span class="dv">0</span>][<span class="dv">0</span>]][<span class="dv">1</span>]</span>
-<span id="cb151-137"><a href="#cb151-137" aria-hidden="true" tabindex="-1"></a>        vergleich <span class="op">=</span> <span class="st">&quot;&quot;</span> <span class="cf">if</span> name <span class="op">==</span> verfahren[<span class="dv">0</span>][<span class="dv">0</span>] <span class="cf">else</span> <span class="ss">f&quot;</span><span class="sc">{</span>(kosten <span class="op">-</span> basis) <span class="op">/</span> basis<span class="sc">:+13.1%}</span><span class="ss">&quot;</span></span>
-<span id="cb151-138"><a href="#cb151-138" aria-hidden="true" tabindex="-1"></a>        <span class="bu">print</span>(<span class="ss">f&quot;  </span><span class="sc">{</span>name<span class="sc">:&lt;42}</span><span class="ss"> </span><span class="sc">{</span>mse<span class="sc">:&gt;9.1f}</span><span class="ss"> </span><span class="sc">{</span>kosten<span class="sc">:&gt;10.2f}</span><span class="ss"> EUR </span><span class="sc">{</span>vergleich<span class="sc">:&gt;14}</span><span class="ss">&quot;</span>)</span>
-<span id="cb151-139"><a href="#cb151-139" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb151-140"><a href="#cb151-140" aria-hidden="true" tabindex="-1"></a>    bester_mse <span class="op">=</span> <span class="bu">min</span>(ergebnisse, key<span class="op">=</span><span class="kw">lambda</span> k: ergebnisse[k][<span class="dv">0</span>])</span>
-<span id="cb151-141"><a href="#cb151-141" aria-hidden="true" tabindex="-1"></a>    beste_kosten <span class="op">=</span> <span class="bu">min</span>(ergebnisse, key<span class="op">=</span><span class="kw">lambda</span> k: ergebnisse[k][<span class="dv">1</span>])</span>
-<span id="cb151-142"><a href="#cb151-142" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;</span><span class="ch">\n</span><span class="ss">  bester MSE:      </span><span class="sc">{</span>bester_mse<span class="sc">}</span><span class="ss">&quot;</span>)</span>
-<span id="cb151-143"><a href="#cb151-143" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;  beste Kosten:    </span><span class="sc">{</span>beste_kosten<span class="sc">}</span><span class="ss">&quot;</span>)</span>
-<span id="cb151-144"><a href="#cb151-144" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;</span><span class="ch">\n</span><span class="ss">  Das Verfahren mit dem besten MSE hat die HOECHSTEN Kosten, und das&quot;</span>)</span>
-<span id="cb151-145"><a href="#cb151-145" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;  Verfahren mit den besten Kosten hat einen um &quot;</span></span>
-<span id="cb151-146"><a href="#cb151-146" aria-hidden="true" tabindex="-1"></a>          <span class="ss">f&quot;</span><span class="sc">{</span>(ergebnisse[beste_kosten][<span class="dv">0</span>] <span class="op">/</span> ergebnisse[bester_mse][<span class="dv">0</span>] <span class="op">-</span> <span class="dv">1</span>)<span class="sc">:.0%}</span><span class="ss"> SCHLECHTEREN MSE.&quot;</span>)</span>
-<span id="cb151-147"><a href="#cb151-147" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;  Wer Prognosemodelle nach MSE auswaehlt, waehlt hier das falsche.&quot;</span>)</span>
-<span id="cb151-148"><a href="#cb151-148" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb151-149"><a href="#cb151-149" aria-hidden="true" tabindex="-1"></a>    <span class="co"># --- Warum der pauschale Zuschlag zu kurz greift ---------------------</span></span>
-<span id="cb151-150"><a href="#cb151-150" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;</span><span class="ch">\n</span><span class="st">&quot;</span> <span class="op">+</span> <span class="st">&quot;-&quot;</span> <span class="op">*</span> <span class="dv">84</span>)</span>
-<span id="cb151-151"><a href="#cb151-151" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;Warum ein pauschaler Zuschlag nicht genuegt</span><span class="ch">\n</span><span class="st">&quot;</span>)</span>
-<span id="cb151-152"><a href="#cb151-152" aria-hidden="true" tabindex="-1"></a>    ist_aktion <span class="op">=</span> aktion[pruefen] <span class="op">&gt;</span> <span class="fl">0.5</span></span>
-<span id="cb151-153"><a href="#cb151-153" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;  </span><span class="sc">{</span><span class="st">&#39;Verfahren&#39;</span><span class="sc">:&lt;42}</span><span class="ss"> </span><span class="sc">{</span><span class="st">&#39;normale Tage&#39;</span><span class="sc">:&gt;14}</span><span class="ss"> </span><span class="sc">{</span><span class="st">&#39;Aktionstage&#39;</span><span class="sc">:&gt;14}</span><span class="ss">&quot;</span>)</span>
-<span id="cb151-154"><a href="#cb151-154" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;  &quot;</span> <span class="op">+</span> <span class="st">&quot;-&quot;</span> <span class="op">*</span> <span class="dv">74</span>)</span>
-<span id="cb151-155"><a href="#cb151-155" aria-hidden="true" tabindex="-1"></a>    <span class="cf">for</span> name, _, bestellung <span class="kw">in</span> verfahren:</span>
-<span id="cb151-156"><a href="#cb151-156" aria-hidden="true" tabindex="-1"></a>        normal <span class="op">=</span> tageskosten(bestellung[<span class="op">~</span>ist_aktion], nachfrage[pruefen][<span class="op">~</span>ist_aktion])</span>
-<span id="cb151-157"><a href="#cb151-157" aria-hidden="true" tabindex="-1"></a>        aktionstag <span class="op">=</span> tageskosten(bestellung[ist_aktion], nachfrage[pruefen][ist_aktion])</span>
-<span id="cb151-158"><a href="#cb151-158" aria-hidden="true" tabindex="-1"></a>        <span class="bu">print</span>(<span class="ss">f&quot;  </span><span class="sc">{</span>name<span class="sc">:&lt;42}</span><span class="ss"> </span><span class="sc">{</span>normal<span class="sc">:&gt;10.2f}</span><span class="ss"> EUR </span><span class="sc">{</span>aktionstag<span class="sc">:&gt;10.2f}</span><span class="ss"> EUR&quot;</span>)</span>
-<span id="cb151-159"><a href="#cb151-159" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb151-160"><a href="#cb151-160" aria-hidden="true" tabindex="-1"></a>    <span class="co"># Nachgerechnet statt behauptet: Welcher Zuschlag waere je Tagesart richtig?</span></span>
-<span id="cb151-161"><a href="#cb151-161" aria-hidden="true" tabindex="-1"></a>    aktion_training <span class="op">=</span> aktion[lernen] <span class="op">&gt;</span> <span class="fl">0.5</span></span>
-<span id="cb151-162"><a href="#cb151-162" aria-hidden="true" tabindex="-1"></a>    z <span class="op">=</span> norm.ppf(KRITISCHES_VERHAELTNIS)</span>
-<span id="cb151-163"><a href="#cb151-163" aria-hidden="true" tabindex="-1"></a>    richtig_normal <span class="op">=</span> z <span class="op">*</span> restfehler[<span class="op">~</span>aktion_training].std()</span>
-<span id="cb151-164"><a href="#cb151-164" aria-hidden="true" tabindex="-1"></a>    richtig_aktion <span class="op">=</span> z <span class="op">*</span> restfehler[aktion_training].std()</span>
-<span id="cb151-165"><a href="#cb151-165" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;</span><span class="ch">\n</span><span class="ss">  Der pauschale Zuschlag betraegt </span><span class="sc">{</span>pauschalzuschlag<span class="sc">:.1f}</span><span class="ss"> Stueck. Aus den&quot;</span>)</span>
-<span id="cb151-166"><a href="#cb151-166" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;  Trainingsresten getrennt nach Tagesart waere richtig:&quot;</span>)</span>
-<span id="cb151-167"><a href="#cb151-167" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;    normale Tage : </span><span class="sc">{</span>richtig_normal<span class="sc">:5.1f}</span><span class="ss"> Stueck&quot;</span>)</span>
-<span id="cb151-168"><a href="#cb151-168" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;    Aktionstage  : </span><span class="sc">{</span>richtig_aktion<span class="sc">:5.1f}</span><span class="ss"> Stueck&quot;</span>)</span>
-<span id="cb151-169"><a href="#cb151-169" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;  Ein Zuschlag fuer alle Tage kann nur einen Mittelweg treffen - hier&quot;</span>)</span>
-<span id="cb151-170"><a href="#cb151-170" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;  ist er an normalen Tagen </span><span class="sc">{</span>pauschalzuschlag <span class="op">/</span> richtig_normal<span class="sc">:.1f}</span><span class="ss">-mal zu gross und an&quot;</span>)</span>
-<span id="cb151-171"><a href="#cb151-171" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;  Aktionstagen nur </span><span class="sc">{</span>pauschalzuschlag <span class="op">/</span> richtig_aktion<span class="sc">:.0%}</span><span class="ss"> dessen, was noetig waere.&quot;</span>)</span>
-<span id="cb151-172"><a href="#cb151-172" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;</span><span class="ch">\n</span><span class="ss">  Die Quantilregression schaetzt das </span><span class="sc">{</span>KRITISCHES_VERHAELTNIS<span class="sc">:.1%}</span><span class="ss">-Quantil &quot;</span></span>
-<span id="cb151-173"><a href="#cb151-173" aria-hidden="true" tabindex="-1"></a>          <span class="ss">f&quot;direkt aus den&quot;</span>)</span>
-<span id="cb151-174"><a href="#cb151-174" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;  Merkmalen und darf deshalb an verschiedenen Tagen verschieden weit&quot;</span>)</span>
-<span id="cb151-175"><a href="#cb151-175" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;  ueber dem Erwartungswert liegen. Genau das ist der Unterschied&quot;</span>)</span>
-<span id="cb151-176"><a href="#cb151-176" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;  zwischen &#39;ein Modell und danach eine Formel&#39; und &#39;ein Modell, das&quot;</span>)</span>
-<span id="cb151-177"><a href="#cb151-177" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;  weiss, wofuer es gebraucht wird&#39;.&quot;</span>)</span>
-<span id="cb151-178"><a href="#cb151-178" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb151-179"><a href="#cb151-179" aria-hidden="true" tabindex="-1"></a>    <span class="co"># --- Die Messfalle ---------------------------------------------------</span></span>
-<span id="cb151-180"><a href="#cb151-180" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;</span><span class="ch">\n</span><span class="st">&quot;</span> <span class="op">+</span> <span class="st">&quot;-&quot;</span> <span class="op">*</span> <span class="dv">84</span>)</span>
-<span id="cb151-181"><a href="#cb151-181" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;Eine Messfalle, in die der Autor zuerst selbst getappt ist</span><span class="ch">\n</span><span class="st">&quot;</span>)</span>
-<span id="cb151-182"><a href="#cb151-182" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;  Der erste Entwurf dieses Programms bewertete auf 230 Testtagen - ein&quot;</span>)</span>
-<span id="cb151-183"><a href="#cb151-183" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;  realistischer Zeitraum. Dort hatte die Quantilregression den BESSEREN&quot;</span>)</span>
-<span id="cb151-184"><a href="#cb151-184" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;  MSE, und die ganze Aussage des Kapitels stand auf dem Kopf.&quot;</span>)</span>
-<span id="cb151-185"><a href="#cb151-185" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;</span><span class="ch">\n</span><span class="st">  Wie oft das passiert, laesst sich ausmessen:</span><span class="ch">\n</span><span class="st">&quot;</span>)</span>
-<span id="cb151-186"><a href="#cb151-186" aria-hidden="true" tabindex="-1"></a>    rng <span class="op">=</span> np.random.default_rng(<span class="dv">0</span>)</span>
-<span id="cb151-187"><a href="#cb151-187" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;  </span><span class="sc">{</span><span class="st">&#39;Testfenster&#39;</span><span class="sc">:&gt;14}</span><span class="ss"> </span><span class="sc">{</span><span class="st">&#39;QR sieht MSE-besser aus&#39;</span><span class="sc">:&gt;26}</span><span class="ss">&quot;</span>)</span>
-<span id="cb151-188"><a href="#cb151-188" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;  &quot;</span> <span class="op">+</span> <span class="st">&quot;-&quot;</span> <span class="op">*</span> <span class="dv">42</span>)</span>
-<span id="cb151-189"><a href="#cb151-189" aria-hidden="true" tabindex="-1"></a>    <span class="cf">for</span> fenster <span class="kw">in</span> (<span class="dv">180</span>, <span class="dv">365</span>, <span class="dv">730</span>, <span class="dv">2000</span>):</span>
-<span id="cb151-190"><a href="#cb151-190" aria-hidden="true" tabindex="-1"></a>        treffer <span class="op">=</span> <span class="dv">0</span></span>
-<span id="cb151-191"><a href="#cb151-191" aria-hidden="true" tabindex="-1"></a>        versuche <span class="op">=</span> <span class="dv">400</span></span>
-<span id="cb151-192"><a href="#cb151-192" aria-hidden="true" tabindex="-1"></a>        <span class="cf">for</span> _ <span class="kw">in</span> <span class="bu">range</span>(versuche):</span>
-<span id="cb151-193"><a href="#cb151-193" aria-hidden="true" tabindex="-1"></a>            start <span class="op">=</span> <span class="bu">int</span>(rng.integers(TRAINING, TAGE <span class="op">-</span> fenster))</span>
-<span id="cb151-194"><a href="#cb151-194" aria-hidden="true" tabindex="-1"></a>            ausschnitt <span class="op">=</span> <span class="bu">slice</span>(start, start <span class="op">+</span> fenster)</span>
-<span id="cb151-195"><a href="#cb151-195" aria-hidden="true" tabindex="-1"></a>            mse_punkt <span class="op">=</span> ((kleinste_quadrate.predict(merkmale[ausschnitt])</span>
-<span id="cb151-196"><a href="#cb151-196" aria-hidden="true" tabindex="-1"></a>                          <span class="op">-</span> nachfrage[ausschnitt]) <span class="op">**</span> <span class="dv">2</span>).mean()</span>
-<span id="cb151-197"><a href="#cb151-197" aria-hidden="true" tabindex="-1"></a>            mse_quantil <span class="op">=</span> ((quantilmodell.predict(merkmale[ausschnitt])</span>
-<span id="cb151-198"><a href="#cb151-198" aria-hidden="true" tabindex="-1"></a>                            <span class="op">-</span> nachfrage[ausschnitt]) <span class="op">**</span> <span class="dv">2</span>).mean()</span>
-<span id="cb151-199"><a href="#cb151-199" aria-hidden="true" tabindex="-1"></a>            treffer <span class="op">+=</span> mse_quantil <span class="op">&lt;</span> mse_punkt</span>
-<span id="cb151-200"><a href="#cb151-200" aria-hidden="true" tabindex="-1"></a>        <span class="bu">print</span>(<span class="ss">f&quot;  </span><span class="sc">{</span>fenster<span class="sc">:&gt;10}</span><span class="ss"> Tage </span><span class="sc">{</span>treffer <span class="op">/</span> versuche<span class="sc">:&gt;24.1%}</span><span class="ss">&quot;</span>)</span>
-<span id="cb151-201"><a href="#cb151-201" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb151-202"><a href="#cb151-202" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;</span><span class="ch">\n</span><span class="st">  Bei einem halben Jahr Testdaten sieht das schlechtere Modell in gut&quot;</span>)</span>
-<span id="cb151-203"><a href="#cb151-203" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;  jedem zehnten Fall besser aus. Das ist keine grosse Zahl - aber wer&quot;</span>)</span>
-<span id="cb151-204"><a href="#cb151-204" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;  EINMAL misst, hat genau eine Ziehung aus dieser Verteilung.&quot;</span>)</span>
-<span id="cb151-205"><a href="#cb151-205" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;</span><span class="ch">\n</span><span class="st">  Die Lehre ist nicht &#39;nimm 4.000 Testtage&#39; - die hat niemand. Sie&quot;</span>)</span>
-<span id="cb151-206"><a href="#cb151-206" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;  lautet: Ein Kennzahlenvergleich ohne Angabe seiner Streuung ist keine&quot;</span>)</span>
-<span id="cb151-207"><a href="#cb151-207" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;  Aussage. Bei kurzen Zeitraeumen gehoert eine Kreuzvalidierung dazu.&quot;</span>)</span>
-<span id="cb151-208"><a href="#cb151-208" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb151-209"><a href="#cb151-209" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;</span><span class="ch">\n</span><span class="st">&quot;</span> <span class="op">+</span> <span class="st">&quot;=&quot;</span> <span class="op">*</span> <span class="dv">84</span>)</span>
-<span id="cb151-210"><a href="#cb151-210" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;  WAS MAN DARAUS MITNIMMT&quot;</span>)</span>
-<span id="cb151-211"><a href="#cb151-211" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;=&quot;</span> <span class="op">*</span> <span class="dv">84</span>)</span>
-<span id="cb151-212"><a href="#cb151-212" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;Der Prognostiker optimiert den MSE, der Planer traegt die Kosten - und&quot;</span>)</span>
-<span id="cb151-213"><a href="#cb151-213" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;die beiden Masse zeigen hier in verschiedene Richtungen. Drei Saetze:&quot;</span>)</span>
-<span id="cb151-214"><a href="#cb151-214" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>()</span>
-<span id="cb151-215"><a href="#cb151-215" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;  1. Sagen Sie nicht den Erwartungswert vorher, sondern die Groesse, die&quot;</span>)</span>
-<span id="cb151-216"><a href="#cb151-216" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;     in die Entscheidung eingeht. Beim Newsvendor ist das das kritische&quot;</span>)</span>
-<span id="cb151-217"><a href="#cb151-217" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;     Quantil - und das kann man direkt schaetzen.&quot;</span>)</span>
-<span id="cb151-218"><a href="#cb151-218" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;  2. Bewerten Sie Prognosemodelle an den ENTSCHEIDUNGSKOSTEN. Die sind&quot;</span>)</span>
-<span id="cb151-219"><a href="#cb151-219" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;     in Euro und damit vergleichbar; ein MSE ist es nicht.&quot;</span>)</span>
-<span id="cb151-220"><a href="#cb151-220" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;  3. Ein pauschaler Sicherheitszuschlag ist besser als nichts und&quot;</span>)</span>
-<span id="cb151-221"><a href="#cb151-221" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;     schlechter als ein Modell, das die Unsicherheit selbst aus den&quot;</span>)</span>
-<span id="cb151-222"><a href="#cb151-222" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;     Merkmalen liest.&quot;</span>)</span>
-<span id="cb151-223"><a href="#cb151-223" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>()</span>
-<span id="cb151-224"><a href="#cb151-224" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;Der naechste Schritt - Prognosemodelle so zu trainieren, dass sie die&quot;</span>)</span>
-<span id="cb151-225"><a href="#cb151-225" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;Entscheidungskosten direkt minimieren (Smart Predict-then-Optimize,&quot;</span>)</span>
-<span id="cb151-226"><a href="#cb151-226" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;differenzierbare Optimierungsschichten) - ist Forschungsstand und&quot;</span>)</span>
-<span id="cb151-227"><a href="#cb151-227" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;erfordert Bibliotheken wie cvxpylayers. Die dritte Zeile der Tabelle&quot;</span>)</span>
-<span id="cb151-228"><a href="#cb151-228" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;oben ist seine einfachste denkbare Form: ein einziger Parameter, auf&quot;</span>)</span>
-<span id="cb151-229"><a href="#cb151-229" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;Kosten statt auf Fehler trainiert.&quot;</span>)</span>
-<span id="cb151-230"><a href="#cb151-230" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;=&quot;</span> <span class="op">*</span> <span class="dv">84</span>)</span></code></pre></div>
+<div class="sourceCode" id="cb153"><pre class="sourceCode python"><code class="sourceCode python"><span id="cb153-1"><a href="#cb153-1" aria-hidden="true" tabindex="-1"></a><span class="co">#!/usr/bin/env python3</span></span>
+<span id="cb153-2"><a href="#cb153-2" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb153-3"><a href="#cb153-3" aria-hidden="true" tabindex="-1"></a><span class="co"># Predict_then_Optimize.py</span></span>
+<span id="cb153-4"><a href="#cb153-4" aria-hidden="true" tabindex="-1"></a><span class="co">&quot;&quot;&quot;</span></span>
+<span id="cb153-5"><a href="#cb153-5" aria-hidden="true" tabindex="-1"></a><span class="co">Kapitel Prognose: Die bessere Prognose trifft die schlechtere Entscheidung.</span></span>
+<span id="cb153-6"><a href="#cb153-6" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb153-7"><a href="#cb153-7" aria-hidden="true" tabindex="-1"></a><span class="co">Eine Baeckerei muss jeden Abend entscheiden, wie viel sie fuer den naechsten Tag</span></span>
+<span id="cb153-8"><a href="#cb153-8" aria-hidden="true" tabindex="-1"></a><span class="co">ansetzt. Zu wenig kostet die Marge des entgangenen Verkaufs, zu viel kostet den</span></span>
+<span id="cb153-9"><a href="#cb153-9" aria-hidden="true" tabindex="-1"></a><span class="co">Einkaufspreis der Retoure. Das ist das Newsvendor-Problem aus dem Kapitel</span></span>
+<span id="cb153-10"><a href="#cb153-10" aria-hidden="true" tabindex="-1"></a><span class="co">Unsicherheit - nur dass die Nachfrage diesmal nicht aus einer Verteilung kommt,</span></span>
+<span id="cb153-11"><a href="#cb153-11" aria-hidden="true" tabindex="-1"></a><span class="co">sondern PROGNOSTIZIERT werden muss: aus Wochentag, Temperatur und Aktionstagen.</span></span>
+<span id="cb153-12"><a href="#cb153-12" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb153-13"><a href="#cb153-13" aria-hidden="true" tabindex="-1"></a><span class="co">Damit zerfaellt die Aufgabe in zwei Schritte, und genau an der Naht entsteht der</span></span>
+<span id="cb153-14"><a href="#cb153-14" aria-hidden="true" tabindex="-1"></a><span class="co">Fehler, um den es hier geht:</span></span>
+<span id="cb153-15"><a href="#cb153-15" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb153-16"><a href="#cb153-16" aria-hidden="true" tabindex="-1"></a><span class="co">    PREDICT     ein Modell schaetzt die Nachfrage</span></span>
+<span id="cb153-17"><a href="#cb153-17" aria-hidden="true" tabindex="-1"></a><span class="co">    OPTIMIZE    daraus wird eine Bestellmenge</span></span>
+<span id="cb153-18"><a href="#cb153-18" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb153-19"><a href="#cb153-19" aria-hidden="true" tabindex="-1"></a><span class="co">Der Prognostiker optimiert seinen Modellfehler, meist den MSE. Der Planer traegt</span></span>
+<span id="cb153-20"><a href="#cb153-20" aria-hidden="true" tabindex="-1"></a><span class="co">die Kosten. Beide messen etwas anderes - und die beiden Masse widersprechen</span></span>
+<span id="cb153-21"><a href="#cb153-21" aria-hidden="true" tabindex="-1"></a><span class="co">einander. Das Programm zeigt:</span></span>
+<span id="cb153-22"><a href="#cb153-22" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb153-23"><a href="#cb153-23" aria-hidden="true" tabindex="-1"></a><span class="co">  1. Vier Verfahren, verglichen nach MSE UND nach Entscheidungskosten. Das</span></span>
+<span id="cb153-24"><a href="#cb153-24" aria-hidden="true" tabindex="-1"></a><span class="co">     Verfahren mit dem BESTEN MSE hat die HOECHSTEN Kosten.</span></span>
+<span id="cb153-25"><a href="#cb153-25" aria-hidden="true" tabindex="-1"></a><span class="co">  2. Warum ein pauschaler Sicherheitszuschlag zu kurz greift - die Streuung der</span></span>
+<span id="cb153-26"><a href="#cb153-26" aria-hidden="true" tabindex="-1"></a><span class="co">     Nachfrage haengt selbst von den Merkmalen ab.</span></span>
+<span id="cb153-27"><a href="#cb153-27" aria-hidden="true" tabindex="-1"></a><span class="co">  3. Eine Messfalle, in die der Autor dieses Programms zuerst selbst getappt</span></span>
+<span id="cb153-28"><a href="#cb153-28" aria-hidden="true" tabindex="-1"></a><span class="co">     ist: Bei kurzen Testzeitraeumen ist der MSE-Vergleich nicht stabil.</span></span>
+<span id="cb153-29"><a href="#cb153-29" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb153-30"><a href="#cb153-30" aria-hidden="true" tabindex="-1"></a><span class="co">Benoetigt: numpy, scipy, scikit-learn</span></span>
+<span id="cb153-31"><a href="#cb153-31" aria-hidden="true" tabindex="-1"></a><span class="co">&quot;&quot;&quot;</span></span>
+<span id="cb153-32"><a href="#cb153-32" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb153-33"><a href="#cb153-33" aria-hidden="true" tabindex="-1"></a><span class="im">from</span> __future__ <span class="im">import</span> annotations</span>
+<span id="cb153-34"><a href="#cb153-34" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb153-35"><a href="#cb153-35" aria-hidden="true" tabindex="-1"></a><span class="im">import</span> numpy <span class="im">as</span> np</span>
+<span id="cb153-36"><a href="#cb153-36" aria-hidden="true" tabindex="-1"></a><span class="im">from</span> scipy.stats <span class="im">import</span> norm</span>
+<span id="cb153-37"><a href="#cb153-37" aria-hidden="true" tabindex="-1"></a><span class="im">from</span> sklearn.linear_model <span class="im">import</span> LinearRegression, QuantileRegressor</span>
+<span id="cb153-38"><a href="#cb153-38" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb153-39"><a href="#cb153-39" aria-hidden="true" tabindex="-1"></a>VERKAUFSPREIS <span class="op">=</span> <span class="fl">9.0</span></span>
+<span id="cb153-40"><a href="#cb153-40" aria-hidden="true" tabindex="-1"></a>EINKAUFSPREIS <span class="op">=</span> <span class="fl">3.0</span></span>
+<span id="cb153-41"><a href="#cb153-41" aria-hidden="true" tabindex="-1"></a>KOSTEN_FEHLMENGE <span class="op">=</span> VERKAUFSPREIS <span class="op">-</span> EINKAUFSPREIS      <span class="co"># entgangene Marge: 6 EUR</span></span>
+<span id="cb153-42"><a href="#cb153-42" aria-hidden="true" tabindex="-1"></a>KOSTEN_UEBERHANG <span class="op">=</span> EINKAUFSPREIS                      <span class="co"># Retoure:           3 EUR</span></span>
+<span id="cb153-43"><a href="#cb153-43" aria-hidden="true" tabindex="-1"></a>KRITISCHES_VERHAELTNIS <span class="op">=</span> KOSTEN_FEHLMENGE <span class="op">/</span> (KOSTEN_FEHLMENGE <span class="op">+</span> KOSTEN_UEBERHANG)</span>
+<span id="cb153-44"><a href="#cb153-44" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb153-45"><a href="#cb153-45" aria-hidden="true" tabindex="-1"></a>TAGE <span class="op">=</span> <span class="dv">5000</span>               <span class="co"># Simulation, siehe Hinweis unten</span></span>
+<span id="cb153-46"><a href="#cb153-46" aria-hidden="true" tabindex="-1"></a>TRAINING <span class="op">=</span> <span class="dv">1000</span></span>
+<span id="cb153-47"><a href="#cb153-47" aria-hidden="true" tabindex="-1"></a>SAAT <span class="op">=</span> <span class="dv">11</span></span>
+<span id="cb153-48"><a href="#cb153-48" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb153-49"><a href="#cb153-49" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb153-50"><a href="#cb153-50" aria-hidden="true" tabindex="-1"></a><span class="kw">def</span> erzeuge_daten(tage: <span class="bu">int</span> <span class="op">=</span> TAGE, saat: <span class="bu">int</span> <span class="op">=</span> SAAT):</span>
+<span id="cb153-51"><a href="#cb153-51" aria-hidden="true" tabindex="-1"></a>    <span class="co">&quot;&quot;&quot;Taegliche Nachfrage mit Wochentag, Temperatur und Aktionstagen.</span></span>
+<span id="cb153-52"><a href="#cb153-52" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb153-53"><a href="#cb153-53" aria-hidden="true" tabindex="-1"></a><span class="co">    Die entscheidende Eigenschaft steckt in &#39;streuung&#39;: An Aktionstagen ist die</span></span>
+<span id="cb153-54"><a href="#cb153-54" aria-hidden="true" tabindex="-1"></a><span class="co">    Nachfrage nicht nur hoeher, sondern auch viel UNSICHERER. Solche</span></span>
+<span id="cb153-55"><a href="#cb153-55" aria-hidden="true" tabindex="-1"></a><span class="co">    heteroskedastischen Daten sind der Normalfall - und der Grund, warum ein</span></span>
+<span id="cb153-56"><a href="#cb153-56" aria-hidden="true" tabindex="-1"></a><span class="co">    pauschaler Sicherheitszuschlag nicht genuegt.</span></span>
+<span id="cb153-57"><a href="#cb153-57" aria-hidden="true" tabindex="-1"></a><span class="co">    &quot;&quot;&quot;</span></span>
+<span id="cb153-58"><a href="#cb153-58" aria-hidden="true" tabindex="-1"></a>    rng <span class="op">=</span> np.random.default_rng(saat)</span>
+<span id="cb153-59"><a href="#cb153-59" aria-hidden="true" tabindex="-1"></a>    wochentag <span class="op">=</span> np.arange(tage) <span class="op">%</span> <span class="dv">7</span></span>
+<span id="cb153-60"><a href="#cb153-60" aria-hidden="true" tabindex="-1"></a>    temperatur <span class="op">=</span> (<span class="dv">12</span> <span class="op">+</span> <span class="dv">10</span> <span class="op">*</span> np.sin(<span class="dv">2</span> <span class="op">*</span> np.pi <span class="op">*</span> np.arange(tage) <span class="op">/</span> <span class="dv">365</span>)</span>
+<span id="cb153-61"><a href="#cb153-61" aria-hidden="true" tabindex="-1"></a>                  <span class="op">+</span> rng.normal(<span class="dv">0</span>, <span class="dv">3</span>, tage))</span>
+<span id="cb153-62"><a href="#cb153-62" aria-hidden="true" tabindex="-1"></a>    aktion <span class="op">=</span> (rng.random(tage) <span class="op">&lt;</span> <span class="fl">0.15</span>).astype(<span class="bu">float</span>)</span>
+<span id="cb153-63"><a href="#cb153-63" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb153-64"><a href="#cb153-64" aria-hidden="true" tabindex="-1"></a>    merkmale <span class="op">=</span> np.column_stack([np.eye(<span class="dv">7</span>)[wochentag][:, <span class="dv">1</span>:], temperatur, aktion])</span>
+<span id="cb153-65"><a href="#cb153-65" aria-hidden="true" tabindex="-1"></a>    erwartung <span class="op">=</span> (<span class="dv">120</span></span>
+<span id="cb153-66"><a href="#cb153-66" aria-hidden="true" tabindex="-1"></a>                 <span class="op">+</span> np.eye(<span class="dv">7</span>)[wochentag] <span class="op">@</span> np.array([<span class="dv">0</span>, <span class="dv">10</span>, <span class="dv">12</span>, <span class="dv">14</span>, <span class="dv">18</span>, <span class="dv">35</span>, <span class="op">-</span><span class="dv">40</span>])</span>
+<span id="cb153-67"><a href="#cb153-67" aria-hidden="true" tabindex="-1"></a>                 <span class="op">+</span> <span class="fl">1.8</span> <span class="op">*</span> temperatur <span class="op">+</span> <span class="dv">45</span> <span class="op">*</span> aktion)</span>
+<span id="cb153-68"><a href="#cb153-68" aria-hidden="true" tabindex="-1"></a>    streuung <span class="op">=</span> <span class="dv">8</span> <span class="op">+</span> <span class="dv">22</span> <span class="op">*</span> aktion</span>
+<span id="cb153-69"><a href="#cb153-69" aria-hidden="true" tabindex="-1"></a>    nachfrage <span class="op">=</span> np.maximum(<span class="fl">0.0</span>, erwartung <span class="op">+</span> rng.normal(<span class="dv">0</span>, <span class="dv">1</span>, tage) <span class="op">*</span> streuung)</span>
+<span id="cb153-70"><a href="#cb153-70" aria-hidden="true" tabindex="-1"></a>    <span class="cf">return</span> merkmale, nachfrage, aktion</span>
+<span id="cb153-71"><a href="#cb153-71" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb153-72"><a href="#cb153-72" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb153-73"><a href="#cb153-73" aria-hidden="true" tabindex="-1"></a><span class="kw">def</span> tageskosten(bestellung: np.ndarray, nachfrage: np.ndarray) <span class="op">-&gt;</span> <span class="bu">float</span>:</span>
+<span id="cb153-74"><a href="#cb153-74" aria-hidden="true" tabindex="-1"></a>    <span class="co">&quot;&quot;&quot;Die Zahl, auf die es ankommt - und die kein Prognosemass kennt.&quot;&quot;&quot;</span></span>
+<span id="cb153-75"><a href="#cb153-75" aria-hidden="true" tabindex="-1"></a>    fehlmenge <span class="op">=</span> np.maximum(<span class="fl">0.0</span>, nachfrage <span class="op">-</span> bestellung)</span>
+<span id="cb153-76"><a href="#cb153-76" aria-hidden="true" tabindex="-1"></a>    ueberhang <span class="op">=</span> np.maximum(<span class="fl">0.0</span>, bestellung <span class="op">-</span> nachfrage)</span>
+<span id="cb153-77"><a href="#cb153-77" aria-hidden="true" tabindex="-1"></a>    <span class="cf">return</span> <span class="bu">float</span>((KOSTEN_FEHLMENGE <span class="op">*</span> fehlmenge</span>
+<span id="cb153-78"><a href="#cb153-78" aria-hidden="true" tabindex="-1"></a>                  <span class="op">+</span> KOSTEN_UEBERHANG <span class="op">*</span> ueberhang).mean())</span>
+<span id="cb153-79"><a href="#cb153-79" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb153-80"><a href="#cb153-80" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb153-81"><a href="#cb153-81" aria-hidden="true" tabindex="-1"></a><span class="cf">if</span> <span class="va">__name__</span> <span class="op">==</span> <span class="st">&quot;__main__&quot;</span>:</span>
+<span id="cb153-82"><a href="#cb153-82" aria-hidden="true" tabindex="-1"></a>    merkmale, nachfrage, aktion <span class="op">=</span> erzeuge_daten()</span>
+<span id="cb153-83"><a href="#cb153-83" aria-hidden="true" tabindex="-1"></a>    lernen <span class="op">=</span> <span class="bu">slice</span>(<span class="dv">0</span>, TRAINING)</span>
+<span id="cb153-84"><a href="#cb153-84" aria-hidden="true" tabindex="-1"></a>    pruefen <span class="op">=</span> <span class="bu">slice</span>(TRAINING, TAGE)</span>
+<span id="cb153-85"><a href="#cb153-85" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb153-86"><a href="#cb153-86" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;=&quot;</span> <span class="op">*</span> <span class="dv">84</span>)</span>
+<span id="cb153-87"><a href="#cb153-87" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;  DIE BESSERE PROGNOSE TRIFFT DIE SCHLECHTERE ENTSCHEIDUNG&quot;</span>)</span>
+<span id="cb153-88"><a href="#cb153-88" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;=&quot;</span> <span class="op">*</span> <span class="dv">84</span>)</span>
+<span id="cb153-89"><a href="#cb153-89" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;Verkaufspreis </span><span class="sc">{</span>VERKAUFSPREIS<span class="sc">:.0f}</span><span class="ss"> EUR, Einkauf </span><span class="sc">{</span>EINKAUFSPREIS<span class="sc">:.0f}</span><span class="ss"> EUR.&quot;</span>)</span>
+<span id="cb153-90"><a href="#cb153-90" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;Fehlmenge kostet </span><span class="sc">{</span>KOSTEN_FEHLMENGE<span class="sc">:.0f}</span><span class="ss"> EUR, Ueberhang &quot;</span></span>
+<span id="cb153-91"><a href="#cb153-91" aria-hidden="true" tabindex="-1"></a>          <span class="ss">f&quot;</span><span class="sc">{</span>KOSTEN_UEBERHANG<span class="sc">:.0f}</span><span class="ss"> EUR je Stueck.&quot;</span>)</span>
+<span id="cb153-92"><a href="#cb153-92" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;Kritisches Verhaeltnis: </span><span class="sc">{</span>KRITISCHES_VERHAELTNIS<span class="sc">:.3f}</span><span class="ss"> - der Planer sollte &quot;</span></span>
+<span id="cb153-93"><a href="#cb153-93" aria-hidden="true" tabindex="-1"></a>          <span class="ss">f&quot;also das&quot;</span>)</span>
+<span id="cb153-94"><a href="#cb153-94" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;</span><span class="sc">{</span>KRITISCHES_VERHAELTNIS<span class="sc">:.1%}</span><span class="ss">-Quantil der Nachfrage bestellen, nicht ihren &quot;</span></span>
+<span id="cb153-95"><a href="#cb153-95" aria-hidden="true" tabindex="-1"></a>          <span class="ss">f&quot;Erwartungswert.&quot;</span>)</span>
+<span id="cb153-96"><a href="#cb153-96" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;</span><span class="ch">\n</span><span class="ss">Training: Tag 1 bis </span><span class="sc">{</span>TRAINING<span class="sc">}</span><span class="ss">. Bewertung: die restlichen &quot;</span></span>
+<span id="cb153-97"><a href="#cb153-97" aria-hidden="true" tabindex="-1"></a>          <span class="ss">f&quot;</span><span class="sc">{</span>TAGE <span class="op">-</span> TRAINING<span class="sc">}</span><span class="ss"> Tage.</span><span class="ch">\n</span><span class="ss">&quot;</span>)</span>
+<span id="cb153-98"><a href="#cb153-98" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb153-99"><a href="#cb153-99" aria-hidden="true" tabindex="-1"></a>    <span class="co"># --- Die vier Verfahren ----------------------------------------------</span></span>
+<span id="cb153-100"><a href="#cb153-100" aria-hidden="true" tabindex="-1"></a>    kleinste_quadrate <span class="op">=</span> LinearRegression().fit(merkmale[lernen], nachfrage[lernen])</span>
+<span id="cb153-101"><a href="#cb153-101" aria-hidden="true" tabindex="-1"></a>    punktprognose <span class="op">=</span> kleinste_quadrate.predict(merkmale[pruefen])</span>
+<span id="cb153-102"><a href="#cb153-102" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb153-103"><a href="#cb153-103" aria-hidden="true" tabindex="-1"></a>    restfehler <span class="op">=</span> nachfrage[lernen] <span class="op">-</span> kleinste_quadrate.predict(merkmale[lernen])</span>
+<span id="cb153-104"><a href="#cb153-104" aria-hidden="true" tabindex="-1"></a>    pauschalzuschlag <span class="op">=</span> norm.ppf(KRITISCHES_VERHAELTNIS) <span class="op">*</span> restfehler.std()</span>
+<span id="cb153-105"><a href="#cb153-105" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb153-106"><a href="#cb153-106" aria-hidden="true" tabindex="-1"></a>    <span class="co"># Ein Zuschlag, der nicht aus der Normalverteilung kommt, sondern direkt</span></span>
+<span id="cb153-107"><a href="#cb153-107" aria-hidden="true" tabindex="-1"></a>    <span class="co"># auf den Trainingsdaten die Kosten minimiert.</span></span>
+<span id="cb153-108"><a href="#cb153-108" aria-hidden="true" tabindex="-1"></a>    kandidaten <span class="op">=</span> np.linspace(<span class="op">-</span><span class="fl">10.0</span>, <span class="fl">30.0</span>, <span class="dv">401</span>)</span>
+<span id="cb153-109"><a href="#cb153-109" aria-hidden="true" tabindex="-1"></a>    trainingsprognose <span class="op">=</span> kleinste_quadrate.predict(merkmale[lernen])</span>
+<span id="cb153-110"><a href="#cb153-110" aria-hidden="true" tabindex="-1"></a>    kostenzuschlag <span class="op">=</span> <span class="bu">float</span>(kandidaten[np.argmin(</span>
+<span id="cb153-111"><a href="#cb153-111" aria-hidden="true" tabindex="-1"></a>        [tageskosten(trainingsprognose <span class="op">+</span> z, nachfrage[lernen]) <span class="cf">for</span> z <span class="kw">in</span> kandidaten])])</span>
+<span id="cb153-112"><a href="#cb153-112" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb153-113"><a href="#cb153-113" aria-hidden="true" tabindex="-1"></a>    <span class="co"># Und das Verfahren, das von vornherein das richtige Quantil schaetzt.</span></span>
+<span id="cb153-114"><a href="#cb153-114" aria-hidden="true" tabindex="-1"></a>    quantilmodell <span class="op">=</span> QuantileRegressor(quantile<span class="op">=</span>KRITISCHES_VERHAELTNIS,</span>
+<span id="cb153-115"><a href="#cb153-115" aria-hidden="true" tabindex="-1"></a>                                      alpha<span class="op">=</span><span class="fl">0.0</span>, solver<span class="op">=</span><span class="st">&quot;highs&quot;</span>)</span>
+<span id="cb153-116"><a href="#cb153-116" aria-hidden="true" tabindex="-1"></a>    quantilmodell.fit(merkmale[lernen], nachfrage[lernen])</span>
+<span id="cb153-117"><a href="#cb153-117" aria-hidden="true" tabindex="-1"></a>    quantilprognose <span class="op">=</span> quantilmodell.predict(merkmale[pruefen])</span>
+<span id="cb153-118"><a href="#cb153-118" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb153-119"><a href="#cb153-119" aria-hidden="true" tabindex="-1"></a>    verfahren <span class="op">=</span> [</span>
+<span id="cb153-120"><a href="#cb153-120" aria-hidden="true" tabindex="-1"></a>        (<span class="st">&quot;bestelle die Punktprognose&quot;</span>, punktprognose, punktprognose),</span>
+<span id="cb153-121"><a href="#cb153-121" aria-hidden="true" tabindex="-1"></a>        (<span class="st">&quot;+ Zuschlag aus der Normalverteilung&quot;</span>,</span>
+<span id="cb153-122"><a href="#cb153-122" aria-hidden="true" tabindex="-1"></a>         punktprognose, punktprognose <span class="op">+</span> pauschalzuschlag),</span>
+<span id="cb153-123"><a href="#cb153-123" aria-hidden="true" tabindex="-1"></a>        (<span class="st">&quot;+ Zuschlag auf Kosten trainiert&quot;</span>,</span>
+<span id="cb153-124"><a href="#cb153-124" aria-hidden="true" tabindex="-1"></a>         punktprognose, punktprognose <span class="op">+</span> kostenzuschlag),</span>
+<span id="cb153-125"><a href="#cb153-125" aria-hidden="true" tabindex="-1"></a>        (<span class="st">&quot;Quantilregression aufs kritische Quantil&quot;</span>,</span>
+<span id="cb153-126"><a href="#cb153-126" aria-hidden="true" tabindex="-1"></a>         quantilprognose, quantilprognose),</span>
+<span id="cb153-127"><a href="#cb153-127" aria-hidden="true" tabindex="-1"></a>    ]</span>
+<span id="cb153-128"><a href="#cb153-128" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb153-129"><a href="#cb153-129" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;  </span><span class="sc">{</span><span class="st">&#39;Verfahren&#39;</span><span class="sc">:&lt;42}</span><span class="ss"> </span><span class="sc">{</span><span class="st">&#39;MSE&#39;</span><span class="sc">:&gt;9}</span><span class="ss"> </span><span class="sc">{</span><span class="st">&#39;Kosten/Tag&#39;</span><span class="sc">:&gt;12}</span><span class="ss"> </span><span class="sc">{</span><span class="st">&#39;gegen Zeile 1&#39;</span><span class="sc">:&gt;14}</span><span class="ss">&quot;</span>)</span>
+<span id="cb153-130"><a href="#cb153-130" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;  &quot;</span> <span class="op">+</span> <span class="st">&quot;-&quot;</span> <span class="op">*</span> <span class="dv">80</span>)</span>
+<span id="cb153-131"><a href="#cb153-131" aria-hidden="true" tabindex="-1"></a>    ergebnisse <span class="op">=</span> {}</span>
+<span id="cb153-132"><a href="#cb153-132" aria-hidden="true" tabindex="-1"></a>    <span class="cf">for</span> name, prognose, bestellung <span class="kw">in</span> verfahren:</span>
+<span id="cb153-133"><a href="#cb153-133" aria-hidden="true" tabindex="-1"></a>        mse <span class="op">=</span> <span class="bu">float</span>(((prognose <span class="op">-</span> nachfrage[pruefen]) <span class="op">**</span> <span class="dv">2</span>).mean())</span>
+<span id="cb153-134"><a href="#cb153-134" aria-hidden="true" tabindex="-1"></a>        kosten <span class="op">=</span> tageskosten(bestellung, nachfrage[pruefen])</span>
+<span id="cb153-135"><a href="#cb153-135" aria-hidden="true" tabindex="-1"></a>        ergebnisse[name] <span class="op">=</span> (mse, kosten)</span>
+<span id="cb153-136"><a href="#cb153-136" aria-hidden="true" tabindex="-1"></a>        basis <span class="op">=</span> ergebnisse[verfahren[<span class="dv">0</span>][<span class="dv">0</span>]][<span class="dv">1</span>]</span>
+<span id="cb153-137"><a href="#cb153-137" aria-hidden="true" tabindex="-1"></a>        vergleich <span class="op">=</span> <span class="st">&quot;&quot;</span> <span class="cf">if</span> name <span class="op">==</span> verfahren[<span class="dv">0</span>][<span class="dv">0</span>] <span class="cf">else</span> <span class="ss">f&quot;</span><span class="sc">{</span>(kosten <span class="op">-</span> basis) <span class="op">/</span> basis<span class="sc">:+13.1%}</span><span class="ss">&quot;</span></span>
+<span id="cb153-138"><a href="#cb153-138" aria-hidden="true" tabindex="-1"></a>        <span class="bu">print</span>(<span class="ss">f&quot;  </span><span class="sc">{</span>name<span class="sc">:&lt;42}</span><span class="ss"> </span><span class="sc">{</span>mse<span class="sc">:&gt;9.1f}</span><span class="ss"> </span><span class="sc">{</span>kosten<span class="sc">:&gt;10.2f}</span><span class="ss"> EUR </span><span class="sc">{</span>vergleich<span class="sc">:&gt;14}</span><span class="ss">&quot;</span>)</span>
+<span id="cb153-139"><a href="#cb153-139" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb153-140"><a href="#cb153-140" aria-hidden="true" tabindex="-1"></a>    bester_mse <span class="op">=</span> <span class="bu">min</span>(ergebnisse, key<span class="op">=</span><span class="kw">lambda</span> k: ergebnisse[k][<span class="dv">0</span>])</span>
+<span id="cb153-141"><a href="#cb153-141" aria-hidden="true" tabindex="-1"></a>    beste_kosten <span class="op">=</span> <span class="bu">min</span>(ergebnisse, key<span class="op">=</span><span class="kw">lambda</span> k: ergebnisse[k][<span class="dv">1</span>])</span>
+<span id="cb153-142"><a href="#cb153-142" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;</span><span class="ch">\n</span><span class="ss">  bester MSE:      </span><span class="sc">{</span>bester_mse<span class="sc">}</span><span class="ss">&quot;</span>)</span>
+<span id="cb153-143"><a href="#cb153-143" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;  beste Kosten:    </span><span class="sc">{</span>beste_kosten<span class="sc">}</span><span class="ss">&quot;</span>)</span>
+<span id="cb153-144"><a href="#cb153-144" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;</span><span class="ch">\n</span><span class="ss">  Das Verfahren mit dem besten MSE hat die HOECHSTEN Kosten, und das&quot;</span>)</span>
+<span id="cb153-145"><a href="#cb153-145" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;  Verfahren mit den besten Kosten hat einen um &quot;</span></span>
+<span id="cb153-146"><a href="#cb153-146" aria-hidden="true" tabindex="-1"></a>          <span class="ss">f&quot;</span><span class="sc">{</span>(ergebnisse[beste_kosten][<span class="dv">0</span>] <span class="op">/</span> ergebnisse[bester_mse][<span class="dv">0</span>] <span class="op">-</span> <span class="dv">1</span>)<span class="sc">:.0%}</span><span class="ss"> SCHLECHTEREN MSE.&quot;</span>)</span>
+<span id="cb153-147"><a href="#cb153-147" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;  Wer Prognosemodelle nach MSE auswaehlt, waehlt hier das falsche.&quot;</span>)</span>
+<span id="cb153-148"><a href="#cb153-148" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb153-149"><a href="#cb153-149" aria-hidden="true" tabindex="-1"></a>    <span class="co"># --- Warum der pauschale Zuschlag zu kurz greift ---------------------</span></span>
+<span id="cb153-150"><a href="#cb153-150" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;</span><span class="ch">\n</span><span class="st">&quot;</span> <span class="op">+</span> <span class="st">&quot;-&quot;</span> <span class="op">*</span> <span class="dv">84</span>)</span>
+<span id="cb153-151"><a href="#cb153-151" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;Warum ein pauschaler Zuschlag nicht genuegt</span><span class="ch">\n</span><span class="st">&quot;</span>)</span>
+<span id="cb153-152"><a href="#cb153-152" aria-hidden="true" tabindex="-1"></a>    ist_aktion <span class="op">=</span> aktion[pruefen] <span class="op">&gt;</span> <span class="fl">0.5</span></span>
+<span id="cb153-153"><a href="#cb153-153" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;  </span><span class="sc">{</span><span class="st">&#39;Verfahren&#39;</span><span class="sc">:&lt;42}</span><span class="ss"> </span><span class="sc">{</span><span class="st">&#39;normale Tage&#39;</span><span class="sc">:&gt;14}</span><span class="ss"> </span><span class="sc">{</span><span class="st">&#39;Aktionstage&#39;</span><span class="sc">:&gt;14}</span><span class="ss">&quot;</span>)</span>
+<span id="cb153-154"><a href="#cb153-154" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;  &quot;</span> <span class="op">+</span> <span class="st">&quot;-&quot;</span> <span class="op">*</span> <span class="dv">74</span>)</span>
+<span id="cb153-155"><a href="#cb153-155" aria-hidden="true" tabindex="-1"></a>    <span class="cf">for</span> name, _, bestellung <span class="kw">in</span> verfahren:</span>
+<span id="cb153-156"><a href="#cb153-156" aria-hidden="true" tabindex="-1"></a>        normal <span class="op">=</span> tageskosten(bestellung[<span class="op">~</span>ist_aktion], nachfrage[pruefen][<span class="op">~</span>ist_aktion])</span>
+<span id="cb153-157"><a href="#cb153-157" aria-hidden="true" tabindex="-1"></a>        aktionstag <span class="op">=</span> tageskosten(bestellung[ist_aktion], nachfrage[pruefen][ist_aktion])</span>
+<span id="cb153-158"><a href="#cb153-158" aria-hidden="true" tabindex="-1"></a>        <span class="bu">print</span>(<span class="ss">f&quot;  </span><span class="sc">{</span>name<span class="sc">:&lt;42}</span><span class="ss"> </span><span class="sc">{</span>normal<span class="sc">:&gt;10.2f}</span><span class="ss"> EUR </span><span class="sc">{</span>aktionstag<span class="sc">:&gt;10.2f}</span><span class="ss"> EUR&quot;</span>)</span>
+<span id="cb153-159"><a href="#cb153-159" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb153-160"><a href="#cb153-160" aria-hidden="true" tabindex="-1"></a>    <span class="co"># Nachgerechnet statt behauptet: Welcher Zuschlag waere je Tagesart richtig?</span></span>
+<span id="cb153-161"><a href="#cb153-161" aria-hidden="true" tabindex="-1"></a>    aktion_training <span class="op">=</span> aktion[lernen] <span class="op">&gt;</span> <span class="fl">0.5</span></span>
+<span id="cb153-162"><a href="#cb153-162" aria-hidden="true" tabindex="-1"></a>    z <span class="op">=</span> norm.ppf(KRITISCHES_VERHAELTNIS)</span>
+<span id="cb153-163"><a href="#cb153-163" aria-hidden="true" tabindex="-1"></a>    richtig_normal <span class="op">=</span> z <span class="op">*</span> restfehler[<span class="op">~</span>aktion_training].std()</span>
+<span id="cb153-164"><a href="#cb153-164" aria-hidden="true" tabindex="-1"></a>    richtig_aktion <span class="op">=</span> z <span class="op">*</span> restfehler[aktion_training].std()</span>
+<span id="cb153-165"><a href="#cb153-165" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;</span><span class="ch">\n</span><span class="ss">  Der pauschale Zuschlag betraegt </span><span class="sc">{</span>pauschalzuschlag<span class="sc">:.1f}</span><span class="ss"> Stueck. Aus den&quot;</span>)</span>
+<span id="cb153-166"><a href="#cb153-166" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;  Trainingsresten getrennt nach Tagesart waere richtig:&quot;</span>)</span>
+<span id="cb153-167"><a href="#cb153-167" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;    normale Tage : </span><span class="sc">{</span>richtig_normal<span class="sc">:5.1f}</span><span class="ss"> Stueck&quot;</span>)</span>
+<span id="cb153-168"><a href="#cb153-168" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;    Aktionstage  : </span><span class="sc">{</span>richtig_aktion<span class="sc">:5.1f}</span><span class="ss"> Stueck&quot;</span>)</span>
+<span id="cb153-169"><a href="#cb153-169" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;  Ein Zuschlag fuer alle Tage kann nur einen Mittelweg treffen - hier&quot;</span>)</span>
+<span id="cb153-170"><a href="#cb153-170" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;  ist er an normalen Tagen </span><span class="sc">{</span>pauschalzuschlag <span class="op">/</span> richtig_normal<span class="sc">:.1f}</span><span class="ss">-mal zu gross und an&quot;</span>)</span>
+<span id="cb153-171"><a href="#cb153-171" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;  Aktionstagen nur </span><span class="sc">{</span>pauschalzuschlag <span class="op">/</span> richtig_aktion<span class="sc">:.0%}</span><span class="ss"> dessen, was noetig waere.&quot;</span>)</span>
+<span id="cb153-172"><a href="#cb153-172" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;</span><span class="ch">\n</span><span class="ss">  Die Quantilregression schaetzt das </span><span class="sc">{</span>KRITISCHES_VERHAELTNIS<span class="sc">:.1%}</span><span class="ss">-Quantil &quot;</span></span>
+<span id="cb153-173"><a href="#cb153-173" aria-hidden="true" tabindex="-1"></a>          <span class="ss">f&quot;direkt aus den&quot;</span>)</span>
+<span id="cb153-174"><a href="#cb153-174" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;  Merkmalen und darf deshalb an verschiedenen Tagen verschieden weit&quot;</span>)</span>
+<span id="cb153-175"><a href="#cb153-175" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;  ueber dem Erwartungswert liegen. Genau das ist der Unterschied&quot;</span>)</span>
+<span id="cb153-176"><a href="#cb153-176" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;  zwischen &#39;ein Modell und danach eine Formel&#39; und &#39;ein Modell, das&quot;</span>)</span>
+<span id="cb153-177"><a href="#cb153-177" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;  weiss, wofuer es gebraucht wird&#39;.&quot;</span>)</span>
+<span id="cb153-178"><a href="#cb153-178" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb153-179"><a href="#cb153-179" aria-hidden="true" tabindex="-1"></a>    <span class="co"># --- Die Messfalle ---------------------------------------------------</span></span>
+<span id="cb153-180"><a href="#cb153-180" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;</span><span class="ch">\n</span><span class="st">&quot;</span> <span class="op">+</span> <span class="st">&quot;-&quot;</span> <span class="op">*</span> <span class="dv">84</span>)</span>
+<span id="cb153-181"><a href="#cb153-181" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;Eine Messfalle, in die der Autor zuerst selbst getappt ist</span><span class="ch">\n</span><span class="st">&quot;</span>)</span>
+<span id="cb153-182"><a href="#cb153-182" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;  Der erste Entwurf dieses Programms bewertete auf 230 Testtagen - ein&quot;</span>)</span>
+<span id="cb153-183"><a href="#cb153-183" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;  realistischer Zeitraum. Dort hatte die Quantilregression den BESSEREN&quot;</span>)</span>
+<span id="cb153-184"><a href="#cb153-184" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;  MSE, und die ganze Aussage des Kapitels stand auf dem Kopf.&quot;</span>)</span>
+<span id="cb153-185"><a href="#cb153-185" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;</span><span class="ch">\n</span><span class="st">  Wie oft das passiert, laesst sich ausmessen:</span><span class="ch">\n</span><span class="st">&quot;</span>)</span>
+<span id="cb153-186"><a href="#cb153-186" aria-hidden="true" tabindex="-1"></a>    rng <span class="op">=</span> np.random.default_rng(<span class="dv">0</span>)</span>
+<span id="cb153-187"><a href="#cb153-187" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;  </span><span class="sc">{</span><span class="st">&#39;Testfenster&#39;</span><span class="sc">:&gt;14}</span><span class="ss"> </span><span class="sc">{</span><span class="st">&#39;QR sieht MSE-besser aus&#39;</span><span class="sc">:&gt;26}</span><span class="ss">&quot;</span>)</span>
+<span id="cb153-188"><a href="#cb153-188" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;  &quot;</span> <span class="op">+</span> <span class="st">&quot;-&quot;</span> <span class="op">*</span> <span class="dv">42</span>)</span>
+<span id="cb153-189"><a href="#cb153-189" aria-hidden="true" tabindex="-1"></a>    <span class="cf">for</span> fenster <span class="kw">in</span> (<span class="dv">180</span>, <span class="dv">365</span>, <span class="dv">730</span>, <span class="dv">2000</span>):</span>
+<span id="cb153-190"><a href="#cb153-190" aria-hidden="true" tabindex="-1"></a>        treffer <span class="op">=</span> <span class="dv">0</span></span>
+<span id="cb153-191"><a href="#cb153-191" aria-hidden="true" tabindex="-1"></a>        versuche <span class="op">=</span> <span class="dv">400</span></span>
+<span id="cb153-192"><a href="#cb153-192" aria-hidden="true" tabindex="-1"></a>        <span class="cf">for</span> _ <span class="kw">in</span> <span class="bu">range</span>(versuche):</span>
+<span id="cb153-193"><a href="#cb153-193" aria-hidden="true" tabindex="-1"></a>            start <span class="op">=</span> <span class="bu">int</span>(rng.integers(TRAINING, TAGE <span class="op">-</span> fenster))</span>
+<span id="cb153-194"><a href="#cb153-194" aria-hidden="true" tabindex="-1"></a>            ausschnitt <span class="op">=</span> <span class="bu">slice</span>(start, start <span class="op">+</span> fenster)</span>
+<span id="cb153-195"><a href="#cb153-195" aria-hidden="true" tabindex="-1"></a>            mse_punkt <span class="op">=</span> ((kleinste_quadrate.predict(merkmale[ausschnitt])</span>
+<span id="cb153-196"><a href="#cb153-196" aria-hidden="true" tabindex="-1"></a>                          <span class="op">-</span> nachfrage[ausschnitt]) <span class="op">**</span> <span class="dv">2</span>).mean()</span>
+<span id="cb153-197"><a href="#cb153-197" aria-hidden="true" tabindex="-1"></a>            mse_quantil <span class="op">=</span> ((quantilmodell.predict(merkmale[ausschnitt])</span>
+<span id="cb153-198"><a href="#cb153-198" aria-hidden="true" tabindex="-1"></a>                            <span class="op">-</span> nachfrage[ausschnitt]) <span class="op">**</span> <span class="dv">2</span>).mean()</span>
+<span id="cb153-199"><a href="#cb153-199" aria-hidden="true" tabindex="-1"></a>            treffer <span class="op">+=</span> mse_quantil <span class="op">&lt;</span> mse_punkt</span>
+<span id="cb153-200"><a href="#cb153-200" aria-hidden="true" tabindex="-1"></a>        <span class="bu">print</span>(<span class="ss">f&quot;  </span><span class="sc">{</span>fenster<span class="sc">:&gt;10}</span><span class="ss"> Tage </span><span class="sc">{</span>treffer <span class="op">/</span> versuche<span class="sc">:&gt;24.1%}</span><span class="ss">&quot;</span>)</span>
+<span id="cb153-201"><a href="#cb153-201" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb153-202"><a href="#cb153-202" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;</span><span class="ch">\n</span><span class="st">  Bei einem halben Jahr Testdaten sieht das schlechtere Modell in gut&quot;</span>)</span>
+<span id="cb153-203"><a href="#cb153-203" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;  jedem zehnten Fall besser aus. Das ist keine grosse Zahl - aber wer&quot;</span>)</span>
+<span id="cb153-204"><a href="#cb153-204" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;  EINMAL misst, hat genau eine Ziehung aus dieser Verteilung.&quot;</span>)</span>
+<span id="cb153-205"><a href="#cb153-205" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;</span><span class="ch">\n</span><span class="st">  Die Lehre ist nicht &#39;nimm 4.000 Testtage&#39; - die hat niemand. Sie&quot;</span>)</span>
+<span id="cb153-206"><a href="#cb153-206" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;  lautet: Ein Kennzahlenvergleich ohne Angabe seiner Streuung ist keine&quot;</span>)</span>
+<span id="cb153-207"><a href="#cb153-207" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;  Aussage. Bei kurzen Zeitraeumen gehoert eine Kreuzvalidierung dazu.&quot;</span>)</span>
+<span id="cb153-208"><a href="#cb153-208" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb153-209"><a href="#cb153-209" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;</span><span class="ch">\n</span><span class="st">&quot;</span> <span class="op">+</span> <span class="st">&quot;=&quot;</span> <span class="op">*</span> <span class="dv">84</span>)</span>
+<span id="cb153-210"><a href="#cb153-210" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;  WAS MAN DARAUS MITNIMMT&quot;</span>)</span>
+<span id="cb153-211"><a href="#cb153-211" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;=&quot;</span> <span class="op">*</span> <span class="dv">84</span>)</span>
+<span id="cb153-212"><a href="#cb153-212" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;Der Prognostiker optimiert den MSE, der Planer traegt die Kosten - und&quot;</span>)</span>
+<span id="cb153-213"><a href="#cb153-213" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;die beiden Masse zeigen hier in verschiedene Richtungen. Drei Saetze:&quot;</span>)</span>
+<span id="cb153-214"><a href="#cb153-214" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>()</span>
+<span id="cb153-215"><a href="#cb153-215" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;  1. Sagen Sie nicht den Erwartungswert vorher, sondern die Groesse, die&quot;</span>)</span>
+<span id="cb153-216"><a href="#cb153-216" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;     in die Entscheidung eingeht. Beim Newsvendor ist das das kritische&quot;</span>)</span>
+<span id="cb153-217"><a href="#cb153-217" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;     Quantil - und das kann man direkt schaetzen.&quot;</span>)</span>
+<span id="cb153-218"><a href="#cb153-218" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;  2. Bewerten Sie Prognosemodelle an den ENTSCHEIDUNGSKOSTEN. Die sind&quot;</span>)</span>
+<span id="cb153-219"><a href="#cb153-219" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;     in Euro und damit vergleichbar; ein MSE ist es nicht.&quot;</span>)</span>
+<span id="cb153-220"><a href="#cb153-220" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;  3. Ein pauschaler Sicherheitszuschlag ist besser als nichts und&quot;</span>)</span>
+<span id="cb153-221"><a href="#cb153-221" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;     schlechter als ein Modell, das die Unsicherheit selbst aus den&quot;</span>)</span>
+<span id="cb153-222"><a href="#cb153-222" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;     Merkmalen liest.&quot;</span>)</span>
+<span id="cb153-223"><a href="#cb153-223" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>()</span>
+<span id="cb153-224"><a href="#cb153-224" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;Der naechste Schritt - Prognosemodelle so zu trainieren, dass sie die&quot;</span>)</span>
+<span id="cb153-225"><a href="#cb153-225" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;Entscheidungskosten direkt minimieren (Smart Predict-then-Optimize,&quot;</span>)</span>
+<span id="cb153-226"><a href="#cb153-226" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;differenzierbare Optimierungsschichten) - ist Forschungsstand und&quot;</span>)</span>
+<span id="cb153-227"><a href="#cb153-227" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;erfordert Bibliotheken wie cvxpylayers. Die dritte Zeile der Tabelle&quot;</span>)</span>
+<span id="cb153-228"><a href="#cb153-228" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;oben ist seine einfachste denkbare Form: ein einziger Parameter, auf&quot;</span>)</span>
+<span id="cb153-229"><a href="#cb153-229" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;Kosten statt auf Fehler trainiert.&quot;</span>)</span>
+<span id="cb153-230"><a href="#cb153-230" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;=&quot;</span> <span class="op">*</span> <span class="dv">84</span>)</span></code></pre></div>
 <p><strong>Erwartete Ausgabe:</strong></p>
 <pre><code>====================================================================================
   DIE BESSERE PROGNOSE TRIFFT DIE SCHLECHTERE ENTSCHEIDUNG
@@ -19730,6 +20595,106 @@ Kosten statt auf Fehler trainiert.
 <li>Ein Kennzahlenvergleich braucht eine <strong>Streuungsangabe</strong>. Bei 180 Testtagen sah das schlechtere Modell in gut jedem zehnten Fall besser aus — und wer einmal misst, hat genau eine Ziehung.</li>
 </ul>
 <hr />
+<h1 id="synthese-teil-iii-wenn-die-idealwelt-nicht-gilt">Synthese Teil III — Wenn die Idealwelt nicht gilt</h1>
+<p><a href="#teil-kernverfahren">Teil II</a> setzte voraus: feste Daten, lineare Zusammenhänge, ein Ziel, eine Periode. Dieser Teil nimmt jede dieser vier Voraussetzungen einzeln weg. Die Tabelle ordnet die Kapitel danach, <strong>welche</strong> Voraussetzung bei Ihnen verletzt ist.</p>
+<h2 id="welche-annahme-fällt-weg">Welche Annahme fällt weg?</h2>
+<table>
+<colgroup>
+<col style="width: 25%" />
+<col style="width: 25%" />
+<col style="width: 25%" />
+<col style="width: 25%" />
+</colgroup>
+<thead>
+<tr class="header">
+<th>Was nicht gilt</th>
+<th>Woran Sie es merken</th>
+<th>Werkzeug</th>
+<th>Kapitel</th>
+</tr>
+</thead>
+<tbody>
+<tr class="odd">
+<td><strong>Linearität</strong></td>
+<td>Risiko wächst quadratisch, Kosten degressiv, Sättigung</td>
+<td>QP, konvexe Optimierung, KKT</td>
+<td><a href="#kap-qp-nlp">Kapitel 11</a></td>
+</tr>
+<tr class="even">
+<td><strong>Feste Daten</strong></td>
+<td>Nachfrage, Wind, Rendite stehen erst morgen fest</td>
+<td>Monte-Carlo, Zweistufigkeit, Robustheit, Chance Constraints</td>
+<td><a href="#kap-unsicherheit">Kapitel 12</a></td>
+</tr>
+<tr class="odd">
+<td><strong>Eine Periode</strong></td>
+<td>die Entscheidung heute verändert, was übermorgen möglich ist</td>
+<td>Bellman-Gleichung, Rückwärtsinduktion</td>
+<td><a href="#kap-dynamische-programmierung">Kapitel 13</a></td>
+</tr>
+<tr class="even">
+<td><strong>Ein Ziel</strong></td>
+<td>zwei Kennzahlen sollen gleichzeitig stimmen</td>
+<td>Pareto-Front, ε-Constraint</td>
+<td><a href="#kap-mehrziel">Kapitel 14</a></td>
+</tr>
+<tr class="odd">
+<td><strong>Daten sind gegeben</strong></td>
+<td>die Eingabe ist selbst eine Prognose</td>
+<td>Predict-then-Optimize, entscheidungsorientiertes Lernen</td>
+<td><a href="#kap-prognose">Kapitel 15</a></td>
+</tr>
+</tbody>
+</table>
+<p>Die letzte Zeile ist die unbequemste: Dort ist nicht das Modell unsicher, sondern seine <strong>Eingabe</strong> — und die kommt aus einem zweiten Modell, das nach anderen Kriterien gebaut wurde.</p>
+<h2 id="was-dieser-teil-gemessen-hat-1">Was dieser Teil gemessen hat</h2>
+<table>
+<colgroup>
+<col style="width: 33%" />
+<col style="width: 33%" />
+<col style="width: 33%" />
+</colgroup>
+<thead>
+<tr class="header">
+<th>Behauptung</th>
+<th>Gemessen</th>
+<th>Wo</th>
+</tr>
+</thead>
+<tbody>
+<tr class="odd">
+<td>„Mit dem Mittelwert zu rechnen ist eine brauchbare Näherung.”</td>
+<td>Der Mittelwertplan hält seine Zusage in <strong>50,08 %</strong> der Fälle — per Definition</td>
+<td><a href="#sec:unsicherheit-chance-constraints">Abschnitt 12.7</a></td>
+</tr>
+<tr class="even">
+<td>„Versorgungssicherheit kostet linear.”</td>
+<td>56 289 € je Prozentpunkt auf dem Weg zu 80 %, <strong>253 848 €</strong> zwischen 95 und 99 % — das 4,5-fache</td>
+<td><a href="#sec:unsicherheit-chance-constraints">Abschnitt 12.7</a></td>
+</tr>
+<tr class="odd">
+<td>„Eine Zusage aus dem Modell hält.”</td>
+<td>Der 95-%-Plan hält <strong>87,44 %</strong>, sobald die Testverteilung einen Fall enthält, in dem alles zugleich ausfällt</td>
+<td><a href="#sec:unsicherheit-chance-constraints">Abschnitt 12.7</a></td>
+</tr>
+<tr class="even">
+<td>„Die bessere Prognose führt zur besseren Entscheidung.”</td>
+<td>Das Modell mit dem <strong>schlechteren</strong> MSE trifft die günstigere Entscheidung</td>
+<td><a href="#kap-prognose">Kapitel 15</a></td>
+</tr>
+</tbody>
+</table>
+<h2 id="drei-fehler-die-dieser-teil-verhindert-1">Drei Fehler, die dieser Teil verhindert</h2>
+<ol type="1">
+<li><strong>Unsicherheit durch Mittelwerte ersetzen.</strong> Der Durchschnittskunde kauft nie. Bei asymmetrischen Kosten liegt das Optimum systematisch neben dem Mittelwert, und eine Terminzusage ist ein <strong>Quantil</strong>, kein Erwartungswert.</li>
+<li><strong>Konvexität voraussetzen, ohne sie zu prüfen.</strong> Ohne sie gibt es keine Optimalitätsgarantie, sondern nur ein lokales Ergebnis — und der Solver sagt das nicht von selbst.</li>
+<li><strong>Zwei Ziele mit einem Gewicht verrechnen, bevor die Front bekannt ist.</strong> Ein Gewicht ist eine Antwort auf eine Frage, die noch niemand gestellt hat. Die Pareto-Front stellt sie zuerst.</li>
+</ol>
+<h2 id="wenn-sie-nur-eines-mitnehmen-2">Wenn Sie nur eines mitnehmen</h2>
+<blockquote>
+<p><strong>🎯</strong> Jede der vier Annahmen lässt sich einzeln aufgeben — aber jede kostet etwas Bestimmtes: Linearität kostet die Optimalitätsgarantie, feste Daten kosten Rechenzeit oder Vorsicht, eine Periode kostet Zustandsraum, ein Ziel kostet eine Entscheidung, die nicht der Modellierer treffen darf. Wer weiß, <strong>welche</strong> Annahme bei ihm fällt, weiß auch, welchen Preis er zahlt.</p>
+</blockquote>
+<hr />
 <h1 id="teil-anwendungen">Teil IV: Anwendungen — Energiewirtschaft und Finanzmärkte</h1>
 <p>Dieser Teil wechselt die Domäne — aber <strong>nicht</strong> die Methoden. Was hier folgt, ist die konsequente Anwendung dessen, was Sie in den Teilen II und III gelernt haben, auf zwei Gebiete, in denen viel Unsicherheit auf ein unmittelbar messbares Ergebnis trifft: die Energiewirtschaft und die Finanzmärkte.</p>
 <p>Er hat drei Abschnitte, und Sie können nach jedem aufhören:</p>
@@ -19749,7 +20714,7 @@ Kosten statt auf Fehler trainiert.
 <blockquote>
 <p><strong>📌 Kapitel auf einen Blick</strong></p>
 <p><strong>Worum geht es?</strong> Um den Nachweis, dass die Verfahren aus Teil II und III unverändert in der Finanzwelt funktionieren — und um die drei Stellen, an denen die Analogie endet.</p>
-<p><strong>Voraussetzungen:</strong> <a href="#kap-einfuehrung">Kapitel 1</a> (Allokation als LP), <a href="#kap-unsicherheit">Kapitel 12</a> (Szenarien) und <a href="#sec:praxisfallen-or-kern">Abschnitt 22.5</a> (<code>or_kern.py</code>).</p>
+<p><strong>Voraussetzungen:</strong> <a href="#kap-einfuehrung">Kapitel 1</a> (Allokation als LP), <a href="#kap-unsicherheit">Kapitel 12</a> (Szenarien) und <a href="#sec:praxisfallen-or-kern">Abschnitt 22.6</a> (<code>or_kern.py</code>).</p>
 <p><strong>Danach können Sie:</strong> ein betriebswirtschaftliches Modell in die andere Domäne übersetzen, ohne den Modellcode anzufassen; Schattenpreise in beiden Welten lesen; und benennen, welche Annahmen dabei <strong>nicht</strong> mitwandern.</p>
 <p><strong>Zeitbedarf:</strong> ca. 2,5 Stunden.</p>
 <p><strong>Programme:</strong><br />
@@ -19800,22 +20765,22 @@ Kosten statt auf Fehler trainiert.
 </table>
 <p>Lesen Sie die Tabelle noch einmal — und ersetzen Sie „Kapital” durch „Montagestunden” und „Risikobudget” durch „Plattenmaterial”. Es ist die Schreinerei aus <a href="#kap-einfuehrung">Kapitel 1</a>, Wort für Wort.</p>
 <p>Deshalb genügt der vorhandene Code:</p>
-<div class="sourceCode" id="cb153"><pre class="sourceCode python"><code class="sourceCode python"><span id="cb153-1"><a href="#cb153-1" aria-hidden="true" tabindex="-1"></a><span class="im">from</span> or_kern <span class="im">import</span> Produkt, Produktionsproblem, loese_mit_scipy</span>
-<span id="cb153-2"><a href="#cb153-2" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb153-3"><a href="#cb153-3" aria-hidden="true" tabindex="-1"></a>depot <span class="op">=</span> Produktionsproblem(</span>
-<span id="cb153-4"><a href="#cb153-4" aria-hidden="true" tabindex="-1"></a>    produkte<span class="op">=</span>[</span>
-<span id="cb153-5"><a href="#cb153-5" aria-hidden="true" tabindex="-1"></a>        Produkt(name<span class="op">=</span><span class="st">&quot;Aktien Welt&quot;</span>, deckungsbeitrag<span class="op">=</span><span class="fl">75.0</span>,</span>
-<span id="cb153-6"><a href="#cb153-6" aria-hidden="true" tabindex="-1"></a>                verbrauch<span class="op">=</span>{<span class="st">&quot;Kapital (Tsd. EUR)&quot;</span>: <span class="fl">1.0</span>, <span class="st">&quot;Risikobudget&quot;</span>: <span class="fl">1.00</span>}),</span>
-<span id="cb153-7"><a href="#cb153-7" aria-hidden="true" tabindex="-1"></a>        Produkt(name<span class="op">=</span><span class="st">&quot;Anleihen&quot;</span>, deckungsbeitrag<span class="op">=</span><span class="fl">28.0</span>,</span>
-<span id="cb153-8"><a href="#cb153-8" aria-hidden="true" tabindex="-1"></a>                verbrauch<span class="op">=</span>{<span class="st">&quot;Kapital (Tsd. EUR)&quot;</span>: <span class="fl">1.0</span>, <span class="st">&quot;Risikobudget&quot;</span>: <span class="fl">0.22</span>}),</span>
-<span id="cb153-9"><a href="#cb153-9" aria-hidden="true" tabindex="-1"></a>        Produkt(name<span class="op">=</span><span class="st">&quot;Immobilienfonds&quot;</span>, deckungsbeitrag<span class="op">=</span><span class="fl">46.0</span>,</span>
-<span id="cb153-10"><a href="#cb153-10" aria-hidden="true" tabindex="-1"></a>                verbrauch<span class="op">=</span>{<span class="st">&quot;Kapital (Tsd. EUR)&quot;</span>: <span class="fl">1.0</span>, <span class="st">&quot;Risikobudget&quot;</span>: <span class="fl">0.55</span>}),</span>
-<span id="cb153-11"><a href="#cb153-11" aria-hidden="true" tabindex="-1"></a>    ],</span>
-<span id="cb153-12"><a href="#cb153-12" aria-hidden="true" tabindex="-1"></a>    kapazitaeten<span class="op">=</span>{<span class="st">&quot;Kapital (Tsd. EUR)&quot;</span>: <span class="fl">150.0</span>, <span class="st">&quot;Risikobudget&quot;</span>: <span class="fl">90.0</span>})</span>
-<span id="cb153-13"><a href="#cb153-13" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb153-14"><a href="#cb153-14" aria-hidden="true" tabindex="-1"></a>loesung <span class="op">=</span> loese_mit_scipy(depot)</span>
-<span id="cb153-15"><a href="#cb153-15" aria-hidden="true" tabindex="-1"></a><span class="bu">print</span>(loesung.als_bericht())</span>
-<span id="cb153-16"><a href="#cb153-16" aria-hidden="true" tabindex="-1"></a><span class="bu">print</span>(loesung.schattenpreise)</span></code></pre></div>
+<div class="sourceCode" id="cb155"><pre class="sourceCode python"><code class="sourceCode python"><span id="cb155-1"><a href="#cb155-1" aria-hidden="true" tabindex="-1"></a><span class="im">from</span> or_kern <span class="im">import</span> Produkt, Produktionsproblem, loese_mit_scipy</span>
+<span id="cb155-2"><a href="#cb155-2" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb155-3"><a href="#cb155-3" aria-hidden="true" tabindex="-1"></a>depot <span class="op">=</span> Produktionsproblem(</span>
+<span id="cb155-4"><a href="#cb155-4" aria-hidden="true" tabindex="-1"></a>    produkte<span class="op">=</span>[</span>
+<span id="cb155-5"><a href="#cb155-5" aria-hidden="true" tabindex="-1"></a>        Produkt(name<span class="op">=</span><span class="st">&quot;Aktien Welt&quot;</span>, deckungsbeitrag<span class="op">=</span><span class="fl">75.0</span>,</span>
+<span id="cb155-6"><a href="#cb155-6" aria-hidden="true" tabindex="-1"></a>                verbrauch<span class="op">=</span>{<span class="st">&quot;Kapital (Tsd. EUR)&quot;</span>: <span class="fl">1.0</span>, <span class="st">&quot;Risikobudget&quot;</span>: <span class="fl">1.00</span>}),</span>
+<span id="cb155-7"><a href="#cb155-7" aria-hidden="true" tabindex="-1"></a>        Produkt(name<span class="op">=</span><span class="st">&quot;Anleihen&quot;</span>, deckungsbeitrag<span class="op">=</span><span class="fl">28.0</span>,</span>
+<span id="cb155-8"><a href="#cb155-8" aria-hidden="true" tabindex="-1"></a>                verbrauch<span class="op">=</span>{<span class="st">&quot;Kapital (Tsd. EUR)&quot;</span>: <span class="fl">1.0</span>, <span class="st">&quot;Risikobudget&quot;</span>: <span class="fl">0.22</span>}),</span>
+<span id="cb155-9"><a href="#cb155-9" aria-hidden="true" tabindex="-1"></a>        Produkt(name<span class="op">=</span><span class="st">&quot;Immobilienfonds&quot;</span>, deckungsbeitrag<span class="op">=</span><span class="fl">46.0</span>,</span>
+<span id="cb155-10"><a href="#cb155-10" aria-hidden="true" tabindex="-1"></a>                verbrauch<span class="op">=</span>{<span class="st">&quot;Kapital (Tsd. EUR)&quot;</span>: <span class="fl">1.0</span>, <span class="st">&quot;Risikobudget&quot;</span>: <span class="fl">0.55</span>}),</span>
+<span id="cb155-11"><a href="#cb155-11" aria-hidden="true" tabindex="-1"></a>    ],</span>
+<span id="cb155-12"><a href="#cb155-12" aria-hidden="true" tabindex="-1"></a>    kapazitaeten<span class="op">=</span>{<span class="st">&quot;Kapital (Tsd. EUR)&quot;</span>: <span class="fl">150.0</span>, <span class="st">&quot;Risikobudget&quot;</span>: <span class="fl">90.0</span>})</span>
+<span id="cb155-13"><a href="#cb155-13" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb155-14"><a href="#cb155-14" aria-hidden="true" tabindex="-1"></a>loesung <span class="op">=</span> loese_mit_scipy(depot)</span>
+<span id="cb155-15"><a href="#cb155-15" aria-hidden="true" tabindex="-1"></a><span class="bu">print</span>(loesung.als_bericht())</span>
+<span id="cb155-16"><a href="#cb155-16" aria-hidden="true" tabindex="-1"></a><span class="bu">print</span>(loesung.schattenpreise)</span></code></pre></div>
 <p><strong>Ausgabe:</strong></p>
 <pre><code>Status: optimal | Zielwert: 7,634.62 | Gap: 0.00% | Zeit: 0.00s
 {&#39;Kapital (Tsd. EUR)&#39;: 14.74, &#39;Risikobudget&#39;: 60.26}</code></pre>
@@ -19837,281 +20802,281 @@ Kosten statt auf Fehler trainiert.
 </ol>
 <hr />
 <h2 id="sec:bruecke-programm">16.3 Das Programm</h2>
-<div class="sourceCode" id="cb155"><pre class="sourceCode python"><code class="sourceCode python"><span id="cb155-1"><a href="#cb155-1" aria-hidden="true" tabindex="-1"></a><span class="co">#!/usr/bin/env python3</span></span>
-<span id="cb155-2"><a href="#cb155-2" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb155-3"><a href="#cb155-3" aria-hidden="true" tabindex="-1"></a><span class="co"># Strukturbruecke.py</span></span>
-<span id="cb155-4"><a href="#cb155-4" aria-hidden="true" tabindex="-1"></a><span class="co">&quot;&quot;&quot;</span></span>
-<span id="cb155-5"><a href="#cb155-5" aria-hidden="true" tabindex="-1"></a><span class="co">Kapitel Bruecke: Derselbe Code, zwei Welten - der Beweis statt der Behauptung.</span></span>
-<span id="cb155-6"><a href="#cb155-6" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb155-7"><a href="#cb155-7" aria-hidden="true" tabindex="-1"></a><span class="co">Der Teil-Auftakt stellt eine Tabelle auf: &quot;Ressourcen auf Produkte verteilen&quot;</span></span>
-<span id="cb155-8"><a href="#cb155-8" aria-hidden="true" tabindex="-1"></a><span class="co">entspreche &quot;Kapital auf Anlagen verteilen&quot;, &quot;gegen den Worst Case absichern&quot;</span></span>
-<span id="cb155-9"><a href="#cb155-9" aria-hidden="true" tabindex="-1"></a><span class="co">entspreche &quot;Absicherung gegen Kursabstuerze&quot;. Solche Tabellen stehen in vielen</span></span>
-<span id="cb155-10"><a href="#cb155-10" aria-hidden="true" tabindex="-1"></a><span class="co">Buechern. Sie sind billig - und man kann sie pruefen.</span></span>
-<span id="cb155-11"><a href="#cb155-11" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb155-12"><a href="#cb155-12" aria-hidden="true" tabindex="-1"></a><span class="co">Dieses Programm prueft sie. Es fuettert zweimal DENSELBEN Code mit Daten aus</span></span>
-<span id="cb155-13"><a href="#cb155-13" aria-hidden="true" tabindex="-1"></a><span class="co">zwei Welten und zeigt die Ergebnisse nebeneinander:</span></span>
-<span id="cb155-14"><a href="#cb155-14" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb155-15"><a href="#cb155-15" aria-hidden="true" tabindex="-1"></a><span class="co">  1. Die Allokation als LP. Das Domaenenmodell aus or_kern.py, einmal mit einer</span></span>
-<span id="cb155-16"><a href="#cb155-16" aria-hidden="true" tabindex="-1"></a><span class="co">     Schreinerei (Montagestunden, Plattenmaterial) und einmal mit einem Depot</span></span>
-<span id="cb155-17"><a href="#cb155-17" aria-hidden="true" tabindex="-1"></a><span class="co">     (Kapital, Risikobudget). Gleiche Klasse, gleicher Modellbauer, gleiche</span></span>
-<span id="cb155-18"><a href="#cb155-18" aria-hidden="true" tabindex="-1"></a><span class="co">     Abnahmepruefung - und der Schattenpreis heisst in der einen Welt</span></span>
-<span id="cb155-19"><a href="#cb155-19" aria-hidden="true" tabindex="-1"></a><span class="co">     &quot;Wert einer zusaetzlichen Montagestunde&quot; und in der anderen &quot;Preis des</span></span>
-<span id="cb155-20"><a href="#cb155-20" aria-hidden="true" tabindex="-1"></a><span class="co">     Risikos&quot;.</span></span>
-<span id="cb155-21"><a href="#cb155-21" aria-hidden="true" tabindex="-1"></a><span class="co">  2. Die Absicherung gegen den schlechtesten Fall als CVaR. EINE Funktion,</span></span>
-<span id="cb155-22"><a href="#cb155-22" aria-hidden="true" tabindex="-1"></a><span class="co">     einmal mit Kursrenditen und einmal mit Lieferverzuegen.</span></span>
-<span id="cb155-23"><a href="#cb155-23" aria-hidden="true" tabindex="-1"></a><span class="co">  3. Was NICHT hinueberreicht. Der ehrliche Teil: Drei Unterschiede, die die</span></span>
-<span id="cb155-24"><a href="#cb155-24" aria-hidden="true" tabindex="-1"></a><span class="co">     Analogie begrenzen - und die man kennen muss, bevor man Methoden aus</span></span>
-<span id="cb155-25"><a href="#cb155-25" aria-hidden="true" tabindex="-1"></a><span class="co">     der einen Welt in die andere traegt.</span></span>
-<span id="cb155-26"><a href="#cb155-26" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb155-27"><a href="#cb155-27" aria-hidden="true" tabindex="-1"></a><span class="co">ZUR SOLVERWAHL: Teil 1 benutzt &#39;loese_mit_scipy&#39; und nicht &#39;loese_mit_glop&#39;.</span></span>
-<span id="cb155-28"><a href="#cb155-28" aria-hidden="true" tabindex="-1"></a><span class="co">Das ist kein Zufall - CVXPY laedt fuer Teil 2 highspy, und ortools vertraegt</span></span>
-<span id="cb155-29"><a href="#cb155-29" aria-hidden="true" tabindex="-1"></a><span class="co">sich damit nicht im selben Prozess (Kapitel Oekosystem). Wer hier GLOP nimmt,</span></span>
-<span id="cb155-30"><a href="#cb155-30" aria-hidden="true" tabindex="-1"></a><span class="co">bekommt beim cvxpy-Import eine Fehlermeldung ueber ein &#39;undefined symbol&#39;.</span></span>
-<span id="cb155-31"><a href="#cb155-31" aria-hidden="true" tabindex="-1"></a><span class="co">Genau deshalb laedt or_kern.py seine Solver erst beim Aufruf.</span></span>
-<span id="cb155-32"><a href="#cb155-32" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb155-33"><a href="#cb155-33" aria-hidden="true" tabindex="-1"></a><span class="co">Benoetigt: numpy, cvxpy, scipy und pydantic (ueber or_kern)</span></span>
-<span id="cb155-34"><a href="#cb155-34" aria-hidden="true" tabindex="-1"></a><span class="co">&quot;&quot;&quot;</span></span>
-<span id="cb155-35"><a href="#cb155-35" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb155-36"><a href="#cb155-36" aria-hidden="true" tabindex="-1"></a><span class="im">from</span> __future__ <span class="im">import</span> annotations</span>
-<span id="cb155-37"><a href="#cb155-37" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb155-38"><a href="#cb155-38" aria-hidden="true" tabindex="-1"></a><span class="im">import</span> numpy <span class="im">as</span> np</span>
-<span id="cb155-39"><a href="#cb155-39" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb155-40"><a href="#cb155-40" aria-hidden="true" tabindex="-1"></a><span class="im">from</span> or_kern <span class="im">import</span> (Produkt, Produktionsproblem, loese_mit_scipy,</span>
-<span id="cb155-41"><a href="#cb155-41" aria-hidden="true" tabindex="-1"></a>                     pruefe_loesung)</span>
-<span id="cb155-42"><a href="#cb155-42" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb155-43"><a href="#cb155-43" aria-hidden="true" tabindex="-1"></a>SAAT <span class="op">=</span> <span class="dv">7</span></span>
-<span id="cb155-44"><a href="#cb155-44" aria-hidden="true" tabindex="-1"></a>SZENARIEN <span class="op">=</span> <span class="dv">500</span></span>
-<span id="cb155-45"><a href="#cb155-45" aria-hidden="true" tabindex="-1"></a>ALPHA <span class="op">=</span> <span class="fl">0.95</span>              <span class="co"># die schlechtesten 5 % der Faelle</span></span>
-<span id="cb155-46"><a href="#cb155-46" aria-hidden="true" tabindex="-1"></a>MAX_ANTEIL <span class="op">=</span> <span class="fl">0.40</span>         <span class="co"># Streuungsgebot in beiden Welten</span></span>
-<span id="cb155-47"><a href="#cb155-47" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb155-48"><a href="#cb155-48" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb155-49"><a href="#cb155-49" aria-hidden="true" tabindex="-1"></a><span class="co"># --- Teil 1: Dieselbe Klasse, zwei Welten ----------------------------------</span></span>
-<span id="cb155-50"><a href="#cb155-50" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb155-51"><a href="#cb155-51" aria-hidden="true" tabindex="-1"></a><span class="kw">def</span> schreinerei() <span class="op">-&gt;</span> Produktionsproblem:</span>
-<span id="cb155-52"><a href="#cb155-52" aria-hidden="true" tabindex="-1"></a>    <span class="co">&quot;&quot;&quot;Montagestunden und Plattenmaterial auf Tische und Stuehle verteilen.&quot;&quot;&quot;</span></span>
-<span id="cb155-53"><a href="#cb155-53" aria-hidden="true" tabindex="-1"></a>    <span class="cf">return</span> Produktionsproblem(</span>
-<span id="cb155-54"><a href="#cb155-54" aria-hidden="true" tabindex="-1"></a>        produkte<span class="op">=</span>[</span>
-<span id="cb155-55"><a href="#cb155-55" aria-hidden="true" tabindex="-1"></a>            Produkt(name<span class="op">=</span><span class="st">&quot;Tisch&quot;</span>, deckungsbeitrag<span class="op">=</span><span class="fl">240.0</span>,</span>
-<span id="cb155-56"><a href="#cb155-56" aria-hidden="true" tabindex="-1"></a>                    verbrauch<span class="op">=</span>{<span class="st">&quot;Montagestunden&quot;</span>: <span class="fl">3.0</span>, <span class="st">&quot;Plattenmaterial&quot;</span>: <span class="fl">6.0</span>}),</span>
-<span id="cb155-57"><a href="#cb155-57" aria-hidden="true" tabindex="-1"></a>            Produkt(name<span class="op">=</span><span class="st">&quot;Stuhl&quot;</span>, deckungsbeitrag<span class="op">=</span><span class="fl">60.0</span>,</span>
-<span id="cb155-58"><a href="#cb155-58" aria-hidden="true" tabindex="-1"></a>                    verbrauch<span class="op">=</span>{<span class="st">&quot;Montagestunden&quot;</span>: <span class="fl">1.0</span>, <span class="st">&quot;Plattenmaterial&quot;</span>: <span class="fl">1.0</span>}),</span>
-<span id="cb155-59"><a href="#cb155-59" aria-hidden="true" tabindex="-1"></a>            Produkt(name<span class="op">=</span><span class="st">&quot;Regal&quot;</span>, deckungsbeitrag<span class="op">=</span><span class="fl">130.0</span>,</span>
-<span id="cb155-60"><a href="#cb155-60" aria-hidden="true" tabindex="-1"></a>                    verbrauch<span class="op">=</span>{<span class="st">&quot;Montagestunden&quot;</span>: <span class="fl">2.0</span>, <span class="st">&quot;Plattenmaterial&quot;</span>: <span class="fl">4.0</span>}),</span>
-<span id="cb155-61"><a href="#cb155-61" aria-hidden="true" tabindex="-1"></a>        ],</span>
-<span id="cb155-62"><a href="#cb155-62" aria-hidden="true" tabindex="-1"></a>        kapazitaeten<span class="op">=</span>{<span class="st">&quot;Montagestunden&quot;</span>: <span class="fl">150.0</span>, <span class="st">&quot;Plattenmaterial&quot;</span>: <span class="fl">240.0</span>})</span>
-<span id="cb155-63"><a href="#cb155-63" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb155-64"><a href="#cb155-64" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb155-65"><a href="#cb155-65" aria-hidden="true" tabindex="-1"></a><span class="kw">def</span> depot() <span class="op">-&gt;</span> Produktionsproblem:</span>
-<span id="cb155-66"><a href="#cb155-66" aria-hidden="true" tabindex="-1"></a>    <span class="co">&quot;&quot;&quot;Kapital und Risikobudget auf Anlageklassen verteilen.</span></span>
-<span id="cb155-67"><a href="#cb155-67" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb155-68"><a href="#cb155-68" aria-hidden="true" tabindex="-1"></a><span class="co">    Eine &quot;Einheit&quot; ist hier 1.000 EUR Anlagesumme. Der Deckungsbeitrag ist der</span></span>
-<span id="cb155-69"><a href="#cb155-69" aria-hidden="true" tabindex="-1"></a><span class="co">    erwartete Jahresertrag dieser Einheit, der Verbrauch die beanspruchte</span></span>
-<span id="cb155-70"><a href="#cb155-70" aria-hidden="true" tabindex="-1"></a><span class="co">    Kapital- und Risikomenge. Das ist keine Analogie, sondern buchstaeblich</span></span>
-<span id="cb155-71"><a href="#cb155-71" aria-hidden="true" tabindex="-1"></a><span class="co">    dasselbe Modell - deshalb passt es in dieselbe Klasse.</span></span>
-<span id="cb155-72"><a href="#cb155-72" aria-hidden="true" tabindex="-1"></a><span class="co">    &quot;&quot;&quot;</span></span>
-<span id="cb155-73"><a href="#cb155-73" aria-hidden="true" tabindex="-1"></a>    <span class="cf">return</span> Produktionsproblem(</span>
-<span id="cb155-74"><a href="#cb155-74" aria-hidden="true" tabindex="-1"></a>        produkte<span class="op">=</span>[</span>
-<span id="cb155-75"><a href="#cb155-75" aria-hidden="true" tabindex="-1"></a>            Produkt(name<span class="op">=</span><span class="st">&quot;Aktien Welt&quot;</span>, deckungsbeitrag<span class="op">=</span><span class="fl">75.0</span>,</span>
-<span id="cb155-76"><a href="#cb155-76" aria-hidden="true" tabindex="-1"></a>                    verbrauch<span class="op">=</span>{<span class="st">&quot;Kapital (Tsd. EUR)&quot;</span>: <span class="fl">1.0</span>, <span class="st">&quot;Risikobudget&quot;</span>: <span class="fl">1.00</span>}),</span>
-<span id="cb155-77"><a href="#cb155-77" aria-hidden="true" tabindex="-1"></a>            Produkt(name<span class="op">=</span><span class="st">&quot;Anleihen&quot;</span>, deckungsbeitrag<span class="op">=</span><span class="fl">28.0</span>,</span>
-<span id="cb155-78"><a href="#cb155-78" aria-hidden="true" tabindex="-1"></a>                    verbrauch<span class="op">=</span>{<span class="st">&quot;Kapital (Tsd. EUR)&quot;</span>: <span class="fl">1.0</span>, <span class="st">&quot;Risikobudget&quot;</span>: <span class="fl">0.22</span>}),</span>
-<span id="cb155-79"><a href="#cb155-79" aria-hidden="true" tabindex="-1"></a>            Produkt(name<span class="op">=</span><span class="st">&quot;Immobilienfonds&quot;</span>, deckungsbeitrag<span class="op">=</span><span class="fl">46.0</span>,</span>
-<span id="cb155-80"><a href="#cb155-80" aria-hidden="true" tabindex="-1"></a>                    verbrauch<span class="op">=</span>{<span class="st">&quot;Kapital (Tsd. EUR)&quot;</span>: <span class="fl">1.0</span>, <span class="st">&quot;Risikobudget&quot;</span>: <span class="fl">0.55</span>}),</span>
-<span id="cb155-81"><a href="#cb155-81" aria-hidden="true" tabindex="-1"></a>        ],</span>
-<span id="cb155-82"><a href="#cb155-82" aria-hidden="true" tabindex="-1"></a>        kapazitaeten<span class="op">=</span>{<span class="st">&quot;Kapital (Tsd. EUR)&quot;</span>: <span class="fl">150.0</span>, <span class="st">&quot;Risikobudget&quot;</span>: <span class="fl">90.0</span>})</span>
-<span id="cb155-83"><a href="#cb155-83" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb155-84"><a href="#cb155-84" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb155-85"><a href="#cb155-85" aria-hidden="true" tabindex="-1"></a><span class="kw">def</span> berichte_allokation(titel: <span class="bu">str</span>, problem: Produktionsproblem,</span>
-<span id="cb155-86"><a href="#cb155-86" aria-hidden="true" tabindex="-1"></a>                        einheit: <span class="bu">str</span>, ertragsname: <span class="bu">str</span>) <span class="op">-&gt;</span> <span class="va">None</span>:</span>
-<span id="cb155-87"><a href="#cb155-87" aria-hidden="true" tabindex="-1"></a>    <span class="co">&quot;&quot;&quot;Ein Bericht fuer beide Welten - nur die Beschriftung wechselt.&quot;&quot;&quot;</span></span>
-<span id="cb155-88"><a href="#cb155-88" aria-hidden="true" tabindex="-1"></a>    loesung <span class="op">=</span> loese_mit_scipy(problem)</span>
-<span id="cb155-89"><a href="#cb155-89" aria-hidden="true" tabindex="-1"></a>    beanstandungen <span class="op">=</span> pruefe_loesung(problem, loesung)</span>
-<span id="cb155-90"><a href="#cb155-90" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb155-91"><a href="#cb155-91" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;  </span><span class="sc">{</span>titel<span class="sc">}</span><span class="ss">&quot;</span>)</span>
-<span id="cb155-92"><a href="#cb155-92" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;    </span><span class="sc">{</span>loesung<span class="sc">.</span>als_bericht()<span class="sc">}</span><span class="ss">&quot;</span>)</span>
-<span id="cb155-93"><a href="#cb155-93" aria-hidden="true" tabindex="-1"></a>    <span class="cf">for</span> produkt <span class="kw">in</span> problem.produkte:</span>
-<span id="cb155-94"><a href="#cb155-94" aria-hidden="true" tabindex="-1"></a>        <span class="bu">print</span>(<span class="ss">f&quot;      </span><span class="sc">{</span>produkt<span class="sc">.</span>name<span class="sc">:&lt;18}</span><span class="ss"> </span><span class="sc">{</span>loesung<span class="sc">.</span>werte[produkt.name]<span class="sc">:8.2f}</span><span class="ss"> </span><span class="sc">{</span>einheit<span class="sc">}</span><span class="ss">&quot;</span>)</span>
-<span id="cb155-95"><a href="#cb155-95" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;      </span><span class="sc">{</span>ertragsname<span class="sc">:&lt;18}</span><span class="ss"> </span><span class="sc">{</span>loesung<span class="sc">.</span>zielwert<span class="sc">:8.2f}</span><span class="ss"> EUR&quot;</span>)</span>
-<span id="cb155-96"><a href="#cb155-96" aria-hidden="true" tabindex="-1"></a>    <span class="cf">for</span> ressource, preis <span class="kw">in</span> loesung.schattenpreise.items():</span>
-<span id="cb155-97"><a href="#cb155-97" aria-hidden="true" tabindex="-1"></a>        <span class="bu">print</span>(<span class="ss">f&quot;      Schattenpreis </span><span class="sc">{</span>ressource<span class="sc">:&lt;24}</span><span class="ss"> </span><span class="sc">{</span>preis<span class="sc">:7.2f}</span><span class="ss"> EUR&quot;</span>)</span>
-<span id="cb155-98"><a href="#cb155-98" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;      Abnahmepruefung: &quot;</span></span>
-<span id="cb155-99"><a href="#cb155-99" aria-hidden="true" tabindex="-1"></a>          <span class="ss">f&quot;</span><span class="sc">{</span><span class="st">&#39;bestanden&#39;</span> <span class="cf">if</span> <span class="kw">not</span> beanstandungen <span class="cf">else</span> beanstandungen<span class="sc">}</span><span class="ss">&quot;</span>)</span>
-<span id="cb155-100"><a href="#cb155-100" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb155-101"><a href="#cb155-101" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb155-102"><a href="#cb155-102" aria-hidden="true" tabindex="-1"></a><span class="co"># --- Teil 2: Eine CVaR-Funktion, zwei Welten -------------------------------</span></span>
-<span id="cb155-103"><a href="#cb155-103" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb155-104"><a href="#cb155-104" aria-hidden="true" tabindex="-1"></a><span class="kw">def</span> optimiere_cvar(verluste: np.ndarray, ertrag: np.ndarray,</span>
-<span id="cb155-105"><a href="#cb155-105" aria-hidden="true" tabindex="-1"></a>                   mindestertrag: <span class="bu">float</span>, alpha: <span class="bu">float</span> <span class="op">=</span> ALPHA,</span>
-<span id="cb155-106"><a href="#cb155-106" aria-hidden="true" tabindex="-1"></a>                   max_anteil: <span class="bu">float</span> <span class="op">=</span> MAX_ANTEIL):</span>
-<span id="cb155-107"><a href="#cb155-107" aria-hidden="true" tabindex="-1"></a>    <span class="co">&quot;&quot;&quot;Minimiert den CVaR der Verluste unter einer Mindestertragsbedingung.</span></span>
-<span id="cb155-108"><a href="#cb155-108" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb155-109"><a href="#cb155-109" aria-hidden="true" tabindex="-1"></a><span class="co">    &#39;verluste&#39; hat die Form (Szenarien x Optionen) und enthaelt, was in</span></span>
-<span id="cb155-110"><a href="#cb155-110" aria-hidden="true" tabindex="-1"></a><span class="co">    Szenario s passiert, wenn eine Einheit in Option j steckt. Was ein</span></span>
-<span id="cb155-111"><a href="#cb155-111" aria-hidden="true" tabindex="-1"></a><span class="co">    &quot;Verlust&quot; ist, entscheidet allein die Einheit der Matrix: Prozentpunkte</span></span>
-<span id="cb155-112"><a href="#cb155-112" aria-hidden="true" tabindex="-1"></a><span class="co">    Kursverlust oder Tage Lieferverzug - die Formel sieht keinen Unterschied.</span></span>
-<span id="cb155-113"><a href="#cb155-113" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb155-114"><a href="#cb155-114" aria-hidden="true" tabindex="-1"></a><span class="co">    Das ist die Rockafellar-Uryasev-Formulierung aus dem Kapitel CVaR, hier</span></span>
-<span id="cb155-115"><a href="#cb155-115" aria-hidden="true" tabindex="-1"></a><span class="co">    ohne jede Aenderung wiederverwendet.</span></span>
-<span id="cb155-116"><a href="#cb155-116" aria-hidden="true" tabindex="-1"></a><span class="co">    &quot;&quot;&quot;</span></span>
-<span id="cb155-117"><a href="#cb155-117" aria-hidden="true" tabindex="-1"></a>    <span class="im">import</span> cvxpy <span class="im">as</span> cp</span>
-<span id="cb155-118"><a href="#cb155-118" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb155-119"><a href="#cb155-119" aria-hidden="true" tabindex="-1"></a>    anzahl_szenarien, anzahl_optionen <span class="op">=</span> verluste.shape</span>
-<span id="cb155-120"><a href="#cb155-120" aria-hidden="true" tabindex="-1"></a>    anteil <span class="op">=</span> cp.Variable(anzahl_optionen, nonneg<span class="op">=</span><span class="va">True</span>)</span>
-<span id="cb155-121"><a href="#cb155-121" aria-hidden="true" tabindex="-1"></a>    schwelle <span class="op">=</span> cp.Variable()                       <span class="co"># wird im Optimum zum VaR</span></span>
-<span id="cb155-122"><a href="#cb155-122" aria-hidden="true" tabindex="-1"></a>    ueberschuss <span class="op">=</span> cp.Variable(anzahl_szenarien, nonneg<span class="op">=</span><span class="va">True</span>)</span>
-<span id="cb155-123"><a href="#cb155-123" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb155-124"><a href="#cb155-124" aria-hidden="true" tabindex="-1"></a>    cvar <span class="op">=</span> schwelle <span class="op">+</span> (<span class="fl">1.0</span> <span class="op">/</span> (anzahl_szenarien <span class="op">*</span> (<span class="dv">1</span> <span class="op">-</span> alpha))) <span class="op">*</span> cp.<span class="bu">sum</span>(ueberschuss)</span>
-<span id="cb155-125"><a href="#cb155-125" aria-hidden="true" tabindex="-1"></a>    problem <span class="op">=</span> cp.Problem(</span>
-<span id="cb155-126"><a href="#cb155-126" aria-hidden="true" tabindex="-1"></a>        cp.Minimize(cvar),</span>
-<span id="cb155-127"><a href="#cb155-127" aria-hidden="true" tabindex="-1"></a>        [ueberschuss <span class="op">&gt;=</span> verluste <span class="op">@</span> anteil <span class="op">-</span> schwelle,</span>
-<span id="cb155-128"><a href="#cb155-128" aria-hidden="true" tabindex="-1"></a>         cp.<span class="bu">sum</span>(anteil) <span class="op">==</span> <span class="dv">1</span>,</span>
-<span id="cb155-129"><a href="#cb155-129" aria-hidden="true" tabindex="-1"></a>         anteil <span class="op">&lt;=</span> max_anteil,</span>
-<span id="cb155-130"><a href="#cb155-130" aria-hidden="true" tabindex="-1"></a>         ertrag <span class="op">@</span> anteil <span class="op">&gt;=</span> mindestertrag])</span>
-<span id="cb155-131"><a href="#cb155-131" aria-hidden="true" tabindex="-1"></a>    problem.solve()</span>
-<span id="cb155-132"><a href="#cb155-132" aria-hidden="true" tabindex="-1"></a>    <span class="cf">if</span> problem.status <span class="kw">not</span> <span class="kw">in</span> (<span class="st">&quot;optimal&quot;</span>, <span class="st">&quot;optimal_inaccurate&quot;</span>):</span>
-<span id="cb155-133"><a href="#cb155-133" aria-hidden="true" tabindex="-1"></a>        <span class="cf">raise</span> <span class="pp">SystemExit</span>(<span class="ss">f&quot;CVaR-Problem nicht loesbar: </span><span class="sc">{</span>problem<span class="sc">.</span>status<span class="sc">}</span><span class="ss">&quot;</span>)</span>
-<span id="cb155-134"><a href="#cb155-134" aria-hidden="true" tabindex="-1"></a>    <span class="cf">return</span> anteil.value, <span class="bu">float</span>(cvar.value), <span class="bu">float</span>(schwelle.value)</span>
-<span id="cb155-135"><a href="#cb155-135" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb155-136"><a href="#cb155-136" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb155-137"><a href="#cb155-137" aria-hidden="true" tabindex="-1"></a><span class="kw">def</span> kursszenarien(rng) <span class="op">-&gt;</span> <span class="bu">tuple</span>[np.ndarray, np.ndarray, <span class="bu">list</span>[<span class="bu">str</span>]]:</span>
-<span id="cb155-138"><a href="#cb155-138" aria-hidden="true" tabindex="-1"></a>    <span class="co">&quot;&quot;&quot;Taegliche Verluste (negative Renditen) von sechs Anlageklassen.&quot;&quot;&quot;</span></span>
-<span id="cb155-139"><a href="#cb155-139" aria-hidden="true" tabindex="-1"></a>    namen <span class="op">=</span> [<span class="st">&quot;Aktien Welt&quot;</span>, <span class="st">&quot;Aktien EU&quot;</span>, <span class="st">&quot;Schwellenlaender&quot;</span>,</span>
-<span id="cb155-140"><a href="#cb155-140" aria-hidden="true" tabindex="-1"></a>             <span class="st">&quot;Staatsanleihen&quot;</span>, <span class="st">&quot;Unternehmensanl.&quot;</span>, <span class="st">&quot;Rohstoffe&quot;</span>]</span>
-<span id="cb155-141"><a href="#cb155-141" aria-hidden="true" tabindex="-1"></a>    rendite_pa <span class="op">=</span> np.array([<span class="fl">0.080</span>, <span class="fl">0.065</span>, <span class="fl">0.110</span>, <span class="fl">0.025</span>, <span class="fl">0.045</span>, <span class="fl">0.070</span>])</span>
-<span id="cb155-142"><a href="#cb155-142" aria-hidden="true" tabindex="-1"></a>    schwankung <span class="op">=</span> np.array([<span class="fl">0.180</span>, <span class="fl">0.160</span>, <span class="fl">0.260</span>, <span class="fl">0.040</span>, <span class="fl">0.075</span>, <span class="fl">0.210</span>])</span>
-<span id="cb155-143"><a href="#cb155-143" aria-hidden="true" tabindex="-1"></a>    taeglich <span class="op">=</span> rng.normal(rendite_pa <span class="op">/</span> <span class="dv">252</span>, schwankung <span class="op">/</span> np.sqrt(<span class="dv">252</span>),</span>
-<span id="cb155-144"><a href="#cb155-144" aria-hidden="true" tabindex="-1"></a>                          (SZENARIEN, <span class="bu">len</span>(namen)))</span>
-<span id="cb155-145"><a href="#cb155-145" aria-hidden="true" tabindex="-1"></a>    <span class="cf">return</span> <span class="op">-</span>taeglich <span class="op">*</span> <span class="fl">100.0</span>, rendite_pa <span class="op">*</span> <span class="fl">100.0</span>, namen</span>
-<span id="cb155-146"><a href="#cb155-146" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb155-147"><a href="#cb155-147" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb155-148"><a href="#cb155-148" aria-hidden="true" tabindex="-1"></a><span class="kw">def</span> lieferszenarien(rng) <span class="op">-&gt;</span> <span class="bu">tuple</span>[np.ndarray, np.ndarray, <span class="bu">list</span>[<span class="bu">str</span>]]:</span>
-<span id="cb155-149"><a href="#cb155-149" aria-hidden="true" tabindex="-1"></a>    <span class="co">&quot;&quot;&quot;Lieferverzug in Tagen bei sechs Lieferanten.</span></span>
-<span id="cb155-150"><a href="#cb155-150" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb155-151"><a href="#cb155-151" aria-hidden="true" tabindex="-1"></a><span class="co">    Der Aufbau ist bewusst anders als bei den Kursen: Hier gibt es einen</span></span>
-<span id="cb155-152"><a href="#cb155-152" aria-hidden="true" tabindex="-1"></a><span class="co">    normalen Verzug UND seltene Totalausfaelle, die 14 Tage kosten. Das ist</span></span>
-<span id="cb155-153"><a href="#cb155-153" aria-hidden="true" tabindex="-1"></a><span class="co">    genau die Art fetter Raender, wegen der man in beiden Welten CVaR statt</span></span>
-<span id="cb155-154"><a href="#cb155-154" aria-hidden="true" tabindex="-1"></a><span class="co">    Standardabweichung benutzt.</span></span>
-<span id="cb155-155"><a href="#cb155-155" aria-hidden="true" tabindex="-1"></a><span class="co">    &quot;&quot;&quot;</span></span>
-<span id="cb155-156"><a href="#cb155-156" aria-hidden="true" tabindex="-1"></a>    namen <span class="op">=</span> [<span class="st">&quot;Nordwerk&quot;</span>, <span class="st">&quot;Sued-Metall&quot;</span>, <span class="st">&quot;Fernost A&quot;</span>, <span class="st">&quot;Lokalzulieferer&quot;</span>,</span>
-<span id="cb155-157"><a href="#cb155-157" aria-hidden="true" tabindex="-1"></a>             <span class="st">&quot;Fernost B&quot;</span>, <span class="st">&quot;Osteuropa&quot;</span>]</span>
-<span id="cb155-158"><a href="#cb155-158" aria-hidden="true" tabindex="-1"></a>    zuverlaessigkeit <span class="op">=</span> np.array([<span class="fl">0.94</span>, <span class="fl">0.97</span>, <span class="fl">0.90</span>, <span class="fl">0.99</span>, <span class="fl">0.92</span>, <span class="fl">0.95</span>])</span>
-<span id="cb155-159"><a href="#cb155-159" aria-hidden="true" tabindex="-1"></a>    verzugsstreuung <span class="op">=</span> np.array([<span class="fl">3.5</span>, <span class="fl">1.8</span>, <span class="fl">5.0</span>, <span class="fl">0.9</span>, <span class="fl">4.2</span>, <span class="fl">2.8</span>])</span>
-<span id="cb155-160"><a href="#cb155-160" aria-hidden="true" tabindex="-1"></a>    normaler_verzug <span class="op">=</span> np.maximum(<span class="fl">0.0</span>, rng.normal(<span class="fl">0.5</span>, <span class="fl">1.0</span>, (SZENARIEN, <span class="bu">len</span>(namen)))</span>
-<span id="cb155-161"><a href="#cb155-161" aria-hidden="true" tabindex="-1"></a>                                 <span class="op">*</span> verzugsstreuung)</span>
-<span id="cb155-162"><a href="#cb155-162" aria-hidden="true" tabindex="-1"></a>    totalausfall <span class="op">=</span> (rng.random((SZENARIEN, <span class="bu">len</span>(namen))) <span class="op">&gt;</span> zuverlaessigkeit) <span class="op">*</span> <span class="fl">14.0</span></span>
-<span id="cb155-163"><a href="#cb155-163" aria-hidden="true" tabindex="-1"></a>    <span class="cf">return</span> normaler_verzug <span class="op">+</span> totalausfall, zuverlaessigkeit, namen</span>
-<span id="cb155-164"><a href="#cb155-164" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb155-165"><a href="#cb155-165" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb155-166"><a href="#cb155-166" aria-hidden="true" tabindex="-1"></a><span class="kw">def</span> berichte_cvar(titel: <span class="bu">str</span>, verluste, ertrag, namen, mindestertrag,</span>
-<span id="cb155-167"><a href="#cb155-167" aria-hidden="true" tabindex="-1"></a>                  einheit: <span class="bu">str</span>, ertragsname: <span class="bu">str</span>):</span>
-<span id="cb155-168"><a href="#cb155-168" aria-hidden="true" tabindex="-1"></a>    anteile, cvar, var <span class="op">=</span> optimiere_cvar(verluste, ertrag, mindestertrag)</span>
-<span id="cb155-169"><a href="#cb155-169" aria-hidden="true" tabindex="-1"></a>    mittel <span class="op">=</span> <span class="bu">float</span>((verluste <span class="op">@</span> anteile).mean())</span>
-<span id="cb155-170"><a href="#cb155-170" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;  </span><span class="sc">{</span>titel<span class="sc">}</span><span class="ss">&quot;</span>)</span>
-<span id="cb155-171"><a href="#cb155-171" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;    VaR  </span><span class="sc">{</span>ALPHA<span class="sc">:.0%}</span><span class="ss">: </span><span class="sc">{</span>var<span class="sc">:8.3f}</span><span class="ss"> </span><span class="sc">{</span>einheit<span class="sc">}</span><span class="ss">&quot;</span>)</span>
-<span id="cb155-172"><a href="#cb155-172" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;    CVaR </span><span class="sc">{</span>ALPHA<span class="sc">:.0%}</span><span class="ss">: </span><span class="sc">{</span>cvar<span class="sc">:8.3f}</span><span class="ss"> </span><span class="sc">{</span>einheit<span class="sc">}</span><span class="ss">      &quot;</span></span>
-<span id="cb155-173"><a href="#cb155-173" aria-hidden="true" tabindex="-1"></a>          <span class="ss">f&quot;(Mittelwert ueber alle Szenarien: </span><span class="sc">{</span>mittel<span class="sc">:.3f}</span><span class="ss">)&quot;</span>)</span>
-<span id="cb155-174"><a href="#cb155-174" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;    </span><span class="sc">{</span>ertragsname<span class="sc">}</span><span class="ss">: </span><span class="sc">{</span><span class="bu">float</span>(ertrag <span class="op">@</span> anteile)<span class="sc">:.3f}</span><span class="ss">&quot;</span>)</span>
-<span id="cb155-175"><a href="#cb155-175" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;    Aufteilung:&quot;</span>)</span>
-<span id="cb155-176"><a href="#cb155-176" aria-hidden="true" tabindex="-1"></a>    <span class="cf">for</span> name, anteil <span class="kw">in</span> <span class="bu">zip</span>(namen, anteile):</span>
-<span id="cb155-177"><a href="#cb155-177" aria-hidden="true" tabindex="-1"></a>        balken <span class="op">=</span> <span class="st">&quot;#&quot;</span> <span class="op">*</span> <span class="bu">int</span>(<span class="bu">round</span>(anteil <span class="op">*</span> <span class="dv">40</span>))</span>
-<span id="cb155-178"><a href="#cb155-178" aria-hidden="true" tabindex="-1"></a>        grenze <span class="op">=</span> <span class="st">&quot;  &lt;- an der Streuungsgrenze&quot;</span> <span class="cf">if</span> anteil <span class="op">&gt;</span> MAX_ANTEIL <span class="op">-</span> <span class="fl">1e-4</span> <span class="cf">else</span> <span class="st">&quot;&quot;</span></span>
-<span id="cb155-179"><a href="#cb155-179" aria-hidden="true" tabindex="-1"></a>        <span class="bu">print</span>(<span class="ss">f&quot;      </span><span class="sc">{</span>name<span class="sc">:&lt;18}</span><span class="ss"> </span><span class="sc">{</span>anteil<span class="sc">:6.1%}</span><span class="ss">  </span><span class="sc">{</span>balken<span class="sc">}{</span>grenze<span class="sc">}</span><span class="ss">&quot;</span>)</span>
-<span id="cb155-180"><a href="#cb155-180" aria-hidden="true" tabindex="-1"></a>    <span class="cf">return</span> anteile</span>
-<span id="cb155-181"><a href="#cb155-181" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb155-182"><a href="#cb155-182" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb155-183"><a href="#cb155-183" aria-hidden="true" tabindex="-1"></a><span class="cf">if</span> <span class="va">__name__</span> <span class="op">==</span> <span class="st">&quot;__main__&quot;</span>:</span>
-<span id="cb155-184"><a href="#cb155-184" aria-hidden="true" tabindex="-1"></a>    rng <span class="op">=</span> np.random.default_rng(SAAT)</span>
-<span id="cb155-185"><a href="#cb155-185" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb155-186"><a href="#cb155-186" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;=&quot;</span> <span class="op">*</span> <span class="dv">80</span>)</span>
-<span id="cb155-187"><a href="#cb155-187" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;  DIESELBE STRUKTUR, ZWEI WELTEN&quot;</span>)</span>
-<span id="cb155-188"><a href="#cb155-188" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;=&quot;</span> <span class="op">*</span> <span class="dv">80</span>)</span>
-<span id="cb155-189"><a href="#cb155-189" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb155-190"><a href="#cb155-190" aria-hidden="true" tabindex="-1"></a>    <span class="co"># --- Teil 1 ----------------------------------------------------------</span></span>
-<span id="cb155-191"><a href="#cb155-191" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;</span><span class="ch">\n</span><span class="st">1. Allokation als LP - EINE Klasse, EIN Modellbauer</span><span class="ch">\n</span><span class="st">&quot;</span>)</span>
-<span id="cb155-192"><a href="#cb155-192" aria-hidden="true" tabindex="-1"></a>    berichte_allokation(<span class="st">&quot;Werkstatt: Produktionsprogramm&quot;</span>, schreinerei(),</span>
-<span id="cb155-193"><a href="#cb155-193" aria-hidden="true" tabindex="-1"></a>                        <span class="st">&quot;Stueck&quot;</span>, <span class="st">&quot;Deckungsbeitrag&quot;</span>)</span>
-<span id="cb155-194"><a href="#cb155-194" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>()</span>
-<span id="cb155-195"><a href="#cb155-195" aria-hidden="true" tabindex="-1"></a>    berichte_allokation(<span class="st">&quot;Depot: Anlageaufteilung&quot;</span>, depot(),</span>
-<span id="cb155-196"><a href="#cb155-196" aria-hidden="true" tabindex="-1"></a>                        <span class="st">&quot;Tsd.  &quot;</span>, <span class="st">&quot;Erwarteter Ertrag&quot;</span>)</span>
-<span id="cb155-197"><a href="#cb155-197" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb155-198"><a href="#cb155-198" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;</span><span class="ch">\n</span><span class="st">  Beide Ausgaben stammen aus derselben Funktion &quot;</span></span>
-<span id="cb155-199"><a href="#cb155-199" aria-hidden="true" tabindex="-1"></a>          <span class="st">&quot;&#39;berichte_allokation&#39;.&quot;</span>)</span>
-<span id="cb155-200"><a href="#cb155-200" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;  Ausgetauscht wurden nur die Daten und die Beschriftungen -&quot;</span>)</span>
-<span id="cb155-201"><a href="#cb155-201" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;  keine Zeile Modellcode.&quot;</span>)</span>
-<span id="cb155-202"><a href="#cb155-202" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>()</span>
-<span id="cb155-203"><a href="#cb155-203" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;  Lesen Sie die Schattenpreise nebeneinander: In der Werkstatt sagt&quot;</span>)</span>
-<span id="cb155-204"><a href="#cb155-204" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;  er, was eine zusaetzliche Montagestunde wert waere. Im Depot sagt&quot;</span>)</span>
-<span id="cb155-205"><a href="#cb155-205" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;  dieselbe Zahl, was eine zusaetzliche Einheit Risikobudget wert&quot;</span>)</span>
-<span id="cb155-206"><a href="#cb155-206" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;  waere - der PREIS DES RISIKOS. Das ist kein Sprachbild, sondern&quot;</span>)</span>
-<span id="cb155-207"><a href="#cb155-207" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;  derselbe Dualwert derselben Nebenbedingung.&quot;</span>)</span>
-<span id="cb155-208"><a href="#cb155-208" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb155-209"><a href="#cb155-209" aria-hidden="true" tabindex="-1"></a>    <span class="co"># --- Teil 2 ----------------------------------------------------------</span></span>
-<span id="cb155-210"><a href="#cb155-210" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;</span><span class="ch">\n</span><span class="st">&quot;</span> <span class="op">+</span> <span class="st">&quot;-&quot;</span> <span class="op">*</span> <span class="dv">80</span>)</span>
-<span id="cb155-211"><a href="#cb155-211" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;2. Absicherung gegen den schlechtesten Fall - EINE CVaR-Funktion</span><span class="ch">\n</span><span class="st">&quot;</span>)</span>
-<span id="cb155-212"><a href="#cb155-212" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb155-213"><a href="#cb155-213" aria-hidden="true" tabindex="-1"></a>    kurse, rendite, anlagen <span class="op">=</span> kursszenarien(rng)</span>
-<span id="cb155-214"><a href="#cb155-214" aria-hidden="true" tabindex="-1"></a>    anteile_depot <span class="op">=</span> berichte_cvar(</span>
-<span id="cb155-215"><a href="#cb155-215" aria-hidden="true" tabindex="-1"></a>                  <span class="st">&quot;Depot: die schlechtesten 5 </span><span class="sc">% d</span><span class="st">er Handelstage&quot;</span>,</span>
-<span id="cb155-216"><a href="#cb155-216" aria-hidden="true" tabindex="-1"></a>                  kurse, rendite, anlagen, <span class="fl">5.5</span>,</span>
-<span id="cb155-217"><a href="#cb155-217" aria-hidden="true" tabindex="-1"></a>                  <span class="st">&quot;% je Tag    &quot;</span>, <span class="st">&quot;Erwartete Jahresrendite (%)&quot;</span>)</span>
-<span id="cb155-218"><a href="#cb155-218" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>()</span>
-<span id="cb155-219"><a href="#cb155-219" aria-hidden="true" tabindex="-1"></a>    lieferung, zuverlaessig, lieferanten <span class="op">=</span> lieferszenarien(rng)</span>
-<span id="cb155-220"><a href="#cb155-220" aria-hidden="true" tabindex="-1"></a>    anteile_einkauf <span class="op">=</span> berichte_cvar(<span class="st">&quot;Einkauf: die schlechtesten 5 </span><span class="sc">% d</span><span class="st">er Bestellungen&quot;</span>,</span>
-<span id="cb155-221"><a href="#cb155-221" aria-hidden="true" tabindex="-1"></a>                  lieferung, zuverlaessig, lieferanten, <span class="fl">0.945</span>,</span>
-<span id="cb155-222"><a href="#cb155-222" aria-hidden="true" tabindex="-1"></a>                  <span class="st">&quot;Tage Verzug  &quot;</span>, <span class="st">&quot;Mittlere Zuverlaessigkeit&quot;</span>)</span>
-<span id="cb155-223"><a href="#cb155-223" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb155-224"><a href="#cb155-224" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;</span><span class="ch">\n</span><span class="st">  Auch hier: eine Funktion, zwei Aufrufe. Die Zielfunktion&quot;</span>)</span>
-<span id="cb155-225"><a href="#cb155-225" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;  interessiert sich nicht dafuer, ob in der Matrix Prozentpunkte&quot;</span>)</span>
-<span id="cb155-226"><a href="#cb155-226" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;  oder Tage stehen.&quot;</span>)</span>
-<span id="cb155-227"><a href="#cb155-227" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>()</span>
-<span id="cb155-228"><a href="#cb155-228" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;  Interessant ist, WO die Streuungsgrenze von </span><span class="sc">{</span>MAX_ANTEIL<span class="sc">:.0%}</span><span class="ss"> bindet:&quot;</span>)</span>
-<span id="cb155-229"><a href="#cb155-229" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;    Depot   : </span><span class="sc">{</span>(anteile_depot <span class="op">&gt;</span> MAX_ANTEIL <span class="op">-</span> <span class="fl">1e-4</span>)<span class="sc">.</span><span class="bu">sum</span>()<span class="sc">}</span><span class="ss"> von &quot;</span></span>
-<span id="cb155-230"><a href="#cb155-230" aria-hidden="true" tabindex="-1"></a>          <span class="ss">f&quot;</span><span class="sc">{</span><span class="bu">len</span>(anteile_depot)<span class="sc">}</span><span class="ss"> Posten am Anschlag&quot;</span>)</span>
-<span id="cb155-231"><a href="#cb155-231" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;    Einkauf : </span><span class="sc">{</span>(anteile_einkauf <span class="op">&gt;</span> MAX_ANTEIL <span class="op">-</span> <span class="fl">1e-4</span>)<span class="sc">.</span><span class="bu">sum</span>()<span class="sc">}</span><span class="ss"> von &quot;</span></span>
-<span id="cb155-232"><a href="#cb155-232" aria-hidden="true" tabindex="-1"></a>          <span class="ss">f&quot;</span><span class="sc">{</span><span class="bu">len</span>(anteile_einkauf)<span class="sc">}</span><span class="ss"> Posten am Anschlag&quot;</span>)</span>
-<span id="cb155-233"><a href="#cb155-233" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>()</span>
-<span id="cb155-234"><a href="#cb155-234" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;  Im Einkauf zieht es die Loesung an den sicheren Lokalzulieferer,&quot;</span>)</span>
-<span id="cb155-235"><a href="#cb155-235" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;  bis die Grenze sie stoppt. Im Depot nicht - dort verhindert die&quot;</span>)</span>
-<span id="cb155-236"><a href="#cb155-236" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;  Mindestrendite, dass alles in Anleihen wandert. Zwei verschiedene&quot;</span>)</span>
-<span id="cb155-237"><a href="#cb155-237" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;  Bremsen also, und sie stehen an verschiedenen Stellen des Modells:&quot;</span>)</span>
-<span id="cb155-238"><a href="#cb155-238" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;  einmal in einer Nebenbedingung ueber die Anteile, einmal in einer&quot;</span>)</span>
-<span id="cb155-239"><a href="#cb155-239" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;  ueber den Ertrag. Wer eine Struktur uebertraegt, uebertraegt eben&quot;</span>)</span>
-<span id="cb155-240"><a href="#cb155-240" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;  nicht automatisch mit, WELCHE Bedingung am Ende bindet.&quot;</span>)</span>
-<span id="cb155-241"><a href="#cb155-241" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb155-242"><a href="#cb155-242" aria-hidden="true" tabindex="-1"></a>    <span class="co"># --- Teil 3: Der ehrliche Teil ---------------------------------------</span></span>
-<span id="cb155-243"><a href="#cb155-243" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;</span><span class="ch">\n</span><span class="st">&quot;</span> <span class="op">+</span> <span class="st">&quot;=&quot;</span> <span class="op">*</span> <span class="dv">80</span>)</span>
-<span id="cb155-244"><a href="#cb155-244" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;  WAS NICHT HINUEBERREICHT&quot;</span>)</span>
-<span id="cb155-245"><a href="#cb155-245" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;=&quot;</span> <span class="op">*</span> <span class="dv">80</span>)</span>
-<span id="cb155-246"><a href="#cb155-246" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;Die Struktur traegt. Drei Unterschiede tragen NICHT mit, und wer sie&quot;</span>)</span>
-<span id="cb155-247"><a href="#cb155-247" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;uebersieht, macht aus einer nuetzlichen Analogie einen Fehler:&quot;</span>)</span>
-<span id="cb155-248"><a href="#cb155-248" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>()</span>
-<span id="cb155-249"><a href="#cb155-249" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;1. WOHER DIE ZAHLEN KOMMEN.&quot;</span>)</span>
-<span id="cb155-250"><a href="#cb155-250" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;   In der Werkstatt ist der Verbrauch je Tisch gemessen - drei&quot;</span>)</span>
-<span id="cb155-251"><a href="#cb155-251" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;   Montagestunden sind drei Montagestunden. Im Depot ist die&quot;</span>)</span>
-<span id="cb155-252"><a href="#cb155-252" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;   erwartete Rendite GESCHAETZT, und zwar mit einem Fehler, der&quot;</span>)</span>
-<span id="cb155-253"><a href="#cb155-253" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;   groesser sein kann als die Unterschiede zwischen den Anlagen&quot;</span>)</span>
-<span id="cb155-254"><a href="#cb155-254" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;   (Kapitel Markowitz, Renditeschaetzung_Falle.py). Dieselbe&quot;</span>)</span>
-<span id="cb155-255"><a href="#cb155-255" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;   Optimierung ist im einen Fall Planung und im anderen&quot;</span>)</span>
-<span id="cb155-256"><a href="#cb155-256" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;   Fehlerverstaerkung.&quot;</span>)</span>
-<span id="cb155-257"><a href="#cb155-257" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>()</span>
-<span id="cb155-258"><a href="#cb155-258" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;2. OB DIE VERGANGENHEIT ETWAS UEBER DIE ZUKUNFT SAGT.&quot;</span>)</span>
-<span id="cb155-259"><a href="#cb155-259" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;   Lieferzeiten haben physikalische Ursachen: Entfernung, Zoll,&quot;</span>)</span>
-<span id="cb155-260"><a href="#cb155-260" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;   Kapazitaet. Sie aendern sich langsam und nachvollziehbar.&quot;</span>)</span>
-<span id="cb155-261"><a href="#cb155-261" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;   Kursrenditen entstehen aus dem Verhalten von Marktteilnehmern,&quot;</span>)</span>
-<span id="cb155-262"><a href="#cb155-262" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;   die selbst auf Modelle reagieren - dort verschwindet ein&quot;</span>)</span>
-<span id="cb155-263"><a href="#cb155-263" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;   erkanntes Muster oft genau deshalb, weil es erkannt wurde&quot;</span>)</span>
-<span id="cb155-264"><a href="#cb155-264" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;   (Kapitel Handelsmaschine, Data_Snooping.py).&quot;</span>)</span>
-<span id="cb155-265"><a href="#cb155-265" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>()</span>
-<span id="cb155-266"><a href="#cb155-266" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;3. OB TEILBARKEIT ERLAUBT IST.&quot;</span>)</span>
-<span id="cb155-267"><a href="#cb155-267" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;   37,4 </span><span class="sc">% e</span><span class="st">ines Aktienfonds sind ein normaler Auftrag. 37,4 </span><span class="sc">% e</span><span class="st">ines&quot;</span>)</span>
-<span id="cb155-268"><a href="#cb155-268" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;   Lieferanten sind es nicht - Vertraege, Mindestabnahmen und&quot;</span>)</span>
-<span id="cb155-269"><a href="#cb155-269" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;   Ruestzeiten machen Einkaufsentscheidungen ganzzahlig. Genau&quot;</span>)</span>
-<span id="cb155-270"><a href="#cb155-270" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;   deshalb ist Teil II voller MILP und Teil V fast frei davon.&quot;</span>)</span>
-<span id="cb155-271"><a href="#cb155-271" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>()</span>
-<span id="cb155-272"><a href="#cb155-272" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;Die Bruecke traegt also die MODELLE, nicht die Annahmen. Wer sie&quot;</span>)</span>
-<span id="cb155-273"><a href="#cb155-273" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;benutzt, spart sich das Lernen der Methoden - nicht das Nachdenken&quot;</span>)</span>
-<span id="cb155-274"><a href="#cb155-274" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;ueber die Daten.&quot;</span>)</span>
-<span id="cb155-275"><a href="#cb155-275" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;=&quot;</span> <span class="op">*</span> <span class="dv">80</span>)</span></code></pre></div>
+<div class="sourceCode" id="cb157"><pre class="sourceCode python"><code class="sourceCode python"><span id="cb157-1"><a href="#cb157-1" aria-hidden="true" tabindex="-1"></a><span class="co">#!/usr/bin/env python3</span></span>
+<span id="cb157-2"><a href="#cb157-2" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb157-3"><a href="#cb157-3" aria-hidden="true" tabindex="-1"></a><span class="co"># Strukturbruecke.py</span></span>
+<span id="cb157-4"><a href="#cb157-4" aria-hidden="true" tabindex="-1"></a><span class="co">&quot;&quot;&quot;</span></span>
+<span id="cb157-5"><a href="#cb157-5" aria-hidden="true" tabindex="-1"></a><span class="co">Kapitel Bruecke: Derselbe Code, zwei Welten - der Beweis statt der Behauptung.</span></span>
+<span id="cb157-6"><a href="#cb157-6" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb157-7"><a href="#cb157-7" aria-hidden="true" tabindex="-1"></a><span class="co">Der Teil-Auftakt stellt eine Tabelle auf: &quot;Ressourcen auf Produkte verteilen&quot;</span></span>
+<span id="cb157-8"><a href="#cb157-8" aria-hidden="true" tabindex="-1"></a><span class="co">entspreche &quot;Kapital auf Anlagen verteilen&quot;, &quot;gegen den Worst Case absichern&quot;</span></span>
+<span id="cb157-9"><a href="#cb157-9" aria-hidden="true" tabindex="-1"></a><span class="co">entspreche &quot;Absicherung gegen Kursabstuerze&quot;. Solche Tabellen stehen in vielen</span></span>
+<span id="cb157-10"><a href="#cb157-10" aria-hidden="true" tabindex="-1"></a><span class="co">Buechern. Sie sind billig - und man kann sie pruefen.</span></span>
+<span id="cb157-11"><a href="#cb157-11" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb157-12"><a href="#cb157-12" aria-hidden="true" tabindex="-1"></a><span class="co">Dieses Programm prueft sie. Es fuettert zweimal DENSELBEN Code mit Daten aus</span></span>
+<span id="cb157-13"><a href="#cb157-13" aria-hidden="true" tabindex="-1"></a><span class="co">zwei Welten und zeigt die Ergebnisse nebeneinander:</span></span>
+<span id="cb157-14"><a href="#cb157-14" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb157-15"><a href="#cb157-15" aria-hidden="true" tabindex="-1"></a><span class="co">  1. Die Allokation als LP. Das Domaenenmodell aus or_kern.py, einmal mit einer</span></span>
+<span id="cb157-16"><a href="#cb157-16" aria-hidden="true" tabindex="-1"></a><span class="co">     Schreinerei (Montagestunden, Plattenmaterial) und einmal mit einem Depot</span></span>
+<span id="cb157-17"><a href="#cb157-17" aria-hidden="true" tabindex="-1"></a><span class="co">     (Kapital, Risikobudget). Gleiche Klasse, gleicher Modellbauer, gleiche</span></span>
+<span id="cb157-18"><a href="#cb157-18" aria-hidden="true" tabindex="-1"></a><span class="co">     Abnahmepruefung - und der Schattenpreis heisst in der einen Welt</span></span>
+<span id="cb157-19"><a href="#cb157-19" aria-hidden="true" tabindex="-1"></a><span class="co">     &quot;Wert einer zusaetzlichen Montagestunde&quot; und in der anderen &quot;Preis des</span></span>
+<span id="cb157-20"><a href="#cb157-20" aria-hidden="true" tabindex="-1"></a><span class="co">     Risikos&quot;.</span></span>
+<span id="cb157-21"><a href="#cb157-21" aria-hidden="true" tabindex="-1"></a><span class="co">  2. Die Absicherung gegen den schlechtesten Fall als CVaR. EINE Funktion,</span></span>
+<span id="cb157-22"><a href="#cb157-22" aria-hidden="true" tabindex="-1"></a><span class="co">     einmal mit Kursrenditen und einmal mit Lieferverzuegen.</span></span>
+<span id="cb157-23"><a href="#cb157-23" aria-hidden="true" tabindex="-1"></a><span class="co">  3. Was NICHT hinueberreicht. Der ehrliche Teil: Drei Unterschiede, die die</span></span>
+<span id="cb157-24"><a href="#cb157-24" aria-hidden="true" tabindex="-1"></a><span class="co">     Analogie begrenzen - und die man kennen muss, bevor man Methoden aus</span></span>
+<span id="cb157-25"><a href="#cb157-25" aria-hidden="true" tabindex="-1"></a><span class="co">     der einen Welt in die andere traegt.</span></span>
+<span id="cb157-26"><a href="#cb157-26" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb157-27"><a href="#cb157-27" aria-hidden="true" tabindex="-1"></a><span class="co">ZUR SOLVERWAHL: Teil 1 benutzt &#39;loese_mit_scipy&#39; und nicht &#39;loese_mit_glop&#39;.</span></span>
+<span id="cb157-28"><a href="#cb157-28" aria-hidden="true" tabindex="-1"></a><span class="co">Das ist kein Zufall - CVXPY laedt fuer Teil 2 highspy, und ortools vertraegt</span></span>
+<span id="cb157-29"><a href="#cb157-29" aria-hidden="true" tabindex="-1"></a><span class="co">sich damit nicht im selben Prozess (Kapitel Oekosystem). Wer hier GLOP nimmt,</span></span>
+<span id="cb157-30"><a href="#cb157-30" aria-hidden="true" tabindex="-1"></a><span class="co">bekommt beim cvxpy-Import eine Fehlermeldung ueber ein &#39;undefined symbol&#39;.</span></span>
+<span id="cb157-31"><a href="#cb157-31" aria-hidden="true" tabindex="-1"></a><span class="co">Genau deshalb laedt or_kern.py seine Solver erst beim Aufruf.</span></span>
+<span id="cb157-32"><a href="#cb157-32" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb157-33"><a href="#cb157-33" aria-hidden="true" tabindex="-1"></a><span class="co">Benoetigt: numpy, cvxpy, scipy und pydantic (ueber or_kern)</span></span>
+<span id="cb157-34"><a href="#cb157-34" aria-hidden="true" tabindex="-1"></a><span class="co">&quot;&quot;&quot;</span></span>
+<span id="cb157-35"><a href="#cb157-35" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb157-36"><a href="#cb157-36" aria-hidden="true" tabindex="-1"></a><span class="im">from</span> __future__ <span class="im">import</span> annotations</span>
+<span id="cb157-37"><a href="#cb157-37" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb157-38"><a href="#cb157-38" aria-hidden="true" tabindex="-1"></a><span class="im">import</span> numpy <span class="im">as</span> np</span>
+<span id="cb157-39"><a href="#cb157-39" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb157-40"><a href="#cb157-40" aria-hidden="true" tabindex="-1"></a><span class="im">from</span> or_kern <span class="im">import</span> (Produkt, Produktionsproblem, loese_mit_scipy,</span>
+<span id="cb157-41"><a href="#cb157-41" aria-hidden="true" tabindex="-1"></a>                     pruefe_loesung)</span>
+<span id="cb157-42"><a href="#cb157-42" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb157-43"><a href="#cb157-43" aria-hidden="true" tabindex="-1"></a>SAAT <span class="op">=</span> <span class="dv">7</span></span>
+<span id="cb157-44"><a href="#cb157-44" aria-hidden="true" tabindex="-1"></a>SZENARIEN <span class="op">=</span> <span class="dv">500</span></span>
+<span id="cb157-45"><a href="#cb157-45" aria-hidden="true" tabindex="-1"></a>ALPHA <span class="op">=</span> <span class="fl">0.95</span>              <span class="co"># die schlechtesten 5 % der Faelle</span></span>
+<span id="cb157-46"><a href="#cb157-46" aria-hidden="true" tabindex="-1"></a>MAX_ANTEIL <span class="op">=</span> <span class="fl">0.40</span>         <span class="co"># Streuungsgebot in beiden Welten</span></span>
+<span id="cb157-47"><a href="#cb157-47" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb157-48"><a href="#cb157-48" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb157-49"><a href="#cb157-49" aria-hidden="true" tabindex="-1"></a><span class="co"># --- Teil 1: Dieselbe Klasse, zwei Welten ----------------------------------</span></span>
+<span id="cb157-50"><a href="#cb157-50" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb157-51"><a href="#cb157-51" aria-hidden="true" tabindex="-1"></a><span class="kw">def</span> schreinerei() <span class="op">-&gt;</span> Produktionsproblem:</span>
+<span id="cb157-52"><a href="#cb157-52" aria-hidden="true" tabindex="-1"></a>    <span class="co">&quot;&quot;&quot;Montagestunden und Plattenmaterial auf Tische und Stuehle verteilen.&quot;&quot;&quot;</span></span>
+<span id="cb157-53"><a href="#cb157-53" aria-hidden="true" tabindex="-1"></a>    <span class="cf">return</span> Produktionsproblem(</span>
+<span id="cb157-54"><a href="#cb157-54" aria-hidden="true" tabindex="-1"></a>        produkte<span class="op">=</span>[</span>
+<span id="cb157-55"><a href="#cb157-55" aria-hidden="true" tabindex="-1"></a>            Produkt(name<span class="op">=</span><span class="st">&quot;Tisch&quot;</span>, deckungsbeitrag<span class="op">=</span><span class="fl">240.0</span>,</span>
+<span id="cb157-56"><a href="#cb157-56" aria-hidden="true" tabindex="-1"></a>                    verbrauch<span class="op">=</span>{<span class="st">&quot;Montagestunden&quot;</span>: <span class="fl">3.0</span>, <span class="st">&quot;Plattenmaterial&quot;</span>: <span class="fl">6.0</span>}),</span>
+<span id="cb157-57"><a href="#cb157-57" aria-hidden="true" tabindex="-1"></a>            Produkt(name<span class="op">=</span><span class="st">&quot;Stuhl&quot;</span>, deckungsbeitrag<span class="op">=</span><span class="fl">60.0</span>,</span>
+<span id="cb157-58"><a href="#cb157-58" aria-hidden="true" tabindex="-1"></a>                    verbrauch<span class="op">=</span>{<span class="st">&quot;Montagestunden&quot;</span>: <span class="fl">1.0</span>, <span class="st">&quot;Plattenmaterial&quot;</span>: <span class="fl">1.0</span>}),</span>
+<span id="cb157-59"><a href="#cb157-59" aria-hidden="true" tabindex="-1"></a>            Produkt(name<span class="op">=</span><span class="st">&quot;Regal&quot;</span>, deckungsbeitrag<span class="op">=</span><span class="fl">130.0</span>,</span>
+<span id="cb157-60"><a href="#cb157-60" aria-hidden="true" tabindex="-1"></a>                    verbrauch<span class="op">=</span>{<span class="st">&quot;Montagestunden&quot;</span>: <span class="fl">2.0</span>, <span class="st">&quot;Plattenmaterial&quot;</span>: <span class="fl">4.0</span>}),</span>
+<span id="cb157-61"><a href="#cb157-61" aria-hidden="true" tabindex="-1"></a>        ],</span>
+<span id="cb157-62"><a href="#cb157-62" aria-hidden="true" tabindex="-1"></a>        kapazitaeten<span class="op">=</span>{<span class="st">&quot;Montagestunden&quot;</span>: <span class="fl">150.0</span>, <span class="st">&quot;Plattenmaterial&quot;</span>: <span class="fl">240.0</span>})</span>
+<span id="cb157-63"><a href="#cb157-63" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb157-64"><a href="#cb157-64" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb157-65"><a href="#cb157-65" aria-hidden="true" tabindex="-1"></a><span class="kw">def</span> depot() <span class="op">-&gt;</span> Produktionsproblem:</span>
+<span id="cb157-66"><a href="#cb157-66" aria-hidden="true" tabindex="-1"></a>    <span class="co">&quot;&quot;&quot;Kapital und Risikobudget auf Anlageklassen verteilen.</span></span>
+<span id="cb157-67"><a href="#cb157-67" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb157-68"><a href="#cb157-68" aria-hidden="true" tabindex="-1"></a><span class="co">    Eine &quot;Einheit&quot; ist hier 1.000 EUR Anlagesumme. Der Deckungsbeitrag ist der</span></span>
+<span id="cb157-69"><a href="#cb157-69" aria-hidden="true" tabindex="-1"></a><span class="co">    erwartete Jahresertrag dieser Einheit, der Verbrauch die beanspruchte</span></span>
+<span id="cb157-70"><a href="#cb157-70" aria-hidden="true" tabindex="-1"></a><span class="co">    Kapital- und Risikomenge. Das ist keine Analogie, sondern buchstaeblich</span></span>
+<span id="cb157-71"><a href="#cb157-71" aria-hidden="true" tabindex="-1"></a><span class="co">    dasselbe Modell - deshalb passt es in dieselbe Klasse.</span></span>
+<span id="cb157-72"><a href="#cb157-72" aria-hidden="true" tabindex="-1"></a><span class="co">    &quot;&quot;&quot;</span></span>
+<span id="cb157-73"><a href="#cb157-73" aria-hidden="true" tabindex="-1"></a>    <span class="cf">return</span> Produktionsproblem(</span>
+<span id="cb157-74"><a href="#cb157-74" aria-hidden="true" tabindex="-1"></a>        produkte<span class="op">=</span>[</span>
+<span id="cb157-75"><a href="#cb157-75" aria-hidden="true" tabindex="-1"></a>            Produkt(name<span class="op">=</span><span class="st">&quot;Aktien Welt&quot;</span>, deckungsbeitrag<span class="op">=</span><span class="fl">75.0</span>,</span>
+<span id="cb157-76"><a href="#cb157-76" aria-hidden="true" tabindex="-1"></a>                    verbrauch<span class="op">=</span>{<span class="st">&quot;Kapital (Tsd. EUR)&quot;</span>: <span class="fl">1.0</span>, <span class="st">&quot;Risikobudget&quot;</span>: <span class="fl">1.00</span>}),</span>
+<span id="cb157-77"><a href="#cb157-77" aria-hidden="true" tabindex="-1"></a>            Produkt(name<span class="op">=</span><span class="st">&quot;Anleihen&quot;</span>, deckungsbeitrag<span class="op">=</span><span class="fl">28.0</span>,</span>
+<span id="cb157-78"><a href="#cb157-78" aria-hidden="true" tabindex="-1"></a>                    verbrauch<span class="op">=</span>{<span class="st">&quot;Kapital (Tsd. EUR)&quot;</span>: <span class="fl">1.0</span>, <span class="st">&quot;Risikobudget&quot;</span>: <span class="fl">0.22</span>}),</span>
+<span id="cb157-79"><a href="#cb157-79" aria-hidden="true" tabindex="-1"></a>            Produkt(name<span class="op">=</span><span class="st">&quot;Immobilienfonds&quot;</span>, deckungsbeitrag<span class="op">=</span><span class="fl">46.0</span>,</span>
+<span id="cb157-80"><a href="#cb157-80" aria-hidden="true" tabindex="-1"></a>                    verbrauch<span class="op">=</span>{<span class="st">&quot;Kapital (Tsd. EUR)&quot;</span>: <span class="fl">1.0</span>, <span class="st">&quot;Risikobudget&quot;</span>: <span class="fl">0.55</span>}),</span>
+<span id="cb157-81"><a href="#cb157-81" aria-hidden="true" tabindex="-1"></a>        ],</span>
+<span id="cb157-82"><a href="#cb157-82" aria-hidden="true" tabindex="-1"></a>        kapazitaeten<span class="op">=</span>{<span class="st">&quot;Kapital (Tsd. EUR)&quot;</span>: <span class="fl">150.0</span>, <span class="st">&quot;Risikobudget&quot;</span>: <span class="fl">90.0</span>})</span>
+<span id="cb157-83"><a href="#cb157-83" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb157-84"><a href="#cb157-84" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb157-85"><a href="#cb157-85" aria-hidden="true" tabindex="-1"></a><span class="kw">def</span> berichte_allokation(titel: <span class="bu">str</span>, problem: Produktionsproblem,</span>
+<span id="cb157-86"><a href="#cb157-86" aria-hidden="true" tabindex="-1"></a>                        einheit: <span class="bu">str</span>, ertragsname: <span class="bu">str</span>) <span class="op">-&gt;</span> <span class="va">None</span>:</span>
+<span id="cb157-87"><a href="#cb157-87" aria-hidden="true" tabindex="-1"></a>    <span class="co">&quot;&quot;&quot;Ein Bericht fuer beide Welten - nur die Beschriftung wechselt.&quot;&quot;&quot;</span></span>
+<span id="cb157-88"><a href="#cb157-88" aria-hidden="true" tabindex="-1"></a>    loesung <span class="op">=</span> loese_mit_scipy(problem)</span>
+<span id="cb157-89"><a href="#cb157-89" aria-hidden="true" tabindex="-1"></a>    beanstandungen <span class="op">=</span> pruefe_loesung(problem, loesung)</span>
+<span id="cb157-90"><a href="#cb157-90" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb157-91"><a href="#cb157-91" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;  </span><span class="sc">{</span>titel<span class="sc">}</span><span class="ss">&quot;</span>)</span>
+<span id="cb157-92"><a href="#cb157-92" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;    </span><span class="sc">{</span>loesung<span class="sc">.</span>als_bericht()<span class="sc">}</span><span class="ss">&quot;</span>)</span>
+<span id="cb157-93"><a href="#cb157-93" aria-hidden="true" tabindex="-1"></a>    <span class="cf">for</span> produkt <span class="kw">in</span> problem.produkte:</span>
+<span id="cb157-94"><a href="#cb157-94" aria-hidden="true" tabindex="-1"></a>        <span class="bu">print</span>(<span class="ss">f&quot;      </span><span class="sc">{</span>produkt<span class="sc">.</span>name<span class="sc">:&lt;18}</span><span class="ss"> </span><span class="sc">{</span>loesung<span class="sc">.</span>werte[produkt.name]<span class="sc">:8.2f}</span><span class="ss"> </span><span class="sc">{</span>einheit<span class="sc">}</span><span class="ss">&quot;</span>)</span>
+<span id="cb157-95"><a href="#cb157-95" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;      </span><span class="sc">{</span>ertragsname<span class="sc">:&lt;18}</span><span class="ss"> </span><span class="sc">{</span>loesung<span class="sc">.</span>zielwert<span class="sc">:8.2f}</span><span class="ss"> EUR&quot;</span>)</span>
+<span id="cb157-96"><a href="#cb157-96" aria-hidden="true" tabindex="-1"></a>    <span class="cf">for</span> ressource, preis <span class="kw">in</span> loesung.schattenpreise.items():</span>
+<span id="cb157-97"><a href="#cb157-97" aria-hidden="true" tabindex="-1"></a>        <span class="bu">print</span>(<span class="ss">f&quot;      Schattenpreis </span><span class="sc">{</span>ressource<span class="sc">:&lt;24}</span><span class="ss"> </span><span class="sc">{</span>preis<span class="sc">:7.2f}</span><span class="ss"> EUR&quot;</span>)</span>
+<span id="cb157-98"><a href="#cb157-98" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;      Abnahmepruefung: &quot;</span></span>
+<span id="cb157-99"><a href="#cb157-99" aria-hidden="true" tabindex="-1"></a>          <span class="ss">f&quot;</span><span class="sc">{</span><span class="st">&#39;bestanden&#39;</span> <span class="cf">if</span> <span class="kw">not</span> beanstandungen <span class="cf">else</span> beanstandungen<span class="sc">}</span><span class="ss">&quot;</span>)</span>
+<span id="cb157-100"><a href="#cb157-100" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb157-101"><a href="#cb157-101" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb157-102"><a href="#cb157-102" aria-hidden="true" tabindex="-1"></a><span class="co"># --- Teil 2: Eine CVaR-Funktion, zwei Welten -------------------------------</span></span>
+<span id="cb157-103"><a href="#cb157-103" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb157-104"><a href="#cb157-104" aria-hidden="true" tabindex="-1"></a><span class="kw">def</span> optimiere_cvar(verluste: np.ndarray, ertrag: np.ndarray,</span>
+<span id="cb157-105"><a href="#cb157-105" aria-hidden="true" tabindex="-1"></a>                   mindestertrag: <span class="bu">float</span>, alpha: <span class="bu">float</span> <span class="op">=</span> ALPHA,</span>
+<span id="cb157-106"><a href="#cb157-106" aria-hidden="true" tabindex="-1"></a>                   max_anteil: <span class="bu">float</span> <span class="op">=</span> MAX_ANTEIL):</span>
+<span id="cb157-107"><a href="#cb157-107" aria-hidden="true" tabindex="-1"></a>    <span class="co">&quot;&quot;&quot;Minimiert den CVaR der Verluste unter einer Mindestertragsbedingung.</span></span>
+<span id="cb157-108"><a href="#cb157-108" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb157-109"><a href="#cb157-109" aria-hidden="true" tabindex="-1"></a><span class="co">    &#39;verluste&#39; hat die Form (Szenarien x Optionen) und enthaelt, was in</span></span>
+<span id="cb157-110"><a href="#cb157-110" aria-hidden="true" tabindex="-1"></a><span class="co">    Szenario s passiert, wenn eine Einheit in Option j steckt. Was ein</span></span>
+<span id="cb157-111"><a href="#cb157-111" aria-hidden="true" tabindex="-1"></a><span class="co">    &quot;Verlust&quot; ist, entscheidet allein die Einheit der Matrix: Prozentpunkte</span></span>
+<span id="cb157-112"><a href="#cb157-112" aria-hidden="true" tabindex="-1"></a><span class="co">    Kursverlust oder Tage Lieferverzug - die Formel sieht keinen Unterschied.</span></span>
+<span id="cb157-113"><a href="#cb157-113" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb157-114"><a href="#cb157-114" aria-hidden="true" tabindex="-1"></a><span class="co">    Das ist die Rockafellar-Uryasev-Formulierung aus dem Kapitel CVaR, hier</span></span>
+<span id="cb157-115"><a href="#cb157-115" aria-hidden="true" tabindex="-1"></a><span class="co">    ohne jede Aenderung wiederverwendet.</span></span>
+<span id="cb157-116"><a href="#cb157-116" aria-hidden="true" tabindex="-1"></a><span class="co">    &quot;&quot;&quot;</span></span>
+<span id="cb157-117"><a href="#cb157-117" aria-hidden="true" tabindex="-1"></a>    <span class="im">import</span> cvxpy <span class="im">as</span> cp</span>
+<span id="cb157-118"><a href="#cb157-118" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb157-119"><a href="#cb157-119" aria-hidden="true" tabindex="-1"></a>    anzahl_szenarien, anzahl_optionen <span class="op">=</span> verluste.shape</span>
+<span id="cb157-120"><a href="#cb157-120" aria-hidden="true" tabindex="-1"></a>    anteil <span class="op">=</span> cp.Variable(anzahl_optionen, nonneg<span class="op">=</span><span class="va">True</span>)</span>
+<span id="cb157-121"><a href="#cb157-121" aria-hidden="true" tabindex="-1"></a>    schwelle <span class="op">=</span> cp.Variable()                       <span class="co"># wird im Optimum zum VaR</span></span>
+<span id="cb157-122"><a href="#cb157-122" aria-hidden="true" tabindex="-1"></a>    ueberschuss <span class="op">=</span> cp.Variable(anzahl_szenarien, nonneg<span class="op">=</span><span class="va">True</span>)</span>
+<span id="cb157-123"><a href="#cb157-123" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb157-124"><a href="#cb157-124" aria-hidden="true" tabindex="-1"></a>    cvar <span class="op">=</span> schwelle <span class="op">+</span> (<span class="fl">1.0</span> <span class="op">/</span> (anzahl_szenarien <span class="op">*</span> (<span class="dv">1</span> <span class="op">-</span> alpha))) <span class="op">*</span> cp.<span class="bu">sum</span>(ueberschuss)</span>
+<span id="cb157-125"><a href="#cb157-125" aria-hidden="true" tabindex="-1"></a>    problem <span class="op">=</span> cp.Problem(</span>
+<span id="cb157-126"><a href="#cb157-126" aria-hidden="true" tabindex="-1"></a>        cp.Minimize(cvar),</span>
+<span id="cb157-127"><a href="#cb157-127" aria-hidden="true" tabindex="-1"></a>        [ueberschuss <span class="op">&gt;=</span> verluste <span class="op">@</span> anteil <span class="op">-</span> schwelle,</span>
+<span id="cb157-128"><a href="#cb157-128" aria-hidden="true" tabindex="-1"></a>         cp.<span class="bu">sum</span>(anteil) <span class="op">==</span> <span class="dv">1</span>,</span>
+<span id="cb157-129"><a href="#cb157-129" aria-hidden="true" tabindex="-1"></a>         anteil <span class="op">&lt;=</span> max_anteil,</span>
+<span id="cb157-130"><a href="#cb157-130" aria-hidden="true" tabindex="-1"></a>         ertrag <span class="op">@</span> anteil <span class="op">&gt;=</span> mindestertrag])</span>
+<span id="cb157-131"><a href="#cb157-131" aria-hidden="true" tabindex="-1"></a>    problem.solve()</span>
+<span id="cb157-132"><a href="#cb157-132" aria-hidden="true" tabindex="-1"></a>    <span class="cf">if</span> problem.status <span class="kw">not</span> <span class="kw">in</span> (<span class="st">&quot;optimal&quot;</span>, <span class="st">&quot;optimal_inaccurate&quot;</span>):</span>
+<span id="cb157-133"><a href="#cb157-133" aria-hidden="true" tabindex="-1"></a>        <span class="cf">raise</span> <span class="pp">SystemExit</span>(<span class="ss">f&quot;CVaR-Problem nicht loesbar: </span><span class="sc">{</span>problem<span class="sc">.</span>status<span class="sc">}</span><span class="ss">&quot;</span>)</span>
+<span id="cb157-134"><a href="#cb157-134" aria-hidden="true" tabindex="-1"></a>    <span class="cf">return</span> anteil.value, <span class="bu">float</span>(cvar.value), <span class="bu">float</span>(schwelle.value)</span>
+<span id="cb157-135"><a href="#cb157-135" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb157-136"><a href="#cb157-136" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb157-137"><a href="#cb157-137" aria-hidden="true" tabindex="-1"></a><span class="kw">def</span> kursszenarien(rng) <span class="op">-&gt;</span> <span class="bu">tuple</span>[np.ndarray, np.ndarray, <span class="bu">list</span>[<span class="bu">str</span>]]:</span>
+<span id="cb157-138"><a href="#cb157-138" aria-hidden="true" tabindex="-1"></a>    <span class="co">&quot;&quot;&quot;Taegliche Verluste (negative Renditen) von sechs Anlageklassen.&quot;&quot;&quot;</span></span>
+<span id="cb157-139"><a href="#cb157-139" aria-hidden="true" tabindex="-1"></a>    namen <span class="op">=</span> [<span class="st">&quot;Aktien Welt&quot;</span>, <span class="st">&quot;Aktien EU&quot;</span>, <span class="st">&quot;Schwellenlaender&quot;</span>,</span>
+<span id="cb157-140"><a href="#cb157-140" aria-hidden="true" tabindex="-1"></a>             <span class="st">&quot;Staatsanleihen&quot;</span>, <span class="st">&quot;Unternehmensanl.&quot;</span>, <span class="st">&quot;Rohstoffe&quot;</span>]</span>
+<span id="cb157-141"><a href="#cb157-141" aria-hidden="true" tabindex="-1"></a>    rendite_pa <span class="op">=</span> np.array([<span class="fl">0.080</span>, <span class="fl">0.065</span>, <span class="fl">0.110</span>, <span class="fl">0.025</span>, <span class="fl">0.045</span>, <span class="fl">0.070</span>])</span>
+<span id="cb157-142"><a href="#cb157-142" aria-hidden="true" tabindex="-1"></a>    schwankung <span class="op">=</span> np.array([<span class="fl">0.180</span>, <span class="fl">0.160</span>, <span class="fl">0.260</span>, <span class="fl">0.040</span>, <span class="fl">0.075</span>, <span class="fl">0.210</span>])</span>
+<span id="cb157-143"><a href="#cb157-143" aria-hidden="true" tabindex="-1"></a>    taeglich <span class="op">=</span> rng.normal(rendite_pa <span class="op">/</span> <span class="dv">252</span>, schwankung <span class="op">/</span> np.sqrt(<span class="dv">252</span>),</span>
+<span id="cb157-144"><a href="#cb157-144" aria-hidden="true" tabindex="-1"></a>                          (SZENARIEN, <span class="bu">len</span>(namen)))</span>
+<span id="cb157-145"><a href="#cb157-145" aria-hidden="true" tabindex="-1"></a>    <span class="cf">return</span> <span class="op">-</span>taeglich <span class="op">*</span> <span class="fl">100.0</span>, rendite_pa <span class="op">*</span> <span class="fl">100.0</span>, namen</span>
+<span id="cb157-146"><a href="#cb157-146" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb157-147"><a href="#cb157-147" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb157-148"><a href="#cb157-148" aria-hidden="true" tabindex="-1"></a><span class="kw">def</span> lieferszenarien(rng) <span class="op">-&gt;</span> <span class="bu">tuple</span>[np.ndarray, np.ndarray, <span class="bu">list</span>[<span class="bu">str</span>]]:</span>
+<span id="cb157-149"><a href="#cb157-149" aria-hidden="true" tabindex="-1"></a>    <span class="co">&quot;&quot;&quot;Lieferverzug in Tagen bei sechs Lieferanten.</span></span>
+<span id="cb157-150"><a href="#cb157-150" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb157-151"><a href="#cb157-151" aria-hidden="true" tabindex="-1"></a><span class="co">    Der Aufbau ist bewusst anders als bei den Kursen: Hier gibt es einen</span></span>
+<span id="cb157-152"><a href="#cb157-152" aria-hidden="true" tabindex="-1"></a><span class="co">    normalen Verzug UND seltene Totalausfaelle, die 14 Tage kosten. Das ist</span></span>
+<span id="cb157-153"><a href="#cb157-153" aria-hidden="true" tabindex="-1"></a><span class="co">    genau die Art fetter Raender, wegen der man in beiden Welten CVaR statt</span></span>
+<span id="cb157-154"><a href="#cb157-154" aria-hidden="true" tabindex="-1"></a><span class="co">    Standardabweichung benutzt.</span></span>
+<span id="cb157-155"><a href="#cb157-155" aria-hidden="true" tabindex="-1"></a><span class="co">    &quot;&quot;&quot;</span></span>
+<span id="cb157-156"><a href="#cb157-156" aria-hidden="true" tabindex="-1"></a>    namen <span class="op">=</span> [<span class="st">&quot;Nordwerk&quot;</span>, <span class="st">&quot;Sued-Metall&quot;</span>, <span class="st">&quot;Fernost A&quot;</span>, <span class="st">&quot;Lokalzulieferer&quot;</span>,</span>
+<span id="cb157-157"><a href="#cb157-157" aria-hidden="true" tabindex="-1"></a>             <span class="st">&quot;Fernost B&quot;</span>, <span class="st">&quot;Osteuropa&quot;</span>]</span>
+<span id="cb157-158"><a href="#cb157-158" aria-hidden="true" tabindex="-1"></a>    zuverlaessigkeit <span class="op">=</span> np.array([<span class="fl">0.94</span>, <span class="fl">0.97</span>, <span class="fl">0.90</span>, <span class="fl">0.99</span>, <span class="fl">0.92</span>, <span class="fl">0.95</span>])</span>
+<span id="cb157-159"><a href="#cb157-159" aria-hidden="true" tabindex="-1"></a>    verzugsstreuung <span class="op">=</span> np.array([<span class="fl">3.5</span>, <span class="fl">1.8</span>, <span class="fl">5.0</span>, <span class="fl">0.9</span>, <span class="fl">4.2</span>, <span class="fl">2.8</span>])</span>
+<span id="cb157-160"><a href="#cb157-160" aria-hidden="true" tabindex="-1"></a>    normaler_verzug <span class="op">=</span> np.maximum(<span class="fl">0.0</span>, rng.normal(<span class="fl">0.5</span>, <span class="fl">1.0</span>, (SZENARIEN, <span class="bu">len</span>(namen)))</span>
+<span id="cb157-161"><a href="#cb157-161" aria-hidden="true" tabindex="-1"></a>                                 <span class="op">*</span> verzugsstreuung)</span>
+<span id="cb157-162"><a href="#cb157-162" aria-hidden="true" tabindex="-1"></a>    totalausfall <span class="op">=</span> (rng.random((SZENARIEN, <span class="bu">len</span>(namen))) <span class="op">&gt;</span> zuverlaessigkeit) <span class="op">*</span> <span class="fl">14.0</span></span>
+<span id="cb157-163"><a href="#cb157-163" aria-hidden="true" tabindex="-1"></a>    <span class="cf">return</span> normaler_verzug <span class="op">+</span> totalausfall, zuverlaessigkeit, namen</span>
+<span id="cb157-164"><a href="#cb157-164" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb157-165"><a href="#cb157-165" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb157-166"><a href="#cb157-166" aria-hidden="true" tabindex="-1"></a><span class="kw">def</span> berichte_cvar(titel: <span class="bu">str</span>, verluste, ertrag, namen, mindestertrag,</span>
+<span id="cb157-167"><a href="#cb157-167" aria-hidden="true" tabindex="-1"></a>                  einheit: <span class="bu">str</span>, ertragsname: <span class="bu">str</span>):</span>
+<span id="cb157-168"><a href="#cb157-168" aria-hidden="true" tabindex="-1"></a>    anteile, cvar, var <span class="op">=</span> optimiere_cvar(verluste, ertrag, mindestertrag)</span>
+<span id="cb157-169"><a href="#cb157-169" aria-hidden="true" tabindex="-1"></a>    mittel <span class="op">=</span> <span class="bu">float</span>((verluste <span class="op">@</span> anteile).mean())</span>
+<span id="cb157-170"><a href="#cb157-170" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;  </span><span class="sc">{</span>titel<span class="sc">}</span><span class="ss">&quot;</span>)</span>
+<span id="cb157-171"><a href="#cb157-171" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;    VaR  </span><span class="sc">{</span>ALPHA<span class="sc">:.0%}</span><span class="ss">: </span><span class="sc">{</span>var<span class="sc">:8.3f}</span><span class="ss"> </span><span class="sc">{</span>einheit<span class="sc">}</span><span class="ss">&quot;</span>)</span>
+<span id="cb157-172"><a href="#cb157-172" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;    CVaR </span><span class="sc">{</span>ALPHA<span class="sc">:.0%}</span><span class="ss">: </span><span class="sc">{</span>cvar<span class="sc">:8.3f}</span><span class="ss"> </span><span class="sc">{</span>einheit<span class="sc">}</span><span class="ss">      &quot;</span></span>
+<span id="cb157-173"><a href="#cb157-173" aria-hidden="true" tabindex="-1"></a>          <span class="ss">f&quot;(Mittelwert ueber alle Szenarien: </span><span class="sc">{</span>mittel<span class="sc">:.3f}</span><span class="ss">)&quot;</span>)</span>
+<span id="cb157-174"><a href="#cb157-174" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;    </span><span class="sc">{</span>ertragsname<span class="sc">}</span><span class="ss">: </span><span class="sc">{</span><span class="bu">float</span>(ertrag <span class="op">@</span> anteile)<span class="sc">:.3f}</span><span class="ss">&quot;</span>)</span>
+<span id="cb157-175"><a href="#cb157-175" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;    Aufteilung:&quot;</span>)</span>
+<span id="cb157-176"><a href="#cb157-176" aria-hidden="true" tabindex="-1"></a>    <span class="cf">for</span> name, anteil <span class="kw">in</span> <span class="bu">zip</span>(namen, anteile):</span>
+<span id="cb157-177"><a href="#cb157-177" aria-hidden="true" tabindex="-1"></a>        balken <span class="op">=</span> <span class="st">&quot;#&quot;</span> <span class="op">*</span> <span class="bu">int</span>(<span class="bu">round</span>(anteil <span class="op">*</span> <span class="dv">40</span>))</span>
+<span id="cb157-178"><a href="#cb157-178" aria-hidden="true" tabindex="-1"></a>        grenze <span class="op">=</span> <span class="st">&quot;  &lt;- an der Streuungsgrenze&quot;</span> <span class="cf">if</span> anteil <span class="op">&gt;</span> MAX_ANTEIL <span class="op">-</span> <span class="fl">1e-4</span> <span class="cf">else</span> <span class="st">&quot;&quot;</span></span>
+<span id="cb157-179"><a href="#cb157-179" aria-hidden="true" tabindex="-1"></a>        <span class="bu">print</span>(<span class="ss">f&quot;      </span><span class="sc">{</span>name<span class="sc">:&lt;18}</span><span class="ss"> </span><span class="sc">{</span>anteil<span class="sc">:6.1%}</span><span class="ss">  </span><span class="sc">{</span>balken<span class="sc">}{</span>grenze<span class="sc">}</span><span class="ss">&quot;</span>)</span>
+<span id="cb157-180"><a href="#cb157-180" aria-hidden="true" tabindex="-1"></a>    <span class="cf">return</span> anteile</span>
+<span id="cb157-181"><a href="#cb157-181" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb157-182"><a href="#cb157-182" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb157-183"><a href="#cb157-183" aria-hidden="true" tabindex="-1"></a><span class="cf">if</span> <span class="va">__name__</span> <span class="op">==</span> <span class="st">&quot;__main__&quot;</span>:</span>
+<span id="cb157-184"><a href="#cb157-184" aria-hidden="true" tabindex="-1"></a>    rng <span class="op">=</span> np.random.default_rng(SAAT)</span>
+<span id="cb157-185"><a href="#cb157-185" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb157-186"><a href="#cb157-186" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;=&quot;</span> <span class="op">*</span> <span class="dv">80</span>)</span>
+<span id="cb157-187"><a href="#cb157-187" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;  DIESELBE STRUKTUR, ZWEI WELTEN&quot;</span>)</span>
+<span id="cb157-188"><a href="#cb157-188" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;=&quot;</span> <span class="op">*</span> <span class="dv">80</span>)</span>
+<span id="cb157-189"><a href="#cb157-189" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb157-190"><a href="#cb157-190" aria-hidden="true" tabindex="-1"></a>    <span class="co"># --- Teil 1 ----------------------------------------------------------</span></span>
+<span id="cb157-191"><a href="#cb157-191" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;</span><span class="ch">\n</span><span class="st">1. Allokation als LP - EINE Klasse, EIN Modellbauer</span><span class="ch">\n</span><span class="st">&quot;</span>)</span>
+<span id="cb157-192"><a href="#cb157-192" aria-hidden="true" tabindex="-1"></a>    berichte_allokation(<span class="st">&quot;Werkstatt: Produktionsprogramm&quot;</span>, schreinerei(),</span>
+<span id="cb157-193"><a href="#cb157-193" aria-hidden="true" tabindex="-1"></a>                        <span class="st">&quot;Stueck&quot;</span>, <span class="st">&quot;Deckungsbeitrag&quot;</span>)</span>
+<span id="cb157-194"><a href="#cb157-194" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>()</span>
+<span id="cb157-195"><a href="#cb157-195" aria-hidden="true" tabindex="-1"></a>    berichte_allokation(<span class="st">&quot;Depot: Anlageaufteilung&quot;</span>, depot(),</span>
+<span id="cb157-196"><a href="#cb157-196" aria-hidden="true" tabindex="-1"></a>                        <span class="st">&quot;Tsd.  &quot;</span>, <span class="st">&quot;Erwarteter Ertrag&quot;</span>)</span>
+<span id="cb157-197"><a href="#cb157-197" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb157-198"><a href="#cb157-198" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;</span><span class="ch">\n</span><span class="st">  Beide Ausgaben stammen aus derselben Funktion &quot;</span></span>
+<span id="cb157-199"><a href="#cb157-199" aria-hidden="true" tabindex="-1"></a>          <span class="st">&quot;&#39;berichte_allokation&#39;.&quot;</span>)</span>
+<span id="cb157-200"><a href="#cb157-200" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;  Ausgetauscht wurden nur die Daten und die Beschriftungen -&quot;</span>)</span>
+<span id="cb157-201"><a href="#cb157-201" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;  keine Zeile Modellcode.&quot;</span>)</span>
+<span id="cb157-202"><a href="#cb157-202" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>()</span>
+<span id="cb157-203"><a href="#cb157-203" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;  Lesen Sie die Schattenpreise nebeneinander: In der Werkstatt sagt&quot;</span>)</span>
+<span id="cb157-204"><a href="#cb157-204" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;  er, was eine zusaetzliche Montagestunde wert waere. Im Depot sagt&quot;</span>)</span>
+<span id="cb157-205"><a href="#cb157-205" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;  dieselbe Zahl, was eine zusaetzliche Einheit Risikobudget wert&quot;</span>)</span>
+<span id="cb157-206"><a href="#cb157-206" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;  waere - der PREIS DES RISIKOS. Das ist kein Sprachbild, sondern&quot;</span>)</span>
+<span id="cb157-207"><a href="#cb157-207" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;  derselbe Dualwert derselben Nebenbedingung.&quot;</span>)</span>
+<span id="cb157-208"><a href="#cb157-208" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb157-209"><a href="#cb157-209" aria-hidden="true" tabindex="-1"></a>    <span class="co"># --- Teil 2 ----------------------------------------------------------</span></span>
+<span id="cb157-210"><a href="#cb157-210" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;</span><span class="ch">\n</span><span class="st">&quot;</span> <span class="op">+</span> <span class="st">&quot;-&quot;</span> <span class="op">*</span> <span class="dv">80</span>)</span>
+<span id="cb157-211"><a href="#cb157-211" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;2. Absicherung gegen den schlechtesten Fall - EINE CVaR-Funktion</span><span class="ch">\n</span><span class="st">&quot;</span>)</span>
+<span id="cb157-212"><a href="#cb157-212" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb157-213"><a href="#cb157-213" aria-hidden="true" tabindex="-1"></a>    kurse, rendite, anlagen <span class="op">=</span> kursszenarien(rng)</span>
+<span id="cb157-214"><a href="#cb157-214" aria-hidden="true" tabindex="-1"></a>    anteile_depot <span class="op">=</span> berichte_cvar(</span>
+<span id="cb157-215"><a href="#cb157-215" aria-hidden="true" tabindex="-1"></a>                  <span class="st">&quot;Depot: die schlechtesten 5 </span><span class="sc">% d</span><span class="st">er Handelstage&quot;</span>,</span>
+<span id="cb157-216"><a href="#cb157-216" aria-hidden="true" tabindex="-1"></a>                  kurse, rendite, anlagen, <span class="fl">5.5</span>,</span>
+<span id="cb157-217"><a href="#cb157-217" aria-hidden="true" tabindex="-1"></a>                  <span class="st">&quot;% je Tag    &quot;</span>, <span class="st">&quot;Erwartete Jahresrendite (%)&quot;</span>)</span>
+<span id="cb157-218"><a href="#cb157-218" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>()</span>
+<span id="cb157-219"><a href="#cb157-219" aria-hidden="true" tabindex="-1"></a>    lieferung, zuverlaessig, lieferanten <span class="op">=</span> lieferszenarien(rng)</span>
+<span id="cb157-220"><a href="#cb157-220" aria-hidden="true" tabindex="-1"></a>    anteile_einkauf <span class="op">=</span> berichte_cvar(<span class="st">&quot;Einkauf: die schlechtesten 5 </span><span class="sc">% d</span><span class="st">er Bestellungen&quot;</span>,</span>
+<span id="cb157-221"><a href="#cb157-221" aria-hidden="true" tabindex="-1"></a>                  lieferung, zuverlaessig, lieferanten, <span class="fl">0.945</span>,</span>
+<span id="cb157-222"><a href="#cb157-222" aria-hidden="true" tabindex="-1"></a>                  <span class="st">&quot;Tage Verzug  &quot;</span>, <span class="st">&quot;Mittlere Zuverlaessigkeit&quot;</span>)</span>
+<span id="cb157-223"><a href="#cb157-223" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb157-224"><a href="#cb157-224" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;</span><span class="ch">\n</span><span class="st">  Auch hier: eine Funktion, zwei Aufrufe. Die Zielfunktion&quot;</span>)</span>
+<span id="cb157-225"><a href="#cb157-225" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;  interessiert sich nicht dafuer, ob in der Matrix Prozentpunkte&quot;</span>)</span>
+<span id="cb157-226"><a href="#cb157-226" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;  oder Tage stehen.&quot;</span>)</span>
+<span id="cb157-227"><a href="#cb157-227" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>()</span>
+<span id="cb157-228"><a href="#cb157-228" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;  Interessant ist, WO die Streuungsgrenze von </span><span class="sc">{</span>MAX_ANTEIL<span class="sc">:.0%}</span><span class="ss"> bindet:&quot;</span>)</span>
+<span id="cb157-229"><a href="#cb157-229" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;    Depot   : </span><span class="sc">{</span>(anteile_depot <span class="op">&gt;</span> MAX_ANTEIL <span class="op">-</span> <span class="fl">1e-4</span>)<span class="sc">.</span><span class="bu">sum</span>()<span class="sc">}</span><span class="ss"> von &quot;</span></span>
+<span id="cb157-230"><a href="#cb157-230" aria-hidden="true" tabindex="-1"></a>          <span class="ss">f&quot;</span><span class="sc">{</span><span class="bu">len</span>(anteile_depot)<span class="sc">}</span><span class="ss"> Posten am Anschlag&quot;</span>)</span>
+<span id="cb157-231"><a href="#cb157-231" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;    Einkauf : </span><span class="sc">{</span>(anteile_einkauf <span class="op">&gt;</span> MAX_ANTEIL <span class="op">-</span> <span class="fl">1e-4</span>)<span class="sc">.</span><span class="bu">sum</span>()<span class="sc">}</span><span class="ss"> von &quot;</span></span>
+<span id="cb157-232"><a href="#cb157-232" aria-hidden="true" tabindex="-1"></a>          <span class="ss">f&quot;</span><span class="sc">{</span><span class="bu">len</span>(anteile_einkauf)<span class="sc">}</span><span class="ss"> Posten am Anschlag&quot;</span>)</span>
+<span id="cb157-233"><a href="#cb157-233" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>()</span>
+<span id="cb157-234"><a href="#cb157-234" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;  Im Einkauf zieht es die Loesung an den sicheren Lokalzulieferer,&quot;</span>)</span>
+<span id="cb157-235"><a href="#cb157-235" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;  bis die Grenze sie stoppt. Im Depot nicht - dort verhindert die&quot;</span>)</span>
+<span id="cb157-236"><a href="#cb157-236" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;  Mindestrendite, dass alles in Anleihen wandert. Zwei verschiedene&quot;</span>)</span>
+<span id="cb157-237"><a href="#cb157-237" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;  Bremsen also, und sie stehen an verschiedenen Stellen des Modells:&quot;</span>)</span>
+<span id="cb157-238"><a href="#cb157-238" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;  einmal in einer Nebenbedingung ueber die Anteile, einmal in einer&quot;</span>)</span>
+<span id="cb157-239"><a href="#cb157-239" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;  ueber den Ertrag. Wer eine Struktur uebertraegt, uebertraegt eben&quot;</span>)</span>
+<span id="cb157-240"><a href="#cb157-240" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;  nicht automatisch mit, WELCHE Bedingung am Ende bindet.&quot;</span>)</span>
+<span id="cb157-241"><a href="#cb157-241" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb157-242"><a href="#cb157-242" aria-hidden="true" tabindex="-1"></a>    <span class="co"># --- Teil 3: Der ehrliche Teil ---------------------------------------</span></span>
+<span id="cb157-243"><a href="#cb157-243" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;</span><span class="ch">\n</span><span class="st">&quot;</span> <span class="op">+</span> <span class="st">&quot;=&quot;</span> <span class="op">*</span> <span class="dv">80</span>)</span>
+<span id="cb157-244"><a href="#cb157-244" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;  WAS NICHT HINUEBERREICHT&quot;</span>)</span>
+<span id="cb157-245"><a href="#cb157-245" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;=&quot;</span> <span class="op">*</span> <span class="dv">80</span>)</span>
+<span id="cb157-246"><a href="#cb157-246" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;Die Struktur traegt. Drei Unterschiede tragen NICHT mit, und wer sie&quot;</span>)</span>
+<span id="cb157-247"><a href="#cb157-247" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;uebersieht, macht aus einer nuetzlichen Analogie einen Fehler:&quot;</span>)</span>
+<span id="cb157-248"><a href="#cb157-248" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>()</span>
+<span id="cb157-249"><a href="#cb157-249" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;1. WOHER DIE ZAHLEN KOMMEN.&quot;</span>)</span>
+<span id="cb157-250"><a href="#cb157-250" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;   In der Werkstatt ist der Verbrauch je Tisch gemessen - drei&quot;</span>)</span>
+<span id="cb157-251"><a href="#cb157-251" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;   Montagestunden sind drei Montagestunden. Im Depot ist die&quot;</span>)</span>
+<span id="cb157-252"><a href="#cb157-252" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;   erwartete Rendite GESCHAETZT, und zwar mit einem Fehler, der&quot;</span>)</span>
+<span id="cb157-253"><a href="#cb157-253" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;   groesser sein kann als die Unterschiede zwischen den Anlagen&quot;</span>)</span>
+<span id="cb157-254"><a href="#cb157-254" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;   (Kapitel Markowitz, Renditeschaetzung_Falle.py). Dieselbe&quot;</span>)</span>
+<span id="cb157-255"><a href="#cb157-255" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;   Optimierung ist im einen Fall Planung und im anderen&quot;</span>)</span>
+<span id="cb157-256"><a href="#cb157-256" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;   Fehlerverstaerkung.&quot;</span>)</span>
+<span id="cb157-257"><a href="#cb157-257" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>()</span>
+<span id="cb157-258"><a href="#cb157-258" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;2. OB DIE VERGANGENHEIT ETWAS UEBER DIE ZUKUNFT SAGT.&quot;</span>)</span>
+<span id="cb157-259"><a href="#cb157-259" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;   Lieferzeiten haben physikalische Ursachen: Entfernung, Zoll,&quot;</span>)</span>
+<span id="cb157-260"><a href="#cb157-260" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;   Kapazitaet. Sie aendern sich langsam und nachvollziehbar.&quot;</span>)</span>
+<span id="cb157-261"><a href="#cb157-261" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;   Kursrenditen entstehen aus dem Verhalten von Marktteilnehmern,&quot;</span>)</span>
+<span id="cb157-262"><a href="#cb157-262" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;   die selbst auf Modelle reagieren - dort verschwindet ein&quot;</span>)</span>
+<span id="cb157-263"><a href="#cb157-263" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;   erkanntes Muster oft genau deshalb, weil es erkannt wurde&quot;</span>)</span>
+<span id="cb157-264"><a href="#cb157-264" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;   (Kapitel Handelsmaschine, Data_Snooping.py).&quot;</span>)</span>
+<span id="cb157-265"><a href="#cb157-265" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>()</span>
+<span id="cb157-266"><a href="#cb157-266" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;3. OB TEILBARKEIT ERLAUBT IST.&quot;</span>)</span>
+<span id="cb157-267"><a href="#cb157-267" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;   37,4 </span><span class="sc">% e</span><span class="st">ines Aktienfonds sind ein normaler Auftrag. 37,4 </span><span class="sc">% e</span><span class="st">ines&quot;</span>)</span>
+<span id="cb157-268"><a href="#cb157-268" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;   Lieferanten sind es nicht - Vertraege, Mindestabnahmen und&quot;</span>)</span>
+<span id="cb157-269"><a href="#cb157-269" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;   Ruestzeiten machen Einkaufsentscheidungen ganzzahlig. Genau&quot;</span>)</span>
+<span id="cb157-270"><a href="#cb157-270" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;   deshalb ist Teil II voller MILP und Teil V fast frei davon.&quot;</span>)</span>
+<span id="cb157-271"><a href="#cb157-271" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>()</span>
+<span id="cb157-272"><a href="#cb157-272" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;Die Bruecke traegt also die MODELLE, nicht die Annahmen. Wer sie&quot;</span>)</span>
+<span id="cb157-273"><a href="#cb157-273" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;benutzt, spart sich das Lernen der Methoden - nicht das Nachdenken&quot;</span>)</span>
+<span id="cb157-274"><a href="#cb157-274" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;ueber die Daten.&quot;</span>)</span>
+<span id="cb157-275"><a href="#cb157-275" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;=&quot;</span> <span class="op">*</span> <span class="dv">80</span>)</span></code></pre></div>
 <p><strong>Erwartete Ausgabe:</strong></p>
 <pre><code>================================================================================
   DIESELBE STRUKTUR, ZWEI WELTEN
@@ -20434,23 +21399,23 @@ u_s \ge \ell_s^\top w - \gamma, \quad u_s \ge 0
 <p><strong>🚀 In 5 Minuten gelöst: Warum „billigstes Kraftwerk zuerst” falsch ist</strong></p>
 <p>Zwei Kraftwerke können 120 MW liefern. Der Kernblock produziert für 22 €/MWh, die Gasturbine für 105 € — fünfmal so teuer. Die Merit-Order-Regel sagt: Kernblock.</p>
 <p>Sie übersieht die Anfahrkosten: 40 000 € gegen 1 500 €.</p>
-<div class="sourceCode" id="cb157"><pre class="sourceCode python"><code class="sourceCode python"><span id="cb157-1"><a href="#cb157-1" aria-hidden="true" tabindex="-1"></a><span class="co"># Zwei Kraftwerke, die 120 MW decken sollen - aber wie lange?</span></span>
-<span id="cb157-2"><a href="#cb157-2" aria-hidden="true" tabindex="-1"></a><span class="co">#                        Grenzkosten   Anfahrkosten</span></span>
-<span id="cb157-3"><a href="#cb157-3" aria-hidden="true" tabindex="-1"></a>kernblock  <span class="op">=</span> <span class="bu">dict</span>(name<span class="op">=</span><span class="st">&quot;Kernblock&quot;</span>,  grenz<span class="op">=</span><span class="dv">22</span>,  anfahrt<span class="op">=</span><span class="dv">40_000</span>)</span>
-<span id="cb157-4"><a href="#cb157-4" aria-hidden="true" tabindex="-1"></a>gasturbine <span class="op">=</span> <span class="bu">dict</span>(name<span class="op">=</span><span class="st">&quot;Gasturbine&quot;</span>, grenz<span class="op">=</span><span class="dv">105</span>, anfahrt<span class="op">=</span><span class="dv">1_500</span>)</span>
-<span id="cb157-5"><a href="#cb157-5" aria-hidden="true" tabindex="-1"></a>LEISTUNG <span class="op">=</span> <span class="dv">120</span>                                   <span class="co"># MW, die gebraucht werden</span></span>
-<span id="cb157-6"><a href="#cb157-6" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb157-7"><a href="#cb157-7" aria-hidden="true" tabindex="-1"></a>kosten <span class="op">=</span> <span class="kw">lambda</span> kw, stunden: kw[<span class="st">&quot;anfahrt&quot;</span>] <span class="op">+</span> kw[<span class="st">&quot;grenz&quot;</span>] <span class="op">*</span> LEISTUNG <span class="op">*</span> stunden</span>
-<span id="cb157-8"><a href="#cb157-8" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb157-9"><a href="#cb157-9" aria-hidden="true" tabindex="-1"></a><span class="bu">print</span>(<span class="ss">f&quot;</span><span class="sc">{</span><span class="st">&#39;Dauer&#39;</span><span class="sc">:&gt;7}</span><span class="ss"> </span><span class="sc">{</span><span class="st">&#39;Kernblock&#39;</span><span class="sc">:&gt;12}</span><span class="ss"> </span><span class="sc">{</span><span class="st">&#39;Gasturbine&#39;</span><span class="sc">:&gt;12}</span><span class="ss">   guenstiger&quot;</span>)</span>
-<span id="cb157-10"><a href="#cb157-10" aria-hidden="true" tabindex="-1"></a><span class="cf">for</span> stunden <span class="kw">in</span> (<span class="dv">1</span>, <span class="dv">2</span>, <span class="dv">3</span>, <span class="dv">4</span>, <span class="dv">5</span>, <span class="dv">6</span>, <span class="dv">8</span>):</span>
-<span id="cb157-11"><a href="#cb157-11" aria-hidden="true" tabindex="-1"></a>    k, g <span class="op">=</span> kosten(kernblock, stunden), kosten(gasturbine, stunden)</span>
-<span id="cb157-12"><a href="#cb157-12" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;</span><span class="sc">{</span>stunden<span class="sc">:&gt;5}</span><span class="ss"> h </span><span class="sc">{</span>k<span class="sc">:&gt;12,.0f}</span><span class="ss"> </span><span class="sc">{</span>g<span class="sc">:&gt;12,.0f}</span><span class="ss">   &quot;</span></span>
-<span id="cb157-13"><a href="#cb157-13" aria-hidden="true" tabindex="-1"></a>          <span class="ss">f&quot;</span><span class="sc">{</span>kernblock[<span class="st">&#39;name&#39;</span>] <span class="cf">if</span> k <span class="op">&lt;</span> g <span class="cf">else</span> gasturbine[<span class="st">&#39;name&#39;</span>]<span class="sc">}</span><span class="ss">&quot;</span>)</span>
-<span id="cb157-14"><a href="#cb157-14" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb157-15"><a href="#cb157-15" aria-hidden="true" tabindex="-1"></a>wechsel <span class="op">=</span> (kernblock[<span class="st">&quot;anfahrt&quot;</span>] <span class="op">-</span> gasturbine[<span class="st">&quot;anfahrt&quot;</span>]) <span class="op">/</span> (</span>
-<span id="cb157-16"><a href="#cb157-16" aria-hidden="true" tabindex="-1"></a>    (gasturbine[<span class="st">&quot;grenz&quot;</span>] <span class="op">-</span> kernblock[<span class="st">&quot;grenz&quot;</span>]) <span class="op">*</span> LEISTUNG)</span>
-<span id="cb157-17"><a href="#cb157-17" aria-hidden="true" tabindex="-1"></a><span class="bu">print</span>(<span class="ss">f&quot;</span><span class="ch">\n</span><span class="ss">Umschlagpunkt: </span><span class="sc">{</span>wechsel<span class="sc">:.1f}</span><span class="ss"> Stunden&quot;</span>)</span></code></pre></div>
+<div class="sourceCode" id="cb159"><pre class="sourceCode python"><code class="sourceCode python"><span id="cb159-1"><a href="#cb159-1" aria-hidden="true" tabindex="-1"></a><span class="co"># Zwei Kraftwerke, die 120 MW decken sollen - aber wie lange?</span></span>
+<span id="cb159-2"><a href="#cb159-2" aria-hidden="true" tabindex="-1"></a><span class="co">#                        Grenzkosten   Anfahrkosten</span></span>
+<span id="cb159-3"><a href="#cb159-3" aria-hidden="true" tabindex="-1"></a>kernblock  <span class="op">=</span> <span class="bu">dict</span>(name<span class="op">=</span><span class="st">&quot;Kernblock&quot;</span>,  grenz<span class="op">=</span><span class="dv">22</span>,  anfahrt<span class="op">=</span><span class="dv">40_000</span>)</span>
+<span id="cb159-4"><a href="#cb159-4" aria-hidden="true" tabindex="-1"></a>gasturbine <span class="op">=</span> <span class="bu">dict</span>(name<span class="op">=</span><span class="st">&quot;Gasturbine&quot;</span>, grenz<span class="op">=</span><span class="dv">105</span>, anfahrt<span class="op">=</span><span class="dv">1_500</span>)</span>
+<span id="cb159-5"><a href="#cb159-5" aria-hidden="true" tabindex="-1"></a>LEISTUNG <span class="op">=</span> <span class="dv">120</span>                                   <span class="co"># MW, die gebraucht werden</span></span>
+<span id="cb159-6"><a href="#cb159-6" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb159-7"><a href="#cb159-7" aria-hidden="true" tabindex="-1"></a>kosten <span class="op">=</span> <span class="kw">lambda</span> kw, stunden: kw[<span class="st">&quot;anfahrt&quot;</span>] <span class="op">+</span> kw[<span class="st">&quot;grenz&quot;</span>] <span class="op">*</span> LEISTUNG <span class="op">*</span> stunden</span>
+<span id="cb159-8"><a href="#cb159-8" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb159-9"><a href="#cb159-9" aria-hidden="true" tabindex="-1"></a><span class="bu">print</span>(<span class="ss">f&quot;</span><span class="sc">{</span><span class="st">&#39;Dauer&#39;</span><span class="sc">:&gt;7}</span><span class="ss"> </span><span class="sc">{</span><span class="st">&#39;Kernblock&#39;</span><span class="sc">:&gt;12}</span><span class="ss"> </span><span class="sc">{</span><span class="st">&#39;Gasturbine&#39;</span><span class="sc">:&gt;12}</span><span class="ss">   guenstiger&quot;</span>)</span>
+<span id="cb159-10"><a href="#cb159-10" aria-hidden="true" tabindex="-1"></a><span class="cf">for</span> stunden <span class="kw">in</span> (<span class="dv">1</span>, <span class="dv">2</span>, <span class="dv">3</span>, <span class="dv">4</span>, <span class="dv">5</span>, <span class="dv">6</span>, <span class="dv">8</span>):</span>
+<span id="cb159-11"><a href="#cb159-11" aria-hidden="true" tabindex="-1"></a>    k, g <span class="op">=</span> kosten(kernblock, stunden), kosten(gasturbine, stunden)</span>
+<span id="cb159-12"><a href="#cb159-12" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;</span><span class="sc">{</span>stunden<span class="sc">:&gt;5}</span><span class="ss"> h </span><span class="sc">{</span>k<span class="sc">:&gt;12,.0f}</span><span class="ss"> </span><span class="sc">{</span>g<span class="sc">:&gt;12,.0f}</span><span class="ss">   &quot;</span></span>
+<span id="cb159-13"><a href="#cb159-13" aria-hidden="true" tabindex="-1"></a>          <span class="ss">f&quot;</span><span class="sc">{</span>kernblock[<span class="st">&#39;name&#39;</span>] <span class="cf">if</span> k <span class="op">&lt;</span> g <span class="cf">else</span> gasturbine[<span class="st">&#39;name&#39;</span>]<span class="sc">}</span><span class="ss">&quot;</span>)</span>
+<span id="cb159-14"><a href="#cb159-14" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb159-15"><a href="#cb159-15" aria-hidden="true" tabindex="-1"></a>wechsel <span class="op">=</span> (kernblock[<span class="st">&quot;anfahrt&quot;</span>] <span class="op">-</span> gasturbine[<span class="st">&quot;anfahrt&quot;</span>]) <span class="op">/</span> (</span>
+<span id="cb159-16"><a href="#cb159-16" aria-hidden="true" tabindex="-1"></a>    (gasturbine[<span class="st">&quot;grenz&quot;</span>] <span class="op">-</span> kernblock[<span class="st">&quot;grenz&quot;</span>]) <span class="op">*</span> LEISTUNG)</span>
+<span id="cb159-17"><a href="#cb159-17" aria-hidden="true" tabindex="-1"></a><span class="bu">print</span>(<span class="ss">f&quot;</span><span class="ch">\n</span><span class="ss">Umschlagpunkt: </span><span class="sc">{</span>wechsel<span class="sc">:.1f}</span><span class="ss"> Stunden&quot;</span>)</span></code></pre></div>
 <p><strong>Ausgabe:</strong></p>
 <pre><code>  Dauer    Kernblock   Gasturbine   guenstiger
     1 h       42,640       14,100   Gasturbine
@@ -20622,344 +21587,344 @@ Umschlagpunkt: 3.9 Stunden</code></pre>
 </blockquote>
 <hr />
 <h2 id="sec:supplychain-programm">17.4 Das Programm</h2>
-<div class="sourceCode" id="cb159"><pre class="sourceCode python"><code class="sourceCode python"><span id="cb159-1"><a href="#cb159-1" aria-hidden="true" tabindex="-1"></a><span class="co">#!/usr/bin/env python3</span></span>
-<span id="cb159-2"><a href="#cb159-2" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb159-3"><a href="#cb159-3" aria-hidden="true" tabindex="-1"></a><span class="co"># Kraftwerkseinsatz.py</span></span>
-<span id="cb159-4"><a href="#cb159-4" aria-hidden="true" tabindex="-1"></a><span class="co">&quot;&quot;&quot;</span></span>
-<span id="cb159-5"><a href="#cb159-5" aria-hidden="true" tabindex="-1"></a><span class="co">Kapitel Supply-Chain: Welche Bloecke laufen morgen? Und was, wenn kein Wind weht?</span></span>
-<span id="cb159-6"><a href="#cb159-6" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb159-7"><a href="#cb159-7" aria-hidden="true" tabindex="-1"></a><span class="co">Die Kraftwerkseinsatzplanung (englisch Unit Commitment) ist die Aufgabe, an der</span></span>
-<span id="cb159-8"><a href="#cb159-8" aria-hidden="true" tabindex="-1"></a><span class="co">sich in der Energiewirtschaft alles entscheidet: Fuer jede Stunde des naechsten</span></span>
-<span id="cb159-9"><a href="#cb159-9" aria-hidden="true" tabindex="-1"></a><span class="co">Tages muss feststehen, welche Bloecke am Netz sind. Ein Kernblock braucht acht</span></span>
-<span id="cb159-10"><a href="#cb159-10" aria-hidden="true" tabindex="-1"></a><span class="co">Stunden Mindestlaufzeit und 40.000 Euro Anfahrkosten - wer ihn abschaltet, hat</span></span>
-<span id="cb159-11"><a href="#cb159-11" aria-hidden="true" tabindex="-1"></a><span class="co">ihn fuer den Rest des Tages verloren.</span></span>
-<span id="cb159-12"><a href="#cb159-12" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb159-13"><a href="#cb159-13" aria-hidden="true" tabindex="-1"></a><span class="co">Das Besondere liegt in der Zeitstruktur, und es geht ueber das zweistufige</span></span>
-<span id="cb159-14"><a href="#cb159-14" aria-hidden="true" tabindex="-1"></a><span class="co">Modell aus dem Kapitel Unsicherheit hinaus:</span></span>
-<span id="cb159-15"><a href="#cb159-15" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb159-16"><a href="#cb159-16" aria-hidden="true" tabindex="-1"></a><span class="co">    STUFE 1   Das AN/AUS je Block und Stunde. Binaer, und es steht am Vorabend</span></span>
-<span id="cb159-17"><a href="#cb159-17" aria-hidden="true" tabindex="-1"></a><span class="co">              fest - bevor irgendjemand weiss, wie viel Wind morgen weht.</span></span>
-<span id="cb159-18"><a href="#cb159-18" aria-hidden="true" tabindex="-1"></a><span class="co">    STUFE 2   Die Fahrweise: wie viel jeder laufende Block liefert. Das darf</span></span>
-<span id="cb159-19"><a href="#cb159-19" aria-hidden="true" tabindex="-1"></a><span class="co">              sich stundenweise an die Wirklichkeit anpassen.</span></span>
-<span id="cb159-20"><a href="#cb159-20" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb159-21"><a href="#cb159-21" aria-hidden="true" tabindex="-1"></a><span class="co">Die erste Stufe ist also GANZZAHLIG und szenariouebergreifend gleich, die</span></span>
-<span id="cb159-22"><a href="#cb159-22" aria-hidden="true" tabindex="-1"></a><span class="co">zweite kontinuierlich und je Szenario verschieden. Genau diese Kombination</span></span>
-<span id="cb159-23"><a href="#cb159-23" aria-hidden="true" tabindex="-1"></a><span class="co">macht das Problem interessant - und sie ist der Grund, warum ein Plan, der auf</span></span>
-<span id="cb159-24"><a href="#cb159-24" aria-hidden="true" tabindex="-1"></a><span class="co">den Wind-Erwartungswert gerechnet wurde, in der Wirklichkeit teuer wird.</span></span>
-<span id="cb159-25"><a href="#cb159-25" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb159-26"><a href="#cb159-26" aria-hidden="true" tabindex="-1"></a><span class="co">Das Programm zeigt drei Plaene auf denselben Daten:</span></span>
-<span id="cb159-27"><a href="#cb159-27" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb159-28"><a href="#cb159-28" aria-hidden="true" tabindex="-1"></a><span class="co">  1. Deterministisch: gerechnet mit dem Wind-ERWARTUNGSWERT, danach gegen 40</span></span>
-<span id="cb159-29"><a href="#cb159-29" aria-hidden="true" tabindex="-1"></a><span class="co">     Szenarien ausgewertet.</span></span>
-<span id="cb159-30"><a href="#cb159-30" aria-hidden="true" tabindex="-1"></a><span class="co">  2. Zweistufig: der Commitment-Plan sieht alle 40 Szenarien.</span></span>
-<span id="cb159-31"><a href="#cb159-31" aria-hidden="true" tabindex="-1"></a><span class="co">  3. Mit Versorgungssicherheit: die Nichtdeckung in den schlechtesten Faellen</span></span>
-<span id="cb159-32"><a href="#cb159-32" aria-hidden="true" tabindex="-1"></a><span class="co">     wird begrenzt - und der Preis dafuer in Euro je vermiedener MWh</span></span>
-<span id="cb159-33"><a href="#cb159-33" aria-hidden="true" tabindex="-1"></a><span class="co">     ausgewiesen.</span></span>
-<span id="cb159-34"><a href="#cb159-34" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb159-35"><a href="#cb159-35" aria-hidden="true" tabindex="-1"></a><span class="co">Benoetigt: numpy, ortools</span></span>
-<span id="cb159-36"><a href="#cb159-36" aria-hidden="true" tabindex="-1"></a><span class="co">&quot;&quot;&quot;</span></span>
-<span id="cb159-37"><a href="#cb159-37" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb159-38"><a href="#cb159-38" aria-hidden="true" tabindex="-1"></a><span class="im">from</span> __future__ <span class="im">import</span> annotations</span>
-<span id="cb159-39"><a href="#cb159-39" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb159-40"><a href="#cb159-40" aria-hidden="true" tabindex="-1"></a><span class="im">import</span> time</span>
-<span id="cb159-41"><a href="#cb159-41" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb159-42"><a href="#cb159-42" aria-hidden="true" tabindex="-1"></a><span class="im">import</span> numpy <span class="im">as</span> np</span>
-<span id="cb159-43"><a href="#cb159-43" aria-hidden="true" tabindex="-1"></a><span class="im">from</span> ortools.linear_solver <span class="im">import</span> pywraplp</span>
-<span id="cb159-44"><a href="#cb159-44" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb159-45"><a href="#cb159-45" aria-hidden="true" tabindex="-1"></a><span class="co"># (Name, Mindestleistung, Nennleistung, Grenzkosten, Anfahrkosten, Mindestlaufzeit)</span></span>
-<span id="cb159-46"><a href="#cb159-46" aria-hidden="true" tabindex="-1"></a>KRAFTWERKE <span class="op">=</span> [</span>
-<span id="cb159-47"><a href="#cb159-47" aria-hidden="true" tabindex="-1"></a>    (<span class="st">&quot;Kernblock&quot;</span>,   <span class="dv">200</span>, <span class="dv">600</span>,  <span class="dv">22</span>, <span class="dv">40_000</span>, <span class="dv">8</span>),</span>
-<span id="cb159-48"><a href="#cb159-48" aria-hidden="true" tabindex="-1"></a>    (<span class="st">&quot;Braunkohle&quot;</span>,  <span class="dv">100</span>, <span class="dv">400</span>,  <span class="dv">35</span>, <span class="dv">18_000</span>, <span class="dv">6</span>),</span>
-<span id="cb159-49"><a href="#cb159-49" aria-hidden="true" tabindex="-1"></a>    (<span class="st">&quot;Steinkohle&quot;</span>,   <span class="dv">80</span>, <span class="dv">300</span>,  <span class="dv">48</span>, <span class="dv">12_000</span>, <span class="dv">4</span>),</span>
-<span id="cb159-50"><a href="#cb159-50" aria-hidden="true" tabindex="-1"></a>    (<span class="st">&quot;Gas GuD&quot;</span>,      <span class="dv">50</span>, <span class="dv">250</span>,  <span class="dv">72</span>,  <span class="dv">6_000</span>, <span class="dv">2</span>),</span>
-<span id="cb159-51"><a href="#cb159-51" aria-hidden="true" tabindex="-1"></a>    (<span class="st">&quot;Gasturbine&quot;</span>,   <span class="dv">20</span>, <span class="dv">150</span>, <span class="dv">105</span>,   <span class="dv">1_500</span>, <span class="dv">1</span>),</span>
-<span id="cb159-52"><a href="#cb159-52" aria-hidden="true" tabindex="-1"></a>]</span>
-<span id="cb159-53"><a href="#cb159-53" aria-hidden="true" tabindex="-1"></a>STUNDEN <span class="op">=</span> <span class="dv">24</span></span>
-<span id="cb159-54"><a href="#cb159-54" aria-hidden="true" tabindex="-1"></a>SZENARIEN <span class="op">=</span> <span class="dv">40</span></span>
-<span id="cb159-55"><a href="#cb159-55" aria-hidden="true" tabindex="-1"></a>FLAUTENANTEIL <span class="op">=</span> <span class="fl">0.15</span></span>
-<span id="cb159-56"><a href="#cb159-56" aria-hidden="true" tabindex="-1"></a>ALPHA <span class="op">=</span> <span class="fl">0.90</span>                  <span class="co"># die schlechtesten 10 % der Szenarien</span></span>
-<span id="cb159-57"><a href="#cb159-57" aria-hidden="true" tabindex="-1"></a>LASTABWURF <span class="op">=</span> <span class="fl">3_000.0</span>          <span class="co"># EUR je nicht gedeckter MWh (&quot;value of lost load&quot;)</span></span>
-<span id="cb159-58"><a href="#cb159-58" aria-hidden="true" tabindex="-1"></a>NIEDRIGER_ABWURFPREIS <span class="op">=</span> <span class="fl">300.0</span>  <span class="co"># zum Vergleich: ein Marktpreisdeckel</span></span>
-<span id="cb159-59"><a href="#cb159-59" aria-hidden="true" tabindex="-1"></a>SAAT <span class="op">=</span> <span class="dv">4</span></span>
-<span id="cb159-60"><a href="#cb159-60" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb159-61"><a href="#cb159-61" aria-hidden="true" tabindex="-1"></a>_t <span class="op">=</span> np.arange(STUNDEN)</span>
-<span id="cb159-62"><a href="#cb159-62" aria-hidden="true" tabindex="-1"></a>LAST <span class="op">=</span> <span class="dv">620</span> <span class="op">+</span> <span class="dv">260</span> <span class="op">*</span> np.sin((_t <span class="op">-</span> <span class="dv">7</span>) <span class="op">/</span> <span class="dv">24</span> <span class="op">*</span> <span class="dv">2</span> <span class="op">*</span> np.pi) <span class="op">+</span> <span class="dv">90</span> <span class="op">*</span> np.sin((_t <span class="op">-</span> <span class="dv">4</span>) <span class="op">/</span> <span class="dv">12</span> <span class="op">*</span> <span class="dv">2</span> <span class="op">*</span> np.pi)</span>
-<span id="cb159-63"><a href="#cb159-63" aria-hidden="true" tabindex="-1"></a>WIND_ERWARTUNG <span class="op">=</span> np.maximum(<span class="fl">0.0</span>, <span class="dv">160</span> <span class="op">+</span> <span class="dv">130</span> <span class="op">*</span> np.sin((_t <span class="op">-</span> <span class="dv">14</span>) <span class="op">/</span> <span class="dv">24</span> <span class="op">*</span> <span class="dv">2</span> <span class="op">*</span> np.pi))</span>
-<span id="cb159-64"><a href="#cb159-64" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb159-65"><a href="#cb159-65" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb159-66"><a href="#cb159-66" aria-hidden="true" tabindex="-1"></a><span class="kw">def</span> erzeuge_windszenarien(anzahl: <span class="bu">int</span> <span class="op">=</span> SZENARIEN, saat: <span class="bu">int</span> <span class="op">=</span> SAAT):</span>
-<span id="cb159-67"><a href="#cb159-67" aria-hidden="true" tabindex="-1"></a>    <span class="co">&quot;&quot;&quot;Windeinspeisung je Szenario und Stunde.</span></span>
-<span id="cb159-68"><a href="#cb159-68" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb159-69"><a href="#cb159-69" aria-hidden="true" tabindex="-1"></a><span class="co">    Zwei Zutaten, die zusammen den Unterschied machen: eine breite</span></span>
-<span id="cb159-70"><a href="#cb159-70" aria-hidden="true" tabindex="-1"></a><span class="co">    lognormale Streuung des Tagesniveaus - und in 15 % der Faelle eine</span></span>
-<span id="cb159-71"><a href="#cb159-71" aria-hidden="true" tabindex="-1"></a><span class="co">    DUNKELFLAUTE, in der praktisch gar kein Wind weht. Solche seltenen,</span></span>
-<span id="cb159-72"><a href="#cb159-72" aria-hidden="true" tabindex="-1"></a><span class="co">    extremen Faelle sind der Grund, warum der Erwartungswert als</span></span>
-<span id="cb159-73"><a href="#cb159-73" aria-hidden="true" tabindex="-1"></a><span class="co">    Planungsgrundlage nicht genuegt.</span></span>
-<span id="cb159-74"><a href="#cb159-74" aria-hidden="true" tabindex="-1"></a><span class="co">    &quot;&quot;&quot;</span></span>
-<span id="cb159-75"><a href="#cb159-75" aria-hidden="true" tabindex="-1"></a>    rng <span class="op">=</span> np.random.default_rng(saat)</span>
-<span id="cb159-76"><a href="#cb159-76" aria-hidden="true" tabindex="-1"></a>    tagesniveau <span class="op">=</span> rng.lognormal(<span class="dv">0</span>, <span class="fl">0.40</span>, (anzahl, <span class="dv">1</span>))</span>
-<span id="cb159-77"><a href="#cb159-77" aria-hidden="true" tabindex="-1"></a>    wind <span class="op">=</span> np.clip(WIND_ERWARTUNG <span class="op">*</span> tagesniveau</span>
-<span id="cb159-78"><a href="#cb159-78" aria-hidden="true" tabindex="-1"></a>                   <span class="op">+</span> rng.normal(<span class="dv">0</span>, <span class="dv">25</span>, (anzahl, STUNDEN)), <span class="dv">0</span>, <span class="dv">420</span>)</span>
-<span id="cb159-79"><a href="#cb159-79" aria-hidden="true" tabindex="-1"></a>    ist_flaute <span class="op">=</span> rng.random(anzahl) <span class="op">&lt;</span> FLAUTENANTEIL</span>
-<span id="cb159-80"><a href="#cb159-80" aria-hidden="true" tabindex="-1"></a>    wind[ist_flaute] <span class="op">*=</span> <span class="fl">0.05</span></span>
-<span id="cb159-81"><a href="#cb159-81" aria-hidden="true" tabindex="-1"></a>    <span class="cf">return</span> wind, ist_flaute</span>
-<span id="cb159-82"><a href="#cb159-82" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb159-83"><a href="#cb159-83" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb159-84"><a href="#cb159-84" aria-hidden="true" tabindex="-1"></a><span class="kw">def</span> plane(wind: np.ndarray, gewichte, cvar_grenze: <span class="bu">float</span> <span class="op">|</span> <span class="va">None</span> <span class="op">=</span> <span class="va">None</span>,</span>
-<span id="cb159-85"><a href="#cb159-85" aria-hidden="true" tabindex="-1"></a>          abwurfpreis: <span class="bu">float</span> <span class="op">=</span> <span class="va">None</span>, zeitlimit: <span class="bu">float</span> <span class="op">=</span> <span class="fl">300.0</span>):</span>
-<span id="cb159-86"><a href="#cb159-86" aria-hidden="true" tabindex="-1"></a>    <span class="co">&quot;&quot;&quot;Commitment (Stufe 1) und Fahrweise je Szenario (Stufe 2) in einem Modell.</span></span>
-<span id="cb159-87"><a href="#cb159-87" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb159-88"><a href="#cb159-88" aria-hidden="true" tabindex="-1"></a><span class="co">    &#39;wind&#39; hat die Form (Szenarien, Stunden). Mit einer einzigen Zeile</span></span>
-<span id="cb159-89"><a href="#cb159-89" aria-hidden="true" tabindex="-1"></a><span class="co">    Windprognose wird daraus die deterministische Planung.</span></span>
-<span id="cb159-90"><a href="#cb159-90" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb159-91"><a href="#cb159-91" aria-hidden="true" tabindex="-1"></a><span class="co">    &#39;cvar_grenze&#39; begrenzt den CVaR der Nichtdeckung ueber die Szenarien -</span></span>
-<span id="cb159-92"><a href="#cb159-92" aria-hidden="true" tabindex="-1"></a><span class="co">    dieselbe Rockafellar-Uryasev-Konstruktion wie im Kapitel CVaR, nur dass</span></span>
-<span id="cb159-93"><a href="#cb159-93" aria-hidden="true" tabindex="-1"></a><span class="co">    hier keine Verluste in Euro, sondern Megawattstunden begrenzt werden.</span></span>
-<span id="cb159-94"><a href="#cb159-94" aria-hidden="true" tabindex="-1"></a><span class="co">    &quot;&quot;&quot;</span></span>
-<span id="cb159-95"><a href="#cb159-95" aria-hidden="true" tabindex="-1"></a>    abwurfpreis <span class="op">=</span> LASTABWURF <span class="cf">if</span> abwurfpreis <span class="kw">is</span> <span class="va">None</span> <span class="cf">else</span> abwurfpreis</span>
-<span id="cb159-96"><a href="#cb159-96" aria-hidden="true" tabindex="-1"></a>    anzahl_szenarien <span class="op">=</span> wind.shape[<span class="dv">0</span>]</span>
-<span id="cb159-97"><a href="#cb159-97" aria-hidden="true" tabindex="-1"></a>    anzahl_bloecke <span class="op">=</span> <span class="bu">len</span>(KRAFTWERKE)</span>
-<span id="cb159-98"><a href="#cb159-98" aria-hidden="true" tabindex="-1"></a>    solver <span class="op">=</span> pywraplp.Solver.CreateSolver(<span class="st">&quot;SCIP&quot;</span>)</span>
-<span id="cb159-99"><a href="#cb159-99" aria-hidden="true" tabindex="-1"></a>    solver.SetTimeLimit(<span class="bu">int</span>(zeitlimit <span class="op">*</span> <span class="dv">1000</span>))</span>
-<span id="cb159-100"><a href="#cb159-100" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb159-101"><a href="#cb159-101" aria-hidden="true" tabindex="-1"></a>    <span class="co"># --- Stufe 1: binaer, szenariouebergreifend gleich --------------------</span></span>
-<span id="cb159-102"><a href="#cb159-102" aria-hidden="true" tabindex="-1"></a>    laeuft <span class="op">=</span> [[solver.BoolVar(<span class="ss">f&quot;laeuft_</span><span class="sc">{</span>k<span class="sc">}</span><span class="ss">_</span><span class="sc">{</span>t<span class="sc">}</span><span class="ss">&quot;</span>) <span class="cf">for</span> t <span class="kw">in</span> <span class="bu">range</span>(STUNDEN)]</span>
-<span id="cb159-103"><a href="#cb159-103" aria-hidden="true" tabindex="-1"></a>              <span class="cf">for</span> k <span class="kw">in</span> <span class="bu">range</span>(anzahl_bloecke)]</span>
-<span id="cb159-104"><a href="#cb159-104" aria-hidden="true" tabindex="-1"></a>    faehrt_an <span class="op">=</span> [[solver.BoolVar(<span class="ss">f&quot;start_</span><span class="sc">{</span>k<span class="sc">}</span><span class="ss">_</span><span class="sc">{</span>t<span class="sc">}</span><span class="ss">&quot;</span>) <span class="cf">for</span> t <span class="kw">in</span> <span class="bu">range</span>(STUNDEN)]</span>
-<span id="cb159-105"><a href="#cb159-105" aria-hidden="true" tabindex="-1"></a>                 <span class="cf">for</span> k <span class="kw">in</span> <span class="bu">range</span>(anzahl_bloecke)]</span>
-<span id="cb159-106"><a href="#cb159-106" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb159-107"><a href="#cb159-107" aria-hidden="true" tabindex="-1"></a>    <span class="co"># --- Stufe 2: kontinuierlich, je Szenario -----------------------------</span></span>
-<span id="cb159-108"><a href="#cb159-108" aria-hidden="true" tabindex="-1"></a>    leistung <span class="op">=</span> [[[solver.NumVar(<span class="dv">0</span>, KRAFTWERKE[k][<span class="dv">2</span>], <span class="ss">f&quot;p_</span><span class="sc">{</span>j<span class="sc">}</span><span class="ss">_</span><span class="sc">{</span>k<span class="sc">}</span><span class="ss">_</span><span class="sc">{</span>t<span class="sc">}</span><span class="ss">&quot;</span>)</span>
-<span id="cb159-109"><a href="#cb159-109" aria-hidden="true" tabindex="-1"></a>                  <span class="cf">for</span> t <span class="kw">in</span> <span class="bu">range</span>(STUNDEN)] <span class="cf">for</span> k <span class="kw">in</span> <span class="bu">range</span>(anzahl_bloecke)]</span>
-<span id="cb159-110"><a href="#cb159-110" aria-hidden="true" tabindex="-1"></a>                <span class="cf">for</span> j <span class="kw">in</span> <span class="bu">range</span>(anzahl_szenarien)]</span>
-<span id="cb159-111"><a href="#cb159-111" aria-hidden="true" tabindex="-1"></a>    nichtdeckung <span class="op">=</span> [[solver.NumVar(<span class="dv">0</span>, solver.infinity(), <span class="ss">f&quot;y_</span><span class="sc">{</span>j<span class="sc">}</span><span class="ss">_</span><span class="sc">{</span>t<span class="sc">}</span><span class="ss">&quot;</span>)</span>
-<span id="cb159-112"><a href="#cb159-112" aria-hidden="true" tabindex="-1"></a>                     <span class="cf">for</span> t <span class="kw">in</span> <span class="bu">range</span>(STUNDEN)] <span class="cf">for</span> j <span class="kw">in</span> <span class="bu">range</span>(anzahl_szenarien)]</span>
-<span id="cb159-113"><a href="#cb159-113" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb159-114"><a href="#cb159-114" aria-hidden="true" tabindex="-1"></a>    <span class="cf">for</span> k, (_, pmin, pmax, _, _, mindestlaufzeit) <span class="kw">in</span> <span class="bu">enumerate</span>(KRAFTWERKE):</span>
-<span id="cb159-115"><a href="#cb159-115" aria-hidden="true" tabindex="-1"></a>        <span class="cf">for</span> t <span class="kw">in</span> <span class="bu">range</span>(STUNDEN):</span>
-<span id="cb159-116"><a href="#cb159-116" aria-hidden="true" tabindex="-1"></a>            <span class="co"># Anfahren erkennen: aus im Vortakt, an im aktuellen</span></span>
-<span id="cb159-117"><a href="#cb159-117" aria-hidden="true" tabindex="-1"></a>            vorher <span class="op">=</span> laeuft[k][t <span class="op">-</span> <span class="dv">1</span>] <span class="cf">if</span> t <span class="op">&gt;</span> <span class="dv">0</span> <span class="cf">else</span> <span class="dv">0</span></span>
-<span id="cb159-118"><a href="#cb159-118" aria-hidden="true" tabindex="-1"></a>            solver.Add(faehrt_an[k][t] <span class="op">&gt;=</span> laeuft[k][t] <span class="op">-</span> vorher)</span>
-<span id="cb159-119"><a href="#cb159-119" aria-hidden="true" tabindex="-1"></a>            <span class="co"># Mindestlaufzeit: wer anfaehrt, laeuft die naechsten Stunden weiter</span></span>
-<span id="cb159-120"><a href="#cb159-120" aria-hidden="true" tabindex="-1"></a>            <span class="cf">for</span> spaeter <span class="kw">in</span> <span class="bu">range</span>(t, <span class="bu">min</span>(STUNDEN, t <span class="op">+</span> mindestlaufzeit)):</span>
-<span id="cb159-121"><a href="#cb159-121" aria-hidden="true" tabindex="-1"></a>                solver.Add(laeuft[k][spaeter] <span class="op">&gt;=</span> faehrt_an[k][t])</span>
-<span id="cb159-122"><a href="#cb159-122" aria-hidden="true" tabindex="-1"></a>            <span class="co"># Ein laufender Block liefert zwischen Mindest- und Nennleistung,</span></span>
-<span id="cb159-123"><a href="#cb159-123" aria-hidden="true" tabindex="-1"></a>            <span class="co"># ein stehender gar nichts. Das koppelt beide Stufen.</span></span>
-<span id="cb159-124"><a href="#cb159-124" aria-hidden="true" tabindex="-1"></a>            <span class="cf">for</span> j <span class="kw">in</span> <span class="bu">range</span>(anzahl_szenarien):</span>
-<span id="cb159-125"><a href="#cb159-125" aria-hidden="true" tabindex="-1"></a>                solver.Add(leistung[j][k][t] <span class="op">&gt;=</span> pmin <span class="op">*</span> laeuft[k][t])</span>
-<span id="cb159-126"><a href="#cb159-126" aria-hidden="true" tabindex="-1"></a>                solver.Add(leistung[j][k][t] <span class="op">&lt;=</span> pmax <span class="op">*</span> laeuft[k][t])</span>
-<span id="cb159-127"><a href="#cb159-127" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb159-128"><a href="#cb159-128" aria-hidden="true" tabindex="-1"></a>    <span class="cf">for</span> j <span class="kw">in</span> <span class="bu">range</span>(anzahl_szenarien):</span>
-<span id="cb159-129"><a href="#cb159-129" aria-hidden="true" tabindex="-1"></a>        <span class="cf">for</span> t <span class="kw">in</span> <span class="bu">range</span>(STUNDEN):</span>
-<span id="cb159-130"><a href="#cb159-130" aria-hidden="true" tabindex="-1"></a>            solver.Add(<span class="bu">sum</span>(leistung[j][k][t] <span class="cf">for</span> k <span class="kw">in</span> <span class="bu">range</span>(anzahl_bloecke))</span>
-<span id="cb159-131"><a href="#cb159-131" aria-hidden="true" tabindex="-1"></a>                       <span class="op">+</span> <span class="bu">float</span>(wind[j, t]) <span class="op">+</span> nichtdeckung[j][t] <span class="op">&gt;=</span> LAST[t])</span>
-<span id="cb159-132"><a href="#cb159-132" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb159-133"><a href="#cb159-133" aria-hidden="true" tabindex="-1"></a>    <span class="co"># --- Versorgungssicherheit als CVaR-Schranke --------------------------</span></span>
-<span id="cb159-134"><a href="#cb159-134" aria-hidden="true" tabindex="-1"></a>    <span class="cf">if</span> cvar_grenze <span class="kw">is</span> <span class="kw">not</span> <span class="va">None</span>:</span>
-<span id="cb159-135"><a href="#cb159-135" aria-hidden="true" tabindex="-1"></a>        schwelle <span class="op">=</span> solver.NumVar(<span class="op">-</span>solver.infinity(), solver.infinity(), <span class="st">&quot;schwelle&quot;</span>)</span>
-<span id="cb159-136"><a href="#cb159-136" aria-hidden="true" tabindex="-1"></a>        ueberschuss <span class="op">=</span> [solver.NumVar(<span class="dv">0</span>, solver.infinity(), <span class="ss">f&quot;u_</span><span class="sc">{</span>j<span class="sc">}</span><span class="ss">&quot;</span>)</span>
-<span id="cb159-137"><a href="#cb159-137" aria-hidden="true" tabindex="-1"></a>                       <span class="cf">for</span> j <span class="kw">in</span> <span class="bu">range</span>(anzahl_szenarien)]</span>
-<span id="cb159-138"><a href="#cb159-138" aria-hidden="true" tabindex="-1"></a>        <span class="cf">for</span> j <span class="kw">in</span> <span class="bu">range</span>(anzahl_szenarien):</span>
-<span id="cb159-139"><a href="#cb159-139" aria-hidden="true" tabindex="-1"></a>            solver.Add(ueberschuss[j] <span class="op">&gt;=</span> <span class="bu">sum</span>(nichtdeckung[j][t]</span>
-<span id="cb159-140"><a href="#cb159-140" aria-hidden="true" tabindex="-1"></a>                                             <span class="cf">for</span> t <span class="kw">in</span> <span class="bu">range</span>(STUNDEN)) <span class="op">-</span> schwelle)</span>
-<span id="cb159-141"><a href="#cb159-141" aria-hidden="true" tabindex="-1"></a>        solver.Add(schwelle <span class="op">+</span> (<span class="fl">1.0</span> <span class="op">/</span> (anzahl_szenarien <span class="op">*</span> (<span class="dv">1</span> <span class="op">-</span> ALPHA)))</span>
-<span id="cb159-142"><a href="#cb159-142" aria-hidden="true" tabindex="-1"></a>                   <span class="op">*</span> <span class="bu">sum</span>(ueberschuss) <span class="op">&lt;=</span> cvar_grenze)</span>
-<span id="cb159-143"><a href="#cb159-143" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb159-144"><a href="#cb159-144" aria-hidden="true" tabindex="-1"></a>    anfahrkosten <span class="op">=</span> <span class="bu">sum</span>(KRAFTWERKE[k][<span class="dv">4</span>] <span class="op">*</span> faehrt_an[k][t]</span>
-<span id="cb159-145"><a href="#cb159-145" aria-hidden="true" tabindex="-1"></a>                       <span class="cf">for</span> k <span class="kw">in</span> <span class="bu">range</span>(anzahl_bloecke) <span class="cf">for</span> t <span class="kw">in</span> <span class="bu">range</span>(STUNDEN))</span>
-<span id="cb159-146"><a href="#cb159-146" aria-hidden="true" tabindex="-1"></a>    betriebskosten <span class="op">=</span> <span class="bu">sum</span>(</span>
-<span id="cb159-147"><a href="#cb159-147" aria-hidden="true" tabindex="-1"></a>        gewichte[j] <span class="op">*</span> <span class="bu">sum</span>(KRAFTWERKE[k][<span class="dv">3</span>] <span class="op">*</span> leistung[j][k][t]</span>
-<span id="cb159-148"><a href="#cb159-148" aria-hidden="true" tabindex="-1"></a>                          <span class="cf">for</span> k <span class="kw">in</span> <span class="bu">range</span>(anzahl_bloecke) <span class="cf">for</span> t <span class="kw">in</span> <span class="bu">range</span>(STUNDEN))</span>
-<span id="cb159-149"><a href="#cb159-149" aria-hidden="true" tabindex="-1"></a>        <span class="cf">for</span> j <span class="kw">in</span> <span class="bu">range</span>(anzahl_szenarien))</span>
-<span id="cb159-150"><a href="#cb159-150" aria-hidden="true" tabindex="-1"></a>    abwurfkosten <span class="op">=</span> <span class="bu">sum</span>(gewichte[j] <span class="op">*</span> abwurfpreis</span>
-<span id="cb159-151"><a href="#cb159-151" aria-hidden="true" tabindex="-1"></a>                       <span class="op">*</span> <span class="bu">sum</span>(nichtdeckung[j][t] <span class="cf">for</span> t <span class="kw">in</span> <span class="bu">range</span>(STUNDEN))</span>
-<span id="cb159-152"><a href="#cb159-152" aria-hidden="true" tabindex="-1"></a>                       <span class="cf">for</span> j <span class="kw">in</span> <span class="bu">range</span>(anzahl_szenarien))</span>
-<span id="cb159-153"><a href="#cb159-153" aria-hidden="true" tabindex="-1"></a>    solver.Minimize(anfahrkosten <span class="op">+</span> betriebskosten <span class="op">+</span> abwurfkosten)</span>
-<span id="cb159-154"><a href="#cb159-154" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb159-155"><a href="#cb159-155" aria-hidden="true" tabindex="-1"></a>    beginn <span class="op">=</span> time.perf_counter()</span>
-<span id="cb159-156"><a href="#cb159-156" aria-hidden="true" tabindex="-1"></a>    status <span class="op">=</span> solver.Solve()</span>
-<span id="cb159-157"><a href="#cb159-157" aria-hidden="true" tabindex="-1"></a>    dauer <span class="op">=</span> time.perf_counter() <span class="op">-</span> beginn</span>
-<span id="cb159-158"><a href="#cb159-158" aria-hidden="true" tabindex="-1"></a>    <span class="cf">if</span> status <span class="kw">not</span> <span class="kw">in</span> (pywraplp.Solver.OPTIMAL, pywraplp.Solver.FEASIBLE):</span>
-<span id="cb159-159"><a href="#cb159-159" aria-hidden="true" tabindex="-1"></a>        <span class="cf">return</span> <span class="va">None</span>, dauer, <span class="va">False</span></span>
-<span id="cb159-160"><a href="#cb159-160" aria-hidden="true" tabindex="-1"></a>    plan <span class="op">=</span> np.array([[laeuft[k][t].solution_value() <span class="cf">for</span> t <span class="kw">in</span> <span class="bu">range</span>(STUNDEN)]</span>
-<span id="cb159-161"><a href="#cb159-161" aria-hidden="true" tabindex="-1"></a>                     <span class="cf">for</span> k <span class="kw">in</span> <span class="bu">range</span>(anzahl_bloecke)]).<span class="bu">round</span>()</span>
-<span id="cb159-162"><a href="#cb159-162" aria-hidden="true" tabindex="-1"></a>    <span class="cf">return</span> plan, dauer, status <span class="op">==</span> pywraplp.Solver.OPTIMAL</span>
-<span id="cb159-163"><a href="#cb159-163" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb159-164"><a href="#cb159-164" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb159-165"><a href="#cb159-165" aria-hidden="true" tabindex="-1"></a><span class="kw">def</span> bewerte(plan: np.ndarray, wind: np.ndarray, abwurfpreis: <span class="bu">float</span> <span class="op">=</span> <span class="va">None</span>):</span>
-<span id="cb159-166"><a href="#cb159-166" aria-hidden="true" tabindex="-1"></a>    <span class="co">&quot;&quot;&quot;Commitment steht fest - nur noch die Fahrweise je Szenario optimieren.</span></span>
-<span id="cb159-167"><a href="#cb159-167" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb159-168"><a href="#cb159-168" aria-hidden="true" tabindex="-1"></a><span class="co">    Das ist die ehrliche Bewertung eines Plans: Er wird der Wirklichkeit</span></span>
-<span id="cb159-169"><a href="#cb159-169" aria-hidden="true" tabindex="-1"></a><span class="co">    ausgesetzt und darf nur noch das anpassen, was sich am Tag selbst</span></span>
-<span id="cb159-170"><a href="#cb159-170" aria-hidden="true" tabindex="-1"></a><span class="co">    anpassen laesst.</span></span>
-<span id="cb159-171"><a href="#cb159-171" aria-hidden="true" tabindex="-1"></a><span class="co">    &quot;&quot;&quot;</span></span>
-<span id="cb159-172"><a href="#cb159-172" aria-hidden="true" tabindex="-1"></a>    abwurfpreis <span class="op">=</span> LASTABWURF <span class="cf">if</span> abwurfpreis <span class="kw">is</span> <span class="va">None</span> <span class="cf">else</span> abwurfpreis</span>
-<span id="cb159-173"><a href="#cb159-173" aria-hidden="true" tabindex="-1"></a>    anzahl_bloecke <span class="op">=</span> <span class="bu">len</span>(KRAFTWERKE)</span>
-<span id="cb159-174"><a href="#cb159-174" aria-hidden="true" tabindex="-1"></a>    kosten, fehlmengen <span class="op">=</span> [], []</span>
-<span id="cb159-175"><a href="#cb159-175" aria-hidden="true" tabindex="-1"></a>    <span class="cf">for</span> j <span class="kw">in</span> <span class="bu">range</span>(wind.shape[<span class="dv">0</span>]):</span>
-<span id="cb159-176"><a href="#cb159-176" aria-hidden="true" tabindex="-1"></a>        solver <span class="op">=</span> pywraplp.Solver.CreateSolver(<span class="st">&quot;GLOP&quot;</span>)</span>
-<span id="cb159-177"><a href="#cb159-177" aria-hidden="true" tabindex="-1"></a>        leistung <span class="op">=</span> [[solver.NumVar(<span class="dv">0</span>, KRAFTWERKE[k][<span class="dv">2</span>], <span class="ss">f&quot;p_</span><span class="sc">{</span>k<span class="sc">}</span><span class="ss">_</span><span class="sc">{</span>t<span class="sc">}</span><span class="ss">&quot;</span>)</span>
-<span id="cb159-178"><a href="#cb159-178" aria-hidden="true" tabindex="-1"></a>                     <span class="cf">for</span> t <span class="kw">in</span> <span class="bu">range</span>(STUNDEN)] <span class="cf">for</span> k <span class="kw">in</span> <span class="bu">range</span>(anzahl_bloecke)]</span>
-<span id="cb159-179"><a href="#cb159-179" aria-hidden="true" tabindex="-1"></a>        fehlt <span class="op">=</span> [solver.NumVar(<span class="dv">0</span>, solver.infinity(), <span class="ss">f&quot;y_</span><span class="sc">{</span>t<span class="sc">}</span><span class="ss">&quot;</span>)</span>
-<span id="cb159-180"><a href="#cb159-180" aria-hidden="true" tabindex="-1"></a>                 <span class="cf">for</span> t <span class="kw">in</span> <span class="bu">range</span>(STUNDEN)]</span>
-<span id="cb159-181"><a href="#cb159-181" aria-hidden="true" tabindex="-1"></a>        <span class="cf">for</span> k, (_, pmin, pmax, _, _, _) <span class="kw">in</span> <span class="bu">enumerate</span>(KRAFTWERKE):</span>
-<span id="cb159-182"><a href="#cb159-182" aria-hidden="true" tabindex="-1"></a>            <span class="cf">for</span> t <span class="kw">in</span> <span class="bu">range</span>(STUNDEN):</span>
-<span id="cb159-183"><a href="#cb159-183" aria-hidden="true" tabindex="-1"></a>                solver.Add(leistung[k][t] <span class="op">&gt;=</span> pmin <span class="op">*</span> plan[k, t])</span>
-<span id="cb159-184"><a href="#cb159-184" aria-hidden="true" tabindex="-1"></a>                solver.Add(leistung[k][t] <span class="op">&lt;=</span> pmax <span class="op">*</span> plan[k, t])</span>
-<span id="cb159-185"><a href="#cb159-185" aria-hidden="true" tabindex="-1"></a>        <span class="cf">for</span> t <span class="kw">in</span> <span class="bu">range</span>(STUNDEN):</span>
-<span id="cb159-186"><a href="#cb159-186" aria-hidden="true" tabindex="-1"></a>            solver.Add(<span class="bu">sum</span>(leistung[k][t] <span class="cf">for</span> k <span class="kw">in</span> <span class="bu">range</span>(anzahl_bloecke))</span>
-<span id="cb159-187"><a href="#cb159-187" aria-hidden="true" tabindex="-1"></a>                       <span class="op">+</span> <span class="bu">float</span>(wind[j, t]) <span class="op">+</span> fehlt[t] <span class="op">&gt;=</span> LAST[t])</span>
-<span id="cb159-188"><a href="#cb159-188" aria-hidden="true" tabindex="-1"></a>        solver.Minimize(</span>
-<span id="cb159-189"><a href="#cb159-189" aria-hidden="true" tabindex="-1"></a>            <span class="bu">sum</span>(KRAFTWERKE[k][<span class="dv">3</span>] <span class="op">*</span> leistung[k][t]</span>
-<span id="cb159-190"><a href="#cb159-190" aria-hidden="true" tabindex="-1"></a>                <span class="cf">for</span> k <span class="kw">in</span> <span class="bu">range</span>(anzahl_bloecke) <span class="cf">for</span> t <span class="kw">in</span> <span class="bu">range</span>(STUNDEN))</span>
-<span id="cb159-191"><a href="#cb159-191" aria-hidden="true" tabindex="-1"></a>            <span class="op">+</span> <span class="bu">sum</span>(abwurfpreis <span class="op">*</span> fehlt[t] <span class="cf">for</span> t <span class="kw">in</span> <span class="bu">range</span>(STUNDEN)))</span>
-<span id="cb159-192"><a href="#cb159-192" aria-hidden="true" tabindex="-1"></a>        solver.Solve()</span>
-<span id="cb159-193"><a href="#cb159-193" aria-hidden="true" tabindex="-1"></a>        kosten.append(solver.Objective().Value())</span>
-<span id="cb159-194"><a href="#cb159-194" aria-hidden="true" tabindex="-1"></a>        fehlmengen.append(<span class="bu">sum</span>(f.solution_value() <span class="cf">for</span> f <span class="kw">in</span> fehlt))</span>
-<span id="cb159-195"><a href="#cb159-195" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb159-196"><a href="#cb159-196" aria-hidden="true" tabindex="-1"></a>    anfahrten <span class="op">=</span> <span class="bu">sum</span>(KRAFTWERKE[k][<span class="dv">4</span>]</span>
-<span id="cb159-197"><a href="#cb159-197" aria-hidden="true" tabindex="-1"></a>                    <span class="op">*</span> <span class="bu">max</span>(<span class="fl">0.0</span>, plan[k, t] <span class="op">-</span> (plan[k, t <span class="op">-</span> <span class="dv">1</span>] <span class="cf">if</span> t <span class="op">&gt;</span> <span class="dv">0</span> <span class="cf">else</span> <span class="fl">0.0</span>))</span>
-<span id="cb159-198"><a href="#cb159-198" aria-hidden="true" tabindex="-1"></a>                    <span class="cf">for</span> k <span class="kw">in</span> <span class="bu">range</span>(anzahl_bloecke) <span class="cf">for</span> t <span class="kw">in</span> <span class="bu">range</span>(STUNDEN))</span>
-<span id="cb159-199"><a href="#cb159-199" aria-hidden="true" tabindex="-1"></a>    <span class="cf">return</span> np.array(kosten) <span class="op">+</span> anfahrten, np.array(fehlmengen)</span>
-<span id="cb159-200"><a href="#cb159-200" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb159-201"><a href="#cb159-201" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb159-202"><a href="#cb159-202" aria-hidden="true" tabindex="-1"></a><span class="kw">def</span> cvar(werte: np.ndarray, alpha: <span class="bu">float</span> <span class="op">=</span> ALPHA) <span class="op">-&gt;</span> <span class="bu">float</span>:</span>
-<span id="cb159-203"><a href="#cb159-203" aria-hidden="true" tabindex="-1"></a>    <span class="co">&quot;&quot;&quot;Mittelwert der schlechtesten (1-alpha) Faelle.&quot;&quot;&quot;</span></span>
-<span id="cb159-204"><a href="#cb159-204" aria-hidden="true" tabindex="-1"></a>    schwelle <span class="op">=</span> np.quantile(werte, alpha)</span>
-<span id="cb159-205"><a href="#cb159-205" aria-hidden="true" tabindex="-1"></a>    schlechteste <span class="op">=</span> werte[werte <span class="op">&gt;=</span> schwelle]</span>
-<span id="cb159-206"><a href="#cb159-206" aria-hidden="true" tabindex="-1"></a>    <span class="cf">return</span> <span class="bu">float</span>(schlechteste.mean()) <span class="cf">if</span> <span class="bu">len</span>(schlechteste) <span class="cf">else</span> <span class="fl">0.0</span></span>
-<span id="cb159-207"><a href="#cb159-207" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb159-208"><a href="#cb159-208" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb159-209"><a href="#cb159-209" aria-hidden="true" tabindex="-1"></a><span class="kw">def</span> zeige(name: <span class="bu">str</span>, plan, wind, abwurfpreis: <span class="bu">float</span> <span class="op">=</span> <span class="va">None</span>) <span class="op">-&gt;</span> <span class="bu">dict</span>:</span>
-<span id="cb159-210"><a href="#cb159-210" aria-hidden="true" tabindex="-1"></a>    kosten, fehl <span class="op">=</span> bewerte(plan, wind, abwurfpreis)</span>
-<span id="cb159-211"><a href="#cb159-211" aria-hidden="true" tabindex="-1"></a>    kennzahlen <span class="op">=</span> {<span class="st">&quot;mittel&quot;</span>: kosten.mean(), <span class="st">&quot;max&quot;</span>: kosten.<span class="bu">max</span>(),</span>
-<span id="cb159-212"><a href="#cb159-212" aria-hidden="true" tabindex="-1"></a>                  <span class="st">&quot;fehl_mittel&quot;</span>: fehl.mean(), <span class="st">&quot;fehl_cvar&quot;</span>: cvar(fehl),</span>
-<span id="cb159-213"><a href="#cb159-213" aria-hidden="true" tabindex="-1"></a>                  <span class="st">&quot;betroffen&quot;</span>: <span class="bu">int</span>((fehl <span class="op">&gt;</span> <span class="fl">0.01</span>).<span class="bu">sum</span>()),</span>
-<span id="cb159-214"><a href="#cb159-214" aria-hidden="true" tabindex="-1"></a>                  <span class="st">&quot;blockstunden&quot;</span>: <span class="bu">int</span>(plan.<span class="bu">sum</span>())}</span>
-<span id="cb159-215"><a href="#cb159-215" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;  </span><span class="sc">{</span>name<span class="sc">:&lt;32}</span><span class="ss"> </span><span class="sc">{</span>kennzahlen[<span class="st">&#39;mittel&#39;</span>]<span class="sc">:&gt;10,.0f}</span><span class="ss"> </span><span class="sc">{</span>kennzahlen[<span class="st">&#39;max&#39;</span>]<span class="sc">:&gt;11,.0f}</span><span class="ss"> &quot;</span></span>
-<span id="cb159-216"><a href="#cb159-216" aria-hidden="true" tabindex="-1"></a>          <span class="ss">f&quot;</span><span class="sc">{</span>kennzahlen[<span class="st">&#39;fehl_mittel&#39;</span>]<span class="sc">:&gt;9.1f}</span><span class="ss"> </span><span class="sc">{</span>kennzahlen[<span class="st">&#39;fehl_cvar&#39;</span>]<span class="sc">:&gt;10.1f}</span><span class="ss"> &quot;</span></span>
-<span id="cb159-217"><a href="#cb159-217" aria-hidden="true" tabindex="-1"></a>          <span class="ss">f&quot;</span><span class="sc">{</span>kennzahlen[<span class="st">&#39;betroffen&#39;</span>]<span class="sc">:&gt;6}</span><span class="ss">/</span><span class="sc">{</span><span class="bu">len</span>(fehl)<span class="sc">}</span><span class="ss">&quot;</span>)</span>
-<span id="cb159-218"><a href="#cb159-218" aria-hidden="true" tabindex="-1"></a>    <span class="cf">return</span> kennzahlen</span>
-<span id="cb159-219"><a href="#cb159-219" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb159-220"><a href="#cb159-220" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb159-221"><a href="#cb159-221" aria-hidden="true" tabindex="-1"></a><span class="cf">if</span> <span class="va">__name__</span> <span class="op">==</span> <span class="st">&quot;__main__&quot;</span>:</span>
-<span id="cb159-222"><a href="#cb159-222" aria-hidden="true" tabindex="-1"></a>    wind, ist_flaute <span class="op">=</span> erzeuge_windszenarien()</span>
-<span id="cb159-223"><a href="#cb159-223" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb159-224"><a href="#cb159-224" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;=&quot;</span> <span class="op">*</span> <span class="dv">88</span>)</span>
-<span id="cb159-225"><a href="#cb159-225" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;  KRAFTWERKSEINSATZ: DER PLAN STEHT, BEVOR DER WIND WEHT&quot;</span>)</span>
-<span id="cb159-226"><a href="#cb159-226" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;=&quot;</span> <span class="op">*</span> <span class="dv">88</span>)</span>
-<span id="cb159-227"><a href="#cb159-227" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;</span><span class="sc">{</span><span class="bu">len</span>(KRAFTWERKE)<span class="sc">}</span><span class="ss"> Bloecke, </span><span class="sc">{</span>STUNDEN<span class="sc">}</span><span class="ss"> Stunden, </span><span class="sc">{</span>SZENARIEN<span class="sc">}</span><span class="ss"> Windszenarien &quot;</span></span>
-<span id="cb159-228"><a href="#cb159-228" aria-hidden="true" tabindex="-1"></a>          <span class="ss">f&quot;(davon </span><span class="sc">{</span><span class="bu">int</span>(ist_flaute.<span class="bu">sum</span>())<span class="sc">}</span><span class="ss"> Dunkelflauten).&quot;</span>)</span>
-<span id="cb159-229"><a href="#cb159-229" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;Last </span><span class="sc">{</span>LAST<span class="sc">.</span><span class="bu">min</span>()<span class="sc">:.0f}</span><span class="ss"> bis </span><span class="sc">{</span>LAST<span class="sc">.</span><span class="bu">max</span>()<span class="sc">:.0f}</span><span class="ss"> MW, &quot;</span></span>
-<span id="cb159-230"><a href="#cb159-230" aria-hidden="true" tabindex="-1"></a>          <span class="ss">f&quot;Wind im Erwartungswert </span><span class="sc">{</span>WIND_ERWARTUNG<span class="sc">.</span><span class="bu">min</span>()<span class="sc">:.0f}</span><span class="ss"> bis &quot;</span></span>
-<span id="cb159-231"><a href="#cb159-231" aria-hidden="true" tabindex="-1"></a>          <span class="ss">f&quot;</span><span class="sc">{</span>WIND_ERWARTUNG<span class="sc">.</span><span class="bu">max</span>()<span class="sc">:.0f}</span><span class="ss"> MW.&quot;</span>)</span>
-<span id="cb159-232"><a href="#cb159-232" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;Nicht gedeckte Last kostet </span><span class="sc">{</span>LASTABWURF<span class="sc">:,.0f}</span><span class="ss"> EUR je MWh.</span><span class="ch">\n</span><span class="ss">&quot;</span>)</span>
-<span id="cb159-233"><a href="#cb159-233" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb159-234"><a href="#cb159-234" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;  </span><span class="sc">{</span><span class="st">&#39;Planungsgrundlage&#39;</span><span class="sc">:&lt;32}</span><span class="ss"> </span><span class="sc">{</span><span class="st">&#39;Kosten&#39;</span><span class="sc">:&gt;10}</span><span class="ss"> </span><span class="sc">{</span><span class="st">&#39;Kosten&#39;</span><span class="sc">:&gt;11}</span><span class="ss"> &quot;</span></span>
-<span id="cb159-235"><a href="#cb159-235" aria-hidden="true" tabindex="-1"></a>          <span class="ss">f&quot;</span><span class="sc">{</span><span class="st">&#39;Fehlmenge&#39;</span><span class="sc">:&gt;9}</span><span class="ss"> </span><span class="sc">{</span><span class="st">&#39;Fehlmenge&#39;</span><span class="sc">:&gt;10}</span><span class="ss"> </span><span class="sc">{</span><span class="st">&#39;Szen. mit&#39;</span><span class="sc">:&gt;12}</span><span class="ss">&quot;</span>)</span>
-<span id="cb159-236"><a href="#cb159-236" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;  </span><span class="sc">{</span><span class="st">&#39;&#39;</span><span class="sc">:&lt;32}</span><span class="ss"> </span><span class="sc">{</span><span class="st">&#39;im Mittel&#39;</span><span class="sc">:&gt;10}</span><span class="ss"> </span><span class="sc">{</span><span class="st">&#39;schlimmst.&#39;</span><span class="sc">:&gt;11}</span><span class="ss"> &quot;</span></span>
-<span id="cb159-237"><a href="#cb159-237" aria-hidden="true" tabindex="-1"></a>          <span class="ss">f&quot;</span><span class="sc">{</span><span class="st">&#39;Mittel&#39;</span><span class="sc">:&gt;9}</span><span class="ss"> </span><span class="sc">{</span><span class="st">&#39;CVaR 90%&#39;</span><span class="sc">:&gt;10}</span><span class="ss"> </span><span class="sc">{</span><span class="st">&#39;Abwurf&#39;</span><span class="sc">:&gt;12}</span><span class="ss">&quot;</span>)</span>
-<span id="cb159-238"><a href="#cb159-238" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;  &quot;</span> <span class="op">+</span> <span class="st">&quot;-&quot;</span> <span class="op">*</span> <span class="dv">86</span>)</span>
-<span id="cb159-239"><a href="#cb159-239" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb159-240"><a href="#cb159-240" aria-hidden="true" tabindex="-1"></a>    <span class="co"># --- 1. Deterministisch ----------------------------------------------</span></span>
-<span id="cb159-241"><a href="#cb159-241" aria-hidden="true" tabindex="-1"></a>    plan_det, dauer_det, _ <span class="op">=</span> plane(WIND_ERWARTUNG.reshape(<span class="dv">1</span>, <span class="op">-</span><span class="dv">1</span>), [<span class="fl">1.0</span>])</span>
-<span id="cb159-242"><a href="#cb159-242" aria-hidden="true" tabindex="-1"></a>    det <span class="op">=</span> zeige(<span class="st">&quot;nur Wind-Erwartungswert&quot;</span>, plan_det, wind)</span>
-<span id="cb159-243"><a href="#cb159-243" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb159-244"><a href="#cb159-244" aria-hidden="true" tabindex="-1"></a>    <span class="co"># --- 2. Zweistufig, risikoneutral ------------------------------------</span></span>
-<span id="cb159-245"><a href="#cb159-245" aria-hidden="true" tabindex="-1"></a>    gleich <span class="op">=</span> [<span class="fl">1.0</span> <span class="op">/</span> SZENARIEN] <span class="op">*</span> SZENARIEN</span>
-<span id="cb159-246"><a href="#cb159-246" aria-hidden="true" tabindex="-1"></a>    plan_sto, dauer_sto, optimal_sto <span class="op">=</span> plane(wind, gleich)</span>
-<span id="cb159-247"><a href="#cb159-247" aria-hidden="true" tabindex="-1"></a>    sto <span class="op">=</span> zeige(<span class="st">&quot;alle 40 Szenarien&quot;</span>, plan_sto, wind)</span>
-<span id="cb159-248"><a href="#cb159-248" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb159-249"><a href="#cb159-249" aria-hidden="true" tabindex="-1"></a>    <span class="co"># --- 3. Mit Versorgungssicherheit ------------------------------------</span></span>
-<span id="cb159-250"><a href="#cb159-250" aria-hidden="true" tabindex="-1"></a>    plan_sicher, dauer_sicher, optimal_sicher <span class="op">=</span> plane(wind, gleich, cvar_grenze<span class="op">=</span><span class="fl">0.0</span>)</span>
-<span id="cb159-251"><a href="#cb159-251" aria-hidden="true" tabindex="-1"></a>    sicher <span class="op">=</span> zeige(<span class="st">&quot;+ Nichtdeckung CVaR 90 % = 0&quot;</span>, plan_sicher, wind)</span>
-<span id="cb159-252"><a href="#cb159-252" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb159-253"><a href="#cb159-253" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;</span><span class="ch">\n</span><span class="ss">  Rechenzeiten: </span><span class="sc">{</span>dauer_det<span class="sc">:.1f}</span><span class="ss">s / </span><span class="sc">{</span>dauer_sto<span class="sc">:.1f}</span><span class="ss">s / </span><span class="sc">{</span>dauer_sicher<span class="sc">:.1f}</span><span class="ss">s &quot;</span></span>
-<span id="cb159-254"><a href="#cb159-254" aria-hidden="true" tabindex="-1"></a>          <span class="ss">f&quot;(alle beweisbar optimal: </span><span class="sc">{</span>optimal_sto <span class="kw">and</span> optimal_sicher<span class="sc">}</span><span class="ss">)&quot;</span>)</span>
-<span id="cb159-255"><a href="#cb159-255" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb159-256"><a href="#cb159-256" aria-hidden="true" tabindex="-1"></a>    <span class="co"># --- Was die Zeilen bedeuten -----------------------------------------</span></span>
-<span id="cb159-257"><a href="#cb159-257" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;</span><span class="ch">\n</span><span class="st">&quot;</span> <span class="op">+</span> <span class="st">&quot;-&quot;</span> <span class="op">*</span> <span class="dv">88</span>)</span>
-<span id="cb159-258"><a href="#cb159-258" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;Was der Erwartungswert-Plan anrichtet</span><span class="ch">\n</span><span class="st">&quot;</span>)</span>
-<span id="cb159-259"><a href="#cb159-259" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;  Er ist auf dem Papier der billigste - gerechnet auf den mittleren&quot;</span>)</span>
-<span id="cb159-260"><a href="#cb159-260" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;  Wind kostet er weniger als jeder andere. In der Wirklichkeit liegt&quot;</span>)</span>
-<span id="cb159-261"><a href="#cb159-261" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;  er </span><span class="sc">{</span>det[<span class="st">&#39;mittel&#39;</span>] <span class="op">/</span> sto[<span class="st">&#39;mittel&#39;</span>] <span class="op">-</span> <span class="dv">1</span><span class="sc">:+.0%}</span><span class="ss"> ueber dem zweistufigen Plan, und sein &quot;</span></span>
-<span id="cb159-262"><a href="#cb159-262" aria-hidden="true" tabindex="-1"></a>          <span class="ss">f&quot;schlimmster Tag&quot;</span>)</span>
-<span id="cb159-263"><a href="#cb159-263" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;  kostet </span><span class="sc">{</span>det[<span class="st">&#39;max&#39;</span>] <span class="op">/</span> sto[<span class="st">&#39;max&#39;</span>]<span class="sc">:.1f}</span><span class="ss">-mal so viel.&quot;</span>)</span>
-<span id="cb159-264"><a href="#cb159-264" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;</span><span class="ch">\n</span><span class="ss">  Der Grund steht in der letzten Spalte: In </span><span class="sc">{</span>det[<span class="st">&#39;betroffen&#39;</span>]<span class="sc">}</span><span class="ss"> von </span><span class="sc">{</span>SZENARIEN<span class="sc">}</span><span class="ss"> &quot;</span></span>
-<span id="cb159-265"><a href="#cb159-265" aria-hidden="true" tabindex="-1"></a>          <span class="ss">f&quot;Szenarien muss&quot;</span>)</span>
-<span id="cb159-266"><a href="#cb159-266" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;  Last abgeworfen werden. Was fehlt, sind nicht Kraftwerke, sondern&quot;</span>)</span>
-<span id="cb159-267"><a href="#cb159-267" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;  ANGEFAHRENE Kraftwerke - und ein Block mit acht Stunden&quot;</span>)</span>
-<span id="cb159-268"><a href="#cb159-268" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;  Mindestlaufzeit laesst sich um 18 Uhr nicht mehr herbeirufen.&quot;</span>)</span>
-<span id="cb159-269"><a href="#cb159-269" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb159-270"><a href="#cb159-270" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;</span><span class="ch">\n</span><span class="ss">  Der Unterschied im Plan ist klein:&quot;</span>)</span>
-<span id="cb159-271"><a href="#cb159-271" aria-hidden="true" tabindex="-1"></a>    <span class="cf">for</span> name, plan <span class="kw">in</span> [(<span class="st">&quot;Erwartungswert&quot;</span>, plan_det), (<span class="st">&quot;zweistufig&quot;</span>, plan_sto),</span>
-<span id="cb159-272"><a href="#cb159-272" aria-hidden="true" tabindex="-1"></a>                       (<span class="st">&quot;mit Sicherheit&quot;</span>, plan_sicher)]:</span>
-<span id="cb159-273"><a href="#cb159-273" aria-hidden="true" tabindex="-1"></a>        laufend <span class="op">=</span> plan.<span class="bu">sum</span>(axis<span class="op">=</span><span class="dv">0</span>).astype(<span class="bu">int</span>)</span>
-<span id="cb159-274"><a href="#cb159-274" aria-hidden="true" tabindex="-1"></a>        <span class="bu">print</span>(<span class="ss">f&quot;    </span><span class="sc">{</span>name<span class="sc">:&lt;16}</span><span class="ss"> </span><span class="sc">{</span><span class="st">&#39;&#39;</span><span class="sc">.</span>join(<span class="bu">str</span>(x) <span class="cf">for</span> x <span class="kw">in</span> laufend)<span class="sc">}</span><span class="ss">  &quot;</span></span>
-<span id="cb159-275"><a href="#cb159-275" aria-hidden="true" tabindex="-1"></a>              <span class="ss">f&quot;(</span><span class="sc">{</span><span class="bu">int</span>(plan.<span class="bu">sum</span>())<span class="sc">}</span><span class="ss"> Blockstunden)&quot;</span>)</span>
-<span id="cb159-276"><a href="#cb159-276" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;</span><span class="ch">\n</span><span class="ss">  Der zweistufige Plan haelt </span><span class="sc">{</span>sto[<span class="st">&#39;blockstunden&#39;</span>] <span class="op">-</span> det[<span class="st">&#39;blockstunden&#39;</span>]<span class="sc">}</span><span class="ss"> &quot;</span></span>
-<span id="cb159-277"><a href="#cb159-277" aria-hidden="true" tabindex="-1"></a>          <span class="ss">f&quot;Blockstunden mehr vor - das genuegt,&quot;</span>)</span>
-<span id="cb159-278"><a href="#cb159-278" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;  um alle </span><span class="sc">{</span>det[<span class="st">&#39;betroffen&#39;</span>]<span class="sc">}</span><span class="ss"> Lastabwuerfe zu vermeiden.&quot;</span>)</span>
-<span id="cb159-279"><a href="#cb159-279" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb159-280"><a href="#cb159-280" aria-hidden="true" tabindex="-1"></a>    <span class="co"># --- Der Preis der Sicherheit ----------------------------------------</span></span>
-<span id="cb159-281"><a href="#cb159-281" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;</span><span class="ch">\n</span><span class="st">&quot;</span> <span class="op">+</span> <span class="st">&quot;-&quot;</span> <span class="op">*</span> <span class="dv">88</span>)</span>
-<span id="cb159-282"><a href="#cb159-282" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;Was Versorgungssicherheit kostet</span><span class="ch">\n</span><span class="st">&quot;</span>)</span>
-<span id="cb159-283"><a href="#cb159-283" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;  Bei </span><span class="sc">{</span>LASTABWURF<span class="sc">:,.0f}</span><span class="ss"> EUR/MWh kostet die CVaR-Schranke NICHTS: Der&quot;</span>)</span>
-<span id="cb159-284"><a href="#cb159-284" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;  risikoneutrale Plan haelt sie schon ein. Das ist kein Zufall - bei&quot;</span>)</span>
-<span id="cb159-285"><a href="#cb159-285" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;  diesem Preis lohnt sich Vorhaltung bereits im Erwartungswert.&quot;</span>)</span>
-<span id="cb159-286"><a href="#cb159-286" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;</span><span class="ch">\n</span><span class="st">  Interessant wird die Schranke dort, wo der Schaden ZU NIEDRIG&quot;</span>)</span>
-<span id="cb159-287"><a href="#cb159-287" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;  bepreist ist. Dieselbe Rechnung mit einem Marktpreisdeckel von&quot;</span>)</span>
-<span id="cb159-288"><a href="#cb159-288" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;  </span><span class="sc">{</span>NIEDRIGER_ABWURFPREIS<span class="sc">:,.0f}</span><span class="ss"> EUR/MWh statt </span><span class="sc">{</span>LASTABWURF<span class="sc">:,.0f}</span><span class="ss">:</span><span class="ch">\n</span><span class="ss">&quot;</span>)</span>
-<span id="cb159-289"><a href="#cb159-289" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb159-290"><a href="#cb159-290" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;  </span><span class="sc">{</span><span class="st">&#39;Planungsgrundlage&#39;</span><span class="sc">:&lt;32}</span><span class="ss"> </span><span class="sc">{</span><span class="st">&#39;Kosten&#39;</span><span class="sc">:&gt;10}</span><span class="ss"> </span><span class="sc">{</span><span class="st">&#39;Kosten&#39;</span><span class="sc">:&gt;11}</span><span class="ss"> &quot;</span></span>
-<span id="cb159-291"><a href="#cb159-291" aria-hidden="true" tabindex="-1"></a>          <span class="ss">f&quot;</span><span class="sc">{</span><span class="st">&#39;Fehlmenge&#39;</span><span class="sc">:&gt;9}</span><span class="ss"> </span><span class="sc">{</span><span class="st">&#39;Fehlmenge&#39;</span><span class="sc">:&gt;10}</span><span class="ss"> </span><span class="sc">{</span><span class="st">&#39;Szen. mit&#39;</span><span class="sc">:&gt;12}</span><span class="ss">&quot;</span>)</span>
-<span id="cb159-292"><a href="#cb159-292" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;  </span><span class="sc">{</span><span class="st">&#39;&#39;</span><span class="sc">:&lt;32}</span><span class="ss"> </span><span class="sc">{</span><span class="st">&#39;im Mittel&#39;</span><span class="sc">:&gt;10}</span><span class="ss"> </span><span class="sc">{</span><span class="st">&#39;schlimmst.&#39;</span><span class="sc">:&gt;11}</span><span class="ss"> &quot;</span></span>
-<span id="cb159-293"><a href="#cb159-293" aria-hidden="true" tabindex="-1"></a>          <span class="ss">f&quot;</span><span class="sc">{</span><span class="st">&#39;Mittel&#39;</span><span class="sc">:&gt;9}</span><span class="ss"> </span><span class="sc">{</span><span class="st">&#39;CVaR 90%&#39;</span><span class="sc">:&gt;10}</span><span class="ss"> </span><span class="sc">{</span><span class="st">&#39;Abwurf&#39;</span><span class="sc">:&gt;12}</span><span class="ss">&quot;</span>)</span>
-<span id="cb159-294"><a href="#cb159-294" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;  &quot;</span> <span class="op">+</span> <span class="st">&quot;-&quot;</span> <span class="op">*</span> <span class="dv">86</span>)</span>
-<span id="cb159-295"><a href="#cb159-295" aria-hidden="true" tabindex="-1"></a>    plan_billig, _, _ <span class="op">=</span> plane(wind, gleich, abwurfpreis<span class="op">=</span>NIEDRIGER_ABWURFPREIS)</span>
-<span id="cb159-296"><a href="#cb159-296" aria-hidden="true" tabindex="-1"></a>    billig <span class="op">=</span> zeige(<span class="st">&quot;risikoneutral, billiger Abwurf&quot;</span>, plan_billig, wind,</span>
-<span id="cb159-297"><a href="#cb159-297" aria-hidden="true" tabindex="-1"></a>                   NIEDRIGER_ABWURFPREIS)</span>
-<span id="cb159-298"><a href="#cb159-298" aria-hidden="true" tabindex="-1"></a>    plan_billig_sicher, _, _ <span class="op">=</span> plane(wind, gleich, cvar_grenze<span class="op">=</span><span class="fl">0.0</span>,</span>
-<span id="cb159-299"><a href="#cb159-299" aria-hidden="true" tabindex="-1"></a>                                     abwurfpreis<span class="op">=</span>NIEDRIGER_ABWURFPREIS)</span>
-<span id="cb159-300"><a href="#cb159-300" aria-hidden="true" tabindex="-1"></a>    billig_sicher <span class="op">=</span> zeige(<span class="st">&quot;+ CVaR 90 </span><span class="sc">% d</span><span class="st">er Fehlmenge = 0&quot;</span>, plan_billig_sicher, wind,</span>
-<span id="cb159-301"><a href="#cb159-301" aria-hidden="true" tabindex="-1"></a>                          NIEDRIGER_ABWURFPREIS)</span>
-<span id="cb159-302"><a href="#cb159-302" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb159-303"><a href="#cb159-303" aria-hidden="true" tabindex="-1"></a>    aufpreis <span class="op">=</span> billig_sicher[<span class="st">&quot;mittel&quot;</span>] <span class="op">-</span> billig[<span class="st">&quot;mittel&quot;</span>]</span>
-<span id="cb159-304"><a href="#cb159-304" aria-hidden="true" tabindex="-1"></a>    vermieden <span class="op">=</span> billig[<span class="st">&quot;fehl_cvar&quot;</span>] <span class="op">-</span> billig_sicher[<span class="st">&quot;fehl_cvar&quot;</span>]</span>
-<span id="cb159-305"><a href="#cb159-305" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;</span><span class="ch">\n</span><span class="ss">  Jetzt greift die Schranke: Der risikoneutrale Plan nimmt in&quot;</span>)</span>
-<span id="cb159-306"><a href="#cb159-306" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;  </span><span class="sc">{</span>billig[<span class="st">&#39;betroffen&#39;</span>]<span class="sc">}</span><span class="ss"> von </span><span class="sc">{</span>SZENARIEN<span class="sc">}</span><span class="ss"> Szenarien einen Lastabwurf in Kauf, weil er bei&quot;</span>)</span>
-<span id="cb159-307"><a href="#cb159-307" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;  </span><span class="sc">{</span>NIEDRIGER_ABWURFPREIS<span class="sc">:,.0f}</span><span class="ss"> EUR/MWh billiger ist als das Vorhalten eines Blocks.&quot;</span>)</span>
-<span id="cb159-308"><a href="#cb159-308" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;</span><span class="ch">\n</span><span class="ss">  Aufpreis fuer die Sicherheit: </span><span class="sc">{</span>aufpreis<span class="sc">:,.0f}</span><span class="ss"> EUR je Tag&quot;</span>)</span>
-<span id="cb159-309"><a href="#cb159-309" aria-hidden="true" tabindex="-1"></a>    <span class="cf">if</span> vermieden <span class="op">&gt;</span> <span class="fl">0.01</span>:</span>
-<span id="cb159-310"><a href="#cb159-310" aria-hidden="true" tabindex="-1"></a>        <span class="bu">print</span>(<span class="ss">f&quot;  Vermiedene Fehlmenge (CVaR 90 %): </span><span class="sc">{</span>vermieden<span class="sc">:.1f}</span><span class="ss"> MWh&quot;</span>)</span>
-<span id="cb159-311"><a href="#cb159-311" aria-hidden="true" tabindex="-1"></a>        <span class="bu">print</span>(<span class="ss">f&quot;  -&gt; </span><span class="sc">{</span>aufpreis <span class="op">/</span> vermieden<span class="sc">:,.0f}</span><span class="ss"> EUR je vermiedener MWh&quot;</span>)</span>
-<span id="cb159-312"><a href="#cb159-312" aria-hidden="true" tabindex="-1"></a>        <span class="bu">print</span>(<span class="ss">f&quot;</span><span class="ch">\n</span><span class="ss">  Diese Zahl ist die Entscheidungsgrundlage - genau wie die Spalte&quot;</span>)</span>
-<span id="cb159-313"><a href="#cb159-313" aria-hidden="true" tabindex="-1"></a>        <span class="bu">print</span>(<span class="ss">f&quot;  &#39;EUR je kg&#39; im Kapitel Mehrziel. Sie sagt der Aufsicht, was ihre&quot;</span>)</span>
-<span id="cb159-314"><a href="#cb159-314" aria-hidden="true" tabindex="-1"></a>        <span class="bu">print</span>(<span class="ss">f&quot;  Versorgungssicherheitsvorgabe tatsaechlich kostet, statt darueber&quot;</span>)</span>
-<span id="cb159-315"><a href="#cb159-315" aria-hidden="true" tabindex="-1"></a>        <span class="bu">print</span>(<span class="ss">f&quot;  zu streiten, wie wichtig sie ist.&quot;</span>)</span>
-<span id="cb159-316"><a href="#cb159-316" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb159-317"><a href="#cb159-317" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;</span><span class="ch">\n</span><span class="st">&quot;</span> <span class="op">+</span> <span class="st">&quot;=&quot;</span> <span class="op">*</span> <span class="dv">88</span>)</span>
-<span id="cb159-318"><a href="#cb159-318" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;  WAS MAN DARAUS MITNIMMT&quot;</span>)</span>
-<span id="cb159-319"><a href="#cb159-319" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;=&quot;</span> <span class="op">*</span> <span class="dv">88</span>)</span>
-<span id="cb159-320"><a href="#cb159-320" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;1. Die erste Stufe ist binaer und traege. Was am Vorabend nicht&quot;</span>)</span>
-<span id="cb159-321"><a href="#cb159-321" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;   angefahren wurde, steht am naechsten Tag nicht zur Verfuegung -&quot;</span>)</span>
-<span id="cb159-322"><a href="#cb159-322" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;   egal, wie hoch der Preis dann steigt.&quot;</span>)</span>
-<span id="cb159-323"><a href="#cb159-323" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;2. Deshalb ist der Erwartungswert als Planungsgrundlage nicht nur&quot;</span>)</span>
-<span id="cb159-324"><a href="#cb159-324" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;   ungenau, sondern SYSTEMATISCH zu knapp: Er plant fuer einen Tag,&quot;</span>)</span>
-<span id="cb159-325"><a href="#cb159-325" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;   der so nie eintritt, und laesst keine Reserve fuer die Haelfte&quot;</span>)</span>
-<span id="cb159-326"><a href="#cb159-326" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;   der Faelle, in denen es schlechter kommt.&quot;</span>)</span>
-<span id="cb159-327"><a href="#cb159-327" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;3. Der Ausweg ist keine bessere Windprognose, sondern ein Modell,&quot;</span>)</span>
-<span id="cb159-328"><a href="#cb159-328" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;   das die Szenarien SIEHT. Die Rechenzeit dafuer liegt hier im&quot;</span>)</span>
-<span id="cb159-329"><a href="#cb159-329" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;   Sekundenbereich - der Aufwand ist die Modellierung, nicht der&quot;</span>)</span>
-<span id="cb159-330"><a href="#cb159-330" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;   Solver.&quot;</span>)</span>
-<span id="cb159-331"><a href="#cb159-331" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;4. Wo der Lastabwurf teuer genug bepreist ist, deckt schon die&quot;</span>)</span>
-<span id="cb159-332"><a href="#cb159-332" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;   Minimierung der ERWARTETEN Kosten die Extremfaelle mit ab. Die&quot;</span>)</span>
-<span id="cb159-333"><a href="#cb159-333" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;   Risikoschranke wird genau dann gebraucht, wenn der Schaden ZU&quot;</span>)</span>
-<span id="cb159-334"><a href="#cb159-334" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;   NIEDRIG bepreist ist - was bei Versorgungssicherheit die Regel&quot;</span>)</span>
-<span id="cb159-335"><a href="#cb159-335" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;   ist, weil ein Marktpreisdeckel nicht den volkswirtschaftlichen&quot;</span>)</span>
-<span id="cb159-336"><a href="#cb159-336" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;   Schaden abbildet. Dann liefert sie den Preis der Vorgabe in Euro&quot;</span>)</span>
-<span id="cb159-337"><a href="#cb159-337" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;   je vermiedener MWh, und darueber laesst sich verhandeln.&quot;</span>)</span>
-<span id="cb159-338"><a href="#cb159-338" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;=&quot;</span> <span class="op">*</span> <span class="dv">88</span>)</span></code></pre></div>
+<div class="sourceCode" id="cb161"><pre class="sourceCode python"><code class="sourceCode python"><span id="cb161-1"><a href="#cb161-1" aria-hidden="true" tabindex="-1"></a><span class="co">#!/usr/bin/env python3</span></span>
+<span id="cb161-2"><a href="#cb161-2" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb161-3"><a href="#cb161-3" aria-hidden="true" tabindex="-1"></a><span class="co"># Kraftwerkseinsatz.py</span></span>
+<span id="cb161-4"><a href="#cb161-4" aria-hidden="true" tabindex="-1"></a><span class="co">&quot;&quot;&quot;</span></span>
+<span id="cb161-5"><a href="#cb161-5" aria-hidden="true" tabindex="-1"></a><span class="co">Kapitel Supply-Chain: Welche Bloecke laufen morgen? Und was, wenn kein Wind weht?</span></span>
+<span id="cb161-6"><a href="#cb161-6" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb161-7"><a href="#cb161-7" aria-hidden="true" tabindex="-1"></a><span class="co">Die Kraftwerkseinsatzplanung (englisch Unit Commitment) ist die Aufgabe, an der</span></span>
+<span id="cb161-8"><a href="#cb161-8" aria-hidden="true" tabindex="-1"></a><span class="co">sich in der Energiewirtschaft alles entscheidet: Fuer jede Stunde des naechsten</span></span>
+<span id="cb161-9"><a href="#cb161-9" aria-hidden="true" tabindex="-1"></a><span class="co">Tages muss feststehen, welche Bloecke am Netz sind. Ein Kernblock braucht acht</span></span>
+<span id="cb161-10"><a href="#cb161-10" aria-hidden="true" tabindex="-1"></a><span class="co">Stunden Mindestlaufzeit und 40.000 Euro Anfahrkosten - wer ihn abschaltet, hat</span></span>
+<span id="cb161-11"><a href="#cb161-11" aria-hidden="true" tabindex="-1"></a><span class="co">ihn fuer den Rest des Tages verloren.</span></span>
+<span id="cb161-12"><a href="#cb161-12" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb161-13"><a href="#cb161-13" aria-hidden="true" tabindex="-1"></a><span class="co">Das Besondere liegt in der Zeitstruktur, und es geht ueber das zweistufige</span></span>
+<span id="cb161-14"><a href="#cb161-14" aria-hidden="true" tabindex="-1"></a><span class="co">Modell aus dem Kapitel Unsicherheit hinaus:</span></span>
+<span id="cb161-15"><a href="#cb161-15" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb161-16"><a href="#cb161-16" aria-hidden="true" tabindex="-1"></a><span class="co">    STUFE 1   Das AN/AUS je Block und Stunde. Binaer, und es steht am Vorabend</span></span>
+<span id="cb161-17"><a href="#cb161-17" aria-hidden="true" tabindex="-1"></a><span class="co">              fest - bevor irgendjemand weiss, wie viel Wind morgen weht.</span></span>
+<span id="cb161-18"><a href="#cb161-18" aria-hidden="true" tabindex="-1"></a><span class="co">    STUFE 2   Die Fahrweise: wie viel jeder laufende Block liefert. Das darf</span></span>
+<span id="cb161-19"><a href="#cb161-19" aria-hidden="true" tabindex="-1"></a><span class="co">              sich stundenweise an die Wirklichkeit anpassen.</span></span>
+<span id="cb161-20"><a href="#cb161-20" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb161-21"><a href="#cb161-21" aria-hidden="true" tabindex="-1"></a><span class="co">Die erste Stufe ist also GANZZAHLIG und szenariouebergreifend gleich, die</span></span>
+<span id="cb161-22"><a href="#cb161-22" aria-hidden="true" tabindex="-1"></a><span class="co">zweite kontinuierlich und je Szenario verschieden. Genau diese Kombination</span></span>
+<span id="cb161-23"><a href="#cb161-23" aria-hidden="true" tabindex="-1"></a><span class="co">macht das Problem interessant - und sie ist der Grund, warum ein Plan, der auf</span></span>
+<span id="cb161-24"><a href="#cb161-24" aria-hidden="true" tabindex="-1"></a><span class="co">den Wind-Erwartungswert gerechnet wurde, in der Wirklichkeit teuer wird.</span></span>
+<span id="cb161-25"><a href="#cb161-25" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb161-26"><a href="#cb161-26" aria-hidden="true" tabindex="-1"></a><span class="co">Das Programm zeigt drei Plaene auf denselben Daten:</span></span>
+<span id="cb161-27"><a href="#cb161-27" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb161-28"><a href="#cb161-28" aria-hidden="true" tabindex="-1"></a><span class="co">  1. Deterministisch: gerechnet mit dem Wind-ERWARTUNGSWERT, danach gegen 40</span></span>
+<span id="cb161-29"><a href="#cb161-29" aria-hidden="true" tabindex="-1"></a><span class="co">     Szenarien ausgewertet.</span></span>
+<span id="cb161-30"><a href="#cb161-30" aria-hidden="true" tabindex="-1"></a><span class="co">  2. Zweistufig: der Commitment-Plan sieht alle 40 Szenarien.</span></span>
+<span id="cb161-31"><a href="#cb161-31" aria-hidden="true" tabindex="-1"></a><span class="co">  3. Mit Versorgungssicherheit: die Nichtdeckung in den schlechtesten Faellen</span></span>
+<span id="cb161-32"><a href="#cb161-32" aria-hidden="true" tabindex="-1"></a><span class="co">     wird begrenzt - und der Preis dafuer in Euro je vermiedener MWh</span></span>
+<span id="cb161-33"><a href="#cb161-33" aria-hidden="true" tabindex="-1"></a><span class="co">     ausgewiesen.</span></span>
+<span id="cb161-34"><a href="#cb161-34" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb161-35"><a href="#cb161-35" aria-hidden="true" tabindex="-1"></a><span class="co">Benoetigt: numpy, ortools</span></span>
+<span id="cb161-36"><a href="#cb161-36" aria-hidden="true" tabindex="-1"></a><span class="co">&quot;&quot;&quot;</span></span>
+<span id="cb161-37"><a href="#cb161-37" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb161-38"><a href="#cb161-38" aria-hidden="true" tabindex="-1"></a><span class="im">from</span> __future__ <span class="im">import</span> annotations</span>
+<span id="cb161-39"><a href="#cb161-39" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb161-40"><a href="#cb161-40" aria-hidden="true" tabindex="-1"></a><span class="im">import</span> time</span>
+<span id="cb161-41"><a href="#cb161-41" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb161-42"><a href="#cb161-42" aria-hidden="true" tabindex="-1"></a><span class="im">import</span> numpy <span class="im">as</span> np</span>
+<span id="cb161-43"><a href="#cb161-43" aria-hidden="true" tabindex="-1"></a><span class="im">from</span> ortools.linear_solver <span class="im">import</span> pywraplp</span>
+<span id="cb161-44"><a href="#cb161-44" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb161-45"><a href="#cb161-45" aria-hidden="true" tabindex="-1"></a><span class="co"># (Name, Mindestleistung, Nennleistung, Grenzkosten, Anfahrkosten, Mindestlaufzeit)</span></span>
+<span id="cb161-46"><a href="#cb161-46" aria-hidden="true" tabindex="-1"></a>KRAFTWERKE <span class="op">=</span> [</span>
+<span id="cb161-47"><a href="#cb161-47" aria-hidden="true" tabindex="-1"></a>    (<span class="st">&quot;Kernblock&quot;</span>,   <span class="dv">200</span>, <span class="dv">600</span>,  <span class="dv">22</span>, <span class="dv">40_000</span>, <span class="dv">8</span>),</span>
+<span id="cb161-48"><a href="#cb161-48" aria-hidden="true" tabindex="-1"></a>    (<span class="st">&quot;Braunkohle&quot;</span>,  <span class="dv">100</span>, <span class="dv">400</span>,  <span class="dv">35</span>, <span class="dv">18_000</span>, <span class="dv">6</span>),</span>
+<span id="cb161-49"><a href="#cb161-49" aria-hidden="true" tabindex="-1"></a>    (<span class="st">&quot;Steinkohle&quot;</span>,   <span class="dv">80</span>, <span class="dv">300</span>,  <span class="dv">48</span>, <span class="dv">12_000</span>, <span class="dv">4</span>),</span>
+<span id="cb161-50"><a href="#cb161-50" aria-hidden="true" tabindex="-1"></a>    (<span class="st">&quot;Gas GuD&quot;</span>,      <span class="dv">50</span>, <span class="dv">250</span>,  <span class="dv">72</span>,  <span class="dv">6_000</span>, <span class="dv">2</span>),</span>
+<span id="cb161-51"><a href="#cb161-51" aria-hidden="true" tabindex="-1"></a>    (<span class="st">&quot;Gasturbine&quot;</span>,   <span class="dv">20</span>, <span class="dv">150</span>, <span class="dv">105</span>,   <span class="dv">1_500</span>, <span class="dv">1</span>),</span>
+<span id="cb161-52"><a href="#cb161-52" aria-hidden="true" tabindex="-1"></a>]</span>
+<span id="cb161-53"><a href="#cb161-53" aria-hidden="true" tabindex="-1"></a>STUNDEN <span class="op">=</span> <span class="dv">24</span></span>
+<span id="cb161-54"><a href="#cb161-54" aria-hidden="true" tabindex="-1"></a>SZENARIEN <span class="op">=</span> <span class="dv">40</span></span>
+<span id="cb161-55"><a href="#cb161-55" aria-hidden="true" tabindex="-1"></a>FLAUTENANTEIL <span class="op">=</span> <span class="fl">0.15</span></span>
+<span id="cb161-56"><a href="#cb161-56" aria-hidden="true" tabindex="-1"></a>ALPHA <span class="op">=</span> <span class="fl">0.90</span>                  <span class="co"># die schlechtesten 10 % der Szenarien</span></span>
+<span id="cb161-57"><a href="#cb161-57" aria-hidden="true" tabindex="-1"></a>LASTABWURF <span class="op">=</span> <span class="fl">3_000.0</span>          <span class="co"># EUR je nicht gedeckter MWh (&quot;value of lost load&quot;)</span></span>
+<span id="cb161-58"><a href="#cb161-58" aria-hidden="true" tabindex="-1"></a>NIEDRIGER_ABWURFPREIS <span class="op">=</span> <span class="fl">300.0</span>  <span class="co"># zum Vergleich: ein Marktpreisdeckel</span></span>
+<span id="cb161-59"><a href="#cb161-59" aria-hidden="true" tabindex="-1"></a>SAAT <span class="op">=</span> <span class="dv">4</span></span>
+<span id="cb161-60"><a href="#cb161-60" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb161-61"><a href="#cb161-61" aria-hidden="true" tabindex="-1"></a>_t <span class="op">=</span> np.arange(STUNDEN)</span>
+<span id="cb161-62"><a href="#cb161-62" aria-hidden="true" tabindex="-1"></a>LAST <span class="op">=</span> <span class="dv">620</span> <span class="op">+</span> <span class="dv">260</span> <span class="op">*</span> np.sin((_t <span class="op">-</span> <span class="dv">7</span>) <span class="op">/</span> <span class="dv">24</span> <span class="op">*</span> <span class="dv">2</span> <span class="op">*</span> np.pi) <span class="op">+</span> <span class="dv">90</span> <span class="op">*</span> np.sin((_t <span class="op">-</span> <span class="dv">4</span>) <span class="op">/</span> <span class="dv">12</span> <span class="op">*</span> <span class="dv">2</span> <span class="op">*</span> np.pi)</span>
+<span id="cb161-63"><a href="#cb161-63" aria-hidden="true" tabindex="-1"></a>WIND_ERWARTUNG <span class="op">=</span> np.maximum(<span class="fl">0.0</span>, <span class="dv">160</span> <span class="op">+</span> <span class="dv">130</span> <span class="op">*</span> np.sin((_t <span class="op">-</span> <span class="dv">14</span>) <span class="op">/</span> <span class="dv">24</span> <span class="op">*</span> <span class="dv">2</span> <span class="op">*</span> np.pi))</span>
+<span id="cb161-64"><a href="#cb161-64" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb161-65"><a href="#cb161-65" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb161-66"><a href="#cb161-66" aria-hidden="true" tabindex="-1"></a><span class="kw">def</span> erzeuge_windszenarien(anzahl: <span class="bu">int</span> <span class="op">=</span> SZENARIEN, saat: <span class="bu">int</span> <span class="op">=</span> SAAT):</span>
+<span id="cb161-67"><a href="#cb161-67" aria-hidden="true" tabindex="-1"></a>    <span class="co">&quot;&quot;&quot;Windeinspeisung je Szenario und Stunde.</span></span>
+<span id="cb161-68"><a href="#cb161-68" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb161-69"><a href="#cb161-69" aria-hidden="true" tabindex="-1"></a><span class="co">    Zwei Zutaten, die zusammen den Unterschied machen: eine breite</span></span>
+<span id="cb161-70"><a href="#cb161-70" aria-hidden="true" tabindex="-1"></a><span class="co">    lognormale Streuung des Tagesniveaus - und in 15 % der Faelle eine</span></span>
+<span id="cb161-71"><a href="#cb161-71" aria-hidden="true" tabindex="-1"></a><span class="co">    DUNKELFLAUTE, in der praktisch gar kein Wind weht. Solche seltenen,</span></span>
+<span id="cb161-72"><a href="#cb161-72" aria-hidden="true" tabindex="-1"></a><span class="co">    extremen Faelle sind der Grund, warum der Erwartungswert als</span></span>
+<span id="cb161-73"><a href="#cb161-73" aria-hidden="true" tabindex="-1"></a><span class="co">    Planungsgrundlage nicht genuegt.</span></span>
+<span id="cb161-74"><a href="#cb161-74" aria-hidden="true" tabindex="-1"></a><span class="co">    &quot;&quot;&quot;</span></span>
+<span id="cb161-75"><a href="#cb161-75" aria-hidden="true" tabindex="-1"></a>    rng <span class="op">=</span> np.random.default_rng(saat)</span>
+<span id="cb161-76"><a href="#cb161-76" aria-hidden="true" tabindex="-1"></a>    tagesniveau <span class="op">=</span> rng.lognormal(<span class="dv">0</span>, <span class="fl">0.40</span>, (anzahl, <span class="dv">1</span>))</span>
+<span id="cb161-77"><a href="#cb161-77" aria-hidden="true" tabindex="-1"></a>    wind <span class="op">=</span> np.clip(WIND_ERWARTUNG <span class="op">*</span> tagesniveau</span>
+<span id="cb161-78"><a href="#cb161-78" aria-hidden="true" tabindex="-1"></a>                   <span class="op">+</span> rng.normal(<span class="dv">0</span>, <span class="dv">25</span>, (anzahl, STUNDEN)), <span class="dv">0</span>, <span class="dv">420</span>)</span>
+<span id="cb161-79"><a href="#cb161-79" aria-hidden="true" tabindex="-1"></a>    ist_flaute <span class="op">=</span> rng.random(anzahl) <span class="op">&lt;</span> FLAUTENANTEIL</span>
+<span id="cb161-80"><a href="#cb161-80" aria-hidden="true" tabindex="-1"></a>    wind[ist_flaute] <span class="op">*=</span> <span class="fl">0.05</span></span>
+<span id="cb161-81"><a href="#cb161-81" aria-hidden="true" tabindex="-1"></a>    <span class="cf">return</span> wind, ist_flaute</span>
+<span id="cb161-82"><a href="#cb161-82" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb161-83"><a href="#cb161-83" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb161-84"><a href="#cb161-84" aria-hidden="true" tabindex="-1"></a><span class="kw">def</span> plane(wind: np.ndarray, gewichte, cvar_grenze: <span class="bu">float</span> <span class="op">|</span> <span class="va">None</span> <span class="op">=</span> <span class="va">None</span>,</span>
+<span id="cb161-85"><a href="#cb161-85" aria-hidden="true" tabindex="-1"></a>          abwurfpreis: <span class="bu">float</span> <span class="op">=</span> <span class="va">None</span>, zeitlimit: <span class="bu">float</span> <span class="op">=</span> <span class="fl">300.0</span>):</span>
+<span id="cb161-86"><a href="#cb161-86" aria-hidden="true" tabindex="-1"></a>    <span class="co">&quot;&quot;&quot;Commitment (Stufe 1) und Fahrweise je Szenario (Stufe 2) in einem Modell.</span></span>
+<span id="cb161-87"><a href="#cb161-87" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb161-88"><a href="#cb161-88" aria-hidden="true" tabindex="-1"></a><span class="co">    &#39;wind&#39; hat die Form (Szenarien, Stunden). Mit einer einzigen Zeile</span></span>
+<span id="cb161-89"><a href="#cb161-89" aria-hidden="true" tabindex="-1"></a><span class="co">    Windprognose wird daraus die deterministische Planung.</span></span>
+<span id="cb161-90"><a href="#cb161-90" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb161-91"><a href="#cb161-91" aria-hidden="true" tabindex="-1"></a><span class="co">    &#39;cvar_grenze&#39; begrenzt den CVaR der Nichtdeckung ueber die Szenarien -</span></span>
+<span id="cb161-92"><a href="#cb161-92" aria-hidden="true" tabindex="-1"></a><span class="co">    dieselbe Rockafellar-Uryasev-Konstruktion wie im Kapitel CVaR, nur dass</span></span>
+<span id="cb161-93"><a href="#cb161-93" aria-hidden="true" tabindex="-1"></a><span class="co">    hier keine Verluste in Euro, sondern Megawattstunden begrenzt werden.</span></span>
+<span id="cb161-94"><a href="#cb161-94" aria-hidden="true" tabindex="-1"></a><span class="co">    &quot;&quot;&quot;</span></span>
+<span id="cb161-95"><a href="#cb161-95" aria-hidden="true" tabindex="-1"></a>    abwurfpreis <span class="op">=</span> LASTABWURF <span class="cf">if</span> abwurfpreis <span class="kw">is</span> <span class="va">None</span> <span class="cf">else</span> abwurfpreis</span>
+<span id="cb161-96"><a href="#cb161-96" aria-hidden="true" tabindex="-1"></a>    anzahl_szenarien <span class="op">=</span> wind.shape[<span class="dv">0</span>]</span>
+<span id="cb161-97"><a href="#cb161-97" aria-hidden="true" tabindex="-1"></a>    anzahl_bloecke <span class="op">=</span> <span class="bu">len</span>(KRAFTWERKE)</span>
+<span id="cb161-98"><a href="#cb161-98" aria-hidden="true" tabindex="-1"></a>    solver <span class="op">=</span> pywraplp.Solver.CreateSolver(<span class="st">&quot;SCIP&quot;</span>)</span>
+<span id="cb161-99"><a href="#cb161-99" aria-hidden="true" tabindex="-1"></a>    solver.SetTimeLimit(<span class="bu">int</span>(zeitlimit <span class="op">*</span> <span class="dv">1000</span>))</span>
+<span id="cb161-100"><a href="#cb161-100" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb161-101"><a href="#cb161-101" aria-hidden="true" tabindex="-1"></a>    <span class="co"># --- Stufe 1: binaer, szenariouebergreifend gleich --------------------</span></span>
+<span id="cb161-102"><a href="#cb161-102" aria-hidden="true" tabindex="-1"></a>    laeuft <span class="op">=</span> [[solver.BoolVar(<span class="ss">f&quot;laeuft_</span><span class="sc">{</span>k<span class="sc">}</span><span class="ss">_</span><span class="sc">{</span>t<span class="sc">}</span><span class="ss">&quot;</span>) <span class="cf">for</span> t <span class="kw">in</span> <span class="bu">range</span>(STUNDEN)]</span>
+<span id="cb161-103"><a href="#cb161-103" aria-hidden="true" tabindex="-1"></a>              <span class="cf">for</span> k <span class="kw">in</span> <span class="bu">range</span>(anzahl_bloecke)]</span>
+<span id="cb161-104"><a href="#cb161-104" aria-hidden="true" tabindex="-1"></a>    faehrt_an <span class="op">=</span> [[solver.BoolVar(<span class="ss">f&quot;start_</span><span class="sc">{</span>k<span class="sc">}</span><span class="ss">_</span><span class="sc">{</span>t<span class="sc">}</span><span class="ss">&quot;</span>) <span class="cf">for</span> t <span class="kw">in</span> <span class="bu">range</span>(STUNDEN)]</span>
+<span id="cb161-105"><a href="#cb161-105" aria-hidden="true" tabindex="-1"></a>                 <span class="cf">for</span> k <span class="kw">in</span> <span class="bu">range</span>(anzahl_bloecke)]</span>
+<span id="cb161-106"><a href="#cb161-106" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb161-107"><a href="#cb161-107" aria-hidden="true" tabindex="-1"></a>    <span class="co"># --- Stufe 2: kontinuierlich, je Szenario -----------------------------</span></span>
+<span id="cb161-108"><a href="#cb161-108" aria-hidden="true" tabindex="-1"></a>    leistung <span class="op">=</span> [[[solver.NumVar(<span class="dv">0</span>, KRAFTWERKE[k][<span class="dv">2</span>], <span class="ss">f&quot;p_</span><span class="sc">{</span>j<span class="sc">}</span><span class="ss">_</span><span class="sc">{</span>k<span class="sc">}</span><span class="ss">_</span><span class="sc">{</span>t<span class="sc">}</span><span class="ss">&quot;</span>)</span>
+<span id="cb161-109"><a href="#cb161-109" aria-hidden="true" tabindex="-1"></a>                  <span class="cf">for</span> t <span class="kw">in</span> <span class="bu">range</span>(STUNDEN)] <span class="cf">for</span> k <span class="kw">in</span> <span class="bu">range</span>(anzahl_bloecke)]</span>
+<span id="cb161-110"><a href="#cb161-110" aria-hidden="true" tabindex="-1"></a>                <span class="cf">for</span> j <span class="kw">in</span> <span class="bu">range</span>(anzahl_szenarien)]</span>
+<span id="cb161-111"><a href="#cb161-111" aria-hidden="true" tabindex="-1"></a>    nichtdeckung <span class="op">=</span> [[solver.NumVar(<span class="dv">0</span>, solver.infinity(), <span class="ss">f&quot;y_</span><span class="sc">{</span>j<span class="sc">}</span><span class="ss">_</span><span class="sc">{</span>t<span class="sc">}</span><span class="ss">&quot;</span>)</span>
+<span id="cb161-112"><a href="#cb161-112" aria-hidden="true" tabindex="-1"></a>                     <span class="cf">for</span> t <span class="kw">in</span> <span class="bu">range</span>(STUNDEN)] <span class="cf">for</span> j <span class="kw">in</span> <span class="bu">range</span>(anzahl_szenarien)]</span>
+<span id="cb161-113"><a href="#cb161-113" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb161-114"><a href="#cb161-114" aria-hidden="true" tabindex="-1"></a>    <span class="cf">for</span> k, (_, pmin, pmax, _, _, mindestlaufzeit) <span class="kw">in</span> <span class="bu">enumerate</span>(KRAFTWERKE):</span>
+<span id="cb161-115"><a href="#cb161-115" aria-hidden="true" tabindex="-1"></a>        <span class="cf">for</span> t <span class="kw">in</span> <span class="bu">range</span>(STUNDEN):</span>
+<span id="cb161-116"><a href="#cb161-116" aria-hidden="true" tabindex="-1"></a>            <span class="co"># Anfahren erkennen: aus im Vortakt, an im aktuellen</span></span>
+<span id="cb161-117"><a href="#cb161-117" aria-hidden="true" tabindex="-1"></a>            vorher <span class="op">=</span> laeuft[k][t <span class="op">-</span> <span class="dv">1</span>] <span class="cf">if</span> t <span class="op">&gt;</span> <span class="dv">0</span> <span class="cf">else</span> <span class="dv">0</span></span>
+<span id="cb161-118"><a href="#cb161-118" aria-hidden="true" tabindex="-1"></a>            solver.Add(faehrt_an[k][t] <span class="op">&gt;=</span> laeuft[k][t] <span class="op">-</span> vorher)</span>
+<span id="cb161-119"><a href="#cb161-119" aria-hidden="true" tabindex="-1"></a>            <span class="co"># Mindestlaufzeit: wer anfaehrt, laeuft die naechsten Stunden weiter</span></span>
+<span id="cb161-120"><a href="#cb161-120" aria-hidden="true" tabindex="-1"></a>            <span class="cf">for</span> spaeter <span class="kw">in</span> <span class="bu">range</span>(t, <span class="bu">min</span>(STUNDEN, t <span class="op">+</span> mindestlaufzeit)):</span>
+<span id="cb161-121"><a href="#cb161-121" aria-hidden="true" tabindex="-1"></a>                solver.Add(laeuft[k][spaeter] <span class="op">&gt;=</span> faehrt_an[k][t])</span>
+<span id="cb161-122"><a href="#cb161-122" aria-hidden="true" tabindex="-1"></a>            <span class="co"># Ein laufender Block liefert zwischen Mindest- und Nennleistung,</span></span>
+<span id="cb161-123"><a href="#cb161-123" aria-hidden="true" tabindex="-1"></a>            <span class="co"># ein stehender gar nichts. Das koppelt beide Stufen.</span></span>
+<span id="cb161-124"><a href="#cb161-124" aria-hidden="true" tabindex="-1"></a>            <span class="cf">for</span> j <span class="kw">in</span> <span class="bu">range</span>(anzahl_szenarien):</span>
+<span id="cb161-125"><a href="#cb161-125" aria-hidden="true" tabindex="-1"></a>                solver.Add(leistung[j][k][t] <span class="op">&gt;=</span> pmin <span class="op">*</span> laeuft[k][t])</span>
+<span id="cb161-126"><a href="#cb161-126" aria-hidden="true" tabindex="-1"></a>                solver.Add(leistung[j][k][t] <span class="op">&lt;=</span> pmax <span class="op">*</span> laeuft[k][t])</span>
+<span id="cb161-127"><a href="#cb161-127" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb161-128"><a href="#cb161-128" aria-hidden="true" tabindex="-1"></a>    <span class="cf">for</span> j <span class="kw">in</span> <span class="bu">range</span>(anzahl_szenarien):</span>
+<span id="cb161-129"><a href="#cb161-129" aria-hidden="true" tabindex="-1"></a>        <span class="cf">for</span> t <span class="kw">in</span> <span class="bu">range</span>(STUNDEN):</span>
+<span id="cb161-130"><a href="#cb161-130" aria-hidden="true" tabindex="-1"></a>            solver.Add(<span class="bu">sum</span>(leistung[j][k][t] <span class="cf">for</span> k <span class="kw">in</span> <span class="bu">range</span>(anzahl_bloecke))</span>
+<span id="cb161-131"><a href="#cb161-131" aria-hidden="true" tabindex="-1"></a>                       <span class="op">+</span> <span class="bu">float</span>(wind[j, t]) <span class="op">+</span> nichtdeckung[j][t] <span class="op">&gt;=</span> LAST[t])</span>
+<span id="cb161-132"><a href="#cb161-132" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb161-133"><a href="#cb161-133" aria-hidden="true" tabindex="-1"></a>    <span class="co"># --- Versorgungssicherheit als CVaR-Schranke --------------------------</span></span>
+<span id="cb161-134"><a href="#cb161-134" aria-hidden="true" tabindex="-1"></a>    <span class="cf">if</span> cvar_grenze <span class="kw">is</span> <span class="kw">not</span> <span class="va">None</span>:</span>
+<span id="cb161-135"><a href="#cb161-135" aria-hidden="true" tabindex="-1"></a>        schwelle <span class="op">=</span> solver.NumVar(<span class="op">-</span>solver.infinity(), solver.infinity(), <span class="st">&quot;schwelle&quot;</span>)</span>
+<span id="cb161-136"><a href="#cb161-136" aria-hidden="true" tabindex="-1"></a>        ueberschuss <span class="op">=</span> [solver.NumVar(<span class="dv">0</span>, solver.infinity(), <span class="ss">f&quot;u_</span><span class="sc">{</span>j<span class="sc">}</span><span class="ss">&quot;</span>)</span>
+<span id="cb161-137"><a href="#cb161-137" aria-hidden="true" tabindex="-1"></a>                       <span class="cf">for</span> j <span class="kw">in</span> <span class="bu">range</span>(anzahl_szenarien)]</span>
+<span id="cb161-138"><a href="#cb161-138" aria-hidden="true" tabindex="-1"></a>        <span class="cf">for</span> j <span class="kw">in</span> <span class="bu">range</span>(anzahl_szenarien):</span>
+<span id="cb161-139"><a href="#cb161-139" aria-hidden="true" tabindex="-1"></a>            solver.Add(ueberschuss[j] <span class="op">&gt;=</span> <span class="bu">sum</span>(nichtdeckung[j][t]</span>
+<span id="cb161-140"><a href="#cb161-140" aria-hidden="true" tabindex="-1"></a>                                             <span class="cf">for</span> t <span class="kw">in</span> <span class="bu">range</span>(STUNDEN)) <span class="op">-</span> schwelle)</span>
+<span id="cb161-141"><a href="#cb161-141" aria-hidden="true" tabindex="-1"></a>        solver.Add(schwelle <span class="op">+</span> (<span class="fl">1.0</span> <span class="op">/</span> (anzahl_szenarien <span class="op">*</span> (<span class="dv">1</span> <span class="op">-</span> ALPHA)))</span>
+<span id="cb161-142"><a href="#cb161-142" aria-hidden="true" tabindex="-1"></a>                   <span class="op">*</span> <span class="bu">sum</span>(ueberschuss) <span class="op">&lt;=</span> cvar_grenze)</span>
+<span id="cb161-143"><a href="#cb161-143" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb161-144"><a href="#cb161-144" aria-hidden="true" tabindex="-1"></a>    anfahrkosten <span class="op">=</span> <span class="bu">sum</span>(KRAFTWERKE[k][<span class="dv">4</span>] <span class="op">*</span> faehrt_an[k][t]</span>
+<span id="cb161-145"><a href="#cb161-145" aria-hidden="true" tabindex="-1"></a>                       <span class="cf">for</span> k <span class="kw">in</span> <span class="bu">range</span>(anzahl_bloecke) <span class="cf">for</span> t <span class="kw">in</span> <span class="bu">range</span>(STUNDEN))</span>
+<span id="cb161-146"><a href="#cb161-146" aria-hidden="true" tabindex="-1"></a>    betriebskosten <span class="op">=</span> <span class="bu">sum</span>(</span>
+<span id="cb161-147"><a href="#cb161-147" aria-hidden="true" tabindex="-1"></a>        gewichte[j] <span class="op">*</span> <span class="bu">sum</span>(KRAFTWERKE[k][<span class="dv">3</span>] <span class="op">*</span> leistung[j][k][t]</span>
+<span id="cb161-148"><a href="#cb161-148" aria-hidden="true" tabindex="-1"></a>                          <span class="cf">for</span> k <span class="kw">in</span> <span class="bu">range</span>(anzahl_bloecke) <span class="cf">for</span> t <span class="kw">in</span> <span class="bu">range</span>(STUNDEN))</span>
+<span id="cb161-149"><a href="#cb161-149" aria-hidden="true" tabindex="-1"></a>        <span class="cf">for</span> j <span class="kw">in</span> <span class="bu">range</span>(anzahl_szenarien))</span>
+<span id="cb161-150"><a href="#cb161-150" aria-hidden="true" tabindex="-1"></a>    abwurfkosten <span class="op">=</span> <span class="bu">sum</span>(gewichte[j] <span class="op">*</span> abwurfpreis</span>
+<span id="cb161-151"><a href="#cb161-151" aria-hidden="true" tabindex="-1"></a>                       <span class="op">*</span> <span class="bu">sum</span>(nichtdeckung[j][t] <span class="cf">for</span> t <span class="kw">in</span> <span class="bu">range</span>(STUNDEN))</span>
+<span id="cb161-152"><a href="#cb161-152" aria-hidden="true" tabindex="-1"></a>                       <span class="cf">for</span> j <span class="kw">in</span> <span class="bu">range</span>(anzahl_szenarien))</span>
+<span id="cb161-153"><a href="#cb161-153" aria-hidden="true" tabindex="-1"></a>    solver.Minimize(anfahrkosten <span class="op">+</span> betriebskosten <span class="op">+</span> abwurfkosten)</span>
+<span id="cb161-154"><a href="#cb161-154" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb161-155"><a href="#cb161-155" aria-hidden="true" tabindex="-1"></a>    beginn <span class="op">=</span> time.perf_counter()</span>
+<span id="cb161-156"><a href="#cb161-156" aria-hidden="true" tabindex="-1"></a>    status <span class="op">=</span> solver.Solve()</span>
+<span id="cb161-157"><a href="#cb161-157" aria-hidden="true" tabindex="-1"></a>    dauer <span class="op">=</span> time.perf_counter() <span class="op">-</span> beginn</span>
+<span id="cb161-158"><a href="#cb161-158" aria-hidden="true" tabindex="-1"></a>    <span class="cf">if</span> status <span class="kw">not</span> <span class="kw">in</span> (pywraplp.Solver.OPTIMAL, pywraplp.Solver.FEASIBLE):</span>
+<span id="cb161-159"><a href="#cb161-159" aria-hidden="true" tabindex="-1"></a>        <span class="cf">return</span> <span class="va">None</span>, dauer, <span class="va">False</span></span>
+<span id="cb161-160"><a href="#cb161-160" aria-hidden="true" tabindex="-1"></a>    plan <span class="op">=</span> np.array([[laeuft[k][t].solution_value() <span class="cf">for</span> t <span class="kw">in</span> <span class="bu">range</span>(STUNDEN)]</span>
+<span id="cb161-161"><a href="#cb161-161" aria-hidden="true" tabindex="-1"></a>                     <span class="cf">for</span> k <span class="kw">in</span> <span class="bu">range</span>(anzahl_bloecke)]).<span class="bu">round</span>()</span>
+<span id="cb161-162"><a href="#cb161-162" aria-hidden="true" tabindex="-1"></a>    <span class="cf">return</span> plan, dauer, status <span class="op">==</span> pywraplp.Solver.OPTIMAL</span>
+<span id="cb161-163"><a href="#cb161-163" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb161-164"><a href="#cb161-164" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb161-165"><a href="#cb161-165" aria-hidden="true" tabindex="-1"></a><span class="kw">def</span> bewerte(plan: np.ndarray, wind: np.ndarray, abwurfpreis: <span class="bu">float</span> <span class="op">=</span> <span class="va">None</span>):</span>
+<span id="cb161-166"><a href="#cb161-166" aria-hidden="true" tabindex="-1"></a>    <span class="co">&quot;&quot;&quot;Commitment steht fest - nur noch die Fahrweise je Szenario optimieren.</span></span>
+<span id="cb161-167"><a href="#cb161-167" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb161-168"><a href="#cb161-168" aria-hidden="true" tabindex="-1"></a><span class="co">    Das ist die ehrliche Bewertung eines Plans: Er wird der Wirklichkeit</span></span>
+<span id="cb161-169"><a href="#cb161-169" aria-hidden="true" tabindex="-1"></a><span class="co">    ausgesetzt und darf nur noch das anpassen, was sich am Tag selbst</span></span>
+<span id="cb161-170"><a href="#cb161-170" aria-hidden="true" tabindex="-1"></a><span class="co">    anpassen laesst.</span></span>
+<span id="cb161-171"><a href="#cb161-171" aria-hidden="true" tabindex="-1"></a><span class="co">    &quot;&quot;&quot;</span></span>
+<span id="cb161-172"><a href="#cb161-172" aria-hidden="true" tabindex="-1"></a>    abwurfpreis <span class="op">=</span> LASTABWURF <span class="cf">if</span> abwurfpreis <span class="kw">is</span> <span class="va">None</span> <span class="cf">else</span> abwurfpreis</span>
+<span id="cb161-173"><a href="#cb161-173" aria-hidden="true" tabindex="-1"></a>    anzahl_bloecke <span class="op">=</span> <span class="bu">len</span>(KRAFTWERKE)</span>
+<span id="cb161-174"><a href="#cb161-174" aria-hidden="true" tabindex="-1"></a>    kosten, fehlmengen <span class="op">=</span> [], []</span>
+<span id="cb161-175"><a href="#cb161-175" aria-hidden="true" tabindex="-1"></a>    <span class="cf">for</span> j <span class="kw">in</span> <span class="bu">range</span>(wind.shape[<span class="dv">0</span>]):</span>
+<span id="cb161-176"><a href="#cb161-176" aria-hidden="true" tabindex="-1"></a>        solver <span class="op">=</span> pywraplp.Solver.CreateSolver(<span class="st">&quot;GLOP&quot;</span>)</span>
+<span id="cb161-177"><a href="#cb161-177" aria-hidden="true" tabindex="-1"></a>        leistung <span class="op">=</span> [[solver.NumVar(<span class="dv">0</span>, KRAFTWERKE[k][<span class="dv">2</span>], <span class="ss">f&quot;p_</span><span class="sc">{</span>k<span class="sc">}</span><span class="ss">_</span><span class="sc">{</span>t<span class="sc">}</span><span class="ss">&quot;</span>)</span>
+<span id="cb161-178"><a href="#cb161-178" aria-hidden="true" tabindex="-1"></a>                     <span class="cf">for</span> t <span class="kw">in</span> <span class="bu">range</span>(STUNDEN)] <span class="cf">for</span> k <span class="kw">in</span> <span class="bu">range</span>(anzahl_bloecke)]</span>
+<span id="cb161-179"><a href="#cb161-179" aria-hidden="true" tabindex="-1"></a>        fehlt <span class="op">=</span> [solver.NumVar(<span class="dv">0</span>, solver.infinity(), <span class="ss">f&quot;y_</span><span class="sc">{</span>t<span class="sc">}</span><span class="ss">&quot;</span>)</span>
+<span id="cb161-180"><a href="#cb161-180" aria-hidden="true" tabindex="-1"></a>                 <span class="cf">for</span> t <span class="kw">in</span> <span class="bu">range</span>(STUNDEN)]</span>
+<span id="cb161-181"><a href="#cb161-181" aria-hidden="true" tabindex="-1"></a>        <span class="cf">for</span> k, (_, pmin, pmax, _, _, _) <span class="kw">in</span> <span class="bu">enumerate</span>(KRAFTWERKE):</span>
+<span id="cb161-182"><a href="#cb161-182" aria-hidden="true" tabindex="-1"></a>            <span class="cf">for</span> t <span class="kw">in</span> <span class="bu">range</span>(STUNDEN):</span>
+<span id="cb161-183"><a href="#cb161-183" aria-hidden="true" tabindex="-1"></a>                solver.Add(leistung[k][t] <span class="op">&gt;=</span> pmin <span class="op">*</span> plan[k, t])</span>
+<span id="cb161-184"><a href="#cb161-184" aria-hidden="true" tabindex="-1"></a>                solver.Add(leistung[k][t] <span class="op">&lt;=</span> pmax <span class="op">*</span> plan[k, t])</span>
+<span id="cb161-185"><a href="#cb161-185" aria-hidden="true" tabindex="-1"></a>        <span class="cf">for</span> t <span class="kw">in</span> <span class="bu">range</span>(STUNDEN):</span>
+<span id="cb161-186"><a href="#cb161-186" aria-hidden="true" tabindex="-1"></a>            solver.Add(<span class="bu">sum</span>(leistung[k][t] <span class="cf">for</span> k <span class="kw">in</span> <span class="bu">range</span>(anzahl_bloecke))</span>
+<span id="cb161-187"><a href="#cb161-187" aria-hidden="true" tabindex="-1"></a>                       <span class="op">+</span> <span class="bu">float</span>(wind[j, t]) <span class="op">+</span> fehlt[t] <span class="op">&gt;=</span> LAST[t])</span>
+<span id="cb161-188"><a href="#cb161-188" aria-hidden="true" tabindex="-1"></a>        solver.Minimize(</span>
+<span id="cb161-189"><a href="#cb161-189" aria-hidden="true" tabindex="-1"></a>            <span class="bu">sum</span>(KRAFTWERKE[k][<span class="dv">3</span>] <span class="op">*</span> leistung[k][t]</span>
+<span id="cb161-190"><a href="#cb161-190" aria-hidden="true" tabindex="-1"></a>                <span class="cf">for</span> k <span class="kw">in</span> <span class="bu">range</span>(anzahl_bloecke) <span class="cf">for</span> t <span class="kw">in</span> <span class="bu">range</span>(STUNDEN))</span>
+<span id="cb161-191"><a href="#cb161-191" aria-hidden="true" tabindex="-1"></a>            <span class="op">+</span> <span class="bu">sum</span>(abwurfpreis <span class="op">*</span> fehlt[t] <span class="cf">for</span> t <span class="kw">in</span> <span class="bu">range</span>(STUNDEN)))</span>
+<span id="cb161-192"><a href="#cb161-192" aria-hidden="true" tabindex="-1"></a>        solver.Solve()</span>
+<span id="cb161-193"><a href="#cb161-193" aria-hidden="true" tabindex="-1"></a>        kosten.append(solver.Objective().Value())</span>
+<span id="cb161-194"><a href="#cb161-194" aria-hidden="true" tabindex="-1"></a>        fehlmengen.append(<span class="bu">sum</span>(f.solution_value() <span class="cf">for</span> f <span class="kw">in</span> fehlt))</span>
+<span id="cb161-195"><a href="#cb161-195" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb161-196"><a href="#cb161-196" aria-hidden="true" tabindex="-1"></a>    anfahrten <span class="op">=</span> <span class="bu">sum</span>(KRAFTWERKE[k][<span class="dv">4</span>]</span>
+<span id="cb161-197"><a href="#cb161-197" aria-hidden="true" tabindex="-1"></a>                    <span class="op">*</span> <span class="bu">max</span>(<span class="fl">0.0</span>, plan[k, t] <span class="op">-</span> (plan[k, t <span class="op">-</span> <span class="dv">1</span>] <span class="cf">if</span> t <span class="op">&gt;</span> <span class="dv">0</span> <span class="cf">else</span> <span class="fl">0.0</span>))</span>
+<span id="cb161-198"><a href="#cb161-198" aria-hidden="true" tabindex="-1"></a>                    <span class="cf">for</span> k <span class="kw">in</span> <span class="bu">range</span>(anzahl_bloecke) <span class="cf">for</span> t <span class="kw">in</span> <span class="bu">range</span>(STUNDEN))</span>
+<span id="cb161-199"><a href="#cb161-199" aria-hidden="true" tabindex="-1"></a>    <span class="cf">return</span> np.array(kosten) <span class="op">+</span> anfahrten, np.array(fehlmengen)</span>
+<span id="cb161-200"><a href="#cb161-200" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb161-201"><a href="#cb161-201" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb161-202"><a href="#cb161-202" aria-hidden="true" tabindex="-1"></a><span class="kw">def</span> cvar(werte: np.ndarray, alpha: <span class="bu">float</span> <span class="op">=</span> ALPHA) <span class="op">-&gt;</span> <span class="bu">float</span>:</span>
+<span id="cb161-203"><a href="#cb161-203" aria-hidden="true" tabindex="-1"></a>    <span class="co">&quot;&quot;&quot;Mittelwert der schlechtesten (1-alpha) Faelle.&quot;&quot;&quot;</span></span>
+<span id="cb161-204"><a href="#cb161-204" aria-hidden="true" tabindex="-1"></a>    schwelle <span class="op">=</span> np.quantile(werte, alpha)</span>
+<span id="cb161-205"><a href="#cb161-205" aria-hidden="true" tabindex="-1"></a>    schlechteste <span class="op">=</span> werte[werte <span class="op">&gt;=</span> schwelle]</span>
+<span id="cb161-206"><a href="#cb161-206" aria-hidden="true" tabindex="-1"></a>    <span class="cf">return</span> <span class="bu">float</span>(schlechteste.mean()) <span class="cf">if</span> <span class="bu">len</span>(schlechteste) <span class="cf">else</span> <span class="fl">0.0</span></span>
+<span id="cb161-207"><a href="#cb161-207" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb161-208"><a href="#cb161-208" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb161-209"><a href="#cb161-209" aria-hidden="true" tabindex="-1"></a><span class="kw">def</span> zeige(name: <span class="bu">str</span>, plan, wind, abwurfpreis: <span class="bu">float</span> <span class="op">=</span> <span class="va">None</span>) <span class="op">-&gt;</span> <span class="bu">dict</span>:</span>
+<span id="cb161-210"><a href="#cb161-210" aria-hidden="true" tabindex="-1"></a>    kosten, fehl <span class="op">=</span> bewerte(plan, wind, abwurfpreis)</span>
+<span id="cb161-211"><a href="#cb161-211" aria-hidden="true" tabindex="-1"></a>    kennzahlen <span class="op">=</span> {<span class="st">&quot;mittel&quot;</span>: kosten.mean(), <span class="st">&quot;max&quot;</span>: kosten.<span class="bu">max</span>(),</span>
+<span id="cb161-212"><a href="#cb161-212" aria-hidden="true" tabindex="-1"></a>                  <span class="st">&quot;fehl_mittel&quot;</span>: fehl.mean(), <span class="st">&quot;fehl_cvar&quot;</span>: cvar(fehl),</span>
+<span id="cb161-213"><a href="#cb161-213" aria-hidden="true" tabindex="-1"></a>                  <span class="st">&quot;betroffen&quot;</span>: <span class="bu">int</span>((fehl <span class="op">&gt;</span> <span class="fl">0.01</span>).<span class="bu">sum</span>()),</span>
+<span id="cb161-214"><a href="#cb161-214" aria-hidden="true" tabindex="-1"></a>                  <span class="st">&quot;blockstunden&quot;</span>: <span class="bu">int</span>(plan.<span class="bu">sum</span>())}</span>
+<span id="cb161-215"><a href="#cb161-215" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;  </span><span class="sc">{</span>name<span class="sc">:&lt;32}</span><span class="ss"> </span><span class="sc">{</span>kennzahlen[<span class="st">&#39;mittel&#39;</span>]<span class="sc">:&gt;10,.0f}</span><span class="ss"> </span><span class="sc">{</span>kennzahlen[<span class="st">&#39;max&#39;</span>]<span class="sc">:&gt;11,.0f}</span><span class="ss"> &quot;</span></span>
+<span id="cb161-216"><a href="#cb161-216" aria-hidden="true" tabindex="-1"></a>          <span class="ss">f&quot;</span><span class="sc">{</span>kennzahlen[<span class="st">&#39;fehl_mittel&#39;</span>]<span class="sc">:&gt;9.1f}</span><span class="ss"> </span><span class="sc">{</span>kennzahlen[<span class="st">&#39;fehl_cvar&#39;</span>]<span class="sc">:&gt;10.1f}</span><span class="ss"> &quot;</span></span>
+<span id="cb161-217"><a href="#cb161-217" aria-hidden="true" tabindex="-1"></a>          <span class="ss">f&quot;</span><span class="sc">{</span>kennzahlen[<span class="st">&#39;betroffen&#39;</span>]<span class="sc">:&gt;6}</span><span class="ss">/</span><span class="sc">{</span><span class="bu">len</span>(fehl)<span class="sc">}</span><span class="ss">&quot;</span>)</span>
+<span id="cb161-218"><a href="#cb161-218" aria-hidden="true" tabindex="-1"></a>    <span class="cf">return</span> kennzahlen</span>
+<span id="cb161-219"><a href="#cb161-219" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb161-220"><a href="#cb161-220" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb161-221"><a href="#cb161-221" aria-hidden="true" tabindex="-1"></a><span class="cf">if</span> <span class="va">__name__</span> <span class="op">==</span> <span class="st">&quot;__main__&quot;</span>:</span>
+<span id="cb161-222"><a href="#cb161-222" aria-hidden="true" tabindex="-1"></a>    wind, ist_flaute <span class="op">=</span> erzeuge_windszenarien()</span>
+<span id="cb161-223"><a href="#cb161-223" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb161-224"><a href="#cb161-224" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;=&quot;</span> <span class="op">*</span> <span class="dv">88</span>)</span>
+<span id="cb161-225"><a href="#cb161-225" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;  KRAFTWERKSEINSATZ: DER PLAN STEHT, BEVOR DER WIND WEHT&quot;</span>)</span>
+<span id="cb161-226"><a href="#cb161-226" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;=&quot;</span> <span class="op">*</span> <span class="dv">88</span>)</span>
+<span id="cb161-227"><a href="#cb161-227" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;</span><span class="sc">{</span><span class="bu">len</span>(KRAFTWERKE)<span class="sc">}</span><span class="ss"> Bloecke, </span><span class="sc">{</span>STUNDEN<span class="sc">}</span><span class="ss"> Stunden, </span><span class="sc">{</span>SZENARIEN<span class="sc">}</span><span class="ss"> Windszenarien &quot;</span></span>
+<span id="cb161-228"><a href="#cb161-228" aria-hidden="true" tabindex="-1"></a>          <span class="ss">f&quot;(davon </span><span class="sc">{</span><span class="bu">int</span>(ist_flaute.<span class="bu">sum</span>())<span class="sc">}</span><span class="ss"> Dunkelflauten).&quot;</span>)</span>
+<span id="cb161-229"><a href="#cb161-229" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;Last </span><span class="sc">{</span>LAST<span class="sc">.</span><span class="bu">min</span>()<span class="sc">:.0f}</span><span class="ss"> bis </span><span class="sc">{</span>LAST<span class="sc">.</span><span class="bu">max</span>()<span class="sc">:.0f}</span><span class="ss"> MW, &quot;</span></span>
+<span id="cb161-230"><a href="#cb161-230" aria-hidden="true" tabindex="-1"></a>          <span class="ss">f&quot;Wind im Erwartungswert </span><span class="sc">{</span>WIND_ERWARTUNG<span class="sc">.</span><span class="bu">min</span>()<span class="sc">:.0f}</span><span class="ss"> bis &quot;</span></span>
+<span id="cb161-231"><a href="#cb161-231" aria-hidden="true" tabindex="-1"></a>          <span class="ss">f&quot;</span><span class="sc">{</span>WIND_ERWARTUNG<span class="sc">.</span><span class="bu">max</span>()<span class="sc">:.0f}</span><span class="ss"> MW.&quot;</span>)</span>
+<span id="cb161-232"><a href="#cb161-232" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;Nicht gedeckte Last kostet </span><span class="sc">{</span>LASTABWURF<span class="sc">:,.0f}</span><span class="ss"> EUR je MWh.</span><span class="ch">\n</span><span class="ss">&quot;</span>)</span>
+<span id="cb161-233"><a href="#cb161-233" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb161-234"><a href="#cb161-234" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;  </span><span class="sc">{</span><span class="st">&#39;Planungsgrundlage&#39;</span><span class="sc">:&lt;32}</span><span class="ss"> </span><span class="sc">{</span><span class="st">&#39;Kosten&#39;</span><span class="sc">:&gt;10}</span><span class="ss"> </span><span class="sc">{</span><span class="st">&#39;Kosten&#39;</span><span class="sc">:&gt;11}</span><span class="ss"> &quot;</span></span>
+<span id="cb161-235"><a href="#cb161-235" aria-hidden="true" tabindex="-1"></a>          <span class="ss">f&quot;</span><span class="sc">{</span><span class="st">&#39;Fehlmenge&#39;</span><span class="sc">:&gt;9}</span><span class="ss"> </span><span class="sc">{</span><span class="st">&#39;Fehlmenge&#39;</span><span class="sc">:&gt;10}</span><span class="ss"> </span><span class="sc">{</span><span class="st">&#39;Szen. mit&#39;</span><span class="sc">:&gt;12}</span><span class="ss">&quot;</span>)</span>
+<span id="cb161-236"><a href="#cb161-236" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;  </span><span class="sc">{</span><span class="st">&#39;&#39;</span><span class="sc">:&lt;32}</span><span class="ss"> </span><span class="sc">{</span><span class="st">&#39;im Mittel&#39;</span><span class="sc">:&gt;10}</span><span class="ss"> </span><span class="sc">{</span><span class="st">&#39;schlimmst.&#39;</span><span class="sc">:&gt;11}</span><span class="ss"> &quot;</span></span>
+<span id="cb161-237"><a href="#cb161-237" aria-hidden="true" tabindex="-1"></a>          <span class="ss">f&quot;</span><span class="sc">{</span><span class="st">&#39;Mittel&#39;</span><span class="sc">:&gt;9}</span><span class="ss"> </span><span class="sc">{</span><span class="st">&#39;CVaR 90%&#39;</span><span class="sc">:&gt;10}</span><span class="ss"> </span><span class="sc">{</span><span class="st">&#39;Abwurf&#39;</span><span class="sc">:&gt;12}</span><span class="ss">&quot;</span>)</span>
+<span id="cb161-238"><a href="#cb161-238" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;  &quot;</span> <span class="op">+</span> <span class="st">&quot;-&quot;</span> <span class="op">*</span> <span class="dv">86</span>)</span>
+<span id="cb161-239"><a href="#cb161-239" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb161-240"><a href="#cb161-240" aria-hidden="true" tabindex="-1"></a>    <span class="co"># --- 1. Deterministisch ----------------------------------------------</span></span>
+<span id="cb161-241"><a href="#cb161-241" aria-hidden="true" tabindex="-1"></a>    plan_det, dauer_det, _ <span class="op">=</span> plane(WIND_ERWARTUNG.reshape(<span class="dv">1</span>, <span class="op">-</span><span class="dv">1</span>), [<span class="fl">1.0</span>])</span>
+<span id="cb161-242"><a href="#cb161-242" aria-hidden="true" tabindex="-1"></a>    det <span class="op">=</span> zeige(<span class="st">&quot;nur Wind-Erwartungswert&quot;</span>, plan_det, wind)</span>
+<span id="cb161-243"><a href="#cb161-243" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb161-244"><a href="#cb161-244" aria-hidden="true" tabindex="-1"></a>    <span class="co"># --- 2. Zweistufig, risikoneutral ------------------------------------</span></span>
+<span id="cb161-245"><a href="#cb161-245" aria-hidden="true" tabindex="-1"></a>    gleich <span class="op">=</span> [<span class="fl">1.0</span> <span class="op">/</span> SZENARIEN] <span class="op">*</span> SZENARIEN</span>
+<span id="cb161-246"><a href="#cb161-246" aria-hidden="true" tabindex="-1"></a>    plan_sto, dauer_sto, optimal_sto <span class="op">=</span> plane(wind, gleich)</span>
+<span id="cb161-247"><a href="#cb161-247" aria-hidden="true" tabindex="-1"></a>    sto <span class="op">=</span> zeige(<span class="st">&quot;alle 40 Szenarien&quot;</span>, plan_sto, wind)</span>
+<span id="cb161-248"><a href="#cb161-248" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb161-249"><a href="#cb161-249" aria-hidden="true" tabindex="-1"></a>    <span class="co"># --- 3. Mit Versorgungssicherheit ------------------------------------</span></span>
+<span id="cb161-250"><a href="#cb161-250" aria-hidden="true" tabindex="-1"></a>    plan_sicher, dauer_sicher, optimal_sicher <span class="op">=</span> plane(wind, gleich, cvar_grenze<span class="op">=</span><span class="fl">0.0</span>)</span>
+<span id="cb161-251"><a href="#cb161-251" aria-hidden="true" tabindex="-1"></a>    sicher <span class="op">=</span> zeige(<span class="st">&quot;+ Nichtdeckung CVaR 90 % = 0&quot;</span>, plan_sicher, wind)</span>
+<span id="cb161-252"><a href="#cb161-252" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb161-253"><a href="#cb161-253" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;</span><span class="ch">\n</span><span class="ss">  Rechenzeiten: </span><span class="sc">{</span>dauer_det<span class="sc">:.1f}</span><span class="ss">s / </span><span class="sc">{</span>dauer_sto<span class="sc">:.1f}</span><span class="ss">s / </span><span class="sc">{</span>dauer_sicher<span class="sc">:.1f}</span><span class="ss">s &quot;</span></span>
+<span id="cb161-254"><a href="#cb161-254" aria-hidden="true" tabindex="-1"></a>          <span class="ss">f&quot;(alle beweisbar optimal: </span><span class="sc">{</span>optimal_sto <span class="kw">and</span> optimal_sicher<span class="sc">}</span><span class="ss">)&quot;</span>)</span>
+<span id="cb161-255"><a href="#cb161-255" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb161-256"><a href="#cb161-256" aria-hidden="true" tabindex="-1"></a>    <span class="co"># --- Was die Zeilen bedeuten -----------------------------------------</span></span>
+<span id="cb161-257"><a href="#cb161-257" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;</span><span class="ch">\n</span><span class="st">&quot;</span> <span class="op">+</span> <span class="st">&quot;-&quot;</span> <span class="op">*</span> <span class="dv">88</span>)</span>
+<span id="cb161-258"><a href="#cb161-258" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;Was der Erwartungswert-Plan anrichtet</span><span class="ch">\n</span><span class="st">&quot;</span>)</span>
+<span id="cb161-259"><a href="#cb161-259" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;  Er ist auf dem Papier der billigste - gerechnet auf den mittleren&quot;</span>)</span>
+<span id="cb161-260"><a href="#cb161-260" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;  Wind kostet er weniger als jeder andere. In der Wirklichkeit liegt&quot;</span>)</span>
+<span id="cb161-261"><a href="#cb161-261" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;  er </span><span class="sc">{</span>det[<span class="st">&#39;mittel&#39;</span>] <span class="op">/</span> sto[<span class="st">&#39;mittel&#39;</span>] <span class="op">-</span> <span class="dv">1</span><span class="sc">:+.0%}</span><span class="ss"> ueber dem zweistufigen Plan, und sein &quot;</span></span>
+<span id="cb161-262"><a href="#cb161-262" aria-hidden="true" tabindex="-1"></a>          <span class="ss">f&quot;schlimmster Tag&quot;</span>)</span>
+<span id="cb161-263"><a href="#cb161-263" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;  kostet </span><span class="sc">{</span>det[<span class="st">&#39;max&#39;</span>] <span class="op">/</span> sto[<span class="st">&#39;max&#39;</span>]<span class="sc">:.1f}</span><span class="ss">-mal so viel.&quot;</span>)</span>
+<span id="cb161-264"><a href="#cb161-264" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;</span><span class="ch">\n</span><span class="ss">  Der Grund steht in der letzten Spalte: In </span><span class="sc">{</span>det[<span class="st">&#39;betroffen&#39;</span>]<span class="sc">}</span><span class="ss"> von </span><span class="sc">{</span>SZENARIEN<span class="sc">}</span><span class="ss"> &quot;</span></span>
+<span id="cb161-265"><a href="#cb161-265" aria-hidden="true" tabindex="-1"></a>          <span class="ss">f&quot;Szenarien muss&quot;</span>)</span>
+<span id="cb161-266"><a href="#cb161-266" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;  Last abgeworfen werden. Was fehlt, sind nicht Kraftwerke, sondern&quot;</span>)</span>
+<span id="cb161-267"><a href="#cb161-267" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;  ANGEFAHRENE Kraftwerke - und ein Block mit acht Stunden&quot;</span>)</span>
+<span id="cb161-268"><a href="#cb161-268" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;  Mindestlaufzeit laesst sich um 18 Uhr nicht mehr herbeirufen.&quot;</span>)</span>
+<span id="cb161-269"><a href="#cb161-269" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb161-270"><a href="#cb161-270" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;</span><span class="ch">\n</span><span class="ss">  Der Unterschied im Plan ist klein:&quot;</span>)</span>
+<span id="cb161-271"><a href="#cb161-271" aria-hidden="true" tabindex="-1"></a>    <span class="cf">for</span> name, plan <span class="kw">in</span> [(<span class="st">&quot;Erwartungswert&quot;</span>, plan_det), (<span class="st">&quot;zweistufig&quot;</span>, plan_sto),</span>
+<span id="cb161-272"><a href="#cb161-272" aria-hidden="true" tabindex="-1"></a>                       (<span class="st">&quot;mit Sicherheit&quot;</span>, plan_sicher)]:</span>
+<span id="cb161-273"><a href="#cb161-273" aria-hidden="true" tabindex="-1"></a>        laufend <span class="op">=</span> plan.<span class="bu">sum</span>(axis<span class="op">=</span><span class="dv">0</span>).astype(<span class="bu">int</span>)</span>
+<span id="cb161-274"><a href="#cb161-274" aria-hidden="true" tabindex="-1"></a>        <span class="bu">print</span>(<span class="ss">f&quot;    </span><span class="sc">{</span>name<span class="sc">:&lt;16}</span><span class="ss"> </span><span class="sc">{</span><span class="st">&#39;&#39;</span><span class="sc">.</span>join(<span class="bu">str</span>(x) <span class="cf">for</span> x <span class="kw">in</span> laufend)<span class="sc">}</span><span class="ss">  &quot;</span></span>
+<span id="cb161-275"><a href="#cb161-275" aria-hidden="true" tabindex="-1"></a>              <span class="ss">f&quot;(</span><span class="sc">{</span><span class="bu">int</span>(plan.<span class="bu">sum</span>())<span class="sc">}</span><span class="ss"> Blockstunden)&quot;</span>)</span>
+<span id="cb161-276"><a href="#cb161-276" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;</span><span class="ch">\n</span><span class="ss">  Der zweistufige Plan haelt </span><span class="sc">{</span>sto[<span class="st">&#39;blockstunden&#39;</span>] <span class="op">-</span> det[<span class="st">&#39;blockstunden&#39;</span>]<span class="sc">}</span><span class="ss"> &quot;</span></span>
+<span id="cb161-277"><a href="#cb161-277" aria-hidden="true" tabindex="-1"></a>          <span class="ss">f&quot;Blockstunden mehr vor - das genuegt,&quot;</span>)</span>
+<span id="cb161-278"><a href="#cb161-278" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;  um alle </span><span class="sc">{</span>det[<span class="st">&#39;betroffen&#39;</span>]<span class="sc">}</span><span class="ss"> Lastabwuerfe zu vermeiden.&quot;</span>)</span>
+<span id="cb161-279"><a href="#cb161-279" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb161-280"><a href="#cb161-280" aria-hidden="true" tabindex="-1"></a>    <span class="co"># --- Der Preis der Sicherheit ----------------------------------------</span></span>
+<span id="cb161-281"><a href="#cb161-281" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;</span><span class="ch">\n</span><span class="st">&quot;</span> <span class="op">+</span> <span class="st">&quot;-&quot;</span> <span class="op">*</span> <span class="dv">88</span>)</span>
+<span id="cb161-282"><a href="#cb161-282" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;Was Versorgungssicherheit kostet</span><span class="ch">\n</span><span class="st">&quot;</span>)</span>
+<span id="cb161-283"><a href="#cb161-283" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;  Bei </span><span class="sc">{</span>LASTABWURF<span class="sc">:,.0f}</span><span class="ss"> EUR/MWh kostet die CVaR-Schranke NICHTS: Der&quot;</span>)</span>
+<span id="cb161-284"><a href="#cb161-284" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;  risikoneutrale Plan haelt sie schon ein. Das ist kein Zufall - bei&quot;</span>)</span>
+<span id="cb161-285"><a href="#cb161-285" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;  diesem Preis lohnt sich Vorhaltung bereits im Erwartungswert.&quot;</span>)</span>
+<span id="cb161-286"><a href="#cb161-286" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;</span><span class="ch">\n</span><span class="st">  Interessant wird die Schranke dort, wo der Schaden ZU NIEDRIG&quot;</span>)</span>
+<span id="cb161-287"><a href="#cb161-287" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;  bepreist ist. Dieselbe Rechnung mit einem Marktpreisdeckel von&quot;</span>)</span>
+<span id="cb161-288"><a href="#cb161-288" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;  </span><span class="sc">{</span>NIEDRIGER_ABWURFPREIS<span class="sc">:,.0f}</span><span class="ss"> EUR/MWh statt </span><span class="sc">{</span>LASTABWURF<span class="sc">:,.0f}</span><span class="ss">:</span><span class="ch">\n</span><span class="ss">&quot;</span>)</span>
+<span id="cb161-289"><a href="#cb161-289" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb161-290"><a href="#cb161-290" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;  </span><span class="sc">{</span><span class="st">&#39;Planungsgrundlage&#39;</span><span class="sc">:&lt;32}</span><span class="ss"> </span><span class="sc">{</span><span class="st">&#39;Kosten&#39;</span><span class="sc">:&gt;10}</span><span class="ss"> </span><span class="sc">{</span><span class="st">&#39;Kosten&#39;</span><span class="sc">:&gt;11}</span><span class="ss"> &quot;</span></span>
+<span id="cb161-291"><a href="#cb161-291" aria-hidden="true" tabindex="-1"></a>          <span class="ss">f&quot;</span><span class="sc">{</span><span class="st">&#39;Fehlmenge&#39;</span><span class="sc">:&gt;9}</span><span class="ss"> </span><span class="sc">{</span><span class="st">&#39;Fehlmenge&#39;</span><span class="sc">:&gt;10}</span><span class="ss"> </span><span class="sc">{</span><span class="st">&#39;Szen. mit&#39;</span><span class="sc">:&gt;12}</span><span class="ss">&quot;</span>)</span>
+<span id="cb161-292"><a href="#cb161-292" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;  </span><span class="sc">{</span><span class="st">&#39;&#39;</span><span class="sc">:&lt;32}</span><span class="ss"> </span><span class="sc">{</span><span class="st">&#39;im Mittel&#39;</span><span class="sc">:&gt;10}</span><span class="ss"> </span><span class="sc">{</span><span class="st">&#39;schlimmst.&#39;</span><span class="sc">:&gt;11}</span><span class="ss"> &quot;</span></span>
+<span id="cb161-293"><a href="#cb161-293" aria-hidden="true" tabindex="-1"></a>          <span class="ss">f&quot;</span><span class="sc">{</span><span class="st">&#39;Mittel&#39;</span><span class="sc">:&gt;9}</span><span class="ss"> </span><span class="sc">{</span><span class="st">&#39;CVaR 90%&#39;</span><span class="sc">:&gt;10}</span><span class="ss"> </span><span class="sc">{</span><span class="st">&#39;Abwurf&#39;</span><span class="sc">:&gt;12}</span><span class="ss">&quot;</span>)</span>
+<span id="cb161-294"><a href="#cb161-294" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;  &quot;</span> <span class="op">+</span> <span class="st">&quot;-&quot;</span> <span class="op">*</span> <span class="dv">86</span>)</span>
+<span id="cb161-295"><a href="#cb161-295" aria-hidden="true" tabindex="-1"></a>    plan_billig, _, _ <span class="op">=</span> plane(wind, gleich, abwurfpreis<span class="op">=</span>NIEDRIGER_ABWURFPREIS)</span>
+<span id="cb161-296"><a href="#cb161-296" aria-hidden="true" tabindex="-1"></a>    billig <span class="op">=</span> zeige(<span class="st">&quot;risikoneutral, billiger Abwurf&quot;</span>, plan_billig, wind,</span>
+<span id="cb161-297"><a href="#cb161-297" aria-hidden="true" tabindex="-1"></a>                   NIEDRIGER_ABWURFPREIS)</span>
+<span id="cb161-298"><a href="#cb161-298" aria-hidden="true" tabindex="-1"></a>    plan_billig_sicher, _, _ <span class="op">=</span> plane(wind, gleich, cvar_grenze<span class="op">=</span><span class="fl">0.0</span>,</span>
+<span id="cb161-299"><a href="#cb161-299" aria-hidden="true" tabindex="-1"></a>                                     abwurfpreis<span class="op">=</span>NIEDRIGER_ABWURFPREIS)</span>
+<span id="cb161-300"><a href="#cb161-300" aria-hidden="true" tabindex="-1"></a>    billig_sicher <span class="op">=</span> zeige(<span class="st">&quot;+ CVaR 90 </span><span class="sc">% d</span><span class="st">er Fehlmenge = 0&quot;</span>, plan_billig_sicher, wind,</span>
+<span id="cb161-301"><a href="#cb161-301" aria-hidden="true" tabindex="-1"></a>                          NIEDRIGER_ABWURFPREIS)</span>
+<span id="cb161-302"><a href="#cb161-302" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb161-303"><a href="#cb161-303" aria-hidden="true" tabindex="-1"></a>    aufpreis <span class="op">=</span> billig_sicher[<span class="st">&quot;mittel&quot;</span>] <span class="op">-</span> billig[<span class="st">&quot;mittel&quot;</span>]</span>
+<span id="cb161-304"><a href="#cb161-304" aria-hidden="true" tabindex="-1"></a>    vermieden <span class="op">=</span> billig[<span class="st">&quot;fehl_cvar&quot;</span>] <span class="op">-</span> billig_sicher[<span class="st">&quot;fehl_cvar&quot;</span>]</span>
+<span id="cb161-305"><a href="#cb161-305" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;</span><span class="ch">\n</span><span class="ss">  Jetzt greift die Schranke: Der risikoneutrale Plan nimmt in&quot;</span>)</span>
+<span id="cb161-306"><a href="#cb161-306" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;  </span><span class="sc">{</span>billig[<span class="st">&#39;betroffen&#39;</span>]<span class="sc">}</span><span class="ss"> von </span><span class="sc">{</span>SZENARIEN<span class="sc">}</span><span class="ss"> Szenarien einen Lastabwurf in Kauf, weil er bei&quot;</span>)</span>
+<span id="cb161-307"><a href="#cb161-307" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;  </span><span class="sc">{</span>NIEDRIGER_ABWURFPREIS<span class="sc">:,.0f}</span><span class="ss"> EUR/MWh billiger ist als das Vorhalten eines Blocks.&quot;</span>)</span>
+<span id="cb161-308"><a href="#cb161-308" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;</span><span class="ch">\n</span><span class="ss">  Aufpreis fuer die Sicherheit: </span><span class="sc">{</span>aufpreis<span class="sc">:,.0f}</span><span class="ss"> EUR je Tag&quot;</span>)</span>
+<span id="cb161-309"><a href="#cb161-309" aria-hidden="true" tabindex="-1"></a>    <span class="cf">if</span> vermieden <span class="op">&gt;</span> <span class="fl">0.01</span>:</span>
+<span id="cb161-310"><a href="#cb161-310" aria-hidden="true" tabindex="-1"></a>        <span class="bu">print</span>(<span class="ss">f&quot;  Vermiedene Fehlmenge (CVaR 90 %): </span><span class="sc">{</span>vermieden<span class="sc">:.1f}</span><span class="ss"> MWh&quot;</span>)</span>
+<span id="cb161-311"><a href="#cb161-311" aria-hidden="true" tabindex="-1"></a>        <span class="bu">print</span>(<span class="ss">f&quot;  -&gt; </span><span class="sc">{</span>aufpreis <span class="op">/</span> vermieden<span class="sc">:,.0f}</span><span class="ss"> EUR je vermiedener MWh&quot;</span>)</span>
+<span id="cb161-312"><a href="#cb161-312" aria-hidden="true" tabindex="-1"></a>        <span class="bu">print</span>(<span class="ss">f&quot;</span><span class="ch">\n</span><span class="ss">  Diese Zahl ist die Entscheidungsgrundlage - genau wie die Spalte&quot;</span>)</span>
+<span id="cb161-313"><a href="#cb161-313" aria-hidden="true" tabindex="-1"></a>        <span class="bu">print</span>(<span class="ss">f&quot;  &#39;EUR je kg&#39; im Kapitel Mehrziel. Sie sagt der Aufsicht, was ihre&quot;</span>)</span>
+<span id="cb161-314"><a href="#cb161-314" aria-hidden="true" tabindex="-1"></a>        <span class="bu">print</span>(<span class="ss">f&quot;  Versorgungssicherheitsvorgabe tatsaechlich kostet, statt darueber&quot;</span>)</span>
+<span id="cb161-315"><a href="#cb161-315" aria-hidden="true" tabindex="-1"></a>        <span class="bu">print</span>(<span class="ss">f&quot;  zu streiten, wie wichtig sie ist.&quot;</span>)</span>
+<span id="cb161-316"><a href="#cb161-316" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb161-317"><a href="#cb161-317" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;</span><span class="ch">\n</span><span class="st">&quot;</span> <span class="op">+</span> <span class="st">&quot;=&quot;</span> <span class="op">*</span> <span class="dv">88</span>)</span>
+<span id="cb161-318"><a href="#cb161-318" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;  WAS MAN DARAUS MITNIMMT&quot;</span>)</span>
+<span id="cb161-319"><a href="#cb161-319" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;=&quot;</span> <span class="op">*</span> <span class="dv">88</span>)</span>
+<span id="cb161-320"><a href="#cb161-320" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;1. Die erste Stufe ist binaer und traege. Was am Vorabend nicht&quot;</span>)</span>
+<span id="cb161-321"><a href="#cb161-321" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;   angefahren wurde, steht am naechsten Tag nicht zur Verfuegung -&quot;</span>)</span>
+<span id="cb161-322"><a href="#cb161-322" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;   egal, wie hoch der Preis dann steigt.&quot;</span>)</span>
+<span id="cb161-323"><a href="#cb161-323" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;2. Deshalb ist der Erwartungswert als Planungsgrundlage nicht nur&quot;</span>)</span>
+<span id="cb161-324"><a href="#cb161-324" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;   ungenau, sondern SYSTEMATISCH zu knapp: Er plant fuer einen Tag,&quot;</span>)</span>
+<span id="cb161-325"><a href="#cb161-325" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;   der so nie eintritt, und laesst keine Reserve fuer die Haelfte&quot;</span>)</span>
+<span id="cb161-326"><a href="#cb161-326" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;   der Faelle, in denen es schlechter kommt.&quot;</span>)</span>
+<span id="cb161-327"><a href="#cb161-327" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;3. Der Ausweg ist keine bessere Windprognose, sondern ein Modell,&quot;</span>)</span>
+<span id="cb161-328"><a href="#cb161-328" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;   das die Szenarien SIEHT. Die Rechenzeit dafuer liegt hier im&quot;</span>)</span>
+<span id="cb161-329"><a href="#cb161-329" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;   Sekundenbereich - der Aufwand ist die Modellierung, nicht der&quot;</span>)</span>
+<span id="cb161-330"><a href="#cb161-330" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;   Solver.&quot;</span>)</span>
+<span id="cb161-331"><a href="#cb161-331" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;4. Wo der Lastabwurf teuer genug bepreist ist, deckt schon die&quot;</span>)</span>
+<span id="cb161-332"><a href="#cb161-332" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;   Minimierung der ERWARTETEN Kosten die Extremfaelle mit ab. Die&quot;</span>)</span>
+<span id="cb161-333"><a href="#cb161-333" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;   Risikoschranke wird genau dann gebraucht, wenn der Schaden ZU&quot;</span>)</span>
+<span id="cb161-334"><a href="#cb161-334" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;   NIEDRIG bepreist ist - was bei Versorgungssicherheit die Regel&quot;</span>)</span>
+<span id="cb161-335"><a href="#cb161-335" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;   ist, weil ein Marktpreisdeckel nicht den volkswirtschaftlichen&quot;</span>)</span>
+<span id="cb161-336"><a href="#cb161-336" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;   Schaden abbildet. Dann liefert sie den Preis der Vorgabe in Euro&quot;</span>)</span>
+<span id="cb161-337"><a href="#cb161-337" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;   je vermiedener MWh, und darueber laesst sich verhandeln.&quot;</span>)</span>
+<span id="cb161-338"><a href="#cb161-338" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;=&quot;</span> <span class="op">*</span> <span class="dv">88</span>)</span></code></pre></div>
 <p><strong>Erwartete Ausgabe</strong> (Laufzeiten hardwareabhängig, die Werte nicht):</p>
 <pre><code>========================================================================================
   KRAFTWERKSEINSATZ: DER PLAN STEHT, BEVOR DER WIND WEHT
@@ -21083,6 +22048,16 @@ Was Versorgungssicherheit kostet
 </tbody>
 </table>
 <p>Der Erwartungswert-Plan kostet in der Wirklichkeit <strong>149 % mehr</strong>, und sein schlimmster Tag ist sechsmal so teuer.</p>
+<p><strong>Wofür genau?</strong> Die Summendifferenz von 523 514 € sagt noch nicht, wo sie entsteht. Zerlegt man sie nach Kostenarten, wird aus dem Befund eine Aussage, die man vorlegen kann:</p>
+<figure>
+<img src="bilder_04/kap_supplychain_wirkung.svg" alt="Abb. 17.1: Wofür der Erwartungswert-Plan 149 % mehr bezahlt" />
+<figcaption aria-hidden="true">Abb. 17.1: Wofür der Erwartungswert-Plan 149 % mehr bezahlt</figcaption>
+</figure>
+<p>Drei Dinge stehen darin, die die Tabelle nicht zeigt. Die <strong>Anfahrkosten sind in beiden Plänen gleich</strong> (58 000 €) — der Erwartungswert-Plan spart also nicht dort, wo man es vermuten würde. Er spart <strong>12 725 € Brennstoff</strong>, weil er weniger Blockstunden vorhält. Und er bezahlt dafür <strong>536 239 € Lastabwurf</strong>: das <strong>42-fache</strong> seiner Ersparnis.</p>
+<p>Genau diese Gegenüberstellung ist es, die eine Investitionsentscheidung trägt. „149 % mehr” ist eine Zahl, über die man streiten kann; „wir sparen 12 725 € und riskieren dafür 536 239 €” ist eine, über die man entscheidet.</p>
+<blockquote>
+<p><strong>📌 Zum Diagramm</strong> Es wird von <code>bilder_04/erzeuge_wirkung.py</code> erzeugt, das die Instanz aus <code>Kraftwerkseinsatz.py</code> <strong>erneut rechnet</strong> statt Zahlen zu übernehmen — und dabei die beiden abgedruckten Summen exakt reproduziert. Die Trennung von Brennstoff- und Abwurfkosten ist der einzige Zusatz; das Buchprogramm braucht sie nicht.</p>
+</blockquote>
 <p>Der Unterschied zwischen den beiden Plänen ist dabei erstaunlich klein:</p>
 <pre><code>Erwartungswert   111111122222222211111111  (33 Blockstunden)
 zweistufig       111111222222222222222111  (39 Blockstunden)</code></pre>
@@ -21207,18 +22182,18 @@ zweistufig       111111222222222222222111  (39 Blockstunden)</code></pre>
 <blockquote>
 <p><strong>🚀 In 5 Minuten gelöst: Die durchschnittliche Rendite, die es nicht gibt</strong></p>
 <p>Eine Anlage wurde über vier Perioden beobachtet. Der Kurs stand bei 100, dann bei 50, 75, 150 und schließlich bei <strong>120</strong>.</p>
-<div class="sourceCode" id="cb162"><pre class="sourceCode python"><code class="sourceCode python"><span id="cb162-1"><a href="#cb162-1" aria-hidden="true" tabindex="-1"></a><span class="im">import</span> numpy <span class="im">as</span> np</span>
-<span id="cb162-2"><a href="#cb162-2" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb162-3"><a href="#cb162-3" aria-hidden="true" tabindex="-1"></a>kurse <span class="op">=</span> np.array([<span class="fl">100.0</span>, <span class="fl">50.0</span>, <span class="fl">75.0</span>, <span class="fl">150.0</span>, <span class="fl">120.0</span>])</span>
-<span id="cb162-4"><a href="#cb162-4" aria-hidden="true" tabindex="-1"></a>diskret <span class="op">=</span> kurse[<span class="dv">1</span>:] <span class="op">/</span> kurse[:<span class="op">-</span><span class="dv">1</span>] <span class="op">-</span> <span class="dv">1</span>          <span class="co"># (neu - alt) / alt</span></span>
-<span id="cb162-5"><a href="#cb162-5" aria-hidden="true" tabindex="-1"></a>log <span class="op">=</span> np.log(kurse[<span class="dv">1</span>:] <span class="op">/</span> kurse[:<span class="op">-</span><span class="dv">1</span>])          <span class="co"># ln(neu / alt)</span></span>
-<span id="cb162-6"><a href="#cb162-6" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb162-7"><a href="#cb162-7" aria-hidden="true" tabindex="-1"></a><span class="bu">print</span>(<span class="st">&quot;diskret:&quot;</span>, np.<span class="bu">round</span>(diskret <span class="op">*</span> <span class="dv">100</span>, <span class="dv">2</span>), <span class="st">&quot;%&quot;</span>)</span>
-<span id="cb162-8"><a href="#cb162-8" aria-hidden="true" tabindex="-1"></a><span class="bu">print</span>(<span class="st">&quot;log    :&quot;</span>, np.<span class="bu">round</span>(log <span class="op">*</span> <span class="dv">100</span>, <span class="dv">2</span>), <span class="st">&quot;%&quot;</span>)</span>
-<span id="cb162-9"><a href="#cb162-9" aria-hidden="true" tabindex="-1"></a><span class="bu">print</span>(<span class="ss">f&quot;Mittelwert diskret </span><span class="sc">{</span>diskret<span class="sc">.</span>mean()<span class="op">*</span><span class="dv">100</span><span class="sc">:5.2f}</span><span class="ss"> % -&gt; hochgerechnet &quot;</span></span>
-<span id="cb162-10"><a href="#cb162-10" aria-hidden="true" tabindex="-1"></a>      <span class="ss">f&quot;</span><span class="sc">{</span><span class="dv">100</span> <span class="op">*</span> (<span class="dv">1</span> <span class="op">+</span> diskret.mean())<span class="op">**</span><span class="dv">4</span><span class="sc">:6.2f}</span><span class="ss">&quot;</span>)</span>
-<span id="cb162-11"><a href="#cb162-11" aria-hidden="true" tabindex="-1"></a><span class="bu">print</span>(<span class="ss">f&quot;Mittelwert log     </span><span class="sc">{</span>log<span class="sc">.</span>mean()<span class="op">*</span><span class="dv">100</span><span class="sc">:5.2f}</span><span class="ss"> % -&gt; hochgerechnet &quot;</span></span>
-<span id="cb162-12"><a href="#cb162-12" aria-hidden="true" tabindex="-1"></a>      <span class="ss">f&quot;</span><span class="sc">{</span><span class="dv">100</span> <span class="op">*</span> np<span class="sc">.</span>exp(log.mean() <span class="op">*</span> <span class="dv">4</span>)<span class="sc">:6.2f}</span><span class="ss">&quot;</span>)</span></code></pre></div>
+<div class="sourceCode" id="cb164"><pre class="sourceCode python"><code class="sourceCode python"><span id="cb164-1"><a href="#cb164-1" aria-hidden="true" tabindex="-1"></a><span class="im">import</span> numpy <span class="im">as</span> np</span>
+<span id="cb164-2"><a href="#cb164-2" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb164-3"><a href="#cb164-3" aria-hidden="true" tabindex="-1"></a>kurse <span class="op">=</span> np.array([<span class="fl">100.0</span>, <span class="fl">50.0</span>, <span class="fl">75.0</span>, <span class="fl">150.0</span>, <span class="fl">120.0</span>])</span>
+<span id="cb164-4"><a href="#cb164-4" aria-hidden="true" tabindex="-1"></a>diskret <span class="op">=</span> kurse[<span class="dv">1</span>:] <span class="op">/</span> kurse[:<span class="op">-</span><span class="dv">1</span>] <span class="op">-</span> <span class="dv">1</span>          <span class="co"># (neu - alt) / alt</span></span>
+<span id="cb164-5"><a href="#cb164-5" aria-hidden="true" tabindex="-1"></a>log <span class="op">=</span> np.log(kurse[<span class="dv">1</span>:] <span class="op">/</span> kurse[:<span class="op">-</span><span class="dv">1</span>])          <span class="co"># ln(neu / alt)</span></span>
+<span id="cb164-6"><a href="#cb164-6" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb164-7"><a href="#cb164-7" aria-hidden="true" tabindex="-1"></a><span class="bu">print</span>(<span class="st">&quot;diskret:&quot;</span>, np.<span class="bu">round</span>(diskret <span class="op">*</span> <span class="dv">100</span>, <span class="dv">2</span>), <span class="st">&quot;%&quot;</span>)</span>
+<span id="cb164-8"><a href="#cb164-8" aria-hidden="true" tabindex="-1"></a><span class="bu">print</span>(<span class="st">&quot;log    :&quot;</span>, np.<span class="bu">round</span>(log <span class="op">*</span> <span class="dv">100</span>, <span class="dv">2</span>), <span class="st">&quot;%&quot;</span>)</span>
+<span id="cb164-9"><a href="#cb164-9" aria-hidden="true" tabindex="-1"></a><span class="bu">print</span>(<span class="ss">f&quot;Mittelwert diskret </span><span class="sc">{</span>diskret<span class="sc">.</span>mean()<span class="op">*</span><span class="dv">100</span><span class="sc">:5.2f}</span><span class="ss"> % -&gt; hochgerechnet &quot;</span></span>
+<span id="cb164-10"><a href="#cb164-10" aria-hidden="true" tabindex="-1"></a>      <span class="ss">f&quot;</span><span class="sc">{</span><span class="dv">100</span> <span class="op">*</span> (<span class="dv">1</span> <span class="op">+</span> diskret.mean())<span class="op">**</span><span class="dv">4</span><span class="sc">:6.2f}</span><span class="ss">&quot;</span>)</span>
+<span id="cb164-11"><a href="#cb164-11" aria-hidden="true" tabindex="-1"></a><span class="bu">print</span>(<span class="ss">f&quot;Mittelwert log     </span><span class="sc">{</span>log<span class="sc">.</span>mean()<span class="op">*</span><span class="dv">100</span><span class="sc">:5.2f}</span><span class="ss"> % -&gt; hochgerechnet &quot;</span></span>
+<span id="cb164-12"><a href="#cb164-12" aria-hidden="true" tabindex="-1"></a>      <span class="ss">f&quot;</span><span class="sc">{</span><span class="dv">100</span> <span class="op">*</span> np<span class="sc">.</span>exp(log.mean() <span class="op">*</span> <span class="dv">4</span>)<span class="sc">:6.2f}</span><span class="ss">&quot;</span>)</span></code></pre></div>
 <p><strong>Ausgabe:</strong></p>
 <pre><code>diskret: [-50.  50. 100. -20.] %
 log    : [-69.31  40.55  69.31 -22.31] %
@@ -21343,74 +22318,74 @@ r_{i,0\to T} = \sum_{t=1}^T r_{i,t}
 <p>Die diskreten Renditen <strong>suggerieren einen Gewinn von 16,7 %</strong>, obwohl der Kurs exakt dort steht, wo er begann. Die Log-Renditen heben sich korrekt auf.</p>
 <p><strong>Deshalb ist die Aussage „im Mittel 5 % Rendite“ mehrdeutig.</strong> Das arithmetische Mittel diskreter Renditen überschätzt systematisch, was ein Anleger tatsächlich verdient hätte. Für Wachstumsaussagen nimmt man das <strong>geometrische</strong> Mittel — oder rechnet gleich in Log-Renditen.</p>
 </blockquote>
-<div class="sourceCode" id="cb164"><pre class="sourceCode python"><code class="sourceCode python"><span id="cb164-1"><a href="#cb164-1" aria-hidden="true" tabindex="-1"></a><span class="co">#!/usr/bin/env python3</span></span>
-<span id="cb164-2"><a href="#cb164-2" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb164-3"><a href="#cb164-3" aria-hidden="true" tabindex="-1"></a><span class="co"># Renditen_Vergleich.py</span></span>
-<span id="cb164-4"><a href="#cb164-4" aria-hidden="true" tabindex="-1"></a><span class="co">&quot;&quot;&quot;</span></span>
-<span id="cb164-5"><a href="#cb164-5" aria-hidden="true" tabindex="-1"></a><span class="co">Kapitel Finanzdaten: Diskrete vs. logarithmische Renditen.</span></span>
-<span id="cb164-6"><a href="#cb164-6" aria-hidden="true" tabindex="-1"></a><span class="co">Zeigt an einem simulierten Kursverlauf, welche Eigenschaft wo gilt -</span></span>
-<span id="cb164-7"><a href="#cb164-7" aria-hidden="true" tabindex="-1"></a><span class="co">und warum das arithmetische Mittel diskreter Renditen in die Irre fuehrt.</span></span>
-<span id="cb164-8"><a href="#cb164-8" aria-hidden="true" tabindex="-1"></a><span class="co">&quot;&quot;&quot;</span></span>
-<span id="cb164-9"><a href="#cb164-9" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb164-10"><a href="#cb164-10" aria-hidden="true" tabindex="-1"></a><span class="im">import</span> numpy <span class="im">as</span> np</span>
-<span id="cb164-11"><a href="#cb164-11" aria-hidden="true" tabindex="-1"></a><span class="im">import</span> pandas <span class="im">as</span> pd</span>
-<span id="cb164-12"><a href="#cb164-12" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb164-13"><a href="#cb164-13" aria-hidden="true" tabindex="-1"></a><span class="cf">if</span> <span class="va">__name__</span> <span class="op">==</span> <span class="st">&quot;__main__&quot;</span>:</span>
-<span id="cb164-14"><a href="#cb164-14" aria-hidden="true" tabindex="-1"></a>    kurse <span class="op">=</span> np.array([<span class="fl">100.0</span>, <span class="fl">150.0</span>, <span class="fl">100.0</span>, <span class="fl">120.0</span>, <span class="fl">90.0</span>, <span class="fl">135.0</span>])</span>
-<span id="cb164-15"><a href="#cb164-15" aria-hidden="true" tabindex="-1"></a>    tage <span class="op">=</span> [<span class="ss">f&quot;t</span><span class="sc">{</span>i<span class="sc">}</span><span class="ss">&quot;</span> <span class="cf">for</span> i <span class="kw">in</span> <span class="bu">range</span>(<span class="bu">len</span>(kurse))]</span>
-<span id="cb164-16"><a href="#cb164-16" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb164-17"><a href="#cb164-17" aria-hidden="true" tabindex="-1"></a>    diskret <span class="op">=</span> kurse[<span class="dv">1</span>:] <span class="op">/</span> kurse[:<span class="op">-</span><span class="dv">1</span>] <span class="op">-</span> <span class="fl">1.0</span></span>
-<span id="cb164-18"><a href="#cb164-18" aria-hidden="true" tabindex="-1"></a>    logarithmisch <span class="op">=</span> np.log(kurse[<span class="dv">1</span>:] <span class="op">/</span> kurse[:<span class="op">-</span><span class="dv">1</span>])</span>
-<span id="cb164-19"><a href="#cb164-19" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb164-20"><a href="#cb164-20" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;=&quot;</span> <span class="op">*</span> <span class="dv">74</span>)</span>
-<span id="cb164-21"><a href="#cb164-21" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;  DISKRETE UND LOGARITHMISCHE RENDITEN IM VERGLEICH&quot;</span>)</span>
-<span id="cb164-22"><a href="#cb164-22" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;=&quot;</span> <span class="op">*</span> <span class="dv">74</span>)</span>
-<span id="cb164-23"><a href="#cb164-23" aria-hidden="true" tabindex="-1"></a>    tabelle <span class="op">=</span> pd.DataFrame({</span>
-<span id="cb164-24"><a href="#cb164-24" aria-hidden="true" tabindex="-1"></a>        <span class="st">&quot;Periode&quot;</span>: [<span class="ss">f&quot;</span><span class="sc">{</span>tage[i]<span class="sc">}</span><span class="ss"> -&gt; </span><span class="sc">{</span>tage[i<span class="op">+</span><span class="dv">1</span>]<span class="sc">}</span><span class="ss">&quot;</span> <span class="cf">for</span> i <span class="kw">in</span> <span class="bu">range</span>(<span class="bu">len</span>(diskret))],</span>
-<span id="cb164-25"><a href="#cb164-25" aria-hidden="true" tabindex="-1"></a>        <span class="st">&quot;Kurs von&quot;</span>: kurse[:<span class="op">-</span><span class="dv">1</span>],</span>
-<span id="cb164-26"><a href="#cb164-26" aria-hidden="true" tabindex="-1"></a>        <span class="st">&quot;Kurs bis&quot;</span>: kurse[<span class="dv">1</span>:],</span>
-<span id="cb164-27"><a href="#cb164-27" aria-hidden="true" tabindex="-1"></a>        <span class="st">&quot;diskret R&quot;</span>: [<span class="ss">f&quot;</span><span class="sc">{</span>r<span class="op">*</span><span class="dv">100</span><span class="sc">:+7.2f}</span><span class="ss"> %&quot;</span> <span class="cf">for</span> r <span class="kw">in</span> diskret],</span>
-<span id="cb164-28"><a href="#cb164-28" aria-hidden="true" tabindex="-1"></a>        <span class="st">&quot;log r&quot;</span>: [<span class="ss">f&quot;</span><span class="sc">{</span>r<span class="sc">:+8.4f}</span><span class="ss">&quot;</span> <span class="cf">for</span> r <span class="kw">in</span> logarithmisch],</span>
-<span id="cb164-29"><a href="#cb164-29" aria-hidden="true" tabindex="-1"></a>    })</span>
-<span id="cb164-30"><a href="#cb164-30" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(tabelle.to_string(index<span class="op">=</span><span class="va">False</span>))</span>
-<span id="cb164-31"><a href="#cb164-31" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb164-32"><a href="#cb164-32" aria-hidden="true" tabindex="-1"></a>    <span class="co"># --- Zeitliche Aggregation ------------------------------------------</span></span>
-<span id="cb164-33"><a href="#cb164-33" aria-hidden="true" tabindex="-1"></a>    gesamt_wahr <span class="op">=</span> kurse[<span class="op">-</span><span class="dv">1</span>] <span class="op">/</span> kurse[<span class="dv">0</span>] <span class="op">-</span> <span class="fl">1.0</span></span>
-<span id="cb164-34"><a href="#cb164-34" aria-hidden="true" tabindex="-1"></a>    summe_log <span class="op">=</span> logarithmisch.<span class="bu">sum</span>()</span>
-<span id="cb164-35"><a href="#cb164-35" aria-hidden="true" tabindex="-1"></a>    aus_log_zurueck <span class="op">=</span> np.exp(summe_log) <span class="op">-</span> <span class="fl">1.0</span></span>
-<span id="cb164-36"><a href="#cb164-36" aria-hidden="true" tabindex="-1"></a>    summe_diskret <span class="op">=</span> diskret.<span class="bu">sum</span>()</span>
-<span id="cb164-37"><a href="#cb164-37" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb164-38"><a href="#cb164-38" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;</span><span class="ch">\n</span><span class="st">--- Aggregation ueber die Zeit ---&quot;</span>)</span>
-<span id="cb164-39"><a href="#cb164-39" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;  Tatsaechliche Gesamtrendite:        </span><span class="sc">{</span>gesamt_wahr<span class="op">*</span><span class="dv">100</span><span class="sc">:+8.2f}</span><span class="ss"> %&quot;</span>)</span>
-<span id="cb164-40"><a href="#cb164-40" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;  Summe der Log-Renditen -&gt; exp()-1:  </span><span class="sc">{</span>aus_log_zurueck<span class="op">*</span><span class="dv">100</span><span class="sc">:+8.2f}</span><span class="ss"> %  &quot;</span></span>
-<span id="cb164-41"><a href="#cb164-41" aria-hidden="true" tabindex="-1"></a>          <span class="ss">f&quot;</span><span class="sc">{</span><span class="st">&#39;KORREKT&#39;</span> <span class="cf">if</span> <span class="bu">abs</span>(aus_log_zurueck <span class="op">-</span> gesamt_wahr) <span class="op">&lt;</span> <span class="fl">1e-9</span> <span class="cf">else</span> <span class="st">&#39;falsch&#39;</span><span class="sc">}</span><span class="ss">&quot;</span>)</span>
-<span id="cb164-42"><a href="#cb164-42" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;  Summe der diskreten Renditen:       </span><span class="sc">{</span>summe_diskret<span class="op">*</span><span class="dv">100</span><span class="sc">:+8.2f}</span><span class="ss"> %  FALSCH&quot;</span>)</span>
-<span id="cb164-43"><a href="#cb164-43" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb164-44"><a href="#cb164-44" aria-hidden="true" tabindex="-1"></a>    <span class="co"># --- Mittelwerte ------------------------------------------------------</span></span>
-<span id="cb164-45"><a href="#cb164-45" aria-hidden="true" tabindex="-1"></a>    arithmetisch <span class="op">=</span> diskret.mean()</span>
-<span id="cb164-46"><a href="#cb164-46" aria-hidden="true" tabindex="-1"></a>    geometrisch <span class="op">=</span> np.prod(<span class="dv">1</span> <span class="op">+</span> diskret) <span class="op">**</span> (<span class="dv">1</span> <span class="op">/</span> <span class="bu">len</span>(diskret)) <span class="op">-</span> <span class="dv">1</span></span>
-<span id="cb164-47"><a href="#cb164-47" aria-hidden="true" tabindex="-1"></a>    aus_log <span class="op">=</span> np.exp(logarithmisch.mean()) <span class="op">-</span> <span class="dv">1</span></span>
-<span id="cb164-48"><a href="#cb164-48" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb164-49"><a href="#cb164-49" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;</span><span class="ch">\n</span><span class="st">--- Welcher Mittelwert ist der richtige? ---&quot;</span>)</span>
-<span id="cb164-50"><a href="#cb164-50" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;  Arithmetisches Mittel (diskret):    </span><span class="sc">{</span>arithmetisch<span class="op">*</span><span class="dv">100</span><span class="sc">:+8.2f}</span><span class="ss"> %  &quot;</span></span>
-<span id="cb164-51"><a href="#cb164-51" aria-hidden="true" tabindex="-1"></a>          <span class="ss">f&quot;-&gt; ueberschaetzt&quot;</span>)</span>
-<span id="cb164-52"><a href="#cb164-52" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;  Geometrisches Mittel:               </span><span class="sc">{</span>geometrisch<span class="op">*</span><span class="dv">100</span><span class="sc">:+8.2f}</span><span class="ss"> %  -&gt; korrekt&quot;</span>)</span>
-<span id="cb164-53"><a href="#cb164-53" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;  exp(Mittel der Log-Renditen) - 1:   </span><span class="sc">{</span>aus_log<span class="op">*</span><span class="dv">100</span><span class="sc">:+8.2f}</span><span class="ss"> %  &quot;</span></span>
-<span id="cb164-54"><a href="#cb164-54" aria-hidden="true" tabindex="-1"></a>          <span class="ss">f&quot;-&gt; identisch zum geometrischen&quot;</span>)</span>
-<span id="cb164-55"><a href="#cb164-55" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb164-56"><a href="#cb164-56" aria-hidden="true" tabindex="-1"></a>    <span class="co"># Probe: Endkapital mit dem jeweiligen Mittelwert hochgerechnet</span></span>
-<span id="cb164-57"><a href="#cb164-57" aria-hidden="true" tabindex="-1"></a>    n <span class="op">=</span> <span class="bu">len</span>(diskret)</span>
-<span id="cb164-58"><a href="#cb164-58" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;</span><span class="ch">\n</span><span class="ss">  Probe - Startkapital 100 EUR ueber </span><span class="sc">{</span>n<span class="sc">}</span><span class="ss"> Perioden:&quot;</span>)</span>
-<span id="cb164-59"><a href="#cb164-59" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;    tatsaechlich:                     </span><span class="sc">{</span>kurse[<span class="op">-</span><span class="dv">1</span>]<span class="sc">:8.2f}</span><span class="ss"> EUR&quot;</span>)</span>
-<span id="cb164-60"><a href="#cb164-60" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;    mit arithm. Mittel hochgerechnet: </span><span class="sc">{</span><span class="dv">100</span><span class="op">*</span>(<span class="dv">1</span><span class="op">+</span>arithmetisch)<span class="op">**</span>n<span class="sc">:8.2f}</span><span class="ss"> EUR&quot;</span>)</span>
-<span id="cb164-61"><a href="#cb164-61" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;    mit geom.  Mittel hochgerechnet:  </span><span class="sc">{</span><span class="dv">100</span><span class="op">*</span>(<span class="dv">1</span><span class="op">+</span>geometrisch)<span class="op">**</span>n<span class="sc">:8.2f}</span><span class="ss"> EUR&quot;</span>)</span>
-<span id="cb164-62"><a href="#cb164-62" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb164-63"><a href="#cb164-63" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;</span><span class="ch">\n</span><span class="st">--- Annualisierung (252 Handelstage) ---&quot;</span>)</span>
-<span id="cb164-64"><a href="#cb164-64" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;  Volatilitaet aus Log-Renditen: &quot;</span></span>
-<span id="cb164-65"><a href="#cb164-65" aria-hidden="true" tabindex="-1"></a>          <span class="ss">f&quot;</span><span class="sc">{</span>logarithmisch<span class="sc">.</span>std(ddof<span class="op">=</span><span class="dv">1</span>)<span class="op">*</span>np<span class="sc">.</span>sqrt(<span class="dv">252</span>)<span class="op">*</span><span class="dv">100</span><span class="sc">:.2f}</span><span class="ss"> % p.a.&quot;</span>)</span>
-<span id="cb164-66"><a href="#cb164-66" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;  (Die Wurzel-Zeit-Regel gilt nur bei unabhaengigen Renditen -&quot;</span>)</span>
-<span id="cb164-67"><a href="#cb164-67" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;   fuer reale Maerkte ist sie eine Naeherung.)&quot;</span>)</span>
-<span id="cb164-68"><a href="#cb164-68" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;=&quot;</span> <span class="op">*</span> <span class="dv">74</span>)</span></code></pre></div>
+<div class="sourceCode" id="cb166"><pre class="sourceCode python"><code class="sourceCode python"><span id="cb166-1"><a href="#cb166-1" aria-hidden="true" tabindex="-1"></a><span class="co">#!/usr/bin/env python3</span></span>
+<span id="cb166-2"><a href="#cb166-2" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb166-3"><a href="#cb166-3" aria-hidden="true" tabindex="-1"></a><span class="co"># Renditen_Vergleich.py</span></span>
+<span id="cb166-4"><a href="#cb166-4" aria-hidden="true" tabindex="-1"></a><span class="co">&quot;&quot;&quot;</span></span>
+<span id="cb166-5"><a href="#cb166-5" aria-hidden="true" tabindex="-1"></a><span class="co">Kapitel Finanzdaten: Diskrete vs. logarithmische Renditen.</span></span>
+<span id="cb166-6"><a href="#cb166-6" aria-hidden="true" tabindex="-1"></a><span class="co">Zeigt an einem simulierten Kursverlauf, welche Eigenschaft wo gilt -</span></span>
+<span id="cb166-7"><a href="#cb166-7" aria-hidden="true" tabindex="-1"></a><span class="co">und warum das arithmetische Mittel diskreter Renditen in die Irre fuehrt.</span></span>
+<span id="cb166-8"><a href="#cb166-8" aria-hidden="true" tabindex="-1"></a><span class="co">&quot;&quot;&quot;</span></span>
+<span id="cb166-9"><a href="#cb166-9" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb166-10"><a href="#cb166-10" aria-hidden="true" tabindex="-1"></a><span class="im">import</span> numpy <span class="im">as</span> np</span>
+<span id="cb166-11"><a href="#cb166-11" aria-hidden="true" tabindex="-1"></a><span class="im">import</span> pandas <span class="im">as</span> pd</span>
+<span id="cb166-12"><a href="#cb166-12" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb166-13"><a href="#cb166-13" aria-hidden="true" tabindex="-1"></a><span class="cf">if</span> <span class="va">__name__</span> <span class="op">==</span> <span class="st">&quot;__main__&quot;</span>:</span>
+<span id="cb166-14"><a href="#cb166-14" aria-hidden="true" tabindex="-1"></a>    kurse <span class="op">=</span> np.array([<span class="fl">100.0</span>, <span class="fl">150.0</span>, <span class="fl">100.0</span>, <span class="fl">120.0</span>, <span class="fl">90.0</span>, <span class="fl">135.0</span>])</span>
+<span id="cb166-15"><a href="#cb166-15" aria-hidden="true" tabindex="-1"></a>    tage <span class="op">=</span> [<span class="ss">f&quot;t</span><span class="sc">{</span>i<span class="sc">}</span><span class="ss">&quot;</span> <span class="cf">for</span> i <span class="kw">in</span> <span class="bu">range</span>(<span class="bu">len</span>(kurse))]</span>
+<span id="cb166-16"><a href="#cb166-16" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb166-17"><a href="#cb166-17" aria-hidden="true" tabindex="-1"></a>    diskret <span class="op">=</span> kurse[<span class="dv">1</span>:] <span class="op">/</span> kurse[:<span class="op">-</span><span class="dv">1</span>] <span class="op">-</span> <span class="fl">1.0</span></span>
+<span id="cb166-18"><a href="#cb166-18" aria-hidden="true" tabindex="-1"></a>    logarithmisch <span class="op">=</span> np.log(kurse[<span class="dv">1</span>:] <span class="op">/</span> kurse[:<span class="op">-</span><span class="dv">1</span>])</span>
+<span id="cb166-19"><a href="#cb166-19" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb166-20"><a href="#cb166-20" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;=&quot;</span> <span class="op">*</span> <span class="dv">74</span>)</span>
+<span id="cb166-21"><a href="#cb166-21" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;  DISKRETE UND LOGARITHMISCHE RENDITEN IM VERGLEICH&quot;</span>)</span>
+<span id="cb166-22"><a href="#cb166-22" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;=&quot;</span> <span class="op">*</span> <span class="dv">74</span>)</span>
+<span id="cb166-23"><a href="#cb166-23" aria-hidden="true" tabindex="-1"></a>    tabelle <span class="op">=</span> pd.DataFrame({</span>
+<span id="cb166-24"><a href="#cb166-24" aria-hidden="true" tabindex="-1"></a>        <span class="st">&quot;Periode&quot;</span>: [<span class="ss">f&quot;</span><span class="sc">{</span>tage[i]<span class="sc">}</span><span class="ss"> -&gt; </span><span class="sc">{</span>tage[i<span class="op">+</span><span class="dv">1</span>]<span class="sc">}</span><span class="ss">&quot;</span> <span class="cf">for</span> i <span class="kw">in</span> <span class="bu">range</span>(<span class="bu">len</span>(diskret))],</span>
+<span id="cb166-25"><a href="#cb166-25" aria-hidden="true" tabindex="-1"></a>        <span class="st">&quot;Kurs von&quot;</span>: kurse[:<span class="op">-</span><span class="dv">1</span>],</span>
+<span id="cb166-26"><a href="#cb166-26" aria-hidden="true" tabindex="-1"></a>        <span class="st">&quot;Kurs bis&quot;</span>: kurse[<span class="dv">1</span>:],</span>
+<span id="cb166-27"><a href="#cb166-27" aria-hidden="true" tabindex="-1"></a>        <span class="st">&quot;diskret R&quot;</span>: [<span class="ss">f&quot;</span><span class="sc">{</span>r<span class="op">*</span><span class="dv">100</span><span class="sc">:+7.2f}</span><span class="ss"> %&quot;</span> <span class="cf">for</span> r <span class="kw">in</span> diskret],</span>
+<span id="cb166-28"><a href="#cb166-28" aria-hidden="true" tabindex="-1"></a>        <span class="st">&quot;log r&quot;</span>: [<span class="ss">f&quot;</span><span class="sc">{</span>r<span class="sc">:+8.4f}</span><span class="ss">&quot;</span> <span class="cf">for</span> r <span class="kw">in</span> logarithmisch],</span>
+<span id="cb166-29"><a href="#cb166-29" aria-hidden="true" tabindex="-1"></a>    })</span>
+<span id="cb166-30"><a href="#cb166-30" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(tabelle.to_string(index<span class="op">=</span><span class="va">False</span>))</span>
+<span id="cb166-31"><a href="#cb166-31" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb166-32"><a href="#cb166-32" aria-hidden="true" tabindex="-1"></a>    <span class="co"># --- Zeitliche Aggregation ------------------------------------------</span></span>
+<span id="cb166-33"><a href="#cb166-33" aria-hidden="true" tabindex="-1"></a>    gesamt_wahr <span class="op">=</span> kurse[<span class="op">-</span><span class="dv">1</span>] <span class="op">/</span> kurse[<span class="dv">0</span>] <span class="op">-</span> <span class="fl">1.0</span></span>
+<span id="cb166-34"><a href="#cb166-34" aria-hidden="true" tabindex="-1"></a>    summe_log <span class="op">=</span> logarithmisch.<span class="bu">sum</span>()</span>
+<span id="cb166-35"><a href="#cb166-35" aria-hidden="true" tabindex="-1"></a>    aus_log_zurueck <span class="op">=</span> np.exp(summe_log) <span class="op">-</span> <span class="fl">1.0</span></span>
+<span id="cb166-36"><a href="#cb166-36" aria-hidden="true" tabindex="-1"></a>    summe_diskret <span class="op">=</span> diskret.<span class="bu">sum</span>()</span>
+<span id="cb166-37"><a href="#cb166-37" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb166-38"><a href="#cb166-38" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;</span><span class="ch">\n</span><span class="st">--- Aggregation ueber die Zeit ---&quot;</span>)</span>
+<span id="cb166-39"><a href="#cb166-39" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;  Tatsaechliche Gesamtrendite:        </span><span class="sc">{</span>gesamt_wahr<span class="op">*</span><span class="dv">100</span><span class="sc">:+8.2f}</span><span class="ss"> %&quot;</span>)</span>
+<span id="cb166-40"><a href="#cb166-40" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;  Summe der Log-Renditen -&gt; exp()-1:  </span><span class="sc">{</span>aus_log_zurueck<span class="op">*</span><span class="dv">100</span><span class="sc">:+8.2f}</span><span class="ss"> %  &quot;</span></span>
+<span id="cb166-41"><a href="#cb166-41" aria-hidden="true" tabindex="-1"></a>          <span class="ss">f&quot;</span><span class="sc">{</span><span class="st">&#39;KORREKT&#39;</span> <span class="cf">if</span> <span class="bu">abs</span>(aus_log_zurueck <span class="op">-</span> gesamt_wahr) <span class="op">&lt;</span> <span class="fl">1e-9</span> <span class="cf">else</span> <span class="st">&#39;falsch&#39;</span><span class="sc">}</span><span class="ss">&quot;</span>)</span>
+<span id="cb166-42"><a href="#cb166-42" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;  Summe der diskreten Renditen:       </span><span class="sc">{</span>summe_diskret<span class="op">*</span><span class="dv">100</span><span class="sc">:+8.2f}</span><span class="ss"> %  FALSCH&quot;</span>)</span>
+<span id="cb166-43"><a href="#cb166-43" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb166-44"><a href="#cb166-44" aria-hidden="true" tabindex="-1"></a>    <span class="co"># --- Mittelwerte ------------------------------------------------------</span></span>
+<span id="cb166-45"><a href="#cb166-45" aria-hidden="true" tabindex="-1"></a>    arithmetisch <span class="op">=</span> diskret.mean()</span>
+<span id="cb166-46"><a href="#cb166-46" aria-hidden="true" tabindex="-1"></a>    geometrisch <span class="op">=</span> np.prod(<span class="dv">1</span> <span class="op">+</span> diskret) <span class="op">**</span> (<span class="dv">1</span> <span class="op">/</span> <span class="bu">len</span>(diskret)) <span class="op">-</span> <span class="dv">1</span></span>
+<span id="cb166-47"><a href="#cb166-47" aria-hidden="true" tabindex="-1"></a>    aus_log <span class="op">=</span> np.exp(logarithmisch.mean()) <span class="op">-</span> <span class="dv">1</span></span>
+<span id="cb166-48"><a href="#cb166-48" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb166-49"><a href="#cb166-49" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;</span><span class="ch">\n</span><span class="st">--- Welcher Mittelwert ist der richtige? ---&quot;</span>)</span>
+<span id="cb166-50"><a href="#cb166-50" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;  Arithmetisches Mittel (diskret):    </span><span class="sc">{</span>arithmetisch<span class="op">*</span><span class="dv">100</span><span class="sc">:+8.2f}</span><span class="ss"> %  &quot;</span></span>
+<span id="cb166-51"><a href="#cb166-51" aria-hidden="true" tabindex="-1"></a>          <span class="ss">f&quot;-&gt; ueberschaetzt&quot;</span>)</span>
+<span id="cb166-52"><a href="#cb166-52" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;  Geometrisches Mittel:               </span><span class="sc">{</span>geometrisch<span class="op">*</span><span class="dv">100</span><span class="sc">:+8.2f}</span><span class="ss"> %  -&gt; korrekt&quot;</span>)</span>
+<span id="cb166-53"><a href="#cb166-53" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;  exp(Mittel der Log-Renditen) - 1:   </span><span class="sc">{</span>aus_log<span class="op">*</span><span class="dv">100</span><span class="sc">:+8.2f}</span><span class="ss"> %  &quot;</span></span>
+<span id="cb166-54"><a href="#cb166-54" aria-hidden="true" tabindex="-1"></a>          <span class="ss">f&quot;-&gt; identisch zum geometrischen&quot;</span>)</span>
+<span id="cb166-55"><a href="#cb166-55" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb166-56"><a href="#cb166-56" aria-hidden="true" tabindex="-1"></a>    <span class="co"># Probe: Endkapital mit dem jeweiligen Mittelwert hochgerechnet</span></span>
+<span id="cb166-57"><a href="#cb166-57" aria-hidden="true" tabindex="-1"></a>    n <span class="op">=</span> <span class="bu">len</span>(diskret)</span>
+<span id="cb166-58"><a href="#cb166-58" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;</span><span class="ch">\n</span><span class="ss">  Probe - Startkapital 100 EUR ueber </span><span class="sc">{</span>n<span class="sc">}</span><span class="ss"> Perioden:&quot;</span>)</span>
+<span id="cb166-59"><a href="#cb166-59" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;    tatsaechlich:                     </span><span class="sc">{</span>kurse[<span class="op">-</span><span class="dv">1</span>]<span class="sc">:8.2f}</span><span class="ss"> EUR&quot;</span>)</span>
+<span id="cb166-60"><a href="#cb166-60" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;    mit arithm. Mittel hochgerechnet: </span><span class="sc">{</span><span class="dv">100</span><span class="op">*</span>(<span class="dv">1</span><span class="op">+</span>arithmetisch)<span class="op">**</span>n<span class="sc">:8.2f}</span><span class="ss"> EUR&quot;</span>)</span>
+<span id="cb166-61"><a href="#cb166-61" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;    mit geom.  Mittel hochgerechnet:  </span><span class="sc">{</span><span class="dv">100</span><span class="op">*</span>(<span class="dv">1</span><span class="op">+</span>geometrisch)<span class="op">**</span>n<span class="sc">:8.2f}</span><span class="ss"> EUR&quot;</span>)</span>
+<span id="cb166-62"><a href="#cb166-62" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb166-63"><a href="#cb166-63" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;</span><span class="ch">\n</span><span class="st">--- Annualisierung (252 Handelstage) ---&quot;</span>)</span>
+<span id="cb166-64"><a href="#cb166-64" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;  Volatilitaet aus Log-Renditen: &quot;</span></span>
+<span id="cb166-65"><a href="#cb166-65" aria-hidden="true" tabindex="-1"></a>          <span class="ss">f&quot;</span><span class="sc">{</span>logarithmisch<span class="sc">.</span>std(ddof<span class="op">=</span><span class="dv">1</span>)<span class="op">*</span>np<span class="sc">.</span>sqrt(<span class="dv">252</span>)<span class="op">*</span><span class="dv">100</span><span class="sc">:.2f}</span><span class="ss"> % p.a.&quot;</span>)</span>
+<span id="cb166-66"><a href="#cb166-66" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;  (Die Wurzel-Zeit-Regel gilt nur bei unabhaengigen Renditen -&quot;</span>)</span>
+<span id="cb166-67"><a href="#cb166-67" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;   fuer reale Maerkte ist sie eine Naeherung.)&quot;</span>)</span>
+<span id="cb166-68"><a href="#cb166-68" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;=&quot;</span> <span class="op">*</span> <span class="dv">74</span>)</span></code></pre></div>
 <hr />
 <h2 id="sec:finanzdaten-das-schaetzfehler-problem">18.4 Das Schätzfehler-Problem</h2>
 <p>Sei <span class="math inline">\mathbf{X}\in\mathbb{R}^{T\times N}</span> die Matrix zentrierter Renditen von <span class="math inline">N</span> Titeln über <span class="math inline">T</span> Handelstage. Die <strong>Stichproben-Kovarianzmatrix</strong> lautet:</p>
@@ -21452,102 +22427,102 @@ r_{i,0\to T} = \sum_{t=1}^T r_{i,t}
 <blockquote>
 <p><strong>🎯 Der Error-Maximizer-Effekt</strong> Ein Risikominimierer sucht die Richtungen mit der <strong>kleinsten</strong> Varianz — also genau jene Eigenrichtungen, deren Eigenwerte am stärksten <strong>nach unten verzerrt</strong> sind. Die Optimierung greift damit zielsicher in das Schätzrauschen hinein. Markowitz-Optimierung ist deshalb kein Fehlerdämpfer, sondern ein <strong>Fehlerverstärker</strong>.</p>
 </blockquote>
-<div class="sourceCode" id="cb165"><pre class="sourceCode python"><code class="sourceCode python"><span id="cb165-1"><a href="#cb165-1" aria-hidden="true" tabindex="-1"></a><span class="co">#!/usr/bin/env python3</span></span>
-<span id="cb165-2"><a href="#cb165-2" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb165-3"><a href="#cb165-3" aria-hidden="true" tabindex="-1"></a><span class="co"># Schaetzrauschen_Demo.py</span></span>
-<span id="cb165-4"><a href="#cb165-4" aria-hidden="true" tabindex="-1"></a><span class="co">&quot;&quot;&quot;</span></span>
-<span id="cb165-5"><a href="#cb165-5" aria-hidden="true" tabindex="-1"></a><span class="co">Kapitel Finanzdaten: Der Error-Maximizer-Effekt im Experiment.</span></span>
-<span id="cb165-6"><a href="#cb165-6" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb165-7"><a href="#cb165-7" aria-hidden="true" tabindex="-1"></a><span class="co">Aufbau: Wir KENNEN die wahre Kovarianzmatrix, weil wir die Daten selbst</span></span>
-<span id="cb165-8"><a href="#cb165-8" aria-hidden="true" tabindex="-1"></a><span class="co">erzeugen. Dann schaetzen wir sie aus endlich vielen Beobachtungen und</span></span>
-<span id="cb165-9"><a href="#cb165-9" aria-hidden="true" tabindex="-1"></a><span class="co">vergleichen, wie gut das daraus optimierte Portfolio in der WAHREN Welt</span></span>
-<span id="cb165-10"><a href="#cb165-10" aria-hidden="true" tabindex="-1"></a><span class="co">abschneidet - mit und ohne Shrinkage.</span></span>
-<span id="cb165-11"><a href="#cb165-11" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb165-12"><a href="#cb165-12" aria-hidden="true" tabindex="-1"></a><span class="co">Das ist der einzige saubere Weg, Schaetzfehler zu messen: Man braucht eine</span></span>
-<span id="cb165-13"><a href="#cb165-13" aria-hidden="true" tabindex="-1"></a><span class="co">Wahrheit zum Vergleich, und die gibt es nur in der Simulation.</span></span>
-<span id="cb165-14"><a href="#cb165-14" aria-hidden="true" tabindex="-1"></a><span class="co">&quot;&quot;&quot;</span></span>
-<span id="cb165-15"><a href="#cb165-15" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb165-16"><a href="#cb165-16" aria-hidden="true" tabindex="-1"></a><span class="im">import</span> numpy <span class="im">as</span> np</span>
-<span id="cb165-17"><a href="#cb165-17" aria-hidden="true" tabindex="-1"></a><span class="im">from</span> sklearn.covariance <span class="im">import</span> LedoitWolf</span>
-<span id="cb165-18"><a href="#cb165-18" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb165-19"><a href="#cb165-19" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb165-20"><a href="#cb165-20" aria-hidden="true" tabindex="-1"></a><span class="kw">def</span> erzeuge_wahre_kovarianz(n, rng):</span>
-<span id="cb165-21"><a href="#cb165-21" aria-hidden="true" tabindex="-1"></a>    <span class="co">&quot;&quot;&quot;Ein-Faktor-Modell: gemeinsamer Marktfaktor plus titelspezifisches Rauschen.&quot;&quot;&quot;</span></span>
-<span id="cb165-22"><a href="#cb165-22" aria-hidden="true" tabindex="-1"></a>    beta <span class="op">=</span> rng.uniform(<span class="fl">0.6</span>, <span class="fl">1.4</span>, size<span class="op">=</span>n)             <span class="co"># Marktsensitivitaeten</span></span>
-<span id="cb165-23"><a href="#cb165-23" aria-hidden="true" tabindex="-1"></a>    var_markt <span class="op">=</span> <span class="fl">0.04</span>                                  <span class="co"># Marktvarianz p.a.</span></span>
-<span id="cb165-24"><a href="#cb165-24" aria-hidden="true" tabindex="-1"></a>    var_spezifisch <span class="op">=</span> rng.uniform(<span class="fl">0.01</span>, <span class="fl">0.09</span>, size<span class="op">=</span>n)  <span class="co"># idiosynkratische Varianz</span></span>
-<span id="cb165-25"><a href="#cb165-25" aria-hidden="true" tabindex="-1"></a>    <span class="cf">return</span> np.outer(beta, beta) <span class="op">*</span> var_markt <span class="op">+</span> np.diag(var_spezifisch)</span>
-<span id="cb165-26"><a href="#cb165-26" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb165-27"><a href="#cb165-27" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb165-28"><a href="#cb165-28" aria-hidden="true" tabindex="-1"></a><span class="kw">def</span> minimum_varianz_gewichte(sigma):</span>
-<span id="cb165-29"><a href="#cb165-29" aria-hidden="true" tabindex="-1"></a>    <span class="co">&quot;&quot;&quot;Analytische GMV-Loesung: w = Sigma^-1 1 / (1&#39; Sigma^-1 1). Ohne Restriktionen.&quot;&quot;&quot;</span></span>
-<span id="cb165-30"><a href="#cb165-30" aria-hidden="true" tabindex="-1"></a>    eins <span class="op">=</span> np.ones(<span class="bu">len</span>(sigma))</span>
-<span id="cb165-31"><a href="#cb165-31" aria-hidden="true" tabindex="-1"></a>    <span class="cf">try</span>:</span>
-<span id="cb165-32"><a href="#cb165-32" aria-hidden="true" tabindex="-1"></a>        loesung <span class="op">=</span> np.linalg.solve(sigma, eins)</span>
-<span id="cb165-33"><a href="#cb165-33" aria-hidden="true" tabindex="-1"></a>    <span class="cf">except</span> np.linalg.LinAlgError:</span>
-<span id="cb165-34"><a href="#cb165-34" aria-hidden="true" tabindex="-1"></a>        loesung <span class="op">=</span> np.linalg.pinv(sigma) <span class="op">@</span> eins        <span class="co"># falls singulaer</span></span>
-<span id="cb165-35"><a href="#cb165-35" aria-hidden="true" tabindex="-1"></a>    <span class="cf">return</span> loesung <span class="op">/</span> loesung.<span class="bu">sum</span>()</span>
-<span id="cb165-36"><a href="#cb165-36" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb165-37"><a href="#cb165-37" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb165-38"><a href="#cb165-38" aria-hidden="true" tabindex="-1"></a><span class="kw">def</span> portfoliovolatilitaet(w, sigma):</span>
-<span id="cb165-39"><a href="#cb165-39" aria-hidden="true" tabindex="-1"></a>    <span class="cf">return</span> <span class="bu">float</span>(np.sqrt(w <span class="op">@</span> sigma <span class="op">@</span> w))</span>
-<span id="cb165-40"><a href="#cb165-40" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb165-41"><a href="#cb165-41" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb165-42"><a href="#cb165-42" aria-hidden="true" tabindex="-1"></a><span class="cf">if</span> <span class="va">__name__</span> <span class="op">==</span> <span class="st">&quot;__main__&quot;</span>:</span>
-<span id="cb165-43"><a href="#cb165-43" aria-hidden="true" tabindex="-1"></a>    rng <span class="op">=</span> np.random.default_rng(<span class="dv">2026</span>)</span>
-<span id="cb165-44"><a href="#cb165-44" aria-hidden="true" tabindex="-1"></a>    N <span class="op">=</span> <span class="dv">40</span>                                            <span class="co"># Anzahl Titel</span></span>
-<span id="cb165-45"><a href="#cb165-45" aria-hidden="true" tabindex="-1"></a>    WIEDERHOLUNGEN <span class="op">=</span> <span class="dv">200</span></span>
-<span id="cb165-46"><a href="#cb165-46" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb165-47"><a href="#cb165-47" aria-hidden="true" tabindex="-1"></a>    sigma_wahr <span class="op">=</span> erzeuge_wahre_kovarianz(N, rng)</span>
-<span id="cb165-48"><a href="#cb165-48" aria-hidden="true" tabindex="-1"></a>    w_ideal <span class="op">=</span> minimum_varianz_gewichte(sigma_wahr)</span>
-<span id="cb165-49"><a href="#cb165-49" aria-hidden="true" tabindex="-1"></a>    vola_ideal <span class="op">=</span> portfoliovolatilitaet(w_ideal, sigma_wahr)</span>
-<span id="cb165-50"><a href="#cb165-50" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb165-51"><a href="#cb165-51" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;=&quot;</span> <span class="op">*</span> <span class="dv">92</span>)</span>
-<span id="cb165-52"><a href="#cb165-52" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;  ERROR-MAXIMIZER: WIE TEUER IST SCHAETZRAUSCHEN?&quot;</span>)</span>
-<span id="cb165-53"><a href="#cb165-53" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;=&quot;</span> <span class="op">*</span> <span class="dv">92</span>)</span>
-<span id="cb165-54"><a href="#cb165-54" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;Aufbau: </span><span class="sc">{</span>N<span class="sc">}</span><span class="ss"> Titel, wahre Kovarianz bekannt (Ein-Faktor-Modell).&quot;</span>)</span>
-<span id="cb165-55"><a href="#cb165-55" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;Bestmoegliche Volatilitaet bei perfektem Wissen: &quot;</span></span>
-<span id="cb165-56"><a href="#cb165-56" aria-hidden="true" tabindex="-1"></a>          <span class="ss">f&quot;</span><span class="sc">{</span>vola_ideal<span class="op">*</span><span class="dv">100</span><span class="sc">:.2f}</span><span class="ss"> % p.a.</span><span class="ch">\n</span><span class="ss">&quot;</span>)</span>
-<span id="cb165-57"><a href="#cb165-57" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb165-58"><a href="#cb165-58" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;</span><span class="sc">{</span><span class="st">&#39;T (Tage)&#39;</span><span class="sc">:&gt;9}</span><span class="ss"> | </span><span class="sc">{</span><span class="st">&#39;T/N&#39;</span><span class="sc">:&gt;5}</span><span class="ss"> | </span><span class="sc">{</span><span class="st">&#39;Stichprobe&#39;</span><span class="sc">:&gt;22}</span><span class="ss"> | </span><span class="sc">{</span><span class="st">&#39;Ledoit-Wolf&#39;</span><span class="sc">:&gt;22}</span><span class="ss"> | &quot;</span></span>
-<span id="cb165-59"><a href="#cb165-59" aria-hidden="true" tabindex="-1"></a>          <span class="ss">f&quot;</span><span class="sc">{</span><span class="st">&#39;Shrink&#39;</span><span class="sc">:&gt;7}</span><span class="ss">&quot;</span>)</span>
-<span id="cb165-60"><a href="#cb165-60" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;</span><span class="sc">{</span><span class="st">&#39;&#39;</span><span class="sc">:&gt;9}</span><span class="ss"> | </span><span class="sc">{</span><span class="st">&#39;&#39;</span><span class="sc">:&gt;5}</span><span class="ss"> | </span><span class="sc">{</span><span class="st">&#39;Vola     Aufschlag&#39;</span><span class="sc">:&gt;22}</span><span class="ss"> | &quot;</span></span>
-<span id="cb165-61"><a href="#cb165-61" aria-hidden="true" tabindex="-1"></a>          <span class="ss">f&quot;</span><span class="sc">{</span><span class="st">&#39;Vola     Aufschlag&#39;</span><span class="sc">:&gt;22}</span><span class="ss"> | </span><span class="sc">{</span><span class="st">&#39;delta&#39;</span><span class="sc">:&gt;7}</span><span class="ss">&quot;</span>)</span>
-<span id="cb165-62"><a href="#cb165-62" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;-&quot;</span> <span class="op">*</span> <span class="dv">92</span>)</span>
-<span id="cb165-63"><a href="#cb165-63" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb165-64"><a href="#cb165-64" aria-hidden="true" tabindex="-1"></a>    <span class="cf">for</span> T <span class="kw">in</span> [<span class="dv">60</span>, <span class="dv">120</span>, <span class="dv">252</span>, <span class="dv">504</span>, <span class="dv">1260</span>]:</span>
-<span id="cb165-65"><a href="#cb165-65" aria-hidden="true" tabindex="-1"></a>        vola_stichprobe, vola_lw, deltas <span class="op">=</span> [], [], []</span>
-<span id="cb165-66"><a href="#cb165-66" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb165-67"><a href="#cb165-67" aria-hidden="true" tabindex="-1"></a>        <span class="cf">for</span> _ <span class="kw">in</span> <span class="bu">range</span>(WIEDERHOLUNGEN):</span>
-<span id="cb165-68"><a href="#cb165-68" aria-hidden="true" tabindex="-1"></a>            <span class="co"># Daten aus der WAHREN Verteilung ziehen (taeglich)</span></span>
-<span id="cb165-69"><a href="#cb165-69" aria-hidden="true" tabindex="-1"></a>            daten <span class="op">=</span> rng.multivariate_normal(np.zeros(N), sigma_wahr <span class="op">/</span> <span class="dv">252</span>, size<span class="op">=</span>T)</span>
-<span id="cb165-70"><a href="#cb165-70" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb165-71"><a href="#cb165-71" aria-hidden="true" tabindex="-1"></a>            <span class="co"># (a) Stichproben-Kovarianz</span></span>
-<span id="cb165-72"><a href="#cb165-72" aria-hidden="true" tabindex="-1"></a>            s_stich <span class="op">=</span> np.cov(daten, rowvar<span class="op">=</span><span class="va">False</span>, ddof<span class="op">=</span><span class="dv">1</span>) <span class="op">*</span> <span class="dv">252</span></span>
-<span id="cb165-73"><a href="#cb165-73" aria-hidden="true" tabindex="-1"></a>            w_stich <span class="op">=</span> minimum_varianz_gewichte(s_stich)</span>
-<span id="cb165-74"><a href="#cb165-74" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb165-75"><a href="#cb165-75" aria-hidden="true" tabindex="-1"></a>            <span class="co"># (b) Ledoit-Wolf-Shrinkage</span></span>
-<span id="cb165-76"><a href="#cb165-76" aria-hidden="true" tabindex="-1"></a>            lw <span class="op">=</span> LedoitWolf().fit(daten)</span>
-<span id="cb165-77"><a href="#cb165-77" aria-hidden="true" tabindex="-1"></a>            s_lw <span class="op">=</span> lw.covariance_ <span class="op">*</span> <span class="dv">252</span></span>
-<span id="cb165-78"><a href="#cb165-78" aria-hidden="true" tabindex="-1"></a>            w_lw <span class="op">=</span> minimum_varianz_gewichte(s_lw)</span>
-<span id="cb165-79"><a href="#cb165-79" aria-hidden="true" tabindex="-1"></a>            deltas.append(lw.shrinkage_)</span>
-<span id="cb165-80"><a href="#cb165-80" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb165-81"><a href="#cb165-81" aria-hidden="true" tabindex="-1"></a>            <span class="co"># Bewertung IMMER mit der wahren Kovarianz - das ist der Punkt</span></span>
-<span id="cb165-82"><a href="#cb165-82" aria-hidden="true" tabindex="-1"></a>            vola_stichprobe.append(portfoliovolatilitaet(w_stich, sigma_wahr))</span>
-<span id="cb165-83"><a href="#cb165-83" aria-hidden="true" tabindex="-1"></a>            vola_lw.append(portfoliovolatilitaet(w_lw, sigma_wahr))</span>
-<span id="cb165-84"><a href="#cb165-84" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb165-85"><a href="#cb165-85" aria-hidden="true" tabindex="-1"></a>        m_stich, m_lw <span class="op">=</span> np.mean(vola_stichprobe), np.mean(vola_lw)</span>
-<span id="cb165-86"><a href="#cb165-86" aria-hidden="true" tabindex="-1"></a>        <span class="bu">print</span>(<span class="ss">f&quot;</span><span class="sc">{</span>T<span class="sc">:&gt;9}</span><span class="ss"> | </span><span class="sc">{</span>T<span class="op">/</span>N<span class="sc">:&gt;5.1f}</span><span class="ss"> | </span><span class="sc">{</span>m_stich<span class="op">*</span><span class="dv">100</span><span class="sc">:&gt;8.2f}</span><span class="ss"> % &quot;</span></span>
-<span id="cb165-87"><a href="#cb165-87" aria-hidden="true" tabindex="-1"></a>              <span class="ss">f&quot;</span><span class="sc">{</span>(m_stich<span class="op">/</span>vola_ideal<span class="op">-</span><span class="dv">1</span>)<span class="op">*</span><span class="dv">100</span><span class="sc">:&gt;+9.1f}</span><span class="ss"> % | &quot;</span></span>
-<span id="cb165-88"><a href="#cb165-88" aria-hidden="true" tabindex="-1"></a>              <span class="ss">f&quot;</span><span class="sc">{</span>m_lw<span class="op">*</span><span class="dv">100</span><span class="sc">:&gt;8.2f}</span><span class="ss"> % </span><span class="sc">{</span>(m_lw<span class="op">/</span>vola_ideal<span class="op">-</span><span class="dv">1</span>)<span class="op">*</span><span class="dv">100</span><span class="sc">:&gt;+9.1f}</span><span class="ss"> % | &quot;</span></span>
-<span id="cb165-89"><a href="#cb165-89" aria-hidden="true" tabindex="-1"></a>              <span class="ss">f&quot;</span><span class="sc">{</span>np<span class="sc">.</span>mean(deltas)<span class="sc">:&gt;7.3f}</span><span class="ss">&quot;</span>)</span>
-<span id="cb165-90"><a href="#cb165-90" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb165-91"><a href="#cb165-91" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;-&quot;</span> <span class="op">*</span> <span class="dv">92</span>)</span>
-<span id="cb165-92"><a href="#cb165-92" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;&#39;Aufschlag&#39; = wie viel mehr Risiko das Portfolio in der WAHREN Welt traegt,&quot;</span>)</span>
-<span id="cb165-93"><a href="#cb165-93" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;verglichen mit dem Portfolio bei perfektem Wissen.&quot;</span>)</span>
-<span id="cb165-94"><a href="#cb165-94" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;Lesart: Je kleiner T/N, desto teurer das Schaetzrauschen - und desto mehr&quot;</span>)</span>
-<span id="cb165-95"><a href="#cb165-95" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;schrumpft Ledoit-Wolf (delta steigt).&quot;</span>)</span>
-<span id="cb165-96"><a href="#cb165-96" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;=&quot;</span> <span class="op">*</span> <span class="dv">92</span>)</span></code></pre></div>
+<div class="sourceCode" id="cb167"><pre class="sourceCode python"><code class="sourceCode python"><span id="cb167-1"><a href="#cb167-1" aria-hidden="true" tabindex="-1"></a><span class="co">#!/usr/bin/env python3</span></span>
+<span id="cb167-2"><a href="#cb167-2" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb167-3"><a href="#cb167-3" aria-hidden="true" tabindex="-1"></a><span class="co"># Schaetzrauschen_Demo.py</span></span>
+<span id="cb167-4"><a href="#cb167-4" aria-hidden="true" tabindex="-1"></a><span class="co">&quot;&quot;&quot;</span></span>
+<span id="cb167-5"><a href="#cb167-5" aria-hidden="true" tabindex="-1"></a><span class="co">Kapitel Finanzdaten: Der Error-Maximizer-Effekt im Experiment.</span></span>
+<span id="cb167-6"><a href="#cb167-6" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb167-7"><a href="#cb167-7" aria-hidden="true" tabindex="-1"></a><span class="co">Aufbau: Wir KENNEN die wahre Kovarianzmatrix, weil wir die Daten selbst</span></span>
+<span id="cb167-8"><a href="#cb167-8" aria-hidden="true" tabindex="-1"></a><span class="co">erzeugen. Dann schaetzen wir sie aus endlich vielen Beobachtungen und</span></span>
+<span id="cb167-9"><a href="#cb167-9" aria-hidden="true" tabindex="-1"></a><span class="co">vergleichen, wie gut das daraus optimierte Portfolio in der WAHREN Welt</span></span>
+<span id="cb167-10"><a href="#cb167-10" aria-hidden="true" tabindex="-1"></a><span class="co">abschneidet - mit und ohne Shrinkage.</span></span>
+<span id="cb167-11"><a href="#cb167-11" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb167-12"><a href="#cb167-12" aria-hidden="true" tabindex="-1"></a><span class="co">Das ist der einzige saubere Weg, Schaetzfehler zu messen: Man braucht eine</span></span>
+<span id="cb167-13"><a href="#cb167-13" aria-hidden="true" tabindex="-1"></a><span class="co">Wahrheit zum Vergleich, und die gibt es nur in der Simulation.</span></span>
+<span id="cb167-14"><a href="#cb167-14" aria-hidden="true" tabindex="-1"></a><span class="co">&quot;&quot;&quot;</span></span>
+<span id="cb167-15"><a href="#cb167-15" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb167-16"><a href="#cb167-16" aria-hidden="true" tabindex="-1"></a><span class="im">import</span> numpy <span class="im">as</span> np</span>
+<span id="cb167-17"><a href="#cb167-17" aria-hidden="true" tabindex="-1"></a><span class="im">from</span> sklearn.covariance <span class="im">import</span> LedoitWolf</span>
+<span id="cb167-18"><a href="#cb167-18" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb167-19"><a href="#cb167-19" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb167-20"><a href="#cb167-20" aria-hidden="true" tabindex="-1"></a><span class="kw">def</span> erzeuge_wahre_kovarianz(n, rng):</span>
+<span id="cb167-21"><a href="#cb167-21" aria-hidden="true" tabindex="-1"></a>    <span class="co">&quot;&quot;&quot;Ein-Faktor-Modell: gemeinsamer Marktfaktor plus titelspezifisches Rauschen.&quot;&quot;&quot;</span></span>
+<span id="cb167-22"><a href="#cb167-22" aria-hidden="true" tabindex="-1"></a>    beta <span class="op">=</span> rng.uniform(<span class="fl">0.6</span>, <span class="fl">1.4</span>, size<span class="op">=</span>n)             <span class="co"># Marktsensitivitaeten</span></span>
+<span id="cb167-23"><a href="#cb167-23" aria-hidden="true" tabindex="-1"></a>    var_markt <span class="op">=</span> <span class="fl">0.04</span>                                  <span class="co"># Marktvarianz p.a.</span></span>
+<span id="cb167-24"><a href="#cb167-24" aria-hidden="true" tabindex="-1"></a>    var_spezifisch <span class="op">=</span> rng.uniform(<span class="fl">0.01</span>, <span class="fl">0.09</span>, size<span class="op">=</span>n)  <span class="co"># idiosynkratische Varianz</span></span>
+<span id="cb167-25"><a href="#cb167-25" aria-hidden="true" tabindex="-1"></a>    <span class="cf">return</span> np.outer(beta, beta) <span class="op">*</span> var_markt <span class="op">+</span> np.diag(var_spezifisch)</span>
+<span id="cb167-26"><a href="#cb167-26" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb167-27"><a href="#cb167-27" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb167-28"><a href="#cb167-28" aria-hidden="true" tabindex="-1"></a><span class="kw">def</span> minimum_varianz_gewichte(sigma):</span>
+<span id="cb167-29"><a href="#cb167-29" aria-hidden="true" tabindex="-1"></a>    <span class="co">&quot;&quot;&quot;Analytische GMV-Loesung: w = Sigma^-1 1 / (1&#39; Sigma^-1 1). Ohne Restriktionen.&quot;&quot;&quot;</span></span>
+<span id="cb167-30"><a href="#cb167-30" aria-hidden="true" tabindex="-1"></a>    eins <span class="op">=</span> np.ones(<span class="bu">len</span>(sigma))</span>
+<span id="cb167-31"><a href="#cb167-31" aria-hidden="true" tabindex="-1"></a>    <span class="cf">try</span>:</span>
+<span id="cb167-32"><a href="#cb167-32" aria-hidden="true" tabindex="-1"></a>        loesung <span class="op">=</span> np.linalg.solve(sigma, eins)</span>
+<span id="cb167-33"><a href="#cb167-33" aria-hidden="true" tabindex="-1"></a>    <span class="cf">except</span> np.linalg.LinAlgError:</span>
+<span id="cb167-34"><a href="#cb167-34" aria-hidden="true" tabindex="-1"></a>        loesung <span class="op">=</span> np.linalg.pinv(sigma) <span class="op">@</span> eins        <span class="co"># falls singulaer</span></span>
+<span id="cb167-35"><a href="#cb167-35" aria-hidden="true" tabindex="-1"></a>    <span class="cf">return</span> loesung <span class="op">/</span> loesung.<span class="bu">sum</span>()</span>
+<span id="cb167-36"><a href="#cb167-36" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb167-37"><a href="#cb167-37" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb167-38"><a href="#cb167-38" aria-hidden="true" tabindex="-1"></a><span class="kw">def</span> portfoliovolatilitaet(w, sigma):</span>
+<span id="cb167-39"><a href="#cb167-39" aria-hidden="true" tabindex="-1"></a>    <span class="cf">return</span> <span class="bu">float</span>(np.sqrt(w <span class="op">@</span> sigma <span class="op">@</span> w))</span>
+<span id="cb167-40"><a href="#cb167-40" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb167-41"><a href="#cb167-41" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb167-42"><a href="#cb167-42" aria-hidden="true" tabindex="-1"></a><span class="cf">if</span> <span class="va">__name__</span> <span class="op">==</span> <span class="st">&quot;__main__&quot;</span>:</span>
+<span id="cb167-43"><a href="#cb167-43" aria-hidden="true" tabindex="-1"></a>    rng <span class="op">=</span> np.random.default_rng(<span class="dv">2026</span>)</span>
+<span id="cb167-44"><a href="#cb167-44" aria-hidden="true" tabindex="-1"></a>    N <span class="op">=</span> <span class="dv">40</span>                                            <span class="co"># Anzahl Titel</span></span>
+<span id="cb167-45"><a href="#cb167-45" aria-hidden="true" tabindex="-1"></a>    WIEDERHOLUNGEN <span class="op">=</span> <span class="dv">200</span></span>
+<span id="cb167-46"><a href="#cb167-46" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb167-47"><a href="#cb167-47" aria-hidden="true" tabindex="-1"></a>    sigma_wahr <span class="op">=</span> erzeuge_wahre_kovarianz(N, rng)</span>
+<span id="cb167-48"><a href="#cb167-48" aria-hidden="true" tabindex="-1"></a>    w_ideal <span class="op">=</span> minimum_varianz_gewichte(sigma_wahr)</span>
+<span id="cb167-49"><a href="#cb167-49" aria-hidden="true" tabindex="-1"></a>    vola_ideal <span class="op">=</span> portfoliovolatilitaet(w_ideal, sigma_wahr)</span>
+<span id="cb167-50"><a href="#cb167-50" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb167-51"><a href="#cb167-51" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;=&quot;</span> <span class="op">*</span> <span class="dv">92</span>)</span>
+<span id="cb167-52"><a href="#cb167-52" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;  ERROR-MAXIMIZER: WIE TEUER IST SCHAETZRAUSCHEN?&quot;</span>)</span>
+<span id="cb167-53"><a href="#cb167-53" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;=&quot;</span> <span class="op">*</span> <span class="dv">92</span>)</span>
+<span id="cb167-54"><a href="#cb167-54" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;Aufbau: </span><span class="sc">{</span>N<span class="sc">}</span><span class="ss"> Titel, wahre Kovarianz bekannt (Ein-Faktor-Modell).&quot;</span>)</span>
+<span id="cb167-55"><a href="#cb167-55" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;Bestmoegliche Volatilitaet bei perfektem Wissen: &quot;</span></span>
+<span id="cb167-56"><a href="#cb167-56" aria-hidden="true" tabindex="-1"></a>          <span class="ss">f&quot;</span><span class="sc">{</span>vola_ideal<span class="op">*</span><span class="dv">100</span><span class="sc">:.2f}</span><span class="ss"> % p.a.</span><span class="ch">\n</span><span class="ss">&quot;</span>)</span>
+<span id="cb167-57"><a href="#cb167-57" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb167-58"><a href="#cb167-58" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;</span><span class="sc">{</span><span class="st">&#39;T (Tage)&#39;</span><span class="sc">:&gt;9}</span><span class="ss"> | </span><span class="sc">{</span><span class="st">&#39;T/N&#39;</span><span class="sc">:&gt;5}</span><span class="ss"> | </span><span class="sc">{</span><span class="st">&#39;Stichprobe&#39;</span><span class="sc">:&gt;22}</span><span class="ss"> | </span><span class="sc">{</span><span class="st">&#39;Ledoit-Wolf&#39;</span><span class="sc">:&gt;22}</span><span class="ss"> | &quot;</span></span>
+<span id="cb167-59"><a href="#cb167-59" aria-hidden="true" tabindex="-1"></a>          <span class="ss">f&quot;</span><span class="sc">{</span><span class="st">&#39;Shrink&#39;</span><span class="sc">:&gt;7}</span><span class="ss">&quot;</span>)</span>
+<span id="cb167-60"><a href="#cb167-60" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;</span><span class="sc">{</span><span class="st">&#39;&#39;</span><span class="sc">:&gt;9}</span><span class="ss"> | </span><span class="sc">{</span><span class="st">&#39;&#39;</span><span class="sc">:&gt;5}</span><span class="ss"> | </span><span class="sc">{</span><span class="st">&#39;Vola     Aufschlag&#39;</span><span class="sc">:&gt;22}</span><span class="ss"> | &quot;</span></span>
+<span id="cb167-61"><a href="#cb167-61" aria-hidden="true" tabindex="-1"></a>          <span class="ss">f&quot;</span><span class="sc">{</span><span class="st">&#39;Vola     Aufschlag&#39;</span><span class="sc">:&gt;22}</span><span class="ss"> | </span><span class="sc">{</span><span class="st">&#39;delta&#39;</span><span class="sc">:&gt;7}</span><span class="ss">&quot;</span>)</span>
+<span id="cb167-62"><a href="#cb167-62" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;-&quot;</span> <span class="op">*</span> <span class="dv">92</span>)</span>
+<span id="cb167-63"><a href="#cb167-63" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb167-64"><a href="#cb167-64" aria-hidden="true" tabindex="-1"></a>    <span class="cf">for</span> T <span class="kw">in</span> [<span class="dv">60</span>, <span class="dv">120</span>, <span class="dv">252</span>, <span class="dv">504</span>, <span class="dv">1260</span>]:</span>
+<span id="cb167-65"><a href="#cb167-65" aria-hidden="true" tabindex="-1"></a>        vola_stichprobe, vola_lw, deltas <span class="op">=</span> [], [], []</span>
+<span id="cb167-66"><a href="#cb167-66" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb167-67"><a href="#cb167-67" aria-hidden="true" tabindex="-1"></a>        <span class="cf">for</span> _ <span class="kw">in</span> <span class="bu">range</span>(WIEDERHOLUNGEN):</span>
+<span id="cb167-68"><a href="#cb167-68" aria-hidden="true" tabindex="-1"></a>            <span class="co"># Daten aus der WAHREN Verteilung ziehen (taeglich)</span></span>
+<span id="cb167-69"><a href="#cb167-69" aria-hidden="true" tabindex="-1"></a>            daten <span class="op">=</span> rng.multivariate_normal(np.zeros(N), sigma_wahr <span class="op">/</span> <span class="dv">252</span>, size<span class="op">=</span>T)</span>
+<span id="cb167-70"><a href="#cb167-70" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb167-71"><a href="#cb167-71" aria-hidden="true" tabindex="-1"></a>            <span class="co"># (a) Stichproben-Kovarianz</span></span>
+<span id="cb167-72"><a href="#cb167-72" aria-hidden="true" tabindex="-1"></a>            s_stich <span class="op">=</span> np.cov(daten, rowvar<span class="op">=</span><span class="va">False</span>, ddof<span class="op">=</span><span class="dv">1</span>) <span class="op">*</span> <span class="dv">252</span></span>
+<span id="cb167-73"><a href="#cb167-73" aria-hidden="true" tabindex="-1"></a>            w_stich <span class="op">=</span> minimum_varianz_gewichte(s_stich)</span>
+<span id="cb167-74"><a href="#cb167-74" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb167-75"><a href="#cb167-75" aria-hidden="true" tabindex="-1"></a>            <span class="co"># (b) Ledoit-Wolf-Shrinkage</span></span>
+<span id="cb167-76"><a href="#cb167-76" aria-hidden="true" tabindex="-1"></a>            lw <span class="op">=</span> LedoitWolf().fit(daten)</span>
+<span id="cb167-77"><a href="#cb167-77" aria-hidden="true" tabindex="-1"></a>            s_lw <span class="op">=</span> lw.covariance_ <span class="op">*</span> <span class="dv">252</span></span>
+<span id="cb167-78"><a href="#cb167-78" aria-hidden="true" tabindex="-1"></a>            w_lw <span class="op">=</span> minimum_varianz_gewichte(s_lw)</span>
+<span id="cb167-79"><a href="#cb167-79" aria-hidden="true" tabindex="-1"></a>            deltas.append(lw.shrinkage_)</span>
+<span id="cb167-80"><a href="#cb167-80" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb167-81"><a href="#cb167-81" aria-hidden="true" tabindex="-1"></a>            <span class="co"># Bewertung IMMER mit der wahren Kovarianz - das ist der Punkt</span></span>
+<span id="cb167-82"><a href="#cb167-82" aria-hidden="true" tabindex="-1"></a>            vola_stichprobe.append(portfoliovolatilitaet(w_stich, sigma_wahr))</span>
+<span id="cb167-83"><a href="#cb167-83" aria-hidden="true" tabindex="-1"></a>            vola_lw.append(portfoliovolatilitaet(w_lw, sigma_wahr))</span>
+<span id="cb167-84"><a href="#cb167-84" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb167-85"><a href="#cb167-85" aria-hidden="true" tabindex="-1"></a>        m_stich, m_lw <span class="op">=</span> np.mean(vola_stichprobe), np.mean(vola_lw)</span>
+<span id="cb167-86"><a href="#cb167-86" aria-hidden="true" tabindex="-1"></a>        <span class="bu">print</span>(<span class="ss">f&quot;</span><span class="sc">{</span>T<span class="sc">:&gt;9}</span><span class="ss"> | </span><span class="sc">{</span>T<span class="op">/</span>N<span class="sc">:&gt;5.1f}</span><span class="ss"> | </span><span class="sc">{</span>m_stich<span class="op">*</span><span class="dv">100</span><span class="sc">:&gt;8.2f}</span><span class="ss"> % &quot;</span></span>
+<span id="cb167-87"><a href="#cb167-87" aria-hidden="true" tabindex="-1"></a>              <span class="ss">f&quot;</span><span class="sc">{</span>(m_stich<span class="op">/</span>vola_ideal<span class="op">-</span><span class="dv">1</span>)<span class="op">*</span><span class="dv">100</span><span class="sc">:&gt;+9.1f}</span><span class="ss"> % | &quot;</span></span>
+<span id="cb167-88"><a href="#cb167-88" aria-hidden="true" tabindex="-1"></a>              <span class="ss">f&quot;</span><span class="sc">{</span>m_lw<span class="op">*</span><span class="dv">100</span><span class="sc">:&gt;8.2f}</span><span class="ss"> % </span><span class="sc">{</span>(m_lw<span class="op">/</span>vola_ideal<span class="op">-</span><span class="dv">1</span>)<span class="op">*</span><span class="dv">100</span><span class="sc">:&gt;+9.1f}</span><span class="ss"> % | &quot;</span></span>
+<span id="cb167-89"><a href="#cb167-89" aria-hidden="true" tabindex="-1"></a>              <span class="ss">f&quot;</span><span class="sc">{</span>np<span class="sc">.</span>mean(deltas)<span class="sc">:&gt;7.3f}</span><span class="ss">&quot;</span>)</span>
+<span id="cb167-90"><a href="#cb167-90" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb167-91"><a href="#cb167-91" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;-&quot;</span> <span class="op">*</span> <span class="dv">92</span>)</span>
+<span id="cb167-92"><a href="#cb167-92" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;&#39;Aufschlag&#39; = wie viel mehr Risiko das Portfolio in der WAHREN Welt traegt,&quot;</span>)</span>
+<span id="cb167-93"><a href="#cb167-93" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;verglichen mit dem Portfolio bei perfektem Wissen.&quot;</span>)</span>
+<span id="cb167-94"><a href="#cb167-94" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;Lesart: Je kleiner T/N, desto teurer das Schaetzrauschen - und desto mehr&quot;</span>)</span>
+<span id="cb167-95"><a href="#cb167-95" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;schrumpft Ledoit-Wolf (delta steigt).&quot;</span>)</span>
+<span id="cb167-96"><a href="#cb167-96" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;=&quot;</span> <span class="op">*</span> <span class="dv">92</span>)</span></code></pre></div>
 <hr />
 <p><strong>Erwartete Ausgabe:</strong></p>
 <pre><code>============================================================================================
@@ -21624,7 +22599,7 @@ Bestmoegliche Volatilitaet bei perfektem Wissen: 11.84 % p.a.
 </table>
 <p><strong>Wichtig ist, Text und Code konsistent auf dieselbe Variante zu beziehen</strong> — zum Beispiel <code>sklearn.covariance.LedoitWolf</code>, das die skalierte Einheitsmatrix verwendet, versus eine manuelle Implementierung des Konstant-Korrelations-Ziels. Dieses Buch nennt beide und macht transparent, welches wo zum Einsatz kommt.</p>
 <blockquote>
-<p><strong>💡 Welches Ziel ist besser?</strong> Es kommt darauf an. Die <strong>Einheitsmatrix</strong> unterstellt, dass alle Titel gleich riskant und unkorreliert sind — eine starke, aber sehr stabile Annahme. Das <strong>Konstant-Korrelations-Ziel</strong> behält die geschätzten Einzelvarianzen und glättet nur die Korrelationen; das ist bei Aktien meist realistischer, weil Titel tatsächlich sehr unterschiedliche Volatilitäten haben. In Übung 11.5 implementieren Sie es selbst und vergleichen.</p>
+<p><strong>💡 Welches Ziel ist besser?</strong> Es kommt darauf an. Die <strong>Einheitsmatrix</strong> unterstellt, dass alle Titel gleich riskant und unkorreliert sind — eine starke, aber sehr stabile Annahme. Das <strong>Konstant-Korrelations-Ziel</strong> behält die geschätzten Einzelvarianzen und glättet nur die Korrelationen; das ist bei Aktien meist realistischer, weil Titel tatsächlich sehr unterschiedliche Volatilitäten haben. In der Aufgabe <em>Beide Shrinkage-Ziele vergleichen</em> (<a href="#sec:finanzdaten-uebungsaufgaben">Abschnitt 18.7</a>) implementieren Sie es selbst und vergleichen.</p>
 </blockquote>
 <p>Das Ergebnis ist in jedem Fall garantiert <strong>positiv definit</strong>, wohlkonditioniert und stabil invertierbar.</p>
 <hr />
@@ -21635,156 +22610,156 @@ Bestmoegliche Volatilitaet bei perfektem Wissen: 11.84 % p.a.
 <pre><code>Ihre Liste:      [&#39;AAPL&#39;, &#39;MSFT&#39;, &#39;NVDA&#39;, &#39;AMZN&#39;, &#39;JNJ&#39;, &#39;PFE&#39;, &#39;JPM&#39;, &#39;GS&#39;, &#39;XOM&#39;, &#39;CVX&#39;]
 prices.columns:  [&#39;AAPL&#39;, &#39;AMZN&#39;, &#39;CVX&#39;, &#39;GS&#39;, &#39;JNJ&#39;, &#39;JPM&#39;, &#39;MSFT&#39;, &#39;NVDA&#39;, &#39;PFE&#39;, &#39;XOM&#39;]</code></pre>
 <p>Wer danach mit Positionsindizes arbeitet, beschriftet Ergebnisse falsch und beschränkt falsche Sektoren. <strong>Die Abhilfe ist eine Zeile:</strong></p>
-<div class="sourceCode" id="cb168"><pre class="sourceCode python"><code class="sourceCode python"><span id="cb168-1"><a href="#cb168-1" aria-hidden="true" tabindex="-1"></a>prices <span class="op">=</span> raw[<span class="st">&quot;Close&quot;</span>][tickers].dropna()      <span class="co"># erzwingt die eigene Reihenfolge</span></span>
-<span id="cb168-2"><a href="#cb168-2" aria-hidden="true" tabindex="-1"></a><span class="cf">assert</span> <span class="bu">list</span>(prices.columns) <span class="op">==</span> tickers</span></code></pre></div>
+<div class="sourceCode" id="cb170"><pre class="sourceCode python"><code class="sourceCode python"><span id="cb170-1"><a href="#cb170-1" aria-hidden="true" tabindex="-1"></a>prices <span class="op">=</span> raw[<span class="st">&quot;Close&quot;</span>][tickers].dropna()      <span class="co"># erzwingt die eigene Reihenfolge</span></span>
+<span id="cb170-2"><a href="#cb170-2" aria-hidden="true" tabindex="-1"></a><span class="cf">assert</span> <span class="bu">list</span>(prices.columns) <span class="op">==</span> tickers</span></code></pre></div>
 </blockquote>
-<div class="sourceCode" id="cb169"><pre class="sourceCode python"><code class="sourceCode python"><span id="cb169-1"><a href="#cb169-1" aria-hidden="true" tabindex="-1"></a><span class="co">#!/usr/bin/env python3</span></span>
-<span id="cb169-2"><a href="#cb169-2" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb169-3"><a href="#cb169-3" aria-hidden="true" tabindex="-1"></a><span class="co"># Finanzdaten_Ledoit_Wolf.py</span></span>
-<span id="cb169-4"><a href="#cb169-4" aria-hidden="true" tabindex="-1"></a><span class="co">&quot;&quot;&quot;</span></span>
-<span id="cb169-5"><a href="#cb169-5" aria-hidden="true" tabindex="-1"></a><span class="co">Kapitel Finanzdaten: Automatisierte Finanzdaten-Pipeline und Kovarianz-Shrinkage.</span></span>
-<span id="cb169-6"><a href="#cb169-6" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb169-7"><a href="#cb169-7" aria-hidden="true" tabindex="-1"></a><span class="co">Eigenschaften:</span></span>
-<span id="cb169-8"><a href="#cb169-8" aria-hidden="true" tabindex="-1"></a><span class="co">  * Spaltenreihenfolge wird erzwungen und per assert geprueft</span></span>
-<span id="cb169-9"><a href="#cb169-9" aria-hidden="true" tabindex="-1"></a><span class="co">  * beide Shrinkage-Ziele werden berechnet und verglichen</span></span>
-<span id="cb169-10"><a href="#cb169-10" aria-hidden="true" tabindex="-1"></a><span class="co">  * Datenqualitaetspruefungen (Luecken, Ausreisser, Mindestlaenge)</span></span>
-<span id="cb169-11"><a href="#cb169-11" aria-hidden="true" tabindex="-1"></a><span class="co">  * Eigenwertspektrum wird ausgewiesen, nicht nur die Konditionszahl</span></span>
-<span id="cb169-12"><a href="#cb169-12" aria-hidden="true" tabindex="-1"></a><span class="co">&quot;&quot;&quot;</span></span>
-<span id="cb169-13"><a href="#cb169-13" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb169-14"><a href="#cb169-14" aria-hidden="true" tabindex="-1"></a><span class="im">import</span> numpy <span class="im">as</span> np</span>
-<span id="cb169-15"><a href="#cb169-15" aria-hidden="true" tabindex="-1"></a><span class="im">import</span> pandas <span class="im">as</span> pd</span>
-<span id="cb169-16"><a href="#cb169-16" aria-hidden="true" tabindex="-1"></a><span class="im">import</span> yfinance <span class="im">as</span> yf</span>
-<span id="cb169-17"><a href="#cb169-17" aria-hidden="true" tabindex="-1"></a><span class="im">from</span> sklearn.covariance <span class="im">import</span> LedoitWolf</span>
-<span id="cb169-18"><a href="#cb169-18" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb169-19"><a href="#cb169-19" aria-hidden="true" tabindex="-1"></a>HANDELSTAGE <span class="op">=</span> <span class="dv">252</span></span>
-<span id="cb169-20"><a href="#cb169-20" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb169-21"><a href="#cb169-21" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb169-22"><a href="#cb169-22" aria-hidden="true" tabindex="-1"></a><span class="kw">def</span> lade_kurse(tickers: <span class="bu">list</span>[<span class="bu">str</span>], start, ende) <span class="op">-&gt;</span> pd.DataFrame:</span>
-<span id="cb169-23"><a href="#cb169-23" aria-hidden="true" tabindex="-1"></a>    <span class="co">&quot;&quot;&quot;Laedt bereinigte Schlusskurse und garantiert die Spaltenreihenfolge.&quot;&quot;&quot;</span></span>
-<span id="cb169-24"><a href="#cb169-24" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;Lade </span><span class="sc">{</span><span class="bu">len</span>(tickers)<span class="sc">}</span><span class="ss"> Ticker von </span><span class="sc">{</span>start<span class="sc">}</span><span class="ss"> bis </span><span class="sc">{</span>ende<span class="sc">}</span><span class="ss"> ...&quot;</span>)</span>
-<span id="cb169-25"><a href="#cb169-25" aria-hidden="true" tabindex="-1"></a>    roh <span class="op">=</span> yf.download(tickers, start<span class="op">=</span>start, end<span class="op">=</span>ende, auto_adjust<span class="op">=</span><span class="va">True</span>, progress<span class="op">=</span><span class="va">False</span>)</span>
-<span id="cb169-26"><a href="#cb169-26" aria-hidden="true" tabindex="-1"></a>    <span class="cf">if</span> roh.empty:</span>
-<span id="cb169-27"><a href="#cb169-27" aria-hidden="true" tabindex="-1"></a>        <span class="cf">raise</span> <span class="pp">SystemExit</span>(<span class="st">&quot;Download fehlgeschlagen (Netz, Ticker oder Rate-Limit pruefen).&quot;</span>)</span>
-<span id="cb169-28"><a href="#cb169-28" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb169-29"><a href="#cb169-29" aria-hidden="true" tabindex="-1"></a>    <span class="cf">if</span> <span class="bu">isinstance</span>(roh.columns, pd.MultiIndex):</span>
-<span id="cb169-30"><a href="#cb169-30" aria-hidden="true" tabindex="-1"></a>        <span class="co"># [tickers] erzwingt die gewuenschte Spaltenreihenfolge</span></span>
-<span id="cb169-31"><a href="#cb169-31" aria-hidden="true" tabindex="-1"></a>        kurse <span class="op">=</span> roh[<span class="st">&quot;Close&quot;</span>][tickers].dropna()</span>
-<span id="cb169-32"><a href="#cb169-32" aria-hidden="true" tabindex="-1"></a>    <span class="cf">else</span>:</span>
-<span id="cb169-33"><a href="#cb169-33" aria-hidden="true" tabindex="-1"></a>        kurse <span class="op">=</span> roh[[<span class="st">&quot;Close&quot;</span>]].dropna()</span>
-<span id="cb169-34"><a href="#cb169-34" aria-hidden="true" tabindex="-1"></a>        kurse.columns <span class="op">=</span> tickers</span>
-<span id="cb169-35"><a href="#cb169-35" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb169-36"><a href="#cb169-36" aria-hidden="true" tabindex="-1"></a>    <span class="cf">assert</span> <span class="bu">list</span>(kurse.columns) <span class="op">==</span> tickers, (</span>
-<span id="cb169-37"><a href="#cb169-37" aria-hidden="true" tabindex="-1"></a>        <span class="ss">f&quot;Spaltenreihenfolge weicht ab!</span><span class="ch">\n</span><span class="ss">  erwartet: </span><span class="sc">{</span>tickers<span class="sc">}</span><span class="ch">\n</span><span class="ss">&quot;</span></span>
-<span id="cb169-38"><a href="#cb169-38" aria-hidden="true" tabindex="-1"></a>        <span class="ss">f&quot;  erhalten: </span><span class="sc">{</span><span class="bu">list</span>(kurse.columns)<span class="sc">}</span><span class="ss">&quot;</span>)</span>
-<span id="cb169-39"><a href="#cb169-39" aria-hidden="true" tabindex="-1"></a>    <span class="cf">return</span> kurse</span>
-<span id="cb169-40"><a href="#cb169-40" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb169-41"><a href="#cb169-41" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb169-42"><a href="#cb169-42" aria-hidden="true" tabindex="-1"></a><span class="kw">def</span> pruefe_datenqualitaet(kurse: pd.DataFrame, mindest_tage: <span class="bu">int</span> <span class="op">=</span> <span class="dv">200</span>) <span class="op">-&gt;</span> <span class="va">None</span>:</span>
-<span id="cb169-43"><a href="#cb169-43" aria-hidden="true" tabindex="-1"></a>    <span class="co">&quot;&quot;&quot;Faengt die haeufigsten Datenprobleme ab, bevor sie ins Modell gelangen.&quot;&quot;&quot;</span></span>
-<span id="cb169-44"><a href="#cb169-44" aria-hidden="true" tabindex="-1"></a>    T, N <span class="op">=</span> kurse.shape</span>
-<span id="cb169-45"><a href="#cb169-45" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;</span><span class="ch">\n</span><span class="ss">Datenqualitaet: </span><span class="sc">{</span>T<span class="sc">}</span><span class="ss"> Handelstage, </span><span class="sc">{</span>N<span class="sc">}</span><span class="ss"> Titel (T/N = </span><span class="sc">{</span>T<span class="op">/</span>N<span class="sc">:.1f}</span><span class="ss">)&quot;</span>)</span>
-<span id="cb169-46"><a href="#cb169-46" aria-hidden="true" tabindex="-1"></a>    <span class="cf">if</span> T <span class="op">&lt;</span> mindest_tage:</span>
-<span id="cb169-47"><a href="#cb169-47" aria-hidden="true" tabindex="-1"></a>        <span class="cf">raise</span> <span class="pp">SystemExit</span>(<span class="ss">f&quot;Zu wenige Beobachtungen (</span><span class="sc">{</span>T<span class="sc">}</span><span class="ss"> &lt; </span><span class="sc">{</span>mindest_tage<span class="sc">}</span><span class="ss">).&quot;</span>)</span>
-<span id="cb169-48"><a href="#cb169-48" aria-hidden="true" tabindex="-1"></a>    <span class="cf">if</span> T <span class="op">&lt;</span> N:</span>
-<span id="cb169-49"><a href="#cb169-49" aria-hidden="true" tabindex="-1"></a>        <span class="bu">print</span>(<span class="st">&quot;  WARNUNG: T &lt; N - die Stichprobenkovarianz ist singulaer!&quot;</span>)</span>
-<span id="cb169-50"><a href="#cb169-50" aria-hidden="true" tabindex="-1"></a>    <span class="cf">elif</span> T <span class="op">&lt;</span> <span class="dv">3</span> <span class="op">*</span> N:</span>
-<span id="cb169-51"><a href="#cb169-51" aria-hidden="true" tabindex="-1"></a>        <span class="bu">print</span>(<span class="st">&quot;  WARNUNG: T &lt; 3N - erhebliches Schaetzrauschen zu erwarten.&quot;</span>)</span>
-<span id="cb169-52"><a href="#cb169-52" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb169-53"><a href="#cb169-53" aria-hidden="true" tabindex="-1"></a>    renditen <span class="op">=</span> kurse.pct_change().dropna()</span>
-<span id="cb169-54"><a href="#cb169-54" aria-hidden="true" tabindex="-1"></a>    extreme <span class="op">=</span> (renditen.<span class="bu">abs</span>() <span class="op">&gt;</span> <span class="fl">0.25</span>).<span class="bu">sum</span>().<span class="bu">sum</span>()</span>
-<span id="cb169-55"><a href="#cb169-55" aria-hidden="true" tabindex="-1"></a>    <span class="cf">if</span> extreme:</span>
-<span id="cb169-56"><a href="#cb169-56" aria-hidden="true" tabindex="-1"></a>        <span class="bu">print</span>(<span class="ss">f&quot;  Hinweis: </span><span class="sc">{</span>extreme<span class="sc">}</span><span class="ss"> Tagesrenditen ueber 25 % &quot;</span></span>
-<span id="cb169-57"><a href="#cb169-57" aria-hidden="true" tabindex="-1"></a>              <span class="ss">f&quot;(Splits, Sondersituationen oder Datenfehler pruefen).&quot;</span>)</span>
-<span id="cb169-58"><a href="#cb169-58" aria-hidden="true" tabindex="-1"></a>    luecken <span class="op">=</span> kurse.isna().<span class="bu">sum</span>().<span class="bu">sum</span>()</span>
-<span id="cb169-59"><a href="#cb169-59" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;  Fehlende Werte nach dropna: </span><span class="sc">{</span>luecken<span class="sc">}</span><span class="ss">&quot;</span>)</span>
-<span id="cb169-60"><a href="#cb169-60" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb169-61"><a href="#cb169-61" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb169-62"><a href="#cb169-62" aria-hidden="true" tabindex="-1"></a><span class="kw">def</span> ziel_konstante_korrelation(renditen: np.ndarray) <span class="op">-&gt;</span> np.ndarray:</span>
-<span id="cb169-63"><a href="#cb169-63" aria-hidden="true" tabindex="-1"></a>    <span class="co">&quot;&quot;&quot;</span></span>
-<span id="cb169-64"><a href="#cb169-64" aria-hidden="true" tabindex="-1"></a><span class="co">    Shrinkage-Ziel nach Ledoit/Wolf 2003: Einzelvarianzen behalten,</span></span>
-<span id="cb169-65"><a href="#cb169-65" aria-hidden="true" tabindex="-1"></a><span class="co">    alle Korrelationen durch ihren Mittelwert ersetzen.</span></span>
-<span id="cb169-66"><a href="#cb169-66" aria-hidden="true" tabindex="-1"></a><span class="co">    (sklearn nutzt stattdessen die skalierte Einheitsmatrix - siehe oben.)</span></span>
-<span id="cb169-67"><a href="#cb169-67" aria-hidden="true" tabindex="-1"></a><span class="co">    &quot;&quot;&quot;</span></span>
-<span id="cb169-68"><a href="#cb169-68" aria-hidden="true" tabindex="-1"></a>    S <span class="op">=</span> np.cov(renditen, rowvar<span class="op">=</span><span class="va">False</span>, ddof<span class="op">=</span><span class="dv">1</span>)</span>
-<span id="cb169-69"><a href="#cb169-69" aria-hidden="true" tabindex="-1"></a>    d <span class="op">=</span> np.sqrt(np.diag(S))</span>
-<span id="cb169-70"><a href="#cb169-70" aria-hidden="true" tabindex="-1"></a>    korrelation <span class="op">=</span> S <span class="op">/</span> np.outer(d, d)</span>
-<span id="cb169-71"><a href="#cb169-71" aria-hidden="true" tabindex="-1"></a>    n <span class="op">=</span> <span class="bu">len</span>(S)</span>
-<span id="cb169-72"><a href="#cb169-72" aria-hidden="true" tabindex="-1"></a>    r_quer <span class="op">=</span> (korrelation.<span class="bu">sum</span>() <span class="op">-</span> n) <span class="op">/</span> (n <span class="op">*</span> (n <span class="op">-</span> <span class="dv">1</span>))       <span class="co"># Mittel ohne Diagonale</span></span>
-<span id="cb169-73"><a href="#cb169-73" aria-hidden="true" tabindex="-1"></a>    F <span class="op">=</span> r_quer <span class="op">*</span> np.outer(d, d)</span>
-<span id="cb169-74"><a href="#cb169-74" aria-hidden="true" tabindex="-1"></a>    np.fill_diagonal(F, np.diag(S))</span>
-<span id="cb169-75"><a href="#cb169-75" aria-hidden="true" tabindex="-1"></a>    <span class="cf">return</span> F</span>
-<span id="cb169-76"><a href="#cb169-76" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb169-77"><a href="#cb169-77" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb169-78"><a href="#cb169-78" aria-hidden="true" tabindex="-1"></a><span class="kw">def</span> analysiere(kurse: pd.DataFrame):</span>
-<span id="cb169-79"><a href="#cb169-79" aria-hidden="true" tabindex="-1"></a>    renditen <span class="op">=</span> kurse.pct_change().dropna()</span>
-<span id="cb169-80"><a href="#cb169-80" aria-hidden="true" tabindex="-1"></a>    T, N <span class="op">=</span> renditen.shape</span>
-<span id="cb169-81"><a href="#cb169-81" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb169-82"><a href="#cb169-82" aria-hidden="true" tabindex="-1"></a>    mu <span class="op">=</span> renditen.mean().values <span class="op">*</span> HANDELSTAGE</span>
-<span id="cb169-83"><a href="#cb169-83" aria-hidden="true" tabindex="-1"></a>    sigma_stichprobe <span class="op">=</span> renditen.cov().values <span class="op">*</span> HANDELSTAGE</span>
-<span id="cb169-84"><a href="#cb169-84" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb169-85"><a href="#cb169-85" aria-hidden="true" tabindex="-1"></a>    lw <span class="op">=</span> LedoitWolf(assume_centered<span class="op">=</span><span class="va">False</span>).fit(renditen.values)</span>
-<span id="cb169-86"><a href="#cb169-86" aria-hidden="true" tabindex="-1"></a>    sigma_lw <span class="op">=</span> lw.covariance_ <span class="op">*</span> HANDELSTAGE</span>
-<span id="cb169-87"><a href="#cb169-87" aria-hidden="true" tabindex="-1"></a>    delta <span class="op">=</span> lw.shrinkage_</span>
-<span id="cb169-88"><a href="#cb169-88" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb169-89"><a href="#cb169-89" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;</span><span class="ch">\n</span><span class="st">&quot;</span> <span class="op">+</span> <span class="st">&quot;=&quot;</span> <span class="op">*</span> <span class="dv">84</span>)</span>
-<span id="cb169-90"><a href="#cb169-90" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;         FINANZDATEN-PIPELINE UND MATRIX-KONDITIONIERUNG&quot;</span>)</span>
-<span id="cb169-91"><a href="#cb169-91" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;=&quot;</span> <span class="op">*</span> <span class="dv">84</span>)</span>
-<span id="cb169-92"><a href="#cb169-92" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;Beobachtungen T:            </span><span class="sc">{</span>T<span class="sc">}</span><span class="ss">&quot;</span>)</span>
-<span id="cb169-93"><a href="#cb169-93" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;Titel N:                    </span><span class="sc">{</span>N<span class="sc">}</span><span class="ss">&quot;</span>)</span>
-<span id="cb169-94"><a href="#cb169-94" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;Optimales Shrinkage delta:  </span><span class="sc">{</span>delta<span class="sc">:.4f}</span><span class="ss"> &quot;</span></span>
-<span id="cb169-95"><a href="#cb169-95" aria-hidden="true" tabindex="-1"></a>          <span class="ss">f&quot;(</span><span class="sc">{</span>delta<span class="op">*</span><span class="dv">100</span><span class="sc">:.1f}</span><span class="ss"> % Gewicht auf dem strukturierten Ziel)&quot;</span>)</span>
-<span id="cb169-96"><a href="#cb169-96" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb169-97"><a href="#cb169-97" aria-hidden="true" tabindex="-1"></a>    eig_stich <span class="op">=</span> np.linalg.eigvalsh(sigma_stichprobe)</span>
-<span id="cb169-98"><a href="#cb169-98" aria-hidden="true" tabindex="-1"></a>    eig_lw <span class="op">=</span> np.linalg.eigvalsh(sigma_lw)</span>
-<span id="cb169-99"><a href="#cb169-99" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb169-100"><a href="#cb169-100" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;</span><span class="ch">\n</span><span class="st">--- Eigenwertspektrum (annualisiert) ---&quot;</span>)</span>
-<span id="cb169-101"><a href="#cb169-101" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;</span><span class="sc">{</span><span class="st">&#39;&#39;</span><span class="sc">:&lt;14}</span><span class="ss"> </span><span class="sc">{</span><span class="st">&#39;kleinster&#39;</span><span class="sc">:&gt;12}</span><span class="ss"> </span><span class="sc">{</span><span class="st">&#39;Median&#39;</span><span class="sc">:&gt;12}</span><span class="ss"> </span><span class="sc">{</span><span class="st">&#39;groesster&#39;</span><span class="sc">:&gt;12}</span><span class="ss"> &quot;</span></span>
-<span id="cb169-102"><a href="#cb169-102" aria-hidden="true" tabindex="-1"></a>          <span class="ss">f&quot;</span><span class="sc">{</span><span class="st">&#39;Kondition&#39;</span><span class="sc">:&gt;12}</span><span class="ss">&quot;</span>)</span>
-<span id="cb169-103"><a href="#cb169-103" aria-hidden="true" tabindex="-1"></a>    <span class="cf">for</span> name, eig <span class="kw">in</span> [(<span class="st">&quot;Stichprobe&quot;</span>, eig_stich), (<span class="st">&quot;Ledoit-Wolf&quot;</span>, eig_lw)]:</span>
-<span id="cb169-104"><a href="#cb169-104" aria-hidden="true" tabindex="-1"></a>        kondition <span class="op">=</span> eig.<span class="bu">max</span>() <span class="op">/</span> <span class="bu">max</span>(eig.<span class="bu">min</span>(), <span class="fl">1e-12</span>)</span>
-<span id="cb169-105"><a href="#cb169-105" aria-hidden="true" tabindex="-1"></a>        <span class="bu">print</span>(<span class="ss">f&quot;</span><span class="sc">{</span>name<span class="sc">:&lt;14}</span><span class="ss"> </span><span class="sc">{</span>eig<span class="sc">.</span><span class="bu">min</span>()<span class="sc">:&gt;12.6f}</span><span class="ss"> </span><span class="sc">{</span>np<span class="sc">.</span>median(eig)<span class="sc">:&gt;12.6f}</span><span class="ss"> &quot;</span></span>
-<span id="cb169-106"><a href="#cb169-106" aria-hidden="true" tabindex="-1"></a>              <span class="ss">f&quot;</span><span class="sc">{</span>eig<span class="sc">.</span><span class="bu">max</span>()<span class="sc">:&gt;12.6f}</span><span class="ss"> </span><span class="sc">{</span>kondition<span class="sc">:&gt;12.1f}</span><span class="ss">&quot;</span>)</span>
-<span id="cb169-107"><a href="#cb169-107" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb169-108"><a href="#cb169-108" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;</span><span class="ch">\n</span><span class="st">Die Konditionszahl misst, wie stark sich kleine Datenaenderungen auf&quot;</span>)</span>
-<span id="cb169-109"><a href="#cb169-109" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;die Inverse auswirken. Je kleiner, desto stabiler die Portfoliogewichte.&quot;</span>)</span>
-<span id="cb169-110"><a href="#cb169-110" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb169-111"><a href="#cb169-111" aria-hidden="true" tabindex="-1"></a>    <span class="co"># --- Vergleich der beiden Shrinkage-Ziele ----------------------------</span></span>
-<span id="cb169-112"><a href="#cb169-112" aria-hidden="true" tabindex="-1"></a>    S_taeglich <span class="op">=</span> np.cov(renditen.values, rowvar<span class="op">=</span><span class="va">False</span>, ddof<span class="op">=</span><span class="dv">1</span>)</span>
-<span id="cb169-113"><a href="#cb169-113" aria-hidden="true" tabindex="-1"></a>    F_identitaet <span class="op">=</span> np.eye(N) <span class="op">*</span> np.trace(S_taeglich) <span class="op">/</span> N</span>
-<span id="cb169-114"><a href="#cb169-114" aria-hidden="true" tabindex="-1"></a>    F_korrelation <span class="op">=</span> ziel_konstante_korrelation(renditen.values)</span>
-<span id="cb169-115"><a href="#cb169-115" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb169-116"><a href="#cb169-116" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;</span><span class="ch">\n</span><span class="st">--- Die beiden Shrinkage-Ziele im Vergleich ---&quot;</span>)</span>
-<span id="cb169-117"><a href="#cb169-117" aria-hidden="true" tabindex="-1"></a>    <span class="cf">for</span> name, F <span class="kw">in</span> [(<span class="st">&quot;skalierte Einheitsmatrix (sklearn)&quot;</span>, F_identitaet),</span>
-<span id="cb169-118"><a href="#cb169-118" aria-hidden="true" tabindex="-1"></a>                    (<span class="st">&quot;konstante Korrelation (LW 2003)&quot;</span>, F_korrelation)]:</span>
-<span id="cb169-119"><a href="#cb169-119" aria-hidden="true" tabindex="-1"></a>        gemischt <span class="op">=</span> ((<span class="dv">1</span> <span class="op">-</span> delta) <span class="op">*</span> S_taeglich <span class="op">+</span> delta <span class="op">*</span> F) <span class="op">*</span> HANDELSTAGE</span>
-<span id="cb169-120"><a href="#cb169-120" aria-hidden="true" tabindex="-1"></a>        eig <span class="op">=</span> np.linalg.eigvalsh(gemischt)</span>
-<span id="cb169-121"><a href="#cb169-121" aria-hidden="true" tabindex="-1"></a>        <span class="bu">print</span>(<span class="ss">f&quot;  </span><span class="sc">{</span>name<span class="sc">:&lt;36}</span><span class="ss">: Kondition </span><span class="sc">{</span>eig<span class="sc">.</span><span class="bu">max</span>()<span class="op">/</span><span class="bu">max</span>(eig.<span class="bu">min</span>(),<span class="fl">1e-12</span>)<span class="sc">:8.1f}</span><span class="ss">, &quot;</span></span>
-<span id="cb169-122"><a href="#cb169-122" aria-hidden="true" tabindex="-1"></a>              <span class="ss">f&quot;kleinster EW </span><span class="sc">{</span>eig<span class="sc">.</span><span class="bu">min</span>()<span class="sc">:.6f}</span><span class="ss">&quot;</span>)</span>
-<span id="cb169-123"><a href="#cb169-123" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb169-124"><a href="#cb169-124" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;</span><span class="ch">\n</span><span class="st">--- Erwartete Renditen (annualisiert) ---&quot;</span>)</span>
-<span id="cb169-125"><a href="#cb169-125" aria-hidden="true" tabindex="-1"></a>    uebersicht <span class="op">=</span> pd.DataFrame({</span>
-<span id="cb169-126"><a href="#cb169-126" aria-hidden="true" tabindex="-1"></a>        <span class="st">&quot;Ticker&quot;</span>: kurse.columns,</span>
-<span id="cb169-127"><a href="#cb169-127" aria-hidden="true" tabindex="-1"></a>        <span class="st">&quot;Rendite p.a.&quot;</span>: [<span class="ss">f&quot;</span><span class="sc">{</span>r<span class="op">*</span><span class="dv">100</span><span class="sc">:+7.2f}</span><span class="ss"> %&quot;</span> <span class="cf">for</span> r <span class="kw">in</span> mu],</span>
-<span id="cb169-128"><a href="#cb169-128" aria-hidden="true" tabindex="-1"></a>        <span class="st">&quot;Volatilitaet p.a.&quot;</span>: [<span class="ss">f&quot;</span><span class="sc">{</span>np<span class="sc">.</span>sqrt(sigma_lw[i, i])<span class="op">*</span><span class="dv">100</span><span class="sc">:6.2f}</span><span class="ss"> %&quot;</span> <span class="cf">for</span> i <span class="kw">in</span> <span class="bu">range</span>(N)],</span>
-<span id="cb169-129"><a href="#cb169-129" aria-hidden="true" tabindex="-1"></a>    })</span>
-<span id="cb169-130"><a href="#cb169-130" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(uebersicht.to_string(index<span class="op">=</span><span class="va">False</span>))</span>
-<span id="cb169-131"><a href="#cb169-131" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;=&quot;</span> <span class="op">*</span> <span class="dv">84</span>)</span>
-<span id="cb169-132"><a href="#cb169-132" aria-hidden="true" tabindex="-1"></a>    <span class="cf">return</span> renditen, mu, sigma_stichprobe, sigma_lw</span>
-<span id="cb169-133"><a href="#cb169-133" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb169-134"><a href="#cb169-134" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb169-135"><a href="#cb169-135" aria-hidden="true" tabindex="-1"></a><span class="cf">if</span> <span class="va">__name__</span> <span class="op">==</span> <span class="st">&quot;__main__&quot;</span>:</span>
-<span id="cb169-136"><a href="#cb169-136" aria-hidden="true" tabindex="-1"></a>    UNIVERSUM <span class="op">=</span> [<span class="st">&quot;AAPL&quot;</span>, <span class="st">&quot;MSFT&quot;</span>, <span class="st">&quot;NVDA&quot;</span>, <span class="st">&quot;AMZN&quot;</span>,   <span class="co"># Technologie</span></span>
-<span id="cb169-137"><a href="#cb169-137" aria-hidden="true" tabindex="-1"></a>                 <span class="st">&quot;JNJ&quot;</span>, <span class="st">&quot;PFE&quot;</span>,                      <span class="co"># Gesundheit</span></span>
-<span id="cb169-138"><a href="#cb169-138" aria-hidden="true" tabindex="-1"></a>                 <span class="st">&quot;JPM&quot;</span>, <span class="st">&quot;GS&quot;</span>,                       <span class="co"># Banken</span></span>
-<span id="cb169-139"><a href="#cb169-139" aria-hidden="true" tabindex="-1"></a>                 <span class="st">&quot;XOM&quot;</span>, <span class="st">&quot;CVX&quot;</span>]                      <span class="co"># Energie</span></span>
-<span id="cb169-140"><a href="#cb169-140" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb169-141"><a href="#cb169-141" aria-hidden="true" tabindex="-1"></a>    <span class="co"># Relatives 2-Jahres-Fenster, damit das Beispiel nicht &quot;altert&quot;</span></span>
-<span id="cb169-142"><a href="#cb169-142" aria-hidden="true" tabindex="-1"></a>    ende <span class="op">=</span> pd.Timestamp.today().normalize()</span>
-<span id="cb169-143"><a href="#cb169-143" aria-hidden="true" tabindex="-1"></a>    start <span class="op">=</span> ende <span class="op">-</span> pd.DateOffset(years<span class="op">=</span><span class="dv">2</span>)</span>
-<span id="cb169-144"><a href="#cb169-144" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb169-145"><a href="#cb169-145" aria-hidden="true" tabindex="-1"></a>    kurse <span class="op">=</span> lade_kurse(UNIVERSUM, start.strftime(<span class="st">&quot;%Y-%m-</span><span class="sc">%d</span><span class="st">&quot;</span>), ende.strftime(<span class="st">&quot;%Y-%m-</span><span class="sc">%d</span><span class="st">&quot;</span>))</span>
-<span id="cb169-146"><a href="#cb169-146" aria-hidden="true" tabindex="-1"></a>    pruefe_datenqualitaet(kurse)</span>
-<span id="cb169-147"><a href="#cb169-147" aria-hidden="true" tabindex="-1"></a>    analysiere(kurse)</span></code></pre></div>
+<div class="sourceCode" id="cb171"><pre class="sourceCode python"><code class="sourceCode python"><span id="cb171-1"><a href="#cb171-1" aria-hidden="true" tabindex="-1"></a><span class="co">#!/usr/bin/env python3</span></span>
+<span id="cb171-2"><a href="#cb171-2" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb171-3"><a href="#cb171-3" aria-hidden="true" tabindex="-1"></a><span class="co"># Finanzdaten_Ledoit_Wolf.py</span></span>
+<span id="cb171-4"><a href="#cb171-4" aria-hidden="true" tabindex="-1"></a><span class="co">&quot;&quot;&quot;</span></span>
+<span id="cb171-5"><a href="#cb171-5" aria-hidden="true" tabindex="-1"></a><span class="co">Kapitel Finanzdaten: Automatisierte Finanzdaten-Pipeline und Kovarianz-Shrinkage.</span></span>
+<span id="cb171-6"><a href="#cb171-6" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb171-7"><a href="#cb171-7" aria-hidden="true" tabindex="-1"></a><span class="co">Eigenschaften:</span></span>
+<span id="cb171-8"><a href="#cb171-8" aria-hidden="true" tabindex="-1"></a><span class="co">  * Spaltenreihenfolge wird erzwungen und per assert geprueft</span></span>
+<span id="cb171-9"><a href="#cb171-9" aria-hidden="true" tabindex="-1"></a><span class="co">  * beide Shrinkage-Ziele werden berechnet und verglichen</span></span>
+<span id="cb171-10"><a href="#cb171-10" aria-hidden="true" tabindex="-1"></a><span class="co">  * Datenqualitaetspruefungen (Luecken, Ausreisser, Mindestlaenge)</span></span>
+<span id="cb171-11"><a href="#cb171-11" aria-hidden="true" tabindex="-1"></a><span class="co">  * Eigenwertspektrum wird ausgewiesen, nicht nur die Konditionszahl</span></span>
+<span id="cb171-12"><a href="#cb171-12" aria-hidden="true" tabindex="-1"></a><span class="co">&quot;&quot;&quot;</span></span>
+<span id="cb171-13"><a href="#cb171-13" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb171-14"><a href="#cb171-14" aria-hidden="true" tabindex="-1"></a><span class="im">import</span> numpy <span class="im">as</span> np</span>
+<span id="cb171-15"><a href="#cb171-15" aria-hidden="true" tabindex="-1"></a><span class="im">import</span> pandas <span class="im">as</span> pd</span>
+<span id="cb171-16"><a href="#cb171-16" aria-hidden="true" tabindex="-1"></a><span class="im">import</span> yfinance <span class="im">as</span> yf</span>
+<span id="cb171-17"><a href="#cb171-17" aria-hidden="true" tabindex="-1"></a><span class="im">from</span> sklearn.covariance <span class="im">import</span> LedoitWolf</span>
+<span id="cb171-18"><a href="#cb171-18" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb171-19"><a href="#cb171-19" aria-hidden="true" tabindex="-1"></a>HANDELSTAGE <span class="op">=</span> <span class="dv">252</span></span>
+<span id="cb171-20"><a href="#cb171-20" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb171-21"><a href="#cb171-21" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb171-22"><a href="#cb171-22" aria-hidden="true" tabindex="-1"></a><span class="kw">def</span> lade_kurse(tickers: <span class="bu">list</span>[<span class="bu">str</span>], start, ende) <span class="op">-&gt;</span> pd.DataFrame:</span>
+<span id="cb171-23"><a href="#cb171-23" aria-hidden="true" tabindex="-1"></a>    <span class="co">&quot;&quot;&quot;Laedt bereinigte Schlusskurse und garantiert die Spaltenreihenfolge.&quot;&quot;&quot;</span></span>
+<span id="cb171-24"><a href="#cb171-24" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;Lade </span><span class="sc">{</span><span class="bu">len</span>(tickers)<span class="sc">}</span><span class="ss"> Ticker von </span><span class="sc">{</span>start<span class="sc">}</span><span class="ss"> bis </span><span class="sc">{</span>ende<span class="sc">}</span><span class="ss"> ...&quot;</span>)</span>
+<span id="cb171-25"><a href="#cb171-25" aria-hidden="true" tabindex="-1"></a>    roh <span class="op">=</span> yf.download(tickers, start<span class="op">=</span>start, end<span class="op">=</span>ende, auto_adjust<span class="op">=</span><span class="va">True</span>, progress<span class="op">=</span><span class="va">False</span>)</span>
+<span id="cb171-26"><a href="#cb171-26" aria-hidden="true" tabindex="-1"></a>    <span class="cf">if</span> roh.empty:</span>
+<span id="cb171-27"><a href="#cb171-27" aria-hidden="true" tabindex="-1"></a>        <span class="cf">raise</span> <span class="pp">SystemExit</span>(<span class="st">&quot;Download fehlgeschlagen (Netz, Ticker oder Rate-Limit pruefen).&quot;</span>)</span>
+<span id="cb171-28"><a href="#cb171-28" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb171-29"><a href="#cb171-29" aria-hidden="true" tabindex="-1"></a>    <span class="cf">if</span> <span class="bu">isinstance</span>(roh.columns, pd.MultiIndex):</span>
+<span id="cb171-30"><a href="#cb171-30" aria-hidden="true" tabindex="-1"></a>        <span class="co"># [tickers] erzwingt die gewuenschte Spaltenreihenfolge</span></span>
+<span id="cb171-31"><a href="#cb171-31" aria-hidden="true" tabindex="-1"></a>        kurse <span class="op">=</span> roh[<span class="st">&quot;Close&quot;</span>][tickers].dropna()</span>
+<span id="cb171-32"><a href="#cb171-32" aria-hidden="true" tabindex="-1"></a>    <span class="cf">else</span>:</span>
+<span id="cb171-33"><a href="#cb171-33" aria-hidden="true" tabindex="-1"></a>        kurse <span class="op">=</span> roh[[<span class="st">&quot;Close&quot;</span>]].dropna()</span>
+<span id="cb171-34"><a href="#cb171-34" aria-hidden="true" tabindex="-1"></a>        kurse.columns <span class="op">=</span> tickers</span>
+<span id="cb171-35"><a href="#cb171-35" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb171-36"><a href="#cb171-36" aria-hidden="true" tabindex="-1"></a>    <span class="cf">assert</span> <span class="bu">list</span>(kurse.columns) <span class="op">==</span> tickers, (</span>
+<span id="cb171-37"><a href="#cb171-37" aria-hidden="true" tabindex="-1"></a>        <span class="ss">f&quot;Spaltenreihenfolge weicht ab!</span><span class="ch">\n</span><span class="ss">  erwartet: </span><span class="sc">{</span>tickers<span class="sc">}</span><span class="ch">\n</span><span class="ss">&quot;</span></span>
+<span id="cb171-38"><a href="#cb171-38" aria-hidden="true" tabindex="-1"></a>        <span class="ss">f&quot;  erhalten: </span><span class="sc">{</span><span class="bu">list</span>(kurse.columns)<span class="sc">}</span><span class="ss">&quot;</span>)</span>
+<span id="cb171-39"><a href="#cb171-39" aria-hidden="true" tabindex="-1"></a>    <span class="cf">return</span> kurse</span>
+<span id="cb171-40"><a href="#cb171-40" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb171-41"><a href="#cb171-41" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb171-42"><a href="#cb171-42" aria-hidden="true" tabindex="-1"></a><span class="kw">def</span> pruefe_datenqualitaet(kurse: pd.DataFrame, mindest_tage: <span class="bu">int</span> <span class="op">=</span> <span class="dv">200</span>) <span class="op">-&gt;</span> <span class="va">None</span>:</span>
+<span id="cb171-43"><a href="#cb171-43" aria-hidden="true" tabindex="-1"></a>    <span class="co">&quot;&quot;&quot;Faengt die haeufigsten Datenprobleme ab, bevor sie ins Modell gelangen.&quot;&quot;&quot;</span></span>
+<span id="cb171-44"><a href="#cb171-44" aria-hidden="true" tabindex="-1"></a>    T, N <span class="op">=</span> kurse.shape</span>
+<span id="cb171-45"><a href="#cb171-45" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;</span><span class="ch">\n</span><span class="ss">Datenqualitaet: </span><span class="sc">{</span>T<span class="sc">}</span><span class="ss"> Handelstage, </span><span class="sc">{</span>N<span class="sc">}</span><span class="ss"> Titel (T/N = </span><span class="sc">{</span>T<span class="op">/</span>N<span class="sc">:.1f}</span><span class="ss">)&quot;</span>)</span>
+<span id="cb171-46"><a href="#cb171-46" aria-hidden="true" tabindex="-1"></a>    <span class="cf">if</span> T <span class="op">&lt;</span> mindest_tage:</span>
+<span id="cb171-47"><a href="#cb171-47" aria-hidden="true" tabindex="-1"></a>        <span class="cf">raise</span> <span class="pp">SystemExit</span>(<span class="ss">f&quot;Zu wenige Beobachtungen (</span><span class="sc">{</span>T<span class="sc">}</span><span class="ss"> &lt; </span><span class="sc">{</span>mindest_tage<span class="sc">}</span><span class="ss">).&quot;</span>)</span>
+<span id="cb171-48"><a href="#cb171-48" aria-hidden="true" tabindex="-1"></a>    <span class="cf">if</span> T <span class="op">&lt;</span> N:</span>
+<span id="cb171-49"><a href="#cb171-49" aria-hidden="true" tabindex="-1"></a>        <span class="bu">print</span>(<span class="st">&quot;  WARNUNG: T &lt; N - die Stichprobenkovarianz ist singulaer!&quot;</span>)</span>
+<span id="cb171-50"><a href="#cb171-50" aria-hidden="true" tabindex="-1"></a>    <span class="cf">elif</span> T <span class="op">&lt;</span> <span class="dv">3</span> <span class="op">*</span> N:</span>
+<span id="cb171-51"><a href="#cb171-51" aria-hidden="true" tabindex="-1"></a>        <span class="bu">print</span>(<span class="st">&quot;  WARNUNG: T &lt; 3N - erhebliches Schaetzrauschen zu erwarten.&quot;</span>)</span>
+<span id="cb171-52"><a href="#cb171-52" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb171-53"><a href="#cb171-53" aria-hidden="true" tabindex="-1"></a>    renditen <span class="op">=</span> kurse.pct_change().dropna()</span>
+<span id="cb171-54"><a href="#cb171-54" aria-hidden="true" tabindex="-1"></a>    extreme <span class="op">=</span> (renditen.<span class="bu">abs</span>() <span class="op">&gt;</span> <span class="fl">0.25</span>).<span class="bu">sum</span>().<span class="bu">sum</span>()</span>
+<span id="cb171-55"><a href="#cb171-55" aria-hidden="true" tabindex="-1"></a>    <span class="cf">if</span> extreme:</span>
+<span id="cb171-56"><a href="#cb171-56" aria-hidden="true" tabindex="-1"></a>        <span class="bu">print</span>(<span class="ss">f&quot;  Hinweis: </span><span class="sc">{</span>extreme<span class="sc">}</span><span class="ss"> Tagesrenditen ueber 25 % &quot;</span></span>
+<span id="cb171-57"><a href="#cb171-57" aria-hidden="true" tabindex="-1"></a>              <span class="ss">f&quot;(Splits, Sondersituationen oder Datenfehler pruefen).&quot;</span>)</span>
+<span id="cb171-58"><a href="#cb171-58" aria-hidden="true" tabindex="-1"></a>    luecken <span class="op">=</span> kurse.isna().<span class="bu">sum</span>().<span class="bu">sum</span>()</span>
+<span id="cb171-59"><a href="#cb171-59" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;  Fehlende Werte nach dropna: </span><span class="sc">{</span>luecken<span class="sc">}</span><span class="ss">&quot;</span>)</span>
+<span id="cb171-60"><a href="#cb171-60" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb171-61"><a href="#cb171-61" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb171-62"><a href="#cb171-62" aria-hidden="true" tabindex="-1"></a><span class="kw">def</span> ziel_konstante_korrelation(renditen: np.ndarray) <span class="op">-&gt;</span> np.ndarray:</span>
+<span id="cb171-63"><a href="#cb171-63" aria-hidden="true" tabindex="-1"></a>    <span class="co">&quot;&quot;&quot;</span></span>
+<span id="cb171-64"><a href="#cb171-64" aria-hidden="true" tabindex="-1"></a><span class="co">    Shrinkage-Ziel nach Ledoit/Wolf 2003: Einzelvarianzen behalten,</span></span>
+<span id="cb171-65"><a href="#cb171-65" aria-hidden="true" tabindex="-1"></a><span class="co">    alle Korrelationen durch ihren Mittelwert ersetzen.</span></span>
+<span id="cb171-66"><a href="#cb171-66" aria-hidden="true" tabindex="-1"></a><span class="co">    (sklearn nutzt stattdessen die skalierte Einheitsmatrix - siehe oben.)</span></span>
+<span id="cb171-67"><a href="#cb171-67" aria-hidden="true" tabindex="-1"></a><span class="co">    &quot;&quot;&quot;</span></span>
+<span id="cb171-68"><a href="#cb171-68" aria-hidden="true" tabindex="-1"></a>    S <span class="op">=</span> np.cov(renditen, rowvar<span class="op">=</span><span class="va">False</span>, ddof<span class="op">=</span><span class="dv">1</span>)</span>
+<span id="cb171-69"><a href="#cb171-69" aria-hidden="true" tabindex="-1"></a>    d <span class="op">=</span> np.sqrt(np.diag(S))</span>
+<span id="cb171-70"><a href="#cb171-70" aria-hidden="true" tabindex="-1"></a>    korrelation <span class="op">=</span> S <span class="op">/</span> np.outer(d, d)</span>
+<span id="cb171-71"><a href="#cb171-71" aria-hidden="true" tabindex="-1"></a>    n <span class="op">=</span> <span class="bu">len</span>(S)</span>
+<span id="cb171-72"><a href="#cb171-72" aria-hidden="true" tabindex="-1"></a>    r_quer <span class="op">=</span> (korrelation.<span class="bu">sum</span>() <span class="op">-</span> n) <span class="op">/</span> (n <span class="op">*</span> (n <span class="op">-</span> <span class="dv">1</span>))       <span class="co"># Mittel ohne Diagonale</span></span>
+<span id="cb171-73"><a href="#cb171-73" aria-hidden="true" tabindex="-1"></a>    F <span class="op">=</span> r_quer <span class="op">*</span> np.outer(d, d)</span>
+<span id="cb171-74"><a href="#cb171-74" aria-hidden="true" tabindex="-1"></a>    np.fill_diagonal(F, np.diag(S))</span>
+<span id="cb171-75"><a href="#cb171-75" aria-hidden="true" tabindex="-1"></a>    <span class="cf">return</span> F</span>
+<span id="cb171-76"><a href="#cb171-76" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb171-77"><a href="#cb171-77" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb171-78"><a href="#cb171-78" aria-hidden="true" tabindex="-1"></a><span class="kw">def</span> analysiere(kurse: pd.DataFrame):</span>
+<span id="cb171-79"><a href="#cb171-79" aria-hidden="true" tabindex="-1"></a>    renditen <span class="op">=</span> kurse.pct_change().dropna()</span>
+<span id="cb171-80"><a href="#cb171-80" aria-hidden="true" tabindex="-1"></a>    T, N <span class="op">=</span> renditen.shape</span>
+<span id="cb171-81"><a href="#cb171-81" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb171-82"><a href="#cb171-82" aria-hidden="true" tabindex="-1"></a>    mu <span class="op">=</span> renditen.mean().values <span class="op">*</span> HANDELSTAGE</span>
+<span id="cb171-83"><a href="#cb171-83" aria-hidden="true" tabindex="-1"></a>    sigma_stichprobe <span class="op">=</span> renditen.cov().values <span class="op">*</span> HANDELSTAGE</span>
+<span id="cb171-84"><a href="#cb171-84" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb171-85"><a href="#cb171-85" aria-hidden="true" tabindex="-1"></a>    lw <span class="op">=</span> LedoitWolf(assume_centered<span class="op">=</span><span class="va">False</span>).fit(renditen.values)</span>
+<span id="cb171-86"><a href="#cb171-86" aria-hidden="true" tabindex="-1"></a>    sigma_lw <span class="op">=</span> lw.covariance_ <span class="op">*</span> HANDELSTAGE</span>
+<span id="cb171-87"><a href="#cb171-87" aria-hidden="true" tabindex="-1"></a>    delta <span class="op">=</span> lw.shrinkage_</span>
+<span id="cb171-88"><a href="#cb171-88" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb171-89"><a href="#cb171-89" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;</span><span class="ch">\n</span><span class="st">&quot;</span> <span class="op">+</span> <span class="st">&quot;=&quot;</span> <span class="op">*</span> <span class="dv">84</span>)</span>
+<span id="cb171-90"><a href="#cb171-90" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;         FINANZDATEN-PIPELINE UND MATRIX-KONDITIONIERUNG&quot;</span>)</span>
+<span id="cb171-91"><a href="#cb171-91" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;=&quot;</span> <span class="op">*</span> <span class="dv">84</span>)</span>
+<span id="cb171-92"><a href="#cb171-92" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;Beobachtungen T:            </span><span class="sc">{</span>T<span class="sc">}</span><span class="ss">&quot;</span>)</span>
+<span id="cb171-93"><a href="#cb171-93" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;Titel N:                    </span><span class="sc">{</span>N<span class="sc">}</span><span class="ss">&quot;</span>)</span>
+<span id="cb171-94"><a href="#cb171-94" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;Optimales Shrinkage delta:  </span><span class="sc">{</span>delta<span class="sc">:.4f}</span><span class="ss"> &quot;</span></span>
+<span id="cb171-95"><a href="#cb171-95" aria-hidden="true" tabindex="-1"></a>          <span class="ss">f&quot;(</span><span class="sc">{</span>delta<span class="op">*</span><span class="dv">100</span><span class="sc">:.1f}</span><span class="ss"> % Gewicht auf dem strukturierten Ziel)&quot;</span>)</span>
+<span id="cb171-96"><a href="#cb171-96" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb171-97"><a href="#cb171-97" aria-hidden="true" tabindex="-1"></a>    eig_stich <span class="op">=</span> np.linalg.eigvalsh(sigma_stichprobe)</span>
+<span id="cb171-98"><a href="#cb171-98" aria-hidden="true" tabindex="-1"></a>    eig_lw <span class="op">=</span> np.linalg.eigvalsh(sigma_lw)</span>
+<span id="cb171-99"><a href="#cb171-99" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb171-100"><a href="#cb171-100" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;</span><span class="ch">\n</span><span class="st">--- Eigenwertspektrum (annualisiert) ---&quot;</span>)</span>
+<span id="cb171-101"><a href="#cb171-101" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;</span><span class="sc">{</span><span class="st">&#39;&#39;</span><span class="sc">:&lt;14}</span><span class="ss"> </span><span class="sc">{</span><span class="st">&#39;kleinster&#39;</span><span class="sc">:&gt;12}</span><span class="ss"> </span><span class="sc">{</span><span class="st">&#39;Median&#39;</span><span class="sc">:&gt;12}</span><span class="ss"> </span><span class="sc">{</span><span class="st">&#39;groesster&#39;</span><span class="sc">:&gt;12}</span><span class="ss"> &quot;</span></span>
+<span id="cb171-102"><a href="#cb171-102" aria-hidden="true" tabindex="-1"></a>          <span class="ss">f&quot;</span><span class="sc">{</span><span class="st">&#39;Kondition&#39;</span><span class="sc">:&gt;12}</span><span class="ss">&quot;</span>)</span>
+<span id="cb171-103"><a href="#cb171-103" aria-hidden="true" tabindex="-1"></a>    <span class="cf">for</span> name, eig <span class="kw">in</span> [(<span class="st">&quot;Stichprobe&quot;</span>, eig_stich), (<span class="st">&quot;Ledoit-Wolf&quot;</span>, eig_lw)]:</span>
+<span id="cb171-104"><a href="#cb171-104" aria-hidden="true" tabindex="-1"></a>        kondition <span class="op">=</span> eig.<span class="bu">max</span>() <span class="op">/</span> <span class="bu">max</span>(eig.<span class="bu">min</span>(), <span class="fl">1e-12</span>)</span>
+<span id="cb171-105"><a href="#cb171-105" aria-hidden="true" tabindex="-1"></a>        <span class="bu">print</span>(<span class="ss">f&quot;</span><span class="sc">{</span>name<span class="sc">:&lt;14}</span><span class="ss"> </span><span class="sc">{</span>eig<span class="sc">.</span><span class="bu">min</span>()<span class="sc">:&gt;12.6f}</span><span class="ss"> </span><span class="sc">{</span>np<span class="sc">.</span>median(eig)<span class="sc">:&gt;12.6f}</span><span class="ss"> &quot;</span></span>
+<span id="cb171-106"><a href="#cb171-106" aria-hidden="true" tabindex="-1"></a>              <span class="ss">f&quot;</span><span class="sc">{</span>eig<span class="sc">.</span><span class="bu">max</span>()<span class="sc">:&gt;12.6f}</span><span class="ss"> </span><span class="sc">{</span>kondition<span class="sc">:&gt;12.1f}</span><span class="ss">&quot;</span>)</span>
+<span id="cb171-107"><a href="#cb171-107" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb171-108"><a href="#cb171-108" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;</span><span class="ch">\n</span><span class="st">Die Konditionszahl misst, wie stark sich kleine Datenaenderungen auf&quot;</span>)</span>
+<span id="cb171-109"><a href="#cb171-109" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;die Inverse auswirken. Je kleiner, desto stabiler die Portfoliogewichte.&quot;</span>)</span>
+<span id="cb171-110"><a href="#cb171-110" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb171-111"><a href="#cb171-111" aria-hidden="true" tabindex="-1"></a>    <span class="co"># --- Vergleich der beiden Shrinkage-Ziele ----------------------------</span></span>
+<span id="cb171-112"><a href="#cb171-112" aria-hidden="true" tabindex="-1"></a>    S_taeglich <span class="op">=</span> np.cov(renditen.values, rowvar<span class="op">=</span><span class="va">False</span>, ddof<span class="op">=</span><span class="dv">1</span>)</span>
+<span id="cb171-113"><a href="#cb171-113" aria-hidden="true" tabindex="-1"></a>    F_identitaet <span class="op">=</span> np.eye(N) <span class="op">*</span> np.trace(S_taeglich) <span class="op">/</span> N</span>
+<span id="cb171-114"><a href="#cb171-114" aria-hidden="true" tabindex="-1"></a>    F_korrelation <span class="op">=</span> ziel_konstante_korrelation(renditen.values)</span>
+<span id="cb171-115"><a href="#cb171-115" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb171-116"><a href="#cb171-116" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;</span><span class="ch">\n</span><span class="st">--- Die beiden Shrinkage-Ziele im Vergleich ---&quot;</span>)</span>
+<span id="cb171-117"><a href="#cb171-117" aria-hidden="true" tabindex="-1"></a>    <span class="cf">for</span> name, F <span class="kw">in</span> [(<span class="st">&quot;skalierte Einheitsmatrix (sklearn)&quot;</span>, F_identitaet),</span>
+<span id="cb171-118"><a href="#cb171-118" aria-hidden="true" tabindex="-1"></a>                    (<span class="st">&quot;konstante Korrelation (LW 2003)&quot;</span>, F_korrelation)]:</span>
+<span id="cb171-119"><a href="#cb171-119" aria-hidden="true" tabindex="-1"></a>        gemischt <span class="op">=</span> ((<span class="dv">1</span> <span class="op">-</span> delta) <span class="op">*</span> S_taeglich <span class="op">+</span> delta <span class="op">*</span> F) <span class="op">*</span> HANDELSTAGE</span>
+<span id="cb171-120"><a href="#cb171-120" aria-hidden="true" tabindex="-1"></a>        eig <span class="op">=</span> np.linalg.eigvalsh(gemischt)</span>
+<span id="cb171-121"><a href="#cb171-121" aria-hidden="true" tabindex="-1"></a>        <span class="bu">print</span>(<span class="ss">f&quot;  </span><span class="sc">{</span>name<span class="sc">:&lt;36}</span><span class="ss">: Kondition </span><span class="sc">{</span>eig<span class="sc">.</span><span class="bu">max</span>()<span class="op">/</span><span class="bu">max</span>(eig.<span class="bu">min</span>(),<span class="fl">1e-12</span>)<span class="sc">:8.1f}</span><span class="ss">, &quot;</span></span>
+<span id="cb171-122"><a href="#cb171-122" aria-hidden="true" tabindex="-1"></a>              <span class="ss">f&quot;kleinster EW </span><span class="sc">{</span>eig<span class="sc">.</span><span class="bu">min</span>()<span class="sc">:.6f}</span><span class="ss">&quot;</span>)</span>
+<span id="cb171-123"><a href="#cb171-123" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb171-124"><a href="#cb171-124" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;</span><span class="ch">\n</span><span class="st">--- Erwartete Renditen (annualisiert) ---&quot;</span>)</span>
+<span id="cb171-125"><a href="#cb171-125" aria-hidden="true" tabindex="-1"></a>    uebersicht <span class="op">=</span> pd.DataFrame({</span>
+<span id="cb171-126"><a href="#cb171-126" aria-hidden="true" tabindex="-1"></a>        <span class="st">&quot;Ticker&quot;</span>: kurse.columns,</span>
+<span id="cb171-127"><a href="#cb171-127" aria-hidden="true" tabindex="-1"></a>        <span class="st">&quot;Rendite p.a.&quot;</span>: [<span class="ss">f&quot;</span><span class="sc">{</span>r<span class="op">*</span><span class="dv">100</span><span class="sc">:+7.2f}</span><span class="ss"> %&quot;</span> <span class="cf">for</span> r <span class="kw">in</span> mu],</span>
+<span id="cb171-128"><a href="#cb171-128" aria-hidden="true" tabindex="-1"></a>        <span class="st">&quot;Volatilitaet p.a.&quot;</span>: [<span class="ss">f&quot;</span><span class="sc">{</span>np<span class="sc">.</span>sqrt(sigma_lw[i, i])<span class="op">*</span><span class="dv">100</span><span class="sc">:6.2f}</span><span class="ss"> %&quot;</span> <span class="cf">for</span> i <span class="kw">in</span> <span class="bu">range</span>(N)],</span>
+<span id="cb171-129"><a href="#cb171-129" aria-hidden="true" tabindex="-1"></a>    })</span>
+<span id="cb171-130"><a href="#cb171-130" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(uebersicht.to_string(index<span class="op">=</span><span class="va">False</span>))</span>
+<span id="cb171-131"><a href="#cb171-131" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;=&quot;</span> <span class="op">*</span> <span class="dv">84</span>)</span>
+<span id="cb171-132"><a href="#cb171-132" aria-hidden="true" tabindex="-1"></a>    <span class="cf">return</span> renditen, mu, sigma_stichprobe, sigma_lw</span>
+<span id="cb171-133"><a href="#cb171-133" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb171-134"><a href="#cb171-134" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb171-135"><a href="#cb171-135" aria-hidden="true" tabindex="-1"></a><span class="cf">if</span> <span class="va">__name__</span> <span class="op">==</span> <span class="st">&quot;__main__&quot;</span>:</span>
+<span id="cb171-136"><a href="#cb171-136" aria-hidden="true" tabindex="-1"></a>    UNIVERSUM <span class="op">=</span> [<span class="st">&quot;AAPL&quot;</span>, <span class="st">&quot;MSFT&quot;</span>, <span class="st">&quot;NVDA&quot;</span>, <span class="st">&quot;AMZN&quot;</span>,   <span class="co"># Technologie</span></span>
+<span id="cb171-137"><a href="#cb171-137" aria-hidden="true" tabindex="-1"></a>                 <span class="st">&quot;JNJ&quot;</span>, <span class="st">&quot;PFE&quot;</span>,                      <span class="co"># Gesundheit</span></span>
+<span id="cb171-138"><a href="#cb171-138" aria-hidden="true" tabindex="-1"></a>                 <span class="st">&quot;JPM&quot;</span>, <span class="st">&quot;GS&quot;</span>,                       <span class="co"># Banken</span></span>
+<span id="cb171-139"><a href="#cb171-139" aria-hidden="true" tabindex="-1"></a>                 <span class="st">&quot;XOM&quot;</span>, <span class="st">&quot;CVX&quot;</span>]                      <span class="co"># Energie</span></span>
+<span id="cb171-140"><a href="#cb171-140" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb171-141"><a href="#cb171-141" aria-hidden="true" tabindex="-1"></a>    <span class="co"># Relatives 2-Jahres-Fenster, damit das Beispiel nicht &quot;altert&quot;</span></span>
+<span id="cb171-142"><a href="#cb171-142" aria-hidden="true" tabindex="-1"></a>    ende <span class="op">=</span> pd.Timestamp.today().normalize()</span>
+<span id="cb171-143"><a href="#cb171-143" aria-hidden="true" tabindex="-1"></a>    start <span class="op">=</span> ende <span class="op">-</span> pd.DateOffset(years<span class="op">=</span><span class="dv">2</span>)</span>
+<span id="cb171-144"><a href="#cb171-144" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb171-145"><a href="#cb171-145" aria-hidden="true" tabindex="-1"></a>    kurse <span class="op">=</span> lade_kurse(UNIVERSUM, start.strftime(<span class="st">&quot;%Y-%m-</span><span class="sc">%d</span><span class="st">&quot;</span>), ende.strftime(<span class="st">&quot;%Y-%m-</span><span class="sc">%d</span><span class="st">&quot;</span>))</span>
+<span id="cb171-146"><a href="#cb171-146" aria-hidden="true" tabindex="-1"></a>    pruefe_datenqualitaet(kurse)</span>
+<span id="cb171-147"><a href="#cb171-147" aria-hidden="true" tabindex="-1"></a>    analysiere(kurse)</span></code></pre></div>
 <blockquote>
 <p><strong>⚠️ Zur Reproduzierbarkeit</strong> Dieses Programm lädt <strong>Live-Daten</strong>. Ihre Zahlen werden von den hier abgedruckten abweichen — je nach Abrufdatum. Das ist beabsichtigt und selbst eine Lektion: Wenn sich das optimale Portfolio zwischen zwei Abrufen deutlich ändert, obwohl nur ein paar Tage vergangen sind, sehen Sie den Schätzfehler direkt. Prüfen Sie das ruhig einmal.</p>
 </blockquote>
@@ -21802,136 +22777,137 @@ prices.columns:  [&#39;AAPL&#39;, &#39;AMZN&#39;, &#39;CVX&#39;, &#39;GS&#39;, &
 <hr />
 <h2 id="sec:finanzdaten-denkfehler">18.8 Finde den Denkfehler</h2>
 <blockquote>
-<p><strong>🐛 Finde den Denkfehler 11.1: Das risikofreie Portfolio</strong></p>
+<p><strong>🐛 Finde den Denkfehler: Das risikofreie Portfolio</strong></p>
 <p>Ein Analyst stellt ein Portfolio aus <strong>30 Titeln</strong> zusammen. Für die Kovarianzmatrix nimmt er das letzte Quartal — bei Wochendaten sind das <strong>20 Beobachtungen</strong>. Dann minimiert er die Varianz.</p>
 <p>Das Ergebnis begeistert ihn: Das Portfolio hat ein Risiko von <strong>0,000 %</strong>. Er hat ein risikofreies Aktienportfolio gefunden.</p>
 <p><strong>Ihre Aufgabe:</strong> (a) Wie hoch ist der Rang einer Kovarianzmatrix, die aus <span class="math inline">T</span> Beobachtungen für <span class="math inline">N &gt; T</span> Anlagen geschätzt wurde — und was folgt daraus geometrisch? (b) Warum findet ausgerechnet ein <strong>Minimum</strong>-Varianz-Optimierer diese Stelle so zuverlässig? (c) Sehen Sie sich unten die Spalte „Hebel“ an. Was sagt ein Wert von 3,8 über das Portfolio aus? (d) Warum schlägt die simple Gleichgewichtung den Optimierer — und was folgt daraus für Ihre eigenen Modelle, auch außerhalb der Finanzwelt?</p>
 <p><em>Auflösung: <a href="#sec:loesungen-finanzdaten">Abschnitt A.18</a>.</em></p>
 </blockquote>
 <p>Das folgende Programm führt den Fall vor. Es arbeitet mit <strong>synthetischen</strong> Daten, damit das Ergebnis reproduzierbar ist und kein Internetzugang nötig wird — mit echten Kursdaten sieht es genauso aus.</p>
-<div class="sourceCode" id="cb170"><pre class="sourceCode python"><code class="sourceCode python"><span id="cb170-1"><a href="#cb170-1" aria-hidden="true" tabindex="-1"></a><span class="co">#!/usr/bin/env python3</span></span>
-<span id="cb170-2"><a href="#cb170-2" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb170-3"><a href="#cb170-3" aria-hidden="true" tabindex="-1"></a><span class="co"># Kovarianz_Falle.py</span></span>
-<span id="cb170-4"><a href="#cb170-4" aria-hidden="true" tabindex="-1"></a><span class="co">&quot;&quot;&quot;</span></span>
-<span id="cb170-5"><a href="#cb170-5" aria-hidden="true" tabindex="-1"></a><span class="co">Kapitel Finanzdaten: Warum die historische Kovarianzmatrix den Optimierer belaeugt.</span></span>
-<span id="cb170-6"><a href="#cb170-6" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb170-7"><a href="#cb170-7" aria-hidden="true" tabindex="-1"></a><span class="co">Ein Portfolio aus 30 Anlagen soll das Risiko minimieren. Geschaetzt wird die</span></span>
-<span id="cb170-8"><a href="#cb170-8" aria-hidden="true" tabindex="-1"></a><span class="co">Kovarianzmatrix aus 20 Beobachtungen - in der Praxis ein voellig ueblicher</span></span>
-<span id="cb170-9"><a href="#cb170-9" aria-hidden="true" tabindex="-1"></a><span class="co">Fall (30 Titel, ein Quartal Wochendaten).</span></span>
-<span id="cb170-10"><a href="#cb170-10" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb170-11"><a href="#cb170-11" aria-hidden="true" tabindex="-1"></a><span class="co">Das Ergebnis ist ein Portfolio mit einem gemessenen Risiko von 0,000 %. Der</span></span>
-<span id="cb170-12"><a href="#cb170-12" aria-hidden="true" tabindex="-1"></a><span class="co">Optimierer haelt es fuer risikofrei. Ausserhalb des Schaetzzeitraums ist es</span></span>
-<span id="cb170-13"><a href="#cb170-13" aria-hidden="true" tabindex="-1"></a><span class="co">das schlechteste der drei untersuchten Portfolios - schlechter sogar als</span></span>
-<span id="cb170-14"><a href="#cb170-14" aria-hidden="true" tabindex="-1"></a><span class="co">blosse Gleichgewichtung.</span></span>
-<span id="cb170-15"><a href="#cb170-15" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb170-16"><a href="#cb170-16" aria-hidden="true" tabindex="-1"></a><span class="co">Der Grund ist nicht Zufall, sondern Struktur: Bei N Anlagen und T &lt; N</span></span>
-<span id="cb170-17"><a href="#cb170-17" aria-hidden="true" tabindex="-1"></a><span class="co">Beobachtungen hat die Stichproben-Kovarianzmatrix hoechstens Rang T-1. Es gibt</span></span>
-<span id="cb170-18"><a href="#cb170-18" aria-hidden="true" tabindex="-1"></a><span class="co">dann ganze Richtungen im Gewichtsraum, in denen sie exakt null Varianz misst -</span></span>
-<span id="cb170-19"><a href="#cb170-19" aria-hidden="true" tabindex="-1"></a><span class="co">Richtungen, die es in Wirklichkeit nicht gibt. Der Optimierer findet sie</span></span>
-<span id="cb170-20"><a href="#cb170-20" aria-hidden="true" tabindex="-1"></a><span class="co">zuverlaessig, denn er sucht ja genau danach.</span></span>
-<span id="cb170-21"><a href="#cb170-21" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb170-22"><a href="#cb170-22" aria-hidden="true" tabindex="-1"></a><span class="co">Die Daten sind synthetisch (ein Marktfaktor plus Eigenrauschen), damit das</span></span>
-<span id="cb170-23"><a href="#cb170-23" aria-hidden="true" tabindex="-1"></a><span class="co">Ergebnis reproduzierbar ist und kein Internetzugang noetig wird. Mit echten</span></span>
-<span id="cb170-24"><a href="#cb170-24" aria-hidden="true" tabindex="-1"></a><span class="co">Kursdaten sieht es genauso aus.</span></span>
-<span id="cb170-25"><a href="#cb170-25" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb170-26"><a href="#cb170-26" aria-hidden="true" tabindex="-1"></a><span class="co">Benoetigt: numpy, cvxpy, scikit-learn</span></span>
-<span id="cb170-27"><a href="#cb170-27" aria-hidden="true" tabindex="-1"></a><span class="co">&quot;&quot;&quot;</span></span>
-<span id="cb170-28"><a href="#cb170-28" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb170-29"><a href="#cb170-29" aria-hidden="true" tabindex="-1"></a><span class="im">from</span> __future__ <span class="im">import</span> annotations</span>
-<span id="cb170-30"><a href="#cb170-30" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb170-31"><a href="#cb170-31" aria-hidden="true" tabindex="-1"></a><span class="im">import</span> numpy <span class="im">as</span> np</span>
-<span id="cb170-32"><a href="#cb170-32" aria-hidden="true" tabindex="-1"></a><span class="im">import</span> cvxpy <span class="im">as</span> cp</span>
-<span id="cb170-33"><a href="#cb170-33" aria-hidden="true" tabindex="-1"></a><span class="im">from</span> sklearn.covariance <span class="im">import</span> LedoitWolf</span>
-<span id="cb170-34"><a href="#cb170-34" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb170-35"><a href="#cb170-35" aria-hidden="true" tabindex="-1"></a>ANZAHL_ANLAGEN <span class="op">=</span> <span class="dv">30</span></span>
-<span id="cb170-36"><a href="#cb170-36" aria-hidden="true" tabindex="-1"></a>BEOBACHTUNGEN_SCHAETZUNG <span class="op">=</span> <span class="dv">20</span>        <span class="co"># weniger als Anlagen - genau darum geht es</span></span>
-<span id="cb170-37"><a href="#cb170-37" aria-hidden="true" tabindex="-1"></a>BEOBACHTUNGEN_TEST <span class="op">=</span> <span class="dv">2000</span>            <span class="co"># der &quot;spaetere Verlauf&quot;</span></span>
-<span id="cb170-38"><a href="#cb170-38" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb170-39"><a href="#cb170-39" aria-hidden="true" tabindex="-1"></a>RNG <span class="op">=</span> np.random.default_rng(<span class="dv">11</span>)</span>
-<span id="cb170-40"><a href="#cb170-40" aria-hidden="true" tabindex="-1"></a><span class="co"># Jede Anlage reagiert unterschiedlich stark auf den Gesamtmarkt.</span></span>
-<span id="cb170-41"><a href="#cb170-41" aria-hidden="true" tabindex="-1"></a>BETA <span class="op">=</span> RNG.uniform(<span class="fl">0.6</span>, <span class="fl">1.4</span>, ANZAHL_ANLAGEN)</span>
-<span id="cb170-42"><a href="#cb170-42" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb170-43"><a href="#cb170-43" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb170-44"><a href="#cb170-44" aria-hidden="true" tabindex="-1"></a><span class="kw">def</span> erzeuge_renditen(perioden: <span class="bu">int</span>) <span class="op">-&gt;</span> np.ndarray:</span>
-<span id="cb170-45"><a href="#cb170-45" aria-hidden="true" tabindex="-1"></a>    <span class="co">&quot;&quot;&quot;Ein Marktfaktor, auf den alle reagieren, plus Eigenrauschen je Anlage.&quot;&quot;&quot;</span></span>
-<span id="cb170-46"><a href="#cb170-46" aria-hidden="true" tabindex="-1"></a>    markt <span class="op">=</span> RNG.normal(<span class="fl">0.0</span>, <span class="fl">0.010</span>, perioden)</span>
-<span id="cb170-47"><a href="#cb170-47" aria-hidden="true" tabindex="-1"></a>    eigen <span class="op">=</span> RNG.normal(<span class="fl">0.0</span>, <span class="fl">0.012</span>, (perioden, ANZAHL_ANLAGEN))</span>
-<span id="cb170-48"><a href="#cb170-48" aria-hidden="true" tabindex="-1"></a>    <span class="cf">return</span> np.outer(markt, BETA) <span class="op">+</span> eigen</span>
-<span id="cb170-49"><a href="#cb170-49" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb170-50"><a href="#cb170-50" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb170-51"><a href="#cb170-51" aria-hidden="true" tabindex="-1"></a><span class="kw">def</span> minimales_risiko(kovarianz: np.ndarray) <span class="op">-&gt;</span> <span class="bu">tuple</span>[np.ndarray, <span class="bu">float</span>]:</span>
-<span id="cb170-52"><a href="#cb170-52" aria-hidden="true" tabindex="-1"></a>    <span class="co">&quot;&quot;&quot;Minimum-Varianz-Portfolio: Gewichte summieren sich zu 1, sonst frei.</span></span>
-<span id="cb170-53"><a href="#cb170-53" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb170-54"><a href="#cb170-54" aria-hidden="true" tabindex="-1"></a><span class="co">    cp.psd_wrap() sagt CVXPY: &#39;Ich weiss, dass diese Matrix numerisch nicht</span></span>
-<span id="cb170-55"><a href="#cb170-55" aria-hidden="true" tabindex="-1"></a><span class="co">    exakt positiv semidefinit ist - rechne trotzdem.&#39; Das ist hier bewusst so</span></span>
-<span id="cb170-56"><a href="#cb170-56" aria-hidden="true" tabindex="-1"></a><span class="co">    gewaehlt, denn genau diese Eigenschaft wollen wir vorfuehren. Im</span></span>
-<span id="cb170-57"><a href="#cb170-57" aria-hidden="true" tabindex="-1"></a><span class="co">    Produktivbetrieb waere die DCP-Fehlermeldung das Warnsignal, dem man</span></span>
-<span id="cb170-58"><a href="#cb170-58" aria-hidden="true" tabindex="-1"></a><span class="co">    nachgehen muss (siehe Denkfehler 8.1).</span></span>
-<span id="cb170-59"><a href="#cb170-59" aria-hidden="true" tabindex="-1"></a><span class="co">    &quot;&quot;&quot;</span></span>
-<span id="cb170-60"><a href="#cb170-60" aria-hidden="true" tabindex="-1"></a>    gewichte <span class="op">=</span> cp.Variable(ANZAHL_ANLAGEN)</span>
-<span id="cb170-61"><a href="#cb170-61" aria-hidden="true" tabindex="-1"></a>    problem <span class="op">=</span> cp.Problem(cp.Minimize(cp.quad_form(gewichte, cp.psd_wrap(kovarianz))),</span>
-<span id="cb170-62"><a href="#cb170-62" aria-hidden="true" tabindex="-1"></a>                         [cp.<span class="bu">sum</span>(gewichte) <span class="op">==</span> <span class="dv">1</span>])</span>
-<span id="cb170-63"><a href="#cb170-63" aria-hidden="true" tabindex="-1"></a>    problem.solve()</span>
-<span id="cb170-64"><a href="#cb170-64" aria-hidden="true" tabindex="-1"></a>    <span class="cf">return</span> np.array(gewichte.value).ravel(), <span class="bu">max</span>(problem.value, <span class="fl">0.0</span>)</span>
-<span id="cb170-65"><a href="#cb170-65" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb170-66"><a href="#cb170-66" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb170-67"><a href="#cb170-67" aria-hidden="true" tabindex="-1"></a><span class="cf">if</span> <span class="va">__name__</span> <span class="op">==</span> <span class="st">&quot;__main__&quot;</span>:</span>
-<span id="cb170-68"><a href="#cb170-68" aria-hidden="true" tabindex="-1"></a>    schaetzzeitraum <span class="op">=</span> erzeuge_renditen(BEOBACHTUNGEN_SCHAETZUNG)</span>
-<span id="cb170-69"><a href="#cb170-69" aria-hidden="true" tabindex="-1"></a>    spaeterer_verlauf <span class="op">=</span> erzeuge_renditen(BEOBACHTUNGEN_TEST)</span>
-<span id="cb170-70"><a href="#cb170-70" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb170-71"><a href="#cb170-71" aria-hidden="true" tabindex="-1"></a>    stichprobe <span class="op">=</span> np.cov(schaetzzeitraum, rowvar<span class="op">=</span><span class="va">False</span>)</span>
-<span id="cb170-72"><a href="#cb170-72" aria-hidden="true" tabindex="-1"></a>    ledoit_wolf <span class="op">=</span> LedoitWolf().fit(schaetzzeitraum)</span>
-<span id="cb170-73"><a href="#cb170-73" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb170-74"><a href="#cb170-74" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;=&quot;</span> <span class="op">*</span> <span class="dv">78</span>)</span>
-<span id="cb170-75"><a href="#cb170-75" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;  DIE KOVARIANZ-FALLE&quot;</span>)</span>
-<span id="cb170-76"><a href="#cb170-76" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;=&quot;</span> <span class="op">*</span> <span class="dv">78</span>)</span>
-<span id="cb170-77"><a href="#cb170-77" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;</span><span class="sc">{</span>ANZAHL_ANLAGEN<span class="sc">}</span><span class="ss"> Anlagen, geschaetzt aus </span><span class="sc">{</span>BEOBACHTUNGEN_SCHAETZUNG<span class="sc">}</span><span class="ss"> &quot;</span></span>
-<span id="cb170-78"><a href="#cb170-78" aria-hidden="true" tabindex="-1"></a>          <span class="ss">f&quot;Beobachtungen.&quot;</span>)</span>
-<span id="cb170-79"><a href="#cb170-79" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;Rang der Stichprobenmatrix: &quot;</span></span>
-<span id="cb170-80"><a href="#cb170-80" aria-hidden="true" tabindex="-1"></a>          <span class="ss">f&quot;</span><span class="sc">{</span>np<span class="sc">.</span>linalg<span class="sc">.</span>matrix_rank(stichprobe)<span class="sc">}</span><span class="ss"> - noetig waeren </span><span class="sc">{</span>ANZAHL_ANLAGEN<span class="sc">}</span><span class="ss">.&quot;</span>)</span>
-<span id="cb170-81"><a href="#cb170-81" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;Kleinster Eigenwert: </span><span class="sc">{</span>np<span class="sc">.</span>linalg<span class="sc">.</span>eigvalsh(stichprobe)<span class="sc">.</span><span class="bu">min</span>()<span class="sc">:.2e}</span><span class="ss">&quot;</span>)</span>
-<span id="cb170-82"><a href="#cb170-82" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>()</span>
-<span id="cb170-83"><a href="#cb170-83" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;Es gibt also Richtungen, in denen diese Matrix EXAKT null Varianz&quot;</span>)</span>
-<span id="cb170-84"><a href="#cb170-84" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;misst. Genau dort sucht ein Minimum-Varianz-Optimierer.&quot;</span>)</span>
-<span id="cb170-85"><a href="#cb170-85" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>()</span>
-<span id="cb170-86"><a href="#cb170-86" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb170-87"><a href="#cb170-87" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;</span><span class="sc">{</span><span class="st">&#39;Schaetzer&#39;</span><span class="sc">:&lt;26}</span><span class="ss"> </span><span class="sc">{</span><span class="st">&#39;Risiko im Zeitraum&#39;</span><span class="sc">:&gt;19}</span><span class="ss"> &quot;</span></span>
-<span id="cb170-88"><a href="#cb170-88" aria-hidden="true" tabindex="-1"></a>          <span class="ss">f&quot;</span><span class="sc">{</span><span class="st">&#39;Risiko spaeter&#39;</span><span class="sc">:&gt;16}</span><span class="ss"> </span><span class="sc">{</span><span class="st">&#39;Hebel&#39;</span><span class="sc">:&gt;7}</span><span class="ss">&quot;</span>)</span>
-<span id="cb170-89"><a href="#cb170-89" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;-&quot;</span> <span class="op">*</span> <span class="dv">78</span>)</span>
-<span id="cb170-90"><a href="#cb170-90" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb170-91"><a href="#cb170-91" aria-hidden="true" tabindex="-1"></a>    ergebnisse <span class="op">=</span> {}</span>
-<span id="cb170-92"><a href="#cb170-92" aria-hidden="true" tabindex="-1"></a>    <span class="cf">for</span> name, matrix <span class="kw">in</span> [</span>
-<span id="cb170-93"><a href="#cb170-93" aria-hidden="true" tabindex="-1"></a>            (<span class="st">&quot;Stichprobe (roh)&quot;</span>, stichprobe),</span>
-<span id="cb170-94"><a href="#cb170-94" aria-hidden="true" tabindex="-1"></a>            (<span class="ss">f&quot;Ledoit-Wolf (d=</span><span class="sc">{</span>ledoit_wolf<span class="sc">.</span>shrinkage_<span class="sc">:.2f}</span><span class="ss">)&quot;</span>, ledoit_wolf.covariance_)]:</span>
-<span id="cb170-95"><a href="#cb170-95" aria-hidden="true" tabindex="-1"></a>        gewichte, varianz_intern <span class="op">=</span> minimales_risiko(matrix)</span>
-<span id="cb170-96"><a href="#cb170-96" aria-hidden="true" tabindex="-1"></a>        risiko_spaeter <span class="op">=</span> <span class="bu">float</span>(np.std(spaeterer_verlauf <span class="op">@</span> gewichte))</span>
-<span id="cb170-97"><a href="#cb170-97" aria-hidden="true" tabindex="-1"></a>        hebel <span class="op">=</span> <span class="bu">float</span>(np.<span class="bu">abs</span>(gewichte).<span class="bu">sum</span>())</span>
-<span id="cb170-98"><a href="#cb170-98" aria-hidden="true" tabindex="-1"></a>        ergebnisse[name] <span class="op">=</span> (risiko_spaeter, gewichte)</span>
-<span id="cb170-99"><a href="#cb170-99" aria-hidden="true" tabindex="-1"></a>        <span class="bu">print</span>(<span class="ss">f&quot;</span><span class="sc">{</span>name<span class="sc">:&lt;26}</span><span class="ss"> </span><span class="sc">{</span>np<span class="sc">.</span>sqrt(varianz_intern) <span class="op">*</span> <span class="dv">100</span><span class="sc">:&gt;18.3f}</span><span class="ss"> % &quot;</span></span>
-<span id="cb170-100"><a href="#cb170-100" aria-hidden="true" tabindex="-1"></a>              <span class="ss">f&quot;</span><span class="sc">{</span>risiko_spaeter <span class="op">*</span> <span class="dv">100</span><span class="sc">:&gt;15.3f}</span><span class="ss"> % </span><span class="sc">{</span>hebel<span class="sc">:&gt;7.1f}</span><span class="ss">&quot;</span>)</span>
-<span id="cb170-101"><a href="#cb170-101" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb170-102"><a href="#cb170-102" aria-hidden="true" tabindex="-1"></a>    gleich <span class="op">=</span> np.full(ANZAHL_ANLAGEN, <span class="fl">1.0</span> <span class="op">/</span> ANZAHL_ANLAGEN)</span>
-<span id="cb170-103"><a href="#cb170-103" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;</span><span class="sc">{</span><span class="st">&#39;Gleichgewichtung 1/N&#39;</span><span class="sc">:&lt;26}</span><span class="ss"> &quot;</span></span>
-<span id="cb170-104"><a href="#cb170-104" aria-hidden="true" tabindex="-1"></a>          <span class="ss">f&quot;</span><span class="sc">{</span><span class="bu">float</span>(np.std(schaetzzeitraum <span class="op">@</span> gleich)) <span class="op">*</span> <span class="dv">100</span><span class="sc">:&gt;18.3f}</span><span class="ss"> % &quot;</span></span>
-<span id="cb170-105"><a href="#cb170-105" aria-hidden="true" tabindex="-1"></a>          <span class="ss">f&quot;</span><span class="sc">{</span><span class="bu">float</span>(np.std(spaeterer_verlauf <span class="op">@</span> gleich)) <span class="op">*</span> <span class="dv">100</span><span class="sc">:&gt;15.3f}</span><span class="ss"> % </span><span class="sc">{</span><span class="fl">1.0</span><span class="sc">:&gt;7.1f}</span><span class="ss">&quot;</span>)</span>
-<span id="cb170-106"><a href="#cb170-106" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;-&quot;</span> <span class="op">*</span> <span class="dv">78</span>)</span>
-<span id="cb170-107"><a href="#cb170-107" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb170-108"><a href="#cb170-108" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;</span><span class="ch">\n</span><span class="st">Drei Beobachtungen:&quot;</span>)</span>
-<span id="cb170-109"><a href="#cb170-109" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;1. Die rohe Schaetzung meldet 0,000 % Risiko - und liefert spaeter das&quot;</span>)</span>
-<span id="cb170-110"><a href="#cb170-110" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;   SCHLECHTESTE Ergebnis der drei. Sie hat kein Portfolio optimiert,&quot;</span>)</span>
-<span id="cb170-111"><a href="#cb170-111" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;   sondern eine Luecke in den eigenen Daten gefunden.&quot;</span>)</span>
-<span id="cb170-112"><a href="#cb170-112" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;2. Die Gleichgewichtung, die gar nicht optimiert, schlaegt den rohen&quot;</span>)</span>
-<span id="cb170-113"><a href="#cb170-113" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;   Optimierer deutlich. Das ist kein Zufallsbefund, sondern in der&quot;</span>)</span>
-<span id="cb170-114"><a href="#cb170-114" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;   Literatur breit belegt.&quot;</span>)</span>
-<span id="cb170-115"><a href="#cb170-115" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;3. Ledoit-Wolf ist im Schaetzzeitraum EHRLICHER (0,441 statt 0,000 %)&quot;</span>)</span>
-<span id="cb170-116"><a href="#cb170-116" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;   und spaeter am besten. Der Hebel faellt von 3,8 auf 1,8 - das&quot;</span>)</span>
-<span id="cb170-117"><a href="#cb170-117" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;   Portfolio wird auch praktisch handelbarer.&quot;</span>)</span>
-<span id="cb170-118"><a href="#cb170-118" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>()</span>
-<span id="cb170-119"><a href="#cb170-119" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;Merksatz: Ein Optimierer glaubt seinen Eingabedaten vollstaendig.&quot;</span>)</span>
-<span id="cb170-120"><a href="#cb170-120" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;Je mehr Freiheit Sie ihm geben, desto gruendlicher findet er deren&quot;</span>)</span>
-<span id="cb170-121"><a href="#cb170-121" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;Fehler. Das gilt fuer Kovarianzmatrizen wie fuer Lieferzeiten,&quot;</span>)</span>
-<span id="cb170-122"><a href="#cb170-122" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;Ausfallraten und jede andere geschaetzte Groesse.&quot;</span>)</span>
-<span id="cb170-123"><a href="#cb170-123" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;=&quot;</span> <span class="op">*</span> <span class="dv">78</span>)</span></code></pre></div>
+<div class="sourceCode" id="cb172"><pre class="sourceCode python"><code class="sourceCode python"><span id="cb172-1"><a href="#cb172-1" aria-hidden="true" tabindex="-1"></a><span class="co">#!/usr/bin/env python3</span></span>
+<span id="cb172-2"><a href="#cb172-2" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb172-3"><a href="#cb172-3" aria-hidden="true" tabindex="-1"></a><span class="co"># Kovarianz_Falle.py</span></span>
+<span id="cb172-4"><a href="#cb172-4" aria-hidden="true" tabindex="-1"></a><span class="co">&quot;&quot;&quot;</span></span>
+<span id="cb172-5"><a href="#cb172-5" aria-hidden="true" tabindex="-1"></a><span class="co">Kapitel Finanzdaten: Warum die historische Kovarianzmatrix den Optimierer belaeugt.</span></span>
+<span id="cb172-6"><a href="#cb172-6" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb172-7"><a href="#cb172-7" aria-hidden="true" tabindex="-1"></a><span class="co">Ein Portfolio aus 30 Anlagen soll das Risiko minimieren. Geschaetzt wird die</span></span>
+<span id="cb172-8"><a href="#cb172-8" aria-hidden="true" tabindex="-1"></a><span class="co">Kovarianzmatrix aus 20 Beobachtungen - in der Praxis ein voellig ueblicher</span></span>
+<span id="cb172-9"><a href="#cb172-9" aria-hidden="true" tabindex="-1"></a><span class="co">Fall (30 Titel, ein Quartal Wochendaten).</span></span>
+<span id="cb172-10"><a href="#cb172-10" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb172-11"><a href="#cb172-11" aria-hidden="true" tabindex="-1"></a><span class="co">Das Ergebnis ist ein Portfolio mit einem gemessenen Risiko von 0,000 %. Der</span></span>
+<span id="cb172-12"><a href="#cb172-12" aria-hidden="true" tabindex="-1"></a><span class="co">Optimierer haelt es fuer risikofrei. Ausserhalb des Schaetzzeitraums ist es</span></span>
+<span id="cb172-13"><a href="#cb172-13" aria-hidden="true" tabindex="-1"></a><span class="co">das schlechteste der drei untersuchten Portfolios - schlechter sogar als</span></span>
+<span id="cb172-14"><a href="#cb172-14" aria-hidden="true" tabindex="-1"></a><span class="co">blosse Gleichgewichtung.</span></span>
+<span id="cb172-15"><a href="#cb172-15" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb172-16"><a href="#cb172-16" aria-hidden="true" tabindex="-1"></a><span class="co">Der Grund ist nicht Zufall, sondern Struktur: Bei N Anlagen und T &lt; N</span></span>
+<span id="cb172-17"><a href="#cb172-17" aria-hidden="true" tabindex="-1"></a><span class="co">Beobachtungen hat die Stichproben-Kovarianzmatrix hoechstens Rang T-1. Es gibt</span></span>
+<span id="cb172-18"><a href="#cb172-18" aria-hidden="true" tabindex="-1"></a><span class="co">dann ganze Richtungen im Gewichtsraum, in denen sie exakt null Varianz misst -</span></span>
+<span id="cb172-19"><a href="#cb172-19" aria-hidden="true" tabindex="-1"></a><span class="co">Richtungen, die es in Wirklichkeit nicht gibt. Der Optimierer findet sie</span></span>
+<span id="cb172-20"><a href="#cb172-20" aria-hidden="true" tabindex="-1"></a><span class="co">zuverlaessig, denn er sucht ja genau danach.</span></span>
+<span id="cb172-21"><a href="#cb172-21" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb172-22"><a href="#cb172-22" aria-hidden="true" tabindex="-1"></a><span class="co">Die Daten sind synthetisch (ein Marktfaktor plus Eigenrauschen), damit das</span></span>
+<span id="cb172-23"><a href="#cb172-23" aria-hidden="true" tabindex="-1"></a><span class="co">Ergebnis reproduzierbar ist und kein Internetzugang noetig wird. Mit echten</span></span>
+<span id="cb172-24"><a href="#cb172-24" aria-hidden="true" tabindex="-1"></a><span class="co">Kursdaten sieht es genauso aus.</span></span>
+<span id="cb172-25"><a href="#cb172-25" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb172-26"><a href="#cb172-26" aria-hidden="true" tabindex="-1"></a><span class="co">Benoetigt: numpy, cvxpy, scikit-learn</span></span>
+<span id="cb172-27"><a href="#cb172-27" aria-hidden="true" tabindex="-1"></a><span class="co">&quot;&quot;&quot;</span></span>
+<span id="cb172-28"><a href="#cb172-28" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb172-29"><a href="#cb172-29" aria-hidden="true" tabindex="-1"></a><span class="im">from</span> __future__ <span class="im">import</span> annotations</span>
+<span id="cb172-30"><a href="#cb172-30" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb172-31"><a href="#cb172-31" aria-hidden="true" tabindex="-1"></a><span class="im">import</span> numpy <span class="im">as</span> np</span>
+<span id="cb172-32"><a href="#cb172-32" aria-hidden="true" tabindex="-1"></a><span class="im">import</span> cvxpy <span class="im">as</span> cp</span>
+<span id="cb172-33"><a href="#cb172-33" aria-hidden="true" tabindex="-1"></a><span class="im">from</span> sklearn.covariance <span class="im">import</span> LedoitWolf</span>
+<span id="cb172-34"><a href="#cb172-34" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb172-35"><a href="#cb172-35" aria-hidden="true" tabindex="-1"></a>ANZAHL_ANLAGEN <span class="op">=</span> <span class="dv">30</span></span>
+<span id="cb172-36"><a href="#cb172-36" aria-hidden="true" tabindex="-1"></a>BEOBACHTUNGEN_SCHAETZUNG <span class="op">=</span> <span class="dv">20</span>        <span class="co"># weniger als Anlagen - genau darum geht es</span></span>
+<span id="cb172-37"><a href="#cb172-37" aria-hidden="true" tabindex="-1"></a>BEOBACHTUNGEN_TEST <span class="op">=</span> <span class="dv">2000</span>            <span class="co"># der &quot;spaetere Verlauf&quot;</span></span>
+<span id="cb172-38"><a href="#cb172-38" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb172-39"><a href="#cb172-39" aria-hidden="true" tabindex="-1"></a>RNG <span class="op">=</span> np.random.default_rng(<span class="dv">11</span>)</span>
+<span id="cb172-40"><a href="#cb172-40" aria-hidden="true" tabindex="-1"></a><span class="co"># Jede Anlage reagiert unterschiedlich stark auf den Gesamtmarkt.</span></span>
+<span id="cb172-41"><a href="#cb172-41" aria-hidden="true" tabindex="-1"></a>BETA <span class="op">=</span> RNG.uniform(<span class="fl">0.6</span>, <span class="fl">1.4</span>, ANZAHL_ANLAGEN)</span>
+<span id="cb172-42"><a href="#cb172-42" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb172-43"><a href="#cb172-43" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb172-44"><a href="#cb172-44" aria-hidden="true" tabindex="-1"></a><span class="kw">def</span> erzeuge_renditen(perioden: <span class="bu">int</span>) <span class="op">-&gt;</span> np.ndarray:</span>
+<span id="cb172-45"><a href="#cb172-45" aria-hidden="true" tabindex="-1"></a>    <span class="co">&quot;&quot;&quot;Ein Marktfaktor, auf den alle reagieren, plus Eigenrauschen je Anlage.&quot;&quot;&quot;</span></span>
+<span id="cb172-46"><a href="#cb172-46" aria-hidden="true" tabindex="-1"></a>    markt <span class="op">=</span> RNG.normal(<span class="fl">0.0</span>, <span class="fl">0.010</span>, perioden)</span>
+<span id="cb172-47"><a href="#cb172-47" aria-hidden="true" tabindex="-1"></a>    eigen <span class="op">=</span> RNG.normal(<span class="fl">0.0</span>, <span class="fl">0.012</span>, (perioden, ANZAHL_ANLAGEN))</span>
+<span id="cb172-48"><a href="#cb172-48" aria-hidden="true" tabindex="-1"></a>    <span class="cf">return</span> np.outer(markt, BETA) <span class="op">+</span> eigen</span>
+<span id="cb172-49"><a href="#cb172-49" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb172-50"><a href="#cb172-50" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb172-51"><a href="#cb172-51" aria-hidden="true" tabindex="-1"></a><span class="kw">def</span> minimales_risiko(kovarianz: np.ndarray) <span class="op">-&gt;</span> <span class="bu">tuple</span>[np.ndarray, <span class="bu">float</span>]:</span>
+<span id="cb172-52"><a href="#cb172-52" aria-hidden="true" tabindex="-1"></a>    <span class="co">&quot;&quot;&quot;Minimum-Varianz-Portfolio: Gewichte summieren sich zu 1, sonst frei.</span></span>
+<span id="cb172-53"><a href="#cb172-53" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb172-54"><a href="#cb172-54" aria-hidden="true" tabindex="-1"></a><span class="co">    cp.psd_wrap() sagt CVXPY: &#39;Ich weiss, dass diese Matrix numerisch nicht</span></span>
+<span id="cb172-55"><a href="#cb172-55" aria-hidden="true" tabindex="-1"></a><span class="co">    exakt positiv semidefinit ist - rechne trotzdem.&#39; Das ist hier bewusst so</span></span>
+<span id="cb172-56"><a href="#cb172-56" aria-hidden="true" tabindex="-1"></a><span class="co">    gewaehlt, denn genau diese Eigenschaft wollen wir vorfuehren. Im</span></span>
+<span id="cb172-57"><a href="#cb172-57" aria-hidden="true" tabindex="-1"></a><span class="co">    Produktivbetrieb waere die DCP-Fehlermeldung das Warnsignal, dem man</span></span>
+<span id="cb172-58"><a href="#cb172-58" aria-hidden="true" tabindex="-1"></a><span class="co">    nachgehen muss (siehe den Denkfehler im Kapitel Quadratische und</span></span>
+<span id="cb172-59"><a href="#cb172-59" aria-hidden="true" tabindex="-1"></a><span class="co">    nichtlineare Optimierung).</span></span>
+<span id="cb172-60"><a href="#cb172-60" aria-hidden="true" tabindex="-1"></a><span class="co">    &quot;&quot;&quot;</span></span>
+<span id="cb172-61"><a href="#cb172-61" aria-hidden="true" tabindex="-1"></a>    gewichte <span class="op">=</span> cp.Variable(ANZAHL_ANLAGEN)</span>
+<span id="cb172-62"><a href="#cb172-62" aria-hidden="true" tabindex="-1"></a>    problem <span class="op">=</span> cp.Problem(cp.Minimize(cp.quad_form(gewichte, cp.psd_wrap(kovarianz))),</span>
+<span id="cb172-63"><a href="#cb172-63" aria-hidden="true" tabindex="-1"></a>                         [cp.<span class="bu">sum</span>(gewichte) <span class="op">==</span> <span class="dv">1</span>])</span>
+<span id="cb172-64"><a href="#cb172-64" aria-hidden="true" tabindex="-1"></a>    problem.solve()</span>
+<span id="cb172-65"><a href="#cb172-65" aria-hidden="true" tabindex="-1"></a>    <span class="cf">return</span> np.array(gewichte.value).ravel(), <span class="bu">max</span>(problem.value, <span class="fl">0.0</span>)</span>
+<span id="cb172-66"><a href="#cb172-66" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb172-67"><a href="#cb172-67" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb172-68"><a href="#cb172-68" aria-hidden="true" tabindex="-1"></a><span class="cf">if</span> <span class="va">__name__</span> <span class="op">==</span> <span class="st">&quot;__main__&quot;</span>:</span>
+<span id="cb172-69"><a href="#cb172-69" aria-hidden="true" tabindex="-1"></a>    schaetzzeitraum <span class="op">=</span> erzeuge_renditen(BEOBACHTUNGEN_SCHAETZUNG)</span>
+<span id="cb172-70"><a href="#cb172-70" aria-hidden="true" tabindex="-1"></a>    spaeterer_verlauf <span class="op">=</span> erzeuge_renditen(BEOBACHTUNGEN_TEST)</span>
+<span id="cb172-71"><a href="#cb172-71" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb172-72"><a href="#cb172-72" aria-hidden="true" tabindex="-1"></a>    stichprobe <span class="op">=</span> np.cov(schaetzzeitraum, rowvar<span class="op">=</span><span class="va">False</span>)</span>
+<span id="cb172-73"><a href="#cb172-73" aria-hidden="true" tabindex="-1"></a>    ledoit_wolf <span class="op">=</span> LedoitWolf().fit(schaetzzeitraum)</span>
+<span id="cb172-74"><a href="#cb172-74" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb172-75"><a href="#cb172-75" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;=&quot;</span> <span class="op">*</span> <span class="dv">78</span>)</span>
+<span id="cb172-76"><a href="#cb172-76" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;  DIE KOVARIANZ-FALLE&quot;</span>)</span>
+<span id="cb172-77"><a href="#cb172-77" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;=&quot;</span> <span class="op">*</span> <span class="dv">78</span>)</span>
+<span id="cb172-78"><a href="#cb172-78" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;</span><span class="sc">{</span>ANZAHL_ANLAGEN<span class="sc">}</span><span class="ss"> Anlagen, geschaetzt aus </span><span class="sc">{</span>BEOBACHTUNGEN_SCHAETZUNG<span class="sc">}</span><span class="ss"> &quot;</span></span>
+<span id="cb172-79"><a href="#cb172-79" aria-hidden="true" tabindex="-1"></a>          <span class="ss">f&quot;Beobachtungen.&quot;</span>)</span>
+<span id="cb172-80"><a href="#cb172-80" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;Rang der Stichprobenmatrix: &quot;</span></span>
+<span id="cb172-81"><a href="#cb172-81" aria-hidden="true" tabindex="-1"></a>          <span class="ss">f&quot;</span><span class="sc">{</span>np<span class="sc">.</span>linalg<span class="sc">.</span>matrix_rank(stichprobe)<span class="sc">}</span><span class="ss"> - noetig waeren </span><span class="sc">{</span>ANZAHL_ANLAGEN<span class="sc">}</span><span class="ss">.&quot;</span>)</span>
+<span id="cb172-82"><a href="#cb172-82" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;Kleinster Eigenwert: </span><span class="sc">{</span>np<span class="sc">.</span>linalg<span class="sc">.</span>eigvalsh(stichprobe)<span class="sc">.</span><span class="bu">min</span>()<span class="sc">:.2e}</span><span class="ss">&quot;</span>)</span>
+<span id="cb172-83"><a href="#cb172-83" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>()</span>
+<span id="cb172-84"><a href="#cb172-84" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;Es gibt also Richtungen, in denen diese Matrix EXAKT null Varianz&quot;</span>)</span>
+<span id="cb172-85"><a href="#cb172-85" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;misst. Genau dort sucht ein Minimum-Varianz-Optimierer.&quot;</span>)</span>
+<span id="cb172-86"><a href="#cb172-86" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>()</span>
+<span id="cb172-87"><a href="#cb172-87" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb172-88"><a href="#cb172-88" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;</span><span class="sc">{</span><span class="st">&#39;Schaetzer&#39;</span><span class="sc">:&lt;26}</span><span class="ss"> </span><span class="sc">{</span><span class="st">&#39;Risiko im Zeitraum&#39;</span><span class="sc">:&gt;19}</span><span class="ss"> &quot;</span></span>
+<span id="cb172-89"><a href="#cb172-89" aria-hidden="true" tabindex="-1"></a>          <span class="ss">f&quot;</span><span class="sc">{</span><span class="st">&#39;Risiko spaeter&#39;</span><span class="sc">:&gt;16}</span><span class="ss"> </span><span class="sc">{</span><span class="st">&#39;Hebel&#39;</span><span class="sc">:&gt;7}</span><span class="ss">&quot;</span>)</span>
+<span id="cb172-90"><a href="#cb172-90" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;-&quot;</span> <span class="op">*</span> <span class="dv">78</span>)</span>
+<span id="cb172-91"><a href="#cb172-91" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb172-92"><a href="#cb172-92" aria-hidden="true" tabindex="-1"></a>    ergebnisse <span class="op">=</span> {}</span>
+<span id="cb172-93"><a href="#cb172-93" aria-hidden="true" tabindex="-1"></a>    <span class="cf">for</span> name, matrix <span class="kw">in</span> [</span>
+<span id="cb172-94"><a href="#cb172-94" aria-hidden="true" tabindex="-1"></a>            (<span class="st">&quot;Stichprobe (roh)&quot;</span>, stichprobe),</span>
+<span id="cb172-95"><a href="#cb172-95" aria-hidden="true" tabindex="-1"></a>            (<span class="ss">f&quot;Ledoit-Wolf (d=</span><span class="sc">{</span>ledoit_wolf<span class="sc">.</span>shrinkage_<span class="sc">:.2f}</span><span class="ss">)&quot;</span>, ledoit_wolf.covariance_)]:</span>
+<span id="cb172-96"><a href="#cb172-96" aria-hidden="true" tabindex="-1"></a>        gewichte, varianz_intern <span class="op">=</span> minimales_risiko(matrix)</span>
+<span id="cb172-97"><a href="#cb172-97" aria-hidden="true" tabindex="-1"></a>        risiko_spaeter <span class="op">=</span> <span class="bu">float</span>(np.std(spaeterer_verlauf <span class="op">@</span> gewichte))</span>
+<span id="cb172-98"><a href="#cb172-98" aria-hidden="true" tabindex="-1"></a>        hebel <span class="op">=</span> <span class="bu">float</span>(np.<span class="bu">abs</span>(gewichte).<span class="bu">sum</span>())</span>
+<span id="cb172-99"><a href="#cb172-99" aria-hidden="true" tabindex="-1"></a>        ergebnisse[name] <span class="op">=</span> (risiko_spaeter, gewichte)</span>
+<span id="cb172-100"><a href="#cb172-100" aria-hidden="true" tabindex="-1"></a>        <span class="bu">print</span>(<span class="ss">f&quot;</span><span class="sc">{</span>name<span class="sc">:&lt;26}</span><span class="ss"> </span><span class="sc">{</span>np<span class="sc">.</span>sqrt(varianz_intern) <span class="op">*</span> <span class="dv">100</span><span class="sc">:&gt;18.3f}</span><span class="ss"> % &quot;</span></span>
+<span id="cb172-101"><a href="#cb172-101" aria-hidden="true" tabindex="-1"></a>              <span class="ss">f&quot;</span><span class="sc">{</span>risiko_spaeter <span class="op">*</span> <span class="dv">100</span><span class="sc">:&gt;15.3f}</span><span class="ss"> % </span><span class="sc">{</span>hebel<span class="sc">:&gt;7.1f}</span><span class="ss">&quot;</span>)</span>
+<span id="cb172-102"><a href="#cb172-102" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb172-103"><a href="#cb172-103" aria-hidden="true" tabindex="-1"></a>    gleich <span class="op">=</span> np.full(ANZAHL_ANLAGEN, <span class="fl">1.0</span> <span class="op">/</span> ANZAHL_ANLAGEN)</span>
+<span id="cb172-104"><a href="#cb172-104" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;</span><span class="sc">{</span><span class="st">&#39;Gleichgewichtung 1/N&#39;</span><span class="sc">:&lt;26}</span><span class="ss"> &quot;</span></span>
+<span id="cb172-105"><a href="#cb172-105" aria-hidden="true" tabindex="-1"></a>          <span class="ss">f&quot;</span><span class="sc">{</span><span class="bu">float</span>(np.std(schaetzzeitraum <span class="op">@</span> gleich)) <span class="op">*</span> <span class="dv">100</span><span class="sc">:&gt;18.3f}</span><span class="ss"> % &quot;</span></span>
+<span id="cb172-106"><a href="#cb172-106" aria-hidden="true" tabindex="-1"></a>          <span class="ss">f&quot;</span><span class="sc">{</span><span class="bu">float</span>(np.std(spaeterer_verlauf <span class="op">@</span> gleich)) <span class="op">*</span> <span class="dv">100</span><span class="sc">:&gt;15.3f}</span><span class="ss"> % </span><span class="sc">{</span><span class="fl">1.0</span><span class="sc">:&gt;7.1f}</span><span class="ss">&quot;</span>)</span>
+<span id="cb172-107"><a href="#cb172-107" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;-&quot;</span> <span class="op">*</span> <span class="dv">78</span>)</span>
+<span id="cb172-108"><a href="#cb172-108" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb172-109"><a href="#cb172-109" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;</span><span class="ch">\n</span><span class="st">Drei Beobachtungen:&quot;</span>)</span>
+<span id="cb172-110"><a href="#cb172-110" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;1. Die rohe Schaetzung meldet 0,000 % Risiko - und liefert spaeter das&quot;</span>)</span>
+<span id="cb172-111"><a href="#cb172-111" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;   SCHLECHTESTE Ergebnis der drei. Sie hat kein Portfolio optimiert,&quot;</span>)</span>
+<span id="cb172-112"><a href="#cb172-112" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;   sondern eine Luecke in den eigenen Daten gefunden.&quot;</span>)</span>
+<span id="cb172-113"><a href="#cb172-113" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;2. Die Gleichgewichtung, die gar nicht optimiert, schlaegt den rohen&quot;</span>)</span>
+<span id="cb172-114"><a href="#cb172-114" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;   Optimierer deutlich. Das ist kein Zufallsbefund, sondern in der&quot;</span>)</span>
+<span id="cb172-115"><a href="#cb172-115" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;   Literatur breit belegt.&quot;</span>)</span>
+<span id="cb172-116"><a href="#cb172-116" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;3. Ledoit-Wolf ist im Schaetzzeitraum EHRLICHER (0,441 statt 0,000 %)&quot;</span>)</span>
+<span id="cb172-117"><a href="#cb172-117" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;   und spaeter am besten. Der Hebel faellt von 3,8 auf 1,8 - das&quot;</span>)</span>
+<span id="cb172-118"><a href="#cb172-118" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;   Portfolio wird auch praktisch handelbarer.&quot;</span>)</span>
+<span id="cb172-119"><a href="#cb172-119" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>()</span>
+<span id="cb172-120"><a href="#cb172-120" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;Merksatz: Ein Optimierer glaubt seinen Eingabedaten vollstaendig.&quot;</span>)</span>
+<span id="cb172-121"><a href="#cb172-121" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;Je mehr Freiheit Sie ihm geben, desto gruendlicher findet er deren&quot;</span>)</span>
+<span id="cb172-122"><a href="#cb172-122" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;Fehler. Das gilt fuer Kovarianzmatrizen wie fuer Lieferzeiten,&quot;</span>)</span>
+<span id="cb172-123"><a href="#cb172-123" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;Ausfallraten und jede andere geschaetzte Groesse.&quot;</span>)</span>
+<span id="cb172-124"><a href="#cb172-124" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;=&quot;</span> <span class="op">*</span> <span class="dv">78</span>)</span></code></pre></div>
 <p><strong>Erwartete Ausgabe:</strong></p>
 <pre><code>==============================================================================
   DIE KOVARIANZ-FALLE
@@ -22007,7 +22983,7 @@ Ausfallraten und jede andere geschaetzte Groesse.
 <hr />
 <h2 id="sec:finanzdaten-quiz">18.9 Micro-Quiz</h2>
 <blockquote>
-<p><strong>❓ Micro-Quiz 11: Drei Fragen zum Selbstcheck</strong></p>
+<p><strong>❓ Micro-Quiz 18: Drei Fragen zum Selbstcheck</strong></p>
 <p>Genau eine Antwort ist jeweils richtig. Auflösung in <a href="#quiz-loesung-finanzdaten">Anhang A</a>.</p>
 <p><strong>1. Ein Kurs fällt um 50 % und steigt danach um 50 %. Wo steht er?</strong> (a) Wieder beim Ausgangswert — die Prozente heben sich auf. (b) Bei 75 % des Ausgangswerts. Diskrete Renditen verknüpfen sich multiplikativ, nicht additiv: <span class="math inline">1{,}0 \cdot 0{,}5 \cdot 1{,}5 = 0{,}75</span>. (c) Bei 25 % des Ausgangswerts.</p>
 <p><strong>2. Wofür nimmt man logarithmische Renditen, wofür diskrete?</strong> (a) Logarithmische sind grundsätzlich genauer und daher immer vorzuziehen. (b) Logarithmische addieren sich über die <strong>Zeit</strong>, diskrete über die <strong>Anlagen</strong> eines Portfolios. Man wählt nach der Richtung, in der summiert wird. (c) Diskrete für kurze, logarithmische für lange Zeiträume.</p>
@@ -22086,24 +23062,24 @@ Ausfallraten und jede andere geschaetzte Groesse.
 </tbody>
 </table>
 <p>Statt <em>einer</em> Antwort rechnen wir gleich die <strong>ganze Auswahl</strong> durch — für jede Zielrendite das Portfolio mit dem geringsten Risiko:</p>
-<div class="sourceCode" id="cb172"><pre class="sourceCode python"><code class="sourceCode python"><span id="cb172-1"><a href="#cb172-1" aria-hidden="true" tabindex="-1"></a><span class="im">import</span> numpy <span class="im">as</span> np</span>
-<span id="cb172-2"><a href="#cb172-2" aria-hidden="true" tabindex="-1"></a><span class="im">import</span> cvxpy <span class="im">as</span> cp</span>
-<span id="cb172-3"><a href="#cb172-3" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb172-4"><a href="#cb172-4" aria-hidden="true" tabindex="-1"></a>mu <span class="op">=</span> np.array([<span class="fl">0.03</span>, <span class="fl">0.08</span>, <span class="fl">0.055</span>])                    <span class="co"># erwartete Rendite</span></span>
-<span id="cb172-5"><a href="#cb172-5" aria-hidden="true" tabindex="-1"></a>sig <span class="op">=</span> np.array([<span class="fl">0.05</span>, <span class="fl">0.18</span>, <span class="fl">0.11</span>])                    <span class="co"># Schwankung</span></span>
-<span id="cb172-6"><a href="#cb172-6" aria-hidden="true" tabindex="-1"></a>R <span class="op">=</span> np.array([[<span class="fl">1.0</span>, <span class="fl">0.1</span>, <span class="fl">0.2</span>], [<span class="fl">0.1</span>, <span class="fl">1.0</span>, <span class="fl">0.5</span>], [<span class="fl">0.2</span>, <span class="fl">0.5</span>, <span class="fl">1.0</span>]])</span>
-<span id="cb172-7"><a href="#cb172-7" aria-hidden="true" tabindex="-1"></a>S <span class="op">=</span> np.outer(sig, sig) <span class="op">*</span> R                            <span class="co"># Kovarianzmatrix</span></span>
-<span id="cb172-8"><a href="#cb172-8" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb172-9"><a href="#cb172-9" aria-hidden="true" tabindex="-1"></a>w, ziel <span class="op">=</span> cp.Variable(<span class="dv">3</span>, nonneg<span class="op">=</span><span class="va">True</span>), cp.Parameter(nonneg<span class="op">=</span><span class="va">True</span>)</span>
-<span id="cb172-10"><a href="#cb172-10" aria-hidden="true" tabindex="-1"></a>problem <span class="op">=</span> cp.Problem(cp.Minimize(cp.quad_form(w, S)),</span>
-<span id="cb172-11"><a href="#cb172-11" aria-hidden="true" tabindex="-1"></a>                     [cp.<span class="bu">sum</span>(w) <span class="op">==</span> <span class="dv">1</span>, mu <span class="op">@</span> w <span class="op">&gt;=</span> ziel])</span>
-<span id="cb172-12"><a href="#cb172-12" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb172-13"><a href="#cb172-13" aria-hidden="true" tabindex="-1"></a><span class="cf">for</span> z <span class="kw">in</span> [<span class="fl">0.03</span>, <span class="fl">0.04</span>, <span class="fl">0.05</span>, <span class="fl">0.06</span>, <span class="fl">0.07</span>, <span class="fl">0.08</span>]:</span>
-<span id="cb172-14"><a href="#cb172-14" aria-hidden="true" tabindex="-1"></a>    ziel.value <span class="op">=</span> z</span>
-<span id="cb172-15"><a href="#cb172-15" aria-hidden="true" tabindex="-1"></a>    problem.solve()</span>
-<span id="cb172-16"><a href="#cb172-16" aria-hidden="true" tabindex="-1"></a>    risiko <span class="op">=</span> np.sqrt(problem.value)</span>
-<span id="cb172-17"><a href="#cb172-17" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;</span><span class="sc">{</span>z<span class="op">*</span><span class="dv">100</span><span class="sc">:5.1f}</span><span class="ss">% </span><span class="sc">{</span>risiko<span class="op">*</span><span class="dv">100</span><span class="sc">:7.2f}</span><span class="ss">% </span><span class="sc">{</span>(mu <span class="op">@</span> w.value)<span class="op">/</span>risiko<span class="sc">:8.2f}</span><span class="ss">   &quot;</span></span>
-<span id="cb172-18"><a href="#cb172-18" aria-hidden="true" tabindex="-1"></a>          <span class="ss">f&quot;</span><span class="sc">{</span>np<span class="sc">.</span><span class="bu">round</span>(w.value, <span class="dv">3</span>)<span class="sc">}</span><span class="ss">&quot;</span>)</span></code></pre></div>
+<div class="sourceCode" id="cb174"><pre class="sourceCode python"><code class="sourceCode python"><span id="cb174-1"><a href="#cb174-1" aria-hidden="true" tabindex="-1"></a><span class="im">import</span> numpy <span class="im">as</span> np</span>
+<span id="cb174-2"><a href="#cb174-2" aria-hidden="true" tabindex="-1"></a><span class="im">import</span> cvxpy <span class="im">as</span> cp</span>
+<span id="cb174-3"><a href="#cb174-3" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb174-4"><a href="#cb174-4" aria-hidden="true" tabindex="-1"></a>mu <span class="op">=</span> np.array([<span class="fl">0.03</span>, <span class="fl">0.08</span>, <span class="fl">0.055</span>])                    <span class="co"># erwartete Rendite</span></span>
+<span id="cb174-5"><a href="#cb174-5" aria-hidden="true" tabindex="-1"></a>sig <span class="op">=</span> np.array([<span class="fl">0.05</span>, <span class="fl">0.18</span>, <span class="fl">0.11</span>])                    <span class="co"># Schwankung</span></span>
+<span id="cb174-6"><a href="#cb174-6" aria-hidden="true" tabindex="-1"></a>R <span class="op">=</span> np.array([[<span class="fl">1.0</span>, <span class="fl">0.1</span>, <span class="fl">0.2</span>], [<span class="fl">0.1</span>, <span class="fl">1.0</span>, <span class="fl">0.5</span>], [<span class="fl">0.2</span>, <span class="fl">0.5</span>, <span class="fl">1.0</span>]])</span>
+<span id="cb174-7"><a href="#cb174-7" aria-hidden="true" tabindex="-1"></a>S <span class="op">=</span> np.outer(sig, sig) <span class="op">*</span> R                            <span class="co"># Kovarianzmatrix</span></span>
+<span id="cb174-8"><a href="#cb174-8" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb174-9"><a href="#cb174-9" aria-hidden="true" tabindex="-1"></a>w, ziel <span class="op">=</span> cp.Variable(<span class="dv">3</span>, nonneg<span class="op">=</span><span class="va">True</span>), cp.Parameter(nonneg<span class="op">=</span><span class="va">True</span>)</span>
+<span id="cb174-10"><a href="#cb174-10" aria-hidden="true" tabindex="-1"></a>problem <span class="op">=</span> cp.Problem(cp.Minimize(cp.quad_form(w, S)),</span>
+<span id="cb174-11"><a href="#cb174-11" aria-hidden="true" tabindex="-1"></a>                     [cp.<span class="bu">sum</span>(w) <span class="op">==</span> <span class="dv">1</span>, mu <span class="op">@</span> w <span class="op">&gt;=</span> ziel])</span>
+<span id="cb174-12"><a href="#cb174-12" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb174-13"><a href="#cb174-13" aria-hidden="true" tabindex="-1"></a><span class="cf">for</span> z <span class="kw">in</span> [<span class="fl">0.03</span>, <span class="fl">0.04</span>, <span class="fl">0.05</span>, <span class="fl">0.06</span>, <span class="fl">0.07</span>, <span class="fl">0.08</span>]:</span>
+<span id="cb174-14"><a href="#cb174-14" aria-hidden="true" tabindex="-1"></a>    ziel.value <span class="op">=</span> z</span>
+<span id="cb174-15"><a href="#cb174-15" aria-hidden="true" tabindex="-1"></a>    problem.solve()</span>
+<span id="cb174-16"><a href="#cb174-16" aria-hidden="true" tabindex="-1"></a>    risiko <span class="op">=</span> np.sqrt(problem.value)</span>
+<span id="cb174-17"><a href="#cb174-17" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;</span><span class="sc">{</span>z<span class="op">*</span><span class="dv">100</span><span class="sc">:5.1f}</span><span class="ss">% </span><span class="sc">{</span>risiko<span class="op">*</span><span class="dv">100</span><span class="sc">:7.2f}</span><span class="ss">% </span><span class="sc">{</span>(mu <span class="op">@</span> w.value)<span class="op">/</span>risiko<span class="sc">:8.2f}</span><span class="ss">   &quot;</span></span>
+<span id="cb174-18"><a href="#cb174-18" aria-hidden="true" tabindex="-1"></a>          <span class="ss">f&quot;</span><span class="sc">{</span>np<span class="sc">.</span><span class="bu">round</span>(w.value, <span class="dv">3</span>)<span class="sc">}</span><span class="ss">&quot;</span>)</span></code></pre></div>
 <p><strong>Ausgabe</strong> (Zielrendite, Risiko, Rendite-je-Risiko, Gewichte):</p>
 <pre><code>  3.0%    4.83%     0.69   [0.884 0.017 0.098]
   4.0%    5.35%     0.75   [0.711 0.111 0.178]
@@ -22191,53 +23167,53 @@ Ausfallraten und jede andere geschaetzte Groesse.
 <p><strong>Die Kehrseite:</strong> In Krisen steigen Korrelationen. Ein Portfolio, dessen Diversifikation auf <span class="math inline">\rho = 0{,}2</span> beruht, kann bei <span class="math inline">\rho \to 0{,}9</span> plötzlich fast unkorrelierte Absicherung verlieren — genau dann, wenn man sie braucht. <a href="#kap-cvar">Kapitel 20</a> und <a href="#kap-praxisfallen">Kapitel 22</a> kommen darauf zurück.</p>
 </blockquote>
 <p>Die Tabelle aus der Handrechnung <em>Das Gratis-Mittagessen in Zahlen</em> lässt sich auf zwei unabhängigen Wegen prüfen: über die <strong>analytische Formel</strong> und über eine <strong>Simulation</strong> korrelierter Renditepaare, die von der Formel nichts weiß.</p>
-<div class="sourceCode" id="cb174"><pre class="sourceCode python"><code class="sourceCode python"><span id="cb174-1"><a href="#cb174-1" aria-hidden="true" tabindex="-1"></a><span class="co">#!/usr/bin/env python3</span></span>
-<span id="cb174-2"><a href="#cb174-2" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb174-3"><a href="#cb174-3" aria-hidden="true" tabindex="-1"></a><span class="co"># Diversifikation_Demo.py</span></span>
-<span id="cb174-4"><a href="#cb174-4" aria-hidden="true" tabindex="-1"></a><span class="co">&quot;&quot;&quot;</span></span>
-<span id="cb174-5"><a href="#cb174-5" aria-hidden="true" tabindex="-1"></a><span class="co">Kapitel Markowitz: Portfoliorisiko in Abhaengigkeit von der Korrelation - die</span></span>
-<span id="cb174-6"><a href="#cb174-6" aria-hidden="true" tabindex="-1"></a><span class="co">Handrechnung zum Gratis-Mittagessen, geprueft ueber die analytische Formel und</span></span>
-<span id="cb174-7"><a href="#cb174-7" aria-hidden="true" tabindex="-1"></a><span class="co">ueber simulierte, korrelierte Renditen.</span></span>
-<span id="cb174-8"><a href="#cb174-8" aria-hidden="true" tabindex="-1"></a><span class="co">&quot;&quot;&quot;</span></span>
-<span id="cb174-9"><a href="#cb174-9" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb174-10"><a href="#cb174-10" aria-hidden="true" tabindex="-1"></a><span class="im">import</span> numpy <span class="im">as</span> np</span>
-<span id="cb174-11"><a href="#cb174-11" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb174-12"><a href="#cb174-12" aria-hidden="true" tabindex="-1"></a>MU <span class="op">=</span> <span class="fl">0.08</span></span>
-<span id="cb174-13"><a href="#cb174-13" aria-hidden="true" tabindex="-1"></a>SIGMA <span class="op">=</span> <span class="fl">0.20</span></span>
-<span id="cb174-14"><a href="#cb174-14" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb174-15"><a href="#cb174-15" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb174-16"><a href="#cb174-16" aria-hidden="true" tabindex="-1"></a><span class="kw">def</span> sigma_portfolio(rho: <span class="bu">float</span>, w1: <span class="bu">float</span> <span class="op">=</span> <span class="fl">0.5</span>) <span class="op">-&gt;</span> <span class="bu">float</span>:</span>
-<span id="cb174-17"><a href="#cb174-17" aria-hidden="true" tabindex="-1"></a>    <span class="co">&quot;&quot;&quot;Analytische Formel: sigma_p^2 = w1^2 s1^2 + w2^2 s2^2 + 2 w1 w2 rho s1 s2.&quot;&quot;&quot;</span></span>
-<span id="cb174-18"><a href="#cb174-18" aria-hidden="true" tabindex="-1"></a>    w2 <span class="op">=</span> <span class="dv">1</span> <span class="op">-</span> w1</span>
-<span id="cb174-19"><a href="#cb174-19" aria-hidden="true" tabindex="-1"></a>    varianz <span class="op">=</span> w1<span class="op">**</span><span class="dv">2</span> <span class="op">*</span> SIGMA<span class="op">**</span><span class="dv">2</span> <span class="op">+</span> w2<span class="op">**</span><span class="dv">2</span> <span class="op">*</span> SIGMA<span class="op">**</span><span class="dv">2</span> <span class="op">+</span> <span class="dv">2</span> <span class="op">*</span> w1 <span class="op">*</span> w2 <span class="op">*</span> rho <span class="op">*</span> SIGMA<span class="op">**</span><span class="dv">2</span></span>
-<span id="cb174-20"><a href="#cb174-20" aria-hidden="true" tabindex="-1"></a>    <span class="cf">return</span> <span class="bu">float</span>(np.sqrt(varianz))</span>
-<span id="cb174-21"><a href="#cb174-21" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb174-22"><a href="#cb174-22" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb174-23"><a href="#cb174-23" aria-hidden="true" tabindex="-1"></a><span class="kw">def</span> simuliere(rho: <span class="bu">float</span>, n: <span class="bu">int</span> <span class="op">=</span> <span class="dv">500_000</span>, seed: <span class="bu">int</span> <span class="op">=</span> <span class="dv">7</span>) <span class="op">-&gt;</span> <span class="bu">float</span>:</span>
-<span id="cb174-24"><a href="#cb174-24" aria-hidden="true" tabindex="-1"></a>    <span class="co">&quot;&quot;&quot;Erzeugt n korrelierte Renditepaare und misst die Portfolio-Volatilitaet empirisch.&quot;&quot;&quot;</span></span>
-<span id="cb174-25"><a href="#cb174-25" aria-hidden="true" tabindex="-1"></a>    rng <span class="op">=</span> np.random.default_rng(seed)</span>
-<span id="cb174-26"><a href="#cb174-26" aria-hidden="true" tabindex="-1"></a>    kovarianz <span class="op">=</span> np.array([[SIGMA<span class="op">**</span><span class="dv">2</span>, rho <span class="op">*</span> SIGMA<span class="op">**</span><span class="dv">2</span>],</span>
-<span id="cb174-27"><a href="#cb174-27" aria-hidden="true" tabindex="-1"></a>                           [rho <span class="op">*</span> SIGMA<span class="op">**</span><span class="dv">2</span>, SIGMA<span class="op">**</span><span class="dv">2</span>]])</span>
-<span id="cb174-28"><a href="#cb174-28" aria-hidden="true" tabindex="-1"></a>    renditen <span class="op">=</span> rng.multivariate_normal([MU, MU], kovarianz, size<span class="op">=</span>n)</span>
-<span id="cb174-29"><a href="#cb174-29" aria-hidden="true" tabindex="-1"></a>    portfolio <span class="op">=</span> <span class="fl">0.5</span> <span class="op">*</span> renditen[:, <span class="dv">0</span>] <span class="op">+</span> <span class="fl">0.5</span> <span class="op">*</span> renditen[:, <span class="dv">1</span>]</span>
-<span id="cb174-30"><a href="#cb174-30" aria-hidden="true" tabindex="-1"></a>    <span class="cf">return</span> <span class="bu">float</span>(portfolio.std(ddof<span class="op">=</span><span class="dv">1</span>))</span>
-<span id="cb174-31"><a href="#cb174-31" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb174-32"><a href="#cb174-32" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb174-33"><a href="#cb174-33" aria-hidden="true" tabindex="-1"></a><span class="cf">if</span> <span class="va">__name__</span> <span class="op">==</span> <span class="st">&quot;__main__&quot;</span>:</span>
-<span id="cb174-34"><a href="#cb174-34" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;=&quot;</span> <span class="op">*</span> <span class="dv">78</span>)</span>
-<span id="cb174-35"><a href="#cb174-35" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;  PORTFOLIORISIKO IN ABHAENGIGKEIT VON DER KORRELATION&quot;</span>)</span>
-<span id="cb174-36"><a href="#cb174-36" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;=&quot;</span> <span class="op">*</span> <span class="dv">78</span>)</span>
-<span id="cb174-37"><a href="#cb174-37" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;</span><span class="sc">{</span><span class="st">&#39;rho&#39;</span><span class="sc">:&gt;6}</span><span class="ss"> | </span><span class="sc">{</span><span class="st">&#39;sigma_p (Formel)&#39;</span><span class="sc">:&gt;18}</span><span class="ss"> | </span><span class="sc">{</span><span class="st">&#39;sigma_p (Simulation)&#39;</span><span class="sc">:&gt;20}</span><span class="ss"> | </span><span class="sc">{</span><span class="st">&#39;Risikoreduktion&#39;</span><span class="sc">:&gt;16}</span><span class="ss">&quot;</span>)</span>
-<span id="cb174-38"><a href="#cb174-38" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;-&quot;</span> <span class="op">*</span> <span class="dv">78</span>)</span>
-<span id="cb174-39"><a href="#cb174-39" aria-hidden="true" tabindex="-1"></a>    <span class="cf">for</span> rho <span class="kw">in</span> [<span class="fl">1.0</span>, <span class="fl">0.5</span>, <span class="fl">0.0</span>, <span class="op">-</span><span class="fl">0.5</span>, <span class="op">-</span><span class="fl">1.0</span>]:</span>
-<span id="cb174-40"><a href="#cb174-40" aria-hidden="true" tabindex="-1"></a>        formel <span class="op">=</span> sigma_portfolio(rho)</span>
-<span id="cb174-41"><a href="#cb174-41" aria-hidden="true" tabindex="-1"></a>        sim <span class="op">=</span> simuliere(rho)</span>
-<span id="cb174-42"><a href="#cb174-42" aria-hidden="true" tabindex="-1"></a>        reduktion <span class="op">=</span> (<span class="dv">1</span> <span class="op">-</span> formel <span class="op">/</span> SIGMA) <span class="op">*</span> <span class="dv">100</span></span>
-<span id="cb174-43"><a href="#cb174-43" aria-hidden="true" tabindex="-1"></a>        <span class="bu">print</span>(<span class="ss">f&quot;</span><span class="sc">{</span>rho<span class="sc">:6.1f}</span><span class="ss"> | </span><span class="sc">{</span>formel<span class="op">*</span><span class="dv">100</span><span class="sc">:16.2f}</span><span class="ss"> % | </span><span class="sc">{</span>sim<span class="op">*</span><span class="dv">100</span><span class="sc">:18.2f}</span><span class="ss"> % | </span><span class="sc">{</span>reduktion<span class="sc">:14.0f}</span><span class="ss"> %&quot;</span>)</span>
-<span id="cb174-44"><a href="#cb174-44" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb174-45"><a href="#cb174-45" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;</span><span class="ch">\n</span><span class="st">Die simulierten Werte (500.000 gezogene Renditepaare je rho) bestaetigen&quot;</span>)</span>
-<span id="cb174-46"><a href="#cb174-46" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;die Formel aus der Handrechnung bis auf statistisches Rauschen - und das,&quot;</span>)</span>
-<span id="cb174-47"><a href="#cb174-47" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;obwohl Formel und Simulation nichts voneinander wissen.&quot;</span>)</span></code></pre></div>
+<div class="sourceCode" id="cb176"><pre class="sourceCode python"><code class="sourceCode python"><span id="cb176-1"><a href="#cb176-1" aria-hidden="true" tabindex="-1"></a><span class="co">#!/usr/bin/env python3</span></span>
+<span id="cb176-2"><a href="#cb176-2" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb176-3"><a href="#cb176-3" aria-hidden="true" tabindex="-1"></a><span class="co"># Diversifikation_Demo.py</span></span>
+<span id="cb176-4"><a href="#cb176-4" aria-hidden="true" tabindex="-1"></a><span class="co">&quot;&quot;&quot;</span></span>
+<span id="cb176-5"><a href="#cb176-5" aria-hidden="true" tabindex="-1"></a><span class="co">Kapitel Markowitz: Portfoliorisiko in Abhaengigkeit von der Korrelation - die</span></span>
+<span id="cb176-6"><a href="#cb176-6" aria-hidden="true" tabindex="-1"></a><span class="co">Handrechnung zum Gratis-Mittagessen, geprueft ueber die analytische Formel und</span></span>
+<span id="cb176-7"><a href="#cb176-7" aria-hidden="true" tabindex="-1"></a><span class="co">ueber simulierte, korrelierte Renditen.</span></span>
+<span id="cb176-8"><a href="#cb176-8" aria-hidden="true" tabindex="-1"></a><span class="co">&quot;&quot;&quot;</span></span>
+<span id="cb176-9"><a href="#cb176-9" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb176-10"><a href="#cb176-10" aria-hidden="true" tabindex="-1"></a><span class="im">import</span> numpy <span class="im">as</span> np</span>
+<span id="cb176-11"><a href="#cb176-11" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb176-12"><a href="#cb176-12" aria-hidden="true" tabindex="-1"></a>MU <span class="op">=</span> <span class="fl">0.08</span></span>
+<span id="cb176-13"><a href="#cb176-13" aria-hidden="true" tabindex="-1"></a>SIGMA <span class="op">=</span> <span class="fl">0.20</span></span>
+<span id="cb176-14"><a href="#cb176-14" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb176-15"><a href="#cb176-15" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb176-16"><a href="#cb176-16" aria-hidden="true" tabindex="-1"></a><span class="kw">def</span> sigma_portfolio(rho: <span class="bu">float</span>, w1: <span class="bu">float</span> <span class="op">=</span> <span class="fl">0.5</span>) <span class="op">-&gt;</span> <span class="bu">float</span>:</span>
+<span id="cb176-17"><a href="#cb176-17" aria-hidden="true" tabindex="-1"></a>    <span class="co">&quot;&quot;&quot;Analytische Formel: sigma_p^2 = w1^2 s1^2 + w2^2 s2^2 + 2 w1 w2 rho s1 s2.&quot;&quot;&quot;</span></span>
+<span id="cb176-18"><a href="#cb176-18" aria-hidden="true" tabindex="-1"></a>    w2 <span class="op">=</span> <span class="dv">1</span> <span class="op">-</span> w1</span>
+<span id="cb176-19"><a href="#cb176-19" aria-hidden="true" tabindex="-1"></a>    varianz <span class="op">=</span> w1<span class="op">**</span><span class="dv">2</span> <span class="op">*</span> SIGMA<span class="op">**</span><span class="dv">2</span> <span class="op">+</span> w2<span class="op">**</span><span class="dv">2</span> <span class="op">*</span> SIGMA<span class="op">**</span><span class="dv">2</span> <span class="op">+</span> <span class="dv">2</span> <span class="op">*</span> w1 <span class="op">*</span> w2 <span class="op">*</span> rho <span class="op">*</span> SIGMA<span class="op">**</span><span class="dv">2</span></span>
+<span id="cb176-20"><a href="#cb176-20" aria-hidden="true" tabindex="-1"></a>    <span class="cf">return</span> <span class="bu">float</span>(np.sqrt(varianz))</span>
+<span id="cb176-21"><a href="#cb176-21" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb176-22"><a href="#cb176-22" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb176-23"><a href="#cb176-23" aria-hidden="true" tabindex="-1"></a><span class="kw">def</span> simuliere(rho: <span class="bu">float</span>, n: <span class="bu">int</span> <span class="op">=</span> <span class="dv">500_000</span>, seed: <span class="bu">int</span> <span class="op">=</span> <span class="dv">7</span>) <span class="op">-&gt;</span> <span class="bu">float</span>:</span>
+<span id="cb176-24"><a href="#cb176-24" aria-hidden="true" tabindex="-1"></a>    <span class="co">&quot;&quot;&quot;Erzeugt n korrelierte Renditepaare und misst die Portfolio-Volatilitaet empirisch.&quot;&quot;&quot;</span></span>
+<span id="cb176-25"><a href="#cb176-25" aria-hidden="true" tabindex="-1"></a>    rng <span class="op">=</span> np.random.default_rng(seed)</span>
+<span id="cb176-26"><a href="#cb176-26" aria-hidden="true" tabindex="-1"></a>    kovarianz <span class="op">=</span> np.array([[SIGMA<span class="op">**</span><span class="dv">2</span>, rho <span class="op">*</span> SIGMA<span class="op">**</span><span class="dv">2</span>],</span>
+<span id="cb176-27"><a href="#cb176-27" aria-hidden="true" tabindex="-1"></a>                           [rho <span class="op">*</span> SIGMA<span class="op">**</span><span class="dv">2</span>, SIGMA<span class="op">**</span><span class="dv">2</span>]])</span>
+<span id="cb176-28"><a href="#cb176-28" aria-hidden="true" tabindex="-1"></a>    renditen <span class="op">=</span> rng.multivariate_normal([MU, MU], kovarianz, size<span class="op">=</span>n)</span>
+<span id="cb176-29"><a href="#cb176-29" aria-hidden="true" tabindex="-1"></a>    portfolio <span class="op">=</span> <span class="fl">0.5</span> <span class="op">*</span> renditen[:, <span class="dv">0</span>] <span class="op">+</span> <span class="fl">0.5</span> <span class="op">*</span> renditen[:, <span class="dv">1</span>]</span>
+<span id="cb176-30"><a href="#cb176-30" aria-hidden="true" tabindex="-1"></a>    <span class="cf">return</span> <span class="bu">float</span>(portfolio.std(ddof<span class="op">=</span><span class="dv">1</span>))</span>
+<span id="cb176-31"><a href="#cb176-31" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb176-32"><a href="#cb176-32" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb176-33"><a href="#cb176-33" aria-hidden="true" tabindex="-1"></a><span class="cf">if</span> <span class="va">__name__</span> <span class="op">==</span> <span class="st">&quot;__main__&quot;</span>:</span>
+<span id="cb176-34"><a href="#cb176-34" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;=&quot;</span> <span class="op">*</span> <span class="dv">78</span>)</span>
+<span id="cb176-35"><a href="#cb176-35" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;  PORTFOLIORISIKO IN ABHAENGIGKEIT VON DER KORRELATION&quot;</span>)</span>
+<span id="cb176-36"><a href="#cb176-36" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;=&quot;</span> <span class="op">*</span> <span class="dv">78</span>)</span>
+<span id="cb176-37"><a href="#cb176-37" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;</span><span class="sc">{</span><span class="st">&#39;rho&#39;</span><span class="sc">:&gt;6}</span><span class="ss"> | </span><span class="sc">{</span><span class="st">&#39;sigma_p (Formel)&#39;</span><span class="sc">:&gt;18}</span><span class="ss"> | </span><span class="sc">{</span><span class="st">&#39;sigma_p (Simulation)&#39;</span><span class="sc">:&gt;20}</span><span class="ss"> | </span><span class="sc">{</span><span class="st">&#39;Risikoreduktion&#39;</span><span class="sc">:&gt;16}</span><span class="ss">&quot;</span>)</span>
+<span id="cb176-38"><a href="#cb176-38" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;-&quot;</span> <span class="op">*</span> <span class="dv">78</span>)</span>
+<span id="cb176-39"><a href="#cb176-39" aria-hidden="true" tabindex="-1"></a>    <span class="cf">for</span> rho <span class="kw">in</span> [<span class="fl">1.0</span>, <span class="fl">0.5</span>, <span class="fl">0.0</span>, <span class="op">-</span><span class="fl">0.5</span>, <span class="op">-</span><span class="fl">1.0</span>]:</span>
+<span id="cb176-40"><a href="#cb176-40" aria-hidden="true" tabindex="-1"></a>        formel <span class="op">=</span> sigma_portfolio(rho)</span>
+<span id="cb176-41"><a href="#cb176-41" aria-hidden="true" tabindex="-1"></a>        sim <span class="op">=</span> simuliere(rho)</span>
+<span id="cb176-42"><a href="#cb176-42" aria-hidden="true" tabindex="-1"></a>        reduktion <span class="op">=</span> (<span class="dv">1</span> <span class="op">-</span> formel <span class="op">/</span> SIGMA) <span class="op">*</span> <span class="dv">100</span></span>
+<span id="cb176-43"><a href="#cb176-43" aria-hidden="true" tabindex="-1"></a>        <span class="bu">print</span>(<span class="ss">f&quot;</span><span class="sc">{</span>rho<span class="sc">:6.1f}</span><span class="ss"> | </span><span class="sc">{</span>formel<span class="op">*</span><span class="dv">100</span><span class="sc">:16.2f}</span><span class="ss"> % | </span><span class="sc">{</span>sim<span class="op">*</span><span class="dv">100</span><span class="sc">:18.2f}</span><span class="ss"> % | </span><span class="sc">{</span>reduktion<span class="sc">:14.0f}</span><span class="ss"> %&quot;</span>)</span>
+<span id="cb176-44"><a href="#cb176-44" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb176-45"><a href="#cb176-45" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;</span><span class="ch">\n</span><span class="st">Die simulierten Werte (500.000 gezogene Renditepaare je rho) bestaetigen&quot;</span>)</span>
+<span id="cb176-46"><a href="#cb176-46" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;die Formel aus der Handrechnung bis auf statistisches Rauschen - und das,&quot;</span>)</span>
+<span id="cb176-47"><a href="#cb176-47" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;obwohl Formel und Simulation nichts voneinander wissen.&quot;</span>)</span></code></pre></div>
 <p><strong>Erwartete Ausgabe:</strong></p>
 <pre><code>==============================================================================
   PORTFOLIORISIKO IN ABHAENGIGKEIT VON DER KORRELATION
@@ -22458,279 +23434,279 @@ obwohl Formel und Simulation nichts voneinander wissen.</code></pre>
 <blockquote>
 <p><strong>⚠️ Sektoren niemals über Positionsindizes definieren</strong></p>
 <p>Ein naiver, aber gefährlicher Ansatz definiert den Technologiesektor so:</p>
-<div class="sourceCode" id="cb176"><pre class="sourceCode python"><code class="sourceCode python"><span id="cb176-1"><a href="#cb176-1" aria-hidden="true" tabindex="-1"></a>tickers <span class="op">=</span> [<span class="st">&quot;AAPL&quot;</span>, <span class="st">&quot;MSFT&quot;</span>, <span class="st">&quot;NVDA&quot;</span>, <span class="st">&quot;AMZN&quot;</span>, <span class="st">&quot;JNJ&quot;</span>, ...]</span>
-<span id="cb176-2"><a href="#cb176-2" aria-hidden="true" tabindex="-1"></a>tech_indices <span class="op">=</span> [<span class="dv">0</span>, <span class="dv">1</span>, <span class="dv">2</span>, <span class="dv">3</span>]        <span class="co"># gemeint: AAPL, MSFT, NVDA, AMZN</span></span></code></pre></div>
+<div class="sourceCode" id="cb178"><pre class="sourceCode python"><code class="sourceCode python"><span id="cb178-1"><a href="#cb178-1" aria-hidden="true" tabindex="-1"></a>tickers <span class="op">=</span> [<span class="st">&quot;AAPL&quot;</span>, <span class="st">&quot;MSFT&quot;</span>, <span class="st">&quot;NVDA&quot;</span>, <span class="st">&quot;AMZN&quot;</span>, <span class="st">&quot;JNJ&quot;</span>, ...]</span>
+<span id="cb178-2"><a href="#cb178-2" aria-hidden="true" tabindex="-1"></a>tech_indices <span class="op">=</span> [<span class="dv">0</span>, <span class="dv">1</span>, <span class="dv">2</span>, <span class="dv">3</span>]        <span class="co"># gemeint: AAPL, MSFT, NVDA, AMZN</span></span></code></pre></div>
 <p>Weil <code>yfinance</code> alphabetisch sortiert, trifft das tatsächlich auf <strong>AAPL, AMZN, CVX (Chevron) und GS (Goldman Sachs)</strong> zu — Microsoft und NVIDIA blieben unbeschränkt.</p>
 <p><strong>Robust ist die Definition über Namen:</strong></p>
-<div class="sourceCode" id="cb177"><pre class="sourceCode python"><code class="sourceCode python"><span id="cb177-1"><a href="#cb177-1" aria-hidden="true" tabindex="-1"></a>SEKTOREN <span class="op">=</span> {<span class="st">&quot;Technologie&quot;</span>: [<span class="st">&quot;AAPL&quot;</span>, <span class="st">&quot;MSFT&quot;</span>, <span class="st">&quot;NVDA&quot;</span>, <span class="st">&quot;AMZN&quot;</span>], ...}</span>
-<span id="cb177-2"><a href="#cb177-2" aria-hidden="true" tabindex="-1"></a>idx <span class="op">=</span> [tickers.index(t) <span class="cf">for</span> t <span class="kw">in</span> SEKTOREN[<span class="st">&quot;Technologie&quot;</span>]]</span></code></pre></div>
+<div class="sourceCode" id="cb179"><pre class="sourceCode python"><code class="sourceCode python"><span id="cb179-1"><a href="#cb179-1" aria-hidden="true" tabindex="-1"></a>SEKTOREN <span class="op">=</span> {<span class="st">&quot;Technologie&quot;</span>: [<span class="st">&quot;AAPL&quot;</span>, <span class="st">&quot;MSFT&quot;</span>, <span class="st">&quot;NVDA&quot;</span>, <span class="st">&quot;AMZN&quot;</span>], ...}</span>
+<span id="cb179-2"><a href="#cb179-2" aria-hidden="true" tabindex="-1"></a>idx <span class="op">=</span> [tickers.index(t) <span class="cf">for</span> t <span class="kw">in</span> SEKTOREN[<span class="st">&quot;Technologie&quot;</span>]]</span></code></pre></div>
 <p>Diese Schreibweise ist nicht nur sicher, sondern auch lesbar — und sie <strong>bricht laut ab</strong>, wenn ein Ticker fehlt, statt still das Falsche zu tun.</p>
 </blockquote>
 <hr />
 <h2 id="sec:markowitz-vollimplementierung-mit-cvxpy">19.6 Vollimplementierung mit CVXPY</h2>
-<div class="sourceCode" id="cb178"><pre class="sourceCode python"><code class="sourceCode python"><span id="cb178-1"><a href="#cb178-1" aria-hidden="true" tabindex="-1"></a><span class="co">#!/usr/bin/env python3</span></span>
-<span id="cb178-2"><a href="#cb178-2" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb178-3"><a href="#cb178-3" aria-hidden="true" tabindex="-1"></a><span class="co"># Markowitz_CVXPY.py</span></span>
-<span id="cb178-4"><a href="#cb178-4" aria-hidden="true" tabindex="-1"></a><span class="co">&quot;&quot;&quot;</span></span>
-<span id="cb178-5"><a href="#cb178-5" aria-hidden="true" tabindex="-1"></a><span class="co">Kapitel Markowitz: Markowitz-Mean-Variance-Optimierung mit CVXPY.</span></span>
-<span id="cb178-6"><a href="#cb178-6" aria-hidden="true" tabindex="-1"></a><span class="co">Enthaelt GMV, Maximum Sharpe (Korn-Transformation), Effizienzgrenze</span></span>
-<span id="cb178-7"><a href="#cb178-7" aria-hidden="true" tabindex="-1"></a><span class="co">und institutionelle Restriktionen.</span></span>
-<span id="cb178-8"><a href="#cb178-8" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb178-9"><a href="#cb178-9" aria-hidden="true" tabindex="-1"></a><span class="co">Eigenschaften:</span></span>
-<span id="cb178-10"><a href="#cb178-10" aria-hidden="true" tabindex="-1"></a><span class="co">  * Spaltenreihenfolge erzwungen; Sektoren ueber NAMEN statt Indizes</span></span>
-<span id="cb178-11"><a href="#cb178-11" aria-hidden="true" tabindex="-1"></a><span class="co">  * Effizienzgrenze bis zur TATSAECHLICH erreichbaren Maximalrendite</span></span>
-<span id="cb178-12"><a href="#cb178-12" aria-hidden="true" tabindex="-1"></a><span class="co">    (nicht etwa max(mu)*0.95 - das waere unter Restriktionen oft</span></span>
-<span id="cb178-13"><a href="#cb178-13" aria-hidden="true" tabindex="-1"></a><span class="co">     unerreichbar und die Kurve wuerde stillschweigend vorzeitig abbrechen)</span></span>
-<span id="cb178-14"><a href="#cb178-14" aria-hidden="true" tabindex="-1"></a><span class="co">  * Pruefung aller Restriktionen nach dem Loesen</span></span>
-<span id="cb178-15"><a href="#cb178-15" aria-hidden="true" tabindex="-1"></a><span class="co">  * Vergleich mit Gleichgewichtung als Realitaetscheck</span></span>
-<span id="cb178-16"><a href="#cb178-16" aria-hidden="true" tabindex="-1"></a><span class="co">&quot;&quot;&quot;</span></span>
-<span id="cb178-17"><a href="#cb178-17" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb178-18"><a href="#cb178-18" aria-hidden="true" tabindex="-1"></a><span class="im">import</span> os</span>
-<span id="cb178-19"><a href="#cb178-19" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb178-20"><a href="#cb178-20" aria-hidden="true" tabindex="-1"></a><span class="im">import</span> cvxpy <span class="im">as</span> cp</span>
-<span id="cb178-21"><a href="#cb178-21" aria-hidden="true" tabindex="-1"></a><span class="im">import</span> numpy <span class="im">as</span> np</span>
-<span id="cb178-22"><a href="#cb178-22" aria-hidden="true" tabindex="-1"></a><span class="im">import</span> pandas <span class="im">as</span> pd</span>
-<span id="cb178-23"><a href="#cb178-23" aria-hidden="true" tabindex="-1"></a><span class="im">import</span> yfinance <span class="im">as</span> yf</span>
-<span id="cb178-24"><a href="#cb178-24" aria-hidden="true" tabindex="-1"></a><span class="im">from</span> sklearn.covariance <span class="im">import</span> LedoitWolf</span>
-<span id="cb178-25"><a href="#cb178-25" aria-hidden="true" tabindex="-1"></a><span class="im">import</span> matplotlib</span>
-<span id="cb178-26"><a href="#cb178-26" aria-hidden="true" tabindex="-1"></a>matplotlib.use(<span class="st">&quot;Agg&quot;</span>)</span>
-<span id="cb178-27"><a href="#cb178-27" aria-hidden="true" tabindex="-1"></a><span class="im">import</span> matplotlib.pyplot <span class="im">as</span> plt</span>
-<span id="cb178-28"><a href="#cb178-28" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb178-29"><a href="#cb178-29" aria-hidden="true" tabindex="-1"></a>OUTPUT_DIR <span class="op">=</span> os.path.join(os.path.dirname(os.path.abspath(<span class="va">__file__</span>)), <span class="st">&quot;output&quot;</span>)</span>
-<span id="cb178-30"><a href="#cb178-30" aria-hidden="true" tabindex="-1"></a>os.makedirs(OUTPUT_DIR, exist_ok<span class="op">=</span><span class="va">True</span>)</span>
-<span id="cb178-31"><a href="#cb178-31" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb178-32"><a href="#cb178-32" aria-hidden="true" tabindex="-1"></a>TICKER <span class="op">=</span> [<span class="st">&quot;AAPL&quot;</span>, <span class="st">&quot;MSFT&quot;</span>, <span class="st">&quot;NVDA&quot;</span>, <span class="st">&quot;AMZN&quot;</span>, <span class="st">&quot;JNJ&quot;</span>, <span class="st">&quot;PFE&quot;</span>, <span class="st">&quot;JPM&quot;</span>, <span class="st">&quot;GS&quot;</span>, <span class="st">&quot;XOM&quot;</span>, <span class="st">&quot;CVX&quot;</span>]</span>
-<span id="cb178-33"><a href="#cb178-33" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb178-34"><a href="#cb178-34" aria-hidden="true" tabindex="-1"></a><span class="co"># Sektoren ueber Namen definiert, nicht ueber Positionen</span></span>
-<span id="cb178-35"><a href="#cb178-35" aria-hidden="true" tabindex="-1"></a>SEKTOREN <span class="op">=</span> {</span>
-<span id="cb178-36"><a href="#cb178-36" aria-hidden="true" tabindex="-1"></a>    <span class="st">&quot;Technologie&quot;</span>: [<span class="st">&quot;AAPL&quot;</span>, <span class="st">&quot;MSFT&quot;</span>, <span class="st">&quot;NVDA&quot;</span>, <span class="st">&quot;AMZN&quot;</span>],</span>
-<span id="cb178-37"><a href="#cb178-37" aria-hidden="true" tabindex="-1"></a>    <span class="st">&quot;Gesundheit&quot;</span>:  [<span class="st">&quot;JNJ&quot;</span>, <span class="st">&quot;PFE&quot;</span>],</span>
-<span id="cb178-38"><a href="#cb178-38" aria-hidden="true" tabindex="-1"></a>    <span class="st">&quot;Finanzen&quot;</span>:    [<span class="st">&quot;JPM&quot;</span>, <span class="st">&quot;GS&quot;</span>],</span>
-<span id="cb178-39"><a href="#cb178-39" aria-hidden="true" tabindex="-1"></a>    <span class="st">&quot;Energie&quot;</span>:     [<span class="st">&quot;XOM&quot;</span>, <span class="st">&quot;CVX&quot;</span>],</span>
-<span id="cb178-40"><a href="#cb178-40" aria-hidden="true" tabindex="-1"></a>}</span>
-<span id="cb178-41"><a href="#cb178-41" aria-hidden="true" tabindex="-1"></a>SEKTORGRENZEN <span class="op">=</span> {<span class="st">&quot;Technologie&quot;</span>: <span class="fl">0.35</span>, <span class="st">&quot;Gesundheit&quot;</span>: <span class="fl">0.40</span>,</span>
-<span id="cb178-42"><a href="#cb178-42" aria-hidden="true" tabindex="-1"></a>                 <span class="st">&quot;Finanzen&quot;</span>: <span class="fl">0.40</span>, <span class="st">&quot;Energie&quot;</span>: <span class="fl">0.40</span>}</span>
-<span id="cb178-43"><a href="#cb178-43" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb178-44"><a href="#cb178-44" aria-hidden="true" tabindex="-1"></a>MAX_GEWICHT <span class="op">=</span> <span class="fl">0.20</span>      <span class="co"># hoechstens 20 % je Einzeltitel</span></span>
-<span id="cb178-45"><a href="#cb178-45" aria-hidden="true" tabindex="-1"></a>RISIKOFREI <span class="op">=</span> <span class="fl">0.03</span>       <span class="co"># 3 % p.a.</span></span>
-<span id="cb178-46"><a href="#cb178-46" aria-hidden="true" tabindex="-1"></a>HANDELSTAGE <span class="op">=</span> <span class="dv">252</span></span>
-<span id="cb178-47"><a href="#cb178-47" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb178-48"><a href="#cb178-48" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb178-49"><a href="#cb178-49" aria-hidden="true" tabindex="-1"></a><span class="kw">def</span> lade_daten():</span>
-<span id="cb178-50"><a href="#cb178-50" aria-hidden="true" tabindex="-1"></a>    <span class="co">&quot;&quot;&quot;Laedt Kurse und garantiert die Spaltenreihenfolge.&quot;&quot;&quot;</span></span>
-<span id="cb178-51"><a href="#cb178-51" aria-hidden="true" tabindex="-1"></a>    ende <span class="op">=</span> pd.Timestamp.today().normalize()</span>
-<span id="cb178-52"><a href="#cb178-52" aria-hidden="true" tabindex="-1"></a>    start <span class="op">=</span> ende <span class="op">-</span> pd.DateOffset(years<span class="op">=</span><span class="dv">2</span>)</span>
-<span id="cb178-53"><a href="#cb178-53" aria-hidden="true" tabindex="-1"></a>    roh <span class="op">=</span> yf.download(TICKER, start<span class="op">=</span>start, end<span class="op">=</span>ende, auto_adjust<span class="op">=</span><span class="va">True</span>, progress<span class="op">=</span><span class="va">False</span>)</span>
-<span id="cb178-54"><a href="#cb178-54" aria-hidden="true" tabindex="-1"></a>    <span class="cf">if</span> roh.empty:</span>
-<span id="cb178-55"><a href="#cb178-55" aria-hidden="true" tabindex="-1"></a>        <span class="cf">raise</span> <span class="pp">SystemExit</span>(<span class="st">&quot;Download fehlgeschlagen (Netz, Ticker oder Rate-Limit pruefen).&quot;</span>)</span>
-<span id="cb178-56"><a href="#cb178-56" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb178-57"><a href="#cb178-57" aria-hidden="true" tabindex="-1"></a>    <span class="cf">if</span> <span class="bu">isinstance</span>(roh.columns, pd.MultiIndex):</span>
-<span id="cb178-58"><a href="#cb178-58" aria-hidden="true" tabindex="-1"></a>        kurse <span class="op">=</span> roh[<span class="st">&quot;Close&quot;</span>][TICKER].dropna()      <span class="co"># [TICKER] erzwingt die Reihenfolge</span></span>
-<span id="cb178-59"><a href="#cb178-59" aria-hidden="true" tabindex="-1"></a>    <span class="cf">else</span>:</span>
-<span id="cb178-60"><a href="#cb178-60" aria-hidden="true" tabindex="-1"></a>        kurse <span class="op">=</span> roh[[<span class="st">&quot;Close&quot;</span>]].dropna()</span>
-<span id="cb178-61"><a href="#cb178-61" aria-hidden="true" tabindex="-1"></a>        kurse.columns <span class="op">=</span> TICKER</span>
-<span id="cb178-62"><a href="#cb178-62" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb178-63"><a href="#cb178-63" aria-hidden="true" tabindex="-1"></a>    <span class="cf">assert</span> <span class="bu">list</span>(kurse.columns) <span class="op">==</span> TICKER, <span class="st">&quot;Spaltenreihenfolge weicht ab!&quot;</span></span>
-<span id="cb178-64"><a href="#cb178-64" aria-hidden="true" tabindex="-1"></a>    renditen <span class="op">=</span> kurse.pct_change().dropna()</span>
-<span id="cb178-65"><a href="#cb178-65" aria-hidden="true" tabindex="-1"></a>    mu <span class="op">=</span> renditen.mean().values <span class="op">*</span> HANDELSTAGE</span>
-<span id="cb178-66"><a href="#cb178-66" aria-hidden="true" tabindex="-1"></a>    sigma <span class="op">=</span> LedoitWolf().fit(renditen.values).covariance_ <span class="op">*</span> HANDELSTAGE</span>
-<span id="cb178-67"><a href="#cb178-67" aria-hidden="true" tabindex="-1"></a>    <span class="cf">return</span> kurse, renditen, mu, sigma</span>
-<span id="cb178-68"><a href="#cb178-68" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb178-69"><a href="#cb178-69" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb178-70"><a href="#cb178-70" aria-hidden="true" tabindex="-1"></a><span class="kw">def</span> sektor_indizes():</span>
-<span id="cb178-71"><a href="#cb178-71" aria-hidden="true" tabindex="-1"></a>    <span class="co">&quot;&quot;&quot;Uebersetzt Sektornamen einmalig in Positionsindizes - mit Pruefung.&quot;&quot;&quot;</span></span>
-<span id="cb178-72"><a href="#cb178-72" aria-hidden="true" tabindex="-1"></a>    ergebnis <span class="op">=</span> {}</span>
-<span id="cb178-73"><a href="#cb178-73" aria-hidden="true" tabindex="-1"></a>    <span class="cf">for</span> sektor, titel <span class="kw">in</span> SEKTOREN.items():</span>
-<span id="cb178-74"><a href="#cb178-74" aria-hidden="true" tabindex="-1"></a>        fehlend <span class="op">=</span> [t <span class="cf">for</span> t <span class="kw">in</span> titel <span class="cf">if</span> t <span class="kw">not</span> <span class="kw">in</span> TICKER]</span>
-<span id="cb178-75"><a href="#cb178-75" aria-hidden="true" tabindex="-1"></a>        <span class="cf">if</span> fehlend:</span>
-<span id="cb178-76"><a href="#cb178-76" aria-hidden="true" tabindex="-1"></a>            <span class="cf">raise</span> <span class="pp">ValueError</span>(<span class="ss">f&quot;Sektor &#39;</span><span class="sc">{</span>sektor<span class="sc">}</span><span class="ss">&#39;: Ticker </span><span class="sc">{</span>fehlend<span class="sc">}</span><span class="ss"> nicht im Universum.&quot;</span>)</span>
-<span id="cb178-77"><a href="#cb178-77" aria-hidden="true" tabindex="-1"></a>        ergebnis[sektor] <span class="op">=</span> [TICKER.index(t) <span class="cf">for</span> t <span class="kw">in</span> titel]</span>
-<span id="cb178-78"><a href="#cb178-78" aria-hidden="true" tabindex="-1"></a>    <span class="cf">return</span> ergebnis</span>
-<span id="cb178-79"><a href="#cb178-79" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb178-80"><a href="#cb178-80" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb178-81"><a href="#cb178-81" aria-hidden="true" tabindex="-1"></a><span class="kw">def</span> basis_restriktionen(w, skala<span class="op">=</span><span class="va">None</span>):</span>
-<span id="cb178-82"><a href="#cb178-82" aria-hidden="true" tabindex="-1"></a>    <span class="co">&quot;&quot;&quot;</span></span>
-<span id="cb178-83"><a href="#cb178-83" aria-hidden="true" tabindex="-1"></a><span class="co">    Standardrestriktionen. Bei der Korn-Transformation muessen ALLE Grenzen</span></span>
-<span id="cb178-84"><a href="#cb178-84" aria-hidden="true" tabindex="-1"></a><span class="co">    mit kappa mitskaliert werden - dafuer dient der Parameter &#39;skala&#39;.</span></span>
-<span id="cb178-85"><a href="#cb178-85" aria-hidden="true" tabindex="-1"></a><span class="co">    &quot;&quot;&quot;</span></span>
-<span id="cb178-86"><a href="#cb178-86" aria-hidden="true" tabindex="-1"></a>    eins <span class="op">=</span> <span class="fl">1.0</span> <span class="cf">if</span> skala <span class="kw">is</span> <span class="va">None</span> <span class="cf">else</span> skala</span>
-<span id="cb178-87"><a href="#cb178-87" aria-hidden="true" tabindex="-1"></a>    idx <span class="op">=</span> sektor_indizes()</span>
-<span id="cb178-88"><a href="#cb178-88" aria-hidden="true" tabindex="-1"></a>    bedingungen <span class="op">=</span> [w <span class="op">&gt;=</span> <span class="dv">0</span>, w <span class="op">&lt;=</span> MAX_GEWICHT <span class="op">*</span> eins]</span>
-<span id="cb178-89"><a href="#cb178-89" aria-hidden="true" tabindex="-1"></a>    <span class="cf">for</span> sektor, positionen <span class="kw">in</span> idx.items():</span>
-<span id="cb178-90"><a href="#cb178-90" aria-hidden="true" tabindex="-1"></a>        bedingungen.append(cp.<span class="bu">sum</span>(w[positionen]) <span class="op">&lt;=</span> SEKTORGRENZEN[sektor] <span class="op">*</span> eins)</span>
-<span id="cb178-91"><a href="#cb178-91" aria-hidden="true" tabindex="-1"></a>    <span class="cf">return</span> bedingungen</span>
-<span id="cb178-92"><a href="#cb178-92" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb178-93"><a href="#cb178-93" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb178-94"><a href="#cb178-94" aria-hidden="true" tabindex="-1"></a><span class="kw">def</span> loese_gmv(sigma):</span>
-<span id="cb178-95"><a href="#cb178-95" aria-hidden="true" tabindex="-1"></a>    <span class="co">&quot;&quot;&quot;Global Minimum Variance: minimiere Risiko, ignoriere Rendite.&quot;&quot;&quot;</span></span>
-<span id="cb178-96"><a href="#cb178-96" aria-hidden="true" tabindex="-1"></a>    w <span class="op">=</span> cp.Variable(<span class="bu">len</span>(sigma))</span>
-<span id="cb178-97"><a href="#cb178-97" aria-hidden="true" tabindex="-1"></a>    problem <span class="op">=</span> cp.Problem(cp.Minimize(<span class="fl">0.5</span> <span class="op">*</span> cp.quad_form(w, sigma)),</span>
-<span id="cb178-98"><a href="#cb178-98" aria-hidden="true" tabindex="-1"></a>                         [cp.<span class="bu">sum</span>(w) <span class="op">==</span> <span class="dv">1</span>] <span class="op">+</span> basis_restriktionen(w))</span>
-<span id="cb178-99"><a href="#cb178-99" aria-hidden="true" tabindex="-1"></a>    problem.solve()</span>
-<span id="cb178-100"><a href="#cb178-100" aria-hidden="true" tabindex="-1"></a>    <span class="cf">if</span> problem.status <span class="kw">not</span> <span class="kw">in</span> (<span class="st">&quot;optimal&quot;</span>, <span class="st">&quot;optimal_inaccurate&quot;</span>):</span>
-<span id="cb178-101"><a href="#cb178-101" aria-hidden="true" tabindex="-1"></a>        <span class="cf">raise</span> <span class="pp">SystemExit</span>(<span class="ss">f&quot;GMV nicht loesbar: </span><span class="sc">{</span>problem<span class="sc">.</span>status<span class="sc">}</span><span class="ss">&quot;</span>)</span>
-<span id="cb178-102"><a href="#cb178-102" aria-hidden="true" tabindex="-1"></a>    <span class="cf">return</span> w.value</span>
-<span id="cb178-103"><a href="#cb178-103" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb178-104"><a href="#cb178-104" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb178-105"><a href="#cb178-105" aria-hidden="true" tabindex="-1"></a><span class="kw">def</span> loese_max_sharpe(mu, sigma, r_f):</span>
-<span id="cb178-106"><a href="#cb178-106" aria-hidden="true" tabindex="-1"></a>    <span class="co">&quot;&quot;&quot;Maximum Sharpe Ratio ueber die Korn-Transformation.&quot;&quot;&quot;</span></span>
-<span id="cb178-107"><a href="#cb178-107" aria-hidden="true" tabindex="-1"></a>    n <span class="op">=</span> <span class="bu">len</span>(mu)</span>
-<span id="cb178-108"><a href="#cb178-108" aria-hidden="true" tabindex="-1"></a>    ueberrendite <span class="op">=</span> mu <span class="op">-</span> r_f</span>
-<span id="cb178-109"><a href="#cb178-109" aria-hidden="true" tabindex="-1"></a>    <span class="cf">if</span> np.<span class="bu">all</span>(ueberrendite <span class="op">&lt;=</span> <span class="dv">0</span>):</span>
-<span id="cb178-110"><a href="#cb178-110" aria-hidden="true" tabindex="-1"></a>        <span class="cf">raise</span> <span class="pp">SystemExit</span>(<span class="st">&quot;Kein Titel schlaegt den risikofreien Zins - &quot;</span></span>
-<span id="cb178-111"><a href="#cb178-111" aria-hidden="true" tabindex="-1"></a>                         <span class="st">&quot;Max-Sharpe-Portfolio existiert nicht.&quot;</span>)</span>
-<span id="cb178-112"><a href="#cb178-112" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb178-113"><a href="#cb178-113" aria-hidden="true" tabindex="-1"></a>    y <span class="op">=</span> cp.Variable(n)</span>
-<span id="cb178-114"><a href="#cb178-114" aria-hidden="true" tabindex="-1"></a>    kappa <span class="op">=</span> cp.Variable(nonneg<span class="op">=</span><span class="va">True</span>)</span>
-<span id="cb178-115"><a href="#cb178-115" aria-hidden="true" tabindex="-1"></a>    bedingungen <span class="op">=</span> ([ueberrendite <span class="op">@</span> y <span class="op">==</span> <span class="dv">1</span>, cp.<span class="bu">sum</span>(y) <span class="op">==</span> kappa]</span>
-<span id="cb178-116"><a href="#cb178-116" aria-hidden="true" tabindex="-1"></a>                   <span class="op">+</span> basis_restriktionen(y, skala<span class="op">=</span>kappa))</span>
-<span id="cb178-117"><a href="#cb178-117" aria-hidden="true" tabindex="-1"></a>    problem <span class="op">=</span> cp.Problem(cp.Minimize(<span class="fl">0.5</span> <span class="op">*</span> cp.quad_form(y, sigma)), bedingungen)</span>
-<span id="cb178-118"><a href="#cb178-118" aria-hidden="true" tabindex="-1"></a>    problem.solve()</span>
-<span id="cb178-119"><a href="#cb178-119" aria-hidden="true" tabindex="-1"></a>    <span class="cf">if</span> problem.status <span class="kw">not</span> <span class="kw">in</span> (<span class="st">&quot;optimal&quot;</span>, <span class="st">&quot;optimal_inaccurate&quot;</span>):</span>
-<span id="cb178-120"><a href="#cb178-120" aria-hidden="true" tabindex="-1"></a>        <span class="cf">raise</span> <span class="pp">SystemExit</span>(<span class="ss">f&quot;Max-Sharpe nicht loesbar: </span><span class="sc">{</span>problem<span class="sc">.</span>status<span class="sc">}</span><span class="ss">&quot;</span>)</span>
-<span id="cb178-121"><a href="#cb178-121" aria-hidden="true" tabindex="-1"></a>    <span class="cf">return</span> y.value <span class="op">/</span> kappa.value</span>
-<span id="cb178-122"><a href="#cb178-122" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb178-123"><a href="#cb178-123" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb178-124"><a href="#cb178-124" aria-hidden="true" tabindex="-1"></a><span class="kw">def</span> max_erreichbare_rendite(mu, sigma):</span>
-<span id="cb178-125"><a href="#cb178-125" aria-hidden="true" tabindex="-1"></a>    <span class="co">&quot;&quot;&quot;</span></span>
-<span id="cb178-126"><a href="#cb178-126" aria-hidden="true" tabindex="-1"></a><span class="co">    Achtung: max(mu)*0.95 als obere Grenze der Frontier anzunehmen, ist unter</span></span>
-<span id="cb178-127"><a href="#cb178-127" aria-hidden="true" tabindex="-1"></a><span class="co">    Positions- und Sektorgrenzen oft unerreichbar; die Kurve wuerde dann</span></span>
-<span id="cb178-128"><a href="#cb178-128" aria-hidden="true" tabindex="-1"></a><span class="co">    stillschweigend abbrechen. Hier wird die tatsaechliche Obergrenze berechnet.</span></span>
-<span id="cb178-129"><a href="#cb178-129" aria-hidden="true" tabindex="-1"></a><span class="co">    &quot;&quot;&quot;</span></span>
-<span id="cb178-130"><a href="#cb178-130" aria-hidden="true" tabindex="-1"></a>    w <span class="op">=</span> cp.Variable(<span class="bu">len</span>(mu))</span>
-<span id="cb178-131"><a href="#cb178-131" aria-hidden="true" tabindex="-1"></a>    problem <span class="op">=</span> cp.Problem(cp.Maximize(mu <span class="op">@</span> w), [cp.<span class="bu">sum</span>(w) <span class="op">==</span> <span class="dv">1</span>] <span class="op">+</span> basis_restriktionen(w))</span>
-<span id="cb178-132"><a href="#cb178-132" aria-hidden="true" tabindex="-1"></a>    problem.solve()</span>
-<span id="cb178-133"><a href="#cb178-133" aria-hidden="true" tabindex="-1"></a>    <span class="cf">return</span> <span class="bu">float</span>(problem.value)</span>
-<span id="cb178-134"><a href="#cb178-134" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb178-135"><a href="#cb178-135" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb178-136"><a href="#cb178-136" aria-hidden="true" tabindex="-1"></a><span class="kw">def</span> berechne_frontier(mu, sigma, ret_min, ret_max, punkte<span class="op">=</span><span class="dv">40</span>):</span>
-<span id="cb178-137"><a href="#cb178-137" aria-hidden="true" tabindex="-1"></a>    <span class="co">&quot;&quot;&quot;Effizienzgrenze durch Variation der Mindestrendite.&quot;&quot;&quot;</span></span>
-<span id="cb178-138"><a href="#cb178-138" aria-hidden="true" tabindex="-1"></a>    n <span class="op">=</span> <span class="bu">len</span>(mu)</span>
-<span id="cb178-139"><a href="#cb178-139" aria-hidden="true" tabindex="-1"></a>    w <span class="op">=</span> cp.Variable(n)</span>
-<span id="cb178-140"><a href="#cb178-140" aria-hidden="true" tabindex="-1"></a>    ziel_rendite <span class="op">=</span> cp.Parameter()</span>
-<span id="cb178-141"><a href="#cb178-141" aria-hidden="true" tabindex="-1"></a>    problem <span class="op">=</span> cp.Problem(</span>
-<span id="cb178-142"><a href="#cb178-142" aria-hidden="true" tabindex="-1"></a>        cp.Minimize(<span class="fl">0.5</span> <span class="op">*</span> cp.quad_form(w, sigma)),</span>
-<span id="cb178-143"><a href="#cb178-143" aria-hidden="true" tabindex="-1"></a>        [cp.<span class="bu">sum</span>(w) <span class="op">==</span> <span class="dv">1</span>, mu <span class="op">@</span> w <span class="op">&gt;=</span> ziel_rendite] <span class="op">+</span> basis_restriktionen(w))</span>
-<span id="cb178-144"><a href="#cb178-144" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb178-145"><a href="#cb178-145" aria-hidden="true" tabindex="-1"></a>    volas, renditen, uebersprungen <span class="op">=</span> [], [], <span class="dv">0</span></span>
-<span id="cb178-146"><a href="#cb178-146" aria-hidden="true" tabindex="-1"></a>    <span class="cf">for</span> ziel <span class="kw">in</span> np.linspace(ret_min, ret_max, punkte):</span>
-<span id="cb178-147"><a href="#cb178-147" aria-hidden="true" tabindex="-1"></a>        ziel_rendite.value <span class="op">=</span> ziel</span>
-<span id="cb178-148"><a href="#cb178-148" aria-hidden="true" tabindex="-1"></a>        problem.solve()</span>
-<span id="cb178-149"><a href="#cb178-149" aria-hidden="true" tabindex="-1"></a>        <span class="cf">if</span> problem.status <span class="kw">in</span> (<span class="st">&quot;optimal&quot;</span>, <span class="st">&quot;optimal_inaccurate&quot;</span>):</span>
-<span id="cb178-150"><a href="#cb178-150" aria-hidden="true" tabindex="-1"></a>            volas.append(<span class="bu">float</span>(np.sqrt(w.value <span class="op">@</span> sigma <span class="op">@</span> w.value)))</span>
-<span id="cb178-151"><a href="#cb178-151" aria-hidden="true" tabindex="-1"></a>            renditen.append(<span class="bu">float</span>(mu <span class="op">@</span> w.value))</span>
-<span id="cb178-152"><a href="#cb178-152" aria-hidden="true" tabindex="-1"></a>        <span class="cf">else</span>:</span>
-<span id="cb178-153"><a href="#cb178-153" aria-hidden="true" tabindex="-1"></a>            uebersprungen <span class="op">+=</span> <span class="dv">1</span></span>
-<span id="cb178-154"><a href="#cb178-154" aria-hidden="true" tabindex="-1"></a>    <span class="cf">if</span> uebersprungen:</span>
-<span id="cb178-155"><a href="#cb178-155" aria-hidden="true" tabindex="-1"></a>        <span class="bu">print</span>(<span class="ss">f&quot;  Hinweis: </span><span class="sc">{</span>uebersprungen<span class="sc">}</span><span class="ss"> Zielrenditen waren nicht erreichbar.&quot;</span>)</span>
-<span id="cb178-156"><a href="#cb178-156" aria-hidden="true" tabindex="-1"></a>    <span class="cf">return</span> np.array(volas), np.array(renditen)</span>
-<span id="cb178-157"><a href="#cb178-157" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb178-158"><a href="#cb178-158" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb178-159"><a href="#cb178-159" aria-hidden="true" tabindex="-1"></a><span class="kw">def</span> pruefe_restriktionen(w, bezeichnung):</span>
-<span id="cb178-160"><a href="#cb178-160" aria-hidden="true" tabindex="-1"></a>    <span class="co">&quot;&quot;&quot;Nach dem Loesen: haelt die Loesung wirklich alle Regeln ein?&quot;&quot;&quot;</span></span>
-<span id="cb178-161"><a href="#cb178-161" aria-hidden="true" tabindex="-1"></a>    <span class="cf">assert</span> <span class="bu">abs</span>(w.<span class="bu">sum</span>() <span class="op">-</span> <span class="dv">1</span>) <span class="op">&lt;</span> <span class="fl">1e-6</span>, <span class="ss">f&quot;</span><span class="sc">{</span>bezeichnung<span class="sc">}</span><span class="ss">: Summe != 1&quot;</span></span>
-<span id="cb178-162"><a href="#cb178-162" aria-hidden="true" tabindex="-1"></a>    <span class="cf">assert</span> w.<span class="bu">min</span>() <span class="op">&gt;</span> <span class="op">-</span><span class="fl">1e-6</span>, <span class="ss">f&quot;</span><span class="sc">{</span>bezeichnung<span class="sc">}</span><span class="ss">: negatives Gewicht&quot;</span></span>
-<span id="cb178-163"><a href="#cb178-163" aria-hidden="true" tabindex="-1"></a>    <span class="cf">assert</span> w.<span class="bu">max</span>() <span class="op">&lt;</span> MAX_GEWICHT <span class="op">+</span> <span class="fl">1e-6</span>, <span class="ss">f&quot;</span><span class="sc">{</span>bezeichnung<span class="sc">}</span><span class="ss">: Positionsgrenze verletzt&quot;</span></span>
-<span id="cb178-164"><a href="#cb178-164" aria-hidden="true" tabindex="-1"></a>    <span class="cf">for</span> sektor, positionen <span class="kw">in</span> sektor_indizes().items():</span>
-<span id="cb178-165"><a href="#cb178-165" aria-hidden="true" tabindex="-1"></a>        anteil <span class="op">=</span> w[positionen].<span class="bu">sum</span>()</span>
-<span id="cb178-166"><a href="#cb178-166" aria-hidden="true" tabindex="-1"></a>        <span class="cf">assert</span> anteil <span class="op">&lt;</span> SEKTORGRENZEN[sektor] <span class="op">+</span> <span class="fl">1e-6</span>, <span class="op">\</span></span>
-<span id="cb178-167"><a href="#cb178-167" aria-hidden="true" tabindex="-1"></a>            <span class="ss">f&quot;</span><span class="sc">{</span>bezeichnung<span class="sc">}</span><span class="ss">: Sektor </span><span class="sc">{</span>sektor<span class="sc">}</span><span class="ss"> bei </span><span class="sc">{</span>anteil<span class="sc">:.3f}</span><span class="ss"> ueber Grenze&quot;</span></span>
-<span id="cb178-168"><a href="#cb178-168" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb178-169"><a href="#cb178-169" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb178-170"><a href="#cb178-170" aria-hidden="true" tabindex="-1"></a><span class="kw">def</span> kennzahlen(w, mu, sigma, r_f):</span>
-<span id="cb178-171"><a href="#cb178-171" aria-hidden="true" tabindex="-1"></a>    rendite <span class="op">=</span> <span class="bu">float</span>(mu <span class="op">@</span> w)</span>
-<span id="cb178-172"><a href="#cb178-172" aria-hidden="true" tabindex="-1"></a>    vola <span class="op">=</span> <span class="bu">float</span>(np.sqrt(w <span class="op">@</span> sigma <span class="op">@</span> w))</span>
-<span id="cb178-173"><a href="#cb178-173" aria-hidden="true" tabindex="-1"></a>    <span class="cf">return</span> rendite, vola, (rendite <span class="op">-</span> r_f) <span class="op">/</span> vola</span>
-<span id="cb178-174"><a href="#cb178-174" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb178-175"><a href="#cb178-175" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb178-176"><a href="#cb178-176" aria-hidden="true" tabindex="-1"></a><span class="cf">if</span> <span class="va">__name__</span> <span class="op">==</span> <span class="st">&quot;__main__&quot;</span>:</span>
-<span id="cb178-177"><a href="#cb178-177" aria-hidden="true" tabindex="-1"></a>    kurse, renditen, mu, sigma <span class="op">=</span> lade_daten()</span>
-<span id="cb178-178"><a href="#cb178-178" aria-hidden="true" tabindex="-1"></a>    n <span class="op">=</span> <span class="bu">len</span>(TICKER)</span>
-<span id="cb178-179"><a href="#cb178-179" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb178-180"><a href="#cb178-180" aria-hidden="true" tabindex="-1"></a>    w_gmv <span class="op">=</span> loese_gmv(sigma)</span>
-<span id="cb178-181"><a href="#cb178-181" aria-hidden="true" tabindex="-1"></a>    w_sharpe <span class="op">=</span> loese_max_sharpe(mu, sigma, RISIKOFREI)</span>
-<span id="cb178-182"><a href="#cb178-182" aria-hidden="true" tabindex="-1"></a>    w_gleich <span class="op">=</span> np.ones(n) <span class="op">/</span> n</span>
-<span id="cb178-183"><a href="#cb178-183" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb178-184"><a href="#cb178-184" aria-hidden="true" tabindex="-1"></a>    pruefe_restriktionen(w_gmv, <span class="st">&quot;GMV&quot;</span>)</span>
-<span id="cb178-185"><a href="#cb178-185" aria-hidden="true" tabindex="-1"></a>    pruefe_restriktionen(w_sharpe, <span class="st">&quot;Max Sharpe&quot;</span>)</span>
-<span id="cb178-186"><a href="#cb178-186" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb178-187"><a href="#cb178-187" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;=&quot;</span> <span class="op">*</span> <span class="dv">88</span>)</span>
-<span id="cb178-188"><a href="#cb178-188" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;        ERGEBNISSE DER MEAN-VARIANCE-OPTIMIERUNG&quot;</span>)</span>
-<span id="cb178-189"><a href="#cb178-189" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;=&quot;</span> <span class="op">*</span> <span class="dv">88</span>)</span>
-<span id="cb178-190"><a href="#cb178-190" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;Datenbasis: </span><span class="sc">{</span><span class="bu">len</span>(renditen)<span class="sc">}</span><span class="ss"> Handelstage, </span><span class="sc">{</span>n<span class="sc">}</span><span class="ss"> Titel, &quot;</span></span>
-<span id="cb178-191"><a href="#cb178-191" aria-hidden="true" tabindex="-1"></a>          <span class="ss">f&quot;risikofreier Zins </span><span class="sc">{</span>RISIKOFREI<span class="op">*</span><span class="dv">100</span><span class="sc">:.1f}</span><span class="ss"> %&quot;</span>)</span>
-<span id="cb178-192"><a href="#cb178-192" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;Restriktionen: max. </span><span class="sc">{</span>MAX_GEWICHT<span class="op">*</span><span class="dv">100</span><span class="sc">:.0f}</span><span class="ss"> % je Titel, &quot;</span></span>
-<span id="cb178-193"><a href="#cb178-193" aria-hidden="true" tabindex="-1"></a>          <span class="ss">f&quot;Sektorgrenzen </span><span class="sc">{</span>SEKTORGRENZEN<span class="sc">}</span><span class="ch">\n</span><span class="ss">&quot;</span>)</span>
-<span id="cb178-194"><a href="#cb178-194" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb178-195"><a href="#cb178-195" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;</span><span class="sc">{</span><span class="st">&#39;Portfolio&#39;</span><span class="sc">:&lt;26}</span><span class="ss"> </span><span class="sc">{</span><span class="st">&#39;Rendite&#39;</span><span class="sc">:&gt;10}</span><span class="ss"> </span><span class="sc">{</span><span class="st">&#39;Volatilitaet&#39;</span><span class="sc">:&gt;13}</span><span class="ss"> </span><span class="sc">{</span><span class="st">&#39;Sharpe&#39;</span><span class="sc">:&gt;9}</span><span class="ss">&quot;</span>)</span>
-<span id="cb178-196"><a href="#cb178-196" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;-&quot;</span> <span class="op">*</span> <span class="dv">88</span>)</span>
-<span id="cb178-197"><a href="#cb178-197" aria-hidden="true" tabindex="-1"></a>    <span class="cf">for</span> name, w <span class="kw">in</span> [(<span class="st">&quot;Global Minimum Variance&quot;</span>, w_gmv),</span>
-<span id="cb178-198"><a href="#cb178-198" aria-hidden="true" tabindex="-1"></a>                    (<span class="st">&quot;Maximum Sharpe Ratio&quot;</span>, w_sharpe),</span>
-<span id="cb178-199"><a href="#cb178-199" aria-hidden="true" tabindex="-1"></a>                    (<span class="st">&quot;Gleichgewichtung (1/N)&quot;</span>, w_gleich)]:</span>
-<span id="cb178-200"><a href="#cb178-200" aria-hidden="true" tabindex="-1"></a>        r, v, sr <span class="op">=</span> kennzahlen(w, mu, sigma, RISIKOFREI)</span>
-<span id="cb178-201"><a href="#cb178-201" aria-hidden="true" tabindex="-1"></a>        <span class="bu">print</span>(<span class="ss">f&quot;</span><span class="sc">{</span>name<span class="sc">:&lt;26}</span><span class="ss"> </span><span class="sc">{</span>r<span class="op">*</span><span class="dv">100</span><span class="sc">:&gt;9.2f}</span><span class="ss"> % </span><span class="sc">{</span>v<span class="op">*</span><span class="dv">100</span><span class="sc">:&gt;12.2f}</span><span class="ss"> % </span><span class="sc">{</span>sr<span class="sc">:&gt;9.2f}</span><span class="ss">&quot;</span>)</span>
-<span id="cb178-202"><a href="#cb178-202" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb178-203"><a href="#cb178-203" aria-hidden="true" tabindex="-1"></a>    <span class="co"># --- Gewichte je Titel ------------------------------------------------</span></span>
-<span id="cb178-204"><a href="#cb178-204" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;</span><span class="ch">\n</span><span class="st">--- Optimierte Portfoliogewichte ---&quot;</span>)</span>
-<span id="cb178-205"><a href="#cb178-205" aria-hidden="true" tabindex="-1"></a>    sektor_je_titel <span class="op">=</span> {t: s <span class="cf">for</span> s, titel <span class="kw">in</span> SEKTOREN.items() <span class="cf">for</span> t <span class="kw">in</span> titel}</span>
-<span id="cb178-206"><a href="#cb178-206" aria-hidden="true" tabindex="-1"></a>    tabelle <span class="op">=</span> pd.DataFrame({</span>
-<span id="cb178-207"><a href="#cb178-207" aria-hidden="true" tabindex="-1"></a>        <span class="st">&quot;Ticker&quot;</span>: TICKER,</span>
-<span id="cb178-208"><a href="#cb178-208" aria-hidden="true" tabindex="-1"></a>        <span class="st">&quot;Sektor&quot;</span>: [sektor_je_titel[t] <span class="cf">for</span> t <span class="kw">in</span> TICKER],</span>
-<span id="cb178-209"><a href="#cb178-209" aria-hidden="true" tabindex="-1"></a>        <span class="st">&quot;Rendite p.a.&quot;</span>: [<span class="ss">f&quot;</span><span class="sc">{</span>r<span class="op">*</span><span class="dv">100</span><span class="sc">:+6.1f}</span><span class="ss"> %&quot;</span> <span class="cf">for</span> r <span class="kw">in</span> mu],</span>
-<span id="cb178-210"><a href="#cb178-210" aria-hidden="true" tabindex="-1"></a>        <span class="st">&quot;Vola p.a.&quot;</span>: [<span class="ss">f&quot;</span><span class="sc">{</span>np<span class="sc">.</span>sqrt(sigma[i, i])<span class="op">*</span><span class="dv">100</span><span class="sc">:5.1f}</span><span class="ss"> %&quot;</span> <span class="cf">for</span> i <span class="kw">in</span> <span class="bu">range</span>(n)],</span>
-<span id="cb178-211"><a href="#cb178-211" aria-hidden="true" tabindex="-1"></a>        <span class="st">&quot;GMV&quot;</span>: [<span class="ss">f&quot;</span><span class="sc">{</span>w<span class="op">*</span><span class="dv">100</span><span class="sc">:5.1f}</span><span class="ss"> %&quot;</span> <span class="cf">for</span> w <span class="kw">in</span> w_gmv],</span>
-<span id="cb178-212"><a href="#cb178-212" aria-hidden="true" tabindex="-1"></a>        <span class="st">&quot;Max Sharpe&quot;</span>: [<span class="ss">f&quot;</span><span class="sc">{</span>w<span class="op">*</span><span class="dv">100</span><span class="sc">:5.1f}</span><span class="ss"> %&quot;</span> <span class="cf">for</span> w <span class="kw">in</span> w_sharpe],</span>
-<span id="cb178-213"><a href="#cb178-213" aria-hidden="true" tabindex="-1"></a>    })</span>
-<span id="cb178-214"><a href="#cb178-214" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(tabelle.to_string(index<span class="op">=</span><span class="va">False</span>))</span>
-<span id="cb178-215"><a href="#cb178-215" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb178-216"><a href="#cb178-216" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;</span><span class="ch">\n</span><span class="st">--- Sektoraufteilung (Kontrolle) ---&quot;</span>)</span>
-<span id="cb178-217"><a href="#cb178-217" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;</span><span class="sc">{</span><span class="st">&#39;Sektor&#39;</span><span class="sc">:&lt;14}</span><span class="ss"> </span><span class="sc">{</span><span class="st">&#39;Grenze&#39;</span><span class="sc">:&gt;8}</span><span class="ss"> </span><span class="sc">{</span><span class="st">&#39;GMV&#39;</span><span class="sc">:&gt;9}</span><span class="ss"> </span><span class="sc">{</span><span class="st">&#39;Max Sharpe&#39;</span><span class="sc">:&gt;12}</span><span class="ss">&quot;</span>)</span>
-<span id="cb178-218"><a href="#cb178-218" aria-hidden="true" tabindex="-1"></a>    <span class="cf">for</span> sektor, positionen <span class="kw">in</span> sektor_indizes().items():</span>
-<span id="cb178-219"><a href="#cb178-219" aria-hidden="true" tabindex="-1"></a>        <span class="bu">print</span>(<span class="ss">f&quot;</span><span class="sc">{</span>sektor<span class="sc">:&lt;14}</span><span class="ss"> </span><span class="sc">{</span>SEKTORGRENZEN[sektor]<span class="op">*</span><span class="dv">100</span><span class="sc">:&gt;7.0f}</span><span class="ss"> % &quot;</span></span>
-<span id="cb178-220"><a href="#cb178-220" aria-hidden="true" tabindex="-1"></a>              <span class="ss">f&quot;</span><span class="sc">{</span>w_gmv[positionen]<span class="sc">.</span><span class="bu">sum</span>()<span class="op">*</span><span class="dv">100</span><span class="sc">:&gt;8.1f}</span><span class="ss"> % &quot;</span></span>
-<span id="cb178-221"><a href="#cb178-221" aria-hidden="true" tabindex="-1"></a>              <span class="ss">f&quot;</span><span class="sc">{</span>w_sharpe[positionen]<span class="sc">.</span><span class="bu">sum</span>()<span class="op">*</span><span class="dv">100</span><span class="sc">:&gt;11.1f}</span><span class="ss"> %&quot;</span>)</span>
-<span id="cb178-222"><a href="#cb178-222" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb178-223"><a href="#cb178-223" aria-hidden="true" tabindex="-1"></a>    <span class="co"># --- Effizienzgrenze --------------------------------------------------</span></span>
-<span id="cb178-224"><a href="#cb178-224" aria-hidden="true" tabindex="-1"></a>    ret_gmv <span class="op">=</span> <span class="bu">float</span>(mu <span class="op">@</span> w_gmv)</span>
-<span id="cb178-225"><a href="#cb178-225" aria-hidden="true" tabindex="-1"></a>    ret_max <span class="op">=</span> max_erreichbare_rendite(mu, sigma)</span>
-<span id="cb178-226"><a href="#cb178-226" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;</span><span class="ch">\n</span><span class="ss">Effizienzgrenze von </span><span class="sc">{</span>ret_gmv<span class="op">*</span><span class="dv">100</span><span class="sc">:.2f}</span><span class="ss"> % bis </span><span class="sc">{</span>ret_max<span class="op">*</span><span class="dv">100</span><span class="sc">:.2f}</span><span class="ss"> % &quot;</span></span>
-<span id="cb178-227"><a href="#cb178-227" aria-hidden="true" tabindex="-1"></a>          <span class="ss">f&quot;(unter Restriktionen tatsaechlich erreichbar)&quot;</span>)</span>
-<span id="cb178-228"><a href="#cb178-228" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;  Zum Vergleich: bester Einzeltitel </span><span class="sc">{</span>mu<span class="sc">.</span><span class="bu">max</span>()<span class="op">*</span><span class="dv">100</span><span class="sc">:.2f}</span><span class="ss"> % - &quot;</span></span>
-<span id="cb178-229"><a href="#cb178-229" aria-hidden="true" tabindex="-1"></a>          <span class="ss">f&quot;durch die Grenzen nicht erreichbar.&quot;</span>)</span>
-<span id="cb178-230"><a href="#cb178-230" aria-hidden="true" tabindex="-1"></a>    volas, rets <span class="op">=</span> berechne_frontier(mu, sigma, ret_gmv, ret_max)</span>
-<span id="cb178-231"><a href="#cb178-231" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb178-232"><a href="#cb178-232" aria-hidden="true" tabindex="-1"></a>    <span class="co"># --- Diagramm ---------------------------------------------------------</span></span>
-<span id="cb178-233"><a href="#cb178-233" aria-hidden="true" tabindex="-1"></a>    plt.figure(figsize<span class="op">=</span>(<span class="dv">11</span>, <span class="fl">6.5</span>))</span>
-<span id="cb178-234"><a href="#cb178-234" aria-hidden="true" tabindex="-1"></a>    plt.plot(volas <span class="op">*</span> <span class="dv">100</span>, rets <span class="op">*</span> <span class="dv">100</span>, <span class="st">&quot;b-&quot;</span>, lw<span class="op">=</span><span class="fl">2.5</span>, label<span class="op">=</span><span class="st">&quot;Effizienzgrenze (restringiert)&quot;</span>)</span>
-<span id="cb178-235"><a href="#cb178-235" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb178-236"><a href="#cb178-236" aria-hidden="true" tabindex="-1"></a>    <span class="cf">for</span> w, farbe, marker, groesse, name <span class="kw">in</span> [</span>
-<span id="cb178-237"><a href="#cb178-237" aria-hidden="true" tabindex="-1"></a>            (w_gmv, <span class="st">&quot;green&quot;</span>, <span class="st">&quot;o&quot;</span>, <span class="dv">150</span>, <span class="st">&quot;GMV&quot;</span>),</span>
-<span id="cb178-238"><a href="#cb178-238" aria-hidden="true" tabindex="-1"></a>            (w_sharpe, <span class="st">&quot;red&quot;</span>, <span class="st">&quot;*&quot;</span>, <span class="dv">260</span>, <span class="st">&quot;Max Sharpe&quot;</span>),</span>
-<span id="cb178-239"><a href="#cb178-239" aria-hidden="true" tabindex="-1"></a>            (w_gleich, <span class="st">&quot;purple&quot;</span>, <span class="st">&quot;D&quot;</span>, <span class="dv">110</span>, <span class="st">&quot;Gleichgewichtung&quot;</span>)]:</span>
-<span id="cb178-240"><a href="#cb178-240" aria-hidden="true" tabindex="-1"></a>        r, v, sr <span class="op">=</span> kennzahlen(w, mu, sigma, RISIKOFREI)</span>
-<span id="cb178-241"><a href="#cb178-241" aria-hidden="true" tabindex="-1"></a>        plt.scatter([v <span class="op">*</span> <span class="dv">100</span>], [r <span class="op">*</span> <span class="dv">100</span>], color<span class="op">=</span>farbe, marker<span class="op">=</span>marker, s<span class="op">=</span>groesse,</span>
-<span id="cb178-242"><a href="#cb178-242" aria-hidden="true" tabindex="-1"></a>                    zorder<span class="op">=</span><span class="dv">5</span>, label<span class="op">=</span><span class="ss">f&quot;</span><span class="sc">{</span>name<span class="sc">}</span><span class="ss"> (SR=</span><span class="sc">{</span>sr<span class="sc">:.2f}</span><span class="ss">)&quot;</span>)</span>
-<span id="cb178-243"><a href="#cb178-243" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb178-244"><a href="#cb178-244" aria-hidden="true" tabindex="-1"></a>    <span class="co"># Kapitalmarktlinie durch den risikofreien Zins und das Tangentialportfolio</span></span>
-<span id="cb178-245"><a href="#cb178-245" aria-hidden="true" tabindex="-1"></a>    r_s, v_s, _ <span class="op">=</span> kennzahlen(w_sharpe, mu, sigma, RISIKOFREI)</span>
-<span id="cb178-246"><a href="#cb178-246" aria-hidden="true" tabindex="-1"></a>    x_linie <span class="op">=</span> np.array([<span class="dv">0</span>, v_s <span class="op">*</span> <span class="fl">1.25</span>])</span>
-<span id="cb178-247"><a href="#cb178-247" aria-hidden="true" tabindex="-1"></a>    plt.plot(x_linie <span class="op">*</span> <span class="dv">100</span>, (RISIKOFREI <span class="op">+</span> (r_s <span class="op">-</span> RISIKOFREI) <span class="op">/</span> v_s <span class="op">*</span> x_linie) <span class="op">*</span> <span class="dv">100</span>,</span>
-<span id="cb178-248"><a href="#cb178-248" aria-hidden="true" tabindex="-1"></a>             color<span class="op">=</span><span class="st">&quot;orange&quot;</span>, ls<span class="op">=</span><span class="st">&quot;:&quot;</span>, lw<span class="op">=</span><span class="dv">2</span>, label<span class="op">=</span><span class="st">&quot;Kapitalmarktlinie&quot;</span>)</span>
-<span id="cb178-249"><a href="#cb178-249" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb178-250"><a href="#cb178-250" aria-hidden="true" tabindex="-1"></a>    <span class="cf">for</span> i, t <span class="kw">in</span> <span class="bu">enumerate</span>(TICKER):</span>
-<span id="cb178-251"><a href="#cb178-251" aria-hidden="true" tabindex="-1"></a>        plt.scatter(np.sqrt(sigma[i, i]) <span class="op">*</span> <span class="dv">100</span>, mu[i] <span class="op">*</span> <span class="dv">100</span>, color<span class="op">=</span><span class="st">&quot;gray&quot;</span>, alpha<span class="op">=</span><span class="fl">0.5</span>, s<span class="op">=</span><span class="dv">40</span>)</span>
-<span id="cb178-252"><a href="#cb178-252" aria-hidden="true" tabindex="-1"></a>        plt.annotate(t, (np.sqrt(sigma[i, i]) <span class="op">*</span> <span class="dv">100</span> <span class="op">+</span> <span class="fl">0.4</span>, mu[i] <span class="op">*</span> <span class="dv">100</span>), fontsize<span class="op">=</span><span class="dv">8</span>)</span>
-<span id="cb178-253"><a href="#cb178-253" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb178-254"><a href="#cb178-254" aria-hidden="true" tabindex="-1"></a>    plt.title(<span class="st">&quot;Markowitz-Effizienzgrenze mit Sektor- und Positionsgrenzen&quot;</span>, fontsize<span class="op">=</span><span class="dv">12</span>)</span>
-<span id="cb178-255"><a href="#cb178-255" aria-hidden="true" tabindex="-1"></a>    plt.xlabel(<span class="st">&quot;Annualisierte Volatilitaet [%]&quot;</span>)</span>
-<span id="cb178-256"><a href="#cb178-256" aria-hidden="true" tabindex="-1"></a>    plt.ylabel(<span class="st">&quot;Annualisierte erwartete Rendite [%]&quot;</span>)</span>
-<span id="cb178-257"><a href="#cb178-257" aria-hidden="true" tabindex="-1"></a>    plt.grid(<span class="va">True</span>, linestyle<span class="op">=</span><span class="st">&quot;:&quot;</span>, alpha<span class="op">=</span><span class="fl">0.6</span>)</span>
-<span id="cb178-258"><a href="#cb178-258" aria-hidden="true" tabindex="-1"></a>    plt.legend(loc<span class="op">=</span><span class="st">&quot;best&quot;</span>)</span>
-<span id="cb178-259"><a href="#cb178-259" aria-hidden="true" tabindex="-1"></a>    plt.tight_layout()</span>
-<span id="cb178-260"><a href="#cb178-260" aria-hidden="true" tabindex="-1"></a>    ziel <span class="op">=</span> os.path.join(OUTPUT_DIR, <span class="st">&quot;markowitz_efficient_frontier.png&quot;</span>)</span>
-<span id="cb178-261"><a href="#cb178-261" aria-hidden="true" tabindex="-1"></a>    plt.savefig(ziel, dpi<span class="op">=</span><span class="dv">150</span>)</span>
-<span id="cb178-262"><a href="#cb178-262" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;</span><span class="ch">\n</span><span class="ss">Diagramm gespeichert unter &#39;</span><span class="sc">{</span>ziel<span class="sc">}</span><span class="ss">&#39;&quot;</span>)</span>
-<span id="cb178-263"><a href="#cb178-263" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;=&quot;</span> <span class="op">*</span> <span class="dv">88</span>)</span></code></pre></div>
+<div class="sourceCode" id="cb180"><pre class="sourceCode python"><code class="sourceCode python"><span id="cb180-1"><a href="#cb180-1" aria-hidden="true" tabindex="-1"></a><span class="co">#!/usr/bin/env python3</span></span>
+<span id="cb180-2"><a href="#cb180-2" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb180-3"><a href="#cb180-3" aria-hidden="true" tabindex="-1"></a><span class="co"># Markowitz_CVXPY.py</span></span>
+<span id="cb180-4"><a href="#cb180-4" aria-hidden="true" tabindex="-1"></a><span class="co">&quot;&quot;&quot;</span></span>
+<span id="cb180-5"><a href="#cb180-5" aria-hidden="true" tabindex="-1"></a><span class="co">Kapitel Markowitz: Markowitz-Mean-Variance-Optimierung mit CVXPY.</span></span>
+<span id="cb180-6"><a href="#cb180-6" aria-hidden="true" tabindex="-1"></a><span class="co">Enthaelt GMV, Maximum Sharpe (Korn-Transformation), Effizienzgrenze</span></span>
+<span id="cb180-7"><a href="#cb180-7" aria-hidden="true" tabindex="-1"></a><span class="co">und institutionelle Restriktionen.</span></span>
+<span id="cb180-8"><a href="#cb180-8" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb180-9"><a href="#cb180-9" aria-hidden="true" tabindex="-1"></a><span class="co">Eigenschaften:</span></span>
+<span id="cb180-10"><a href="#cb180-10" aria-hidden="true" tabindex="-1"></a><span class="co">  * Spaltenreihenfolge erzwungen; Sektoren ueber NAMEN statt Indizes</span></span>
+<span id="cb180-11"><a href="#cb180-11" aria-hidden="true" tabindex="-1"></a><span class="co">  * Effizienzgrenze bis zur TATSAECHLICH erreichbaren Maximalrendite</span></span>
+<span id="cb180-12"><a href="#cb180-12" aria-hidden="true" tabindex="-1"></a><span class="co">    (nicht etwa max(mu)*0.95 - das waere unter Restriktionen oft</span></span>
+<span id="cb180-13"><a href="#cb180-13" aria-hidden="true" tabindex="-1"></a><span class="co">     unerreichbar und die Kurve wuerde stillschweigend vorzeitig abbrechen)</span></span>
+<span id="cb180-14"><a href="#cb180-14" aria-hidden="true" tabindex="-1"></a><span class="co">  * Pruefung aller Restriktionen nach dem Loesen</span></span>
+<span id="cb180-15"><a href="#cb180-15" aria-hidden="true" tabindex="-1"></a><span class="co">  * Vergleich mit Gleichgewichtung als Realitaetscheck</span></span>
+<span id="cb180-16"><a href="#cb180-16" aria-hidden="true" tabindex="-1"></a><span class="co">&quot;&quot;&quot;</span></span>
+<span id="cb180-17"><a href="#cb180-17" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb180-18"><a href="#cb180-18" aria-hidden="true" tabindex="-1"></a><span class="im">import</span> os</span>
+<span id="cb180-19"><a href="#cb180-19" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb180-20"><a href="#cb180-20" aria-hidden="true" tabindex="-1"></a><span class="im">import</span> cvxpy <span class="im">as</span> cp</span>
+<span id="cb180-21"><a href="#cb180-21" aria-hidden="true" tabindex="-1"></a><span class="im">import</span> numpy <span class="im">as</span> np</span>
+<span id="cb180-22"><a href="#cb180-22" aria-hidden="true" tabindex="-1"></a><span class="im">import</span> pandas <span class="im">as</span> pd</span>
+<span id="cb180-23"><a href="#cb180-23" aria-hidden="true" tabindex="-1"></a><span class="im">import</span> yfinance <span class="im">as</span> yf</span>
+<span id="cb180-24"><a href="#cb180-24" aria-hidden="true" tabindex="-1"></a><span class="im">from</span> sklearn.covariance <span class="im">import</span> LedoitWolf</span>
+<span id="cb180-25"><a href="#cb180-25" aria-hidden="true" tabindex="-1"></a><span class="im">import</span> matplotlib</span>
+<span id="cb180-26"><a href="#cb180-26" aria-hidden="true" tabindex="-1"></a>matplotlib.use(<span class="st">&quot;Agg&quot;</span>)</span>
+<span id="cb180-27"><a href="#cb180-27" aria-hidden="true" tabindex="-1"></a><span class="im">import</span> matplotlib.pyplot <span class="im">as</span> plt</span>
+<span id="cb180-28"><a href="#cb180-28" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb180-29"><a href="#cb180-29" aria-hidden="true" tabindex="-1"></a>OUTPUT_DIR <span class="op">=</span> os.path.join(os.path.dirname(os.path.abspath(<span class="va">__file__</span>)), <span class="st">&quot;output&quot;</span>)</span>
+<span id="cb180-30"><a href="#cb180-30" aria-hidden="true" tabindex="-1"></a>os.makedirs(OUTPUT_DIR, exist_ok<span class="op">=</span><span class="va">True</span>)</span>
+<span id="cb180-31"><a href="#cb180-31" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb180-32"><a href="#cb180-32" aria-hidden="true" tabindex="-1"></a>TICKER <span class="op">=</span> [<span class="st">&quot;AAPL&quot;</span>, <span class="st">&quot;MSFT&quot;</span>, <span class="st">&quot;NVDA&quot;</span>, <span class="st">&quot;AMZN&quot;</span>, <span class="st">&quot;JNJ&quot;</span>, <span class="st">&quot;PFE&quot;</span>, <span class="st">&quot;JPM&quot;</span>, <span class="st">&quot;GS&quot;</span>, <span class="st">&quot;XOM&quot;</span>, <span class="st">&quot;CVX&quot;</span>]</span>
+<span id="cb180-33"><a href="#cb180-33" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb180-34"><a href="#cb180-34" aria-hidden="true" tabindex="-1"></a><span class="co"># Sektoren ueber Namen definiert, nicht ueber Positionen</span></span>
+<span id="cb180-35"><a href="#cb180-35" aria-hidden="true" tabindex="-1"></a>SEKTOREN <span class="op">=</span> {</span>
+<span id="cb180-36"><a href="#cb180-36" aria-hidden="true" tabindex="-1"></a>    <span class="st">&quot;Technologie&quot;</span>: [<span class="st">&quot;AAPL&quot;</span>, <span class="st">&quot;MSFT&quot;</span>, <span class="st">&quot;NVDA&quot;</span>, <span class="st">&quot;AMZN&quot;</span>],</span>
+<span id="cb180-37"><a href="#cb180-37" aria-hidden="true" tabindex="-1"></a>    <span class="st">&quot;Gesundheit&quot;</span>:  [<span class="st">&quot;JNJ&quot;</span>, <span class="st">&quot;PFE&quot;</span>],</span>
+<span id="cb180-38"><a href="#cb180-38" aria-hidden="true" tabindex="-1"></a>    <span class="st">&quot;Finanzen&quot;</span>:    [<span class="st">&quot;JPM&quot;</span>, <span class="st">&quot;GS&quot;</span>],</span>
+<span id="cb180-39"><a href="#cb180-39" aria-hidden="true" tabindex="-1"></a>    <span class="st">&quot;Energie&quot;</span>:     [<span class="st">&quot;XOM&quot;</span>, <span class="st">&quot;CVX&quot;</span>],</span>
+<span id="cb180-40"><a href="#cb180-40" aria-hidden="true" tabindex="-1"></a>}</span>
+<span id="cb180-41"><a href="#cb180-41" aria-hidden="true" tabindex="-1"></a>SEKTORGRENZEN <span class="op">=</span> {<span class="st">&quot;Technologie&quot;</span>: <span class="fl">0.35</span>, <span class="st">&quot;Gesundheit&quot;</span>: <span class="fl">0.40</span>,</span>
+<span id="cb180-42"><a href="#cb180-42" aria-hidden="true" tabindex="-1"></a>                 <span class="st">&quot;Finanzen&quot;</span>: <span class="fl">0.40</span>, <span class="st">&quot;Energie&quot;</span>: <span class="fl">0.40</span>}</span>
+<span id="cb180-43"><a href="#cb180-43" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb180-44"><a href="#cb180-44" aria-hidden="true" tabindex="-1"></a>MAX_GEWICHT <span class="op">=</span> <span class="fl">0.20</span>      <span class="co"># hoechstens 20 % je Einzeltitel</span></span>
+<span id="cb180-45"><a href="#cb180-45" aria-hidden="true" tabindex="-1"></a>RISIKOFREI <span class="op">=</span> <span class="fl">0.03</span>       <span class="co"># 3 % p.a.</span></span>
+<span id="cb180-46"><a href="#cb180-46" aria-hidden="true" tabindex="-1"></a>HANDELSTAGE <span class="op">=</span> <span class="dv">252</span></span>
+<span id="cb180-47"><a href="#cb180-47" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb180-48"><a href="#cb180-48" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb180-49"><a href="#cb180-49" aria-hidden="true" tabindex="-1"></a><span class="kw">def</span> lade_daten():</span>
+<span id="cb180-50"><a href="#cb180-50" aria-hidden="true" tabindex="-1"></a>    <span class="co">&quot;&quot;&quot;Laedt Kurse und garantiert die Spaltenreihenfolge.&quot;&quot;&quot;</span></span>
+<span id="cb180-51"><a href="#cb180-51" aria-hidden="true" tabindex="-1"></a>    ende <span class="op">=</span> pd.Timestamp.today().normalize()</span>
+<span id="cb180-52"><a href="#cb180-52" aria-hidden="true" tabindex="-1"></a>    start <span class="op">=</span> ende <span class="op">-</span> pd.DateOffset(years<span class="op">=</span><span class="dv">2</span>)</span>
+<span id="cb180-53"><a href="#cb180-53" aria-hidden="true" tabindex="-1"></a>    roh <span class="op">=</span> yf.download(TICKER, start<span class="op">=</span>start, end<span class="op">=</span>ende, auto_adjust<span class="op">=</span><span class="va">True</span>, progress<span class="op">=</span><span class="va">False</span>)</span>
+<span id="cb180-54"><a href="#cb180-54" aria-hidden="true" tabindex="-1"></a>    <span class="cf">if</span> roh.empty:</span>
+<span id="cb180-55"><a href="#cb180-55" aria-hidden="true" tabindex="-1"></a>        <span class="cf">raise</span> <span class="pp">SystemExit</span>(<span class="st">&quot;Download fehlgeschlagen (Netz, Ticker oder Rate-Limit pruefen).&quot;</span>)</span>
+<span id="cb180-56"><a href="#cb180-56" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb180-57"><a href="#cb180-57" aria-hidden="true" tabindex="-1"></a>    <span class="cf">if</span> <span class="bu">isinstance</span>(roh.columns, pd.MultiIndex):</span>
+<span id="cb180-58"><a href="#cb180-58" aria-hidden="true" tabindex="-1"></a>        kurse <span class="op">=</span> roh[<span class="st">&quot;Close&quot;</span>][TICKER].dropna()      <span class="co"># [TICKER] erzwingt die Reihenfolge</span></span>
+<span id="cb180-59"><a href="#cb180-59" aria-hidden="true" tabindex="-1"></a>    <span class="cf">else</span>:</span>
+<span id="cb180-60"><a href="#cb180-60" aria-hidden="true" tabindex="-1"></a>        kurse <span class="op">=</span> roh[[<span class="st">&quot;Close&quot;</span>]].dropna()</span>
+<span id="cb180-61"><a href="#cb180-61" aria-hidden="true" tabindex="-1"></a>        kurse.columns <span class="op">=</span> TICKER</span>
+<span id="cb180-62"><a href="#cb180-62" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb180-63"><a href="#cb180-63" aria-hidden="true" tabindex="-1"></a>    <span class="cf">assert</span> <span class="bu">list</span>(kurse.columns) <span class="op">==</span> TICKER, <span class="st">&quot;Spaltenreihenfolge weicht ab!&quot;</span></span>
+<span id="cb180-64"><a href="#cb180-64" aria-hidden="true" tabindex="-1"></a>    renditen <span class="op">=</span> kurse.pct_change().dropna()</span>
+<span id="cb180-65"><a href="#cb180-65" aria-hidden="true" tabindex="-1"></a>    mu <span class="op">=</span> renditen.mean().values <span class="op">*</span> HANDELSTAGE</span>
+<span id="cb180-66"><a href="#cb180-66" aria-hidden="true" tabindex="-1"></a>    sigma <span class="op">=</span> LedoitWolf().fit(renditen.values).covariance_ <span class="op">*</span> HANDELSTAGE</span>
+<span id="cb180-67"><a href="#cb180-67" aria-hidden="true" tabindex="-1"></a>    <span class="cf">return</span> kurse, renditen, mu, sigma</span>
+<span id="cb180-68"><a href="#cb180-68" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb180-69"><a href="#cb180-69" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb180-70"><a href="#cb180-70" aria-hidden="true" tabindex="-1"></a><span class="kw">def</span> sektor_indizes():</span>
+<span id="cb180-71"><a href="#cb180-71" aria-hidden="true" tabindex="-1"></a>    <span class="co">&quot;&quot;&quot;Uebersetzt Sektornamen einmalig in Positionsindizes - mit Pruefung.&quot;&quot;&quot;</span></span>
+<span id="cb180-72"><a href="#cb180-72" aria-hidden="true" tabindex="-1"></a>    ergebnis <span class="op">=</span> {}</span>
+<span id="cb180-73"><a href="#cb180-73" aria-hidden="true" tabindex="-1"></a>    <span class="cf">for</span> sektor, titel <span class="kw">in</span> SEKTOREN.items():</span>
+<span id="cb180-74"><a href="#cb180-74" aria-hidden="true" tabindex="-1"></a>        fehlend <span class="op">=</span> [t <span class="cf">for</span> t <span class="kw">in</span> titel <span class="cf">if</span> t <span class="kw">not</span> <span class="kw">in</span> TICKER]</span>
+<span id="cb180-75"><a href="#cb180-75" aria-hidden="true" tabindex="-1"></a>        <span class="cf">if</span> fehlend:</span>
+<span id="cb180-76"><a href="#cb180-76" aria-hidden="true" tabindex="-1"></a>            <span class="cf">raise</span> <span class="pp">ValueError</span>(<span class="ss">f&quot;Sektor &#39;</span><span class="sc">{</span>sektor<span class="sc">}</span><span class="ss">&#39;: Ticker </span><span class="sc">{</span>fehlend<span class="sc">}</span><span class="ss"> nicht im Universum.&quot;</span>)</span>
+<span id="cb180-77"><a href="#cb180-77" aria-hidden="true" tabindex="-1"></a>        ergebnis[sektor] <span class="op">=</span> [TICKER.index(t) <span class="cf">for</span> t <span class="kw">in</span> titel]</span>
+<span id="cb180-78"><a href="#cb180-78" aria-hidden="true" tabindex="-1"></a>    <span class="cf">return</span> ergebnis</span>
+<span id="cb180-79"><a href="#cb180-79" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb180-80"><a href="#cb180-80" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb180-81"><a href="#cb180-81" aria-hidden="true" tabindex="-1"></a><span class="kw">def</span> basis_restriktionen(w, skala<span class="op">=</span><span class="va">None</span>):</span>
+<span id="cb180-82"><a href="#cb180-82" aria-hidden="true" tabindex="-1"></a>    <span class="co">&quot;&quot;&quot;</span></span>
+<span id="cb180-83"><a href="#cb180-83" aria-hidden="true" tabindex="-1"></a><span class="co">    Standardrestriktionen. Bei der Korn-Transformation muessen ALLE Grenzen</span></span>
+<span id="cb180-84"><a href="#cb180-84" aria-hidden="true" tabindex="-1"></a><span class="co">    mit kappa mitskaliert werden - dafuer dient der Parameter &#39;skala&#39;.</span></span>
+<span id="cb180-85"><a href="#cb180-85" aria-hidden="true" tabindex="-1"></a><span class="co">    &quot;&quot;&quot;</span></span>
+<span id="cb180-86"><a href="#cb180-86" aria-hidden="true" tabindex="-1"></a>    eins <span class="op">=</span> <span class="fl">1.0</span> <span class="cf">if</span> skala <span class="kw">is</span> <span class="va">None</span> <span class="cf">else</span> skala</span>
+<span id="cb180-87"><a href="#cb180-87" aria-hidden="true" tabindex="-1"></a>    idx <span class="op">=</span> sektor_indizes()</span>
+<span id="cb180-88"><a href="#cb180-88" aria-hidden="true" tabindex="-1"></a>    bedingungen <span class="op">=</span> [w <span class="op">&gt;=</span> <span class="dv">0</span>, w <span class="op">&lt;=</span> MAX_GEWICHT <span class="op">*</span> eins]</span>
+<span id="cb180-89"><a href="#cb180-89" aria-hidden="true" tabindex="-1"></a>    <span class="cf">for</span> sektor, positionen <span class="kw">in</span> idx.items():</span>
+<span id="cb180-90"><a href="#cb180-90" aria-hidden="true" tabindex="-1"></a>        bedingungen.append(cp.<span class="bu">sum</span>(w[positionen]) <span class="op">&lt;=</span> SEKTORGRENZEN[sektor] <span class="op">*</span> eins)</span>
+<span id="cb180-91"><a href="#cb180-91" aria-hidden="true" tabindex="-1"></a>    <span class="cf">return</span> bedingungen</span>
+<span id="cb180-92"><a href="#cb180-92" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb180-93"><a href="#cb180-93" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb180-94"><a href="#cb180-94" aria-hidden="true" tabindex="-1"></a><span class="kw">def</span> loese_gmv(sigma):</span>
+<span id="cb180-95"><a href="#cb180-95" aria-hidden="true" tabindex="-1"></a>    <span class="co">&quot;&quot;&quot;Global Minimum Variance: minimiere Risiko, ignoriere Rendite.&quot;&quot;&quot;</span></span>
+<span id="cb180-96"><a href="#cb180-96" aria-hidden="true" tabindex="-1"></a>    w <span class="op">=</span> cp.Variable(<span class="bu">len</span>(sigma))</span>
+<span id="cb180-97"><a href="#cb180-97" aria-hidden="true" tabindex="-1"></a>    problem <span class="op">=</span> cp.Problem(cp.Minimize(<span class="fl">0.5</span> <span class="op">*</span> cp.quad_form(w, sigma)),</span>
+<span id="cb180-98"><a href="#cb180-98" aria-hidden="true" tabindex="-1"></a>                         [cp.<span class="bu">sum</span>(w) <span class="op">==</span> <span class="dv">1</span>] <span class="op">+</span> basis_restriktionen(w))</span>
+<span id="cb180-99"><a href="#cb180-99" aria-hidden="true" tabindex="-1"></a>    problem.solve()</span>
+<span id="cb180-100"><a href="#cb180-100" aria-hidden="true" tabindex="-1"></a>    <span class="cf">if</span> problem.status <span class="kw">not</span> <span class="kw">in</span> (<span class="st">&quot;optimal&quot;</span>, <span class="st">&quot;optimal_inaccurate&quot;</span>):</span>
+<span id="cb180-101"><a href="#cb180-101" aria-hidden="true" tabindex="-1"></a>        <span class="cf">raise</span> <span class="pp">SystemExit</span>(<span class="ss">f&quot;GMV nicht loesbar: </span><span class="sc">{</span>problem<span class="sc">.</span>status<span class="sc">}</span><span class="ss">&quot;</span>)</span>
+<span id="cb180-102"><a href="#cb180-102" aria-hidden="true" tabindex="-1"></a>    <span class="cf">return</span> w.value</span>
+<span id="cb180-103"><a href="#cb180-103" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb180-104"><a href="#cb180-104" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb180-105"><a href="#cb180-105" aria-hidden="true" tabindex="-1"></a><span class="kw">def</span> loese_max_sharpe(mu, sigma, r_f):</span>
+<span id="cb180-106"><a href="#cb180-106" aria-hidden="true" tabindex="-1"></a>    <span class="co">&quot;&quot;&quot;Maximum Sharpe Ratio ueber die Korn-Transformation.&quot;&quot;&quot;</span></span>
+<span id="cb180-107"><a href="#cb180-107" aria-hidden="true" tabindex="-1"></a>    n <span class="op">=</span> <span class="bu">len</span>(mu)</span>
+<span id="cb180-108"><a href="#cb180-108" aria-hidden="true" tabindex="-1"></a>    ueberrendite <span class="op">=</span> mu <span class="op">-</span> r_f</span>
+<span id="cb180-109"><a href="#cb180-109" aria-hidden="true" tabindex="-1"></a>    <span class="cf">if</span> np.<span class="bu">all</span>(ueberrendite <span class="op">&lt;=</span> <span class="dv">0</span>):</span>
+<span id="cb180-110"><a href="#cb180-110" aria-hidden="true" tabindex="-1"></a>        <span class="cf">raise</span> <span class="pp">SystemExit</span>(<span class="st">&quot;Kein Titel schlaegt den risikofreien Zins - &quot;</span></span>
+<span id="cb180-111"><a href="#cb180-111" aria-hidden="true" tabindex="-1"></a>                         <span class="st">&quot;Max-Sharpe-Portfolio existiert nicht.&quot;</span>)</span>
+<span id="cb180-112"><a href="#cb180-112" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb180-113"><a href="#cb180-113" aria-hidden="true" tabindex="-1"></a>    y <span class="op">=</span> cp.Variable(n)</span>
+<span id="cb180-114"><a href="#cb180-114" aria-hidden="true" tabindex="-1"></a>    kappa <span class="op">=</span> cp.Variable(nonneg<span class="op">=</span><span class="va">True</span>)</span>
+<span id="cb180-115"><a href="#cb180-115" aria-hidden="true" tabindex="-1"></a>    bedingungen <span class="op">=</span> ([ueberrendite <span class="op">@</span> y <span class="op">==</span> <span class="dv">1</span>, cp.<span class="bu">sum</span>(y) <span class="op">==</span> kappa]</span>
+<span id="cb180-116"><a href="#cb180-116" aria-hidden="true" tabindex="-1"></a>                   <span class="op">+</span> basis_restriktionen(y, skala<span class="op">=</span>kappa))</span>
+<span id="cb180-117"><a href="#cb180-117" aria-hidden="true" tabindex="-1"></a>    problem <span class="op">=</span> cp.Problem(cp.Minimize(<span class="fl">0.5</span> <span class="op">*</span> cp.quad_form(y, sigma)), bedingungen)</span>
+<span id="cb180-118"><a href="#cb180-118" aria-hidden="true" tabindex="-1"></a>    problem.solve()</span>
+<span id="cb180-119"><a href="#cb180-119" aria-hidden="true" tabindex="-1"></a>    <span class="cf">if</span> problem.status <span class="kw">not</span> <span class="kw">in</span> (<span class="st">&quot;optimal&quot;</span>, <span class="st">&quot;optimal_inaccurate&quot;</span>):</span>
+<span id="cb180-120"><a href="#cb180-120" aria-hidden="true" tabindex="-1"></a>        <span class="cf">raise</span> <span class="pp">SystemExit</span>(<span class="ss">f&quot;Max-Sharpe nicht loesbar: </span><span class="sc">{</span>problem<span class="sc">.</span>status<span class="sc">}</span><span class="ss">&quot;</span>)</span>
+<span id="cb180-121"><a href="#cb180-121" aria-hidden="true" tabindex="-1"></a>    <span class="cf">return</span> y.value <span class="op">/</span> kappa.value</span>
+<span id="cb180-122"><a href="#cb180-122" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb180-123"><a href="#cb180-123" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb180-124"><a href="#cb180-124" aria-hidden="true" tabindex="-1"></a><span class="kw">def</span> max_erreichbare_rendite(mu, sigma):</span>
+<span id="cb180-125"><a href="#cb180-125" aria-hidden="true" tabindex="-1"></a>    <span class="co">&quot;&quot;&quot;</span></span>
+<span id="cb180-126"><a href="#cb180-126" aria-hidden="true" tabindex="-1"></a><span class="co">    Achtung: max(mu)*0.95 als obere Grenze der Frontier anzunehmen, ist unter</span></span>
+<span id="cb180-127"><a href="#cb180-127" aria-hidden="true" tabindex="-1"></a><span class="co">    Positions- und Sektorgrenzen oft unerreichbar; die Kurve wuerde dann</span></span>
+<span id="cb180-128"><a href="#cb180-128" aria-hidden="true" tabindex="-1"></a><span class="co">    stillschweigend abbrechen. Hier wird die tatsaechliche Obergrenze berechnet.</span></span>
+<span id="cb180-129"><a href="#cb180-129" aria-hidden="true" tabindex="-1"></a><span class="co">    &quot;&quot;&quot;</span></span>
+<span id="cb180-130"><a href="#cb180-130" aria-hidden="true" tabindex="-1"></a>    w <span class="op">=</span> cp.Variable(<span class="bu">len</span>(mu))</span>
+<span id="cb180-131"><a href="#cb180-131" aria-hidden="true" tabindex="-1"></a>    problem <span class="op">=</span> cp.Problem(cp.Maximize(mu <span class="op">@</span> w), [cp.<span class="bu">sum</span>(w) <span class="op">==</span> <span class="dv">1</span>] <span class="op">+</span> basis_restriktionen(w))</span>
+<span id="cb180-132"><a href="#cb180-132" aria-hidden="true" tabindex="-1"></a>    problem.solve()</span>
+<span id="cb180-133"><a href="#cb180-133" aria-hidden="true" tabindex="-1"></a>    <span class="cf">return</span> <span class="bu">float</span>(problem.value)</span>
+<span id="cb180-134"><a href="#cb180-134" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb180-135"><a href="#cb180-135" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb180-136"><a href="#cb180-136" aria-hidden="true" tabindex="-1"></a><span class="kw">def</span> berechne_frontier(mu, sigma, ret_min, ret_max, punkte<span class="op">=</span><span class="dv">40</span>):</span>
+<span id="cb180-137"><a href="#cb180-137" aria-hidden="true" tabindex="-1"></a>    <span class="co">&quot;&quot;&quot;Effizienzgrenze durch Variation der Mindestrendite.&quot;&quot;&quot;</span></span>
+<span id="cb180-138"><a href="#cb180-138" aria-hidden="true" tabindex="-1"></a>    n <span class="op">=</span> <span class="bu">len</span>(mu)</span>
+<span id="cb180-139"><a href="#cb180-139" aria-hidden="true" tabindex="-1"></a>    w <span class="op">=</span> cp.Variable(n)</span>
+<span id="cb180-140"><a href="#cb180-140" aria-hidden="true" tabindex="-1"></a>    ziel_rendite <span class="op">=</span> cp.Parameter()</span>
+<span id="cb180-141"><a href="#cb180-141" aria-hidden="true" tabindex="-1"></a>    problem <span class="op">=</span> cp.Problem(</span>
+<span id="cb180-142"><a href="#cb180-142" aria-hidden="true" tabindex="-1"></a>        cp.Minimize(<span class="fl">0.5</span> <span class="op">*</span> cp.quad_form(w, sigma)),</span>
+<span id="cb180-143"><a href="#cb180-143" aria-hidden="true" tabindex="-1"></a>        [cp.<span class="bu">sum</span>(w) <span class="op">==</span> <span class="dv">1</span>, mu <span class="op">@</span> w <span class="op">&gt;=</span> ziel_rendite] <span class="op">+</span> basis_restriktionen(w))</span>
+<span id="cb180-144"><a href="#cb180-144" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb180-145"><a href="#cb180-145" aria-hidden="true" tabindex="-1"></a>    volas, renditen, uebersprungen <span class="op">=</span> [], [], <span class="dv">0</span></span>
+<span id="cb180-146"><a href="#cb180-146" aria-hidden="true" tabindex="-1"></a>    <span class="cf">for</span> ziel <span class="kw">in</span> np.linspace(ret_min, ret_max, punkte):</span>
+<span id="cb180-147"><a href="#cb180-147" aria-hidden="true" tabindex="-1"></a>        ziel_rendite.value <span class="op">=</span> ziel</span>
+<span id="cb180-148"><a href="#cb180-148" aria-hidden="true" tabindex="-1"></a>        problem.solve()</span>
+<span id="cb180-149"><a href="#cb180-149" aria-hidden="true" tabindex="-1"></a>        <span class="cf">if</span> problem.status <span class="kw">in</span> (<span class="st">&quot;optimal&quot;</span>, <span class="st">&quot;optimal_inaccurate&quot;</span>):</span>
+<span id="cb180-150"><a href="#cb180-150" aria-hidden="true" tabindex="-1"></a>            volas.append(<span class="bu">float</span>(np.sqrt(w.value <span class="op">@</span> sigma <span class="op">@</span> w.value)))</span>
+<span id="cb180-151"><a href="#cb180-151" aria-hidden="true" tabindex="-1"></a>            renditen.append(<span class="bu">float</span>(mu <span class="op">@</span> w.value))</span>
+<span id="cb180-152"><a href="#cb180-152" aria-hidden="true" tabindex="-1"></a>        <span class="cf">else</span>:</span>
+<span id="cb180-153"><a href="#cb180-153" aria-hidden="true" tabindex="-1"></a>            uebersprungen <span class="op">+=</span> <span class="dv">1</span></span>
+<span id="cb180-154"><a href="#cb180-154" aria-hidden="true" tabindex="-1"></a>    <span class="cf">if</span> uebersprungen:</span>
+<span id="cb180-155"><a href="#cb180-155" aria-hidden="true" tabindex="-1"></a>        <span class="bu">print</span>(<span class="ss">f&quot;  Hinweis: </span><span class="sc">{</span>uebersprungen<span class="sc">}</span><span class="ss"> Zielrenditen waren nicht erreichbar.&quot;</span>)</span>
+<span id="cb180-156"><a href="#cb180-156" aria-hidden="true" tabindex="-1"></a>    <span class="cf">return</span> np.array(volas), np.array(renditen)</span>
+<span id="cb180-157"><a href="#cb180-157" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb180-158"><a href="#cb180-158" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb180-159"><a href="#cb180-159" aria-hidden="true" tabindex="-1"></a><span class="kw">def</span> pruefe_restriktionen(w, bezeichnung):</span>
+<span id="cb180-160"><a href="#cb180-160" aria-hidden="true" tabindex="-1"></a>    <span class="co">&quot;&quot;&quot;Nach dem Loesen: haelt die Loesung wirklich alle Regeln ein?&quot;&quot;&quot;</span></span>
+<span id="cb180-161"><a href="#cb180-161" aria-hidden="true" tabindex="-1"></a>    <span class="cf">assert</span> <span class="bu">abs</span>(w.<span class="bu">sum</span>() <span class="op">-</span> <span class="dv">1</span>) <span class="op">&lt;</span> <span class="fl">1e-6</span>, <span class="ss">f&quot;</span><span class="sc">{</span>bezeichnung<span class="sc">}</span><span class="ss">: Summe != 1&quot;</span></span>
+<span id="cb180-162"><a href="#cb180-162" aria-hidden="true" tabindex="-1"></a>    <span class="cf">assert</span> w.<span class="bu">min</span>() <span class="op">&gt;</span> <span class="op">-</span><span class="fl">1e-6</span>, <span class="ss">f&quot;</span><span class="sc">{</span>bezeichnung<span class="sc">}</span><span class="ss">: negatives Gewicht&quot;</span></span>
+<span id="cb180-163"><a href="#cb180-163" aria-hidden="true" tabindex="-1"></a>    <span class="cf">assert</span> w.<span class="bu">max</span>() <span class="op">&lt;</span> MAX_GEWICHT <span class="op">+</span> <span class="fl">1e-6</span>, <span class="ss">f&quot;</span><span class="sc">{</span>bezeichnung<span class="sc">}</span><span class="ss">: Positionsgrenze verletzt&quot;</span></span>
+<span id="cb180-164"><a href="#cb180-164" aria-hidden="true" tabindex="-1"></a>    <span class="cf">for</span> sektor, positionen <span class="kw">in</span> sektor_indizes().items():</span>
+<span id="cb180-165"><a href="#cb180-165" aria-hidden="true" tabindex="-1"></a>        anteil <span class="op">=</span> w[positionen].<span class="bu">sum</span>()</span>
+<span id="cb180-166"><a href="#cb180-166" aria-hidden="true" tabindex="-1"></a>        <span class="cf">assert</span> anteil <span class="op">&lt;</span> SEKTORGRENZEN[sektor] <span class="op">+</span> <span class="fl">1e-6</span>, <span class="op">\</span></span>
+<span id="cb180-167"><a href="#cb180-167" aria-hidden="true" tabindex="-1"></a>            <span class="ss">f&quot;</span><span class="sc">{</span>bezeichnung<span class="sc">}</span><span class="ss">: Sektor </span><span class="sc">{</span>sektor<span class="sc">}</span><span class="ss"> bei </span><span class="sc">{</span>anteil<span class="sc">:.3f}</span><span class="ss"> ueber Grenze&quot;</span></span>
+<span id="cb180-168"><a href="#cb180-168" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb180-169"><a href="#cb180-169" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb180-170"><a href="#cb180-170" aria-hidden="true" tabindex="-1"></a><span class="kw">def</span> kennzahlen(w, mu, sigma, r_f):</span>
+<span id="cb180-171"><a href="#cb180-171" aria-hidden="true" tabindex="-1"></a>    rendite <span class="op">=</span> <span class="bu">float</span>(mu <span class="op">@</span> w)</span>
+<span id="cb180-172"><a href="#cb180-172" aria-hidden="true" tabindex="-1"></a>    vola <span class="op">=</span> <span class="bu">float</span>(np.sqrt(w <span class="op">@</span> sigma <span class="op">@</span> w))</span>
+<span id="cb180-173"><a href="#cb180-173" aria-hidden="true" tabindex="-1"></a>    <span class="cf">return</span> rendite, vola, (rendite <span class="op">-</span> r_f) <span class="op">/</span> vola</span>
+<span id="cb180-174"><a href="#cb180-174" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb180-175"><a href="#cb180-175" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb180-176"><a href="#cb180-176" aria-hidden="true" tabindex="-1"></a><span class="cf">if</span> <span class="va">__name__</span> <span class="op">==</span> <span class="st">&quot;__main__&quot;</span>:</span>
+<span id="cb180-177"><a href="#cb180-177" aria-hidden="true" tabindex="-1"></a>    kurse, renditen, mu, sigma <span class="op">=</span> lade_daten()</span>
+<span id="cb180-178"><a href="#cb180-178" aria-hidden="true" tabindex="-1"></a>    n <span class="op">=</span> <span class="bu">len</span>(TICKER)</span>
+<span id="cb180-179"><a href="#cb180-179" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb180-180"><a href="#cb180-180" aria-hidden="true" tabindex="-1"></a>    w_gmv <span class="op">=</span> loese_gmv(sigma)</span>
+<span id="cb180-181"><a href="#cb180-181" aria-hidden="true" tabindex="-1"></a>    w_sharpe <span class="op">=</span> loese_max_sharpe(mu, sigma, RISIKOFREI)</span>
+<span id="cb180-182"><a href="#cb180-182" aria-hidden="true" tabindex="-1"></a>    w_gleich <span class="op">=</span> np.ones(n) <span class="op">/</span> n</span>
+<span id="cb180-183"><a href="#cb180-183" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb180-184"><a href="#cb180-184" aria-hidden="true" tabindex="-1"></a>    pruefe_restriktionen(w_gmv, <span class="st">&quot;GMV&quot;</span>)</span>
+<span id="cb180-185"><a href="#cb180-185" aria-hidden="true" tabindex="-1"></a>    pruefe_restriktionen(w_sharpe, <span class="st">&quot;Max Sharpe&quot;</span>)</span>
+<span id="cb180-186"><a href="#cb180-186" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb180-187"><a href="#cb180-187" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;=&quot;</span> <span class="op">*</span> <span class="dv">88</span>)</span>
+<span id="cb180-188"><a href="#cb180-188" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;        ERGEBNISSE DER MEAN-VARIANCE-OPTIMIERUNG&quot;</span>)</span>
+<span id="cb180-189"><a href="#cb180-189" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;=&quot;</span> <span class="op">*</span> <span class="dv">88</span>)</span>
+<span id="cb180-190"><a href="#cb180-190" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;Datenbasis: </span><span class="sc">{</span><span class="bu">len</span>(renditen)<span class="sc">}</span><span class="ss"> Handelstage, </span><span class="sc">{</span>n<span class="sc">}</span><span class="ss"> Titel, &quot;</span></span>
+<span id="cb180-191"><a href="#cb180-191" aria-hidden="true" tabindex="-1"></a>          <span class="ss">f&quot;risikofreier Zins </span><span class="sc">{</span>RISIKOFREI<span class="op">*</span><span class="dv">100</span><span class="sc">:.1f}</span><span class="ss"> %&quot;</span>)</span>
+<span id="cb180-192"><a href="#cb180-192" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;Restriktionen: max. </span><span class="sc">{</span>MAX_GEWICHT<span class="op">*</span><span class="dv">100</span><span class="sc">:.0f}</span><span class="ss"> % je Titel, &quot;</span></span>
+<span id="cb180-193"><a href="#cb180-193" aria-hidden="true" tabindex="-1"></a>          <span class="ss">f&quot;Sektorgrenzen </span><span class="sc">{</span>SEKTORGRENZEN<span class="sc">}</span><span class="ch">\n</span><span class="ss">&quot;</span>)</span>
+<span id="cb180-194"><a href="#cb180-194" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb180-195"><a href="#cb180-195" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;</span><span class="sc">{</span><span class="st">&#39;Portfolio&#39;</span><span class="sc">:&lt;26}</span><span class="ss"> </span><span class="sc">{</span><span class="st">&#39;Rendite&#39;</span><span class="sc">:&gt;10}</span><span class="ss"> </span><span class="sc">{</span><span class="st">&#39;Volatilitaet&#39;</span><span class="sc">:&gt;13}</span><span class="ss"> </span><span class="sc">{</span><span class="st">&#39;Sharpe&#39;</span><span class="sc">:&gt;9}</span><span class="ss">&quot;</span>)</span>
+<span id="cb180-196"><a href="#cb180-196" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;-&quot;</span> <span class="op">*</span> <span class="dv">88</span>)</span>
+<span id="cb180-197"><a href="#cb180-197" aria-hidden="true" tabindex="-1"></a>    <span class="cf">for</span> name, w <span class="kw">in</span> [(<span class="st">&quot;Global Minimum Variance&quot;</span>, w_gmv),</span>
+<span id="cb180-198"><a href="#cb180-198" aria-hidden="true" tabindex="-1"></a>                    (<span class="st">&quot;Maximum Sharpe Ratio&quot;</span>, w_sharpe),</span>
+<span id="cb180-199"><a href="#cb180-199" aria-hidden="true" tabindex="-1"></a>                    (<span class="st">&quot;Gleichgewichtung (1/N)&quot;</span>, w_gleich)]:</span>
+<span id="cb180-200"><a href="#cb180-200" aria-hidden="true" tabindex="-1"></a>        r, v, sr <span class="op">=</span> kennzahlen(w, mu, sigma, RISIKOFREI)</span>
+<span id="cb180-201"><a href="#cb180-201" aria-hidden="true" tabindex="-1"></a>        <span class="bu">print</span>(<span class="ss">f&quot;</span><span class="sc">{</span>name<span class="sc">:&lt;26}</span><span class="ss"> </span><span class="sc">{</span>r<span class="op">*</span><span class="dv">100</span><span class="sc">:&gt;9.2f}</span><span class="ss"> % </span><span class="sc">{</span>v<span class="op">*</span><span class="dv">100</span><span class="sc">:&gt;12.2f}</span><span class="ss"> % </span><span class="sc">{</span>sr<span class="sc">:&gt;9.2f}</span><span class="ss">&quot;</span>)</span>
+<span id="cb180-202"><a href="#cb180-202" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb180-203"><a href="#cb180-203" aria-hidden="true" tabindex="-1"></a>    <span class="co"># --- Gewichte je Titel ------------------------------------------------</span></span>
+<span id="cb180-204"><a href="#cb180-204" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;</span><span class="ch">\n</span><span class="st">--- Optimierte Portfoliogewichte ---&quot;</span>)</span>
+<span id="cb180-205"><a href="#cb180-205" aria-hidden="true" tabindex="-1"></a>    sektor_je_titel <span class="op">=</span> {t: s <span class="cf">for</span> s, titel <span class="kw">in</span> SEKTOREN.items() <span class="cf">for</span> t <span class="kw">in</span> titel}</span>
+<span id="cb180-206"><a href="#cb180-206" aria-hidden="true" tabindex="-1"></a>    tabelle <span class="op">=</span> pd.DataFrame({</span>
+<span id="cb180-207"><a href="#cb180-207" aria-hidden="true" tabindex="-1"></a>        <span class="st">&quot;Ticker&quot;</span>: TICKER,</span>
+<span id="cb180-208"><a href="#cb180-208" aria-hidden="true" tabindex="-1"></a>        <span class="st">&quot;Sektor&quot;</span>: [sektor_je_titel[t] <span class="cf">for</span> t <span class="kw">in</span> TICKER],</span>
+<span id="cb180-209"><a href="#cb180-209" aria-hidden="true" tabindex="-1"></a>        <span class="st">&quot;Rendite p.a.&quot;</span>: [<span class="ss">f&quot;</span><span class="sc">{</span>r<span class="op">*</span><span class="dv">100</span><span class="sc">:+6.1f}</span><span class="ss"> %&quot;</span> <span class="cf">for</span> r <span class="kw">in</span> mu],</span>
+<span id="cb180-210"><a href="#cb180-210" aria-hidden="true" tabindex="-1"></a>        <span class="st">&quot;Vola p.a.&quot;</span>: [<span class="ss">f&quot;</span><span class="sc">{</span>np<span class="sc">.</span>sqrt(sigma[i, i])<span class="op">*</span><span class="dv">100</span><span class="sc">:5.1f}</span><span class="ss"> %&quot;</span> <span class="cf">for</span> i <span class="kw">in</span> <span class="bu">range</span>(n)],</span>
+<span id="cb180-211"><a href="#cb180-211" aria-hidden="true" tabindex="-1"></a>        <span class="st">&quot;GMV&quot;</span>: [<span class="ss">f&quot;</span><span class="sc">{</span>w<span class="op">*</span><span class="dv">100</span><span class="sc">:5.1f}</span><span class="ss"> %&quot;</span> <span class="cf">for</span> w <span class="kw">in</span> w_gmv],</span>
+<span id="cb180-212"><a href="#cb180-212" aria-hidden="true" tabindex="-1"></a>        <span class="st">&quot;Max Sharpe&quot;</span>: [<span class="ss">f&quot;</span><span class="sc">{</span>w<span class="op">*</span><span class="dv">100</span><span class="sc">:5.1f}</span><span class="ss"> %&quot;</span> <span class="cf">for</span> w <span class="kw">in</span> w_sharpe],</span>
+<span id="cb180-213"><a href="#cb180-213" aria-hidden="true" tabindex="-1"></a>    })</span>
+<span id="cb180-214"><a href="#cb180-214" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(tabelle.to_string(index<span class="op">=</span><span class="va">False</span>))</span>
+<span id="cb180-215"><a href="#cb180-215" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb180-216"><a href="#cb180-216" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;</span><span class="ch">\n</span><span class="st">--- Sektoraufteilung (Kontrolle) ---&quot;</span>)</span>
+<span id="cb180-217"><a href="#cb180-217" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;</span><span class="sc">{</span><span class="st">&#39;Sektor&#39;</span><span class="sc">:&lt;14}</span><span class="ss"> </span><span class="sc">{</span><span class="st">&#39;Grenze&#39;</span><span class="sc">:&gt;8}</span><span class="ss"> </span><span class="sc">{</span><span class="st">&#39;GMV&#39;</span><span class="sc">:&gt;9}</span><span class="ss"> </span><span class="sc">{</span><span class="st">&#39;Max Sharpe&#39;</span><span class="sc">:&gt;12}</span><span class="ss">&quot;</span>)</span>
+<span id="cb180-218"><a href="#cb180-218" aria-hidden="true" tabindex="-1"></a>    <span class="cf">for</span> sektor, positionen <span class="kw">in</span> sektor_indizes().items():</span>
+<span id="cb180-219"><a href="#cb180-219" aria-hidden="true" tabindex="-1"></a>        <span class="bu">print</span>(<span class="ss">f&quot;</span><span class="sc">{</span>sektor<span class="sc">:&lt;14}</span><span class="ss"> </span><span class="sc">{</span>SEKTORGRENZEN[sektor]<span class="op">*</span><span class="dv">100</span><span class="sc">:&gt;7.0f}</span><span class="ss"> % &quot;</span></span>
+<span id="cb180-220"><a href="#cb180-220" aria-hidden="true" tabindex="-1"></a>              <span class="ss">f&quot;</span><span class="sc">{</span>w_gmv[positionen]<span class="sc">.</span><span class="bu">sum</span>()<span class="op">*</span><span class="dv">100</span><span class="sc">:&gt;8.1f}</span><span class="ss"> % &quot;</span></span>
+<span id="cb180-221"><a href="#cb180-221" aria-hidden="true" tabindex="-1"></a>              <span class="ss">f&quot;</span><span class="sc">{</span>w_sharpe[positionen]<span class="sc">.</span><span class="bu">sum</span>()<span class="op">*</span><span class="dv">100</span><span class="sc">:&gt;11.1f}</span><span class="ss"> %&quot;</span>)</span>
+<span id="cb180-222"><a href="#cb180-222" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb180-223"><a href="#cb180-223" aria-hidden="true" tabindex="-1"></a>    <span class="co"># --- Effizienzgrenze --------------------------------------------------</span></span>
+<span id="cb180-224"><a href="#cb180-224" aria-hidden="true" tabindex="-1"></a>    ret_gmv <span class="op">=</span> <span class="bu">float</span>(mu <span class="op">@</span> w_gmv)</span>
+<span id="cb180-225"><a href="#cb180-225" aria-hidden="true" tabindex="-1"></a>    ret_max <span class="op">=</span> max_erreichbare_rendite(mu, sigma)</span>
+<span id="cb180-226"><a href="#cb180-226" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;</span><span class="ch">\n</span><span class="ss">Effizienzgrenze von </span><span class="sc">{</span>ret_gmv<span class="op">*</span><span class="dv">100</span><span class="sc">:.2f}</span><span class="ss"> % bis </span><span class="sc">{</span>ret_max<span class="op">*</span><span class="dv">100</span><span class="sc">:.2f}</span><span class="ss"> % &quot;</span></span>
+<span id="cb180-227"><a href="#cb180-227" aria-hidden="true" tabindex="-1"></a>          <span class="ss">f&quot;(unter Restriktionen tatsaechlich erreichbar)&quot;</span>)</span>
+<span id="cb180-228"><a href="#cb180-228" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;  Zum Vergleich: bester Einzeltitel </span><span class="sc">{</span>mu<span class="sc">.</span><span class="bu">max</span>()<span class="op">*</span><span class="dv">100</span><span class="sc">:.2f}</span><span class="ss"> % - &quot;</span></span>
+<span id="cb180-229"><a href="#cb180-229" aria-hidden="true" tabindex="-1"></a>          <span class="ss">f&quot;durch die Grenzen nicht erreichbar.&quot;</span>)</span>
+<span id="cb180-230"><a href="#cb180-230" aria-hidden="true" tabindex="-1"></a>    volas, rets <span class="op">=</span> berechne_frontier(mu, sigma, ret_gmv, ret_max)</span>
+<span id="cb180-231"><a href="#cb180-231" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb180-232"><a href="#cb180-232" aria-hidden="true" tabindex="-1"></a>    <span class="co"># --- Diagramm ---------------------------------------------------------</span></span>
+<span id="cb180-233"><a href="#cb180-233" aria-hidden="true" tabindex="-1"></a>    plt.figure(figsize<span class="op">=</span>(<span class="dv">11</span>, <span class="fl">6.5</span>))</span>
+<span id="cb180-234"><a href="#cb180-234" aria-hidden="true" tabindex="-1"></a>    plt.plot(volas <span class="op">*</span> <span class="dv">100</span>, rets <span class="op">*</span> <span class="dv">100</span>, <span class="st">&quot;b-&quot;</span>, lw<span class="op">=</span><span class="fl">2.5</span>, label<span class="op">=</span><span class="st">&quot;Effizienzgrenze (restringiert)&quot;</span>)</span>
+<span id="cb180-235"><a href="#cb180-235" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb180-236"><a href="#cb180-236" aria-hidden="true" tabindex="-1"></a>    <span class="cf">for</span> w, farbe, marker, groesse, name <span class="kw">in</span> [</span>
+<span id="cb180-237"><a href="#cb180-237" aria-hidden="true" tabindex="-1"></a>            (w_gmv, <span class="st">&quot;green&quot;</span>, <span class="st">&quot;o&quot;</span>, <span class="dv">150</span>, <span class="st">&quot;GMV&quot;</span>),</span>
+<span id="cb180-238"><a href="#cb180-238" aria-hidden="true" tabindex="-1"></a>            (w_sharpe, <span class="st">&quot;red&quot;</span>, <span class="st">&quot;*&quot;</span>, <span class="dv">260</span>, <span class="st">&quot;Max Sharpe&quot;</span>),</span>
+<span id="cb180-239"><a href="#cb180-239" aria-hidden="true" tabindex="-1"></a>            (w_gleich, <span class="st">&quot;purple&quot;</span>, <span class="st">&quot;D&quot;</span>, <span class="dv">110</span>, <span class="st">&quot;Gleichgewichtung&quot;</span>)]:</span>
+<span id="cb180-240"><a href="#cb180-240" aria-hidden="true" tabindex="-1"></a>        r, v, sr <span class="op">=</span> kennzahlen(w, mu, sigma, RISIKOFREI)</span>
+<span id="cb180-241"><a href="#cb180-241" aria-hidden="true" tabindex="-1"></a>        plt.scatter([v <span class="op">*</span> <span class="dv">100</span>], [r <span class="op">*</span> <span class="dv">100</span>], color<span class="op">=</span>farbe, marker<span class="op">=</span>marker, s<span class="op">=</span>groesse,</span>
+<span id="cb180-242"><a href="#cb180-242" aria-hidden="true" tabindex="-1"></a>                    zorder<span class="op">=</span><span class="dv">5</span>, label<span class="op">=</span><span class="ss">f&quot;</span><span class="sc">{</span>name<span class="sc">}</span><span class="ss"> (SR=</span><span class="sc">{</span>sr<span class="sc">:.2f}</span><span class="ss">)&quot;</span>)</span>
+<span id="cb180-243"><a href="#cb180-243" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb180-244"><a href="#cb180-244" aria-hidden="true" tabindex="-1"></a>    <span class="co"># Kapitalmarktlinie durch den risikofreien Zins und das Tangentialportfolio</span></span>
+<span id="cb180-245"><a href="#cb180-245" aria-hidden="true" tabindex="-1"></a>    r_s, v_s, _ <span class="op">=</span> kennzahlen(w_sharpe, mu, sigma, RISIKOFREI)</span>
+<span id="cb180-246"><a href="#cb180-246" aria-hidden="true" tabindex="-1"></a>    x_linie <span class="op">=</span> np.array([<span class="dv">0</span>, v_s <span class="op">*</span> <span class="fl">1.25</span>])</span>
+<span id="cb180-247"><a href="#cb180-247" aria-hidden="true" tabindex="-1"></a>    plt.plot(x_linie <span class="op">*</span> <span class="dv">100</span>, (RISIKOFREI <span class="op">+</span> (r_s <span class="op">-</span> RISIKOFREI) <span class="op">/</span> v_s <span class="op">*</span> x_linie) <span class="op">*</span> <span class="dv">100</span>,</span>
+<span id="cb180-248"><a href="#cb180-248" aria-hidden="true" tabindex="-1"></a>             color<span class="op">=</span><span class="st">&quot;orange&quot;</span>, ls<span class="op">=</span><span class="st">&quot;:&quot;</span>, lw<span class="op">=</span><span class="dv">2</span>, label<span class="op">=</span><span class="st">&quot;Kapitalmarktlinie&quot;</span>)</span>
+<span id="cb180-249"><a href="#cb180-249" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb180-250"><a href="#cb180-250" aria-hidden="true" tabindex="-1"></a>    <span class="cf">for</span> i, t <span class="kw">in</span> <span class="bu">enumerate</span>(TICKER):</span>
+<span id="cb180-251"><a href="#cb180-251" aria-hidden="true" tabindex="-1"></a>        plt.scatter(np.sqrt(sigma[i, i]) <span class="op">*</span> <span class="dv">100</span>, mu[i] <span class="op">*</span> <span class="dv">100</span>, color<span class="op">=</span><span class="st">&quot;gray&quot;</span>, alpha<span class="op">=</span><span class="fl">0.5</span>, s<span class="op">=</span><span class="dv">40</span>)</span>
+<span id="cb180-252"><a href="#cb180-252" aria-hidden="true" tabindex="-1"></a>        plt.annotate(t, (np.sqrt(sigma[i, i]) <span class="op">*</span> <span class="dv">100</span> <span class="op">+</span> <span class="fl">0.4</span>, mu[i] <span class="op">*</span> <span class="dv">100</span>), fontsize<span class="op">=</span><span class="dv">8</span>)</span>
+<span id="cb180-253"><a href="#cb180-253" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb180-254"><a href="#cb180-254" aria-hidden="true" tabindex="-1"></a>    plt.title(<span class="st">&quot;Markowitz-Effizienzgrenze mit Sektor- und Positionsgrenzen&quot;</span>, fontsize<span class="op">=</span><span class="dv">12</span>)</span>
+<span id="cb180-255"><a href="#cb180-255" aria-hidden="true" tabindex="-1"></a>    plt.xlabel(<span class="st">&quot;Annualisierte Volatilitaet [%]&quot;</span>)</span>
+<span id="cb180-256"><a href="#cb180-256" aria-hidden="true" tabindex="-1"></a>    plt.ylabel(<span class="st">&quot;Annualisierte erwartete Rendite [%]&quot;</span>)</span>
+<span id="cb180-257"><a href="#cb180-257" aria-hidden="true" tabindex="-1"></a>    plt.grid(<span class="va">True</span>, linestyle<span class="op">=</span><span class="st">&quot;:&quot;</span>, alpha<span class="op">=</span><span class="fl">0.6</span>)</span>
+<span id="cb180-258"><a href="#cb180-258" aria-hidden="true" tabindex="-1"></a>    plt.legend(loc<span class="op">=</span><span class="st">&quot;best&quot;</span>)</span>
+<span id="cb180-259"><a href="#cb180-259" aria-hidden="true" tabindex="-1"></a>    plt.tight_layout()</span>
+<span id="cb180-260"><a href="#cb180-260" aria-hidden="true" tabindex="-1"></a>    ziel <span class="op">=</span> os.path.join(OUTPUT_DIR, <span class="st">&quot;markowitz_efficient_frontier.png&quot;</span>)</span>
+<span id="cb180-261"><a href="#cb180-261" aria-hidden="true" tabindex="-1"></a>    plt.savefig(ziel, dpi<span class="op">=</span><span class="dv">150</span>)</span>
+<span id="cb180-262"><a href="#cb180-262" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;</span><span class="ch">\n</span><span class="ss">Diagramm gespeichert unter &#39;</span><span class="sc">{</span>ziel<span class="sc">}</span><span class="ss">&#39;&quot;</span>)</span>
+<span id="cb180-263"><a href="#cb180-263" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;=&quot;</span> <span class="op">*</span> <span class="dv">88</span>)</span></code></pre></div>
 <blockquote>
 <p><strong>💻 Code-Durchgang: vier typische Fehlerquellen und ihre Absicherung</strong></p>
 <table>
@@ -22793,156 +23769,156 @@ obwohl Formel und Simulation nichts voneinander wissen.</code></pre>
 <h2 id="sec:markowitz-denkfehler">19.8 Finde den Denkfehler</h2>
 <p><a href="#kap-finanzdaten">Kapitel 18</a> hat gezeigt, was eine schlecht geschätzte <strong>Kovarianzmatrix</strong> anrichtet. Bei den erwarteten <strong>Renditen</strong> ist es schlimmer — und weil sie in der Zielfunktion stehen statt in der Nebenbedingung, fällt es schwerer auf.</p>
 <blockquote>
-<p><strong>🐛 Finde den Denkfehler 12.1: Zwölf gleiche Anlagen, ein sehr ungleiches Portfolio</strong></p>
+<p><strong>🐛 Finde den Denkfehler: Zwölf gleiche Anlagen, ein sehr ungleiches Portfolio</strong></p>
 <p>Ein Analyst optimiert ein Portfolio aus zwölf Anlagen. Erwartete Renditen und Kovarianzen schätzt er aus einem Jahr Tagesdaten — 250 Beobachtungen, in der Praxis durchaus üblich.</p>
 <p>Zur Kontrolle bauen wir das Experiment so, dass die richtige Antwort <strong>feststeht</strong>: Alle zwölf Anlagen haben in Wahrheit exakt dieselbe Rendite (0,0400 % täglich) und dieselbe Schwankung, und sie sind unabhängig. Ein korrektes Verfahren müsste also gleichgewichten.</p>
 <p>Der Optimierer legt stattdessen im Mittel <strong>38 %</strong> in eine einzige Anlage — und meldet für das Portfolio eine Tagesrendite von <strong>0,1261 %</strong>, mehr als das Dreifache dessen, was überhaupt erzielbar ist.</p>
 <p><strong>Ihre Aufgabe:</strong> (a) Woher kommt die Spanne von 0,24 Prozentpunkten zwischen der höchsten und der niedrigsten geschätzten Rendite, wenn doch alle Anlagen identisch sind? (b) Rechnen Sie nach, wie viele Beobachtungen nötig wären, um eine Rendite von 0,04 % bei 1,2 % Tagesschwankung überhaupt von null zu unterscheiden. (c) Warum wirkt sich derselbe Schätzfehler bei Renditen stärker aus als bei Kovarianzen? (d) Nennen Sie drei Gegenmittel — und begründen Sie, warum das erste davon das wirksamste ist.</p>
 <p><em>Auflösung: <a href="#sec:loesungen-markowitz">Abschnitt A.19</a>.</em></p>
 </blockquote>
-<div class="sourceCode" id="cb179"><pre class="sourceCode python"><code class="sourceCode python"><span id="cb179-1"><a href="#cb179-1" aria-hidden="true" tabindex="-1"></a><span class="co">#!/usr/bin/env python3</span></span>
-<span id="cb179-2"><a href="#cb179-2" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb179-3"><a href="#cb179-3" aria-hidden="true" tabindex="-1"></a><span class="co"># Renditeschaetzung_Falle.py</span></span>
-<span id="cb179-4"><a href="#cb179-4" aria-hidden="true" tabindex="-1"></a><span class="co">&quot;&quot;&quot;</span></span>
-<span id="cb179-5"><a href="#cb179-5" aria-hidden="true" tabindex="-1"></a><span class="co">Kapitel Markowitz: Warum geschaetzte Renditen noch gefaehrlicher sind als geschaetzte</span></span>
-<span id="cb179-6"><a href="#cb179-6" aria-hidden="true" tabindex="-1"></a><span class="co">Kovarianzen.</span></span>
-<span id="cb179-7"><a href="#cb179-7" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb179-8"><a href="#cb179-8" aria-hidden="true" tabindex="-1"></a><span class="co">Das Kapitel Finanzdaten hat gezeigt, was eine schlecht geschaetzte Kovarianzmatrix</span></span>
-<span id="cb179-9"><a href="#cb179-9" aria-hidden="true" tabindex="-1"></a><span class="co">anrichtet. Bei den erwarteten RENDITEN ist es schlimmer - aus einem einfachen</span></span>
-<span id="cb179-10"><a href="#cb179-10" aria-hidden="true" tabindex="-1"></a><span class="co">statistischen Grund: Um eine Rendite von 0,04 % pro Tag von null zu</span></span>
-<span id="cb179-11"><a href="#cb179-11" aria-hidden="true" tabindex="-1"></a><span class="co">unterscheiden, braucht man bei 1,2 % Tagesschwankung ueber tausend</span></span>
-<span id="cb179-12"><a href="#cb179-12" aria-hidden="true" tabindex="-1"></a><span class="co">Beobachtungen. Kovarianzen konvergieren dagegen deutlich schneller.</span></span>
-<span id="cb179-13"><a href="#cb179-13" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb179-14"><a href="#cb179-14" aria-hidden="true" tabindex="-1"></a><span class="co">Das Experiment ist bewusst so gebaut, dass die Antwort feststeht: ALLE zwoelf</span></span>
-<span id="cb179-15"><a href="#cb179-15" aria-hidden="true" tabindex="-1"></a><span class="co">Anlagen haben exakt dieselbe wahre Rendite und dieselbe Schwankung. Ein</span></span>
-<span id="cb179-16"><a href="#cb179-16" aria-hidden="true" tabindex="-1"></a><span class="co">korrektes Ergebnis waere also Gleichgewichtung. Was der Optimierer stattdessen</span></span>
-<span id="cb179-17"><a href="#cb179-17" aria-hidden="true" tabindex="-1"></a><span class="co">tut, zeigt der Lauf.</span></span>
-<span id="cb179-18"><a href="#cb179-18" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb179-19"><a href="#cb179-19" aria-hidden="true" tabindex="-1"></a><span class="co">Wiederholt wird 200 mal, damit das Ergebnis nicht von einer Zufallsstichprobe</span></span>
-<span id="cb179-20"><a href="#cb179-20" aria-hidden="true" tabindex="-1"></a><span class="co">abhaengt.</span></span>
-<span id="cb179-21"><a href="#cb179-21" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb179-22"><a href="#cb179-22" aria-hidden="true" tabindex="-1"></a><span class="co">Benoetigt: numpy, cvxpy</span></span>
-<span id="cb179-23"><a href="#cb179-23" aria-hidden="true" tabindex="-1"></a><span class="co">&quot;&quot;&quot;</span></span>
-<span id="cb179-24"><a href="#cb179-24" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb179-25"><a href="#cb179-25" aria-hidden="true" tabindex="-1"></a><span class="im">from</span> __future__ <span class="im">import</span> annotations</span>
-<span id="cb179-26"><a href="#cb179-26" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb179-27"><a href="#cb179-27" aria-hidden="true" tabindex="-1"></a><span class="im">import</span> numpy <span class="im">as</span> np</span>
-<span id="cb179-28"><a href="#cb179-28" aria-hidden="true" tabindex="-1"></a><span class="im">import</span> cvxpy <span class="im">as</span> cp</span>
-<span id="cb179-29"><a href="#cb179-29" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb179-30"><a href="#cb179-30" aria-hidden="true" tabindex="-1"></a>ANZAHL_ANLAGEN <span class="op">=</span> <span class="dv">12</span></span>
-<span id="cb179-31"><a href="#cb179-31" aria-hidden="true" tabindex="-1"></a>BEOBACHTUNGEN <span class="op">=</span> <span class="dv">250</span>              <span class="co"># ein Jahr Tagesdaten</span></span>
-<span id="cb179-32"><a href="#cb179-32" aria-hidden="true" tabindex="-1"></a>BEOBACHTUNGEN_SPAETER <span class="op">=</span> <span class="dv">2000</span>     <span class="co"># der &quot;spaetere Verlauf&quot;</span></span>
-<span id="cb179-33"><a href="#cb179-33" aria-hidden="true" tabindex="-1"></a>WIEDERHOLUNGEN <span class="op">=</span> <span class="dv">200</span></span>
-<span id="cb179-34"><a href="#cb179-34" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb179-35"><a href="#cb179-35" aria-hidden="true" tabindex="-1"></a><span class="co"># Die Wahrheit, die der Optimierer nicht kennt: alle Anlagen sind gleich.</span></span>
-<span id="cb179-36"><a href="#cb179-36" aria-hidden="true" tabindex="-1"></a>WAHRE_RENDITE <span class="op">=</span> <span class="fl">0.0004</span>           <span class="co"># 0,04 % pro Tag</span></span>
-<span id="cb179-37"><a href="#cb179-37" aria-hidden="true" tabindex="-1"></a>WAHRE_SCHWANKUNG <span class="op">=</span> <span class="fl">0.012</span>         <span class="co"># 1,2 % pro Tag</span></span>
-<span id="cb179-38"><a href="#cb179-38" aria-hidden="true" tabindex="-1"></a>RISIKOAVERSION <span class="op">=</span> <span class="fl">10.0</span></span>
-<span id="cb179-39"><a href="#cb179-39" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb179-40"><a href="#cb179-40" aria-hidden="true" tabindex="-1"></a>RNG <span class="op">=</span> np.random.default_rng(<span class="dv">5</span>)</span>
-<span id="cb179-41"><a href="#cb179-41" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb179-42"><a href="#cb179-42" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb179-43"><a href="#cb179-43" aria-hidden="true" tabindex="-1"></a><span class="kw">def</span> baue_optimierer() <span class="op">-&gt;</span> <span class="bu">tuple</span>[cp.Problem, cp.Variable, cp.Parameter, cp.Parameter]:</span>
-<span id="cb179-44"><a href="#cb179-44" aria-hidden="true" tabindex="-1"></a>    <span class="co">&quot;&quot;&quot;Baut das Markowitz-Problem EINMAL mit Parametern.</span></span>
-<span id="cb179-45"><a href="#cb179-45" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb179-46"><a href="#cb179-46" aria-hidden="true" tabindex="-1"></a><span class="co">    Bei 200 Wiederholungen ist das der Unterschied zwischen Sekunden und</span></span>
-<span id="cb179-47"><a href="#cb179-47" aria-hidden="true" tabindex="-1"></a><span class="co">    Minuten: cp.Parameter erlaubt es, nur die Daten zu tauschen, statt den</span></span>
-<span id="cb179-48"><a href="#cb179-48" aria-hidden="true" tabindex="-1"></a><span class="co">    Ausdrucksbaum jedes Mal neu zu kompilieren (siehe Kapitel Oekosystem).</span></span>
-<span id="cb179-49"><a href="#cb179-49" aria-hidden="true" tabindex="-1"></a><span class="co">    &quot;&quot;&quot;</span></span>
-<span id="cb179-50"><a href="#cb179-50" aria-hidden="true" tabindex="-1"></a>    gewichte <span class="op">=</span> cp.Variable(ANZAHL_ANLAGEN, nonneg<span class="op">=</span><span class="va">True</span>)</span>
-<span id="cb179-51"><a href="#cb179-51" aria-hidden="true" tabindex="-1"></a>    renditen <span class="op">=</span> cp.Parameter(ANZAHL_ANLAGEN)</span>
-<span id="cb179-52"><a href="#cb179-52" aria-hidden="true" tabindex="-1"></a>    kovarianz <span class="op">=</span> cp.Parameter((ANZAHL_ANLAGEN, ANZAHL_ANLAGEN), PSD<span class="op">=</span><span class="va">True</span>)</span>
-<span id="cb179-53"><a href="#cb179-53" aria-hidden="true" tabindex="-1"></a>    problem <span class="op">=</span> cp.Problem(</span>
-<span id="cb179-54"><a href="#cb179-54" aria-hidden="true" tabindex="-1"></a>        cp.Maximize(renditen <span class="op">@</span> gewichte</span>
-<span id="cb179-55"><a href="#cb179-55" aria-hidden="true" tabindex="-1"></a>                    <span class="op">-</span> RISIKOAVERSION <span class="op">*</span> cp.quad_form(gewichte, kovarianz)),</span>
-<span id="cb179-56"><a href="#cb179-56" aria-hidden="true" tabindex="-1"></a>        [cp.<span class="bu">sum</span>(gewichte) <span class="op">==</span> <span class="dv">1</span>])</span>
-<span id="cb179-57"><a href="#cb179-57" aria-hidden="true" tabindex="-1"></a>    <span class="cf">return</span> problem, gewichte, renditen, kovarianz</span>
-<span id="cb179-58"><a href="#cb179-58" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb179-59"><a href="#cb179-59" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb179-60"><a href="#cb179-60" aria-hidden="true" tabindex="-1"></a><span class="kw">def</span> erzeuge(perioden: <span class="bu">int</span>) <span class="op">-&gt;</span> np.ndarray:</span>
-<span id="cb179-61"><a href="#cb179-61" aria-hidden="true" tabindex="-1"></a>    <span class="co">&quot;&quot;&quot;Renditen, bei denen alle Anlagen identisch verteilt und unabhaengig sind.&quot;&quot;&quot;</span></span>
-<span id="cb179-62"><a href="#cb179-62" aria-hidden="true" tabindex="-1"></a>    <span class="cf">return</span> RNG.normal(WAHRE_RENDITE, WAHRE_SCHWANKUNG,</span>
-<span id="cb179-63"><a href="#cb179-63" aria-hidden="true" tabindex="-1"></a>                      (perioden, ANZAHL_ANLAGEN))</span>
-<span id="cb179-64"><a href="#cb179-64" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb179-65"><a href="#cb179-65" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb179-66"><a href="#cb179-66" aria-hidden="true" tabindex="-1"></a><span class="cf">if</span> <span class="va">__name__</span> <span class="op">==</span> <span class="st">&quot;__main__&quot;</span>:</span>
-<span id="cb179-67"><a href="#cb179-67" aria-hidden="true" tabindex="-1"></a>    problem, gewichte, renditen, kovarianz <span class="op">=</span> baue_optimierer()</span>
-<span id="cb179-68"><a href="#cb179-68" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb179-69"><a href="#cb179-69" aria-hidden="true" tabindex="-1"></a>    im_zeitraum, spaeter, spaeter_gleich <span class="op">=</span> [], [], []</span>
-<span id="cb179-70"><a href="#cb179-70" aria-hidden="true" tabindex="-1"></a>    groesstes_gewicht, schaetzspanne <span class="op">=</span> [], []</span>
-<span id="cb179-71"><a href="#cb179-71" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb179-72"><a href="#cb179-72" aria-hidden="true" tabindex="-1"></a>    <span class="cf">for</span> _ <span class="kw">in</span> <span class="bu">range</span>(WIEDERHOLUNGEN):</span>
-<span id="cb179-73"><a href="#cb179-73" aria-hidden="true" tabindex="-1"></a>        schaetzdaten <span class="op">=</span> erzeuge(BEOBACHTUNGEN)</span>
-<span id="cb179-74"><a href="#cb179-74" aria-hidden="true" tabindex="-1"></a>        spaetere_daten <span class="op">=</span> erzeuge(BEOBACHTUNGEN_SPAETER)</span>
-<span id="cb179-75"><a href="#cb179-75" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb179-76"><a href="#cb179-76" aria-hidden="true" tabindex="-1"></a>        geschaetzte_rendite <span class="op">=</span> schaetzdaten.mean(axis<span class="op">=</span><span class="dv">0</span>)</span>
-<span id="cb179-77"><a href="#cb179-77" aria-hidden="true" tabindex="-1"></a>        geschaetzte_kovarianz <span class="op">=</span> np.cov(schaetzdaten, rowvar<span class="op">=</span><span class="va">False</span>)</span>
-<span id="cb179-78"><a href="#cb179-78" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb179-79"><a href="#cb179-79" aria-hidden="true" tabindex="-1"></a>        renditen.value <span class="op">=</span> geschaetzte_rendite</span>
-<span id="cb179-80"><a href="#cb179-80" aria-hidden="true" tabindex="-1"></a>        <span class="co"># Symmetrisieren und minimal anheben: numerisches Rauschen kann die</span></span>
-<span id="cb179-81"><a href="#cb179-81" aria-hidden="true" tabindex="-1"></a>        <span class="co"># Matrix sonst knapp unter die PSD-Grenze druecken (Kapitel Fundament).</span></span>
-<span id="cb179-82"><a href="#cb179-82" aria-hidden="true" tabindex="-1"></a>        kovarianz.value <span class="op">=</span> ((geschaetzte_kovarianz <span class="op">+</span> geschaetzte_kovarianz.T) <span class="op">/</span> <span class="dv">2</span></span>
-<span id="cb179-83"><a href="#cb179-83" aria-hidden="true" tabindex="-1"></a>                           <span class="op">+</span> <span class="fl">1e-10</span> <span class="op">*</span> np.eye(ANZAHL_ANLAGEN))</span>
-<span id="cb179-84"><a href="#cb179-84" aria-hidden="true" tabindex="-1"></a>        problem.solve()</span>
-<span id="cb179-85"><a href="#cb179-85" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb179-86"><a href="#cb179-86" aria-hidden="true" tabindex="-1"></a>        w <span class="op">=</span> np.array(gewichte.value).ravel()</span>
-<span id="cb179-87"><a href="#cb179-87" aria-hidden="true" tabindex="-1"></a>        im_zeitraum.append(<span class="bu">float</span>((schaetzdaten <span class="op">@</span> w).mean()))</span>
-<span id="cb179-88"><a href="#cb179-88" aria-hidden="true" tabindex="-1"></a>        spaeter.append(<span class="bu">float</span>((spaetere_daten <span class="op">@</span> w).mean()))</span>
-<span id="cb179-89"><a href="#cb179-89" aria-hidden="true" tabindex="-1"></a>        spaeter_gleich.append(<span class="bu">float</span>(spaetere_daten.mean()))</span>
-<span id="cb179-90"><a href="#cb179-90" aria-hidden="true" tabindex="-1"></a>        groesstes_gewicht.append(<span class="bu">float</span>(w.<span class="bu">max</span>()))</span>
-<span id="cb179-91"><a href="#cb179-91" aria-hidden="true" tabindex="-1"></a>        schaetzspanne.append(<span class="bu">float</span>(geschaetzte_rendite.<span class="bu">max</span>()</span>
-<span id="cb179-92"><a href="#cb179-92" aria-hidden="true" tabindex="-1"></a>                                   <span class="op">-</span> geschaetzte_rendite.<span class="bu">min</span>()))</span>
-<span id="cb179-93"><a href="#cb179-93" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb179-94"><a href="#cb179-94" aria-hidden="true" tabindex="-1"></a>    prozent <span class="op">=</span> <span class="kw">lambda</span> werte: <span class="bu">float</span>(np.mean(werte)) <span class="op">*</span> <span class="dv">100</span></span>
-<span id="cb179-95"><a href="#cb179-95" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb179-96"><a href="#cb179-96" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;=&quot;</span> <span class="op">*</span> <span class="dv">78</span>)</span>
-<span id="cb179-97"><a href="#cb179-97" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;  WENN DER OPTIMIERER GESCHAETZTE RENDITEN GLAUBT&quot;</span>)</span>
-<span id="cb179-98"><a href="#cb179-98" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;=&quot;</span> <span class="op">*</span> <span class="dv">78</span>)</span>
-<span id="cb179-99"><a href="#cb179-99" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;</span><span class="sc">{</span>ANZAHL_ANLAGEN<span class="sc">}</span><span class="ss"> Anlagen, </span><span class="sc">{</span>WIEDERHOLUNGEN<span class="sc">}</span><span class="ss"> Wiederholungen, &quot;</span></span>
-<span id="cb179-100"><a href="#cb179-100" aria-hidden="true" tabindex="-1"></a>          <span class="ss">f&quot;je </span><span class="sc">{</span>BEOBACHTUNGEN<span class="sc">}</span><span class="ss"> Beobachtungen zur Schaetzung.&quot;</span>)</span>
-<span id="cb179-101"><a href="#cb179-101" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;In Wahrheit haben ALLE dieselbe Tagesrendite von &quot;</span></span>
-<span id="cb179-102"><a href="#cb179-102" aria-hidden="true" tabindex="-1"></a>          <span class="ss">f&quot;</span><span class="sc">{</span>WAHRE_RENDITE <span class="op">*</span> <span class="dv">100</span><span class="sc">:.4f}</span><span class="ss"> % und dieselbe Schwankung.&quot;</span>)</span>
-<span id="cb179-103"><a href="#cb179-103" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;Die richtige Antwort waere also: gleichgewichten.&quot;</span>)</span>
-<span id="cb179-104"><a href="#cb179-104" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>()</span>
-<span id="cb179-105"><a href="#cb179-105" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;Mittlere Spanne der geschaetzten Renditen: &quot;</span></span>
-<span id="cb179-106"><a href="#cb179-106" aria-hidden="true" tabindex="-1"></a>          <span class="ss">f&quot;</span><span class="sc">{</span>prozent(schaetzspanne)<span class="sc">:.4f}</span><span class="ss"> Prozentpunkte&quot;</span>)</span>
-<span id="cb179-107"><a href="#cb179-107" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;  -&gt; Das ist das </span><span class="sc">{</span>prozent(schaetzspanne) <span class="op">/</span> (WAHRE_RENDITE <span class="op">*</span> <span class="dv">100</span>)<span class="sc">:.1f}</span><span class="ss">-Fache &quot;</span></span>
-<span id="cb179-108"><a href="#cb179-108" aria-hidden="true" tabindex="-1"></a>          <span class="ss">f&quot;des wahren Werts. Aus reinem Rauschen.&quot;</span>)</span>
-<span id="cb179-109"><a href="#cb179-109" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;Mittleres groesstes Einzelgewicht: &quot;</span></span>
-<span id="cb179-110"><a href="#cb179-110" aria-hidden="true" tabindex="-1"></a>          <span class="ss">f&quot;</span><span class="sc">{</span>prozent(groesstes_gewicht)<span class="sc">:.1f}</span><span class="ss"> % &quot;</span></span>
-<span id="cb179-111"><a href="#cb179-111" aria-hidden="true" tabindex="-1"></a>          <span class="ss">f&quot;(bei Gleichgewichtung waeren es </span><span class="sc">{</span><span class="dv">100</span> <span class="op">/</span> ANZAHL_ANLAGEN<span class="sc">:.1f}</span><span class="ss"> %)&quot;</span>)</span>
-<span id="cb179-112"><a href="#cb179-112" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>()</span>
-<span id="cb179-113"><a href="#cb179-113" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;</span><span class="sc">{</span><span class="st">&#39;&#39;</span><span class="sc">:&lt;38}</span><span class="ss"> </span><span class="sc">{</span><span class="st">&#39;Tagesrendite&#39;</span><span class="sc">:&gt;14}</span><span class="ss">&quot;</span>)</span>
-<span id="cb179-114"><a href="#cb179-114" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;-&quot;</span> <span class="op">*</span> <span class="dv">78</span>)</span>
-<span id="cb179-115"><a href="#cb179-115" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;</span><span class="sc">{</span><span class="st">&#39;Wahrheit (alle Anlagen)&#39;</span><span class="sc">:&lt;38}</span><span class="ss"> </span><span class="sc">{</span>WAHRE_RENDITE <span class="op">*</span> <span class="dv">100</span><span class="sc">:&gt;13.4f}</span><span class="ss"> %&quot;</span>)</span>
-<span id="cb179-116"><a href="#cb179-116" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;</span><span class="sc">{</span><span class="st">&#39;Optimierer IM Schaetzzeitraum&#39;</span><span class="sc">:&lt;38}</span><span class="ss"> </span><span class="sc">{</span>prozent(im_zeitraum)<span class="sc">:&gt;13.4f}</span><span class="ss"> %&quot;</span></span>
-<span id="cb179-117"><a href="#cb179-117" aria-hidden="true" tabindex="-1"></a>          <span class="ss">f&quot;   &lt;- Illusion&quot;</span>)</span>
-<span id="cb179-118"><a href="#cb179-118" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;</span><span class="sc">{</span><span class="st">&#39;Optimierer AUSSERHALB&#39;</span><span class="sc">:&lt;38}</span><span class="ss"> </span><span class="sc">{</span>prozent(spaeter)<span class="sc">:&gt;13.4f}</span><span class="ss"> %&quot;</span>)</span>
-<span id="cb179-119"><a href="#cb179-119" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;</span><span class="sc">{</span><span class="st">&#39;Gleichgewichtung AUSSERHALB&#39;</span><span class="sc">:&lt;38}</span><span class="ss"> </span><span class="sc">{</span>prozent(spaeter_gleich)<span class="sc">:&gt;13.4f}</span><span class="ss"> %&quot;</span>)</span>
-<span id="cb179-120"><a href="#cb179-120" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;-&quot;</span> <span class="op">*</span> <span class="dv">78</span>)</span>
-<span id="cb179-121"><a href="#cb179-121" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb179-122"><a href="#cb179-122" aria-hidden="true" tabindex="-1"></a>    faktor <span class="op">=</span> prozent(im_zeitraum) <span class="op">/</span> (WAHRE_RENDITE <span class="op">*</span> <span class="dv">100</span>)</span>
-<span id="cb179-123"><a href="#cb179-123" aria-hidden="true" tabindex="-1"></a>    vorsprung <span class="op">=</span> prozent(spaeter) <span class="op">-</span> prozent(spaeter_gleich)</span>
-<span id="cb179-124"><a href="#cb179-124" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;</span><span class="ch">\n</span><span class="ss">Im Schaetzzeitraum verspricht der Optimierer das &quot;</span></span>
-<span id="cb179-125"><a href="#cb179-125" aria-hidden="true" tabindex="-1"></a>          <span class="ss">f&quot;</span><span class="sc">{</span>faktor<span class="sc">:.1f}</span><span class="ss">-Fache der wahren Rendite.&quot;</span>)</span>
-<span id="cb179-126"><a href="#cb179-126" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;Ausserhalb bleibt davon nichts: Er liegt </span><span class="sc">{</span><span class="bu">abs</span>(vorsprung)<span class="sc">:.4f}</span><span class="ss"> &quot;</span></span>
-<span id="cb179-127"><a href="#cb179-127" aria-hidden="true" tabindex="-1"></a>          <span class="ss">f&quot;Prozentpunkte&quot;</span>)</span>
-<span id="cb179-128"><a href="#cb179-128" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;</span><span class="sc">{</span><span class="st">&#39;schlechter&#39;</span> <span class="cf">if</span> vorsprung <span class="op">&lt;</span> <span class="dv">0</span> <span class="cf">else</span> <span class="st">&#39;besser&#39;</span><span class="sc">}</span><span class="ss"> als blosse Gleichgewichtung.&quot;</span>)</span>
-<span id="cb179-129"><a href="#cb179-129" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>()</span>
-<span id="cb179-130"><a href="#cb179-130" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;Der Grund ist statistisch, nicht finanzwirtschaftlich: Um eine&quot;</span>)</span>
-<span id="cb179-131"><a href="#cb179-131" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;Rendite von </span><span class="sc">{</span>WAHRE_RENDITE<span class="op">*</span><span class="dv">100</span><span class="sc">:.2f}</span><span class="ss"> % taeglich von null zu unterscheiden,&quot;</span>)</span>
-<span id="cb179-132"><a href="#cb179-132" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;braucht man bei </span><span class="sc">{</span>WAHRE_SCHWANKUNG<span class="op">*</span><span class="dv">100</span><span class="sc">:.1f}</span><span class="ss"> % Schwankung ueber tausend&quot;</span>)</span>
-<span id="cb179-133"><a href="#cb179-133" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;Beobachtungen. Mit 250 misst man ueberwiegend Rauschen - und der&quot;</span>)</span>
-<span id="cb179-134"><a href="#cb179-134" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;Optimierer nimmt jedes Rauschen fuer bare Muenze.&quot;</span>)</span>
-<span id="cb179-135"><a href="#cb179-135" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>()</span>
-<span id="cb179-136"><a href="#cb179-136" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;Drei praktische Konsequenzen:&quot;</span>)</span>
-<span id="cb179-137"><a href="#cb179-137" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;  1. Verzichten Sie auf Renditeschaetzungen, wo es geht. Das&quot;</span>)</span>
-<span id="cb179-138"><a href="#cb179-138" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;     Minimum-Varianz-Portfolio braucht gar keine.&quot;</span>)</span>
-<span id="cb179-139"><a href="#cb179-139" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;  2. Wenn Sie welche brauchen: schrumpfen Sie sie stark zur Mitte&quot;</span>)</span>
-<span id="cb179-140"><a href="#cb179-140" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;     (James-Stein, Black-Litterman) - viel staerker als Kovarianzen.&quot;</span>)</span>
-<span id="cb179-141"><a href="#cb179-141" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;  3. Begrenzen Sie Einzelgewichte. Was der Optimierer nicht darf,&quot;</span>)</span>
-<span id="cb179-142"><a href="#cb179-142" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;     kann er auch nicht auf Rauschen setzen.&quot;</span>)</span>
-<span id="cb179-143"><a href="#cb179-143" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;=&quot;</span> <span class="op">*</span> <span class="dv">78</span>)</span></code></pre></div>
+<div class="sourceCode" id="cb181"><pre class="sourceCode python"><code class="sourceCode python"><span id="cb181-1"><a href="#cb181-1" aria-hidden="true" tabindex="-1"></a><span class="co">#!/usr/bin/env python3</span></span>
+<span id="cb181-2"><a href="#cb181-2" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb181-3"><a href="#cb181-3" aria-hidden="true" tabindex="-1"></a><span class="co"># Renditeschaetzung_Falle.py</span></span>
+<span id="cb181-4"><a href="#cb181-4" aria-hidden="true" tabindex="-1"></a><span class="co">&quot;&quot;&quot;</span></span>
+<span id="cb181-5"><a href="#cb181-5" aria-hidden="true" tabindex="-1"></a><span class="co">Kapitel Markowitz: Warum geschaetzte Renditen noch gefaehrlicher sind als geschaetzte</span></span>
+<span id="cb181-6"><a href="#cb181-6" aria-hidden="true" tabindex="-1"></a><span class="co">Kovarianzen.</span></span>
+<span id="cb181-7"><a href="#cb181-7" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb181-8"><a href="#cb181-8" aria-hidden="true" tabindex="-1"></a><span class="co">Das Kapitel Finanzdaten hat gezeigt, was eine schlecht geschaetzte Kovarianzmatrix</span></span>
+<span id="cb181-9"><a href="#cb181-9" aria-hidden="true" tabindex="-1"></a><span class="co">anrichtet. Bei den erwarteten RENDITEN ist es schlimmer - aus einem einfachen</span></span>
+<span id="cb181-10"><a href="#cb181-10" aria-hidden="true" tabindex="-1"></a><span class="co">statistischen Grund: Um eine Rendite von 0,04 % pro Tag von null zu</span></span>
+<span id="cb181-11"><a href="#cb181-11" aria-hidden="true" tabindex="-1"></a><span class="co">unterscheiden, braucht man bei 1,2 % Tagesschwankung ueber tausend</span></span>
+<span id="cb181-12"><a href="#cb181-12" aria-hidden="true" tabindex="-1"></a><span class="co">Beobachtungen. Kovarianzen konvergieren dagegen deutlich schneller.</span></span>
+<span id="cb181-13"><a href="#cb181-13" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb181-14"><a href="#cb181-14" aria-hidden="true" tabindex="-1"></a><span class="co">Das Experiment ist bewusst so gebaut, dass die Antwort feststeht: ALLE zwoelf</span></span>
+<span id="cb181-15"><a href="#cb181-15" aria-hidden="true" tabindex="-1"></a><span class="co">Anlagen haben exakt dieselbe wahre Rendite und dieselbe Schwankung. Ein</span></span>
+<span id="cb181-16"><a href="#cb181-16" aria-hidden="true" tabindex="-1"></a><span class="co">korrektes Ergebnis waere also Gleichgewichtung. Was der Optimierer stattdessen</span></span>
+<span id="cb181-17"><a href="#cb181-17" aria-hidden="true" tabindex="-1"></a><span class="co">tut, zeigt der Lauf.</span></span>
+<span id="cb181-18"><a href="#cb181-18" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb181-19"><a href="#cb181-19" aria-hidden="true" tabindex="-1"></a><span class="co">Wiederholt wird 200 mal, damit das Ergebnis nicht von einer Zufallsstichprobe</span></span>
+<span id="cb181-20"><a href="#cb181-20" aria-hidden="true" tabindex="-1"></a><span class="co">abhaengt.</span></span>
+<span id="cb181-21"><a href="#cb181-21" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb181-22"><a href="#cb181-22" aria-hidden="true" tabindex="-1"></a><span class="co">Benoetigt: numpy, cvxpy</span></span>
+<span id="cb181-23"><a href="#cb181-23" aria-hidden="true" tabindex="-1"></a><span class="co">&quot;&quot;&quot;</span></span>
+<span id="cb181-24"><a href="#cb181-24" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb181-25"><a href="#cb181-25" aria-hidden="true" tabindex="-1"></a><span class="im">from</span> __future__ <span class="im">import</span> annotations</span>
+<span id="cb181-26"><a href="#cb181-26" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb181-27"><a href="#cb181-27" aria-hidden="true" tabindex="-1"></a><span class="im">import</span> numpy <span class="im">as</span> np</span>
+<span id="cb181-28"><a href="#cb181-28" aria-hidden="true" tabindex="-1"></a><span class="im">import</span> cvxpy <span class="im">as</span> cp</span>
+<span id="cb181-29"><a href="#cb181-29" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb181-30"><a href="#cb181-30" aria-hidden="true" tabindex="-1"></a>ANZAHL_ANLAGEN <span class="op">=</span> <span class="dv">12</span></span>
+<span id="cb181-31"><a href="#cb181-31" aria-hidden="true" tabindex="-1"></a>BEOBACHTUNGEN <span class="op">=</span> <span class="dv">250</span>              <span class="co"># ein Jahr Tagesdaten</span></span>
+<span id="cb181-32"><a href="#cb181-32" aria-hidden="true" tabindex="-1"></a>BEOBACHTUNGEN_SPAETER <span class="op">=</span> <span class="dv">2000</span>     <span class="co"># der &quot;spaetere Verlauf&quot;</span></span>
+<span id="cb181-33"><a href="#cb181-33" aria-hidden="true" tabindex="-1"></a>WIEDERHOLUNGEN <span class="op">=</span> <span class="dv">200</span></span>
+<span id="cb181-34"><a href="#cb181-34" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb181-35"><a href="#cb181-35" aria-hidden="true" tabindex="-1"></a><span class="co"># Die Wahrheit, die der Optimierer nicht kennt: alle Anlagen sind gleich.</span></span>
+<span id="cb181-36"><a href="#cb181-36" aria-hidden="true" tabindex="-1"></a>WAHRE_RENDITE <span class="op">=</span> <span class="fl">0.0004</span>           <span class="co"># 0,04 % pro Tag</span></span>
+<span id="cb181-37"><a href="#cb181-37" aria-hidden="true" tabindex="-1"></a>WAHRE_SCHWANKUNG <span class="op">=</span> <span class="fl">0.012</span>         <span class="co"># 1,2 % pro Tag</span></span>
+<span id="cb181-38"><a href="#cb181-38" aria-hidden="true" tabindex="-1"></a>RISIKOAVERSION <span class="op">=</span> <span class="fl">10.0</span></span>
+<span id="cb181-39"><a href="#cb181-39" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb181-40"><a href="#cb181-40" aria-hidden="true" tabindex="-1"></a>RNG <span class="op">=</span> np.random.default_rng(<span class="dv">5</span>)</span>
+<span id="cb181-41"><a href="#cb181-41" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb181-42"><a href="#cb181-42" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb181-43"><a href="#cb181-43" aria-hidden="true" tabindex="-1"></a><span class="kw">def</span> baue_optimierer() <span class="op">-&gt;</span> <span class="bu">tuple</span>[cp.Problem, cp.Variable, cp.Parameter, cp.Parameter]:</span>
+<span id="cb181-44"><a href="#cb181-44" aria-hidden="true" tabindex="-1"></a>    <span class="co">&quot;&quot;&quot;Baut das Markowitz-Problem EINMAL mit Parametern.</span></span>
+<span id="cb181-45"><a href="#cb181-45" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb181-46"><a href="#cb181-46" aria-hidden="true" tabindex="-1"></a><span class="co">    Bei 200 Wiederholungen ist das der Unterschied zwischen Sekunden und</span></span>
+<span id="cb181-47"><a href="#cb181-47" aria-hidden="true" tabindex="-1"></a><span class="co">    Minuten: cp.Parameter erlaubt es, nur die Daten zu tauschen, statt den</span></span>
+<span id="cb181-48"><a href="#cb181-48" aria-hidden="true" tabindex="-1"></a><span class="co">    Ausdrucksbaum jedes Mal neu zu kompilieren (siehe Kapitel Oekosystem).</span></span>
+<span id="cb181-49"><a href="#cb181-49" aria-hidden="true" tabindex="-1"></a><span class="co">    &quot;&quot;&quot;</span></span>
+<span id="cb181-50"><a href="#cb181-50" aria-hidden="true" tabindex="-1"></a>    gewichte <span class="op">=</span> cp.Variable(ANZAHL_ANLAGEN, nonneg<span class="op">=</span><span class="va">True</span>)</span>
+<span id="cb181-51"><a href="#cb181-51" aria-hidden="true" tabindex="-1"></a>    renditen <span class="op">=</span> cp.Parameter(ANZAHL_ANLAGEN)</span>
+<span id="cb181-52"><a href="#cb181-52" aria-hidden="true" tabindex="-1"></a>    kovarianz <span class="op">=</span> cp.Parameter((ANZAHL_ANLAGEN, ANZAHL_ANLAGEN), PSD<span class="op">=</span><span class="va">True</span>)</span>
+<span id="cb181-53"><a href="#cb181-53" aria-hidden="true" tabindex="-1"></a>    problem <span class="op">=</span> cp.Problem(</span>
+<span id="cb181-54"><a href="#cb181-54" aria-hidden="true" tabindex="-1"></a>        cp.Maximize(renditen <span class="op">@</span> gewichte</span>
+<span id="cb181-55"><a href="#cb181-55" aria-hidden="true" tabindex="-1"></a>                    <span class="op">-</span> RISIKOAVERSION <span class="op">*</span> cp.quad_form(gewichte, kovarianz)),</span>
+<span id="cb181-56"><a href="#cb181-56" aria-hidden="true" tabindex="-1"></a>        [cp.<span class="bu">sum</span>(gewichte) <span class="op">==</span> <span class="dv">1</span>])</span>
+<span id="cb181-57"><a href="#cb181-57" aria-hidden="true" tabindex="-1"></a>    <span class="cf">return</span> problem, gewichte, renditen, kovarianz</span>
+<span id="cb181-58"><a href="#cb181-58" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb181-59"><a href="#cb181-59" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb181-60"><a href="#cb181-60" aria-hidden="true" tabindex="-1"></a><span class="kw">def</span> erzeuge(perioden: <span class="bu">int</span>) <span class="op">-&gt;</span> np.ndarray:</span>
+<span id="cb181-61"><a href="#cb181-61" aria-hidden="true" tabindex="-1"></a>    <span class="co">&quot;&quot;&quot;Renditen, bei denen alle Anlagen identisch verteilt und unabhaengig sind.&quot;&quot;&quot;</span></span>
+<span id="cb181-62"><a href="#cb181-62" aria-hidden="true" tabindex="-1"></a>    <span class="cf">return</span> RNG.normal(WAHRE_RENDITE, WAHRE_SCHWANKUNG,</span>
+<span id="cb181-63"><a href="#cb181-63" aria-hidden="true" tabindex="-1"></a>                      (perioden, ANZAHL_ANLAGEN))</span>
+<span id="cb181-64"><a href="#cb181-64" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb181-65"><a href="#cb181-65" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb181-66"><a href="#cb181-66" aria-hidden="true" tabindex="-1"></a><span class="cf">if</span> <span class="va">__name__</span> <span class="op">==</span> <span class="st">&quot;__main__&quot;</span>:</span>
+<span id="cb181-67"><a href="#cb181-67" aria-hidden="true" tabindex="-1"></a>    problem, gewichte, renditen, kovarianz <span class="op">=</span> baue_optimierer()</span>
+<span id="cb181-68"><a href="#cb181-68" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb181-69"><a href="#cb181-69" aria-hidden="true" tabindex="-1"></a>    im_zeitraum, spaeter, spaeter_gleich <span class="op">=</span> [], [], []</span>
+<span id="cb181-70"><a href="#cb181-70" aria-hidden="true" tabindex="-1"></a>    groesstes_gewicht, schaetzspanne <span class="op">=</span> [], []</span>
+<span id="cb181-71"><a href="#cb181-71" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb181-72"><a href="#cb181-72" aria-hidden="true" tabindex="-1"></a>    <span class="cf">for</span> _ <span class="kw">in</span> <span class="bu">range</span>(WIEDERHOLUNGEN):</span>
+<span id="cb181-73"><a href="#cb181-73" aria-hidden="true" tabindex="-1"></a>        schaetzdaten <span class="op">=</span> erzeuge(BEOBACHTUNGEN)</span>
+<span id="cb181-74"><a href="#cb181-74" aria-hidden="true" tabindex="-1"></a>        spaetere_daten <span class="op">=</span> erzeuge(BEOBACHTUNGEN_SPAETER)</span>
+<span id="cb181-75"><a href="#cb181-75" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb181-76"><a href="#cb181-76" aria-hidden="true" tabindex="-1"></a>        geschaetzte_rendite <span class="op">=</span> schaetzdaten.mean(axis<span class="op">=</span><span class="dv">0</span>)</span>
+<span id="cb181-77"><a href="#cb181-77" aria-hidden="true" tabindex="-1"></a>        geschaetzte_kovarianz <span class="op">=</span> np.cov(schaetzdaten, rowvar<span class="op">=</span><span class="va">False</span>)</span>
+<span id="cb181-78"><a href="#cb181-78" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb181-79"><a href="#cb181-79" aria-hidden="true" tabindex="-1"></a>        renditen.value <span class="op">=</span> geschaetzte_rendite</span>
+<span id="cb181-80"><a href="#cb181-80" aria-hidden="true" tabindex="-1"></a>        <span class="co"># Symmetrisieren und minimal anheben: numerisches Rauschen kann die</span></span>
+<span id="cb181-81"><a href="#cb181-81" aria-hidden="true" tabindex="-1"></a>        <span class="co"># Matrix sonst knapp unter die PSD-Grenze druecken (Kapitel Fundament).</span></span>
+<span id="cb181-82"><a href="#cb181-82" aria-hidden="true" tabindex="-1"></a>        kovarianz.value <span class="op">=</span> ((geschaetzte_kovarianz <span class="op">+</span> geschaetzte_kovarianz.T) <span class="op">/</span> <span class="dv">2</span></span>
+<span id="cb181-83"><a href="#cb181-83" aria-hidden="true" tabindex="-1"></a>                           <span class="op">+</span> <span class="fl">1e-10</span> <span class="op">*</span> np.eye(ANZAHL_ANLAGEN))</span>
+<span id="cb181-84"><a href="#cb181-84" aria-hidden="true" tabindex="-1"></a>        problem.solve()</span>
+<span id="cb181-85"><a href="#cb181-85" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb181-86"><a href="#cb181-86" aria-hidden="true" tabindex="-1"></a>        w <span class="op">=</span> np.array(gewichte.value).ravel()</span>
+<span id="cb181-87"><a href="#cb181-87" aria-hidden="true" tabindex="-1"></a>        im_zeitraum.append(<span class="bu">float</span>((schaetzdaten <span class="op">@</span> w).mean()))</span>
+<span id="cb181-88"><a href="#cb181-88" aria-hidden="true" tabindex="-1"></a>        spaeter.append(<span class="bu">float</span>((spaetere_daten <span class="op">@</span> w).mean()))</span>
+<span id="cb181-89"><a href="#cb181-89" aria-hidden="true" tabindex="-1"></a>        spaeter_gleich.append(<span class="bu">float</span>(spaetere_daten.mean()))</span>
+<span id="cb181-90"><a href="#cb181-90" aria-hidden="true" tabindex="-1"></a>        groesstes_gewicht.append(<span class="bu">float</span>(w.<span class="bu">max</span>()))</span>
+<span id="cb181-91"><a href="#cb181-91" aria-hidden="true" tabindex="-1"></a>        schaetzspanne.append(<span class="bu">float</span>(geschaetzte_rendite.<span class="bu">max</span>()</span>
+<span id="cb181-92"><a href="#cb181-92" aria-hidden="true" tabindex="-1"></a>                                   <span class="op">-</span> geschaetzte_rendite.<span class="bu">min</span>()))</span>
+<span id="cb181-93"><a href="#cb181-93" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb181-94"><a href="#cb181-94" aria-hidden="true" tabindex="-1"></a>    prozent <span class="op">=</span> <span class="kw">lambda</span> werte: <span class="bu">float</span>(np.mean(werte)) <span class="op">*</span> <span class="dv">100</span></span>
+<span id="cb181-95"><a href="#cb181-95" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb181-96"><a href="#cb181-96" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;=&quot;</span> <span class="op">*</span> <span class="dv">78</span>)</span>
+<span id="cb181-97"><a href="#cb181-97" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;  WENN DER OPTIMIERER GESCHAETZTE RENDITEN GLAUBT&quot;</span>)</span>
+<span id="cb181-98"><a href="#cb181-98" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;=&quot;</span> <span class="op">*</span> <span class="dv">78</span>)</span>
+<span id="cb181-99"><a href="#cb181-99" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;</span><span class="sc">{</span>ANZAHL_ANLAGEN<span class="sc">}</span><span class="ss"> Anlagen, </span><span class="sc">{</span>WIEDERHOLUNGEN<span class="sc">}</span><span class="ss"> Wiederholungen, &quot;</span></span>
+<span id="cb181-100"><a href="#cb181-100" aria-hidden="true" tabindex="-1"></a>          <span class="ss">f&quot;je </span><span class="sc">{</span>BEOBACHTUNGEN<span class="sc">}</span><span class="ss"> Beobachtungen zur Schaetzung.&quot;</span>)</span>
+<span id="cb181-101"><a href="#cb181-101" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;In Wahrheit haben ALLE dieselbe Tagesrendite von &quot;</span></span>
+<span id="cb181-102"><a href="#cb181-102" aria-hidden="true" tabindex="-1"></a>          <span class="ss">f&quot;</span><span class="sc">{</span>WAHRE_RENDITE <span class="op">*</span> <span class="dv">100</span><span class="sc">:.4f}</span><span class="ss"> % und dieselbe Schwankung.&quot;</span>)</span>
+<span id="cb181-103"><a href="#cb181-103" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;Die richtige Antwort waere also: gleichgewichten.&quot;</span>)</span>
+<span id="cb181-104"><a href="#cb181-104" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>()</span>
+<span id="cb181-105"><a href="#cb181-105" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;Mittlere Spanne der geschaetzten Renditen: &quot;</span></span>
+<span id="cb181-106"><a href="#cb181-106" aria-hidden="true" tabindex="-1"></a>          <span class="ss">f&quot;</span><span class="sc">{</span>prozent(schaetzspanne)<span class="sc">:.4f}</span><span class="ss"> Prozentpunkte&quot;</span>)</span>
+<span id="cb181-107"><a href="#cb181-107" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;  -&gt; Das ist das </span><span class="sc">{</span>prozent(schaetzspanne) <span class="op">/</span> (WAHRE_RENDITE <span class="op">*</span> <span class="dv">100</span>)<span class="sc">:.1f}</span><span class="ss">-Fache &quot;</span></span>
+<span id="cb181-108"><a href="#cb181-108" aria-hidden="true" tabindex="-1"></a>          <span class="ss">f&quot;des wahren Werts. Aus reinem Rauschen.&quot;</span>)</span>
+<span id="cb181-109"><a href="#cb181-109" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;Mittleres groesstes Einzelgewicht: &quot;</span></span>
+<span id="cb181-110"><a href="#cb181-110" aria-hidden="true" tabindex="-1"></a>          <span class="ss">f&quot;</span><span class="sc">{</span>prozent(groesstes_gewicht)<span class="sc">:.1f}</span><span class="ss"> % &quot;</span></span>
+<span id="cb181-111"><a href="#cb181-111" aria-hidden="true" tabindex="-1"></a>          <span class="ss">f&quot;(bei Gleichgewichtung waeren es </span><span class="sc">{</span><span class="dv">100</span> <span class="op">/</span> ANZAHL_ANLAGEN<span class="sc">:.1f}</span><span class="ss"> %)&quot;</span>)</span>
+<span id="cb181-112"><a href="#cb181-112" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>()</span>
+<span id="cb181-113"><a href="#cb181-113" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;</span><span class="sc">{</span><span class="st">&#39;&#39;</span><span class="sc">:&lt;38}</span><span class="ss"> </span><span class="sc">{</span><span class="st">&#39;Tagesrendite&#39;</span><span class="sc">:&gt;14}</span><span class="ss">&quot;</span>)</span>
+<span id="cb181-114"><a href="#cb181-114" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;-&quot;</span> <span class="op">*</span> <span class="dv">78</span>)</span>
+<span id="cb181-115"><a href="#cb181-115" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;</span><span class="sc">{</span><span class="st">&#39;Wahrheit (alle Anlagen)&#39;</span><span class="sc">:&lt;38}</span><span class="ss"> </span><span class="sc">{</span>WAHRE_RENDITE <span class="op">*</span> <span class="dv">100</span><span class="sc">:&gt;13.4f}</span><span class="ss"> %&quot;</span>)</span>
+<span id="cb181-116"><a href="#cb181-116" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;</span><span class="sc">{</span><span class="st">&#39;Optimierer IM Schaetzzeitraum&#39;</span><span class="sc">:&lt;38}</span><span class="ss"> </span><span class="sc">{</span>prozent(im_zeitraum)<span class="sc">:&gt;13.4f}</span><span class="ss"> %&quot;</span></span>
+<span id="cb181-117"><a href="#cb181-117" aria-hidden="true" tabindex="-1"></a>          <span class="ss">f&quot;   &lt;- Illusion&quot;</span>)</span>
+<span id="cb181-118"><a href="#cb181-118" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;</span><span class="sc">{</span><span class="st">&#39;Optimierer AUSSERHALB&#39;</span><span class="sc">:&lt;38}</span><span class="ss"> </span><span class="sc">{</span>prozent(spaeter)<span class="sc">:&gt;13.4f}</span><span class="ss"> %&quot;</span>)</span>
+<span id="cb181-119"><a href="#cb181-119" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;</span><span class="sc">{</span><span class="st">&#39;Gleichgewichtung AUSSERHALB&#39;</span><span class="sc">:&lt;38}</span><span class="ss"> </span><span class="sc">{</span>prozent(spaeter_gleich)<span class="sc">:&gt;13.4f}</span><span class="ss"> %&quot;</span>)</span>
+<span id="cb181-120"><a href="#cb181-120" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;-&quot;</span> <span class="op">*</span> <span class="dv">78</span>)</span>
+<span id="cb181-121"><a href="#cb181-121" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb181-122"><a href="#cb181-122" aria-hidden="true" tabindex="-1"></a>    faktor <span class="op">=</span> prozent(im_zeitraum) <span class="op">/</span> (WAHRE_RENDITE <span class="op">*</span> <span class="dv">100</span>)</span>
+<span id="cb181-123"><a href="#cb181-123" aria-hidden="true" tabindex="-1"></a>    vorsprung <span class="op">=</span> prozent(spaeter) <span class="op">-</span> prozent(spaeter_gleich)</span>
+<span id="cb181-124"><a href="#cb181-124" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;</span><span class="ch">\n</span><span class="ss">Im Schaetzzeitraum verspricht der Optimierer das &quot;</span></span>
+<span id="cb181-125"><a href="#cb181-125" aria-hidden="true" tabindex="-1"></a>          <span class="ss">f&quot;</span><span class="sc">{</span>faktor<span class="sc">:.1f}</span><span class="ss">-Fache der wahren Rendite.&quot;</span>)</span>
+<span id="cb181-126"><a href="#cb181-126" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;Ausserhalb bleibt davon nichts: Er liegt </span><span class="sc">{</span><span class="bu">abs</span>(vorsprung)<span class="sc">:.4f}</span><span class="ss"> &quot;</span></span>
+<span id="cb181-127"><a href="#cb181-127" aria-hidden="true" tabindex="-1"></a>          <span class="ss">f&quot;Prozentpunkte&quot;</span>)</span>
+<span id="cb181-128"><a href="#cb181-128" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;</span><span class="sc">{</span><span class="st">&#39;schlechter&#39;</span> <span class="cf">if</span> vorsprung <span class="op">&lt;</span> <span class="dv">0</span> <span class="cf">else</span> <span class="st">&#39;besser&#39;</span><span class="sc">}</span><span class="ss"> als blosse Gleichgewichtung.&quot;</span>)</span>
+<span id="cb181-129"><a href="#cb181-129" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>()</span>
+<span id="cb181-130"><a href="#cb181-130" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;Der Grund ist statistisch, nicht finanzwirtschaftlich: Um eine&quot;</span>)</span>
+<span id="cb181-131"><a href="#cb181-131" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;Rendite von </span><span class="sc">{</span>WAHRE_RENDITE<span class="op">*</span><span class="dv">100</span><span class="sc">:.2f}</span><span class="ss"> % taeglich von null zu unterscheiden,&quot;</span>)</span>
+<span id="cb181-132"><a href="#cb181-132" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;braucht man bei </span><span class="sc">{</span>WAHRE_SCHWANKUNG<span class="op">*</span><span class="dv">100</span><span class="sc">:.1f}</span><span class="ss"> % Schwankung ueber tausend&quot;</span>)</span>
+<span id="cb181-133"><a href="#cb181-133" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;Beobachtungen. Mit 250 misst man ueberwiegend Rauschen - und der&quot;</span>)</span>
+<span id="cb181-134"><a href="#cb181-134" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;Optimierer nimmt jedes Rauschen fuer bare Muenze.&quot;</span>)</span>
+<span id="cb181-135"><a href="#cb181-135" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>()</span>
+<span id="cb181-136"><a href="#cb181-136" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;Drei praktische Konsequenzen:&quot;</span>)</span>
+<span id="cb181-137"><a href="#cb181-137" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;  1. Verzichten Sie auf Renditeschaetzungen, wo es geht. Das&quot;</span>)</span>
+<span id="cb181-138"><a href="#cb181-138" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;     Minimum-Varianz-Portfolio braucht gar keine.&quot;</span>)</span>
+<span id="cb181-139"><a href="#cb181-139" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;  2. Wenn Sie welche brauchen: schrumpfen Sie sie stark zur Mitte&quot;</span>)</span>
+<span id="cb181-140"><a href="#cb181-140" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;     (James-Stein, Black-Litterman) - viel staerker als Kovarianzen.&quot;</span>)</span>
+<span id="cb181-141"><a href="#cb181-141" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;  3. Begrenzen Sie Einzelgewichte. Was der Optimierer nicht darf,&quot;</span>)</span>
+<span id="cb181-142"><a href="#cb181-142" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;     kann er auch nicht auf Rauschen setzen.&quot;</span>)</span>
+<span id="cb181-143"><a href="#cb181-143" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;=&quot;</span> <span class="op">*</span> <span class="dv">78</span>)</span></code></pre></div>
 <p><strong>Erwartete Ausgabe:</strong></p>
 <pre><code>==============================================================================
   WENN DER OPTIMIERER GESCHAETZTE RENDITEN GLAUBT
@@ -22987,7 +23963,7 @@ Drei praktische Konsequenzen:
 <hr />
 <h2 id="sec:markowitz-quiz">19.9 Micro-Quiz</h2>
 <blockquote>
-<p><strong>❓ Micro-Quiz 12: Drei Fragen zum Selbstcheck</strong></p>
+<p><strong>❓ Micro-Quiz 19: Drei Fragen zum Selbstcheck</strong></p>
 <p>Genau eine Antwort ist jeweils richtig. Auflösung in <a href="#quiz-loesung-markowitz">Anhang A</a>.</p>
 <p><strong>1. Auf der Effizienzlinie liegt das Portfolio mit der höchsten Rendite. Warum ist es trotzdem selten die richtige Wahl?</strong> (a) Weil es rechnerisch instabil ist. (b) Weil es das schlechteste Verhältnis von Rendite zu Risiko hat und zwangsläufig vollständig in die renditestärkste Einzelanlage geht — also gar nicht mehr diversifiziert ist. (c) Weil CVXPY dort keine Lösung mehr findet.</p>
 <p><strong>2. Warum ist das Minimum-Varianz-Portfolio in der Praxis oft robuster als das Maximum-Sharpe-Portfolio?</strong> (a) Weil es weniger Nebenbedingungen hat. (b) Weil es <strong>ohne Renditeschätzung</strong> auskommt. Renditen sind die mit Abstand am unzuverlässigsten geschätzte Eingangsgröße; wer sie nicht braucht, umgeht das Problem. (c) Weil es immer die höhere Rendite erzielt.</p>
@@ -23041,17 +24017,17 @@ Drei praktische Konsequenzen:
 <li><strong>Anlage A:</strong> sechsmal −3 %.</li>
 <li><strong>Anlage B:</strong> fünfmal −3 % — und einmal <strong>−40 %</strong>.</li>
 </ul>
-<div class="sourceCode" id="cb181"><pre class="sourceCode python"><code class="sourceCode python"><span id="cb181-1"><a href="#cb181-1" aria-hidden="true" tabindex="-1"></a><span class="im">import</span> numpy <span class="im">as</span> np</span>
-<span id="cb181-2"><a href="#cb181-2" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb181-3"><a href="#cb181-3" aria-hidden="true" tabindex="-1"></a>gut <span class="op">=</span> np.full(<span class="dv">94</span>, <span class="fl">0.5</span>)</span>
-<span id="cb181-4"><a href="#cb181-4" aria-hidden="true" tabindex="-1"></a>A <span class="op">=</span> np.concatenate([gut, np.full(<span class="dv">6</span>, <span class="op">-</span><span class="fl">3.0</span>)])</span>
-<span id="cb181-5"><a href="#cb181-5" aria-hidden="true" tabindex="-1"></a>B <span class="op">=</span> np.concatenate([gut, np.full(<span class="dv">5</span>, <span class="op">-</span><span class="fl">3.0</span>), [<span class="op">-</span><span class="fl">40.0</span>]])</span>
-<span id="cb181-6"><a href="#cb181-6" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb181-7"><a href="#cb181-7" aria-hidden="true" tabindex="-1"></a><span class="cf">for</span> name, r <span class="kw">in</span> [(<span class="st">&quot;Anlage A&quot;</span>, A), (<span class="st">&quot;Anlage B&quot;</span>, B)]:</span>
-<span id="cb181-8"><a href="#cb181-8" aria-hidden="true" tabindex="-1"></a>    schwelle <span class="op">=</span> np.percentile(r, <span class="dv">5</span>)               <span class="co"># 5-%-Quantil</span></span>
-<span id="cb181-9"><a href="#cb181-9" aria-hidden="true" tabindex="-1"></a>    var <span class="op">=</span> <span class="op">-</span>schwelle                              <span class="co"># Value at Risk</span></span>
-<span id="cb181-10"><a href="#cb181-10" aria-hidden="true" tabindex="-1"></a>    cvar <span class="op">=</span> <span class="op">-</span>r[r <span class="op">&lt;=</span> schwelle].mean()              <span class="co"># Mittel der schlimmsten 5 %</span></span>
-<span id="cb181-11"><a href="#cb181-11" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;</span><span class="sc">{</span>name<span class="sc">}</span><span class="ss">: VaR(95) </span><span class="sc">{</span>var<span class="sc">:5.2f}</span><span class="ss"> %   CVaR(95) </span><span class="sc">{</span>cvar<span class="sc">:5.2f}</span><span class="ss"> %&quot;</span>)</span></code></pre></div>
+<div class="sourceCode" id="cb183"><pre class="sourceCode python"><code class="sourceCode python"><span id="cb183-1"><a href="#cb183-1" aria-hidden="true" tabindex="-1"></a><span class="im">import</span> numpy <span class="im">as</span> np</span>
+<span id="cb183-2"><a href="#cb183-2" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb183-3"><a href="#cb183-3" aria-hidden="true" tabindex="-1"></a>gut <span class="op">=</span> np.full(<span class="dv">94</span>, <span class="fl">0.5</span>)</span>
+<span id="cb183-4"><a href="#cb183-4" aria-hidden="true" tabindex="-1"></a>A <span class="op">=</span> np.concatenate([gut, np.full(<span class="dv">6</span>, <span class="op">-</span><span class="fl">3.0</span>)])</span>
+<span id="cb183-5"><a href="#cb183-5" aria-hidden="true" tabindex="-1"></a>B <span class="op">=</span> np.concatenate([gut, np.full(<span class="dv">5</span>, <span class="op">-</span><span class="fl">3.0</span>), [<span class="op">-</span><span class="fl">40.0</span>]])</span>
+<span id="cb183-6"><a href="#cb183-6" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb183-7"><a href="#cb183-7" aria-hidden="true" tabindex="-1"></a><span class="cf">for</span> name, r <span class="kw">in</span> [(<span class="st">&quot;Anlage A&quot;</span>, A), (<span class="st">&quot;Anlage B&quot;</span>, B)]:</span>
+<span id="cb183-8"><a href="#cb183-8" aria-hidden="true" tabindex="-1"></a>    schwelle <span class="op">=</span> np.percentile(r, <span class="dv">5</span>)               <span class="co"># 5-%-Quantil</span></span>
+<span id="cb183-9"><a href="#cb183-9" aria-hidden="true" tabindex="-1"></a>    var <span class="op">=</span> <span class="op">-</span>schwelle                              <span class="co"># Value at Risk</span></span>
+<span id="cb183-10"><a href="#cb183-10" aria-hidden="true" tabindex="-1"></a>    cvar <span class="op">=</span> <span class="op">-</span>r[r <span class="op">&lt;=</span> schwelle].mean()              <span class="co"># Mittel der schlimmsten 5 %</span></span>
+<span id="cb183-11"><a href="#cb183-11" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;</span><span class="sc">{</span>name<span class="sc">}</span><span class="ss">: VaR(95) </span><span class="sc">{</span>var<span class="sc">:5.2f}</span><span class="ss"> %   CVaR(95) </span><span class="sc">{</span>cvar<span class="sc">:5.2f}</span><span class="ss"> %&quot;</span>)</span></code></pre></div>
 <p><strong>Ausgabe:</strong></p>
 <pre><code>Anlage A: VaR(95)  3.00 %   CVaR(95)  3.00 %
 Anlage B: VaR(95)  3.00 %   CVaR(95)  9.17 %</code></pre>
@@ -23106,111 +24082,111 @@ Anlage B: VaR(95)  3.00 %   CVaR(95)  9.17 %</code></pre>
 <h2 id="sec:cvar-die-zwei-schwaechen-des-markowitz-modells">20.3 Die zwei Schwächen des Markowitz-Modells</h2>
 <p><strong>Erstens: die Normalverteilungs-Illusion.</strong> Die Varianz behandelt Aufwärts- und Abwärtsschwankungen gleich und unterstellt implizit symmetrische, dünn auslaufende Verteilungen. Reale Marktrenditen haben aber <strong>fette Ränder</strong> (<em>fat tails</em>) und <strong>negative Schiefe</strong>: Extreme Verluste treten deutlich häufiger auf, als eine Normalverteilung vorhersagt.</p>
 <p><strong>Zweitens: Reibungsblindheit.</strong> Ein ungedämpftes Mean-Variance-Modell schichtet bei minimalen Schätzänderungen das gesamte Portfolio um. Ohne Berücksichtigung von Gebühren, Spreads und Steuern frisst der Umschlag (<em>turnover</em>) den theoretischen Mehrertrag auf.</p>
-<div class="sourceCode" id="cb183"><pre class="sourceCode python"><code class="sourceCode python"><span id="cb183-1"><a href="#cb183-1" aria-hidden="true" tabindex="-1"></a><span class="co">#!/usr/bin/env python3</span></span>
-<span id="cb183-2"><a href="#cb183-2" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb183-3"><a href="#cb183-3" aria-hidden="true" tabindex="-1"></a><span class="co"># VaR_CVaR_Demo.py</span></span>
-<span id="cb183-4"><a href="#cb183-4" aria-hidden="true" tabindex="-1"></a><span class="co">&quot;&quot;&quot;</span></span>
-<span id="cb183-5"><a href="#cb183-5" aria-hidden="true" tabindex="-1"></a><span class="co">Kapitel CVaR: Fat Tails, VaR und CVaR anschaulich.</span></span>
-<span id="cb183-6"><a href="#cb183-6" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb183-7"><a href="#cb183-7" aria-hidden="true" tabindex="-1"></a><span class="co">Teil 1: Wie oft treten &quot;unmoegliche&quot; Tage wirklich auf?</span></span>
-<span id="cb183-8"><a href="#cb183-8" aria-hidden="true" tabindex="-1"></a><span class="co">Teil 2: Warum ist der VaR nicht subadditiv - ein Gegenbeispiel zum Nachrechnen.</span></span>
-<span id="cb183-9"><a href="#cb183-9" aria-hidden="true" tabindex="-1"></a><span class="co">&quot;&quot;&quot;</span></span>
-<span id="cb183-10"><a href="#cb183-10" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb183-11"><a href="#cb183-11" aria-hidden="true" tabindex="-1"></a><span class="im">import</span> numpy <span class="im">as</span> np</span>
-<span id="cb183-12"><a href="#cb183-12" aria-hidden="true" tabindex="-1"></a><span class="im">from</span> scipy <span class="im">import</span> stats</span>
-<span id="cb183-13"><a href="#cb183-13" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb183-14"><a href="#cb183-14" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb183-15"><a href="#cb183-15" aria-hidden="true" tabindex="-1"></a><span class="kw">def</span> var_quantil(verluste: np.ndarray, alpha: <span class="bu">float</span> <span class="op">=</span> <span class="fl">0.95</span>) <span class="op">-&gt;</span> <span class="bu">float</span>:</span>
-<span id="cb183-16"><a href="#cb183-16" aria-hidden="true" tabindex="-1"></a>    <span class="co">&quot;&quot;&quot;VaR = Quantil der Verlustverteilung (Verluste positiv, Gewinne negativ).&quot;&quot;&quot;</span></span>
-<span id="cb183-17"><a href="#cb183-17" aria-hidden="true" tabindex="-1"></a>    <span class="cf">return</span> <span class="bu">float</span>(np.quantile(verluste, alpha))</span>
-<span id="cb183-18"><a href="#cb183-18" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb183-19"><a href="#cb183-19" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb183-20"><a href="#cb183-20" aria-hidden="true" tabindex="-1"></a><span class="kw">def</span> cvar_rockafellar(verluste: np.ndarray, alpha: <span class="bu">float</span> <span class="op">=</span> <span class="fl">0.95</span>) <span class="op">-&gt;</span> <span class="bu">float</span>:</span>
-<span id="cb183-21"><a href="#cb183-21" aria-hidden="true" tabindex="-1"></a>    <span class="co">&quot;&quot;&quot;</span></span>
-<span id="cb183-22"><a href="#cb183-22" aria-hidden="true" tabindex="-1"></a><span class="co">    CVaR ueber die Rockafellar-Uryasev-Formel:</span></span>
-<span id="cb183-23"><a href="#cb183-23" aria-hidden="true" tabindex="-1"></a><span class="co">        CVaR = min_gamma { gamma + 1/(1-alpha) * E[max(Verlust - gamma, 0)] }</span></span>
-<span id="cb183-24"><a href="#cb183-24" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb183-25"><a href="#cb183-25" aria-hidden="true" tabindex="-1"></a><span class="co">    WICHTIG: Der naheliegende Weg &quot;Mittelwert aller Werte &gt;= VaR&quot; ist FALSCH,</span></span>
-<span id="cb183-26"><a href="#cb183-26" aria-hidden="true" tabindex="-1"></a><span class="co">    sobald die Verteilung Atome hat (z. B. genau zwei moegliche Verluste).</span></span>
-<span id="cb183-27"><a href="#cb183-27" aria-hidden="true" tabindex="-1"></a><span class="co">    Dann liegt der VaR selbst auf einem Atom, und der Vergleich &#39;&gt;=&#39; erfasst</span></span>
-<span id="cb183-28"><a href="#cb183-28" aria-hidden="true" tabindex="-1"></a><span class="co">    zu viel Wahrscheinlichkeitsmasse. Die Formel unten behandelt das korrekt -</span></span>
-<span id="cb183-29"><a href="#cb183-29" aria-hidden="true" tabindex="-1"></a><span class="co">    und ist zugleich genau der Ausdruck, den wir im Abschnitt &#39;Value at Risk</span></span>
-<span id="cb183-30"><a href="#cb183-30" aria-hidden="true" tabindex="-1"></a><span class="co">    und Conditional Value at Risk&#39; optimieren.</span></span>
-<span id="cb183-31"><a href="#cb183-31" aria-hidden="true" tabindex="-1"></a><span class="co">    &quot;&quot;&quot;</span></span>
-<span id="cb183-32"><a href="#cb183-32" aria-hidden="true" tabindex="-1"></a>    kandidaten <span class="op">=</span> np.unique(verluste)          <span class="co"># Optimum liegt immer auf einem Datenpunkt</span></span>
-<span id="cb183-33"><a href="#cb183-33" aria-hidden="true" tabindex="-1"></a>    <span class="cf">return</span> <span class="bu">float</span>(<span class="bu">min</span>(g <span class="op">+</span> np.mean(np.maximum(verluste <span class="op">-</span> g, <span class="fl">0.0</span>)) <span class="op">/</span> (<span class="fl">1.0</span> <span class="op">-</span> alpha)</span>
-<span id="cb183-34"><a href="#cb183-34" aria-hidden="true" tabindex="-1"></a>                     <span class="cf">for</span> g <span class="kw">in</span> kandidaten))</span>
-<span id="cb183-35"><a href="#cb183-35" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb183-36"><a href="#cb183-36" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb183-37"><a href="#cb183-37" aria-hidden="true" tabindex="-1"></a><span class="cf">if</span> <span class="va">__name__</span> <span class="op">==</span> <span class="st">&quot;__main__&quot;</span>:</span>
-<span id="cb183-38"><a href="#cb183-38" aria-hidden="true" tabindex="-1"></a>    rng <span class="op">=</span> np.random.default_rng(<span class="dv">2026</span>)</span>
-<span id="cb183-39"><a href="#cb183-39" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb183-40"><a href="#cb183-40" aria-hidden="true" tabindex="-1"></a>    <span class="co"># --- Teil 1: Fat Tails (analytisch, nicht simuliert) ------------------</span></span>
-<span id="cb183-41"><a href="#cb183-41" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;=&quot;</span> <span class="op">*</span> <span class="dv">88</span>)</span>
-<span id="cb183-42"><a href="#cb183-42" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;  TEIL 1: WIE OFT TRITT DAS &#39;UNMOEGLICHE&#39; EIN?&quot;</span>)</span>
-<span id="cb183-43"><a href="#cb183-43" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;=&quot;</span> <span class="op">*</span> <span class="dv">88</span>)</span>
-<span id="cb183-44"><a href="#cb183-44" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;Vergleich: Normalverteilung gegen t-Verteilung mit 3 Freiheitsgraden&quot;</span>)</span>
-<span id="cb183-45"><a href="#cb183-45" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;(beide auf Standardabweichung 1 normiert).</span><span class="ch">\n</span><span class="st">&quot;</span>)</span>
-<span id="cb183-46"><a href="#cb183-46" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb183-47"><a href="#cb183-47" aria-hidden="true" tabindex="-1"></a>    t_verteilung <span class="op">=</span> stats.t(df<span class="op">=</span><span class="dv">3</span>)</span>
-<span id="cb183-48"><a href="#cb183-48" aria-hidden="true" tabindex="-1"></a>    skalierung <span class="op">=</span> t_verteilung.std()            <span class="co"># auf Varianz 1 bringen</span></span>
-<span id="cb183-49"><a href="#cb183-49" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb183-50"><a href="#cb183-50" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;</span><span class="sc">{</span><span class="st">&#39;Ereignis&#39;</span><span class="sc">:&lt;22}</span><span class="ss"> </span><span class="sc">{</span><span class="st">&#39;Normal&#39;</span><span class="sc">:&gt;14}</span><span class="ss"> </span><span class="sc">{</span><span class="st">&#39;t (df=3)&#39;</span><span class="sc">:&gt;14}</span><span class="ss"> </span><span class="sc">{</span><span class="st">&#39;Faktor&#39;</span><span class="sc">:&gt;11}</span><span class="ss"> &quot;</span></span>
-<span id="cb183-51"><a href="#cb183-51" aria-hidden="true" tabindex="-1"></a>          <span class="ss">f&quot;</span><span class="sc">{</span><span class="st">&#39;Normal: 1 Tag in&#39;</span><span class="sc">:&gt;18}</span><span class="ss">&quot;</span>)</span>
-<span id="cb183-52"><a href="#cb183-52" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;-&quot;</span> <span class="op">*</span> <span class="dv">88</span>)</span>
-<span id="cb183-53"><a href="#cb183-53" aria-hidden="true" tabindex="-1"></a>    <span class="cf">for</span> k <span class="kw">in</span> [<span class="dv">3</span>, <span class="dv">4</span>, <span class="dv">5</span>, <span class="dv">6</span>]:</span>
-<span id="cb183-54"><a href="#cb183-54" aria-hidden="true" tabindex="-1"></a>        p_normal <span class="op">=</span> <span class="dv">2</span> <span class="op">*</span> stats.norm.sf(k)                     <span class="co"># beidseitig</span></span>
-<span id="cb183-55"><a href="#cb183-55" aria-hidden="true" tabindex="-1"></a>        p_t <span class="op">=</span> <span class="dv">2</span> <span class="op">*</span> t_verteilung.sf(k <span class="op">*</span> skalierung)</span>
-<span id="cb183-56"><a href="#cb183-56" aria-hidden="true" tabindex="-1"></a>        <span class="bu">print</span>(<span class="ss">f&quot;Abweichung &gt; </span><span class="sc">{</span>k<span class="sc">}</span><span class="ss"> Sigma  </span><span class="sc">{</span>p_normal<span class="op">*</span><span class="dv">100</span><span class="sc">:&gt;13.6f}</span><span class="ss"> % </span><span class="sc">{</span>p_t<span class="op">*</span><span class="dv">100</span><span class="sc">:&gt;13.6f}</span><span class="ss"> % &quot;</span></span>
-<span id="cb183-57"><a href="#cb183-57" aria-hidden="true" tabindex="-1"></a>              <span class="ss">f&quot;</span><span class="sc">{</span>p_t<span class="op">/</span>p_normal<span class="sc">:&gt;10.1f}</span><span class="ss">x </span><span class="sc">{</span><span class="dv">1</span><span class="op">/</span>p_normal<span class="op">/</span><span class="dv">252</span><span class="sc">:&gt;15,.0f}</span><span class="ss"> Jahre&quot;</span>)</span>
-<span id="cb183-58"><a href="#cb183-58" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb183-59"><a href="#cb183-59" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;</span><span class="ch">\n</span><span class="st">Deutung: Ein 5-Sigma-Tag ist unter Normalverteilung ein Ereignis von&quot;</span>)</span>
-<span id="cb183-60"><a href="#cb183-60" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;etwa einmal in 6.900 Jahren. Reale Aktienmaerkte liefern solche Tage&quot;</span>)</span>
-<span id="cb183-61"><a href="#cb183-61" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;mehrfach pro Jahrzehnt. Wer allein mit Varianz steuert, plant fuer&quot;</span>)</span>
-<span id="cb183-62"><a href="#cb183-62" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;eine Welt, in der Crashs praktisch nicht vorkommen.&quot;</span>)</span>
-<span id="cb183-63"><a href="#cb183-63" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb183-64"><a href="#cb183-64" aria-hidden="true" tabindex="-1"></a>    <span class="co"># --- Teil 2: VaR ist nicht subadditiv ---------------------------------</span></span>
-<span id="cb183-65"><a href="#cb183-65" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;</span><span class="ch">\n</span><span class="st">&quot;</span> <span class="op">+</span> <span class="st">&quot;=&quot;</span> <span class="op">*</span> <span class="dv">88</span>)</span>
-<span id="cb183-66"><a href="#cb183-66" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;  TEIL 2: WARUM DER VaR KEIN KOHAERENTES RISIKOMASS IST&quot;</span>)</span>
-<span id="cb183-67"><a href="#cb183-67" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;=&quot;</span> <span class="op">*</span> <span class="dv">88</span>)</span>
-<span id="cb183-68"><a href="#cb183-68" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;Zwei unabhaengige Anleihen, je 100 EUR Nominal.&quot;</span>)</span>
-<span id="cb183-69"><a href="#cb183-69" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;Jede faellt mit 4 % Wahrscheinlichkeit aus (Verlust 100),&quot;</span>)</span>
-<span id="cb183-70"><a href="#cb183-70" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;sonst zahlt sie 2 EUR Kupon (Verlust -2).</span><span class="ch">\n</span><span class="st">&quot;</span>)</span>
-<span id="cb183-71"><a href="#cb183-71" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb183-72"><a href="#cb183-72" aria-hidden="true" tabindex="-1"></a>    ziehungen <span class="op">=</span> <span class="dv">2_000_000</span></span>
-<span id="cb183-73"><a href="#cb183-73" aria-hidden="true" tabindex="-1"></a>    verlust_a <span class="op">=</span> np.where(rng.random(ziehungen) <span class="op">&lt;</span> <span class="fl">0.04</span>, <span class="fl">100.0</span>, <span class="op">-</span><span class="fl">2.0</span>)</span>
-<span id="cb183-74"><a href="#cb183-74" aria-hidden="true" tabindex="-1"></a>    verlust_b <span class="op">=</span> np.where(rng.random(ziehungen) <span class="op">&lt;</span> <span class="fl">0.04</span>, <span class="fl">100.0</span>, <span class="op">-</span><span class="fl">2.0</span>)</span>
-<span id="cb183-75"><a href="#cb183-75" aria-hidden="true" tabindex="-1"></a>    verlust_ab <span class="op">=</span> verlust_a <span class="op">+</span> verlust_b</span>
-<span id="cb183-76"><a href="#cb183-76" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb183-77"><a href="#cb183-77" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;</span><span class="sc">{</span><span class="st">&#39;&#39;</span><span class="sc">:&lt;28}</span><span class="ss"> </span><span class="sc">{</span><span class="st">&#39;VaR 95%&#39;</span><span class="sc">:&gt;12}</span><span class="ss"> </span><span class="sc">{</span><span class="st">&#39;CVaR 95%&#39;</span><span class="sc">:&gt;12}</span><span class="ss">&quot;</span>)</span>
-<span id="cb183-78"><a href="#cb183-78" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;-&quot;</span> <span class="op">*</span> <span class="dv">88</span>)</span>
-<span id="cb183-79"><a href="#cb183-79" aria-hidden="true" tabindex="-1"></a>    werte <span class="op">=</span> {}</span>
-<span id="cb183-80"><a href="#cb183-80" aria-hidden="true" tabindex="-1"></a>    <span class="cf">for</span> name, v <span class="kw">in</span> [(<span class="st">&quot;Anleihe A allein&quot;</span>, verlust_a),</span>
-<span id="cb183-81"><a href="#cb183-81" aria-hidden="true" tabindex="-1"></a>                    (<span class="st">&quot;Anleihe B allein&quot;</span>, verlust_b),</span>
-<span id="cb183-82"><a href="#cb183-82" aria-hidden="true" tabindex="-1"></a>                    (<span class="st">&quot;Portfolio A+B&quot;</span>, verlust_ab)]:</span>
-<span id="cb183-83"><a href="#cb183-83" aria-hidden="true" tabindex="-1"></a>        werte[name] <span class="op">=</span> (var_quantil(v), cvar_rockafellar(v))</span>
-<span id="cb183-84"><a href="#cb183-84" aria-hidden="true" tabindex="-1"></a>        <span class="bu">print</span>(<span class="ss">f&quot;</span><span class="sc">{</span>name<span class="sc">:&lt;28}</span><span class="ss"> </span><span class="sc">{</span>werte[name][<span class="dv">0</span>]<span class="sc">:&gt;12.2f}</span><span class="ss"> </span><span class="sc">{</span>werte[name][<span class="dv">1</span>]<span class="sc">:&gt;12.2f}</span><span class="ss">&quot;</span>)</span>
-<span id="cb183-85"><a href="#cb183-85" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb183-86"><a href="#cb183-86" aria-hidden="true" tabindex="-1"></a>    var_summe <span class="op">=</span> werte[<span class="st">&quot;Anleihe A allein&quot;</span>][<span class="dv">0</span>] <span class="op">+</span> werte[<span class="st">&quot;Anleihe B allein&quot;</span>][<span class="dv">0</span>]</span>
-<span id="cb183-87"><a href="#cb183-87" aria-hidden="true" tabindex="-1"></a>    cvar_summe <span class="op">=</span> werte[<span class="st">&quot;Anleihe A allein&quot;</span>][<span class="dv">1</span>] <span class="op">+</span> werte[<span class="st">&quot;Anleihe B allein&quot;</span>][<span class="dv">1</span>]</span>
-<span id="cb183-88"><a href="#cb183-88" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;</span><span class="sc">{</span><span class="st">&#39;Summe der Einzelwerte&#39;</span><span class="sc">:&lt;28}</span><span class="ss"> </span><span class="sc">{</span>var_summe<span class="sc">:&gt;12.2f}</span><span class="ss"> </span><span class="sc">{</span>cvar_summe<span class="sc">:&gt;12.2f}</span><span class="ss">&quot;</span>)</span>
-<span id="cb183-89"><a href="#cb183-89" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb183-90"><a href="#cb183-90" aria-hidden="true" tabindex="-1"></a>    var_port, cvar_port <span class="op">=</span> werte[<span class="st">&quot;Portfolio A+B&quot;</span>]</span>
-<span id="cb183-91"><a href="#cb183-91" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;-&quot;</span> <span class="op">*</span> <span class="dv">88</span>)</span>
-<span id="cb183-92"><a href="#cb183-92" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;VaR:  Portfolio </span><span class="sc">{</span>var_port<span class="sc">:7.2f}</span><span class="ss">  vs. Summe </span><span class="sc">{</span>var_summe<span class="sc">:7.2f}</span><span class="ss">  -&gt; &quot;</span></span>
-<span id="cb183-93"><a href="#cb183-93" aria-hidden="true" tabindex="-1"></a>          <span class="ss">f&quot;</span><span class="sc">{</span><span class="st">&#39;VERLETZT die Subadditivitaet!&#39;</span> <span class="cf">if</span> var_port <span class="op">&gt;</span> var_summe <span class="cf">else</span> <span class="st">&#39;subadditiv&#39;</span><span class="sc">}</span><span class="ss">&quot;</span>)</span>
-<span id="cb183-94"><a href="#cb183-94" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;CVaR: Portfolio </span><span class="sc">{</span>cvar_port<span class="sc">:7.2f}</span><span class="ss">  vs. Summe </span><span class="sc">{</span>cvar_summe<span class="sc">:7.2f}</span><span class="ss">  -&gt; &quot;</span></span>
-<span id="cb183-95"><a href="#cb183-95" aria-hidden="true" tabindex="-1"></a>          <span class="ss">f&quot;</span><span class="sc">{</span><span class="st">&#39;subadditiv (kohaerent)&#39;</span> <span class="cf">if</span> cvar_port <span class="op">&lt;=</span> cvar_summe <span class="op">+</span> <span class="fl">1e-6</span> <span class="cf">else</span> <span class="st">&#39;verletzt&#39;</span><span class="sc">}</span><span class="ss">&quot;</span>)</span>
-<span id="cb183-96"><a href="#cb183-96" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb183-97"><a href="#cb183-97" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;</span><span class="ch">\n</span><span class="st">Deutung: Einzeln betrachtet meldet der VaR fuer jede Anleihe einen&quot;</span>)</span>
-<span id="cb183-98"><a href="#cb183-98" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;GEWINN von 2 EUR - denn mit 96 % Wahrscheinlichkeit passiert nichts,&quot;</span>)</span>
-<span id="cb183-99"><a href="#cb183-99" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;und 4 </span><span class="sc">% li</span><span class="st">egen unterhalb der 5-%-Schwelle. Im Portfolio steigt die&quot;</span>)</span>
-<span id="cb183-100"><a href="#cb183-100" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;Wahrscheinlichkeit mindestens eines Ausfalls auf 7,8 </span><span class="sc">% u</span><span class="st">nd damit UEBER&quot;</span>)</span>
-<span id="cb183-101"><a href="#cb183-101" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;die Schwelle - der VaR springt auf 98. Er behauptet also, Streuung&quot;</span>)</span>
-<span id="cb183-102"><a href="#cb183-102" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;habe das Risiko erhoeht. Das ist oekonomisch unsinnig und der Grund,&quot;</span>)</span>
-<span id="cb183-103"><a href="#cb183-103" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;warum die Bankenaufsicht mit Basel III auf den Expected Shortfall&quot;</span>)</span>
-<span id="cb183-104"><a href="#cb183-104" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;umgestellt hat.&quot;</span>)</span>
-<span id="cb183-105"><a href="#cb183-105" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;=&quot;</span> <span class="op">*</span> <span class="dv">88</span>)</span></code></pre></div>
+<div class="sourceCode" id="cb185"><pre class="sourceCode python"><code class="sourceCode python"><span id="cb185-1"><a href="#cb185-1" aria-hidden="true" tabindex="-1"></a><span class="co">#!/usr/bin/env python3</span></span>
+<span id="cb185-2"><a href="#cb185-2" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb185-3"><a href="#cb185-3" aria-hidden="true" tabindex="-1"></a><span class="co"># VaR_CVaR_Demo.py</span></span>
+<span id="cb185-4"><a href="#cb185-4" aria-hidden="true" tabindex="-1"></a><span class="co">&quot;&quot;&quot;</span></span>
+<span id="cb185-5"><a href="#cb185-5" aria-hidden="true" tabindex="-1"></a><span class="co">Kapitel CVaR: Fat Tails, VaR und CVaR anschaulich.</span></span>
+<span id="cb185-6"><a href="#cb185-6" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb185-7"><a href="#cb185-7" aria-hidden="true" tabindex="-1"></a><span class="co">Teil 1: Wie oft treten &quot;unmoegliche&quot; Tage wirklich auf?</span></span>
+<span id="cb185-8"><a href="#cb185-8" aria-hidden="true" tabindex="-1"></a><span class="co">Teil 2: Warum ist der VaR nicht subadditiv - ein Gegenbeispiel zum Nachrechnen.</span></span>
+<span id="cb185-9"><a href="#cb185-9" aria-hidden="true" tabindex="-1"></a><span class="co">&quot;&quot;&quot;</span></span>
+<span id="cb185-10"><a href="#cb185-10" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb185-11"><a href="#cb185-11" aria-hidden="true" tabindex="-1"></a><span class="im">import</span> numpy <span class="im">as</span> np</span>
+<span id="cb185-12"><a href="#cb185-12" aria-hidden="true" tabindex="-1"></a><span class="im">from</span> scipy <span class="im">import</span> stats</span>
+<span id="cb185-13"><a href="#cb185-13" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb185-14"><a href="#cb185-14" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb185-15"><a href="#cb185-15" aria-hidden="true" tabindex="-1"></a><span class="kw">def</span> var_quantil(verluste: np.ndarray, alpha: <span class="bu">float</span> <span class="op">=</span> <span class="fl">0.95</span>) <span class="op">-&gt;</span> <span class="bu">float</span>:</span>
+<span id="cb185-16"><a href="#cb185-16" aria-hidden="true" tabindex="-1"></a>    <span class="co">&quot;&quot;&quot;VaR = Quantil der Verlustverteilung (Verluste positiv, Gewinne negativ).&quot;&quot;&quot;</span></span>
+<span id="cb185-17"><a href="#cb185-17" aria-hidden="true" tabindex="-1"></a>    <span class="cf">return</span> <span class="bu">float</span>(np.quantile(verluste, alpha))</span>
+<span id="cb185-18"><a href="#cb185-18" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb185-19"><a href="#cb185-19" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb185-20"><a href="#cb185-20" aria-hidden="true" tabindex="-1"></a><span class="kw">def</span> cvar_rockafellar(verluste: np.ndarray, alpha: <span class="bu">float</span> <span class="op">=</span> <span class="fl">0.95</span>) <span class="op">-&gt;</span> <span class="bu">float</span>:</span>
+<span id="cb185-21"><a href="#cb185-21" aria-hidden="true" tabindex="-1"></a>    <span class="co">&quot;&quot;&quot;</span></span>
+<span id="cb185-22"><a href="#cb185-22" aria-hidden="true" tabindex="-1"></a><span class="co">    CVaR ueber die Rockafellar-Uryasev-Formel:</span></span>
+<span id="cb185-23"><a href="#cb185-23" aria-hidden="true" tabindex="-1"></a><span class="co">        CVaR = min_gamma { gamma + 1/(1-alpha) * E[max(Verlust - gamma, 0)] }</span></span>
+<span id="cb185-24"><a href="#cb185-24" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb185-25"><a href="#cb185-25" aria-hidden="true" tabindex="-1"></a><span class="co">    WICHTIG: Der naheliegende Weg &quot;Mittelwert aller Werte &gt;= VaR&quot; ist FALSCH,</span></span>
+<span id="cb185-26"><a href="#cb185-26" aria-hidden="true" tabindex="-1"></a><span class="co">    sobald die Verteilung Atome hat (z. B. genau zwei moegliche Verluste).</span></span>
+<span id="cb185-27"><a href="#cb185-27" aria-hidden="true" tabindex="-1"></a><span class="co">    Dann liegt der VaR selbst auf einem Atom, und der Vergleich &#39;&gt;=&#39; erfasst</span></span>
+<span id="cb185-28"><a href="#cb185-28" aria-hidden="true" tabindex="-1"></a><span class="co">    zu viel Wahrscheinlichkeitsmasse. Die Formel unten behandelt das korrekt -</span></span>
+<span id="cb185-29"><a href="#cb185-29" aria-hidden="true" tabindex="-1"></a><span class="co">    und ist zugleich genau der Ausdruck, den wir im Abschnitt &#39;Value at Risk</span></span>
+<span id="cb185-30"><a href="#cb185-30" aria-hidden="true" tabindex="-1"></a><span class="co">    und Conditional Value at Risk&#39; optimieren.</span></span>
+<span id="cb185-31"><a href="#cb185-31" aria-hidden="true" tabindex="-1"></a><span class="co">    &quot;&quot;&quot;</span></span>
+<span id="cb185-32"><a href="#cb185-32" aria-hidden="true" tabindex="-1"></a>    kandidaten <span class="op">=</span> np.unique(verluste)          <span class="co"># Optimum liegt immer auf einem Datenpunkt</span></span>
+<span id="cb185-33"><a href="#cb185-33" aria-hidden="true" tabindex="-1"></a>    <span class="cf">return</span> <span class="bu">float</span>(<span class="bu">min</span>(g <span class="op">+</span> np.mean(np.maximum(verluste <span class="op">-</span> g, <span class="fl">0.0</span>)) <span class="op">/</span> (<span class="fl">1.0</span> <span class="op">-</span> alpha)</span>
+<span id="cb185-34"><a href="#cb185-34" aria-hidden="true" tabindex="-1"></a>                     <span class="cf">for</span> g <span class="kw">in</span> kandidaten))</span>
+<span id="cb185-35"><a href="#cb185-35" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb185-36"><a href="#cb185-36" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb185-37"><a href="#cb185-37" aria-hidden="true" tabindex="-1"></a><span class="cf">if</span> <span class="va">__name__</span> <span class="op">==</span> <span class="st">&quot;__main__&quot;</span>:</span>
+<span id="cb185-38"><a href="#cb185-38" aria-hidden="true" tabindex="-1"></a>    rng <span class="op">=</span> np.random.default_rng(<span class="dv">2026</span>)</span>
+<span id="cb185-39"><a href="#cb185-39" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb185-40"><a href="#cb185-40" aria-hidden="true" tabindex="-1"></a>    <span class="co"># --- Teil 1: Fat Tails (analytisch, nicht simuliert) ------------------</span></span>
+<span id="cb185-41"><a href="#cb185-41" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;=&quot;</span> <span class="op">*</span> <span class="dv">88</span>)</span>
+<span id="cb185-42"><a href="#cb185-42" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;  TEIL 1: WIE OFT TRITT DAS &#39;UNMOEGLICHE&#39; EIN?&quot;</span>)</span>
+<span id="cb185-43"><a href="#cb185-43" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;=&quot;</span> <span class="op">*</span> <span class="dv">88</span>)</span>
+<span id="cb185-44"><a href="#cb185-44" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;Vergleich: Normalverteilung gegen t-Verteilung mit 3 Freiheitsgraden&quot;</span>)</span>
+<span id="cb185-45"><a href="#cb185-45" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;(beide auf Standardabweichung 1 normiert).</span><span class="ch">\n</span><span class="st">&quot;</span>)</span>
+<span id="cb185-46"><a href="#cb185-46" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb185-47"><a href="#cb185-47" aria-hidden="true" tabindex="-1"></a>    t_verteilung <span class="op">=</span> stats.t(df<span class="op">=</span><span class="dv">3</span>)</span>
+<span id="cb185-48"><a href="#cb185-48" aria-hidden="true" tabindex="-1"></a>    skalierung <span class="op">=</span> t_verteilung.std()            <span class="co"># auf Varianz 1 bringen</span></span>
+<span id="cb185-49"><a href="#cb185-49" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb185-50"><a href="#cb185-50" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;</span><span class="sc">{</span><span class="st">&#39;Ereignis&#39;</span><span class="sc">:&lt;22}</span><span class="ss"> </span><span class="sc">{</span><span class="st">&#39;Normal&#39;</span><span class="sc">:&gt;14}</span><span class="ss"> </span><span class="sc">{</span><span class="st">&#39;t (df=3)&#39;</span><span class="sc">:&gt;14}</span><span class="ss"> </span><span class="sc">{</span><span class="st">&#39;Faktor&#39;</span><span class="sc">:&gt;11}</span><span class="ss"> &quot;</span></span>
+<span id="cb185-51"><a href="#cb185-51" aria-hidden="true" tabindex="-1"></a>          <span class="ss">f&quot;</span><span class="sc">{</span><span class="st">&#39;Normal: 1 Tag in&#39;</span><span class="sc">:&gt;18}</span><span class="ss">&quot;</span>)</span>
+<span id="cb185-52"><a href="#cb185-52" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;-&quot;</span> <span class="op">*</span> <span class="dv">88</span>)</span>
+<span id="cb185-53"><a href="#cb185-53" aria-hidden="true" tabindex="-1"></a>    <span class="cf">for</span> k <span class="kw">in</span> [<span class="dv">3</span>, <span class="dv">4</span>, <span class="dv">5</span>, <span class="dv">6</span>]:</span>
+<span id="cb185-54"><a href="#cb185-54" aria-hidden="true" tabindex="-1"></a>        p_normal <span class="op">=</span> <span class="dv">2</span> <span class="op">*</span> stats.norm.sf(k)                     <span class="co"># beidseitig</span></span>
+<span id="cb185-55"><a href="#cb185-55" aria-hidden="true" tabindex="-1"></a>        p_t <span class="op">=</span> <span class="dv">2</span> <span class="op">*</span> t_verteilung.sf(k <span class="op">*</span> skalierung)</span>
+<span id="cb185-56"><a href="#cb185-56" aria-hidden="true" tabindex="-1"></a>        <span class="bu">print</span>(<span class="ss">f&quot;Abweichung &gt; </span><span class="sc">{</span>k<span class="sc">}</span><span class="ss"> Sigma  </span><span class="sc">{</span>p_normal<span class="op">*</span><span class="dv">100</span><span class="sc">:&gt;13.6f}</span><span class="ss"> % </span><span class="sc">{</span>p_t<span class="op">*</span><span class="dv">100</span><span class="sc">:&gt;13.6f}</span><span class="ss"> % &quot;</span></span>
+<span id="cb185-57"><a href="#cb185-57" aria-hidden="true" tabindex="-1"></a>              <span class="ss">f&quot;</span><span class="sc">{</span>p_t<span class="op">/</span>p_normal<span class="sc">:&gt;10.1f}</span><span class="ss">x </span><span class="sc">{</span><span class="dv">1</span><span class="op">/</span>p_normal<span class="op">/</span><span class="dv">252</span><span class="sc">:&gt;15,.0f}</span><span class="ss"> Jahre&quot;</span>)</span>
+<span id="cb185-58"><a href="#cb185-58" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb185-59"><a href="#cb185-59" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;</span><span class="ch">\n</span><span class="st">Deutung: Ein 5-Sigma-Tag ist unter Normalverteilung ein Ereignis von&quot;</span>)</span>
+<span id="cb185-60"><a href="#cb185-60" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;etwa einmal in 6.900 Jahren. Reale Aktienmaerkte liefern solche Tage&quot;</span>)</span>
+<span id="cb185-61"><a href="#cb185-61" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;mehrfach pro Jahrzehnt. Wer allein mit Varianz steuert, plant fuer&quot;</span>)</span>
+<span id="cb185-62"><a href="#cb185-62" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;eine Welt, in der Crashs praktisch nicht vorkommen.&quot;</span>)</span>
+<span id="cb185-63"><a href="#cb185-63" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb185-64"><a href="#cb185-64" aria-hidden="true" tabindex="-1"></a>    <span class="co"># --- Teil 2: VaR ist nicht subadditiv ---------------------------------</span></span>
+<span id="cb185-65"><a href="#cb185-65" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;</span><span class="ch">\n</span><span class="st">&quot;</span> <span class="op">+</span> <span class="st">&quot;=&quot;</span> <span class="op">*</span> <span class="dv">88</span>)</span>
+<span id="cb185-66"><a href="#cb185-66" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;  TEIL 2: WARUM DER VaR KEIN KOHAERENTES RISIKOMASS IST&quot;</span>)</span>
+<span id="cb185-67"><a href="#cb185-67" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;=&quot;</span> <span class="op">*</span> <span class="dv">88</span>)</span>
+<span id="cb185-68"><a href="#cb185-68" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;Zwei unabhaengige Anleihen, je 100 EUR Nominal.&quot;</span>)</span>
+<span id="cb185-69"><a href="#cb185-69" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;Jede faellt mit 4 % Wahrscheinlichkeit aus (Verlust 100),&quot;</span>)</span>
+<span id="cb185-70"><a href="#cb185-70" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;sonst zahlt sie 2 EUR Kupon (Verlust -2).</span><span class="ch">\n</span><span class="st">&quot;</span>)</span>
+<span id="cb185-71"><a href="#cb185-71" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb185-72"><a href="#cb185-72" aria-hidden="true" tabindex="-1"></a>    ziehungen <span class="op">=</span> <span class="dv">2_000_000</span></span>
+<span id="cb185-73"><a href="#cb185-73" aria-hidden="true" tabindex="-1"></a>    verlust_a <span class="op">=</span> np.where(rng.random(ziehungen) <span class="op">&lt;</span> <span class="fl">0.04</span>, <span class="fl">100.0</span>, <span class="op">-</span><span class="fl">2.0</span>)</span>
+<span id="cb185-74"><a href="#cb185-74" aria-hidden="true" tabindex="-1"></a>    verlust_b <span class="op">=</span> np.where(rng.random(ziehungen) <span class="op">&lt;</span> <span class="fl">0.04</span>, <span class="fl">100.0</span>, <span class="op">-</span><span class="fl">2.0</span>)</span>
+<span id="cb185-75"><a href="#cb185-75" aria-hidden="true" tabindex="-1"></a>    verlust_ab <span class="op">=</span> verlust_a <span class="op">+</span> verlust_b</span>
+<span id="cb185-76"><a href="#cb185-76" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb185-77"><a href="#cb185-77" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;</span><span class="sc">{</span><span class="st">&#39;&#39;</span><span class="sc">:&lt;28}</span><span class="ss"> </span><span class="sc">{</span><span class="st">&#39;VaR 95%&#39;</span><span class="sc">:&gt;12}</span><span class="ss"> </span><span class="sc">{</span><span class="st">&#39;CVaR 95%&#39;</span><span class="sc">:&gt;12}</span><span class="ss">&quot;</span>)</span>
+<span id="cb185-78"><a href="#cb185-78" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;-&quot;</span> <span class="op">*</span> <span class="dv">88</span>)</span>
+<span id="cb185-79"><a href="#cb185-79" aria-hidden="true" tabindex="-1"></a>    werte <span class="op">=</span> {}</span>
+<span id="cb185-80"><a href="#cb185-80" aria-hidden="true" tabindex="-1"></a>    <span class="cf">for</span> name, v <span class="kw">in</span> [(<span class="st">&quot;Anleihe A allein&quot;</span>, verlust_a),</span>
+<span id="cb185-81"><a href="#cb185-81" aria-hidden="true" tabindex="-1"></a>                    (<span class="st">&quot;Anleihe B allein&quot;</span>, verlust_b),</span>
+<span id="cb185-82"><a href="#cb185-82" aria-hidden="true" tabindex="-1"></a>                    (<span class="st">&quot;Portfolio A+B&quot;</span>, verlust_ab)]:</span>
+<span id="cb185-83"><a href="#cb185-83" aria-hidden="true" tabindex="-1"></a>        werte[name] <span class="op">=</span> (var_quantil(v), cvar_rockafellar(v))</span>
+<span id="cb185-84"><a href="#cb185-84" aria-hidden="true" tabindex="-1"></a>        <span class="bu">print</span>(<span class="ss">f&quot;</span><span class="sc">{</span>name<span class="sc">:&lt;28}</span><span class="ss"> </span><span class="sc">{</span>werte[name][<span class="dv">0</span>]<span class="sc">:&gt;12.2f}</span><span class="ss"> </span><span class="sc">{</span>werte[name][<span class="dv">1</span>]<span class="sc">:&gt;12.2f}</span><span class="ss">&quot;</span>)</span>
+<span id="cb185-85"><a href="#cb185-85" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb185-86"><a href="#cb185-86" aria-hidden="true" tabindex="-1"></a>    var_summe <span class="op">=</span> werte[<span class="st">&quot;Anleihe A allein&quot;</span>][<span class="dv">0</span>] <span class="op">+</span> werte[<span class="st">&quot;Anleihe B allein&quot;</span>][<span class="dv">0</span>]</span>
+<span id="cb185-87"><a href="#cb185-87" aria-hidden="true" tabindex="-1"></a>    cvar_summe <span class="op">=</span> werte[<span class="st">&quot;Anleihe A allein&quot;</span>][<span class="dv">1</span>] <span class="op">+</span> werte[<span class="st">&quot;Anleihe B allein&quot;</span>][<span class="dv">1</span>]</span>
+<span id="cb185-88"><a href="#cb185-88" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;</span><span class="sc">{</span><span class="st">&#39;Summe der Einzelwerte&#39;</span><span class="sc">:&lt;28}</span><span class="ss"> </span><span class="sc">{</span>var_summe<span class="sc">:&gt;12.2f}</span><span class="ss"> </span><span class="sc">{</span>cvar_summe<span class="sc">:&gt;12.2f}</span><span class="ss">&quot;</span>)</span>
+<span id="cb185-89"><a href="#cb185-89" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb185-90"><a href="#cb185-90" aria-hidden="true" tabindex="-1"></a>    var_port, cvar_port <span class="op">=</span> werte[<span class="st">&quot;Portfolio A+B&quot;</span>]</span>
+<span id="cb185-91"><a href="#cb185-91" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;-&quot;</span> <span class="op">*</span> <span class="dv">88</span>)</span>
+<span id="cb185-92"><a href="#cb185-92" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;VaR:  Portfolio </span><span class="sc">{</span>var_port<span class="sc">:7.2f}</span><span class="ss">  vs. Summe </span><span class="sc">{</span>var_summe<span class="sc">:7.2f}</span><span class="ss">  -&gt; &quot;</span></span>
+<span id="cb185-93"><a href="#cb185-93" aria-hidden="true" tabindex="-1"></a>          <span class="ss">f&quot;</span><span class="sc">{</span><span class="st">&#39;VERLETZT die Subadditivitaet!&#39;</span> <span class="cf">if</span> var_port <span class="op">&gt;</span> var_summe <span class="cf">else</span> <span class="st">&#39;subadditiv&#39;</span><span class="sc">}</span><span class="ss">&quot;</span>)</span>
+<span id="cb185-94"><a href="#cb185-94" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;CVaR: Portfolio </span><span class="sc">{</span>cvar_port<span class="sc">:7.2f}</span><span class="ss">  vs. Summe </span><span class="sc">{</span>cvar_summe<span class="sc">:7.2f}</span><span class="ss">  -&gt; &quot;</span></span>
+<span id="cb185-95"><a href="#cb185-95" aria-hidden="true" tabindex="-1"></a>          <span class="ss">f&quot;</span><span class="sc">{</span><span class="st">&#39;subadditiv (kohaerent)&#39;</span> <span class="cf">if</span> cvar_port <span class="op">&lt;=</span> cvar_summe <span class="op">+</span> <span class="fl">1e-6</span> <span class="cf">else</span> <span class="st">&#39;verletzt&#39;</span><span class="sc">}</span><span class="ss">&quot;</span>)</span>
+<span id="cb185-96"><a href="#cb185-96" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb185-97"><a href="#cb185-97" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;</span><span class="ch">\n</span><span class="st">Deutung: Einzeln betrachtet meldet der VaR fuer jede Anleihe einen&quot;</span>)</span>
+<span id="cb185-98"><a href="#cb185-98" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;GEWINN von 2 EUR - denn mit 96 % Wahrscheinlichkeit passiert nichts,&quot;</span>)</span>
+<span id="cb185-99"><a href="#cb185-99" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;und 4 </span><span class="sc">% li</span><span class="st">egen unterhalb der 5-%-Schwelle. Im Portfolio steigt die&quot;</span>)</span>
+<span id="cb185-100"><a href="#cb185-100" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;Wahrscheinlichkeit mindestens eines Ausfalls auf 7,8 </span><span class="sc">% u</span><span class="st">nd damit UEBER&quot;</span>)</span>
+<span id="cb185-101"><a href="#cb185-101" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;die Schwelle - der VaR springt auf 98. Er behauptet also, Streuung&quot;</span>)</span>
+<span id="cb185-102"><a href="#cb185-102" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;habe das Risiko erhoeht. Das ist oekonomisch unsinnig und der Grund,&quot;</span>)</span>
+<span id="cb185-103"><a href="#cb185-103" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;warum die Bankenaufsicht mit Basel III auf den Expected Shortfall&quot;</span>)</span>
+<span id="cb185-104"><a href="#cb185-104" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;umgestellt hat.&quot;</span>)</span>
+<span id="cb185-105"><a href="#cb185-105" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;=&quot;</span> <span class="op">*</span> <span class="dv">88</span>)</span></code></pre></div>
 <p><strong>Erwartete Ausgabe (gekürzt):</strong></p>
 <pre><code>========================================================================================
   TEIL 1: WIE OFT TRITT DAS &#39;UNMOEGLICHE&#39; EIN?
@@ -23385,215 +24361,215 @@ CVaR: Portfolio  101.33  vs. Summe  159.24  -&gt; subadditiv (kohaerent)
 <blockquote>
 <p><strong>⚠️ Einheiten konsistent halten</strong></p>
 <p>Ein häufiger Fehler verrechnet eine <strong>annualisierte</strong> Rendite gegen einen <strong>täglichen</strong> CVaR:</p>
-<div class="sourceCode" id="cb185"><pre class="sourceCode python"><code class="sourceCode python"><span id="cb185-1"><a href="#cb185-1" aria-hidden="true" tabindex="-1"></a>mu <span class="op">=</span> returns_df.mean().values <span class="op">*</span> <span class="dv">252</span>              <span class="co"># ANNUALISIERT</span></span>
-<span id="cb185-2"><a href="#cb185-2" aria-hidden="true" tabindex="-1"></a>cvar <span class="op">=</span> gamma <span class="op">+</span> (<span class="dv">1</span><span class="op">/</span>(S<span class="op">*</span>(<span class="dv">1</span><span class="op">-</span>alpha))) <span class="op">*</span> cp.<span class="bu">sum</span>(u)     <span class="co"># TAEGLICH</span></span>
-<span id="cb185-3"><a href="#cb185-3" aria-hidden="true" tabindex="-1"></a>objective <span class="op">=</span> cp.Maximize(mu <span class="op">@</span> w <span class="op">-</span> lambda_risk <span class="op">*</span> cvar <span class="op">-</span> trans_costs)</span></code></pre></div>
+<div class="sourceCode" id="cb187"><pre class="sourceCode python"><code class="sourceCode python"><span id="cb187-1"><a href="#cb187-1" aria-hidden="true" tabindex="-1"></a>mu <span class="op">=</span> returns_df.mean().values <span class="op">*</span> <span class="dv">252</span>              <span class="co"># ANNUALISIERT</span></span>
+<span id="cb187-2"><a href="#cb187-2" aria-hidden="true" tabindex="-1"></a>cvar <span class="op">=</span> gamma <span class="op">+</span> (<span class="dv">1</span><span class="op">/</span>(S<span class="op">*</span>(<span class="dv">1</span><span class="op">-</span>alpha))) <span class="op">*</span> cp.<span class="bu">sum</span>(u)     <span class="co"># TAEGLICH</span></span>
+<span id="cb187-3"><a href="#cb187-3" aria-hidden="true" tabindex="-1"></a>objective <span class="op">=</span> cp.Maximize(mu <span class="op">@</span> w <span class="op">-</span> lambda_risk <span class="op">*</span> cvar <span class="op">-</span> trans_costs)</span></code></pre></div>
 <p>Der Risikoterm ist dadurch faktisch um Faktor 252 zu schwach gewichtet: <code>lambda_risk = 1.5</code> bedeutet dann effektiv eine Risikoaversion von <span class="math inline">1{,}5/252 \approx 0{,}006</span>. Das Modell ist nicht falsch im Sinne von unlösbar — aber der Parameter bedeutet nicht, was er zu bedeuten scheint, und lässt sich daher nicht sinnvoll einstellen.</p>
 <p><strong>Dieses Programm rechnet deshalb durchgehend auf Tagesbasis</strong> und annualisiert erst in der Ausgabe.</p>
 </blockquote>
-<div class="sourceCode" id="cb186"><pre class="sourceCode python"><code class="sourceCode python"><span id="cb186-1"><a href="#cb186-1" aria-hidden="true" tabindex="-1"></a><span class="co">#!/usr/bin/env python3</span></span>
-<span id="cb186-2"><a href="#cb186-2" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb186-3"><a href="#cb186-3" aria-hidden="true" tabindex="-1"></a><span class="co"># CVaR_Portfolio.py</span></span>
-<span id="cb186-4"><a href="#cb186-4" aria-hidden="true" tabindex="-1"></a><span class="co">&quot;&quot;&quot;</span></span>
-<span id="cb186-5"><a href="#cb186-5" aria-hidden="true" tabindex="-1"></a><span class="co">Kapitel CVaR: CVaR-Optimierung mit L1-Transaktionskosten via CVXPY.</span></span>
-<span id="cb186-6"><a href="#cb186-6" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb186-7"><a href="#cb186-7" aria-hidden="true" tabindex="-1"></a><span class="co">Eigenschaften:</span></span>
-<span id="cb186-8"><a href="#cb186-8" aria-hidden="true" tabindex="-1"></a><span class="co">  * Spaltenreihenfolge erzwungen</span></span>
-<span id="cb186-9"><a href="#cb186-9" aria-hidden="true" tabindex="-1"></a><span class="co">  * Einheiten konsistent (alles taeglich, Annualisierung nur in der Ausgabe)</span></span>
-<span id="cb186-10"><a href="#cb186-10" aria-hidden="true" tabindex="-1"></a><span class="co">  * Szenario-Nebenbedingungen VEKTORISIERT statt in einer Python-Schleife</span></span>
-<span id="cb186-11"><a href="#cb186-11" aria-hidden="true" tabindex="-1"></a><span class="co">    (eine Matrixbedingung statt S einzelner Constraints - deutlich schneller)</span></span>
-<span id="cb186-12"><a href="#cb186-12" aria-hidden="true" tabindex="-1"></a><span class="co">  * Vergleich CVaR- gegen Varianz-Optimierung</span></span>
-<span id="cb186-13"><a href="#cb186-13" aria-hidden="true" tabindex="-1"></a><span class="co">  * Nachrechnung von VaR/CVaR aus den realisierten Szenarien</span></span>
-<span id="cb186-14"><a href="#cb186-14" aria-hidden="true" tabindex="-1"></a><span class="co">&quot;&quot;&quot;</span></span>
-<span id="cb186-15"><a href="#cb186-15" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb186-16"><a href="#cb186-16" aria-hidden="true" tabindex="-1"></a><span class="im">import</span> time</span>
-<span id="cb186-17"><a href="#cb186-17" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb186-18"><a href="#cb186-18" aria-hidden="true" tabindex="-1"></a><span class="im">import</span> cvxpy <span class="im">as</span> cp</span>
-<span id="cb186-19"><a href="#cb186-19" aria-hidden="true" tabindex="-1"></a><span class="im">import</span> numpy <span class="im">as</span> np</span>
-<span id="cb186-20"><a href="#cb186-20" aria-hidden="true" tabindex="-1"></a><span class="im">import</span> pandas <span class="im">as</span> pd</span>
-<span id="cb186-21"><a href="#cb186-21" aria-hidden="true" tabindex="-1"></a><span class="im">import</span> yfinance <span class="im">as</span> yf</span>
-<span id="cb186-22"><a href="#cb186-22" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb186-23"><a href="#cb186-23" aria-hidden="true" tabindex="-1"></a>TICKER <span class="op">=</span> [<span class="st">&quot;AAPL&quot;</span>, <span class="st">&quot;MSFT&quot;</span>, <span class="st">&quot;NVDA&quot;</span>, <span class="st">&quot;AMZN&quot;</span>, <span class="st">&quot;JNJ&quot;</span>, <span class="st">&quot;PFE&quot;</span>, <span class="st">&quot;JPM&quot;</span>, <span class="st">&quot;GS&quot;</span>, <span class="st">&quot;XOM&quot;</span>, <span class="st">&quot;CVX&quot;</span>]</span>
-<span id="cb186-24"><a href="#cb186-24" aria-hidden="true" tabindex="-1"></a>ALPHA <span class="op">=</span> <span class="fl">0.95</span>            <span class="co"># Konfidenzniveau: schlechteste 5 % der Tage</span></span>
-<span id="cb186-25"><a href="#cb186-25" aria-hidden="true" tabindex="-1"></a>MAX_GEWICHT <span class="op">=</span> <span class="fl">0.25</span></span>
-<span id="cb186-26"><a href="#cb186-26" aria-hidden="true" tabindex="-1"></a>GEBUEHRENSATZ <span class="op">=</span> <span class="fl">0.002</span>   <span class="co"># 0,2 % je Einheit Turnover (Spread + Brokerage)</span></span>
-<span id="cb186-27"><a href="#cb186-27" aria-hidden="true" tabindex="-1"></a>RISIKOAVERSION <span class="op">=</span> <span class="fl">1.5</span>    <span class="co"># bezogen auf TAEGLICHE Groessen</span></span>
-<span id="cb186-28"><a href="#cb186-28" aria-hidden="true" tabindex="-1"></a>HANDELSTAGE <span class="op">=</span> <span class="dv">252</span></span>
-<span id="cb186-29"><a href="#cb186-29" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb186-30"><a href="#cb186-30" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb186-31"><a href="#cb186-31" aria-hidden="true" tabindex="-1"></a><span class="kw">def</span> lade_renditen():</span>
-<span id="cb186-32"><a href="#cb186-32" aria-hidden="true" tabindex="-1"></a>    ende <span class="op">=</span> pd.Timestamp.today().normalize()</span>
-<span id="cb186-33"><a href="#cb186-33" aria-hidden="true" tabindex="-1"></a>    start <span class="op">=</span> ende <span class="op">-</span> pd.DateOffset(years<span class="op">=</span><span class="dv">2</span>)</span>
-<span id="cb186-34"><a href="#cb186-34" aria-hidden="true" tabindex="-1"></a>    roh <span class="op">=</span> yf.download(TICKER, start<span class="op">=</span>start, end<span class="op">=</span>ende, auto_adjust<span class="op">=</span><span class="va">True</span>, progress<span class="op">=</span><span class="va">False</span>)</span>
-<span id="cb186-35"><a href="#cb186-35" aria-hidden="true" tabindex="-1"></a>    <span class="cf">if</span> roh.empty:</span>
-<span id="cb186-36"><a href="#cb186-36" aria-hidden="true" tabindex="-1"></a>        <span class="cf">raise</span> <span class="pp">SystemExit</span>(<span class="st">&quot;Download fehlgeschlagen (Netz, Ticker oder Rate-Limit pruefen).&quot;</span>)</span>
-<span id="cb186-37"><a href="#cb186-37" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb186-38"><a href="#cb186-38" aria-hidden="true" tabindex="-1"></a>    <span class="cf">if</span> <span class="bu">isinstance</span>(roh.columns, pd.MultiIndex):</span>
-<span id="cb186-39"><a href="#cb186-39" aria-hidden="true" tabindex="-1"></a>        kurse <span class="op">=</span> roh[<span class="st">&quot;Close&quot;</span>][TICKER].dropna()        <span class="co"># erzwingt eigene Spaltenreihenfolge</span></span>
-<span id="cb186-40"><a href="#cb186-40" aria-hidden="true" tabindex="-1"></a>    <span class="cf">else</span>:</span>
-<span id="cb186-41"><a href="#cb186-41" aria-hidden="true" tabindex="-1"></a>        kurse <span class="op">=</span> roh[[<span class="st">&quot;Close&quot;</span>]].dropna()</span>
-<span id="cb186-42"><a href="#cb186-42" aria-hidden="true" tabindex="-1"></a>        kurse.columns <span class="op">=</span> TICKER</span>
-<span id="cb186-43"><a href="#cb186-43" aria-hidden="true" tabindex="-1"></a>    <span class="cf">assert</span> <span class="bu">list</span>(kurse.columns) <span class="op">==</span> TICKER, <span class="st">&quot;Spaltenreihenfolge weicht ab!&quot;</span></span>
-<span id="cb186-44"><a href="#cb186-44" aria-hidden="true" tabindex="-1"></a>    <span class="cf">return</span> kurse.pct_change().dropna()</span>
-<span id="cb186-45"><a href="#cb186-45" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb186-46"><a href="#cb186-46" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb186-47"><a href="#cb186-47" aria-hidden="true" tabindex="-1"></a><span class="kw">def</span> optimiere_cvar(R, w_alt, vektorisiert<span class="op">=</span><span class="va">True</span>):</span>
-<span id="cb186-48"><a href="#cb186-48" aria-hidden="true" tabindex="-1"></a>    <span class="co">&quot;&quot;&quot;</span></span>
-<span id="cb186-49"><a href="#cb186-49" aria-hidden="true" tabindex="-1"></a><span class="co">    Maximiere:  taegliche Rendite - lambda * CVaR - Transaktionskosten</span></span>
-<span id="cb186-50"><a href="#cb186-50" aria-hidden="true" tabindex="-1"></a><span class="co">    Alle Groessen TAEGLICH.</span></span>
-<span id="cb186-51"><a href="#cb186-51" aria-hidden="true" tabindex="-1"></a><span class="co">    &quot;&quot;&quot;</span></span>
-<span id="cb186-52"><a href="#cb186-52" aria-hidden="true" tabindex="-1"></a>    S, N <span class="op">=</span> R.shape</span>
-<span id="cb186-53"><a href="#cb186-53" aria-hidden="true" tabindex="-1"></a>    mu_taeglich <span class="op">=</span> R.mean(axis<span class="op">=</span><span class="dv">0</span>)</span>
-<span id="cb186-54"><a href="#cb186-54" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb186-55"><a href="#cb186-55" aria-hidden="true" tabindex="-1"></a>    w <span class="op">=</span> cp.Variable(N, nonneg<span class="op">=</span><span class="va">True</span>)</span>
-<span id="cb186-56"><a href="#cb186-56" aria-hidden="true" tabindex="-1"></a>    gamma <span class="op">=</span> cp.Variable()                  <span class="co"># wird im Optimum zum VaR</span></span>
-<span id="cb186-57"><a href="#cb186-57" aria-hidden="true" tabindex="-1"></a>    u <span class="op">=</span> cp.Variable(S, nonneg<span class="op">=</span><span class="va">True</span>)        <span class="co"># Ueberschuss ueber die Schwelle</span></span>
-<span id="cb186-58"><a href="#cb186-58" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb186-59"><a href="#cb186-59" aria-hidden="true" tabindex="-1"></a>    cvar <span class="op">=</span> gamma <span class="op">+</span> (<span class="fl">1.0</span> <span class="op">/</span> (S <span class="op">*</span> (<span class="fl">1.0</span> <span class="op">-</span> ALPHA))) <span class="op">*</span> cp.<span class="bu">sum</span>(u)</span>
-<span id="cb186-60"><a href="#cb186-60" aria-hidden="true" tabindex="-1"></a>    turnover <span class="op">=</span> cp.norm1(w <span class="op">-</span> w_alt)</span>
-<span id="cb186-61"><a href="#cb186-61" aria-hidden="true" tabindex="-1"></a>    kosten <span class="op">=</span> GEBUEHRENSATZ <span class="op">*</span> turnover</span>
-<span id="cb186-62"><a href="#cb186-62" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb186-63"><a href="#cb186-63" aria-hidden="true" tabindex="-1"></a>    ziel <span class="op">=</span> cp.Maximize(mu_taeglich <span class="op">@</span> w <span class="op">-</span> RISIKOAVERSION <span class="op">*</span> cvar <span class="op">-</span> kosten)</span>
-<span id="cb186-64"><a href="#cb186-64" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb186-65"><a href="#cb186-65" aria-hidden="true" tabindex="-1"></a>    bedingungen <span class="op">=</span> [cp.<span class="bu">sum</span>(w) <span class="op">==</span> <span class="dv">1</span>, w <span class="op">&lt;=</span> MAX_GEWICHT]</span>
-<span id="cb186-66"><a href="#cb186-66" aria-hidden="true" tabindex="-1"></a>    <span class="cf">if</span> vektorisiert:</span>
-<span id="cb186-67"><a href="#cb186-67" aria-hidden="true" tabindex="-1"></a>        <span class="co"># EINE Matrixbedingung statt S einzelner - deutlich schneller</span></span>
-<span id="cb186-68"><a href="#cb186-68" aria-hidden="true" tabindex="-1"></a>        bedingungen.append(u <span class="op">&gt;=</span> <span class="op">-</span>(R <span class="op">@</span> w) <span class="op">-</span> gamma)</span>
-<span id="cb186-69"><a href="#cb186-69" aria-hidden="true" tabindex="-1"></a>    <span class="cf">else</span>:</span>
-<span id="cb186-70"><a href="#cb186-70" aria-hidden="true" tabindex="-1"></a>        <span class="cf">for</span> s <span class="kw">in</span> <span class="bu">range</span>(S):                 <span class="co"># Alternative: S einzelne Constraints (langsamer)</span></span>
-<span id="cb186-71"><a href="#cb186-71" aria-hidden="true" tabindex="-1"></a>            bedingungen.append(u[s] <span class="op">&gt;=</span> <span class="op">-</span>R[s] <span class="op">@</span> w <span class="op">-</span> gamma)</span>
-<span id="cb186-72"><a href="#cb186-72" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb186-73"><a href="#cb186-73" aria-hidden="true" tabindex="-1"></a>    problem <span class="op">=</span> cp.Problem(ziel, bedingungen)</span>
-<span id="cb186-74"><a href="#cb186-74" aria-hidden="true" tabindex="-1"></a>    problem.solve()</span>
-<span id="cb186-75"><a href="#cb186-75" aria-hidden="true" tabindex="-1"></a>    <span class="cf">if</span> problem.status <span class="kw">not</span> <span class="kw">in</span> (<span class="st">&quot;optimal&quot;</span>, <span class="st">&quot;optimal_inaccurate&quot;</span>):</span>
-<span id="cb186-76"><a href="#cb186-76" aria-hidden="true" tabindex="-1"></a>        <span class="cf">raise</span> <span class="pp">SystemExit</span>(<span class="ss">f&quot;CVaR-Problem nicht loesbar: </span><span class="sc">{</span>problem<span class="sc">.</span>status<span class="sc">}</span><span class="ss">&quot;</span>)</span>
-<span id="cb186-77"><a href="#cb186-77" aria-hidden="true" tabindex="-1"></a>    <span class="cf">return</span> w.value, <span class="bu">float</span>(gamma.value), <span class="bu">float</span>(cvar.value), <span class="bu">float</span>(turnover.value)</span>
-<span id="cb186-78"><a href="#cb186-78" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb186-79"><a href="#cb186-79" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb186-80"><a href="#cb186-80" aria-hidden="true" tabindex="-1"></a><span class="kw">def</span> optimiere_varianz(R, w_alt):</span>
-<span id="cb186-81"><a href="#cb186-81" aria-hidden="true" tabindex="-1"></a>    <span class="co">&quot;&quot;&quot;Klassisches Mean-Variance zum Vergleich - ebenfalls taeglich gerechnet.</span></span>
-<span id="cb186-82"><a href="#cb186-82" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb186-83"><a href="#cb186-83" aria-hidden="true" tabindex="-1"></a><span class="co">    ACHTUNG, DCP-Falle: Die Standardabweichung ist hier NICHT als</span></span>
-<span id="cb186-84"><a href="#cb186-84" aria-hidden="true" tabindex="-1"></a><span class="co">    cp.sqrt(cp.quad_form(w, sigma)) formulierbar. cp.sqrt ist konkav und</span></span>
-<span id="cb186-85"><a href="#cb186-85" aria-hidden="true" tabindex="-1"></a><span class="co">    verlangt ein konkaves Argument; quad_form ist konvex - CVXPY lehnt den</span></span>
-<span id="cb186-86"><a href="#cb186-86" aria-hidden="true" tabindex="-1"></a><span class="co">    Ausdruck mit einem DCPError ab, und zwar voellig zu Recht (Anhang</span></span>
-<span id="cb186-87"><a href="#cb186-87" aria-hidden="true" tabindex="-1"></a><span class="co">    Fehlerdiagnose). cp.psd_wrap() hilft dagegen nicht: Es behebt eine</span></span>
-<span id="cb186-88"><a href="#cb186-88" aria-hidden="true" tabindex="-1"></a><span class="co">    NUMERISCHE Beanstandung an sigma, keine Regelverletzung im Aufbau.</span></span>
-<span id="cb186-89"><a href="#cb186-89" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb186-90"><a href="#cb186-90" aria-hidden="true" tabindex="-1"></a><span class="co">    Der Standardweg ist die Cholesky-Zerlegung sigma = L L^T. Damit gilt</span></span>
-<span id="cb186-91"><a href="#cb186-91" aria-hidden="true" tabindex="-1"></a><span class="co">    w&#39; sigma w = ||L^T w||^2, also ist die Standardabweichung die 2-Norm</span></span>
-<span id="cb186-92"><a href="#cb186-92" aria-hidden="true" tabindex="-1"></a><span class="co">    eines AFFINEN Ausdrucks - konvex und damit regelkonform.</span></span>
-<span id="cb186-93"><a href="#cb186-93" aria-hidden="true" tabindex="-1"></a><span class="co">    &quot;&quot;&quot;</span></span>
-<span id="cb186-94"><a href="#cb186-94" aria-hidden="true" tabindex="-1"></a>    N <span class="op">=</span> R.shape[<span class="dv">1</span>]</span>
-<span id="cb186-95"><a href="#cb186-95" aria-hidden="true" tabindex="-1"></a>    mu_taeglich <span class="op">=</span> R.mean(axis<span class="op">=</span><span class="dv">0</span>)</span>
-<span id="cb186-96"><a href="#cb186-96" aria-hidden="true" tabindex="-1"></a>    sigma <span class="op">=</span> np.cov(R, rowvar<span class="op">=</span><span class="va">False</span>, ddof<span class="op">=</span><span class="dv">1</span>)</span>
-<span id="cb186-97"><a href="#cb186-97" aria-hidden="true" tabindex="-1"></a>    <span class="co"># Der winzige Diagonalzuschlag faengt den Fall ab, dass sigma numerisch</span></span>
-<span id="cb186-98"><a href="#cb186-98" aria-hidden="true" tabindex="-1"></a>    <span class="co"># nur halbdefinit ist (mehr Titel als Handelstage, doppelte Spalten).</span></span>
-<span id="cb186-99"><a href="#cb186-99" aria-hidden="true" tabindex="-1"></a>    L <span class="op">=</span> np.linalg.cholesky(sigma <span class="op">+</span> <span class="fl">1e-12</span> <span class="op">*</span> np.eye(N))</span>
-<span id="cb186-100"><a href="#cb186-100" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb186-101"><a href="#cb186-101" aria-hidden="true" tabindex="-1"></a>    w <span class="op">=</span> cp.Variable(N, nonneg<span class="op">=</span><span class="va">True</span>)</span>
-<span id="cb186-102"><a href="#cb186-102" aria-hidden="true" tabindex="-1"></a>    ziel <span class="op">=</span> cp.Maximize(mu_taeglich <span class="op">@</span> w</span>
-<span id="cb186-103"><a href="#cb186-103" aria-hidden="true" tabindex="-1"></a>                       <span class="op">-</span> RISIKOAVERSION <span class="op">*</span> cp.norm2(L.T <span class="op">@</span> w)</span>
-<span id="cb186-104"><a href="#cb186-104" aria-hidden="true" tabindex="-1"></a>                       <span class="op">-</span> GEBUEHRENSATZ <span class="op">*</span> cp.norm1(w <span class="op">-</span> w_alt))</span>
-<span id="cb186-105"><a href="#cb186-105" aria-hidden="true" tabindex="-1"></a>    problem <span class="op">=</span> cp.Problem(ziel, [cp.<span class="bu">sum</span>(w) <span class="op">==</span> <span class="dv">1</span>, w <span class="op">&lt;=</span> MAX_GEWICHT])</span>
-<span id="cb186-106"><a href="#cb186-106" aria-hidden="true" tabindex="-1"></a>    problem.solve()</span>
-<span id="cb186-107"><a href="#cb186-107" aria-hidden="true" tabindex="-1"></a>    <span class="cf">if</span> problem.status <span class="kw">not</span> <span class="kw">in</span> (<span class="st">&quot;optimal&quot;</span>, <span class="st">&quot;optimal_inaccurate&quot;</span>):</span>
-<span id="cb186-108"><a href="#cb186-108" aria-hidden="true" tabindex="-1"></a>        <span class="cf">raise</span> <span class="pp">SystemExit</span>(<span class="ss">f&quot;Varianz-Problem nicht loesbar: </span><span class="sc">{</span>problem<span class="sc">.</span>status<span class="sc">}</span><span class="ss">&quot;</span>)</span>
-<span id="cb186-109"><a href="#cb186-109" aria-hidden="true" tabindex="-1"></a>    <span class="cf">return</span> w.value</span>
-<span id="cb186-110"><a href="#cb186-110" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb186-111"><a href="#cb186-111" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb186-112"><a href="#cb186-112" aria-hidden="true" tabindex="-1"></a><span class="kw">def</span> realisierte_kennzahlen(w, R):</span>
-<span id="cb186-113"><a href="#cb186-113" aria-hidden="true" tabindex="-1"></a>    <span class="co">&quot;&quot;&quot;VaR und CVaR direkt aus den Szenarien - unabhaengige Gegenprobe.&quot;&quot;&quot;</span></span>
-<span id="cb186-114"><a href="#cb186-114" aria-hidden="true" tabindex="-1"></a>    portfoliorenditen <span class="op">=</span> R <span class="op">@</span> w</span>
-<span id="cb186-115"><a href="#cb186-115" aria-hidden="true" tabindex="-1"></a>    verluste <span class="op">=</span> <span class="op">-</span>portfoliorenditen</span>
-<span id="cb186-116"><a href="#cb186-116" aria-hidden="true" tabindex="-1"></a>    var <span class="op">=</span> <span class="bu">float</span>(np.quantile(verluste, ALPHA))</span>
-<span id="cb186-117"><a href="#cb186-117" aria-hidden="true" tabindex="-1"></a>    cvar <span class="op">=</span> <span class="bu">float</span>(verluste[verluste <span class="op">&gt;=</span> var].mean())</span>
-<span id="cb186-118"><a href="#cb186-118" aria-hidden="true" tabindex="-1"></a>    <span class="cf">return</span> var, cvar, <span class="bu">float</span>(portfoliorenditen.mean()), <span class="bu">float</span>(portfoliorenditen.std(ddof<span class="op">=</span><span class="dv">1</span>))</span>
-<span id="cb186-119"><a href="#cb186-119" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb186-120"><a href="#cb186-120" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb186-121"><a href="#cb186-121" aria-hidden="true" tabindex="-1"></a><span class="cf">if</span> <span class="va">__name__</span> <span class="op">==</span> <span class="st">&quot;__main__&quot;</span>:</span>
-<span id="cb186-122"><a href="#cb186-122" aria-hidden="true" tabindex="-1"></a>    renditen <span class="op">=</span> lade_renditen()</span>
-<span id="cb186-123"><a href="#cb186-123" aria-hidden="true" tabindex="-1"></a>    R <span class="op">=</span> renditen.values</span>
-<span id="cb186-124"><a href="#cb186-124" aria-hidden="true" tabindex="-1"></a>    S, N <span class="op">=</span> R.shape</span>
-<span id="cb186-125"><a href="#cb186-125" aria-hidden="true" tabindex="-1"></a>    w_alt <span class="op">=</span> np.ones(N) <span class="op">/</span> N                 <span class="co"># Ausgangslage: Gleichgewichtung</span></span>
-<span id="cb186-126"><a href="#cb186-126" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb186-127"><a href="#cb186-127" aria-hidden="true" tabindex="-1"></a>    t0 <span class="op">=</span> time.perf_counter()</span>
-<span id="cb186-128"><a href="#cb186-128" aria-hidden="true" tabindex="-1"></a>    w_cvar, var_modell, cvar_modell, turnover <span class="op">=</span> optimiere_cvar(R, w_alt, vektorisiert<span class="op">=</span><span class="va">True</span>)</span>
-<span id="cb186-129"><a href="#cb186-129" aria-hidden="true" tabindex="-1"></a>    dauer_vektor <span class="op">=</span> time.perf_counter() <span class="op">-</span> t0</span>
-<span id="cb186-130"><a href="#cb186-130" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb186-131"><a href="#cb186-131" aria-hidden="true" tabindex="-1"></a>    w_var <span class="op">=</span> optimiere_varianz(R, w_alt)</span>
-<span id="cb186-132"><a href="#cb186-132" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb186-133"><a href="#cb186-133" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;=&quot;</span> <span class="op">*</span> <span class="dv">90</span>)</span>
-<span id="cb186-134"><a href="#cb186-134" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;         CVaR-PORTFOLIO-OPTIMIERUNG MIT TRANSAKTIONSKOSTEN&quot;</span>)</span>
-<span id="cb186-135"><a href="#cb186-135" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;=&quot;</span> <span class="op">*</span> <span class="dv">90</span>)</span>
-<span id="cb186-136"><a href="#cb186-136" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;Datenbasis: </span><span class="sc">{</span>S<span class="sc">}</span><span class="ss"> Handelstage, </span><span class="sc">{</span>N<span class="sc">}</span><span class="ss"> Titel | Konfidenzniveau &quot;</span></span>
-<span id="cb186-137"><a href="#cb186-137" aria-hidden="true" tabindex="-1"></a>          <span class="ss">f&quot;</span><span class="sc">{</span>ALPHA<span class="op">*</span><span class="dv">100</span><span class="sc">:.0f}</span><span class="ss"> % | Loesungszeit </span><span class="sc">{</span>dauer_vektor<span class="sc">:.2f}</span><span class="ss"> s</span><span class="ch">\n</span><span class="ss">&quot;</span>)</span>
-<span id="cb186-138"><a href="#cb186-138" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb186-139"><a href="#cb186-139" aria-hidden="true" tabindex="-1"></a>    <span class="co"># --- Gegenprobe: Modellwerte gegen realisierte Szenariowerte ---------</span></span>
-<span id="cb186-140"><a href="#cb186-140" aria-hidden="true" tabindex="-1"></a>    var_real, cvar_real, mu_real, sd_real <span class="op">=</span> realisierte_kennzahlen(w_cvar, R)</span>
-<span id="cb186-141"><a href="#cb186-141" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;--- Gegenprobe: stimmen Modell und Szenarien ueberein? ---&quot;</span>)</span>
-<span id="cb186-142"><a href="#cb186-142" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;  VaR  aus dem Modell (gamma): </span><span class="sc">{</span>var_modell<span class="op">*</span><span class="dv">100</span><span class="sc">:7.4f}</span><span class="ss"> %  |  &quot;</span></span>
-<span id="cb186-143"><a href="#cb186-143" aria-hidden="true" tabindex="-1"></a>          <span class="ss">f&quot;aus den Szenarien: </span><span class="sc">{</span>var_real<span class="op">*</span><span class="dv">100</span><span class="sc">:7.4f}</span><span class="ss"> %&quot;</span>)</span>
-<span id="cb186-144"><a href="#cb186-144" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;  CVaR aus dem Modell:         </span><span class="sc">{</span>cvar_modell<span class="op">*</span><span class="dv">100</span><span class="sc">:7.4f}</span><span class="ss"> %  |  &quot;</span></span>
-<span id="cb186-145"><a href="#cb186-145" aria-hidden="true" tabindex="-1"></a>          <span class="ss">f&quot;aus den Szenarien: </span><span class="sc">{</span>cvar_real<span class="op">*</span><span class="dv">100</span><span class="sc">:7.4f}</span><span class="ss"> %&quot;</span>)</span>
-<span id="cb186-146"><a href="#cb186-146" aria-hidden="true" tabindex="-1"></a>    <span class="cf">assert</span> <span class="bu">abs</span>(cvar_modell <span class="op">-</span> cvar_real) <span class="op">&lt;</span> <span class="fl">1e-4</span>, <span class="st">&quot;CVaR stimmt nicht mit den Szenarien!&quot;</span></span>
-<span id="cb186-147"><a href="#cb186-147" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;  -&gt; Der Rockafellar-Uryasev-Trick liefert exakt den empirischen CVaR.&quot;</span>)</span>
-<span id="cb186-148"><a href="#cb186-148" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb186-149"><a href="#cb186-149" aria-hidden="true" tabindex="-1"></a>    <span class="co"># --- Kennzahlen beider Portfolios ------------------------------------</span></span>
-<span id="cb186-150"><a href="#cb186-150" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;</span><span class="ch">\n</span><span class="sc">{</span><span class="st">&#39;Portfolio&#39;</span><span class="sc">:&lt;24}</span><span class="ss"> </span><span class="sc">{</span><span class="st">&#39;Rendite p.a.&#39;</span><span class="sc">:&gt;13}</span><span class="ss"> </span><span class="sc">{</span><span class="st">&#39;Vola p.a.&#39;</span><span class="sc">:&gt;11}</span><span class="ss"> &quot;</span></span>
-<span id="cb186-151"><a href="#cb186-151" aria-hidden="true" tabindex="-1"></a>          <span class="ss">f&quot;</span><span class="sc">{</span><span class="st">&#39;VaR 95% (Tag)&#39;</span><span class="sc">:&gt;15}</span><span class="ss"> </span><span class="sc">{</span><span class="st">&#39;CVaR 95% (Tag)&#39;</span><span class="sc">:&gt;16}</span><span class="ss"> </span><span class="sc">{</span><span class="st">&#39;Turnover&#39;</span><span class="sc">:&gt;10}</span><span class="ss">&quot;</span>)</span>
-<span id="cb186-152"><a href="#cb186-152" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;-&quot;</span> <span class="op">*</span> <span class="dv">90</span>)</span>
-<span id="cb186-153"><a href="#cb186-153" aria-hidden="true" tabindex="-1"></a>    <span class="cf">for</span> name, w <span class="kw">in</span> [(<span class="st">&quot;CVaR-optimiert&quot;</span>, w_cvar), (<span class="st">&quot;Varianz-optimiert&quot;</span>, w_var),</span>
-<span id="cb186-154"><a href="#cb186-154" aria-hidden="true" tabindex="-1"></a>                    (<span class="st">&quot;Gleichgewichtung&quot;</span>, w_alt)]:</span>
-<span id="cb186-155"><a href="#cb186-155" aria-hidden="true" tabindex="-1"></a>        v, c, m, s <span class="op">=</span> realisierte_kennzahlen(w, R)</span>
-<span id="cb186-156"><a href="#cb186-156" aria-hidden="true" tabindex="-1"></a>        to <span class="op">=</span> <span class="bu">float</span>(np.<span class="bu">abs</span>(w <span class="op">-</span> w_alt).<span class="bu">sum</span>())</span>
-<span id="cb186-157"><a href="#cb186-157" aria-hidden="true" tabindex="-1"></a>        <span class="bu">print</span>(<span class="ss">f&quot;</span><span class="sc">{</span>name<span class="sc">:&lt;24}</span><span class="ss"> </span><span class="sc">{</span>m<span class="op">*</span>HANDELSTAGE<span class="op">*</span><span class="dv">100</span><span class="sc">:&gt;12.2f}</span><span class="ss"> % &quot;</span></span>
-<span id="cb186-158"><a href="#cb186-158" aria-hidden="true" tabindex="-1"></a>              <span class="ss">f&quot;</span><span class="sc">{</span>s<span class="op">*</span>np<span class="sc">.</span>sqrt(HANDELSTAGE)<span class="op">*</span><span class="dv">100</span><span class="sc">:&gt;10.2f}</span><span class="ss"> % </span><span class="sc">{</span>v<span class="op">*</span><span class="dv">100</span><span class="sc">:&gt;14.3f}</span><span class="ss"> % &quot;</span></span>
-<span id="cb186-159"><a href="#cb186-159" aria-hidden="true" tabindex="-1"></a>              <span class="ss">f&quot;</span><span class="sc">{</span>c<span class="op">*</span><span class="dv">100</span><span class="sc">:&gt;15.3f}</span><span class="ss"> % </span><span class="sc">{</span>to<span class="op">*</span><span class="dv">100</span><span class="sc">:&gt;9.1f}</span><span class="ss"> %&quot;</span>)</span>
-<span id="cb186-160"><a href="#cb186-160" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb186-161"><a href="#cb186-161" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;</span><span class="ch">\n</span><span class="st">Hinweis zur Annualisierung: Renditen werden mit 252 skaliert,&quot;</span>)</span>
-<span id="cb186-162"><a href="#cb186-162" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;Volatilitaeten mit sqrt(252). Fuer VaR/CVaR ist eine solche Skalierung&quot;</span>)</span>
-<span id="cb186-163"><a href="#cb186-163" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;nur unter starken Annahmen (Unabhaengigkeit, kein Drift) zulaessig -&quot;</span>)</span>
-<span id="cb186-164"><a href="#cb186-164" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;sie werden hier deshalb bewusst als TAGESwerte ausgewiesen.&quot;</span>)</span>
-<span id="cb186-165"><a href="#cb186-165" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb186-166"><a href="#cb186-166" aria-hidden="true" tabindex="-1"></a>    <span class="co"># --- Allokationstabelle ------------------------------------------------</span></span>
-<span id="cb186-167"><a href="#cb186-167" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;</span><span class="ch">\n</span><span class="st">--- Allokation ---&quot;</span>)</span>
-<span id="cb186-168"><a href="#cb186-168" aria-hidden="true" tabindex="-1"></a>    tabelle <span class="op">=</span> pd.DataFrame({</span>
-<span id="cb186-169"><a href="#cb186-169" aria-hidden="true" tabindex="-1"></a>        <span class="st">&quot;Ticker&quot;</span>: TICKER,</span>
-<span id="cb186-170"><a href="#cb186-170" aria-hidden="true" tabindex="-1"></a>        <span class="st">&quot;vorher&quot;</span>: [<span class="ss">f&quot;</span><span class="sc">{</span>v<span class="op">*</span><span class="dv">100</span><span class="sc">:5.1f}</span><span class="ss"> %&quot;</span> <span class="cf">for</span> v <span class="kw">in</span> w_alt],</span>
-<span id="cb186-171"><a href="#cb186-171" aria-hidden="true" tabindex="-1"></a>        <span class="st">&quot;CVaR-opt.&quot;</span>: [<span class="ss">f&quot;</span><span class="sc">{</span>v<span class="op">*</span><span class="dv">100</span><span class="sc">:5.1f}</span><span class="ss"> %&quot;</span> <span class="cf">for</span> v <span class="kw">in</span> w_cvar],</span>
-<span id="cb186-172"><a href="#cb186-172" aria-hidden="true" tabindex="-1"></a>        <span class="st">&quot;Handel&quot;</span>: [<span class="ss">f&quot;</span><span class="sc">{</span>(w_cvar[i]<span class="op">-</span>w_alt[i])<span class="op">*</span><span class="dv">100</span><span class="sc">:+6.1f}</span><span class="ss"> %&quot;</span> <span class="cf">for</span> i <span class="kw">in</span> <span class="bu">range</span>(N)],</span>
-<span id="cb186-173"><a href="#cb186-173" aria-hidden="true" tabindex="-1"></a>        <span class="st">&quot;Varianz-opt.&quot;</span>: [<span class="ss">f&quot;</span><span class="sc">{</span>v<span class="op">*</span><span class="dv">100</span><span class="sc">:5.1f}</span><span class="ss"> %&quot;</span> <span class="cf">for</span> v <span class="kw">in</span> w_var],</span>
-<span id="cb186-174"><a href="#cb186-174" aria-hidden="true" tabindex="-1"></a>    })</span>
-<span id="cb186-175"><a href="#cb186-175" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(tabelle.to_string(index<span class="op">=</span><span class="va">False</span>))</span>
-<span id="cb186-176"><a href="#cb186-176" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;</span><span class="ch">\n</span><span class="ss">Turnover </span><span class="sc">{</span>turnover<span class="op">*</span><span class="dv">100</span><span class="sc">:.1f}</span><span class="ss"> % -&gt; Transaktionskosten &quot;</span></span>
-<span id="cb186-177"><a href="#cb186-177" aria-hidden="true" tabindex="-1"></a>          <span class="ss">f&quot;</span><span class="sc">{</span>GEBUEHRENSATZ<span class="op">*</span>turnover<span class="op">*</span><span class="dv">100</span><span class="sc">:.3f}</span><span class="ss"> % des Portfoliowerts&quot;</span>)</span>
-<span id="cb186-178"><a href="#cb186-178" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb186-179"><a href="#cb186-179" aria-hidden="true" tabindex="-1"></a>    <span class="co"># --- Laufzeitvergleich vektorisiert vs. Schleife ----------------------</span></span>
-<span id="cb186-180"><a href="#cb186-180" aria-hidden="true" tabindex="-1"></a>    <span class="cf">if</span> S <span class="op">&lt;=</span> <span class="dv">600</span>:                     <span class="co"># bei sehr vielen Szenarien zu langsam</span></span>
-<span id="cb186-181"><a href="#cb186-181" aria-hidden="true" tabindex="-1"></a>        t0 <span class="op">=</span> time.perf_counter()</span>
-<span id="cb186-182"><a href="#cb186-182" aria-hidden="true" tabindex="-1"></a>        optimiere_cvar(R, w_alt, vektorisiert<span class="op">=</span><span class="va">False</span>)</span>
-<span id="cb186-183"><a href="#cb186-183" aria-hidden="true" tabindex="-1"></a>        dauer_schleife <span class="op">=</span> time.perf_counter() <span class="op">-</span> t0</span>
-<span id="cb186-184"><a href="#cb186-184" aria-hidden="true" tabindex="-1"></a>        <span class="bu">print</span>(<span class="ss">f&quot;</span><span class="ch">\n</span><span class="ss">--- Laufzeit: </span><span class="sc">{</span>S<span class="sc">}</span><span class="ss"> Nebenbedingungen aufbauen ---&quot;</span>)</span>
-<span id="cb186-185"><a href="#cb186-185" aria-hidden="true" tabindex="-1"></a>        <span class="bu">print</span>(<span class="ss">f&quot;  vektorisiert (u &gt;= -(R @ w) - gamma): </span><span class="sc">{</span>dauer_vektor<span class="sc">:6.2f}</span><span class="ss"> s&quot;</span>)</span>
-<span id="cb186-186"><a href="#cb186-186" aria-hidden="true" tabindex="-1"></a>        <span class="bu">print</span>(<span class="ss">f&quot;  Schleife ueber Szenarien (V01):        </span><span class="sc">{</span>dauer_schleife<span class="sc">:6.2f}</span><span class="ss"> s &quot;</span></span>
-<span id="cb186-187"><a href="#cb186-187" aria-hidden="true" tabindex="-1"></a>              <span class="ss">f&quot;(</span><span class="sc">{</span>dauer_schleife<span class="op">/</span>dauer_vektor<span class="sc">:.1f}</span><span class="ss">x langsamer)&quot;</span>)</span>
-<span id="cb186-188"><a href="#cb186-188" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;=&quot;</span> <span class="op">*</span> <span class="dv">90</span>)</span></code></pre></div>
+<div class="sourceCode" id="cb188"><pre class="sourceCode python"><code class="sourceCode python"><span id="cb188-1"><a href="#cb188-1" aria-hidden="true" tabindex="-1"></a><span class="co">#!/usr/bin/env python3</span></span>
+<span id="cb188-2"><a href="#cb188-2" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb188-3"><a href="#cb188-3" aria-hidden="true" tabindex="-1"></a><span class="co"># CVaR_Portfolio.py</span></span>
+<span id="cb188-4"><a href="#cb188-4" aria-hidden="true" tabindex="-1"></a><span class="co">&quot;&quot;&quot;</span></span>
+<span id="cb188-5"><a href="#cb188-5" aria-hidden="true" tabindex="-1"></a><span class="co">Kapitel CVaR: CVaR-Optimierung mit L1-Transaktionskosten via CVXPY.</span></span>
+<span id="cb188-6"><a href="#cb188-6" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb188-7"><a href="#cb188-7" aria-hidden="true" tabindex="-1"></a><span class="co">Eigenschaften:</span></span>
+<span id="cb188-8"><a href="#cb188-8" aria-hidden="true" tabindex="-1"></a><span class="co">  * Spaltenreihenfolge erzwungen</span></span>
+<span id="cb188-9"><a href="#cb188-9" aria-hidden="true" tabindex="-1"></a><span class="co">  * Einheiten konsistent (alles taeglich, Annualisierung nur in der Ausgabe)</span></span>
+<span id="cb188-10"><a href="#cb188-10" aria-hidden="true" tabindex="-1"></a><span class="co">  * Szenario-Nebenbedingungen VEKTORISIERT statt in einer Python-Schleife</span></span>
+<span id="cb188-11"><a href="#cb188-11" aria-hidden="true" tabindex="-1"></a><span class="co">    (eine Matrixbedingung statt S einzelner Constraints - deutlich schneller)</span></span>
+<span id="cb188-12"><a href="#cb188-12" aria-hidden="true" tabindex="-1"></a><span class="co">  * Vergleich CVaR- gegen Varianz-Optimierung</span></span>
+<span id="cb188-13"><a href="#cb188-13" aria-hidden="true" tabindex="-1"></a><span class="co">  * Nachrechnung von VaR/CVaR aus den realisierten Szenarien</span></span>
+<span id="cb188-14"><a href="#cb188-14" aria-hidden="true" tabindex="-1"></a><span class="co">&quot;&quot;&quot;</span></span>
+<span id="cb188-15"><a href="#cb188-15" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb188-16"><a href="#cb188-16" aria-hidden="true" tabindex="-1"></a><span class="im">import</span> time</span>
+<span id="cb188-17"><a href="#cb188-17" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb188-18"><a href="#cb188-18" aria-hidden="true" tabindex="-1"></a><span class="im">import</span> cvxpy <span class="im">as</span> cp</span>
+<span id="cb188-19"><a href="#cb188-19" aria-hidden="true" tabindex="-1"></a><span class="im">import</span> numpy <span class="im">as</span> np</span>
+<span id="cb188-20"><a href="#cb188-20" aria-hidden="true" tabindex="-1"></a><span class="im">import</span> pandas <span class="im">as</span> pd</span>
+<span id="cb188-21"><a href="#cb188-21" aria-hidden="true" tabindex="-1"></a><span class="im">import</span> yfinance <span class="im">as</span> yf</span>
+<span id="cb188-22"><a href="#cb188-22" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb188-23"><a href="#cb188-23" aria-hidden="true" tabindex="-1"></a>TICKER <span class="op">=</span> [<span class="st">&quot;AAPL&quot;</span>, <span class="st">&quot;MSFT&quot;</span>, <span class="st">&quot;NVDA&quot;</span>, <span class="st">&quot;AMZN&quot;</span>, <span class="st">&quot;JNJ&quot;</span>, <span class="st">&quot;PFE&quot;</span>, <span class="st">&quot;JPM&quot;</span>, <span class="st">&quot;GS&quot;</span>, <span class="st">&quot;XOM&quot;</span>, <span class="st">&quot;CVX&quot;</span>]</span>
+<span id="cb188-24"><a href="#cb188-24" aria-hidden="true" tabindex="-1"></a>ALPHA <span class="op">=</span> <span class="fl">0.95</span>            <span class="co"># Konfidenzniveau: schlechteste 5 % der Tage</span></span>
+<span id="cb188-25"><a href="#cb188-25" aria-hidden="true" tabindex="-1"></a>MAX_GEWICHT <span class="op">=</span> <span class="fl">0.25</span></span>
+<span id="cb188-26"><a href="#cb188-26" aria-hidden="true" tabindex="-1"></a>GEBUEHRENSATZ <span class="op">=</span> <span class="fl">0.002</span>   <span class="co"># 0,2 % je Einheit Turnover (Spread + Brokerage)</span></span>
+<span id="cb188-27"><a href="#cb188-27" aria-hidden="true" tabindex="-1"></a>RISIKOAVERSION <span class="op">=</span> <span class="fl">1.5</span>    <span class="co"># bezogen auf TAEGLICHE Groessen</span></span>
+<span id="cb188-28"><a href="#cb188-28" aria-hidden="true" tabindex="-1"></a>HANDELSTAGE <span class="op">=</span> <span class="dv">252</span></span>
+<span id="cb188-29"><a href="#cb188-29" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb188-30"><a href="#cb188-30" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb188-31"><a href="#cb188-31" aria-hidden="true" tabindex="-1"></a><span class="kw">def</span> lade_renditen():</span>
+<span id="cb188-32"><a href="#cb188-32" aria-hidden="true" tabindex="-1"></a>    ende <span class="op">=</span> pd.Timestamp.today().normalize()</span>
+<span id="cb188-33"><a href="#cb188-33" aria-hidden="true" tabindex="-1"></a>    start <span class="op">=</span> ende <span class="op">-</span> pd.DateOffset(years<span class="op">=</span><span class="dv">2</span>)</span>
+<span id="cb188-34"><a href="#cb188-34" aria-hidden="true" tabindex="-1"></a>    roh <span class="op">=</span> yf.download(TICKER, start<span class="op">=</span>start, end<span class="op">=</span>ende, auto_adjust<span class="op">=</span><span class="va">True</span>, progress<span class="op">=</span><span class="va">False</span>)</span>
+<span id="cb188-35"><a href="#cb188-35" aria-hidden="true" tabindex="-1"></a>    <span class="cf">if</span> roh.empty:</span>
+<span id="cb188-36"><a href="#cb188-36" aria-hidden="true" tabindex="-1"></a>        <span class="cf">raise</span> <span class="pp">SystemExit</span>(<span class="st">&quot;Download fehlgeschlagen (Netz, Ticker oder Rate-Limit pruefen).&quot;</span>)</span>
+<span id="cb188-37"><a href="#cb188-37" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb188-38"><a href="#cb188-38" aria-hidden="true" tabindex="-1"></a>    <span class="cf">if</span> <span class="bu">isinstance</span>(roh.columns, pd.MultiIndex):</span>
+<span id="cb188-39"><a href="#cb188-39" aria-hidden="true" tabindex="-1"></a>        kurse <span class="op">=</span> roh[<span class="st">&quot;Close&quot;</span>][TICKER].dropna()        <span class="co"># erzwingt eigene Spaltenreihenfolge</span></span>
+<span id="cb188-40"><a href="#cb188-40" aria-hidden="true" tabindex="-1"></a>    <span class="cf">else</span>:</span>
+<span id="cb188-41"><a href="#cb188-41" aria-hidden="true" tabindex="-1"></a>        kurse <span class="op">=</span> roh[[<span class="st">&quot;Close&quot;</span>]].dropna()</span>
+<span id="cb188-42"><a href="#cb188-42" aria-hidden="true" tabindex="-1"></a>        kurse.columns <span class="op">=</span> TICKER</span>
+<span id="cb188-43"><a href="#cb188-43" aria-hidden="true" tabindex="-1"></a>    <span class="cf">assert</span> <span class="bu">list</span>(kurse.columns) <span class="op">==</span> TICKER, <span class="st">&quot;Spaltenreihenfolge weicht ab!&quot;</span></span>
+<span id="cb188-44"><a href="#cb188-44" aria-hidden="true" tabindex="-1"></a>    <span class="cf">return</span> kurse.pct_change().dropna()</span>
+<span id="cb188-45"><a href="#cb188-45" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb188-46"><a href="#cb188-46" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb188-47"><a href="#cb188-47" aria-hidden="true" tabindex="-1"></a><span class="kw">def</span> optimiere_cvar(R, w_alt, vektorisiert<span class="op">=</span><span class="va">True</span>):</span>
+<span id="cb188-48"><a href="#cb188-48" aria-hidden="true" tabindex="-1"></a>    <span class="co">&quot;&quot;&quot;</span></span>
+<span id="cb188-49"><a href="#cb188-49" aria-hidden="true" tabindex="-1"></a><span class="co">    Maximiere:  taegliche Rendite - lambda * CVaR - Transaktionskosten</span></span>
+<span id="cb188-50"><a href="#cb188-50" aria-hidden="true" tabindex="-1"></a><span class="co">    Alle Groessen TAEGLICH.</span></span>
+<span id="cb188-51"><a href="#cb188-51" aria-hidden="true" tabindex="-1"></a><span class="co">    &quot;&quot;&quot;</span></span>
+<span id="cb188-52"><a href="#cb188-52" aria-hidden="true" tabindex="-1"></a>    S, N <span class="op">=</span> R.shape</span>
+<span id="cb188-53"><a href="#cb188-53" aria-hidden="true" tabindex="-1"></a>    mu_taeglich <span class="op">=</span> R.mean(axis<span class="op">=</span><span class="dv">0</span>)</span>
+<span id="cb188-54"><a href="#cb188-54" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb188-55"><a href="#cb188-55" aria-hidden="true" tabindex="-1"></a>    w <span class="op">=</span> cp.Variable(N, nonneg<span class="op">=</span><span class="va">True</span>)</span>
+<span id="cb188-56"><a href="#cb188-56" aria-hidden="true" tabindex="-1"></a>    gamma <span class="op">=</span> cp.Variable()                  <span class="co"># wird im Optimum zum VaR</span></span>
+<span id="cb188-57"><a href="#cb188-57" aria-hidden="true" tabindex="-1"></a>    u <span class="op">=</span> cp.Variable(S, nonneg<span class="op">=</span><span class="va">True</span>)        <span class="co"># Ueberschuss ueber die Schwelle</span></span>
+<span id="cb188-58"><a href="#cb188-58" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb188-59"><a href="#cb188-59" aria-hidden="true" tabindex="-1"></a>    cvar <span class="op">=</span> gamma <span class="op">+</span> (<span class="fl">1.0</span> <span class="op">/</span> (S <span class="op">*</span> (<span class="fl">1.0</span> <span class="op">-</span> ALPHA))) <span class="op">*</span> cp.<span class="bu">sum</span>(u)</span>
+<span id="cb188-60"><a href="#cb188-60" aria-hidden="true" tabindex="-1"></a>    turnover <span class="op">=</span> cp.norm1(w <span class="op">-</span> w_alt)</span>
+<span id="cb188-61"><a href="#cb188-61" aria-hidden="true" tabindex="-1"></a>    kosten <span class="op">=</span> GEBUEHRENSATZ <span class="op">*</span> turnover</span>
+<span id="cb188-62"><a href="#cb188-62" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb188-63"><a href="#cb188-63" aria-hidden="true" tabindex="-1"></a>    ziel <span class="op">=</span> cp.Maximize(mu_taeglich <span class="op">@</span> w <span class="op">-</span> RISIKOAVERSION <span class="op">*</span> cvar <span class="op">-</span> kosten)</span>
+<span id="cb188-64"><a href="#cb188-64" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb188-65"><a href="#cb188-65" aria-hidden="true" tabindex="-1"></a>    bedingungen <span class="op">=</span> [cp.<span class="bu">sum</span>(w) <span class="op">==</span> <span class="dv">1</span>, w <span class="op">&lt;=</span> MAX_GEWICHT]</span>
+<span id="cb188-66"><a href="#cb188-66" aria-hidden="true" tabindex="-1"></a>    <span class="cf">if</span> vektorisiert:</span>
+<span id="cb188-67"><a href="#cb188-67" aria-hidden="true" tabindex="-1"></a>        <span class="co"># EINE Matrixbedingung statt S einzelner - deutlich schneller</span></span>
+<span id="cb188-68"><a href="#cb188-68" aria-hidden="true" tabindex="-1"></a>        bedingungen.append(u <span class="op">&gt;=</span> <span class="op">-</span>(R <span class="op">@</span> w) <span class="op">-</span> gamma)</span>
+<span id="cb188-69"><a href="#cb188-69" aria-hidden="true" tabindex="-1"></a>    <span class="cf">else</span>:</span>
+<span id="cb188-70"><a href="#cb188-70" aria-hidden="true" tabindex="-1"></a>        <span class="cf">for</span> s <span class="kw">in</span> <span class="bu">range</span>(S):                 <span class="co"># Alternative: S einzelne Constraints (langsamer)</span></span>
+<span id="cb188-71"><a href="#cb188-71" aria-hidden="true" tabindex="-1"></a>            bedingungen.append(u[s] <span class="op">&gt;=</span> <span class="op">-</span>R[s] <span class="op">@</span> w <span class="op">-</span> gamma)</span>
+<span id="cb188-72"><a href="#cb188-72" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb188-73"><a href="#cb188-73" aria-hidden="true" tabindex="-1"></a>    problem <span class="op">=</span> cp.Problem(ziel, bedingungen)</span>
+<span id="cb188-74"><a href="#cb188-74" aria-hidden="true" tabindex="-1"></a>    problem.solve()</span>
+<span id="cb188-75"><a href="#cb188-75" aria-hidden="true" tabindex="-1"></a>    <span class="cf">if</span> problem.status <span class="kw">not</span> <span class="kw">in</span> (<span class="st">&quot;optimal&quot;</span>, <span class="st">&quot;optimal_inaccurate&quot;</span>):</span>
+<span id="cb188-76"><a href="#cb188-76" aria-hidden="true" tabindex="-1"></a>        <span class="cf">raise</span> <span class="pp">SystemExit</span>(<span class="ss">f&quot;CVaR-Problem nicht loesbar: </span><span class="sc">{</span>problem<span class="sc">.</span>status<span class="sc">}</span><span class="ss">&quot;</span>)</span>
+<span id="cb188-77"><a href="#cb188-77" aria-hidden="true" tabindex="-1"></a>    <span class="cf">return</span> w.value, <span class="bu">float</span>(gamma.value), <span class="bu">float</span>(cvar.value), <span class="bu">float</span>(turnover.value)</span>
+<span id="cb188-78"><a href="#cb188-78" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb188-79"><a href="#cb188-79" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb188-80"><a href="#cb188-80" aria-hidden="true" tabindex="-1"></a><span class="kw">def</span> optimiere_varianz(R, w_alt):</span>
+<span id="cb188-81"><a href="#cb188-81" aria-hidden="true" tabindex="-1"></a>    <span class="co">&quot;&quot;&quot;Klassisches Mean-Variance zum Vergleich - ebenfalls taeglich gerechnet.</span></span>
+<span id="cb188-82"><a href="#cb188-82" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb188-83"><a href="#cb188-83" aria-hidden="true" tabindex="-1"></a><span class="co">    ACHTUNG, DCP-Falle: Die Standardabweichung ist hier NICHT als</span></span>
+<span id="cb188-84"><a href="#cb188-84" aria-hidden="true" tabindex="-1"></a><span class="co">    cp.sqrt(cp.quad_form(w, sigma)) formulierbar. cp.sqrt ist konkav und</span></span>
+<span id="cb188-85"><a href="#cb188-85" aria-hidden="true" tabindex="-1"></a><span class="co">    verlangt ein konkaves Argument; quad_form ist konvex - CVXPY lehnt den</span></span>
+<span id="cb188-86"><a href="#cb188-86" aria-hidden="true" tabindex="-1"></a><span class="co">    Ausdruck mit einem DCPError ab, und zwar voellig zu Recht (Anhang</span></span>
+<span id="cb188-87"><a href="#cb188-87" aria-hidden="true" tabindex="-1"></a><span class="co">    Fehlerdiagnose). cp.psd_wrap() hilft dagegen nicht: Es behebt eine</span></span>
+<span id="cb188-88"><a href="#cb188-88" aria-hidden="true" tabindex="-1"></a><span class="co">    NUMERISCHE Beanstandung an sigma, keine Regelverletzung im Aufbau.</span></span>
+<span id="cb188-89"><a href="#cb188-89" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb188-90"><a href="#cb188-90" aria-hidden="true" tabindex="-1"></a><span class="co">    Der Standardweg ist die Cholesky-Zerlegung sigma = L L^T. Damit gilt</span></span>
+<span id="cb188-91"><a href="#cb188-91" aria-hidden="true" tabindex="-1"></a><span class="co">    w&#39; sigma w = ||L^T w||^2, also ist die Standardabweichung die 2-Norm</span></span>
+<span id="cb188-92"><a href="#cb188-92" aria-hidden="true" tabindex="-1"></a><span class="co">    eines AFFINEN Ausdrucks - konvex und damit regelkonform.</span></span>
+<span id="cb188-93"><a href="#cb188-93" aria-hidden="true" tabindex="-1"></a><span class="co">    &quot;&quot;&quot;</span></span>
+<span id="cb188-94"><a href="#cb188-94" aria-hidden="true" tabindex="-1"></a>    N <span class="op">=</span> R.shape[<span class="dv">1</span>]</span>
+<span id="cb188-95"><a href="#cb188-95" aria-hidden="true" tabindex="-1"></a>    mu_taeglich <span class="op">=</span> R.mean(axis<span class="op">=</span><span class="dv">0</span>)</span>
+<span id="cb188-96"><a href="#cb188-96" aria-hidden="true" tabindex="-1"></a>    sigma <span class="op">=</span> np.cov(R, rowvar<span class="op">=</span><span class="va">False</span>, ddof<span class="op">=</span><span class="dv">1</span>)</span>
+<span id="cb188-97"><a href="#cb188-97" aria-hidden="true" tabindex="-1"></a>    <span class="co"># Der winzige Diagonalzuschlag faengt den Fall ab, dass sigma numerisch</span></span>
+<span id="cb188-98"><a href="#cb188-98" aria-hidden="true" tabindex="-1"></a>    <span class="co"># nur halbdefinit ist (mehr Titel als Handelstage, doppelte Spalten).</span></span>
+<span id="cb188-99"><a href="#cb188-99" aria-hidden="true" tabindex="-1"></a>    L <span class="op">=</span> np.linalg.cholesky(sigma <span class="op">+</span> <span class="fl">1e-12</span> <span class="op">*</span> np.eye(N))</span>
+<span id="cb188-100"><a href="#cb188-100" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb188-101"><a href="#cb188-101" aria-hidden="true" tabindex="-1"></a>    w <span class="op">=</span> cp.Variable(N, nonneg<span class="op">=</span><span class="va">True</span>)</span>
+<span id="cb188-102"><a href="#cb188-102" aria-hidden="true" tabindex="-1"></a>    ziel <span class="op">=</span> cp.Maximize(mu_taeglich <span class="op">@</span> w</span>
+<span id="cb188-103"><a href="#cb188-103" aria-hidden="true" tabindex="-1"></a>                       <span class="op">-</span> RISIKOAVERSION <span class="op">*</span> cp.norm2(L.T <span class="op">@</span> w)</span>
+<span id="cb188-104"><a href="#cb188-104" aria-hidden="true" tabindex="-1"></a>                       <span class="op">-</span> GEBUEHRENSATZ <span class="op">*</span> cp.norm1(w <span class="op">-</span> w_alt))</span>
+<span id="cb188-105"><a href="#cb188-105" aria-hidden="true" tabindex="-1"></a>    problem <span class="op">=</span> cp.Problem(ziel, [cp.<span class="bu">sum</span>(w) <span class="op">==</span> <span class="dv">1</span>, w <span class="op">&lt;=</span> MAX_GEWICHT])</span>
+<span id="cb188-106"><a href="#cb188-106" aria-hidden="true" tabindex="-1"></a>    problem.solve()</span>
+<span id="cb188-107"><a href="#cb188-107" aria-hidden="true" tabindex="-1"></a>    <span class="cf">if</span> problem.status <span class="kw">not</span> <span class="kw">in</span> (<span class="st">&quot;optimal&quot;</span>, <span class="st">&quot;optimal_inaccurate&quot;</span>):</span>
+<span id="cb188-108"><a href="#cb188-108" aria-hidden="true" tabindex="-1"></a>        <span class="cf">raise</span> <span class="pp">SystemExit</span>(<span class="ss">f&quot;Varianz-Problem nicht loesbar: </span><span class="sc">{</span>problem<span class="sc">.</span>status<span class="sc">}</span><span class="ss">&quot;</span>)</span>
+<span id="cb188-109"><a href="#cb188-109" aria-hidden="true" tabindex="-1"></a>    <span class="cf">return</span> w.value</span>
+<span id="cb188-110"><a href="#cb188-110" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb188-111"><a href="#cb188-111" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb188-112"><a href="#cb188-112" aria-hidden="true" tabindex="-1"></a><span class="kw">def</span> realisierte_kennzahlen(w, R):</span>
+<span id="cb188-113"><a href="#cb188-113" aria-hidden="true" tabindex="-1"></a>    <span class="co">&quot;&quot;&quot;VaR und CVaR direkt aus den Szenarien - unabhaengige Gegenprobe.&quot;&quot;&quot;</span></span>
+<span id="cb188-114"><a href="#cb188-114" aria-hidden="true" tabindex="-1"></a>    portfoliorenditen <span class="op">=</span> R <span class="op">@</span> w</span>
+<span id="cb188-115"><a href="#cb188-115" aria-hidden="true" tabindex="-1"></a>    verluste <span class="op">=</span> <span class="op">-</span>portfoliorenditen</span>
+<span id="cb188-116"><a href="#cb188-116" aria-hidden="true" tabindex="-1"></a>    var <span class="op">=</span> <span class="bu">float</span>(np.quantile(verluste, ALPHA))</span>
+<span id="cb188-117"><a href="#cb188-117" aria-hidden="true" tabindex="-1"></a>    cvar <span class="op">=</span> <span class="bu">float</span>(verluste[verluste <span class="op">&gt;=</span> var].mean())</span>
+<span id="cb188-118"><a href="#cb188-118" aria-hidden="true" tabindex="-1"></a>    <span class="cf">return</span> var, cvar, <span class="bu">float</span>(portfoliorenditen.mean()), <span class="bu">float</span>(portfoliorenditen.std(ddof<span class="op">=</span><span class="dv">1</span>))</span>
+<span id="cb188-119"><a href="#cb188-119" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb188-120"><a href="#cb188-120" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb188-121"><a href="#cb188-121" aria-hidden="true" tabindex="-1"></a><span class="cf">if</span> <span class="va">__name__</span> <span class="op">==</span> <span class="st">&quot;__main__&quot;</span>:</span>
+<span id="cb188-122"><a href="#cb188-122" aria-hidden="true" tabindex="-1"></a>    renditen <span class="op">=</span> lade_renditen()</span>
+<span id="cb188-123"><a href="#cb188-123" aria-hidden="true" tabindex="-1"></a>    R <span class="op">=</span> renditen.values</span>
+<span id="cb188-124"><a href="#cb188-124" aria-hidden="true" tabindex="-1"></a>    S, N <span class="op">=</span> R.shape</span>
+<span id="cb188-125"><a href="#cb188-125" aria-hidden="true" tabindex="-1"></a>    w_alt <span class="op">=</span> np.ones(N) <span class="op">/</span> N                 <span class="co"># Ausgangslage: Gleichgewichtung</span></span>
+<span id="cb188-126"><a href="#cb188-126" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb188-127"><a href="#cb188-127" aria-hidden="true" tabindex="-1"></a>    t0 <span class="op">=</span> time.perf_counter()</span>
+<span id="cb188-128"><a href="#cb188-128" aria-hidden="true" tabindex="-1"></a>    w_cvar, var_modell, cvar_modell, turnover <span class="op">=</span> optimiere_cvar(R, w_alt, vektorisiert<span class="op">=</span><span class="va">True</span>)</span>
+<span id="cb188-129"><a href="#cb188-129" aria-hidden="true" tabindex="-1"></a>    dauer_vektor <span class="op">=</span> time.perf_counter() <span class="op">-</span> t0</span>
+<span id="cb188-130"><a href="#cb188-130" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb188-131"><a href="#cb188-131" aria-hidden="true" tabindex="-1"></a>    w_var <span class="op">=</span> optimiere_varianz(R, w_alt)</span>
+<span id="cb188-132"><a href="#cb188-132" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb188-133"><a href="#cb188-133" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;=&quot;</span> <span class="op">*</span> <span class="dv">90</span>)</span>
+<span id="cb188-134"><a href="#cb188-134" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;         CVaR-PORTFOLIO-OPTIMIERUNG MIT TRANSAKTIONSKOSTEN&quot;</span>)</span>
+<span id="cb188-135"><a href="#cb188-135" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;=&quot;</span> <span class="op">*</span> <span class="dv">90</span>)</span>
+<span id="cb188-136"><a href="#cb188-136" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;Datenbasis: </span><span class="sc">{</span>S<span class="sc">}</span><span class="ss"> Handelstage, </span><span class="sc">{</span>N<span class="sc">}</span><span class="ss"> Titel | Konfidenzniveau &quot;</span></span>
+<span id="cb188-137"><a href="#cb188-137" aria-hidden="true" tabindex="-1"></a>          <span class="ss">f&quot;</span><span class="sc">{</span>ALPHA<span class="op">*</span><span class="dv">100</span><span class="sc">:.0f}</span><span class="ss"> % | Loesungszeit </span><span class="sc">{</span>dauer_vektor<span class="sc">:.2f}</span><span class="ss"> s</span><span class="ch">\n</span><span class="ss">&quot;</span>)</span>
+<span id="cb188-138"><a href="#cb188-138" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb188-139"><a href="#cb188-139" aria-hidden="true" tabindex="-1"></a>    <span class="co"># --- Gegenprobe: Modellwerte gegen realisierte Szenariowerte ---------</span></span>
+<span id="cb188-140"><a href="#cb188-140" aria-hidden="true" tabindex="-1"></a>    var_real, cvar_real, mu_real, sd_real <span class="op">=</span> realisierte_kennzahlen(w_cvar, R)</span>
+<span id="cb188-141"><a href="#cb188-141" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;--- Gegenprobe: stimmen Modell und Szenarien ueberein? ---&quot;</span>)</span>
+<span id="cb188-142"><a href="#cb188-142" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;  VaR  aus dem Modell (gamma): </span><span class="sc">{</span>var_modell<span class="op">*</span><span class="dv">100</span><span class="sc">:7.4f}</span><span class="ss"> %  |  &quot;</span></span>
+<span id="cb188-143"><a href="#cb188-143" aria-hidden="true" tabindex="-1"></a>          <span class="ss">f&quot;aus den Szenarien: </span><span class="sc">{</span>var_real<span class="op">*</span><span class="dv">100</span><span class="sc">:7.4f}</span><span class="ss"> %&quot;</span>)</span>
+<span id="cb188-144"><a href="#cb188-144" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;  CVaR aus dem Modell:         </span><span class="sc">{</span>cvar_modell<span class="op">*</span><span class="dv">100</span><span class="sc">:7.4f}</span><span class="ss"> %  |  &quot;</span></span>
+<span id="cb188-145"><a href="#cb188-145" aria-hidden="true" tabindex="-1"></a>          <span class="ss">f&quot;aus den Szenarien: </span><span class="sc">{</span>cvar_real<span class="op">*</span><span class="dv">100</span><span class="sc">:7.4f}</span><span class="ss"> %&quot;</span>)</span>
+<span id="cb188-146"><a href="#cb188-146" aria-hidden="true" tabindex="-1"></a>    <span class="cf">assert</span> <span class="bu">abs</span>(cvar_modell <span class="op">-</span> cvar_real) <span class="op">&lt;</span> <span class="fl">1e-4</span>, <span class="st">&quot;CVaR stimmt nicht mit den Szenarien!&quot;</span></span>
+<span id="cb188-147"><a href="#cb188-147" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;  -&gt; Der Rockafellar-Uryasev-Trick liefert exakt den empirischen CVaR.&quot;</span>)</span>
+<span id="cb188-148"><a href="#cb188-148" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb188-149"><a href="#cb188-149" aria-hidden="true" tabindex="-1"></a>    <span class="co"># --- Kennzahlen beider Portfolios ------------------------------------</span></span>
+<span id="cb188-150"><a href="#cb188-150" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;</span><span class="ch">\n</span><span class="sc">{</span><span class="st">&#39;Portfolio&#39;</span><span class="sc">:&lt;24}</span><span class="ss"> </span><span class="sc">{</span><span class="st">&#39;Rendite p.a.&#39;</span><span class="sc">:&gt;13}</span><span class="ss"> </span><span class="sc">{</span><span class="st">&#39;Vola p.a.&#39;</span><span class="sc">:&gt;11}</span><span class="ss"> &quot;</span></span>
+<span id="cb188-151"><a href="#cb188-151" aria-hidden="true" tabindex="-1"></a>          <span class="ss">f&quot;</span><span class="sc">{</span><span class="st">&#39;VaR 95% (Tag)&#39;</span><span class="sc">:&gt;15}</span><span class="ss"> </span><span class="sc">{</span><span class="st">&#39;CVaR 95% (Tag)&#39;</span><span class="sc">:&gt;16}</span><span class="ss"> </span><span class="sc">{</span><span class="st">&#39;Turnover&#39;</span><span class="sc">:&gt;10}</span><span class="ss">&quot;</span>)</span>
+<span id="cb188-152"><a href="#cb188-152" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;-&quot;</span> <span class="op">*</span> <span class="dv">90</span>)</span>
+<span id="cb188-153"><a href="#cb188-153" aria-hidden="true" tabindex="-1"></a>    <span class="cf">for</span> name, w <span class="kw">in</span> [(<span class="st">&quot;CVaR-optimiert&quot;</span>, w_cvar), (<span class="st">&quot;Varianz-optimiert&quot;</span>, w_var),</span>
+<span id="cb188-154"><a href="#cb188-154" aria-hidden="true" tabindex="-1"></a>                    (<span class="st">&quot;Gleichgewichtung&quot;</span>, w_alt)]:</span>
+<span id="cb188-155"><a href="#cb188-155" aria-hidden="true" tabindex="-1"></a>        v, c, m, s <span class="op">=</span> realisierte_kennzahlen(w, R)</span>
+<span id="cb188-156"><a href="#cb188-156" aria-hidden="true" tabindex="-1"></a>        to <span class="op">=</span> <span class="bu">float</span>(np.<span class="bu">abs</span>(w <span class="op">-</span> w_alt).<span class="bu">sum</span>())</span>
+<span id="cb188-157"><a href="#cb188-157" aria-hidden="true" tabindex="-1"></a>        <span class="bu">print</span>(<span class="ss">f&quot;</span><span class="sc">{</span>name<span class="sc">:&lt;24}</span><span class="ss"> </span><span class="sc">{</span>m<span class="op">*</span>HANDELSTAGE<span class="op">*</span><span class="dv">100</span><span class="sc">:&gt;12.2f}</span><span class="ss"> % &quot;</span></span>
+<span id="cb188-158"><a href="#cb188-158" aria-hidden="true" tabindex="-1"></a>              <span class="ss">f&quot;</span><span class="sc">{</span>s<span class="op">*</span>np<span class="sc">.</span>sqrt(HANDELSTAGE)<span class="op">*</span><span class="dv">100</span><span class="sc">:&gt;10.2f}</span><span class="ss"> % </span><span class="sc">{</span>v<span class="op">*</span><span class="dv">100</span><span class="sc">:&gt;14.3f}</span><span class="ss"> % &quot;</span></span>
+<span id="cb188-159"><a href="#cb188-159" aria-hidden="true" tabindex="-1"></a>              <span class="ss">f&quot;</span><span class="sc">{</span>c<span class="op">*</span><span class="dv">100</span><span class="sc">:&gt;15.3f}</span><span class="ss"> % </span><span class="sc">{</span>to<span class="op">*</span><span class="dv">100</span><span class="sc">:&gt;9.1f}</span><span class="ss"> %&quot;</span>)</span>
+<span id="cb188-160"><a href="#cb188-160" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb188-161"><a href="#cb188-161" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;</span><span class="ch">\n</span><span class="st">Hinweis zur Annualisierung: Renditen werden mit 252 skaliert,&quot;</span>)</span>
+<span id="cb188-162"><a href="#cb188-162" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;Volatilitaeten mit sqrt(252). Fuer VaR/CVaR ist eine solche Skalierung&quot;</span>)</span>
+<span id="cb188-163"><a href="#cb188-163" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;nur unter starken Annahmen (Unabhaengigkeit, kein Drift) zulaessig -&quot;</span>)</span>
+<span id="cb188-164"><a href="#cb188-164" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;sie werden hier deshalb bewusst als TAGESwerte ausgewiesen.&quot;</span>)</span>
+<span id="cb188-165"><a href="#cb188-165" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb188-166"><a href="#cb188-166" aria-hidden="true" tabindex="-1"></a>    <span class="co"># --- Allokationstabelle ------------------------------------------------</span></span>
+<span id="cb188-167"><a href="#cb188-167" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;</span><span class="ch">\n</span><span class="st">--- Allokation ---&quot;</span>)</span>
+<span id="cb188-168"><a href="#cb188-168" aria-hidden="true" tabindex="-1"></a>    tabelle <span class="op">=</span> pd.DataFrame({</span>
+<span id="cb188-169"><a href="#cb188-169" aria-hidden="true" tabindex="-1"></a>        <span class="st">&quot;Ticker&quot;</span>: TICKER,</span>
+<span id="cb188-170"><a href="#cb188-170" aria-hidden="true" tabindex="-1"></a>        <span class="st">&quot;vorher&quot;</span>: [<span class="ss">f&quot;</span><span class="sc">{</span>v<span class="op">*</span><span class="dv">100</span><span class="sc">:5.1f}</span><span class="ss"> %&quot;</span> <span class="cf">for</span> v <span class="kw">in</span> w_alt],</span>
+<span id="cb188-171"><a href="#cb188-171" aria-hidden="true" tabindex="-1"></a>        <span class="st">&quot;CVaR-opt.&quot;</span>: [<span class="ss">f&quot;</span><span class="sc">{</span>v<span class="op">*</span><span class="dv">100</span><span class="sc">:5.1f}</span><span class="ss"> %&quot;</span> <span class="cf">for</span> v <span class="kw">in</span> w_cvar],</span>
+<span id="cb188-172"><a href="#cb188-172" aria-hidden="true" tabindex="-1"></a>        <span class="st">&quot;Handel&quot;</span>: [<span class="ss">f&quot;</span><span class="sc">{</span>(w_cvar[i]<span class="op">-</span>w_alt[i])<span class="op">*</span><span class="dv">100</span><span class="sc">:+6.1f}</span><span class="ss"> %&quot;</span> <span class="cf">for</span> i <span class="kw">in</span> <span class="bu">range</span>(N)],</span>
+<span id="cb188-173"><a href="#cb188-173" aria-hidden="true" tabindex="-1"></a>        <span class="st">&quot;Varianz-opt.&quot;</span>: [<span class="ss">f&quot;</span><span class="sc">{</span>v<span class="op">*</span><span class="dv">100</span><span class="sc">:5.1f}</span><span class="ss"> %&quot;</span> <span class="cf">for</span> v <span class="kw">in</span> w_var],</span>
+<span id="cb188-174"><a href="#cb188-174" aria-hidden="true" tabindex="-1"></a>    })</span>
+<span id="cb188-175"><a href="#cb188-175" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(tabelle.to_string(index<span class="op">=</span><span class="va">False</span>))</span>
+<span id="cb188-176"><a href="#cb188-176" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;</span><span class="ch">\n</span><span class="ss">Turnover </span><span class="sc">{</span>turnover<span class="op">*</span><span class="dv">100</span><span class="sc">:.1f}</span><span class="ss"> % -&gt; Transaktionskosten &quot;</span></span>
+<span id="cb188-177"><a href="#cb188-177" aria-hidden="true" tabindex="-1"></a>          <span class="ss">f&quot;</span><span class="sc">{</span>GEBUEHRENSATZ<span class="op">*</span>turnover<span class="op">*</span><span class="dv">100</span><span class="sc">:.3f}</span><span class="ss"> % des Portfoliowerts&quot;</span>)</span>
+<span id="cb188-178"><a href="#cb188-178" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb188-179"><a href="#cb188-179" aria-hidden="true" tabindex="-1"></a>    <span class="co"># --- Laufzeitvergleich vektorisiert vs. Schleife ----------------------</span></span>
+<span id="cb188-180"><a href="#cb188-180" aria-hidden="true" tabindex="-1"></a>    <span class="cf">if</span> S <span class="op">&lt;=</span> <span class="dv">600</span>:                     <span class="co"># bei sehr vielen Szenarien zu langsam</span></span>
+<span id="cb188-181"><a href="#cb188-181" aria-hidden="true" tabindex="-1"></a>        t0 <span class="op">=</span> time.perf_counter()</span>
+<span id="cb188-182"><a href="#cb188-182" aria-hidden="true" tabindex="-1"></a>        optimiere_cvar(R, w_alt, vektorisiert<span class="op">=</span><span class="va">False</span>)</span>
+<span id="cb188-183"><a href="#cb188-183" aria-hidden="true" tabindex="-1"></a>        dauer_schleife <span class="op">=</span> time.perf_counter() <span class="op">-</span> t0</span>
+<span id="cb188-184"><a href="#cb188-184" aria-hidden="true" tabindex="-1"></a>        <span class="bu">print</span>(<span class="ss">f&quot;</span><span class="ch">\n</span><span class="ss">--- Laufzeit: </span><span class="sc">{</span>S<span class="sc">}</span><span class="ss"> Nebenbedingungen aufbauen ---&quot;</span>)</span>
+<span id="cb188-185"><a href="#cb188-185" aria-hidden="true" tabindex="-1"></a>        <span class="bu">print</span>(<span class="ss">f&quot;  vektorisiert (u &gt;= -(R @ w) - gamma): </span><span class="sc">{</span>dauer_vektor<span class="sc">:6.2f}</span><span class="ss"> s&quot;</span>)</span>
+<span id="cb188-186"><a href="#cb188-186" aria-hidden="true" tabindex="-1"></a>        <span class="bu">print</span>(<span class="ss">f&quot;  Schleife ueber Szenarien (V01):        </span><span class="sc">{</span>dauer_schleife<span class="sc">:6.2f}</span><span class="ss"> s &quot;</span></span>
+<span id="cb188-187"><a href="#cb188-187" aria-hidden="true" tabindex="-1"></a>              <span class="ss">f&quot;(</span><span class="sc">{</span>dauer_schleife<span class="op">/</span>dauer_vektor<span class="sc">:.1f}</span><span class="ss">x langsamer)&quot;</span>)</span>
+<span id="cb188-188"><a href="#cb188-188" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;=&quot;</span> <span class="op">*</span> <span class="dv">90</span>)</span></code></pre></div>
 <blockquote>
 <p><strong>💻 Code-Durchgang: Vektorisierung</strong></p>
 <p>Die entscheidende Zeile ist</p>
-<div class="sourceCode" id="cb187"><pre class="sourceCode python"><code class="sourceCode python"><span id="cb187-1"><a href="#cb187-1" aria-hidden="true" tabindex="-1"></a>bedingungen.append(u <span class="op">&gt;=</span> <span class="op">-</span>(R <span class="op">@</span> w) <span class="op">-</span> gamma)     <span class="co"># EINE Matrixbedingung</span></span></code></pre></div>
+<div class="sourceCode" id="cb189"><pre class="sourceCode python"><code class="sourceCode python"><span id="cb189-1"><a href="#cb189-1" aria-hidden="true" tabindex="-1"></a>bedingungen.append(u <span class="op">&gt;=</span> <span class="op">-</span>(R <span class="op">@</span> w) <span class="op">-</span> gamma)     <span class="co"># EINE Matrixbedingung</span></span></code></pre></div>
 <p>statt</p>
-<div class="sourceCode" id="cb188"><pre class="sourceCode python"><code class="sourceCode python"><span id="cb188-1"><a href="#cb188-1" aria-hidden="true" tabindex="-1"></a><span class="cf">for</span> s <span class="kw">in</span> <span class="bu">range</span>(S):</span>
-<span id="cb188-2"><a href="#cb188-2" aria-hidden="true" tabindex="-1"></a>    bedingungen.append(u[s] <span class="op">&gt;=</span> <span class="op">-</span>R[s] <span class="op">@</span> w <span class="op">-</span> gamma)    <span class="co"># S einzelne Bedingungen</span></span></code></pre></div>
+<div class="sourceCode" id="cb190"><pre class="sourceCode python"><code class="sourceCode python"><span id="cb190-1"><a href="#cb190-1" aria-hidden="true" tabindex="-1"></a><span class="cf">for</span> s <span class="kw">in</span> <span class="bu">range</span>(S):</span>
+<span id="cb190-2"><a href="#cb190-2" aria-hidden="true" tabindex="-1"></a>    bedingungen.append(u[s] <span class="op">&gt;=</span> <span class="op">-</span>R[s] <span class="op">@</span> w <span class="op">-</span> gamma)    <span class="co"># S einzelne Bedingungen</span></span></code></pre></div>
 <p>Beide beschreiben <strong>dasselbe Modell</strong>. Der Unterschied liegt im Aufbau: CVXPY muss im zweiten Fall 500 einzelne Ausdrucksbäume erzeugen, prüfen und zusammensetzen. Bei einem Backtest mit 60 Rebalancings (<a href="#kap-handelsmaschine">Kapitel 21</a>) summiert sich das erheblich.</p>
 <p><strong>Die allgemeine Regel:</strong> Wenn Sie in einer Modellierungssprache eine Python-Schleife über Datenzeilen schreiben, prüfen Sie, ob sich dasselbe als Matrixoperation ausdrücken lässt. Der Solver rechnet ohnehin mit Matrizen — der Umweg über einzelne Ausdrücke kostet nur Aufbauzeit.</p>
 </blockquote>
 <blockquote>
 <p><strong>⚠️ Die Standardabweichung ist in CVXPY keine Wurzel</strong></p>
 <p>Im Vergleichsmodell <code>optimiere_varianz()</code> steht die Standardabweichung als</p>
-<div class="sourceCode" id="cb189"><pre class="sourceCode python"><code class="sourceCode python"><span id="cb189-1"><a href="#cb189-1" aria-hidden="true" tabindex="-1"></a>L <span class="op">=</span> np.linalg.cholesky(sigma <span class="op">+</span> <span class="fl">1e-12</span> <span class="op">*</span> np.eye(N))</span>
-<span id="cb189-2"><a href="#cb189-2" aria-hidden="true" tabindex="-1"></a>risiko <span class="op">=</span> cp.norm2(L.T <span class="op">@</span> w)                    <span class="co"># = sqrt(w&#39; sigma w)</span></span></code></pre></div>
+<div class="sourceCode" id="cb191"><pre class="sourceCode python"><code class="sourceCode python"><span id="cb191-1"><a href="#cb191-1" aria-hidden="true" tabindex="-1"></a>L <span class="op">=</span> np.linalg.cholesky(sigma <span class="op">+</span> <span class="fl">1e-12</span> <span class="op">*</span> np.eye(N))</span>
+<span id="cb191-2"><a href="#cb191-2" aria-hidden="true" tabindex="-1"></a>risiko <span class="op">=</span> cp.norm2(L.T <span class="op">@</span> w)                    <span class="co"># = sqrt(w&#39; sigma w)</span></span></code></pre></div>
 <p>und <strong>nicht</strong> als das Naheliegende, <code>cp.sqrt(cp.quad_form(w, sigma))</code>. Der naheliegende Ausdruck ist nicht DCP und wird von CVXPY mit einem <code>DCPError</code> abgelehnt: <code>cp.sqrt</code> ist konkav und verlangt deshalb ein <strong>konkaves</strong> Argument, <code>quad_form</code> ist aber konvex. Die Regel wird verletzt, obwohl die Funktion als ganze mathematisch völlig harmlos ist — <span class="math inline">\sqrt{w^\top \Sigma w}</span> ist konvex, DCP kann es nur nicht <em>sehen</em>.</p>
 <p>Wichtig ist die Fehlerdiagnose dahinter, weil sie leicht in die Irre geht: <code>cp.psd_wrap(sigma)</code> sieht nach der Lösung aus und ist keine. Es unterdrückt die <strong>numerische</strong> Beanstandung, dass <span class="math inline">\Sigma</span> nicht als positiv semidefinit erkannt wird — gegen die <strong>strukturelle</strong> Regelverletzung im Aufbau hilft es nicht.</p>
 <p>Der Ausweg ist immer derselbe: Zerlegen Sie <span class="math inline">\Sigma = LL^\top</span> (Cholesky). Dann ist <span class="math inline">w^\top \Sigma w = \lVert L^\top w\rVert_2^2</span>, und die Standardabweichung wird zur 2-Norm eines <strong>affinen</strong> Ausdrucks — konvex, regelkonform und für den Solver sogar die bessere Formulierung, weil sie direkt ein Kegelproblem ist. Der winzige Diagonalzuschlag <span class="math inline">10^{-12}</span> fängt den Fall ab, dass <span class="math inline">\Sigma</span> numerisch nur halbdefinit ist (mehr Titel als Handelstage, duplizierte Spalten). Die vollständige Fehlertabelle steht in <a href="#anhang-fehlerdiagnose">Anhang C</a>.</p>
@@ -23616,7 +24592,7 @@ CVaR: Portfolio  101.33  vs. Summe  159.24  -&gt; subadditiv (kohaerent)
 <hr />
 <h2 id="sec:cvar-denkfehler">20.8 Finde den Denkfehler</h2>
 <blockquote>
-<p><strong>🐛 Finde den Denkfehler 13.1: Das Risikobudget, das durch Diversifikation stieg</strong></p>
+<p><strong>🐛 Finde den Denkfehler: Das Risikobudget, das durch Diversifikation stieg</strong></p>
 <p>Eine Bank vergibt Risikobudgets je Abteilung. Zwei Kreditabteilungen halten je eine Unternehmensanleihe über 100 € Nominal mit <strong>4 % Ausfallwahrscheinlichkeit</strong> (bei Ausfall Totalverlust, sonst 2 € Kupon). Der Risikocontroller misst für jede einzeln:</p>
 <p><span class="math display">\text{VaR}_{95}(\text{A}) = -2{,}00\,€, \qquad \text{VaR}_{95}(\text{B}) = -2{,}00\,€</span></p>
 <p>Ein <em>negativer</em> Verlust, also ein Gewinn. Auf dem 95-%-Niveau erscheint jede Anleihe risikolos, beide Abteilungen bekommen grünes Licht. Der Controller notiert als Gesamtrisiko die Summe: <span class="math inline">-4{,}00\,€</span>.</p>
@@ -23642,7 +24618,7 @@ CVaR: Portfolio  101.33  vs. Summe  159.24  -&gt; subadditiv (kohaerent)
 <hr />
 <h2 id="sec:cvar-quiz">20.9 Micro-Quiz</h2>
 <blockquote>
-<p><strong>❓ Micro-Quiz 13: Drei Fragen zum Selbstcheck</strong></p>
+<p><strong>❓ Micro-Quiz 20: Drei Fragen zum Selbstcheck</strong></p>
 <p>Genau eine Antwort ist jeweils richtig. Auflösung in <a href="#quiz-loesung-cvar">Anhang A</a>.</p>
 <p><strong>1. Zwei Anlagen haben denselben VaR(95) von 3 %. Was wissen Sie über ihre Extremverluste?</strong> (a) Sie sind gleich hoch — der VaR misst genau das. (b) <strong>Nichts.</strong> Der VaR ist ein Quantil: Er markiert die Schwelle und sagt nichts darüber, was dahinter liegt. Die eine kann dort −3 %, die andere −40 % haben. (c) Die Anlage mit der höheren Schwankung hat auch die höheren Extremverluste.</p>
 <p><strong>2. Warum lässt sich der CVaR als lineares Programm minimieren, der VaR aber nicht?</strong> (a) Der VaR ist nicht differenzierbar. (b) Der CVaR lässt sich nach Rockafellar/Uryasev über eine Hilfsvariable und Schlupfterme als konvexes — sogar lineares — Problem schreiben. Die VaR-Minimierung ist dagegen nicht konvex und hat viele lokale Optima. (c) Der CVaR ist immer größer als der VaR.</p>
@@ -23694,28 +24670,28 @@ CVaR: Portfolio  101.33  vs. Summe  159.24  -&gt; subadditiv (kohaerent)
 <blockquote>
 <p><strong>🚀 In 5 Minuten gelöst: Dieselben Tage, ein anderes Schicksal</strong></p>
 <p>Zwei Strategien über zehn Jahre. Sie bestehen aus <strong>exakt denselben Tagesrenditen</strong> — nur in anderer Reihenfolge. Bei der einen sind die 250 schlechtesten Tage über den ganzen Zeitraum verstreut, bei der anderen liegen sie am Stück.</p>
-<div class="sourceCode" id="cb190"><pre class="sourceCode python"><code class="sourceCode python"><span id="cb190-1"><a href="#cb190-1" aria-hidden="true" tabindex="-1"></a><span class="im">import</span> numpy <span class="im">as</span> np</span>
-<span id="cb190-2"><a href="#cb190-2" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb190-3"><a href="#cb190-3" aria-hidden="true" tabindex="-1"></a>rng <span class="op">=</span> np.random.default_rng(<span class="dv">1</span>)</span>
-<span id="cb190-4"><a href="#cb190-4" aria-hidden="true" tabindex="-1"></a>tage <span class="op">=</span> rng.normal(<span class="fl">0.0005</span>, <span class="fl">0.010</span>, <span class="dv">2520</span>)          <span class="co"># zehn Jahre Tagesrenditen</span></span>
-<span id="cb190-5"><a href="#cb190-5" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb190-6"><a href="#cb190-6" aria-hidden="true" tabindex="-1"></a>gestreut <span class="op">=</span> tage.copy()</span>
-<span id="cb190-7"><a href="#cb190-7" aria-hidden="true" tabindex="-1"></a>rng.shuffle(gestreut)</span>
-<span id="cb190-8"><a href="#cb190-8" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb190-9"><a href="#cb190-9" aria-hidden="true" tabindex="-1"></a>sortiert <span class="op">=</span> np.sort(tage)                         <span class="co"># dieselben Tage, neu geordnet:</span></span>
-<span id="cb190-10"><a href="#cb190-10" aria-hidden="true" tabindex="-1"></a>schlecht, rest <span class="op">=</span> sortiert[:<span class="dv">250</span>], sortiert[<span class="dv">250</span>:]  <span class="co"># die 250 schlechtesten ...</span></span>
-<span id="cb190-11"><a href="#cb190-11" aria-hidden="true" tabindex="-1"></a>rng.shuffle(rest)</span>
-<span id="cb190-12"><a href="#cb190-12" aria-hidden="true" tabindex="-1"></a>geballt <span class="op">=</span> np.concatenate([rest[:<span class="dv">1000</span>], schlecht, rest[<span class="dv">1000</span>:]])   <span class="co"># ... am Stueck</span></span>
-<span id="cb190-13"><a href="#cb190-13" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb190-14"><a href="#cb190-14" aria-hidden="true" tabindex="-1"></a><span class="kw">def</span> kennzahlen(r):</span>
-<span id="cb190-15"><a href="#cb190-15" aria-hidden="true" tabindex="-1"></a>    verlauf <span class="op">=</span> np.cumprod(<span class="dv">1</span> <span class="op">+</span> r)</span>
-<span id="cb190-16"><a href="#cb190-16" aria-hidden="true" tabindex="-1"></a>    rueckschlag <span class="op">=</span> (verlauf <span class="op">/</span> np.maximum.accumulate(verlauf) <span class="op">-</span> <span class="dv">1</span>).<span class="bu">min</span>()</span>
-<span id="cb190-17"><a href="#cb190-17" aria-hidden="true" tabindex="-1"></a>    <span class="cf">return</span> verlauf[<span class="op">-</span><span class="dv">1</span>]<span class="op">**</span>(<span class="dv">252</span><span class="op">/</span><span class="bu">len</span>(r)) <span class="op">-</span> <span class="dv">1</span>, r.mean()<span class="op">/</span>r.std()<span class="op">*</span>np.sqrt(<span class="dv">252</span>), rueckschlag</span>
-<span id="cb190-18"><a href="#cb190-18" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb190-19"><a href="#cb190-19" aria-hidden="true" tabindex="-1"></a><span class="cf">for</span> name, r <span class="kw">in</span> [(<span class="st">&quot;gestreut&quot;</span>, gestreut), (<span class="st">&quot;geballt&quot;</span>, geballt)]:</span>
-<span id="cb190-20"><a href="#cb190-20" aria-hidden="true" tabindex="-1"></a>    jahr, sharpe, rueckschlag <span class="op">=</span> kennzahlen(r)</span>
-<span id="cb190-21"><a href="#cb190-21" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;</span><span class="sc">{</span>name<span class="sc">:9}</span><span class="ss"> Jahresrendite </span><span class="sc">{</span>jahr<span class="op">*</span><span class="dv">100</span><span class="sc">:5.2f}</span><span class="ss"> %  Sharpe </span><span class="sc">{</span>sharpe<span class="sc">:4.2f}</span><span class="ss">  &quot;</span></span>
-<span id="cb190-22"><a href="#cb190-22" aria-hidden="true" tabindex="-1"></a>          <span class="ss">f&quot;max. Rueckschlag </span><span class="sc">{</span>rueckschlag<span class="op">*</span><span class="dv">100</span><span class="sc">:6.1f}</span><span class="ss"> %&quot;</span>)</span></code></pre></div>
+<div class="sourceCode" id="cb192"><pre class="sourceCode python"><code class="sourceCode python"><span id="cb192-1"><a href="#cb192-1" aria-hidden="true" tabindex="-1"></a><span class="im">import</span> numpy <span class="im">as</span> np</span>
+<span id="cb192-2"><a href="#cb192-2" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb192-3"><a href="#cb192-3" aria-hidden="true" tabindex="-1"></a>rng <span class="op">=</span> np.random.default_rng(<span class="dv">1</span>)</span>
+<span id="cb192-4"><a href="#cb192-4" aria-hidden="true" tabindex="-1"></a>tage <span class="op">=</span> rng.normal(<span class="fl">0.0005</span>, <span class="fl">0.010</span>, <span class="dv">2520</span>)          <span class="co"># zehn Jahre Tagesrenditen</span></span>
+<span id="cb192-5"><a href="#cb192-5" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb192-6"><a href="#cb192-6" aria-hidden="true" tabindex="-1"></a>gestreut <span class="op">=</span> tage.copy()</span>
+<span id="cb192-7"><a href="#cb192-7" aria-hidden="true" tabindex="-1"></a>rng.shuffle(gestreut)</span>
+<span id="cb192-8"><a href="#cb192-8" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb192-9"><a href="#cb192-9" aria-hidden="true" tabindex="-1"></a>sortiert <span class="op">=</span> np.sort(tage)                         <span class="co"># dieselben Tage, neu geordnet:</span></span>
+<span id="cb192-10"><a href="#cb192-10" aria-hidden="true" tabindex="-1"></a>schlecht, rest <span class="op">=</span> sortiert[:<span class="dv">250</span>], sortiert[<span class="dv">250</span>:]  <span class="co"># die 250 schlechtesten ...</span></span>
+<span id="cb192-11"><a href="#cb192-11" aria-hidden="true" tabindex="-1"></a>rng.shuffle(rest)</span>
+<span id="cb192-12"><a href="#cb192-12" aria-hidden="true" tabindex="-1"></a>geballt <span class="op">=</span> np.concatenate([rest[:<span class="dv">1000</span>], schlecht, rest[<span class="dv">1000</span>:]])   <span class="co"># ... am Stueck</span></span>
+<span id="cb192-13"><a href="#cb192-13" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb192-14"><a href="#cb192-14" aria-hidden="true" tabindex="-1"></a><span class="kw">def</span> kennzahlen(r):</span>
+<span id="cb192-15"><a href="#cb192-15" aria-hidden="true" tabindex="-1"></a>    verlauf <span class="op">=</span> np.cumprod(<span class="dv">1</span> <span class="op">+</span> r)</span>
+<span id="cb192-16"><a href="#cb192-16" aria-hidden="true" tabindex="-1"></a>    rueckschlag <span class="op">=</span> (verlauf <span class="op">/</span> np.maximum.accumulate(verlauf) <span class="op">-</span> <span class="dv">1</span>).<span class="bu">min</span>()</span>
+<span id="cb192-17"><a href="#cb192-17" aria-hidden="true" tabindex="-1"></a>    <span class="cf">return</span> verlauf[<span class="op">-</span><span class="dv">1</span>]<span class="op">**</span>(<span class="dv">252</span><span class="op">/</span><span class="bu">len</span>(r)) <span class="op">-</span> <span class="dv">1</span>, r.mean()<span class="op">/</span>r.std()<span class="op">*</span>np.sqrt(<span class="dv">252</span>), rueckschlag</span>
+<span id="cb192-18"><a href="#cb192-18" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb192-19"><a href="#cb192-19" aria-hidden="true" tabindex="-1"></a><span class="cf">for</span> name, r <span class="kw">in</span> [(<span class="st">&quot;gestreut&quot;</span>, gestreut), (<span class="st">&quot;geballt&quot;</span>, geballt)]:</span>
+<span id="cb192-20"><a href="#cb192-20" aria-hidden="true" tabindex="-1"></a>    jahr, sharpe, rueckschlag <span class="op">=</span> kennzahlen(r)</span>
+<span id="cb192-21"><a href="#cb192-21" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;</span><span class="sc">{</span>name<span class="sc">:9}</span><span class="ss"> Jahresrendite </span><span class="sc">{</span>jahr<span class="op">*</span><span class="dv">100</span><span class="sc">:5.2f}</span><span class="ss"> %  Sharpe </span><span class="sc">{</span>sharpe<span class="sc">:4.2f}</span><span class="ss">  &quot;</span></span>
+<span id="cb192-22"><a href="#cb192-22" aria-hidden="true" tabindex="-1"></a>          <span class="ss">f&quot;max. Rueckschlag </span><span class="sc">{</span>rueckschlag<span class="op">*</span><span class="dv">100</span><span class="sc">:6.1f}</span><span class="ss"> %&quot;</span>)</span></code></pre></div>
 <p><strong>Ausgabe:</strong></p>
 <pre><code>gestreut  Jahresrendite  8.88 %  Sharpe 0.61  max. Rueckschlag  -19.0 %
 geballt   Jahresrendite  8.88 %  Sharpe 0.61  max. Rueckschlag  -98.7 %</code></pre>
@@ -23806,9 +24782,9 @@ geballt   Jahresrendite  8.88 %  Sharpe 0.61  max. Rueckschlag  -98.7 %</code></
 <h2 id="sec:handelsmaschine-rebalancing-termine-richtig-bestimmen">21.4 Rebalancing-Termine richtig bestimmen</h2>
 <blockquote>
 <p><strong>⚠️ Ein stiller, häufiger Fehler</strong></p>
-<div class="sourceCode" id="cb192"><pre class="sourceCode python"><code class="sourceCode python"><span id="cb192-1"><a href="#cb192-1" aria-hidden="true" tabindex="-1"></a><span class="va">self</span>.rebalance_dates <span class="op">=</span> <span class="va">self</span>.prices.resample(<span class="st">&quot;MS&quot;</span>).first().index</span>
-<span id="cb192-2"><a href="#cb192-2" aria-hidden="true" tabindex="-1"></a>...</span>
-<span id="cb192-3"><a href="#cb192-3" aria-hidden="true" tabindex="-1"></a><span class="cf">if</span> current_date <span class="kw">in</span> <span class="va">self</span>.rebalance_dates:</span></code></pre></div>
+<div class="sourceCode" id="cb194"><pre class="sourceCode python"><code class="sourceCode python"><span id="cb194-1"><a href="#cb194-1" aria-hidden="true" tabindex="-1"></a><span class="va">self</span>.rebalance_dates <span class="op">=</span> <span class="va">self</span>.prices.resample(<span class="st">&quot;MS&quot;</span>).first().index</span>
+<span id="cb194-2"><a href="#cb194-2" aria-hidden="true" tabindex="-1"></a>...</span>
+<span id="cb194-3"><a href="#cb194-3" aria-hidden="true" tabindex="-1"></a><span class="cf">if</span> current_date <span class="kw">in</span> <span class="va">self</span>.rebalance_dates:</span></code></pre></div>
 <p><code>resample("MS")</code> erzeugt <strong>Kalender-Monatsanfänge</strong> — den 1. Januar, den 1. Februar und so fort. Der Kursindex enthält aber nur <strong>Handelstage</strong>. Fällt der Monatserste auf ein Wochenende oder einen Feiertag, ist er kein Element des Index, die Bedingung wird nie wahr, und das Rebalancing <strong>entfällt kommentarlos</strong>.</p>
 <p>Messung auf einem reinen Wochentagskalender über fünf Jahre:</p>
 <table>
@@ -23835,9 +24811,9 @@ geballt   Jahresrendite  8.88 %  Sharpe 0.61  max. Rueckschlag  -98.7 %</code></
 </table>
 <p>Mit echten Börsenfeiertagen fallen weitere Termine aus. Der Backtest testete also eine <strong>andere Strategie als die beschriebene</strong> — und lieferte trotzdem plausibel aussehende Kennzahlen.</p>
 <p><strong>Die Korrektur:</strong></p>
-<div class="sourceCode" id="cb193"><pre class="sourceCode python"><code class="sourceCode python"><span id="cb193-1"><a href="#cb193-1" aria-hidden="true" tabindex="-1"></a>monat <span class="op">=</span> <span class="va">self</span>.kurse.index.to_period(<span class="st">&quot;M&quot;</span>)</span>
-<span id="cb193-2"><a href="#cb193-2" aria-hidden="true" tabindex="-1"></a><span class="va">self</span>.rebalancing_termine <span class="op">=</span> <span class="va">self</span>.kurse.index[<span class="op">~</span>monat.duplicated()]   <span class="co"># erster HANDELStag</span></span>
-<span id="cb193-3"><a href="#cb193-3" aria-hidden="true" tabindex="-1"></a><span class="cf">assert</span> <span class="va">self</span>.rebalancing_termine.isin(<span class="va">self</span>.kurse.index).<span class="bu">all</span>()</span></code></pre></div>
+<div class="sourceCode" id="cb195"><pre class="sourceCode python"><code class="sourceCode python"><span id="cb195-1"><a href="#cb195-1" aria-hidden="true" tabindex="-1"></a>monat <span class="op">=</span> <span class="va">self</span>.kurse.index.to_period(<span class="st">&quot;M&quot;</span>)</span>
+<span id="cb195-2"><a href="#cb195-2" aria-hidden="true" tabindex="-1"></a><span class="va">self</span>.rebalancing_termine <span class="op">=</span> <span class="va">self</span>.kurse.index[<span class="op">~</span>monat.duplicated()]   <span class="co"># erster HANDELStag</span></span>
+<span id="cb195-3"><a href="#cb195-3" aria-hidden="true" tabindex="-1"></a><span class="cf">assert</span> <span class="va">self</span>.rebalancing_termine.isin(<span class="va">self</span>.kurse.index).<span class="bu">all</span>()</span></code></pre></div>
 <p><code>~monat.duplicated()</code> markiert den jeweils <strong>ersten vorhandenen</strong> Tag jedes Monats — also garantiert einen Handelstag.</p>
 </blockquote>
 <blockquote>
@@ -23845,325 +24821,325 @@ geballt   Jahresrendite  8.88 %  Sharpe 0.61  max. Rueckschlag  -98.7 %</code></
 </blockquote>
 <hr />
 <h2 id="sec:handelsmaschine-die-engine">21.5 Die Engine</h2>
-<div class="sourceCode" id="cb194"><pre class="sourceCode python"><code class="sourceCode python"><span id="cb194-1"><a href="#cb194-1" aria-hidden="true" tabindex="-1"></a><span class="co">#!/usr/bin/env python3</span></span>
-<span id="cb194-2"><a href="#cb194-2" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb194-3"><a href="#cb194-3" aria-hidden="true" tabindex="-1"></a><span class="co"># QuantitativeTradingEngine.py</span></span>
-<span id="cb194-4"><a href="#cb194-4" aria-hidden="true" tabindex="-1"></a><span class="co">&quot;&quot;&quot;</span></span>
-<span id="cb194-5"><a href="#cb194-5" aria-hidden="true" tabindex="-1"></a><span class="co">Kapitel Handelsmaschine: Vollstaendige quantitative Handelsmaschine mit</span></span>
-<span id="cb194-6"><a href="#cb194-6" aria-hidden="true" tabindex="-1"></a><span class="co">Walk-Forward-Backtest und OR-Optimierungsschicht.</span></span>
-<span id="cb194-7"><a href="#cb194-7" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb194-8"><a href="#cb194-8" aria-hidden="true" tabindex="-1"></a><span class="co">Eigenschaften:</span></span>
-<span id="cb194-9"><a href="#cb194-9" aria-hidden="true" tabindex="-1"></a><span class="co">  * Rebalancing-Termine sind garantiert Handelstage; die Zahl der</span></span>
-<span id="cb194-10"><a href="#cb194-10" aria-hidden="true" tabindex="-1"></a><span class="co">    tatsaechlich ausgefuehrten Umschichtungen wird ausgewiesen</span></span>
-<span id="cb194-11"><a href="#cb194-11" aria-hidden="true" tabindex="-1"></a><span class="co">  * Spaltenreihenfolge erzwungen</span></span>
-<span id="cb194-12"><a href="#cb194-12" aria-hidden="true" tabindex="-1"></a><span class="co">  * Einheiten konsistent (taegliche Groessen im Modell)</span></span>
-<span id="cb194-13"><a href="#cb194-13" aria-hidden="true" tabindex="-1"></a><span class="co">  * Szenario-Nebenbedingungen vektorisiert</span></span>
-<span id="cb194-14"><a href="#cb194-14" aria-hidden="true" tabindex="-1"></a><span class="co">  * Lookahead-Selbsttest eingebaut</span></span>
-<span id="cb194-15"><a href="#cb194-15" aria-hidden="true" tabindex="-1"></a><span class="co">  * Zusaetzliche Kennzahlen: Calmar, Trefferquote, Turnover, Kostenanteil</span></span>
-<span id="cb194-16"><a href="#cb194-16" aria-hidden="true" tabindex="-1"></a><span class="co">&quot;&quot;&quot;</span></span>
-<span id="cb194-17"><a href="#cb194-17" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb194-18"><a href="#cb194-18" aria-hidden="true" tabindex="-1"></a><span class="im">import</span> os</span>
-<span id="cb194-19"><a href="#cb194-19" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb194-20"><a href="#cb194-20" aria-hidden="true" tabindex="-1"></a><span class="im">import</span> cvxpy <span class="im">as</span> cp</span>
-<span id="cb194-21"><a href="#cb194-21" aria-hidden="true" tabindex="-1"></a><span class="im">import</span> numpy <span class="im">as</span> np</span>
-<span id="cb194-22"><a href="#cb194-22" aria-hidden="true" tabindex="-1"></a><span class="im">import</span> pandas <span class="im">as</span> pd</span>
-<span id="cb194-23"><a href="#cb194-23" aria-hidden="true" tabindex="-1"></a><span class="im">import</span> yfinance <span class="im">as</span> yf</span>
-<span id="cb194-24"><a href="#cb194-24" aria-hidden="true" tabindex="-1"></a><span class="im">from</span> sklearn.covariance <span class="im">import</span> LedoitWolf</span>
-<span id="cb194-25"><a href="#cb194-25" aria-hidden="true" tabindex="-1"></a><span class="im">import</span> matplotlib</span>
-<span id="cb194-26"><a href="#cb194-26" aria-hidden="true" tabindex="-1"></a>matplotlib.use(<span class="st">&quot;Agg&quot;</span>)</span>
-<span id="cb194-27"><a href="#cb194-27" aria-hidden="true" tabindex="-1"></a><span class="im">import</span> matplotlib.pyplot <span class="im">as</span> plt</span>
-<span id="cb194-28"><a href="#cb194-28" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb194-29"><a href="#cb194-29" aria-hidden="true" tabindex="-1"></a>OUTPUT_DIR <span class="op">=</span> os.path.join(os.path.dirname(os.path.abspath(<span class="va">__file__</span>)), <span class="st">&quot;output&quot;</span>)</span>
-<span id="cb194-30"><a href="#cb194-30" aria-hidden="true" tabindex="-1"></a>os.makedirs(OUTPUT_DIR, exist_ok<span class="op">=</span><span class="va">True</span>)</span>
-<span id="cb194-31"><a href="#cb194-31" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb194-32"><a href="#cb194-32" aria-hidden="true" tabindex="-1"></a>HANDELSTAGE <span class="op">=</span> <span class="dv">252</span></span>
-<span id="cb194-33"><a href="#cb194-33" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb194-34"><a href="#cb194-34" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb194-35"><a href="#cb194-35" aria-hidden="true" tabindex="-1"></a><span class="kw">class</span> QuantitativeHandelsmaschine:</span>
-<span id="cb194-36"><a href="#cb194-36" aria-hidden="true" tabindex="-1"></a>    <span class="co">&quot;&quot;&quot;Walk-Forward-Backtest mit CVaR-Optimierung und Transaktionskosten.&quot;&quot;&quot;</span></span>
-<span id="cb194-37"><a href="#cb194-37" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb194-38"><a href="#cb194-38" aria-hidden="true" tabindex="-1"></a>    <span class="kw">def</span> <span class="fu">__init__</span>(<span class="va">self</span>, universum, benchmark<span class="op">=</span><span class="st">&quot;SPY&quot;</span>, jahre<span class="op">=</span><span class="dv">5</span>,</span>
-<span id="cb194-39"><a href="#cb194-39" aria-hidden="true" tabindex="-1"></a>                 startkapital<span class="op">=</span><span class="fl">100_000.0</span>, gebuehrensatz<span class="op">=</span><span class="fl">0.0015</span>,</span>
-<span id="cb194-40"><a href="#cb194-40" aria-hidden="true" tabindex="-1"></a>                 max_gewicht<span class="op">=</span><span class="fl">0.20</span>, alpha<span class="op">=</span><span class="fl">0.95</span>, risikoaversion<span class="op">=</span><span class="fl">1.2</span>,</span>
-<span id="cb194-41"><a href="#cb194-41" aria-hidden="true" tabindex="-1"></a>                 warmup<span class="op">=</span>HANDELSTAGE):</span>
-<span id="cb194-42"><a href="#cb194-42" aria-hidden="true" tabindex="-1"></a>        <span class="va">self</span>.universum <span class="op">=</span> <span class="bu">list</span>(universum)</span>
-<span id="cb194-43"><a href="#cb194-43" aria-hidden="true" tabindex="-1"></a>        <span class="va">self</span>.benchmark <span class="op">=</span> benchmark</span>
-<span id="cb194-44"><a href="#cb194-44" aria-hidden="true" tabindex="-1"></a>        <span class="va">self</span>.jahre <span class="op">=</span> jahre</span>
-<span id="cb194-45"><a href="#cb194-45" aria-hidden="true" tabindex="-1"></a>        <span class="va">self</span>.startkapital <span class="op">=</span> startkapital</span>
-<span id="cb194-46"><a href="#cb194-46" aria-hidden="true" tabindex="-1"></a>        <span class="va">self</span>.gebuehrensatz <span class="op">=</span> gebuehrensatz</span>
-<span id="cb194-47"><a href="#cb194-47" aria-hidden="true" tabindex="-1"></a>        <span class="va">self</span>.max_gewicht <span class="op">=</span> max_gewicht</span>
-<span id="cb194-48"><a href="#cb194-48" aria-hidden="true" tabindex="-1"></a>        <span class="va">self</span>.alpha <span class="op">=</span> alpha</span>
-<span id="cb194-49"><a href="#cb194-49" aria-hidden="true" tabindex="-1"></a>        <span class="va">self</span>.risikoaversion <span class="op">=</span> risikoaversion</span>
-<span id="cb194-50"><a href="#cb194-50" aria-hidden="true" tabindex="-1"></a>        <span class="va">self</span>.warmup <span class="op">=</span> warmup</span>
-<span id="cb194-51"><a href="#cb194-51" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb194-52"><a href="#cb194-52" aria-hidden="true" tabindex="-1"></a>        <span class="va">self</span>.kurse <span class="op">=</span> <span class="va">None</span></span>
-<span id="cb194-53"><a href="#cb194-53" aria-hidden="true" tabindex="-1"></a>        <span class="va">self</span>.benchmark_kurse <span class="op">=</span> <span class="va">None</span></span>
-<span id="cb194-54"><a href="#cb194-54" aria-hidden="true" tabindex="-1"></a>        <span class="va">self</span>.renditen <span class="op">=</span> <span class="va">None</span></span>
-<span id="cb194-55"><a href="#cb194-55" aria-hidden="true" tabindex="-1"></a>        <span class="va">self</span>.rebalancing_termine <span class="op">=</span> <span class="va">None</span></span>
-<span id="cb194-56"><a href="#cb194-56" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb194-57"><a href="#cb194-57" aria-hidden="true" tabindex="-1"></a>    <span class="co"># -- 1. Datenpipeline ------------------------------------------------</span></span>
-<span id="cb194-58"><a href="#cb194-58" aria-hidden="true" tabindex="-1"></a>    <span class="kw">def</span> lade_daten(<span class="va">self</span>):</span>
-<span id="cb194-59"><a href="#cb194-59" aria-hidden="true" tabindex="-1"></a>        ende <span class="op">=</span> pd.Timestamp.today().normalize()</span>
-<span id="cb194-60"><a href="#cb194-60" aria-hidden="true" tabindex="-1"></a>        start <span class="op">=</span> ende <span class="op">-</span> pd.DateOffset(years<span class="op">=</span><span class="va">self</span>.jahre)</span>
-<span id="cb194-61"><a href="#cb194-61" aria-hidden="true" tabindex="-1"></a>        alle <span class="op">=</span> <span class="va">self</span>.universum <span class="op">+</span> [<span class="va">self</span>.benchmark]</span>
-<span id="cb194-62"><a href="#cb194-62" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb194-63"><a href="#cb194-63" aria-hidden="true" tabindex="-1"></a>        <span class="bu">print</span>(<span class="ss">f&quot;Lade </span><span class="sc">{</span><span class="bu">len</span>(<span class="va">self</span>.universum)<span class="sc">}</span><span class="ss"> Titel + Benchmark (</span><span class="sc">{</span><span class="va">self</span><span class="sc">.</span>benchmark<span class="sc">}</span><span class="ss">) &quot;</span></span>
-<span id="cb194-64"><a href="#cb194-64" aria-hidden="true" tabindex="-1"></a>              <span class="ss">f&quot;ueber </span><span class="sc">{</span><span class="va">self</span><span class="sc">.</span>jahre<span class="sc">}</span><span class="ss"> Jahre ...&quot;</span>)</span>
-<span id="cb194-65"><a href="#cb194-65" aria-hidden="true" tabindex="-1"></a>        roh <span class="op">=</span> yf.download(alle, start<span class="op">=</span>start, end<span class="op">=</span>ende, auto_adjust<span class="op">=</span><span class="va">True</span>, progress<span class="op">=</span><span class="va">False</span>)</span>
-<span id="cb194-66"><a href="#cb194-66" aria-hidden="true" tabindex="-1"></a>        <span class="cf">if</span> roh.empty:</span>
-<span id="cb194-67"><a href="#cb194-67" aria-hidden="true" tabindex="-1"></a>            <span class="cf">raise</span> <span class="pp">SystemExit</span>(<span class="st">&quot;Download fehlgeschlagen (Netz/Ticker/Rate-Limit pruefen).&quot;</span>)</span>
-<span id="cb194-68"><a href="#cb194-68" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb194-69"><a href="#cb194-69" aria-hidden="true" tabindex="-1"></a>        <span class="cf">if</span> <span class="bu">isinstance</span>(roh.columns, pd.MultiIndex):</span>
-<span id="cb194-70"><a href="#cb194-70" aria-hidden="true" tabindex="-1"></a>            daten <span class="op">=</span> roh[<span class="st">&quot;Close&quot;</span>][alle].dropna()      <span class="co"># erzwingt eigene Spaltenreihenfolge</span></span>
-<span id="cb194-71"><a href="#cb194-71" aria-hidden="true" tabindex="-1"></a>        <span class="cf">else</span>:</span>
-<span id="cb194-72"><a href="#cb194-72" aria-hidden="true" tabindex="-1"></a>            daten <span class="op">=</span> roh[[<span class="st">&quot;Close&quot;</span>]].dropna()</span>
-<span id="cb194-73"><a href="#cb194-73" aria-hidden="true" tabindex="-1"></a>            daten.columns <span class="op">=</span> alle</span>
-<span id="cb194-74"><a href="#cb194-74" aria-hidden="true" tabindex="-1"></a>        <span class="cf">assert</span> <span class="bu">list</span>(daten.columns) <span class="op">==</span> alle, <span class="st">&quot;Spaltenreihenfolge weicht ab!&quot;</span></span>
-<span id="cb194-75"><a href="#cb194-75" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb194-76"><a href="#cb194-76" aria-hidden="true" tabindex="-1"></a>        <span class="va">self</span>.kurse <span class="op">=</span> daten[<span class="va">self</span>.universum]</span>
-<span id="cb194-77"><a href="#cb194-77" aria-hidden="true" tabindex="-1"></a>        <span class="va">self</span>.benchmark_kurse <span class="op">=</span> daten[<span class="va">self</span>.benchmark]</span>
-<span id="cb194-78"><a href="#cb194-78" aria-hidden="true" tabindex="-1"></a>        <span class="va">self</span>.renditen <span class="op">=</span> <span class="va">self</span>.kurse.pct_change().dropna()</span>
-<span id="cb194-79"><a href="#cb194-79" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb194-80"><a href="#cb194-80" aria-hidden="true" tabindex="-1"></a>        <span class="co"># --- erster HANDELStag je Monat, nicht Kalendermonatsanfang -----</span></span>
-<span id="cb194-81"><a href="#cb194-81" aria-hidden="true" tabindex="-1"></a>        monat <span class="op">=</span> <span class="va">self</span>.kurse.index.to_period(<span class="st">&quot;M&quot;</span>)</span>
-<span id="cb194-82"><a href="#cb194-82" aria-hidden="true" tabindex="-1"></a>        <span class="va">self</span>.rebalancing_termine <span class="op">=</span> <span class="va">self</span>.kurse.index[<span class="op">~</span>monat.duplicated()]</span>
-<span id="cb194-83"><a href="#cb194-83" aria-hidden="true" tabindex="-1"></a>        <span class="cf">assert</span> <span class="va">self</span>.rebalancing_termine.isin(<span class="va">self</span>.kurse.index).<span class="bu">all</span>(), <span class="op">\</span></span>
-<span id="cb194-84"><a href="#cb194-84" aria-hidden="true" tabindex="-1"></a>            <span class="st">&quot;Rebalancing-Termine sind keine Handelstage!&quot;</span></span>
-<span id="cb194-85"><a href="#cb194-85" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb194-86"><a href="#cb194-86" aria-hidden="true" tabindex="-1"></a>        <span class="bu">print</span>(<span class="ss">f&quot;  </span><span class="sc">{</span><span class="bu">len</span>(<span class="va">self</span>.kurse)<span class="sc">}</span><span class="ss"> Handelstage, &quot;</span></span>
-<span id="cb194-87"><a href="#cb194-87" aria-hidden="true" tabindex="-1"></a>              <span class="ss">f&quot;</span><span class="sc">{</span><span class="bu">len</span>(<span class="va">self</span>.rebalancing_termine)<span class="sc">}</span><span class="ss"> Rebalancing-Termine &quot;</span></span>
-<span id="cb194-88"><a href="#cb194-88" aria-hidden="true" tabindex="-1"></a>              <span class="ss">f&quot;(alle sind Handelstage)&quot;</span>)</span>
-<span id="cb194-89"><a href="#cb194-89" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb194-90"><a href="#cb194-90" aria-hidden="true" tabindex="-1"></a>    <span class="co"># -- 2. Signal --------------------------------------------------------</span></span>
-<span id="cb194-91"><a href="#cb194-91" aria-hidden="true" tabindex="-1"></a>    <span class="kw">def</span> alpha_signal(<span class="va">self</span>, stichtag, rueckblick<span class="op">=</span>HANDELSTAGE):</span>
-<span id="cb194-92"><a href="#cb194-92" aria-hidden="true" tabindex="-1"></a>        <span class="co">&quot;&quot;&quot;</span></span>
-<span id="cb194-93"><a href="#cb194-93" aria-hidden="true" tabindex="-1"></a><span class="co">        12-1-Momentum: Kursentwicklung der letzten 12 Monate unter Auslassung</span></span>
-<span id="cb194-94"><a href="#cb194-94" aria-hidden="true" tabindex="-1"></a><span class="co">        des letzten Monats (kurzfristige Umkehr herausrechnen).</span></span>
-<span id="cb194-95"><a href="#cb194-95" aria-hidden="true" tabindex="-1"></a><span class="co">        Rueckgabe: TAEGLICHE Renditeerwartung.</span></span>
-<span id="cb194-96"><a href="#cb194-96" aria-hidden="true" tabindex="-1"></a><span class="co">        &quot;&quot;&quot;</span></span>
-<span id="cb194-97"><a href="#cb194-97" aria-hidden="true" tabindex="-1"></a>        historie <span class="op">=</span> <span class="va">self</span>.kurse.loc[:stichtag]</span>
-<span id="cb194-98"><a href="#cb194-98" aria-hidden="true" tabindex="-1"></a>        <span class="cf">if</span> <span class="bu">len</span>(historie) <span class="op">&lt;</span> rueckblick:</span>
-<span id="cb194-99"><a href="#cb194-99" aria-hidden="true" tabindex="-1"></a>            <span class="cf">return</span> np.zeros(<span class="bu">len</span>(<span class="va">self</span>.universum))</span>
-<span id="cb194-100"><a href="#cb194-100" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb194-101"><a href="#cb194-101" aria-hidden="true" tabindex="-1"></a>        p_alt <span class="op">=</span> historie.iloc[<span class="op">-</span>rueckblick]</span>
-<span id="cb194-102"><a href="#cb194-102" aria-hidden="true" tabindex="-1"></a>        p_neu <span class="op">=</span> historie.iloc[<span class="op">-</span><span class="dv">21</span>]                    <span class="co"># vor ca. einem Monat</span></span>
-<span id="cb194-103"><a href="#cb194-103" aria-hidden="true" tabindex="-1"></a>        momentum <span class="op">=</span> (p_neu <span class="op">/</span> p_alt <span class="op">-</span> <span class="fl">1.0</span>).values</span>
-<span id="cb194-104"><a href="#cb194-104" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb194-105"><a href="#cb194-105" aria-hidden="true" tabindex="-1"></a>        <span class="co"># Z-Score, damit das Signal skalenfrei wird</span></span>
-<span id="cb194-106"><a href="#cb194-106" aria-hidden="true" tabindex="-1"></a>        streuung <span class="op">=</span> momentum.std()</span>
-<span id="cb194-107"><a href="#cb194-107" aria-hidden="true" tabindex="-1"></a>        score <span class="op">=</span> (momentum <span class="op">-</span> momentum.mean()) <span class="op">/</span> (streuung <span class="op">+</span> <span class="fl">1e-9</span>)</span>
-<span id="cb194-108"><a href="#cb194-108" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb194-109"><a href="#cb194-109" aria-hidden="true" tabindex="-1"></a>        <span class="co"># In eine taegliche Renditeerwartung uebersetzen:</span></span>
-<span id="cb194-110"><a href="#cb194-110" aria-hidden="true" tabindex="-1"></a>        <span class="co"># Basis 4 % p.a. plus 6 % p.a. je Standardabweichung Momentum.</span></span>
-<span id="cb194-111"><a href="#cb194-111" aria-hidden="true" tabindex="-1"></a>        mu_jaehrlich <span class="op">=</span> np.maximum(<span class="fl">0.04</span> <span class="op">+</span> <span class="fl">0.06</span> <span class="op">*</span> score, <span class="fl">0.0</span>)</span>
-<span id="cb194-112"><a href="#cb194-112" aria-hidden="true" tabindex="-1"></a>        <span class="cf">return</span> mu_jaehrlich <span class="op">/</span> HANDELSTAGE</span>
-<span id="cb194-113"><a href="#cb194-113" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb194-114"><a href="#cb194-114" aria-hidden="true" tabindex="-1"></a>    <span class="co"># -- 3./4. Risikomodell und Optimierung -------------------------------</span></span>
-<span id="cb194-115"><a href="#cb194-115" aria-hidden="true" tabindex="-1"></a>    <span class="kw">def</span> optimiere(<span class="va">self</span>, stichtag, w_alt, rueckblick<span class="op">=</span>HANDELSTAGE):</span>
-<span id="cb194-116"><a href="#cb194-116" aria-hidden="true" tabindex="-1"></a>        historie <span class="op">=</span> <span class="va">self</span>.renditen.loc[:stichtag].iloc[<span class="op">-</span>rueckblick:]</span>
-<span id="cb194-117"><a href="#cb194-117" aria-hidden="true" tabindex="-1"></a>        <span class="cf">if</span> <span class="bu">len</span>(historie) <span class="op">&lt;</span> <span class="dv">100</span>:</span>
-<span id="cb194-118"><a href="#cb194-118" aria-hidden="true" tabindex="-1"></a>            <span class="cf">return</span> w_alt, <span class="va">False</span></span>
-<span id="cb194-119"><a href="#cb194-119" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb194-120"><a href="#cb194-120" aria-hidden="true" tabindex="-1"></a>        R <span class="op">=</span> historie.values</span>
-<span id="cb194-121"><a href="#cb194-121" aria-hidden="true" tabindex="-1"></a>        S, N <span class="op">=</span> R.shape</span>
-<span id="cb194-122"><a href="#cb194-122" aria-hidden="true" tabindex="-1"></a>        mu_taeglich <span class="op">=</span> <span class="va">self</span>.alpha_signal(stichtag, rueckblick)</span>
-<span id="cb194-123"><a href="#cb194-123" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb194-124"><a href="#cb194-124" aria-hidden="true" tabindex="-1"></a>        w <span class="op">=</span> cp.Variable(N, nonneg<span class="op">=</span><span class="va">True</span>)</span>
-<span id="cb194-125"><a href="#cb194-125" aria-hidden="true" tabindex="-1"></a>        gamma <span class="op">=</span> cp.Variable()</span>
-<span id="cb194-126"><a href="#cb194-126" aria-hidden="true" tabindex="-1"></a>        u <span class="op">=</span> cp.Variable(S, nonneg<span class="op">=</span><span class="va">True</span>)</span>
-<span id="cb194-127"><a href="#cb194-127" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb194-128"><a href="#cb194-128" aria-hidden="true" tabindex="-1"></a>        cvar <span class="op">=</span> gamma <span class="op">+</span> (<span class="fl">1.0</span> <span class="op">/</span> (S <span class="op">*</span> (<span class="fl">1.0</span> <span class="op">-</span> <span class="va">self</span>.alpha))) <span class="op">*</span> cp.<span class="bu">sum</span>(u)</span>
-<span id="cb194-129"><a href="#cb194-129" aria-hidden="true" tabindex="-1"></a>        kosten <span class="op">=</span> <span class="va">self</span>.gebuehrensatz <span class="op">*</span> cp.norm1(w <span class="op">-</span> w_alt)</span>
-<span id="cb194-130"><a href="#cb194-130" aria-hidden="true" tabindex="-1"></a>        ziel <span class="op">=</span> cp.Maximize(mu_taeglich <span class="op">@</span> w <span class="op">-</span> <span class="va">self</span>.risikoaversion <span class="op">*</span> cvar <span class="op">-</span> kosten)</span>
-<span id="cb194-131"><a href="#cb194-131" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb194-132"><a href="#cb194-132" aria-hidden="true" tabindex="-1"></a>        bedingungen <span class="op">=</span> [cp.<span class="bu">sum</span>(w) <span class="op">==</span> <span class="dv">1</span>,</span>
-<span id="cb194-133"><a href="#cb194-133" aria-hidden="true" tabindex="-1"></a>                       w <span class="op">&lt;=</span> <span class="va">self</span>.max_gewicht,</span>
-<span id="cb194-134"><a href="#cb194-134" aria-hidden="true" tabindex="-1"></a>                       u <span class="op">&gt;=</span> <span class="op">-</span>(R <span class="op">@</span> w) <span class="op">-</span> gamma]          <span class="co"># vektorisiert</span></span>
-<span id="cb194-135"><a href="#cb194-135" aria-hidden="true" tabindex="-1"></a>        problem <span class="op">=</span> cp.Problem(ziel, bedingungen)</span>
-<span id="cb194-136"><a href="#cb194-136" aria-hidden="true" tabindex="-1"></a>        <span class="cf">try</span>:</span>
-<span id="cb194-137"><a href="#cb194-137" aria-hidden="true" tabindex="-1"></a>            problem.solve(solver<span class="op">=</span>cp.CLARABEL)</span>
-<span id="cb194-138"><a href="#cb194-138" aria-hidden="true" tabindex="-1"></a>        <span class="cf">except</span> cp.error.SolverError:</span>
-<span id="cb194-139"><a href="#cb194-139" aria-hidden="true" tabindex="-1"></a>            <span class="cf">return</span> w_alt, <span class="va">False</span></span>
-<span id="cb194-140"><a href="#cb194-140" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb194-141"><a href="#cb194-141" aria-hidden="true" tabindex="-1"></a>        <span class="cf">if</span> problem.status <span class="kw">not</span> <span class="kw">in</span> (<span class="st">&quot;optimal&quot;</span>, <span class="st">&quot;optimal_inaccurate&quot;</span>) <span class="kw">or</span> w.value <span class="kw">is</span> <span class="va">None</span>:</span>
-<span id="cb194-142"><a href="#cb194-142" aria-hidden="true" tabindex="-1"></a>            <span class="cf">return</span> w_alt, <span class="va">False</span></span>
-<span id="cb194-143"><a href="#cb194-143" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb194-144"><a href="#cb194-144" aria-hidden="true" tabindex="-1"></a>        gewichte <span class="op">=</span> np.maximum(w.value, <span class="fl">0.0</span>)</span>
-<span id="cb194-145"><a href="#cb194-145" aria-hidden="true" tabindex="-1"></a>        <span class="cf">return</span> gewichte <span class="op">/</span> gewichte.<span class="bu">sum</span>(), <span class="va">True</span></span>
-<span id="cb194-146"><a href="#cb194-146" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb194-147"><a href="#cb194-147" aria-hidden="true" tabindex="-1"></a>    <span class="co"># -- 5. Backtest -------------------------------------------------------</span></span>
-<span id="cb194-148"><a href="#cb194-148" aria-hidden="true" tabindex="-1"></a>    <span class="kw">def</span> backtest(<span class="va">self</span>):</span>
-<span id="cb194-149"><a href="#cb194-149" aria-hidden="true" tabindex="-1"></a>        <span class="bu">print</span>(<span class="st">&quot;Starte Walk-Forward-Backtest ...&quot;</span>)</span>
-<span id="cb194-150"><a href="#cb194-150" aria-hidden="true" tabindex="-1"></a>        N <span class="op">=</span> <span class="bu">len</span>(<span class="va">self</span>.universum)</span>
-<span id="cb194-151"><a href="#cb194-151" aria-hidden="true" tabindex="-1"></a>        gewichte <span class="op">=</span> np.ones(N) <span class="op">/</span> N</span>
-<span id="cb194-152"><a href="#cb194-152" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb194-153"><a href="#cb194-153" aria-hidden="true" tabindex="-1"></a>        werte <span class="op">=</span> [<span class="va">self</span>.startkapital]</span>
-<span id="cb194-154"><a href="#cb194-154" aria-hidden="true" tabindex="-1"></a>        datumsliste <span class="op">=</span> [<span class="va">self</span>.renditen.index[<span class="va">self</span>.warmup]]</span>
-<span id="cb194-155"><a href="#cb194-155" aria-hidden="true" tabindex="-1"></a>        gewichtshistorie <span class="op">=</span> []</span>
-<span id="cb194-156"><a href="#cb194-156" aria-hidden="true" tabindex="-1"></a>        geplant <span class="op">=</span> versucht <span class="op">=</span> ausgefuehrt <span class="op">=</span> <span class="dv">0</span></span>
-<span id="cb194-157"><a href="#cb194-157" aria-hidden="true" tabindex="-1"></a>        kosten_gesamt <span class="op">=</span> <span class="fl">0.0</span></span>
-<span id="cb194-158"><a href="#cb194-158" aria-hidden="true" tabindex="-1"></a>        turnover_gesamt <span class="op">=</span> <span class="fl">0.0</span></span>
-<span id="cb194-159"><a href="#cb194-159" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb194-160"><a href="#cb194-160" aria-hidden="true" tabindex="-1"></a>        <span class="cf">for</span> t <span class="kw">in</span> <span class="bu">range</span>(<span class="va">self</span>.warmup, <span class="bu">len</span>(<span class="va">self</span>.renditen) <span class="op">-</span> <span class="dv">1</span>):</span>
-<span id="cb194-161"><a href="#cb194-161" aria-hidden="true" tabindex="-1"></a>            heute <span class="op">=</span> <span class="va">self</span>.renditen.index[t]</span>
-<span id="cb194-162"><a href="#cb194-162" aria-hidden="true" tabindex="-1"></a>            morgen <span class="op">=</span> <span class="va">self</span>.renditen.index[t <span class="op">+</span> <span class="dv">1</span>]</span>
-<span id="cb194-163"><a href="#cb194-163" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb194-164"><a href="#cb194-164" aria-hidden="true" tabindex="-1"></a>            ist_termin <span class="op">=</span> heute <span class="kw">in</span> <span class="va">self</span>.rebalancing_termine <span class="kw">or</span> t <span class="op">==</span> <span class="va">self</span>.warmup</span>
-<span id="cb194-165"><a href="#cb194-165" aria-hidden="true" tabindex="-1"></a>            <span class="cf">if</span> ist_termin:</span>
-<span id="cb194-166"><a href="#cb194-166" aria-hidden="true" tabindex="-1"></a>                geplant <span class="op">+=</span> <span class="dv">1</span></span>
-<span id="cb194-167"><a href="#cb194-167" aria-hidden="true" tabindex="-1"></a>                versucht <span class="op">+=</span> <span class="dv">1</span></span>
-<span id="cb194-168"><a href="#cb194-168" aria-hidden="true" tabindex="-1"></a>                neue_gewichte, erfolg <span class="op">=</span> <span class="va">self</span>.optimiere(heute, gewichte)</span>
-<span id="cb194-169"><a href="#cb194-169" aria-hidden="true" tabindex="-1"></a>                <span class="cf">if</span> erfolg:</span>
-<span id="cb194-170"><a href="#cb194-170" aria-hidden="true" tabindex="-1"></a>                    ausgefuehrt <span class="op">+=</span> <span class="dv">1</span></span>
-<span id="cb194-171"><a href="#cb194-171" aria-hidden="true" tabindex="-1"></a>                    turnover <span class="op">=</span> <span class="bu">float</span>(np.<span class="bu">abs</span>(neue_gewichte <span class="op">-</span> gewichte).<span class="bu">sum</span>())</span>
-<span id="cb194-172"><a href="#cb194-172" aria-hidden="true" tabindex="-1"></a>                    gebuehr <span class="op">=</span> werte[<span class="op">-</span><span class="dv">1</span>] <span class="op">*</span> turnover <span class="op">*</span> <span class="va">self</span>.gebuehrensatz</span>
-<span id="cb194-173"><a href="#cb194-173" aria-hidden="true" tabindex="-1"></a>                    werte[<span class="op">-</span><span class="dv">1</span>] <span class="op">-=</span> gebuehr</span>
-<span id="cb194-174"><a href="#cb194-174" aria-hidden="true" tabindex="-1"></a>                    kosten_gesamt <span class="op">+=</span> gebuehr</span>
-<span id="cb194-175"><a href="#cb194-175" aria-hidden="true" tabindex="-1"></a>                    turnover_gesamt <span class="op">+=</span> turnover</span>
-<span id="cb194-176"><a href="#cb194-176" aria-hidden="true" tabindex="-1"></a>                    gewichte <span class="op">=</span> neue_gewichte</span>
-<span id="cb194-177"><a href="#cb194-177" aria-hidden="true" tabindex="-1"></a>                    gewichtshistorie.append((heute, gewichte.copy()))</span>
-<span id="cb194-178"><a href="#cb194-178" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb194-179"><a href="#cb194-179" aria-hidden="true" tabindex="-1"></a>            <span class="co"># Rendite von MORGEN auf die HEUTE festgelegten Gewichte anwenden</span></span>
-<span id="cb194-180"><a href="#cb194-180" aria-hidden="true" tabindex="-1"></a>            tagesrenditen <span class="op">=</span> <span class="va">self</span>.renditen.iloc[t <span class="op">+</span> <span class="dv">1</span>].values</span>
-<span id="cb194-181"><a href="#cb194-181" aria-hidden="true" tabindex="-1"></a>            portfoliorendite <span class="op">=</span> <span class="bu">float</span>(gewichte <span class="op">@</span> tagesrenditen)</span>
-<span id="cb194-182"><a href="#cb194-182" aria-hidden="true" tabindex="-1"></a>            werte.append(werte[<span class="op">-</span><span class="dv">1</span>] <span class="op">*</span> (<span class="fl">1.0</span> <span class="op">+</span> portfoliorendite))</span>
-<span id="cb194-183"><a href="#cb194-183" aria-hidden="true" tabindex="-1"></a>            datumsliste.append(morgen)</span>
-<span id="cb194-184"><a href="#cb194-184" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb194-185"><a href="#cb194-185" aria-hidden="true" tabindex="-1"></a>            <span class="co"># Gewichte driften mit den Kursen weiter</span></span>
-<span id="cb194-186"><a href="#cb194-186" aria-hidden="true" tabindex="-1"></a>            gedriftet <span class="op">=</span> gewichte <span class="op">*</span> (<span class="fl">1.0</span> <span class="op">+</span> tagesrenditen)</span>
-<span id="cb194-187"><a href="#cb194-187" aria-hidden="true" tabindex="-1"></a>            gewichte <span class="op">=</span> gedriftet <span class="op">/</span> gedriftet.<span class="bu">sum</span>()</span>
-<span id="cb194-188"><a href="#cb194-188" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb194-189"><a href="#cb194-189" aria-hidden="true" tabindex="-1"></a>        <span class="bu">print</span>(<span class="ss">f&quot;  Rebalancing: </span><span class="sc">{</span>geplant<span class="sc">}</span><span class="ss"> geplant, </span><span class="sc">{</span>ausgefuehrt<span class="sc">}</span><span class="ss"> ausgefuehrt &quot;</span></span>
-<span id="cb194-190"><a href="#cb194-190" aria-hidden="true" tabindex="-1"></a>              <span class="ss">f&quot;(</span><span class="sc">{</span>ausgefuehrt<span class="op">/</span><span class="bu">max</span>(geplant,<span class="dv">1</span>)<span class="op">*</span><span class="dv">100</span><span class="sc">:.0f}</span><span class="ss"> %)&quot;</span>)</span>
-<span id="cb194-191"><a href="#cb194-191" aria-hidden="true" tabindex="-1"></a>        <span class="cf">if</span> ausgefuehrt <span class="op">&lt;</span> geplant:</span>
-<span id="cb194-192"><a href="#cb194-192" aria-hidden="true" tabindex="-1"></a>            <span class="bu">print</span>(<span class="ss">f&quot;  WARNUNG: </span><span class="sc">{</span>geplant <span class="op">-</span> ausgefuehrt<span class="sc">}</span><span class="ss"> Optimierungen sind &quot;</span></span>
-<span id="cb194-193"><a href="#cb194-193" aria-hidden="true" tabindex="-1"></a>                  <span class="ss">f&quot;fehlgeschlagen - Ursache pruefen!&quot;</span>)</span>
-<span id="cb194-194"><a href="#cb194-194" aria-hidden="true" tabindex="-1"></a>        <span class="bu">print</span>(<span class="ss">f&quot;  Kumulierter Turnover: </span><span class="sc">{</span>turnover_gesamt<span class="op">*</span><span class="dv">100</span><span class="sc">:.0f}</span><span class="ss"> % | &quot;</span></span>
-<span id="cb194-195"><a href="#cb194-195" aria-hidden="true" tabindex="-1"></a>              <span class="ss">f&quot;Transaktionskosten insgesamt: </span><span class="sc">{</span>kosten_gesamt<span class="sc">:,.2f}</span><span class="ss"> EUR&quot;</span>)</span>
-<span id="cb194-196"><a href="#cb194-196" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb194-197"><a href="#cb194-197" aria-hidden="true" tabindex="-1"></a>        ergebnis <span class="op">=</span> pd.DataFrame({<span class="st">&quot;Portfolio&quot;</span>: werte}, index<span class="op">=</span>datumsliste)</span>
-<span id="cb194-198"><a href="#cb194-198" aria-hidden="true" tabindex="-1"></a>        benchmark <span class="op">=</span> <span class="va">self</span>.benchmark_kurse.loc[datumsliste]</span>
-<span id="cb194-199"><a href="#cb194-199" aria-hidden="true" tabindex="-1"></a>        ergebnis[<span class="st">&quot;Benchmark&quot;</span>] <span class="op">=</span> benchmark <span class="op">/</span> benchmark.iloc[<span class="dv">0</span>] <span class="op">*</span> <span class="va">self</span>.startkapital</span>
-<span id="cb194-200"><a href="#cb194-200" aria-hidden="true" tabindex="-1"></a>        <span class="cf">return</span> ergebnis, gewichtshistorie, kosten_gesamt</span>
-<span id="cb194-201"><a href="#cb194-201" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb194-202"><a href="#cb194-202" aria-hidden="true" tabindex="-1"></a>    <span class="co"># -- 6. Auswertung -----------------------------------------------------</span></span>
-<span id="cb194-203"><a href="#cb194-203" aria-hidden="true" tabindex="-1"></a>    <span class="at">@staticmethod</span></span>
-<span id="cb194-204"><a href="#cb194-204" aria-hidden="true" tabindex="-1"></a>    <span class="kw">def</span> kennzahlen(reihe, risikofrei<span class="op">=</span><span class="fl">0.02</span>):</span>
-<span id="cb194-205"><a href="#cb194-205" aria-hidden="true" tabindex="-1"></a>        renditen <span class="op">=</span> reihe.pct_change().dropna()</span>
-<span id="cb194-206"><a href="#cb194-206" aria-hidden="true" tabindex="-1"></a>        jahre <span class="op">=</span> (reihe.index[<span class="op">-</span><span class="dv">1</span>] <span class="op">-</span> reihe.index[<span class="dv">0</span>]).days <span class="op">/</span> <span class="fl">365.25</span></span>
-<span id="cb194-207"><a href="#cb194-207" aria-hidden="true" tabindex="-1"></a>        cagr <span class="op">=</span> (reihe.iloc[<span class="op">-</span><span class="dv">1</span>] <span class="op">/</span> reihe.iloc[<span class="dv">0</span>]) <span class="op">**</span> (<span class="dv">1</span> <span class="op">/</span> jahre) <span class="op">-</span> <span class="dv">1</span></span>
-<span id="cb194-208"><a href="#cb194-208" aria-hidden="true" tabindex="-1"></a>        vola <span class="op">=</span> renditen.std() <span class="op">*</span> np.sqrt(HANDELSTAGE)</span>
-<span id="cb194-209"><a href="#cb194-209" aria-hidden="true" tabindex="-1"></a>        sharpe <span class="op">=</span> (cagr <span class="op">-</span> risikofrei) <span class="op">/</span> vola <span class="cf">if</span> vola <span class="op">&gt;</span> <span class="dv">0</span> <span class="cf">else</span> np.nan</span>
-<span id="cb194-210"><a href="#cb194-210" aria-hidden="true" tabindex="-1"></a>        drawdown <span class="op">=</span> ((reihe <span class="op">-</span> reihe.cummax()) <span class="op">/</span> reihe.cummax()).<span class="bu">min</span>()</span>
-<span id="cb194-211"><a href="#cb194-211" aria-hidden="true" tabindex="-1"></a>        calmar <span class="op">=</span> cagr <span class="op">/</span> <span class="bu">abs</span>(drawdown) <span class="cf">if</span> drawdown <span class="op">&lt;</span> <span class="dv">0</span> <span class="cf">else</span> np.nan</span>
-<span id="cb194-212"><a href="#cb194-212" aria-hidden="true" tabindex="-1"></a>        trefferquote <span class="op">=</span> <span class="bu">float</span>((renditen <span class="op">&gt;</span> <span class="dv">0</span>).mean())</span>
-<span id="cb194-213"><a href="#cb194-213" aria-hidden="true" tabindex="-1"></a>        <span class="cf">return</span> {<span class="st">&quot;CAGR&quot;</span>: cagr, <span class="st">&quot;Volatilitaet&quot;</span>: vola, <span class="st">&quot;Sharpe&quot;</span>: sharpe,</span>
-<span id="cb194-214"><a href="#cb194-214" aria-hidden="true" tabindex="-1"></a>                <span class="st">&quot;Max Drawdown&quot;</span>: drawdown, <span class="st">&quot;Calmar&quot;</span>: calmar,</span>
-<span id="cb194-215"><a href="#cb194-215" aria-hidden="true" tabindex="-1"></a>                <span class="st">&quot;Trefferquote&quot;</span>: trefferquote, <span class="st">&quot;Jahre&quot;</span>: jahre}</span>
-<span id="cb194-216"><a href="#cb194-216" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb194-217"><a href="#cb194-217" aria-hidden="true" tabindex="-1"></a>    <span class="kw">def</span> bericht(<span class="va">self</span>, ergebnis, kosten_gesamt):</span>
-<span id="cb194-218"><a href="#cb194-218" aria-hidden="true" tabindex="-1"></a>        k_port <span class="op">=</span> <span class="va">self</span>.kennzahlen(ergebnis[<span class="st">&quot;Portfolio&quot;</span>])</span>
-<span id="cb194-219"><a href="#cb194-219" aria-hidden="true" tabindex="-1"></a>        k_bench <span class="op">=</span> <span class="va">self</span>.kennzahlen(ergebnis[<span class="st">&quot;Benchmark&quot;</span>])</span>
-<span id="cb194-220"><a href="#cb194-220" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb194-221"><a href="#cb194-221" aria-hidden="true" tabindex="-1"></a>        <span class="bu">print</span>(<span class="st">&quot;</span><span class="ch">\n</span><span class="st">&quot;</span> <span class="op">+</span> <span class="st">&quot;=&quot;</span> <span class="op">*</span> <span class="dv">84</span>)</span>
-<span id="cb194-222"><a href="#cb194-222" aria-hidden="true" tabindex="-1"></a>        <span class="bu">print</span>(<span class="st">&quot;          LEISTUNGSREPORT DER QUANTITATIVEN ENGINE&quot;</span>)</span>
-<span id="cb194-223"><a href="#cb194-223" aria-hidden="true" tabindex="-1"></a>        <span class="bu">print</span>(<span class="st">&quot;=&quot;</span> <span class="op">*</span> <span class="dv">84</span>)</span>
-<span id="cb194-224"><a href="#cb194-224" aria-hidden="true" tabindex="-1"></a>        <span class="bu">print</span>(<span class="ss">f&quot;Zeitraum: </span><span class="sc">{</span>ergebnis<span class="sc">.</span>index[<span class="dv">0</span>]<span class="sc">:</span><span class="op">%</span>Y<span class="op">-%</span>m<span class="op">-%</span>d<span class="sc">}</span><span class="ss"> bis </span><span class="sc">{</span>ergebnis<span class="sc">.</span>index[<span class="op">-</span><span class="dv">1</span>]<span class="sc">:</span><span class="op">%</span>Y<span class="op">-%</span>m<span class="op">-%</span>d<span class="sc">}</span><span class="ss"> &quot;</span></span>
-<span id="cb194-225"><a href="#cb194-225" aria-hidden="true" tabindex="-1"></a>              <span class="ss">f&quot;(</span><span class="sc">{</span>k_port[<span class="st">&#39;Jahre&#39;</span>]<span class="sc">:.1f}</span><span class="ss"> Jahre) | Startkapital &quot;</span></span>
-<span id="cb194-226"><a href="#cb194-226" aria-hidden="true" tabindex="-1"></a>              <span class="ss">f&quot;</span><span class="sc">{</span><span class="va">self</span><span class="sc">.</span>startkapital<span class="sc">:,.0f}</span><span class="ss"> EUR</span><span class="ch">\n</span><span class="ss">&quot;</span>)</span>
-<span id="cb194-227"><a href="#cb194-227" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb194-228"><a href="#cb194-228" aria-hidden="true" tabindex="-1"></a>        zeilen <span class="op">=</span> [</span>
-<span id="cb194-229"><a href="#cb194-229" aria-hidden="true" tabindex="-1"></a>            (<span class="st">&quot;Endkapital&quot;</span>, <span class="ss">f&quot;</span><span class="sc">{</span>ergebnis[<span class="st">&#39;Portfolio&#39;</span>]<span class="sc">.</span>iloc[<span class="op">-</span><span class="dv">1</span>]<span class="sc">:,.0f}</span><span class="ss"> EUR&quot;</span>,</span>
-<span id="cb194-230"><a href="#cb194-230" aria-hidden="true" tabindex="-1"></a>             <span class="ss">f&quot;</span><span class="sc">{</span>ergebnis[<span class="st">&#39;Benchmark&#39;</span>]<span class="sc">.</span>iloc[<span class="op">-</span><span class="dv">1</span>]<span class="sc">:,.0f}</span><span class="ss"> EUR&quot;</span>),</span>
-<span id="cb194-231"><a href="#cb194-231" aria-hidden="true" tabindex="-1"></a>            (<span class="st">&quot;CAGR (Jahresrendite)&quot;</span>, <span class="ss">f&quot;</span><span class="sc">{</span>k_port[<span class="st">&#39;CAGR&#39;</span>]<span class="op">*</span><span class="dv">100</span><span class="sc">:6.2f}</span><span class="ss"> %&quot;</span>,</span>
-<span id="cb194-232"><a href="#cb194-232" aria-hidden="true" tabindex="-1"></a>             <span class="ss">f&quot;</span><span class="sc">{</span>k_bench[<span class="st">&#39;CAGR&#39;</span>]<span class="op">*</span><span class="dv">100</span><span class="sc">:6.2f}</span><span class="ss"> %&quot;</span>),</span>
-<span id="cb194-233"><a href="#cb194-233" aria-hidden="true" tabindex="-1"></a>            (<span class="st">&quot;Volatilitaet p.a.&quot;</span>, <span class="ss">f&quot;</span><span class="sc">{</span>k_port[<span class="st">&#39;Volatilitaet&#39;</span>]<span class="op">*</span><span class="dv">100</span><span class="sc">:6.2f}</span><span class="ss"> %&quot;</span>,</span>
-<span id="cb194-234"><a href="#cb194-234" aria-hidden="true" tabindex="-1"></a>             <span class="ss">f&quot;</span><span class="sc">{</span>k_bench[<span class="st">&#39;Volatilitaet&#39;</span>]<span class="op">*</span><span class="dv">100</span><span class="sc">:6.2f}</span><span class="ss"> %&quot;</span>),</span>
-<span id="cb194-235"><a href="#cb194-235" aria-hidden="true" tabindex="-1"></a>            (<span class="st">&quot;Sharpe Ratio (rf=2 %)&quot;</span>, <span class="ss">f&quot;</span><span class="sc">{</span>k_port[<span class="st">&#39;Sharpe&#39;</span>]<span class="sc">:6.2f}</span><span class="ss">&quot;</span>,</span>
-<span id="cb194-236"><a href="#cb194-236" aria-hidden="true" tabindex="-1"></a>             <span class="ss">f&quot;</span><span class="sc">{</span>k_bench[<span class="st">&#39;Sharpe&#39;</span>]<span class="sc">:6.2f}</span><span class="ss">&quot;</span>),</span>
-<span id="cb194-237"><a href="#cb194-237" aria-hidden="true" tabindex="-1"></a>            (<span class="st">&quot;Maximum Drawdown&quot;</span>, <span class="ss">f&quot;</span><span class="sc">{</span>k_port[<span class="st">&#39;Max Drawdown&#39;</span>]<span class="op">*</span><span class="dv">100</span><span class="sc">:6.2f}</span><span class="ss"> %&quot;</span>,</span>
-<span id="cb194-238"><a href="#cb194-238" aria-hidden="true" tabindex="-1"></a>             <span class="ss">f&quot;</span><span class="sc">{</span>k_bench[<span class="st">&#39;Max Drawdown&#39;</span>]<span class="op">*</span><span class="dv">100</span><span class="sc">:6.2f}</span><span class="ss"> %&quot;</span>),</span>
-<span id="cb194-239"><a href="#cb194-239" aria-hidden="true" tabindex="-1"></a>            (<span class="st">&quot;Calmar Ratio&quot;</span>, <span class="ss">f&quot;</span><span class="sc">{</span>k_port[<span class="st">&#39;Calmar&#39;</span>]<span class="sc">:6.2f}</span><span class="ss">&quot;</span>, <span class="ss">f&quot;</span><span class="sc">{</span>k_bench[<span class="st">&#39;Calmar&#39;</span>]<span class="sc">:6.2f}</span><span class="ss">&quot;</span>),</span>
-<span id="cb194-240"><a href="#cb194-240" aria-hidden="true" tabindex="-1"></a>            (<span class="st">&quot;Trefferquote (Tage)&quot;</span>, <span class="ss">f&quot;</span><span class="sc">{</span>k_port[<span class="st">&#39;Trefferquote&#39;</span>]<span class="op">*</span><span class="dv">100</span><span class="sc">:6.1f}</span><span class="ss"> %&quot;</span>,</span>
-<span id="cb194-241"><a href="#cb194-241" aria-hidden="true" tabindex="-1"></a>             <span class="ss">f&quot;</span><span class="sc">{</span>k_bench[<span class="st">&#39;Trefferquote&#39;</span>]<span class="op">*</span><span class="dv">100</span><span class="sc">:6.1f}</span><span class="ss"> %&quot;</span>),</span>
-<span id="cb194-242"><a href="#cb194-242" aria-hidden="true" tabindex="-1"></a>        ]</span>
-<span id="cb194-243"><a href="#cb194-243" aria-hidden="true" tabindex="-1"></a>        <span class="bu">print</span>(pd.DataFrame(zeilen, columns<span class="op">=</span>[<span class="st">&quot;Kennzahl&quot;</span>, <span class="st">&quot;OR-Strategie&quot;</span>, <span class="st">&quot;Benchmark&quot;</span>])</span>
-<span id="cb194-244"><a href="#cb194-244" aria-hidden="true" tabindex="-1"></a>              .to_string(index<span class="op">=</span><span class="va">False</span>))</span>
-<span id="cb194-245"><a href="#cb194-245" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb194-246"><a href="#cb194-246" aria-hidden="true" tabindex="-1"></a>        anteil <span class="op">=</span> kosten_gesamt <span class="op">/</span> <span class="va">self</span>.startkapital</span>
-<span id="cb194-247"><a href="#cb194-247" aria-hidden="true" tabindex="-1"></a>        <span class="bu">print</span>(<span class="ss">f&quot;</span><span class="ch">\n</span><span class="ss">Transaktionskosten: </span><span class="sc">{</span>kosten_gesamt<span class="sc">:,.0f}</span><span class="ss"> EUR &quot;</span></span>
-<span id="cb194-248"><a href="#cb194-248" aria-hidden="true" tabindex="-1"></a>              <span class="ss">f&quot;= </span><span class="sc">{</span>anteil<span class="op">*</span><span class="dv">100</span><span class="sc">:.2f}</span><span class="ss"> % des Startkapitals &quot;</span></span>
-<span id="cb194-249"><a href="#cb194-249" aria-hidden="true" tabindex="-1"></a>              <span class="ss">f&quot;= </span><span class="sc">{</span>anteil<span class="op">/</span>k_port[<span class="st">&#39;Jahre&#39;</span>]<span class="op">*</span><span class="dv">100</span><span class="sc">:.2f}</span><span class="ss"> % p.a.&quot;</span>)</span>
-<span id="cb194-250"><a href="#cb194-250" aria-hidden="true" tabindex="-1"></a>        <span class="bu">print</span>(<span class="st">&quot;Ohne diese Kosten waere die ausgewiesene Rendite entsprechend hoeher -&quot;</span>)</span>
-<span id="cb194-251"><a href="#cb194-251" aria-hidden="true" tabindex="-1"></a>        <span class="bu">print</span>(<span class="st">&quot;genau deshalb gehoeren sie in den Backtest und nicht daneben.&quot;</span>)</span>
-<span id="cb194-252"><a href="#cb194-252" aria-hidden="true" tabindex="-1"></a>        <span class="bu">print</span>(<span class="st">&quot;=&quot;</span> <span class="op">*</span> <span class="dv">84</span>)</span>
-<span id="cb194-253"><a href="#cb194-253" aria-hidden="true" tabindex="-1"></a>        <span class="cf">return</span> k_port, k_bench</span>
-<span id="cb194-254"><a href="#cb194-254" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb194-255"><a href="#cb194-255" aria-hidden="true" tabindex="-1"></a>    <span class="kw">def</span> zeichne(<span class="va">self</span>, ergebnis):</span>
-<span id="cb194-256"><a href="#cb194-256" aria-hidden="true" tabindex="-1"></a>        plt.figure(figsize<span class="op">=</span>(<span class="dv">11</span>, <span class="dv">6</span>))</span>
-<span id="cb194-257"><a href="#cb194-257" aria-hidden="true" tabindex="-1"></a>        plt.plot(ergebnis.index, ergebnis[<span class="st">&quot;Portfolio&quot;</span>], <span class="st">&quot;b-&quot;</span>, lw<span class="op">=</span><span class="fl">2.2</span>,</span>
-<span id="cb194-258"><a href="#cb194-258" aria-hidden="true" tabindex="-1"></a>                 label<span class="op">=</span><span class="st">&quot;OR-Handelsmaschine&quot;</span>)</span>
-<span id="cb194-259"><a href="#cb194-259" aria-hidden="true" tabindex="-1"></a>        plt.plot(ergebnis.index, ergebnis[<span class="st">&quot;Benchmark&quot;</span>], <span class="st">&quot;k--&quot;</span>, lw<span class="op">=</span><span class="fl">1.5</span>, alpha<span class="op">=</span><span class="fl">0.75</span>,</span>
-<span id="cb194-260"><a href="#cb194-260" aria-hidden="true" tabindex="-1"></a>                 label<span class="op">=</span><span class="ss">f&quot;Benchmark (</span><span class="sc">{</span><span class="va">self</span><span class="sc">.</span>benchmark<span class="sc">}</span><span class="ss">)&quot;</span>)</span>
-<span id="cb194-261"><a href="#cb194-261" aria-hidden="true" tabindex="-1"></a>        plt.title(<span class="st">&quot;Walk-Forward-Backtest: OR-Strategie gegen Benchmark&quot;</span>, fontsize<span class="op">=</span><span class="dv">12</span>)</span>
-<span id="cb194-262"><a href="#cb194-262" aria-hidden="true" tabindex="-1"></a>        plt.xlabel(<span class="st">&quot;Datum&quot;</span>)</span>
-<span id="cb194-263"><a href="#cb194-263" aria-hidden="true" tabindex="-1"></a>        plt.ylabel(<span class="st">&quot;Depotwert in EUR&quot;</span>)</span>
-<span id="cb194-264"><a href="#cb194-264" aria-hidden="true" tabindex="-1"></a>        plt.grid(<span class="va">True</span>, linestyle<span class="op">=</span><span class="st">&quot;:&quot;</span>, alpha<span class="op">=</span><span class="fl">0.6</span>)</span>
-<span id="cb194-265"><a href="#cb194-265" aria-hidden="true" tabindex="-1"></a>        plt.legend(loc<span class="op">=</span><span class="st">&quot;upper left&quot;</span>)</span>
-<span id="cb194-266"><a href="#cb194-266" aria-hidden="true" tabindex="-1"></a>        plt.tight_layout()</span>
-<span id="cb194-267"><a href="#cb194-267" aria-hidden="true" tabindex="-1"></a>        ziel <span class="op">=</span> os.path.join(OUTPUT_DIR, <span class="st">&quot;trading_engine_backtest.png&quot;</span>)</span>
-<span id="cb194-268"><a href="#cb194-268" aria-hidden="true" tabindex="-1"></a>        plt.savefig(ziel, dpi<span class="op">=</span><span class="dv">150</span>)</span>
-<span id="cb194-269"><a href="#cb194-269" aria-hidden="true" tabindex="-1"></a>        <span class="bu">print</span>(<span class="ss">f&quot;Chart gespeichert unter &#39;</span><span class="sc">{</span>ziel<span class="sc">}</span><span class="ss">&#39;&quot;</span>)</span>
-<span id="cb194-270"><a href="#cb194-270" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb194-271"><a href="#cb194-271" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb194-272"><a href="#cb194-272" aria-hidden="true" tabindex="-1"></a><span class="kw">def</span> lookahead_selbsttest(maschine):</span>
-<span id="cb194-273"><a href="#cb194-273" aria-hidden="true" tabindex="-1"></a>    <span class="co">&quot;&quot;&quot;</span></span>
-<span id="cb194-274"><a href="#cb194-274" aria-hidden="true" tabindex="-1"></a><span class="co">    Prueft, dass das Signal zum Zeitpunkt t NUR Daten bis t verwendet.</span></span>
-<span id="cb194-275"><a href="#cb194-275" aria-hidden="true" tabindex="-1"></a><span class="co">    Methode: kuenstlich die Zukunft veraendern und pruefen, ob sich das</span></span>
-<span id="cb194-276"><a href="#cb194-276" aria-hidden="true" tabindex="-1"></a><span class="co">    Signal von heute dadurch aendert. Tut es das, liegt Lookahead vor.</span></span>
-<span id="cb194-277"><a href="#cb194-277" aria-hidden="true" tabindex="-1"></a><span class="co">    &quot;&quot;&quot;</span></span>
-<span id="cb194-278"><a href="#cb194-278" aria-hidden="true" tabindex="-1"></a>    stichtag <span class="op">=</span> maschine.kurse.index[<span class="bu">len</span>(maschine.kurse) <span class="op">//</span> <span class="dv">2</span>]</span>
-<span id="cb194-279"><a href="#cb194-279" aria-hidden="true" tabindex="-1"></a>    signal_original <span class="op">=</span> maschine.alpha_signal(stichtag)</span>
-<span id="cb194-280"><a href="#cb194-280" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb194-281"><a href="#cb194-281" aria-hidden="true" tabindex="-1"></a>    original_kurse <span class="op">=</span> maschine.kurse.copy()</span>
-<span id="cb194-282"><a href="#cb194-282" aria-hidden="true" tabindex="-1"></a>    zukunft <span class="op">=</span> maschine.kurse.index <span class="op">&gt;</span> stichtag</span>
-<span id="cb194-283"><a href="#cb194-283" aria-hidden="true" tabindex="-1"></a>    maschine.kurse.loc[zukunft] <span class="op">*=</span> <span class="fl">3.0</span>            <span class="co"># Zukunft massiv veraendern</span></span>
-<span id="cb194-284"><a href="#cb194-284" aria-hidden="true" tabindex="-1"></a>    signal_manipuliert <span class="op">=</span> maschine.alpha_signal(stichtag)</span>
-<span id="cb194-285"><a href="#cb194-285" aria-hidden="true" tabindex="-1"></a>    maschine.kurse <span class="op">=</span> original_kurse               <span class="co"># zuruecksetzen</span></span>
-<span id="cb194-286"><a href="#cb194-286" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb194-287"><a href="#cb194-287" aria-hidden="true" tabindex="-1"></a>    identisch <span class="op">=</span> np.allclose(signal_original, signal_manipuliert)</span>
-<span id="cb194-288"><a href="#cb194-288" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;Lookahead-Selbsttest: Signal bleibt bei manipulierter Zukunft &quot;</span></span>
-<span id="cb194-289"><a href="#cb194-289" aria-hidden="true" tabindex="-1"></a>          <span class="ss">f&quot;</span><span class="sc">{</span><span class="st">&#39;UNVERAENDERT (gut)&#39;</span> <span class="cf">if</span> identisch <span class="cf">else</span> <span class="st">&#39;VERAENDERT - LOOKAHEAD-BIAS!&#39;</span><span class="sc">}</span><span class="ss">&quot;</span>)</span>
-<span id="cb194-290"><a href="#cb194-290" aria-hidden="true" tabindex="-1"></a>    <span class="cf">assert</span> identisch, <span class="st">&quot;Das Signal verwendet Zukunftsdaten!&quot;</span></span>
-<span id="cb194-291"><a href="#cb194-291" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb194-292"><a href="#cb194-292" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb194-293"><a href="#cb194-293" aria-hidden="true" tabindex="-1"></a><span class="cf">if</span> <span class="va">__name__</span> <span class="op">==</span> <span class="st">&quot;__main__&quot;</span>:</span>
-<span id="cb194-294"><a href="#cb194-294" aria-hidden="true" tabindex="-1"></a>    UNIVERSUM <span class="op">=</span> [<span class="st">&quot;AAPL&quot;</span>, <span class="st">&quot;MSFT&quot;</span>, <span class="st">&quot;NVDA&quot;</span>, <span class="st">&quot;GOOGL&quot;</span>,</span>
-<span id="cb194-295"><a href="#cb194-295" aria-hidden="true" tabindex="-1"></a>                 <span class="st">&quot;JNJ&quot;</span>, <span class="st">&quot;UNH&quot;</span>, <span class="st">&quot;PFE&quot;</span>,</span>
-<span id="cb194-296"><a href="#cb194-296" aria-hidden="true" tabindex="-1"></a>                 <span class="st">&quot;JPM&quot;</span>, <span class="st">&quot;BAC&quot;</span>, <span class="st">&quot;GS&quot;</span>,</span>
-<span id="cb194-297"><a href="#cb194-297" aria-hidden="true" tabindex="-1"></a>                 <span class="st">&quot;XOM&quot;</span>, <span class="st">&quot;CVX&quot;</span>,</span>
-<span id="cb194-298"><a href="#cb194-298" aria-hidden="true" tabindex="-1"></a>                 <span class="st">&quot;PG&quot;</span>, <span class="st">&quot;KO&quot;</span>, <span class="st">&quot;COST&quot;</span>]</span>
-<span id="cb194-299"><a href="#cb194-299" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb194-300"><a href="#cb194-300" aria-hidden="true" tabindex="-1"></a>    maschine <span class="op">=</span> QuantitativeHandelsmaschine(UNIVERSUM, benchmark<span class="op">=</span><span class="st">&quot;SPY&quot;</span>, jahre<span class="op">=</span><span class="dv">5</span>)</span>
-<span id="cb194-301"><a href="#cb194-301" aria-hidden="true" tabindex="-1"></a>    maschine.lade_daten()</span>
-<span id="cb194-302"><a href="#cb194-302" aria-hidden="true" tabindex="-1"></a>    lookahead_selbsttest(maschine)</span>
-<span id="cb194-303"><a href="#cb194-303" aria-hidden="true" tabindex="-1"></a>    ergebnis, gewichte, kosten <span class="op">=</span> maschine.backtest()</span>
-<span id="cb194-304"><a href="#cb194-304" aria-hidden="true" tabindex="-1"></a>    maschine.bericht(ergebnis, kosten)</span>
-<span id="cb194-305"><a href="#cb194-305" aria-hidden="true" tabindex="-1"></a>    maschine.zeichne(ergebnis)</span></code></pre></div>
+<div class="sourceCode" id="cb196"><pre class="sourceCode python"><code class="sourceCode python"><span id="cb196-1"><a href="#cb196-1" aria-hidden="true" tabindex="-1"></a><span class="co">#!/usr/bin/env python3</span></span>
+<span id="cb196-2"><a href="#cb196-2" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb196-3"><a href="#cb196-3" aria-hidden="true" tabindex="-1"></a><span class="co"># QuantitativeTradingEngine.py</span></span>
+<span id="cb196-4"><a href="#cb196-4" aria-hidden="true" tabindex="-1"></a><span class="co">&quot;&quot;&quot;</span></span>
+<span id="cb196-5"><a href="#cb196-5" aria-hidden="true" tabindex="-1"></a><span class="co">Kapitel Handelsmaschine: Vollstaendige quantitative Handelsmaschine mit</span></span>
+<span id="cb196-6"><a href="#cb196-6" aria-hidden="true" tabindex="-1"></a><span class="co">Walk-Forward-Backtest und OR-Optimierungsschicht.</span></span>
+<span id="cb196-7"><a href="#cb196-7" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb196-8"><a href="#cb196-8" aria-hidden="true" tabindex="-1"></a><span class="co">Eigenschaften:</span></span>
+<span id="cb196-9"><a href="#cb196-9" aria-hidden="true" tabindex="-1"></a><span class="co">  * Rebalancing-Termine sind garantiert Handelstage; die Zahl der</span></span>
+<span id="cb196-10"><a href="#cb196-10" aria-hidden="true" tabindex="-1"></a><span class="co">    tatsaechlich ausgefuehrten Umschichtungen wird ausgewiesen</span></span>
+<span id="cb196-11"><a href="#cb196-11" aria-hidden="true" tabindex="-1"></a><span class="co">  * Spaltenreihenfolge erzwungen</span></span>
+<span id="cb196-12"><a href="#cb196-12" aria-hidden="true" tabindex="-1"></a><span class="co">  * Einheiten konsistent (taegliche Groessen im Modell)</span></span>
+<span id="cb196-13"><a href="#cb196-13" aria-hidden="true" tabindex="-1"></a><span class="co">  * Szenario-Nebenbedingungen vektorisiert</span></span>
+<span id="cb196-14"><a href="#cb196-14" aria-hidden="true" tabindex="-1"></a><span class="co">  * Lookahead-Selbsttest eingebaut</span></span>
+<span id="cb196-15"><a href="#cb196-15" aria-hidden="true" tabindex="-1"></a><span class="co">  * Zusaetzliche Kennzahlen: Calmar, Trefferquote, Turnover, Kostenanteil</span></span>
+<span id="cb196-16"><a href="#cb196-16" aria-hidden="true" tabindex="-1"></a><span class="co">&quot;&quot;&quot;</span></span>
+<span id="cb196-17"><a href="#cb196-17" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb196-18"><a href="#cb196-18" aria-hidden="true" tabindex="-1"></a><span class="im">import</span> os</span>
+<span id="cb196-19"><a href="#cb196-19" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb196-20"><a href="#cb196-20" aria-hidden="true" tabindex="-1"></a><span class="im">import</span> cvxpy <span class="im">as</span> cp</span>
+<span id="cb196-21"><a href="#cb196-21" aria-hidden="true" tabindex="-1"></a><span class="im">import</span> numpy <span class="im">as</span> np</span>
+<span id="cb196-22"><a href="#cb196-22" aria-hidden="true" tabindex="-1"></a><span class="im">import</span> pandas <span class="im">as</span> pd</span>
+<span id="cb196-23"><a href="#cb196-23" aria-hidden="true" tabindex="-1"></a><span class="im">import</span> yfinance <span class="im">as</span> yf</span>
+<span id="cb196-24"><a href="#cb196-24" aria-hidden="true" tabindex="-1"></a><span class="im">from</span> sklearn.covariance <span class="im">import</span> LedoitWolf</span>
+<span id="cb196-25"><a href="#cb196-25" aria-hidden="true" tabindex="-1"></a><span class="im">import</span> matplotlib</span>
+<span id="cb196-26"><a href="#cb196-26" aria-hidden="true" tabindex="-1"></a>matplotlib.use(<span class="st">&quot;Agg&quot;</span>)</span>
+<span id="cb196-27"><a href="#cb196-27" aria-hidden="true" tabindex="-1"></a><span class="im">import</span> matplotlib.pyplot <span class="im">as</span> plt</span>
+<span id="cb196-28"><a href="#cb196-28" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb196-29"><a href="#cb196-29" aria-hidden="true" tabindex="-1"></a>OUTPUT_DIR <span class="op">=</span> os.path.join(os.path.dirname(os.path.abspath(<span class="va">__file__</span>)), <span class="st">&quot;output&quot;</span>)</span>
+<span id="cb196-30"><a href="#cb196-30" aria-hidden="true" tabindex="-1"></a>os.makedirs(OUTPUT_DIR, exist_ok<span class="op">=</span><span class="va">True</span>)</span>
+<span id="cb196-31"><a href="#cb196-31" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb196-32"><a href="#cb196-32" aria-hidden="true" tabindex="-1"></a>HANDELSTAGE <span class="op">=</span> <span class="dv">252</span></span>
+<span id="cb196-33"><a href="#cb196-33" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb196-34"><a href="#cb196-34" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb196-35"><a href="#cb196-35" aria-hidden="true" tabindex="-1"></a><span class="kw">class</span> QuantitativeHandelsmaschine:</span>
+<span id="cb196-36"><a href="#cb196-36" aria-hidden="true" tabindex="-1"></a>    <span class="co">&quot;&quot;&quot;Walk-Forward-Backtest mit CVaR-Optimierung und Transaktionskosten.&quot;&quot;&quot;</span></span>
+<span id="cb196-37"><a href="#cb196-37" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb196-38"><a href="#cb196-38" aria-hidden="true" tabindex="-1"></a>    <span class="kw">def</span> <span class="fu">__init__</span>(<span class="va">self</span>, universum, benchmark<span class="op">=</span><span class="st">&quot;SPY&quot;</span>, jahre<span class="op">=</span><span class="dv">5</span>,</span>
+<span id="cb196-39"><a href="#cb196-39" aria-hidden="true" tabindex="-1"></a>                 startkapital<span class="op">=</span><span class="fl">100_000.0</span>, gebuehrensatz<span class="op">=</span><span class="fl">0.0015</span>,</span>
+<span id="cb196-40"><a href="#cb196-40" aria-hidden="true" tabindex="-1"></a>                 max_gewicht<span class="op">=</span><span class="fl">0.20</span>, alpha<span class="op">=</span><span class="fl">0.95</span>, risikoaversion<span class="op">=</span><span class="fl">1.2</span>,</span>
+<span id="cb196-41"><a href="#cb196-41" aria-hidden="true" tabindex="-1"></a>                 warmup<span class="op">=</span>HANDELSTAGE):</span>
+<span id="cb196-42"><a href="#cb196-42" aria-hidden="true" tabindex="-1"></a>        <span class="va">self</span>.universum <span class="op">=</span> <span class="bu">list</span>(universum)</span>
+<span id="cb196-43"><a href="#cb196-43" aria-hidden="true" tabindex="-1"></a>        <span class="va">self</span>.benchmark <span class="op">=</span> benchmark</span>
+<span id="cb196-44"><a href="#cb196-44" aria-hidden="true" tabindex="-1"></a>        <span class="va">self</span>.jahre <span class="op">=</span> jahre</span>
+<span id="cb196-45"><a href="#cb196-45" aria-hidden="true" tabindex="-1"></a>        <span class="va">self</span>.startkapital <span class="op">=</span> startkapital</span>
+<span id="cb196-46"><a href="#cb196-46" aria-hidden="true" tabindex="-1"></a>        <span class="va">self</span>.gebuehrensatz <span class="op">=</span> gebuehrensatz</span>
+<span id="cb196-47"><a href="#cb196-47" aria-hidden="true" tabindex="-1"></a>        <span class="va">self</span>.max_gewicht <span class="op">=</span> max_gewicht</span>
+<span id="cb196-48"><a href="#cb196-48" aria-hidden="true" tabindex="-1"></a>        <span class="va">self</span>.alpha <span class="op">=</span> alpha</span>
+<span id="cb196-49"><a href="#cb196-49" aria-hidden="true" tabindex="-1"></a>        <span class="va">self</span>.risikoaversion <span class="op">=</span> risikoaversion</span>
+<span id="cb196-50"><a href="#cb196-50" aria-hidden="true" tabindex="-1"></a>        <span class="va">self</span>.warmup <span class="op">=</span> warmup</span>
+<span id="cb196-51"><a href="#cb196-51" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb196-52"><a href="#cb196-52" aria-hidden="true" tabindex="-1"></a>        <span class="va">self</span>.kurse <span class="op">=</span> <span class="va">None</span></span>
+<span id="cb196-53"><a href="#cb196-53" aria-hidden="true" tabindex="-1"></a>        <span class="va">self</span>.benchmark_kurse <span class="op">=</span> <span class="va">None</span></span>
+<span id="cb196-54"><a href="#cb196-54" aria-hidden="true" tabindex="-1"></a>        <span class="va">self</span>.renditen <span class="op">=</span> <span class="va">None</span></span>
+<span id="cb196-55"><a href="#cb196-55" aria-hidden="true" tabindex="-1"></a>        <span class="va">self</span>.rebalancing_termine <span class="op">=</span> <span class="va">None</span></span>
+<span id="cb196-56"><a href="#cb196-56" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb196-57"><a href="#cb196-57" aria-hidden="true" tabindex="-1"></a>    <span class="co"># -- 1. Datenpipeline ------------------------------------------------</span></span>
+<span id="cb196-58"><a href="#cb196-58" aria-hidden="true" tabindex="-1"></a>    <span class="kw">def</span> lade_daten(<span class="va">self</span>):</span>
+<span id="cb196-59"><a href="#cb196-59" aria-hidden="true" tabindex="-1"></a>        ende <span class="op">=</span> pd.Timestamp.today().normalize()</span>
+<span id="cb196-60"><a href="#cb196-60" aria-hidden="true" tabindex="-1"></a>        start <span class="op">=</span> ende <span class="op">-</span> pd.DateOffset(years<span class="op">=</span><span class="va">self</span>.jahre)</span>
+<span id="cb196-61"><a href="#cb196-61" aria-hidden="true" tabindex="-1"></a>        alle <span class="op">=</span> <span class="va">self</span>.universum <span class="op">+</span> [<span class="va">self</span>.benchmark]</span>
+<span id="cb196-62"><a href="#cb196-62" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb196-63"><a href="#cb196-63" aria-hidden="true" tabindex="-1"></a>        <span class="bu">print</span>(<span class="ss">f&quot;Lade </span><span class="sc">{</span><span class="bu">len</span>(<span class="va">self</span>.universum)<span class="sc">}</span><span class="ss"> Titel + Benchmark (</span><span class="sc">{</span><span class="va">self</span><span class="sc">.</span>benchmark<span class="sc">}</span><span class="ss">) &quot;</span></span>
+<span id="cb196-64"><a href="#cb196-64" aria-hidden="true" tabindex="-1"></a>              <span class="ss">f&quot;ueber </span><span class="sc">{</span><span class="va">self</span><span class="sc">.</span>jahre<span class="sc">}</span><span class="ss"> Jahre ...&quot;</span>)</span>
+<span id="cb196-65"><a href="#cb196-65" aria-hidden="true" tabindex="-1"></a>        roh <span class="op">=</span> yf.download(alle, start<span class="op">=</span>start, end<span class="op">=</span>ende, auto_adjust<span class="op">=</span><span class="va">True</span>, progress<span class="op">=</span><span class="va">False</span>)</span>
+<span id="cb196-66"><a href="#cb196-66" aria-hidden="true" tabindex="-1"></a>        <span class="cf">if</span> roh.empty:</span>
+<span id="cb196-67"><a href="#cb196-67" aria-hidden="true" tabindex="-1"></a>            <span class="cf">raise</span> <span class="pp">SystemExit</span>(<span class="st">&quot;Download fehlgeschlagen (Netz/Ticker/Rate-Limit pruefen).&quot;</span>)</span>
+<span id="cb196-68"><a href="#cb196-68" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb196-69"><a href="#cb196-69" aria-hidden="true" tabindex="-1"></a>        <span class="cf">if</span> <span class="bu">isinstance</span>(roh.columns, pd.MultiIndex):</span>
+<span id="cb196-70"><a href="#cb196-70" aria-hidden="true" tabindex="-1"></a>            daten <span class="op">=</span> roh[<span class="st">&quot;Close&quot;</span>][alle].dropna()      <span class="co"># erzwingt eigene Spaltenreihenfolge</span></span>
+<span id="cb196-71"><a href="#cb196-71" aria-hidden="true" tabindex="-1"></a>        <span class="cf">else</span>:</span>
+<span id="cb196-72"><a href="#cb196-72" aria-hidden="true" tabindex="-1"></a>            daten <span class="op">=</span> roh[[<span class="st">&quot;Close&quot;</span>]].dropna()</span>
+<span id="cb196-73"><a href="#cb196-73" aria-hidden="true" tabindex="-1"></a>            daten.columns <span class="op">=</span> alle</span>
+<span id="cb196-74"><a href="#cb196-74" aria-hidden="true" tabindex="-1"></a>        <span class="cf">assert</span> <span class="bu">list</span>(daten.columns) <span class="op">==</span> alle, <span class="st">&quot;Spaltenreihenfolge weicht ab!&quot;</span></span>
+<span id="cb196-75"><a href="#cb196-75" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb196-76"><a href="#cb196-76" aria-hidden="true" tabindex="-1"></a>        <span class="va">self</span>.kurse <span class="op">=</span> daten[<span class="va">self</span>.universum]</span>
+<span id="cb196-77"><a href="#cb196-77" aria-hidden="true" tabindex="-1"></a>        <span class="va">self</span>.benchmark_kurse <span class="op">=</span> daten[<span class="va">self</span>.benchmark]</span>
+<span id="cb196-78"><a href="#cb196-78" aria-hidden="true" tabindex="-1"></a>        <span class="va">self</span>.renditen <span class="op">=</span> <span class="va">self</span>.kurse.pct_change().dropna()</span>
+<span id="cb196-79"><a href="#cb196-79" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb196-80"><a href="#cb196-80" aria-hidden="true" tabindex="-1"></a>        <span class="co"># --- erster HANDELStag je Monat, nicht Kalendermonatsanfang -----</span></span>
+<span id="cb196-81"><a href="#cb196-81" aria-hidden="true" tabindex="-1"></a>        monat <span class="op">=</span> <span class="va">self</span>.kurse.index.to_period(<span class="st">&quot;M&quot;</span>)</span>
+<span id="cb196-82"><a href="#cb196-82" aria-hidden="true" tabindex="-1"></a>        <span class="va">self</span>.rebalancing_termine <span class="op">=</span> <span class="va">self</span>.kurse.index[<span class="op">~</span>monat.duplicated()]</span>
+<span id="cb196-83"><a href="#cb196-83" aria-hidden="true" tabindex="-1"></a>        <span class="cf">assert</span> <span class="va">self</span>.rebalancing_termine.isin(<span class="va">self</span>.kurse.index).<span class="bu">all</span>(), <span class="op">\</span></span>
+<span id="cb196-84"><a href="#cb196-84" aria-hidden="true" tabindex="-1"></a>            <span class="st">&quot;Rebalancing-Termine sind keine Handelstage!&quot;</span></span>
+<span id="cb196-85"><a href="#cb196-85" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb196-86"><a href="#cb196-86" aria-hidden="true" tabindex="-1"></a>        <span class="bu">print</span>(<span class="ss">f&quot;  </span><span class="sc">{</span><span class="bu">len</span>(<span class="va">self</span>.kurse)<span class="sc">}</span><span class="ss"> Handelstage, &quot;</span></span>
+<span id="cb196-87"><a href="#cb196-87" aria-hidden="true" tabindex="-1"></a>              <span class="ss">f&quot;</span><span class="sc">{</span><span class="bu">len</span>(<span class="va">self</span>.rebalancing_termine)<span class="sc">}</span><span class="ss"> Rebalancing-Termine &quot;</span></span>
+<span id="cb196-88"><a href="#cb196-88" aria-hidden="true" tabindex="-1"></a>              <span class="ss">f&quot;(alle sind Handelstage)&quot;</span>)</span>
+<span id="cb196-89"><a href="#cb196-89" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb196-90"><a href="#cb196-90" aria-hidden="true" tabindex="-1"></a>    <span class="co"># -- 2. Signal --------------------------------------------------------</span></span>
+<span id="cb196-91"><a href="#cb196-91" aria-hidden="true" tabindex="-1"></a>    <span class="kw">def</span> alpha_signal(<span class="va">self</span>, stichtag, rueckblick<span class="op">=</span>HANDELSTAGE):</span>
+<span id="cb196-92"><a href="#cb196-92" aria-hidden="true" tabindex="-1"></a>        <span class="co">&quot;&quot;&quot;</span></span>
+<span id="cb196-93"><a href="#cb196-93" aria-hidden="true" tabindex="-1"></a><span class="co">        12-1-Momentum: Kursentwicklung der letzten 12 Monate unter Auslassung</span></span>
+<span id="cb196-94"><a href="#cb196-94" aria-hidden="true" tabindex="-1"></a><span class="co">        des letzten Monats (kurzfristige Umkehr herausrechnen).</span></span>
+<span id="cb196-95"><a href="#cb196-95" aria-hidden="true" tabindex="-1"></a><span class="co">        Rueckgabe: TAEGLICHE Renditeerwartung.</span></span>
+<span id="cb196-96"><a href="#cb196-96" aria-hidden="true" tabindex="-1"></a><span class="co">        &quot;&quot;&quot;</span></span>
+<span id="cb196-97"><a href="#cb196-97" aria-hidden="true" tabindex="-1"></a>        historie <span class="op">=</span> <span class="va">self</span>.kurse.loc[:stichtag]</span>
+<span id="cb196-98"><a href="#cb196-98" aria-hidden="true" tabindex="-1"></a>        <span class="cf">if</span> <span class="bu">len</span>(historie) <span class="op">&lt;</span> rueckblick:</span>
+<span id="cb196-99"><a href="#cb196-99" aria-hidden="true" tabindex="-1"></a>            <span class="cf">return</span> np.zeros(<span class="bu">len</span>(<span class="va">self</span>.universum))</span>
+<span id="cb196-100"><a href="#cb196-100" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb196-101"><a href="#cb196-101" aria-hidden="true" tabindex="-1"></a>        p_alt <span class="op">=</span> historie.iloc[<span class="op">-</span>rueckblick]</span>
+<span id="cb196-102"><a href="#cb196-102" aria-hidden="true" tabindex="-1"></a>        p_neu <span class="op">=</span> historie.iloc[<span class="op">-</span><span class="dv">21</span>]                    <span class="co"># vor ca. einem Monat</span></span>
+<span id="cb196-103"><a href="#cb196-103" aria-hidden="true" tabindex="-1"></a>        momentum <span class="op">=</span> (p_neu <span class="op">/</span> p_alt <span class="op">-</span> <span class="fl">1.0</span>).values</span>
+<span id="cb196-104"><a href="#cb196-104" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb196-105"><a href="#cb196-105" aria-hidden="true" tabindex="-1"></a>        <span class="co"># Z-Score, damit das Signal skalenfrei wird</span></span>
+<span id="cb196-106"><a href="#cb196-106" aria-hidden="true" tabindex="-1"></a>        streuung <span class="op">=</span> momentum.std()</span>
+<span id="cb196-107"><a href="#cb196-107" aria-hidden="true" tabindex="-1"></a>        score <span class="op">=</span> (momentum <span class="op">-</span> momentum.mean()) <span class="op">/</span> (streuung <span class="op">+</span> <span class="fl">1e-9</span>)</span>
+<span id="cb196-108"><a href="#cb196-108" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb196-109"><a href="#cb196-109" aria-hidden="true" tabindex="-1"></a>        <span class="co"># In eine taegliche Renditeerwartung uebersetzen:</span></span>
+<span id="cb196-110"><a href="#cb196-110" aria-hidden="true" tabindex="-1"></a>        <span class="co"># Basis 4 % p.a. plus 6 % p.a. je Standardabweichung Momentum.</span></span>
+<span id="cb196-111"><a href="#cb196-111" aria-hidden="true" tabindex="-1"></a>        mu_jaehrlich <span class="op">=</span> np.maximum(<span class="fl">0.04</span> <span class="op">+</span> <span class="fl">0.06</span> <span class="op">*</span> score, <span class="fl">0.0</span>)</span>
+<span id="cb196-112"><a href="#cb196-112" aria-hidden="true" tabindex="-1"></a>        <span class="cf">return</span> mu_jaehrlich <span class="op">/</span> HANDELSTAGE</span>
+<span id="cb196-113"><a href="#cb196-113" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb196-114"><a href="#cb196-114" aria-hidden="true" tabindex="-1"></a>    <span class="co"># -- 3./4. Risikomodell und Optimierung -------------------------------</span></span>
+<span id="cb196-115"><a href="#cb196-115" aria-hidden="true" tabindex="-1"></a>    <span class="kw">def</span> optimiere(<span class="va">self</span>, stichtag, w_alt, rueckblick<span class="op">=</span>HANDELSTAGE):</span>
+<span id="cb196-116"><a href="#cb196-116" aria-hidden="true" tabindex="-1"></a>        historie <span class="op">=</span> <span class="va">self</span>.renditen.loc[:stichtag].iloc[<span class="op">-</span>rueckblick:]</span>
+<span id="cb196-117"><a href="#cb196-117" aria-hidden="true" tabindex="-1"></a>        <span class="cf">if</span> <span class="bu">len</span>(historie) <span class="op">&lt;</span> <span class="dv">100</span>:</span>
+<span id="cb196-118"><a href="#cb196-118" aria-hidden="true" tabindex="-1"></a>            <span class="cf">return</span> w_alt, <span class="va">False</span></span>
+<span id="cb196-119"><a href="#cb196-119" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb196-120"><a href="#cb196-120" aria-hidden="true" tabindex="-1"></a>        R <span class="op">=</span> historie.values</span>
+<span id="cb196-121"><a href="#cb196-121" aria-hidden="true" tabindex="-1"></a>        S, N <span class="op">=</span> R.shape</span>
+<span id="cb196-122"><a href="#cb196-122" aria-hidden="true" tabindex="-1"></a>        mu_taeglich <span class="op">=</span> <span class="va">self</span>.alpha_signal(stichtag, rueckblick)</span>
+<span id="cb196-123"><a href="#cb196-123" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb196-124"><a href="#cb196-124" aria-hidden="true" tabindex="-1"></a>        w <span class="op">=</span> cp.Variable(N, nonneg<span class="op">=</span><span class="va">True</span>)</span>
+<span id="cb196-125"><a href="#cb196-125" aria-hidden="true" tabindex="-1"></a>        gamma <span class="op">=</span> cp.Variable()</span>
+<span id="cb196-126"><a href="#cb196-126" aria-hidden="true" tabindex="-1"></a>        u <span class="op">=</span> cp.Variable(S, nonneg<span class="op">=</span><span class="va">True</span>)</span>
+<span id="cb196-127"><a href="#cb196-127" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb196-128"><a href="#cb196-128" aria-hidden="true" tabindex="-1"></a>        cvar <span class="op">=</span> gamma <span class="op">+</span> (<span class="fl">1.0</span> <span class="op">/</span> (S <span class="op">*</span> (<span class="fl">1.0</span> <span class="op">-</span> <span class="va">self</span>.alpha))) <span class="op">*</span> cp.<span class="bu">sum</span>(u)</span>
+<span id="cb196-129"><a href="#cb196-129" aria-hidden="true" tabindex="-1"></a>        kosten <span class="op">=</span> <span class="va">self</span>.gebuehrensatz <span class="op">*</span> cp.norm1(w <span class="op">-</span> w_alt)</span>
+<span id="cb196-130"><a href="#cb196-130" aria-hidden="true" tabindex="-1"></a>        ziel <span class="op">=</span> cp.Maximize(mu_taeglich <span class="op">@</span> w <span class="op">-</span> <span class="va">self</span>.risikoaversion <span class="op">*</span> cvar <span class="op">-</span> kosten)</span>
+<span id="cb196-131"><a href="#cb196-131" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb196-132"><a href="#cb196-132" aria-hidden="true" tabindex="-1"></a>        bedingungen <span class="op">=</span> [cp.<span class="bu">sum</span>(w) <span class="op">==</span> <span class="dv">1</span>,</span>
+<span id="cb196-133"><a href="#cb196-133" aria-hidden="true" tabindex="-1"></a>                       w <span class="op">&lt;=</span> <span class="va">self</span>.max_gewicht,</span>
+<span id="cb196-134"><a href="#cb196-134" aria-hidden="true" tabindex="-1"></a>                       u <span class="op">&gt;=</span> <span class="op">-</span>(R <span class="op">@</span> w) <span class="op">-</span> gamma]          <span class="co"># vektorisiert</span></span>
+<span id="cb196-135"><a href="#cb196-135" aria-hidden="true" tabindex="-1"></a>        problem <span class="op">=</span> cp.Problem(ziel, bedingungen)</span>
+<span id="cb196-136"><a href="#cb196-136" aria-hidden="true" tabindex="-1"></a>        <span class="cf">try</span>:</span>
+<span id="cb196-137"><a href="#cb196-137" aria-hidden="true" tabindex="-1"></a>            problem.solve(solver<span class="op">=</span>cp.CLARABEL)</span>
+<span id="cb196-138"><a href="#cb196-138" aria-hidden="true" tabindex="-1"></a>        <span class="cf">except</span> cp.error.SolverError:</span>
+<span id="cb196-139"><a href="#cb196-139" aria-hidden="true" tabindex="-1"></a>            <span class="cf">return</span> w_alt, <span class="va">False</span></span>
+<span id="cb196-140"><a href="#cb196-140" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb196-141"><a href="#cb196-141" aria-hidden="true" tabindex="-1"></a>        <span class="cf">if</span> problem.status <span class="kw">not</span> <span class="kw">in</span> (<span class="st">&quot;optimal&quot;</span>, <span class="st">&quot;optimal_inaccurate&quot;</span>) <span class="kw">or</span> w.value <span class="kw">is</span> <span class="va">None</span>:</span>
+<span id="cb196-142"><a href="#cb196-142" aria-hidden="true" tabindex="-1"></a>            <span class="cf">return</span> w_alt, <span class="va">False</span></span>
+<span id="cb196-143"><a href="#cb196-143" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb196-144"><a href="#cb196-144" aria-hidden="true" tabindex="-1"></a>        gewichte <span class="op">=</span> np.maximum(w.value, <span class="fl">0.0</span>)</span>
+<span id="cb196-145"><a href="#cb196-145" aria-hidden="true" tabindex="-1"></a>        <span class="cf">return</span> gewichte <span class="op">/</span> gewichte.<span class="bu">sum</span>(), <span class="va">True</span></span>
+<span id="cb196-146"><a href="#cb196-146" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb196-147"><a href="#cb196-147" aria-hidden="true" tabindex="-1"></a>    <span class="co"># -- 5. Backtest -------------------------------------------------------</span></span>
+<span id="cb196-148"><a href="#cb196-148" aria-hidden="true" tabindex="-1"></a>    <span class="kw">def</span> backtest(<span class="va">self</span>):</span>
+<span id="cb196-149"><a href="#cb196-149" aria-hidden="true" tabindex="-1"></a>        <span class="bu">print</span>(<span class="st">&quot;Starte Walk-Forward-Backtest ...&quot;</span>)</span>
+<span id="cb196-150"><a href="#cb196-150" aria-hidden="true" tabindex="-1"></a>        N <span class="op">=</span> <span class="bu">len</span>(<span class="va">self</span>.universum)</span>
+<span id="cb196-151"><a href="#cb196-151" aria-hidden="true" tabindex="-1"></a>        gewichte <span class="op">=</span> np.ones(N) <span class="op">/</span> N</span>
+<span id="cb196-152"><a href="#cb196-152" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb196-153"><a href="#cb196-153" aria-hidden="true" tabindex="-1"></a>        werte <span class="op">=</span> [<span class="va">self</span>.startkapital]</span>
+<span id="cb196-154"><a href="#cb196-154" aria-hidden="true" tabindex="-1"></a>        datumsliste <span class="op">=</span> [<span class="va">self</span>.renditen.index[<span class="va">self</span>.warmup]]</span>
+<span id="cb196-155"><a href="#cb196-155" aria-hidden="true" tabindex="-1"></a>        gewichtshistorie <span class="op">=</span> []</span>
+<span id="cb196-156"><a href="#cb196-156" aria-hidden="true" tabindex="-1"></a>        geplant <span class="op">=</span> versucht <span class="op">=</span> ausgefuehrt <span class="op">=</span> <span class="dv">0</span></span>
+<span id="cb196-157"><a href="#cb196-157" aria-hidden="true" tabindex="-1"></a>        kosten_gesamt <span class="op">=</span> <span class="fl">0.0</span></span>
+<span id="cb196-158"><a href="#cb196-158" aria-hidden="true" tabindex="-1"></a>        turnover_gesamt <span class="op">=</span> <span class="fl">0.0</span></span>
+<span id="cb196-159"><a href="#cb196-159" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb196-160"><a href="#cb196-160" aria-hidden="true" tabindex="-1"></a>        <span class="cf">for</span> t <span class="kw">in</span> <span class="bu">range</span>(<span class="va">self</span>.warmup, <span class="bu">len</span>(<span class="va">self</span>.renditen) <span class="op">-</span> <span class="dv">1</span>):</span>
+<span id="cb196-161"><a href="#cb196-161" aria-hidden="true" tabindex="-1"></a>            heute <span class="op">=</span> <span class="va">self</span>.renditen.index[t]</span>
+<span id="cb196-162"><a href="#cb196-162" aria-hidden="true" tabindex="-1"></a>            morgen <span class="op">=</span> <span class="va">self</span>.renditen.index[t <span class="op">+</span> <span class="dv">1</span>]</span>
+<span id="cb196-163"><a href="#cb196-163" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb196-164"><a href="#cb196-164" aria-hidden="true" tabindex="-1"></a>            ist_termin <span class="op">=</span> heute <span class="kw">in</span> <span class="va">self</span>.rebalancing_termine <span class="kw">or</span> t <span class="op">==</span> <span class="va">self</span>.warmup</span>
+<span id="cb196-165"><a href="#cb196-165" aria-hidden="true" tabindex="-1"></a>            <span class="cf">if</span> ist_termin:</span>
+<span id="cb196-166"><a href="#cb196-166" aria-hidden="true" tabindex="-1"></a>                geplant <span class="op">+=</span> <span class="dv">1</span></span>
+<span id="cb196-167"><a href="#cb196-167" aria-hidden="true" tabindex="-1"></a>                versucht <span class="op">+=</span> <span class="dv">1</span></span>
+<span id="cb196-168"><a href="#cb196-168" aria-hidden="true" tabindex="-1"></a>                neue_gewichte, erfolg <span class="op">=</span> <span class="va">self</span>.optimiere(heute, gewichte)</span>
+<span id="cb196-169"><a href="#cb196-169" aria-hidden="true" tabindex="-1"></a>                <span class="cf">if</span> erfolg:</span>
+<span id="cb196-170"><a href="#cb196-170" aria-hidden="true" tabindex="-1"></a>                    ausgefuehrt <span class="op">+=</span> <span class="dv">1</span></span>
+<span id="cb196-171"><a href="#cb196-171" aria-hidden="true" tabindex="-1"></a>                    turnover <span class="op">=</span> <span class="bu">float</span>(np.<span class="bu">abs</span>(neue_gewichte <span class="op">-</span> gewichte).<span class="bu">sum</span>())</span>
+<span id="cb196-172"><a href="#cb196-172" aria-hidden="true" tabindex="-1"></a>                    gebuehr <span class="op">=</span> werte[<span class="op">-</span><span class="dv">1</span>] <span class="op">*</span> turnover <span class="op">*</span> <span class="va">self</span>.gebuehrensatz</span>
+<span id="cb196-173"><a href="#cb196-173" aria-hidden="true" tabindex="-1"></a>                    werte[<span class="op">-</span><span class="dv">1</span>] <span class="op">-=</span> gebuehr</span>
+<span id="cb196-174"><a href="#cb196-174" aria-hidden="true" tabindex="-1"></a>                    kosten_gesamt <span class="op">+=</span> gebuehr</span>
+<span id="cb196-175"><a href="#cb196-175" aria-hidden="true" tabindex="-1"></a>                    turnover_gesamt <span class="op">+=</span> turnover</span>
+<span id="cb196-176"><a href="#cb196-176" aria-hidden="true" tabindex="-1"></a>                    gewichte <span class="op">=</span> neue_gewichte</span>
+<span id="cb196-177"><a href="#cb196-177" aria-hidden="true" tabindex="-1"></a>                    gewichtshistorie.append((heute, gewichte.copy()))</span>
+<span id="cb196-178"><a href="#cb196-178" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb196-179"><a href="#cb196-179" aria-hidden="true" tabindex="-1"></a>            <span class="co"># Rendite von MORGEN auf die HEUTE festgelegten Gewichte anwenden</span></span>
+<span id="cb196-180"><a href="#cb196-180" aria-hidden="true" tabindex="-1"></a>            tagesrenditen <span class="op">=</span> <span class="va">self</span>.renditen.iloc[t <span class="op">+</span> <span class="dv">1</span>].values</span>
+<span id="cb196-181"><a href="#cb196-181" aria-hidden="true" tabindex="-1"></a>            portfoliorendite <span class="op">=</span> <span class="bu">float</span>(gewichte <span class="op">@</span> tagesrenditen)</span>
+<span id="cb196-182"><a href="#cb196-182" aria-hidden="true" tabindex="-1"></a>            werte.append(werte[<span class="op">-</span><span class="dv">1</span>] <span class="op">*</span> (<span class="fl">1.0</span> <span class="op">+</span> portfoliorendite))</span>
+<span id="cb196-183"><a href="#cb196-183" aria-hidden="true" tabindex="-1"></a>            datumsliste.append(morgen)</span>
+<span id="cb196-184"><a href="#cb196-184" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb196-185"><a href="#cb196-185" aria-hidden="true" tabindex="-1"></a>            <span class="co"># Gewichte driften mit den Kursen weiter</span></span>
+<span id="cb196-186"><a href="#cb196-186" aria-hidden="true" tabindex="-1"></a>            gedriftet <span class="op">=</span> gewichte <span class="op">*</span> (<span class="fl">1.0</span> <span class="op">+</span> tagesrenditen)</span>
+<span id="cb196-187"><a href="#cb196-187" aria-hidden="true" tabindex="-1"></a>            gewichte <span class="op">=</span> gedriftet <span class="op">/</span> gedriftet.<span class="bu">sum</span>()</span>
+<span id="cb196-188"><a href="#cb196-188" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb196-189"><a href="#cb196-189" aria-hidden="true" tabindex="-1"></a>        <span class="bu">print</span>(<span class="ss">f&quot;  Rebalancing: </span><span class="sc">{</span>geplant<span class="sc">}</span><span class="ss"> geplant, </span><span class="sc">{</span>ausgefuehrt<span class="sc">}</span><span class="ss"> ausgefuehrt &quot;</span></span>
+<span id="cb196-190"><a href="#cb196-190" aria-hidden="true" tabindex="-1"></a>              <span class="ss">f&quot;(</span><span class="sc">{</span>ausgefuehrt<span class="op">/</span><span class="bu">max</span>(geplant,<span class="dv">1</span>)<span class="op">*</span><span class="dv">100</span><span class="sc">:.0f}</span><span class="ss"> %)&quot;</span>)</span>
+<span id="cb196-191"><a href="#cb196-191" aria-hidden="true" tabindex="-1"></a>        <span class="cf">if</span> ausgefuehrt <span class="op">&lt;</span> geplant:</span>
+<span id="cb196-192"><a href="#cb196-192" aria-hidden="true" tabindex="-1"></a>            <span class="bu">print</span>(<span class="ss">f&quot;  WARNUNG: </span><span class="sc">{</span>geplant <span class="op">-</span> ausgefuehrt<span class="sc">}</span><span class="ss"> Optimierungen sind &quot;</span></span>
+<span id="cb196-193"><a href="#cb196-193" aria-hidden="true" tabindex="-1"></a>                  <span class="ss">f&quot;fehlgeschlagen - Ursache pruefen!&quot;</span>)</span>
+<span id="cb196-194"><a href="#cb196-194" aria-hidden="true" tabindex="-1"></a>        <span class="bu">print</span>(<span class="ss">f&quot;  Kumulierter Turnover: </span><span class="sc">{</span>turnover_gesamt<span class="op">*</span><span class="dv">100</span><span class="sc">:.0f}</span><span class="ss"> % | &quot;</span></span>
+<span id="cb196-195"><a href="#cb196-195" aria-hidden="true" tabindex="-1"></a>              <span class="ss">f&quot;Transaktionskosten insgesamt: </span><span class="sc">{</span>kosten_gesamt<span class="sc">:,.2f}</span><span class="ss"> EUR&quot;</span>)</span>
+<span id="cb196-196"><a href="#cb196-196" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb196-197"><a href="#cb196-197" aria-hidden="true" tabindex="-1"></a>        ergebnis <span class="op">=</span> pd.DataFrame({<span class="st">&quot;Portfolio&quot;</span>: werte}, index<span class="op">=</span>datumsliste)</span>
+<span id="cb196-198"><a href="#cb196-198" aria-hidden="true" tabindex="-1"></a>        benchmark <span class="op">=</span> <span class="va">self</span>.benchmark_kurse.loc[datumsliste]</span>
+<span id="cb196-199"><a href="#cb196-199" aria-hidden="true" tabindex="-1"></a>        ergebnis[<span class="st">&quot;Benchmark&quot;</span>] <span class="op">=</span> benchmark <span class="op">/</span> benchmark.iloc[<span class="dv">0</span>] <span class="op">*</span> <span class="va">self</span>.startkapital</span>
+<span id="cb196-200"><a href="#cb196-200" aria-hidden="true" tabindex="-1"></a>        <span class="cf">return</span> ergebnis, gewichtshistorie, kosten_gesamt</span>
+<span id="cb196-201"><a href="#cb196-201" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb196-202"><a href="#cb196-202" aria-hidden="true" tabindex="-1"></a>    <span class="co"># -- 6. Auswertung -----------------------------------------------------</span></span>
+<span id="cb196-203"><a href="#cb196-203" aria-hidden="true" tabindex="-1"></a>    <span class="at">@staticmethod</span></span>
+<span id="cb196-204"><a href="#cb196-204" aria-hidden="true" tabindex="-1"></a>    <span class="kw">def</span> kennzahlen(reihe, risikofrei<span class="op">=</span><span class="fl">0.02</span>):</span>
+<span id="cb196-205"><a href="#cb196-205" aria-hidden="true" tabindex="-1"></a>        renditen <span class="op">=</span> reihe.pct_change().dropna()</span>
+<span id="cb196-206"><a href="#cb196-206" aria-hidden="true" tabindex="-1"></a>        jahre <span class="op">=</span> (reihe.index[<span class="op">-</span><span class="dv">1</span>] <span class="op">-</span> reihe.index[<span class="dv">0</span>]).days <span class="op">/</span> <span class="fl">365.25</span></span>
+<span id="cb196-207"><a href="#cb196-207" aria-hidden="true" tabindex="-1"></a>        cagr <span class="op">=</span> (reihe.iloc[<span class="op">-</span><span class="dv">1</span>] <span class="op">/</span> reihe.iloc[<span class="dv">0</span>]) <span class="op">**</span> (<span class="dv">1</span> <span class="op">/</span> jahre) <span class="op">-</span> <span class="dv">1</span></span>
+<span id="cb196-208"><a href="#cb196-208" aria-hidden="true" tabindex="-1"></a>        vola <span class="op">=</span> renditen.std() <span class="op">*</span> np.sqrt(HANDELSTAGE)</span>
+<span id="cb196-209"><a href="#cb196-209" aria-hidden="true" tabindex="-1"></a>        sharpe <span class="op">=</span> (cagr <span class="op">-</span> risikofrei) <span class="op">/</span> vola <span class="cf">if</span> vola <span class="op">&gt;</span> <span class="dv">0</span> <span class="cf">else</span> np.nan</span>
+<span id="cb196-210"><a href="#cb196-210" aria-hidden="true" tabindex="-1"></a>        drawdown <span class="op">=</span> ((reihe <span class="op">-</span> reihe.cummax()) <span class="op">/</span> reihe.cummax()).<span class="bu">min</span>()</span>
+<span id="cb196-211"><a href="#cb196-211" aria-hidden="true" tabindex="-1"></a>        calmar <span class="op">=</span> cagr <span class="op">/</span> <span class="bu">abs</span>(drawdown) <span class="cf">if</span> drawdown <span class="op">&lt;</span> <span class="dv">0</span> <span class="cf">else</span> np.nan</span>
+<span id="cb196-212"><a href="#cb196-212" aria-hidden="true" tabindex="-1"></a>        trefferquote <span class="op">=</span> <span class="bu">float</span>((renditen <span class="op">&gt;</span> <span class="dv">0</span>).mean())</span>
+<span id="cb196-213"><a href="#cb196-213" aria-hidden="true" tabindex="-1"></a>        <span class="cf">return</span> {<span class="st">&quot;CAGR&quot;</span>: cagr, <span class="st">&quot;Volatilitaet&quot;</span>: vola, <span class="st">&quot;Sharpe&quot;</span>: sharpe,</span>
+<span id="cb196-214"><a href="#cb196-214" aria-hidden="true" tabindex="-1"></a>                <span class="st">&quot;Max Drawdown&quot;</span>: drawdown, <span class="st">&quot;Calmar&quot;</span>: calmar,</span>
+<span id="cb196-215"><a href="#cb196-215" aria-hidden="true" tabindex="-1"></a>                <span class="st">&quot;Trefferquote&quot;</span>: trefferquote, <span class="st">&quot;Jahre&quot;</span>: jahre}</span>
+<span id="cb196-216"><a href="#cb196-216" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb196-217"><a href="#cb196-217" aria-hidden="true" tabindex="-1"></a>    <span class="kw">def</span> bericht(<span class="va">self</span>, ergebnis, kosten_gesamt):</span>
+<span id="cb196-218"><a href="#cb196-218" aria-hidden="true" tabindex="-1"></a>        k_port <span class="op">=</span> <span class="va">self</span>.kennzahlen(ergebnis[<span class="st">&quot;Portfolio&quot;</span>])</span>
+<span id="cb196-219"><a href="#cb196-219" aria-hidden="true" tabindex="-1"></a>        k_bench <span class="op">=</span> <span class="va">self</span>.kennzahlen(ergebnis[<span class="st">&quot;Benchmark&quot;</span>])</span>
+<span id="cb196-220"><a href="#cb196-220" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb196-221"><a href="#cb196-221" aria-hidden="true" tabindex="-1"></a>        <span class="bu">print</span>(<span class="st">&quot;</span><span class="ch">\n</span><span class="st">&quot;</span> <span class="op">+</span> <span class="st">&quot;=&quot;</span> <span class="op">*</span> <span class="dv">84</span>)</span>
+<span id="cb196-222"><a href="#cb196-222" aria-hidden="true" tabindex="-1"></a>        <span class="bu">print</span>(<span class="st">&quot;          LEISTUNGSREPORT DER QUANTITATIVEN ENGINE&quot;</span>)</span>
+<span id="cb196-223"><a href="#cb196-223" aria-hidden="true" tabindex="-1"></a>        <span class="bu">print</span>(<span class="st">&quot;=&quot;</span> <span class="op">*</span> <span class="dv">84</span>)</span>
+<span id="cb196-224"><a href="#cb196-224" aria-hidden="true" tabindex="-1"></a>        <span class="bu">print</span>(<span class="ss">f&quot;Zeitraum: </span><span class="sc">{</span>ergebnis<span class="sc">.</span>index[<span class="dv">0</span>]<span class="sc">:</span><span class="op">%</span>Y<span class="op">-%</span>m<span class="op">-%</span>d<span class="sc">}</span><span class="ss"> bis </span><span class="sc">{</span>ergebnis<span class="sc">.</span>index[<span class="op">-</span><span class="dv">1</span>]<span class="sc">:</span><span class="op">%</span>Y<span class="op">-%</span>m<span class="op">-%</span>d<span class="sc">}</span><span class="ss"> &quot;</span></span>
+<span id="cb196-225"><a href="#cb196-225" aria-hidden="true" tabindex="-1"></a>              <span class="ss">f&quot;(</span><span class="sc">{</span>k_port[<span class="st">&#39;Jahre&#39;</span>]<span class="sc">:.1f}</span><span class="ss"> Jahre) | Startkapital &quot;</span></span>
+<span id="cb196-226"><a href="#cb196-226" aria-hidden="true" tabindex="-1"></a>              <span class="ss">f&quot;</span><span class="sc">{</span><span class="va">self</span><span class="sc">.</span>startkapital<span class="sc">:,.0f}</span><span class="ss"> EUR</span><span class="ch">\n</span><span class="ss">&quot;</span>)</span>
+<span id="cb196-227"><a href="#cb196-227" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb196-228"><a href="#cb196-228" aria-hidden="true" tabindex="-1"></a>        zeilen <span class="op">=</span> [</span>
+<span id="cb196-229"><a href="#cb196-229" aria-hidden="true" tabindex="-1"></a>            (<span class="st">&quot;Endkapital&quot;</span>, <span class="ss">f&quot;</span><span class="sc">{</span>ergebnis[<span class="st">&#39;Portfolio&#39;</span>]<span class="sc">.</span>iloc[<span class="op">-</span><span class="dv">1</span>]<span class="sc">:,.0f}</span><span class="ss"> EUR&quot;</span>,</span>
+<span id="cb196-230"><a href="#cb196-230" aria-hidden="true" tabindex="-1"></a>             <span class="ss">f&quot;</span><span class="sc">{</span>ergebnis[<span class="st">&#39;Benchmark&#39;</span>]<span class="sc">.</span>iloc[<span class="op">-</span><span class="dv">1</span>]<span class="sc">:,.0f}</span><span class="ss"> EUR&quot;</span>),</span>
+<span id="cb196-231"><a href="#cb196-231" aria-hidden="true" tabindex="-1"></a>            (<span class="st">&quot;CAGR (Jahresrendite)&quot;</span>, <span class="ss">f&quot;</span><span class="sc">{</span>k_port[<span class="st">&#39;CAGR&#39;</span>]<span class="op">*</span><span class="dv">100</span><span class="sc">:6.2f}</span><span class="ss"> %&quot;</span>,</span>
+<span id="cb196-232"><a href="#cb196-232" aria-hidden="true" tabindex="-1"></a>             <span class="ss">f&quot;</span><span class="sc">{</span>k_bench[<span class="st">&#39;CAGR&#39;</span>]<span class="op">*</span><span class="dv">100</span><span class="sc">:6.2f}</span><span class="ss"> %&quot;</span>),</span>
+<span id="cb196-233"><a href="#cb196-233" aria-hidden="true" tabindex="-1"></a>            (<span class="st">&quot;Volatilitaet p.a.&quot;</span>, <span class="ss">f&quot;</span><span class="sc">{</span>k_port[<span class="st">&#39;Volatilitaet&#39;</span>]<span class="op">*</span><span class="dv">100</span><span class="sc">:6.2f}</span><span class="ss"> %&quot;</span>,</span>
+<span id="cb196-234"><a href="#cb196-234" aria-hidden="true" tabindex="-1"></a>             <span class="ss">f&quot;</span><span class="sc">{</span>k_bench[<span class="st">&#39;Volatilitaet&#39;</span>]<span class="op">*</span><span class="dv">100</span><span class="sc">:6.2f}</span><span class="ss"> %&quot;</span>),</span>
+<span id="cb196-235"><a href="#cb196-235" aria-hidden="true" tabindex="-1"></a>            (<span class="st">&quot;Sharpe Ratio (rf=2 %)&quot;</span>, <span class="ss">f&quot;</span><span class="sc">{</span>k_port[<span class="st">&#39;Sharpe&#39;</span>]<span class="sc">:6.2f}</span><span class="ss">&quot;</span>,</span>
+<span id="cb196-236"><a href="#cb196-236" aria-hidden="true" tabindex="-1"></a>             <span class="ss">f&quot;</span><span class="sc">{</span>k_bench[<span class="st">&#39;Sharpe&#39;</span>]<span class="sc">:6.2f}</span><span class="ss">&quot;</span>),</span>
+<span id="cb196-237"><a href="#cb196-237" aria-hidden="true" tabindex="-1"></a>            (<span class="st">&quot;Maximum Drawdown&quot;</span>, <span class="ss">f&quot;</span><span class="sc">{</span>k_port[<span class="st">&#39;Max Drawdown&#39;</span>]<span class="op">*</span><span class="dv">100</span><span class="sc">:6.2f}</span><span class="ss"> %&quot;</span>,</span>
+<span id="cb196-238"><a href="#cb196-238" aria-hidden="true" tabindex="-1"></a>             <span class="ss">f&quot;</span><span class="sc">{</span>k_bench[<span class="st">&#39;Max Drawdown&#39;</span>]<span class="op">*</span><span class="dv">100</span><span class="sc">:6.2f}</span><span class="ss"> %&quot;</span>),</span>
+<span id="cb196-239"><a href="#cb196-239" aria-hidden="true" tabindex="-1"></a>            (<span class="st">&quot;Calmar Ratio&quot;</span>, <span class="ss">f&quot;</span><span class="sc">{</span>k_port[<span class="st">&#39;Calmar&#39;</span>]<span class="sc">:6.2f}</span><span class="ss">&quot;</span>, <span class="ss">f&quot;</span><span class="sc">{</span>k_bench[<span class="st">&#39;Calmar&#39;</span>]<span class="sc">:6.2f}</span><span class="ss">&quot;</span>),</span>
+<span id="cb196-240"><a href="#cb196-240" aria-hidden="true" tabindex="-1"></a>            (<span class="st">&quot;Trefferquote (Tage)&quot;</span>, <span class="ss">f&quot;</span><span class="sc">{</span>k_port[<span class="st">&#39;Trefferquote&#39;</span>]<span class="op">*</span><span class="dv">100</span><span class="sc">:6.1f}</span><span class="ss"> %&quot;</span>,</span>
+<span id="cb196-241"><a href="#cb196-241" aria-hidden="true" tabindex="-1"></a>             <span class="ss">f&quot;</span><span class="sc">{</span>k_bench[<span class="st">&#39;Trefferquote&#39;</span>]<span class="op">*</span><span class="dv">100</span><span class="sc">:6.1f}</span><span class="ss"> %&quot;</span>),</span>
+<span id="cb196-242"><a href="#cb196-242" aria-hidden="true" tabindex="-1"></a>        ]</span>
+<span id="cb196-243"><a href="#cb196-243" aria-hidden="true" tabindex="-1"></a>        <span class="bu">print</span>(pd.DataFrame(zeilen, columns<span class="op">=</span>[<span class="st">&quot;Kennzahl&quot;</span>, <span class="st">&quot;OR-Strategie&quot;</span>, <span class="st">&quot;Benchmark&quot;</span>])</span>
+<span id="cb196-244"><a href="#cb196-244" aria-hidden="true" tabindex="-1"></a>              .to_string(index<span class="op">=</span><span class="va">False</span>))</span>
+<span id="cb196-245"><a href="#cb196-245" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb196-246"><a href="#cb196-246" aria-hidden="true" tabindex="-1"></a>        anteil <span class="op">=</span> kosten_gesamt <span class="op">/</span> <span class="va">self</span>.startkapital</span>
+<span id="cb196-247"><a href="#cb196-247" aria-hidden="true" tabindex="-1"></a>        <span class="bu">print</span>(<span class="ss">f&quot;</span><span class="ch">\n</span><span class="ss">Transaktionskosten: </span><span class="sc">{</span>kosten_gesamt<span class="sc">:,.0f}</span><span class="ss"> EUR &quot;</span></span>
+<span id="cb196-248"><a href="#cb196-248" aria-hidden="true" tabindex="-1"></a>              <span class="ss">f&quot;= </span><span class="sc">{</span>anteil<span class="op">*</span><span class="dv">100</span><span class="sc">:.2f}</span><span class="ss"> % des Startkapitals &quot;</span></span>
+<span id="cb196-249"><a href="#cb196-249" aria-hidden="true" tabindex="-1"></a>              <span class="ss">f&quot;= </span><span class="sc">{</span>anteil<span class="op">/</span>k_port[<span class="st">&#39;Jahre&#39;</span>]<span class="op">*</span><span class="dv">100</span><span class="sc">:.2f}</span><span class="ss"> % p.a.&quot;</span>)</span>
+<span id="cb196-250"><a href="#cb196-250" aria-hidden="true" tabindex="-1"></a>        <span class="bu">print</span>(<span class="st">&quot;Ohne diese Kosten waere die ausgewiesene Rendite entsprechend hoeher -&quot;</span>)</span>
+<span id="cb196-251"><a href="#cb196-251" aria-hidden="true" tabindex="-1"></a>        <span class="bu">print</span>(<span class="st">&quot;genau deshalb gehoeren sie in den Backtest und nicht daneben.&quot;</span>)</span>
+<span id="cb196-252"><a href="#cb196-252" aria-hidden="true" tabindex="-1"></a>        <span class="bu">print</span>(<span class="st">&quot;=&quot;</span> <span class="op">*</span> <span class="dv">84</span>)</span>
+<span id="cb196-253"><a href="#cb196-253" aria-hidden="true" tabindex="-1"></a>        <span class="cf">return</span> k_port, k_bench</span>
+<span id="cb196-254"><a href="#cb196-254" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb196-255"><a href="#cb196-255" aria-hidden="true" tabindex="-1"></a>    <span class="kw">def</span> zeichne(<span class="va">self</span>, ergebnis):</span>
+<span id="cb196-256"><a href="#cb196-256" aria-hidden="true" tabindex="-1"></a>        plt.figure(figsize<span class="op">=</span>(<span class="dv">11</span>, <span class="dv">6</span>))</span>
+<span id="cb196-257"><a href="#cb196-257" aria-hidden="true" tabindex="-1"></a>        plt.plot(ergebnis.index, ergebnis[<span class="st">&quot;Portfolio&quot;</span>], <span class="st">&quot;b-&quot;</span>, lw<span class="op">=</span><span class="fl">2.2</span>,</span>
+<span id="cb196-258"><a href="#cb196-258" aria-hidden="true" tabindex="-1"></a>                 label<span class="op">=</span><span class="st">&quot;OR-Handelsmaschine&quot;</span>)</span>
+<span id="cb196-259"><a href="#cb196-259" aria-hidden="true" tabindex="-1"></a>        plt.plot(ergebnis.index, ergebnis[<span class="st">&quot;Benchmark&quot;</span>], <span class="st">&quot;k--&quot;</span>, lw<span class="op">=</span><span class="fl">1.5</span>, alpha<span class="op">=</span><span class="fl">0.75</span>,</span>
+<span id="cb196-260"><a href="#cb196-260" aria-hidden="true" tabindex="-1"></a>                 label<span class="op">=</span><span class="ss">f&quot;Benchmark (</span><span class="sc">{</span><span class="va">self</span><span class="sc">.</span>benchmark<span class="sc">}</span><span class="ss">)&quot;</span>)</span>
+<span id="cb196-261"><a href="#cb196-261" aria-hidden="true" tabindex="-1"></a>        plt.title(<span class="st">&quot;Walk-Forward-Backtest: OR-Strategie gegen Benchmark&quot;</span>, fontsize<span class="op">=</span><span class="dv">12</span>)</span>
+<span id="cb196-262"><a href="#cb196-262" aria-hidden="true" tabindex="-1"></a>        plt.xlabel(<span class="st">&quot;Datum&quot;</span>)</span>
+<span id="cb196-263"><a href="#cb196-263" aria-hidden="true" tabindex="-1"></a>        plt.ylabel(<span class="st">&quot;Depotwert in EUR&quot;</span>)</span>
+<span id="cb196-264"><a href="#cb196-264" aria-hidden="true" tabindex="-1"></a>        plt.grid(<span class="va">True</span>, linestyle<span class="op">=</span><span class="st">&quot;:&quot;</span>, alpha<span class="op">=</span><span class="fl">0.6</span>)</span>
+<span id="cb196-265"><a href="#cb196-265" aria-hidden="true" tabindex="-1"></a>        plt.legend(loc<span class="op">=</span><span class="st">&quot;upper left&quot;</span>)</span>
+<span id="cb196-266"><a href="#cb196-266" aria-hidden="true" tabindex="-1"></a>        plt.tight_layout()</span>
+<span id="cb196-267"><a href="#cb196-267" aria-hidden="true" tabindex="-1"></a>        ziel <span class="op">=</span> os.path.join(OUTPUT_DIR, <span class="st">&quot;trading_engine_backtest.png&quot;</span>)</span>
+<span id="cb196-268"><a href="#cb196-268" aria-hidden="true" tabindex="-1"></a>        plt.savefig(ziel, dpi<span class="op">=</span><span class="dv">150</span>)</span>
+<span id="cb196-269"><a href="#cb196-269" aria-hidden="true" tabindex="-1"></a>        <span class="bu">print</span>(<span class="ss">f&quot;Chart gespeichert unter &#39;</span><span class="sc">{</span>ziel<span class="sc">}</span><span class="ss">&#39;&quot;</span>)</span>
+<span id="cb196-270"><a href="#cb196-270" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb196-271"><a href="#cb196-271" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb196-272"><a href="#cb196-272" aria-hidden="true" tabindex="-1"></a><span class="kw">def</span> lookahead_selbsttest(maschine):</span>
+<span id="cb196-273"><a href="#cb196-273" aria-hidden="true" tabindex="-1"></a>    <span class="co">&quot;&quot;&quot;</span></span>
+<span id="cb196-274"><a href="#cb196-274" aria-hidden="true" tabindex="-1"></a><span class="co">    Prueft, dass das Signal zum Zeitpunkt t NUR Daten bis t verwendet.</span></span>
+<span id="cb196-275"><a href="#cb196-275" aria-hidden="true" tabindex="-1"></a><span class="co">    Methode: kuenstlich die Zukunft veraendern und pruefen, ob sich das</span></span>
+<span id="cb196-276"><a href="#cb196-276" aria-hidden="true" tabindex="-1"></a><span class="co">    Signal von heute dadurch aendert. Tut es das, liegt Lookahead vor.</span></span>
+<span id="cb196-277"><a href="#cb196-277" aria-hidden="true" tabindex="-1"></a><span class="co">    &quot;&quot;&quot;</span></span>
+<span id="cb196-278"><a href="#cb196-278" aria-hidden="true" tabindex="-1"></a>    stichtag <span class="op">=</span> maschine.kurse.index[<span class="bu">len</span>(maschine.kurse) <span class="op">//</span> <span class="dv">2</span>]</span>
+<span id="cb196-279"><a href="#cb196-279" aria-hidden="true" tabindex="-1"></a>    signal_original <span class="op">=</span> maschine.alpha_signal(stichtag)</span>
+<span id="cb196-280"><a href="#cb196-280" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb196-281"><a href="#cb196-281" aria-hidden="true" tabindex="-1"></a>    original_kurse <span class="op">=</span> maschine.kurse.copy()</span>
+<span id="cb196-282"><a href="#cb196-282" aria-hidden="true" tabindex="-1"></a>    zukunft <span class="op">=</span> maschine.kurse.index <span class="op">&gt;</span> stichtag</span>
+<span id="cb196-283"><a href="#cb196-283" aria-hidden="true" tabindex="-1"></a>    maschine.kurse.loc[zukunft] <span class="op">*=</span> <span class="fl">3.0</span>            <span class="co"># Zukunft massiv veraendern</span></span>
+<span id="cb196-284"><a href="#cb196-284" aria-hidden="true" tabindex="-1"></a>    signal_manipuliert <span class="op">=</span> maschine.alpha_signal(stichtag)</span>
+<span id="cb196-285"><a href="#cb196-285" aria-hidden="true" tabindex="-1"></a>    maschine.kurse <span class="op">=</span> original_kurse               <span class="co"># zuruecksetzen</span></span>
+<span id="cb196-286"><a href="#cb196-286" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb196-287"><a href="#cb196-287" aria-hidden="true" tabindex="-1"></a>    identisch <span class="op">=</span> np.allclose(signal_original, signal_manipuliert)</span>
+<span id="cb196-288"><a href="#cb196-288" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;Lookahead-Selbsttest: Signal bleibt bei manipulierter Zukunft &quot;</span></span>
+<span id="cb196-289"><a href="#cb196-289" aria-hidden="true" tabindex="-1"></a>          <span class="ss">f&quot;</span><span class="sc">{</span><span class="st">&#39;UNVERAENDERT (gut)&#39;</span> <span class="cf">if</span> identisch <span class="cf">else</span> <span class="st">&#39;VERAENDERT - LOOKAHEAD-BIAS!&#39;</span><span class="sc">}</span><span class="ss">&quot;</span>)</span>
+<span id="cb196-290"><a href="#cb196-290" aria-hidden="true" tabindex="-1"></a>    <span class="cf">assert</span> identisch, <span class="st">&quot;Das Signal verwendet Zukunftsdaten!&quot;</span></span>
+<span id="cb196-291"><a href="#cb196-291" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb196-292"><a href="#cb196-292" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb196-293"><a href="#cb196-293" aria-hidden="true" tabindex="-1"></a><span class="cf">if</span> <span class="va">__name__</span> <span class="op">==</span> <span class="st">&quot;__main__&quot;</span>:</span>
+<span id="cb196-294"><a href="#cb196-294" aria-hidden="true" tabindex="-1"></a>    UNIVERSUM <span class="op">=</span> [<span class="st">&quot;AAPL&quot;</span>, <span class="st">&quot;MSFT&quot;</span>, <span class="st">&quot;NVDA&quot;</span>, <span class="st">&quot;GOOGL&quot;</span>,</span>
+<span id="cb196-295"><a href="#cb196-295" aria-hidden="true" tabindex="-1"></a>                 <span class="st">&quot;JNJ&quot;</span>, <span class="st">&quot;UNH&quot;</span>, <span class="st">&quot;PFE&quot;</span>,</span>
+<span id="cb196-296"><a href="#cb196-296" aria-hidden="true" tabindex="-1"></a>                 <span class="st">&quot;JPM&quot;</span>, <span class="st">&quot;BAC&quot;</span>, <span class="st">&quot;GS&quot;</span>,</span>
+<span id="cb196-297"><a href="#cb196-297" aria-hidden="true" tabindex="-1"></a>                 <span class="st">&quot;XOM&quot;</span>, <span class="st">&quot;CVX&quot;</span>,</span>
+<span id="cb196-298"><a href="#cb196-298" aria-hidden="true" tabindex="-1"></a>                 <span class="st">&quot;PG&quot;</span>, <span class="st">&quot;KO&quot;</span>, <span class="st">&quot;COST&quot;</span>]</span>
+<span id="cb196-299"><a href="#cb196-299" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb196-300"><a href="#cb196-300" aria-hidden="true" tabindex="-1"></a>    maschine <span class="op">=</span> QuantitativeHandelsmaschine(UNIVERSUM, benchmark<span class="op">=</span><span class="st">&quot;SPY&quot;</span>, jahre<span class="op">=</span><span class="dv">5</span>)</span>
+<span id="cb196-301"><a href="#cb196-301" aria-hidden="true" tabindex="-1"></a>    maschine.lade_daten()</span>
+<span id="cb196-302"><a href="#cb196-302" aria-hidden="true" tabindex="-1"></a>    lookahead_selbsttest(maschine)</span>
+<span id="cb196-303"><a href="#cb196-303" aria-hidden="true" tabindex="-1"></a>    ergebnis, gewichte, kosten <span class="op">=</span> maschine.backtest()</span>
+<span id="cb196-304"><a href="#cb196-304" aria-hidden="true" tabindex="-1"></a>    maschine.bericht(ergebnis, kosten)</span>
+<span id="cb196-305"><a href="#cb196-305" aria-hidden="true" tabindex="-1"></a>    maschine.zeichne(ergebnis)</span></code></pre></div>
 <blockquote>
 <p><strong>💻 Code-Durchgang: die vier kritischen Stellen</strong></p>
 <p><strong>1. Rebalancing-Kalender.</strong></p>
-<div class="sourceCode" id="cb195"><pre class="sourceCode python"><code class="sourceCode python"><span id="cb195-1"><a href="#cb195-1" aria-hidden="true" tabindex="-1"></a>monat <span class="op">=</span> <span class="va">self</span>.kurse.index.to_period(<span class="st">&quot;M&quot;</span>)</span>
-<span id="cb195-2"><a href="#cb195-2" aria-hidden="true" tabindex="-1"></a><span class="va">self</span>.rebalancing_termine <span class="op">=</span> <span class="va">self</span>.kurse.index[<span class="op">~</span>monat.duplicated()]</span></code></pre></div>
+<div class="sourceCode" id="cb197"><pre class="sourceCode python"><code class="sourceCode python"><span id="cb197-1"><a href="#cb197-1" aria-hidden="true" tabindex="-1"></a>monat <span class="op">=</span> <span class="va">self</span>.kurse.index.to_period(<span class="st">&quot;M&quot;</span>)</span>
+<span id="cb197-2"><a href="#cb197-2" aria-hidden="true" tabindex="-1"></a><span class="va">self</span>.rebalancing_termine <span class="op">=</span> <span class="va">self</span>.kurse.index[<span class="op">~</span>monat.duplicated()]</span></code></pre></div>
 <p><code>to_period("M")</code> bildet jeden Handelstag auf seinen Monat ab; <code>~duplicated()</code> behält jeweils den <strong>ersten</strong> — also garantiert einen realen Handelstag.</p>
 <p><strong>2. Die Zeitachse im Backtest.</strong></p>
-<div class="sourceCode" id="cb196"><pre class="sourceCode python"><code class="sourceCode python"><span id="cb196-1"><a href="#cb196-1" aria-hidden="true" tabindex="-1"></a>tagesrenditen <span class="op">=</span> <span class="va">self</span>.renditen.iloc[t <span class="op">+</span> <span class="dv">1</span>].values      <span class="co"># MORGEN</span></span>
-<span id="cb196-2"><a href="#cb196-2" aria-hidden="true" tabindex="-1"></a>portfoliorendite <span class="op">=</span> gewichte <span class="op">@</span> tagesrenditen            <span class="co"># HEUTE festgelegt</span></span></code></pre></div>
+<div class="sourceCode" id="cb198"><pre class="sourceCode python"><code class="sourceCode python"><span id="cb198-1"><a href="#cb198-1" aria-hidden="true" tabindex="-1"></a>tagesrenditen <span class="op">=</span> <span class="va">self</span>.renditen.iloc[t <span class="op">+</span> <span class="dv">1</span>].values      <span class="co"># MORGEN</span></span>
+<span id="cb198-2"><a href="#cb198-2" aria-hidden="true" tabindex="-1"></a>portfoliorendite <span class="op">=</span> gewichte <span class="op">@</span> tagesrenditen            <span class="co"># HEUTE festgelegt</span></span></code></pre></div>
 <p>Die Gewichte werden am Tag <span class="math inline">t</span> aus Daten bis <span class="math inline">t</span> bestimmt und auf die Rendite von <span class="math inline">t+1</span> angewendet. <strong>Diese eine Indexverschiebung ist der Unterschied zwischen einem ehrlichen und einem geschönten Backtest.</strong></p>
 <p><strong>3. Der Lookahead-Selbsttest.</strong> Er verdreifacht künstlich alle Kurse <strong>nach</strong> dem Stichtag und prüft, ob sich das Signal von <em>vor</em> dem Stichtag dadurch ändert. Ändert es sich, greift der Code auf die Zukunft zu. Dieser Test kostet zehn Zeilen und findet eine Fehlerklasse, die sonst praktisch unsichtbar bleibt. <strong>Übernehmen Sie ihn in jedes Backtest-Projekt.</strong></p>
 <p><strong>4. Gewichtsdrift.</strong></p>
-<div class="sourceCode" id="cb197"><pre class="sourceCode python"><code class="sourceCode python"><span id="cb197-1"><a href="#cb197-1" aria-hidden="true" tabindex="-1"></a>gedriftet <span class="op">=</span> gewichte <span class="op">*</span> (<span class="fl">1.0</span> <span class="op">+</span> tagesrenditen)</span>
-<span id="cb197-2"><a href="#cb197-2" aria-hidden="true" tabindex="-1"></a>gewichte <span class="op">=</span> gedriftet <span class="op">/</span> gedriftet.<span class="bu">sum</span>()</span></code></pre></div>
+<div class="sourceCode" id="cb199"><pre class="sourceCode python"><code class="sourceCode python"><span id="cb199-1"><a href="#cb199-1" aria-hidden="true" tabindex="-1"></a>gedriftet <span class="op">=</span> gewichte <span class="op">*</span> (<span class="fl">1.0</span> <span class="op">+</span> tagesrenditen)</span>
+<span id="cb199-2"><a href="#cb199-2" aria-hidden="true" tabindex="-1"></a>gewichte <span class="op">=</span> gedriftet <span class="op">/</span> gedriftet.<span class="bu">sum</span>()</span></code></pre></div>
 <p>Zwischen zwei Rebalancings verändern sich die Gewichte von selbst — gestiegene Titel bekommen mehr Gewicht. Wer das weglässt, unterstellt implizit <strong>tägliches</strong> kostenloses Rebalancing und überschätzt die Strategie.</p>
 </blockquote>
 <blockquote>
@@ -24171,102 +25147,102 @@ geballt   Jahresrendite  8.88 %  Sharpe 0.61  max. Rueckschlag  -98.7 %</code></
 </blockquote>
 <hr />
 <h2 id="sec:handelsmaschine-die-fuenf-selbsttaeuschungen-des-backtestens">21.6 Die fünf Selbsttäuschungen des Backtestens</h2>
-<div class="sourceCode" id="cb198"><pre class="sourceCode python"><code class="sourceCode python"><span id="cb198-1"><a href="#cb198-1" aria-hidden="true" tabindex="-1"></a><span class="co">#!/usr/bin/env python3</span></span>
-<span id="cb198-2"><a href="#cb198-2" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb198-3"><a href="#cb198-3" aria-hidden="true" tabindex="-1"></a><span class="co"># Backtest_Fallen.py</span></span>
-<span id="cb198-4"><a href="#cb198-4" aria-hidden="true" tabindex="-1"></a><span class="co">&quot;&quot;&quot;</span></span>
-<span id="cb198-5"><a href="#cb198-5" aria-hidden="true" tabindex="-1"></a><span class="co">Kapitel Handelsmaschine: Wie leicht man sich selbst betruegt.</span></span>
-<span id="cb198-6"><a href="#cb198-6" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb198-7"><a href="#cb198-7" aria-hidden="true" tabindex="-1"></a><span class="co">Demonstriert an SIMULIERTEN Daten (also ohne jede echte Prognosekraft),</span></span>
-<span id="cb198-8"><a href="#cb198-8" aria-hidden="true" tabindex="-1"></a><span class="co">wie gross die scheinbare Ueberrendite durch typische Backtest-Fehler wird.</span></span>
-<span id="cb198-9"><a href="#cb198-9" aria-hidden="true" tabindex="-1"></a><span class="co">Weil die Daten reines Rauschen sind, ist JEDE positive Ueberrendite ein Artefakt.</span></span>
-<span id="cb198-10"><a href="#cb198-10" aria-hidden="true" tabindex="-1"></a><span class="co">&quot;&quot;&quot;</span></span>
-<span id="cb198-11"><a href="#cb198-11" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb198-12"><a href="#cb198-12" aria-hidden="true" tabindex="-1"></a><span class="im">import</span> numpy <span class="im">as</span> np</span>
-<span id="cb198-13"><a href="#cb198-13" aria-hidden="true" tabindex="-1"></a><span class="im">import</span> pandas <span class="im">as</span> pd</span>
-<span id="cb198-14"><a href="#cb198-14" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb198-15"><a href="#cb198-15" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb198-16"><a href="#cb198-16" aria-hidden="true" tabindex="-1"></a><span class="kw">def</span> erzeuge_zufallsmarkt(tage<span class="op">=</span><span class="dv">1260</span>, titel<span class="op">=</span><span class="dv">15</span>, seed<span class="op">=</span><span class="dv">7</span>):</span>
-<span id="cb198-17"><a href="#cb198-17" aria-hidden="true" tabindex="-1"></a>    <span class="co">&quot;&quot;&quot;Reines Rauschen: kein Titel hat echte Prognosekraft.&quot;&quot;&quot;</span></span>
-<span id="cb198-18"><a href="#cb198-18" aria-hidden="true" tabindex="-1"></a>    rng <span class="op">=</span> np.random.default_rng(seed)</span>
-<span id="cb198-19"><a href="#cb198-19" aria-hidden="true" tabindex="-1"></a>    renditen <span class="op">=</span> rng.normal(<span class="fl">0.0003</span>, <span class="fl">0.015</span>, size<span class="op">=</span>(tage, titel))</span>
-<span id="cb198-20"><a href="#cb198-20" aria-hidden="true" tabindex="-1"></a>    index <span class="op">=</span> pd.bdate_range(<span class="st">&quot;2020-01-01&quot;</span>, periods<span class="op">=</span>tage)</span>
-<span id="cb198-21"><a href="#cb198-21" aria-hidden="true" tabindex="-1"></a>    <span class="cf">return</span> pd.DataFrame(renditen, index<span class="op">=</span>index,</span>
-<span id="cb198-22"><a href="#cb198-22" aria-hidden="true" tabindex="-1"></a>                        columns<span class="op">=</span>[<span class="ss">f&quot;T</span><span class="sc">{</span>i<span class="sc">:02d}</span><span class="ss">&quot;</span> <span class="cf">for</span> i <span class="kw">in</span> <span class="bu">range</span>(titel)])</span>
-<span id="cb198-23"><a href="#cb198-23" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb198-24"><a href="#cb198-24" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb198-25"><a href="#cb198-25" aria-hidden="true" tabindex="-1"></a><span class="kw">def</span> strategie(renditen, lookahead<span class="op">=</span><span class="va">False</span>, survivorship<span class="op">=</span><span class="va">False</span>,</span>
-<span id="cb198-26"><a href="#cb198-26" aria-hidden="true" tabindex="-1"></a>              ohne_kosten<span class="op">=</span><span class="va">False</span>, gebuehr<span class="op">=</span><span class="fl">0.0015</span>):</span>
-<span id="cb198-27"><a href="#cb198-27" aria-hidden="true" tabindex="-1"></a>    <span class="co">&quot;&quot;&quot;Einfache Momentum-Strategie mit optional eingebauten Fehlern.&quot;&quot;&quot;</span></span>
-<span id="cb198-28"><a href="#cb198-28" aria-hidden="true" tabindex="-1"></a>    fenster <span class="op">=</span> <span class="dv">60</span></span>
-<span id="cb198-29"><a href="#cb198-29" aria-hidden="true" tabindex="-1"></a>    kapital <span class="op">=</span> [<span class="fl">100.0</span>]</span>
-<span id="cb198-30"><a href="#cb198-30" aria-hidden="true" tabindex="-1"></a>    gewichte <span class="op">=</span> np.ones(renditen.shape[<span class="dv">1</span>]) <span class="op">/</span> renditen.shape[<span class="dv">1</span>]</span>
-<span id="cb198-31"><a href="#cb198-31" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb198-32"><a href="#cb198-32" aria-hidden="true" tabindex="-1"></a>    daten <span class="op">=</span> renditen</span>
-<span id="cb198-33"><a href="#cb198-33" aria-hidden="true" tabindex="-1"></a>    <span class="cf">if</span> survivorship:</span>
-<span id="cb198-34"><a href="#cb198-34" aria-hidden="true" tabindex="-1"></a>        <span class="co"># FEHLER: nur die im Nachhinein besten Titel ins Universum lassen</span></span>
-<span id="cb198-35"><a href="#cb198-35" aria-hidden="true" tabindex="-1"></a>        beste <span class="op">=</span> renditen.<span class="bu">sum</span>().nlargest(renditen.shape[<span class="dv">1</span>] <span class="op">//</span> <span class="dv">2</span>).index</span>
-<span id="cb198-36"><a href="#cb198-36" aria-hidden="true" tabindex="-1"></a>        daten <span class="op">=</span> renditen[beste]</span>
-<span id="cb198-37"><a href="#cb198-37" aria-hidden="true" tabindex="-1"></a>        gewichte <span class="op">=</span> np.ones(<span class="bu">len</span>(beste)) <span class="op">/</span> <span class="bu">len</span>(beste)</span>
-<span id="cb198-38"><a href="#cb198-38" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb198-39"><a href="#cb198-39" aria-hidden="true" tabindex="-1"></a>    <span class="cf">for</span> t <span class="kw">in</span> <span class="bu">range</span>(fenster, <span class="bu">len</span>(daten) <span class="op">-</span> <span class="dv">1</span>):</span>
-<span id="cb198-40"><a href="#cb198-40" aria-hidden="true" tabindex="-1"></a>        <span class="cf">if</span> t <span class="op">%</span> <span class="dv">21</span> <span class="op">==</span> <span class="dv">0</span>:                                  <span class="co"># monatlich</span></span>
-<span id="cb198-41"><a href="#cb198-41" aria-hidden="true" tabindex="-1"></a>            <span class="cf">if</span> lookahead:</span>
-<span id="cb198-42"><a href="#cb198-42" aria-hidden="true" tabindex="-1"></a>                <span class="co"># FEHLER: Signal nutzt die Rendite von MORGEN</span></span>
-<span id="cb198-43"><a href="#cb198-43" aria-hidden="true" tabindex="-1"></a>                signal <span class="op">=</span> daten.iloc[t <span class="op">+</span> <span class="dv">1</span>].values</span>
-<span id="cb198-44"><a href="#cb198-44" aria-hidden="true" tabindex="-1"></a>            <span class="cf">else</span>:</span>
-<span id="cb198-45"><a href="#cb198-45" aria-hidden="true" tabindex="-1"></a>                signal <span class="op">=</span> daten.iloc[t <span class="op">-</span> fenster:t].mean().values</span>
-<span id="cb198-46"><a href="#cb198-46" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb198-47"><a href="#cb198-47" aria-hidden="true" tabindex="-1"></a>            neue <span class="op">=</span> (signal <span class="op">&gt;</span> np.median(signal)).astype(<span class="bu">float</span>)</span>
-<span id="cb198-48"><a href="#cb198-48" aria-hidden="true" tabindex="-1"></a>            neue <span class="op">=</span> neue <span class="op">/</span> neue.<span class="bu">sum</span>() <span class="cf">if</span> neue.<span class="bu">sum</span>() <span class="op">&gt;</span> <span class="dv">0</span> <span class="cf">else</span> gewichte</span>
-<span id="cb198-49"><a href="#cb198-49" aria-hidden="true" tabindex="-1"></a>            <span class="cf">if</span> <span class="kw">not</span> ohne_kosten:</span>
-<span id="cb198-50"><a href="#cb198-50" aria-hidden="true" tabindex="-1"></a>                kapital[<span class="op">-</span><span class="dv">1</span>] <span class="op">*=</span> (<span class="dv">1</span> <span class="op">-</span> np.<span class="bu">abs</span>(neue <span class="op">-</span> gewichte).<span class="bu">sum</span>() <span class="op">*</span> gebuehr)</span>
-<span id="cb198-51"><a href="#cb198-51" aria-hidden="true" tabindex="-1"></a>            gewichte <span class="op">=</span> neue</span>
-<span id="cb198-52"><a href="#cb198-52" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb198-53"><a href="#cb198-53" aria-hidden="true" tabindex="-1"></a>        kapital.append(kapital[<span class="op">-</span><span class="dv">1</span>] <span class="op">*</span> (<span class="dv">1</span> <span class="op">+</span> <span class="bu">float</span>(gewichte <span class="op">@</span> daten.iloc[t <span class="op">+</span> <span class="dv">1</span>].values)))</span>
-<span id="cb198-54"><a href="#cb198-54" aria-hidden="true" tabindex="-1"></a>    <span class="cf">return</span> np.array(kapital)</span>
-<span id="cb198-55"><a href="#cb198-55" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb198-56"><a href="#cb198-56" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb198-57"><a href="#cb198-57" aria-hidden="true" tabindex="-1"></a><span class="kw">def</span> cagr(verlauf, jahre):</span>
-<span id="cb198-58"><a href="#cb198-58" aria-hidden="true" tabindex="-1"></a>    <span class="cf">return</span> (verlauf[<span class="op">-</span><span class="dv">1</span>] <span class="op">/</span> verlauf[<span class="dv">0</span>]) <span class="op">**</span> (<span class="dv">1</span> <span class="op">/</span> jahre) <span class="op">-</span> <span class="dv">1</span></span>
-<span id="cb198-59"><a href="#cb198-59" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb198-60"><a href="#cb198-60" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb198-61"><a href="#cb198-61" aria-hidden="true" tabindex="-1"></a><span class="cf">if</span> <span class="va">__name__</span> <span class="op">==</span> <span class="st">&quot;__main__&quot;</span>:</span>
-<span id="cb198-62"><a href="#cb198-62" aria-hidden="true" tabindex="-1"></a>    renditen <span class="op">=</span> erzeuge_zufallsmarkt()</span>
-<span id="cb198-63"><a href="#cb198-63" aria-hidden="true" tabindex="-1"></a>    jahre <span class="op">=</span> <span class="bu">len</span>(renditen) <span class="op">/</span> <span class="dv">252</span></span>
-<span id="cb198-64"><a href="#cb198-64" aria-hidden="true" tabindex="-1"></a>    markt <span class="op">=</span> <span class="dv">100</span> <span class="op">*</span> (<span class="dv">1</span> <span class="op">+</span> renditen.mean(axis<span class="op">=</span><span class="dv">1</span>)).cumprod().values</span>
-<span id="cb198-65"><a href="#cb198-65" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb198-66"><a href="#cb198-66" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;=&quot;</span> <span class="op">*</span> <span class="dv">84</span>)</span>
-<span id="cb198-67"><a href="#cb198-67" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;  DIE FUENF SELBSTTAEUSCHUNGEN - GEMESSEN AN REINEM RAUSCHEN&quot;</span>)</span>
-<span id="cb198-68"><a href="#cb198-68" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;=&quot;</span> <span class="op">*</span> <span class="dv">84</span>)</span>
-<span id="cb198-69"><a href="#cb198-69" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;Die Daten sind zufaellig erzeugt. Es gibt KEINE echte Prognosekraft.&quot;</span>)</span>
-<span id="cb198-70"><a href="#cb198-70" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;Jede Ueberrendite unten ist daher ein reines Artefakt.</span><span class="ch">\n</span><span class="st">&quot;</span>)</span>
-<span id="cb198-71"><a href="#cb198-71" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;</span><span class="sc">{</span><span class="st">&#39;Variante&#39;</span><span class="sc">:&lt;44}</span><span class="ss"> </span><span class="sc">{</span><span class="st">&#39;CAGR&#39;</span><span class="sc">:&gt;9}</span><span class="ss"> </span><span class="sc">{</span><span class="st">&#39;ggue. Markt&#39;</span><span class="sc">:&gt;13}</span><span class="ss">&quot;</span>)</span>
-<span id="cb198-72"><a href="#cb198-72" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;-&quot;</span> <span class="op">*</span> <span class="dv">84</span>)</span>
-<span id="cb198-73"><a href="#cb198-73" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb198-74"><a href="#cb198-74" aria-hidden="true" tabindex="-1"></a>    basis <span class="op">=</span> cagr(markt, jahre)</span>
-<span id="cb198-75"><a href="#cb198-75" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;</span><span class="sc">{</span><span class="st">&#39;Markt (Gleichgewichtung, Referenz)&#39;</span><span class="sc">:&lt;44}</span><span class="ss"> </span><span class="sc">{</span>basis<span class="op">*</span><span class="dv">100</span><span class="sc">:&gt;8.2f}</span><span class="ss"> % &quot;</span></span>
-<span id="cb198-76"><a href="#cb198-76" aria-hidden="true" tabindex="-1"></a>          <span class="ss">f&quot;</span><span class="sc">{</span><span class="fl">0.0</span><span class="sc">:&gt;12.2f}</span><span class="ss"> %&quot;</span>)</span>
-<span id="cb198-77"><a href="#cb198-77" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb198-78"><a href="#cb198-78" aria-hidden="true" tabindex="-1"></a>    varianten <span class="op">=</span> [</span>
-<span id="cb198-79"><a href="#cb198-79" aria-hidden="true" tabindex="-1"></a>        (<span class="st">&quot;Ehrlich: Signal aus Vergangenheit, mit Kosten&quot;</span>, {}),</span>
-<span id="cb198-80"><a href="#cb198-80" aria-hidden="true" tabindex="-1"></a>        (<span class="st">&quot;FEHLER 1: Lookahead (Signal kennt morgen)&quot;</span>, {<span class="st">&quot;lookahead&quot;</span>: <span class="va">True</span>}),</span>
-<span id="cb198-81"><a href="#cb198-81" aria-hidden="true" tabindex="-1"></a>        (<span class="st">&quot;FEHLER 2: Survivorship (nur Gewinner im Universum)&quot;</span>, {<span class="st">&quot;survivorship&quot;</span>: <span class="va">True</span>}),</span>
-<span id="cb198-82"><a href="#cb198-82" aria-hidden="true" tabindex="-1"></a>        (<span class="st">&quot;FEHLER 3: Transaktionskosten ignoriert&quot;</span>, {<span class="st">&quot;ohne_kosten&quot;</span>: <span class="va">True</span>}),</span>
-<span id="cb198-83"><a href="#cb198-83" aria-hidden="true" tabindex="-1"></a>        (<span class="st">&quot;FEHLER 1+2+3 kombiniert&quot;</span>, {<span class="st">&quot;lookahead&quot;</span>: <span class="va">True</span>, <span class="st">&quot;survivorship&quot;</span>: <span class="va">True</span>,</span>
-<span id="cb198-84"><a href="#cb198-84" aria-hidden="true" tabindex="-1"></a>                                     <span class="st">&quot;ohne_kosten&quot;</span>: <span class="va">True</span>}),</span>
-<span id="cb198-85"><a href="#cb198-85" aria-hidden="true" tabindex="-1"></a>    ]</span>
-<span id="cb198-86"><a href="#cb198-86" aria-hidden="true" tabindex="-1"></a>    <span class="cf">for</span> name, argumente <span class="kw">in</span> varianten:</span>
-<span id="cb198-87"><a href="#cb198-87" aria-hidden="true" tabindex="-1"></a>        verlauf <span class="op">=</span> strategie(renditen, <span class="op">**</span>argumente)</span>
-<span id="cb198-88"><a href="#cb198-88" aria-hidden="true" tabindex="-1"></a>        wert <span class="op">=</span> cagr(verlauf, jahre)</span>
-<span id="cb198-89"><a href="#cb198-89" aria-hidden="true" tabindex="-1"></a>        <span class="bu">print</span>(<span class="ss">f&quot;</span><span class="sc">{</span>name<span class="sc">:&lt;44}</span><span class="ss"> </span><span class="sc">{</span>wert<span class="op">*</span><span class="dv">100</span><span class="sc">:&gt;8.2f}</span><span class="ss"> % </span><span class="sc">{</span>(wert<span class="op">-</span>basis)<span class="op">*</span><span class="dv">100</span><span class="sc">:&gt;+12.2f}</span><span class="ss"> %&quot;</span>)</span>
-<span id="cb198-90"><a href="#cb198-90" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb198-91"><a href="#cb198-91" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;-&quot;</span> <span class="op">*</span> <span class="dv">84</span>)</span>
-<span id="cb198-92"><a href="#cb198-92" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;FEHLER 4 (Overfitting) und FEHLER 5 (Data Snooping) lassen sich so nicht&quot;</span>)</span>
-<span id="cb198-93"><a href="#cb198-93" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;zeigen - sie entstehen erst durch WIEDERHOLTES Probieren. Faustregel:&quot;</span>)</span>
-<span id="cb198-94"><a href="#cb198-94" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;Wer 20 Strategien testet, findet auch in reinem Rauschen eine mit&quot;</span>)</span>
-<span id="cb198-95"><a href="#cb198-95" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;Signifikanz auf dem 5-%-Niveau. Genau das ist der Punkt.&quot;</span>)</span>
-<span id="cb198-96"><a href="#cb198-96" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;=&quot;</span> <span class="op">*</span> <span class="dv">84</span>)</span></code></pre></div>
+<div class="sourceCode" id="cb200"><pre class="sourceCode python"><code class="sourceCode python"><span id="cb200-1"><a href="#cb200-1" aria-hidden="true" tabindex="-1"></a><span class="co">#!/usr/bin/env python3</span></span>
+<span id="cb200-2"><a href="#cb200-2" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb200-3"><a href="#cb200-3" aria-hidden="true" tabindex="-1"></a><span class="co"># Backtest_Fallen.py</span></span>
+<span id="cb200-4"><a href="#cb200-4" aria-hidden="true" tabindex="-1"></a><span class="co">&quot;&quot;&quot;</span></span>
+<span id="cb200-5"><a href="#cb200-5" aria-hidden="true" tabindex="-1"></a><span class="co">Kapitel Handelsmaschine: Wie leicht man sich selbst betruegt.</span></span>
+<span id="cb200-6"><a href="#cb200-6" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb200-7"><a href="#cb200-7" aria-hidden="true" tabindex="-1"></a><span class="co">Demonstriert an SIMULIERTEN Daten (also ohne jede echte Prognosekraft),</span></span>
+<span id="cb200-8"><a href="#cb200-8" aria-hidden="true" tabindex="-1"></a><span class="co">wie gross die scheinbare Ueberrendite durch typische Backtest-Fehler wird.</span></span>
+<span id="cb200-9"><a href="#cb200-9" aria-hidden="true" tabindex="-1"></a><span class="co">Weil die Daten reines Rauschen sind, ist JEDE positive Ueberrendite ein Artefakt.</span></span>
+<span id="cb200-10"><a href="#cb200-10" aria-hidden="true" tabindex="-1"></a><span class="co">&quot;&quot;&quot;</span></span>
+<span id="cb200-11"><a href="#cb200-11" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb200-12"><a href="#cb200-12" aria-hidden="true" tabindex="-1"></a><span class="im">import</span> numpy <span class="im">as</span> np</span>
+<span id="cb200-13"><a href="#cb200-13" aria-hidden="true" tabindex="-1"></a><span class="im">import</span> pandas <span class="im">as</span> pd</span>
+<span id="cb200-14"><a href="#cb200-14" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb200-15"><a href="#cb200-15" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb200-16"><a href="#cb200-16" aria-hidden="true" tabindex="-1"></a><span class="kw">def</span> erzeuge_zufallsmarkt(tage<span class="op">=</span><span class="dv">1260</span>, titel<span class="op">=</span><span class="dv">15</span>, seed<span class="op">=</span><span class="dv">7</span>):</span>
+<span id="cb200-17"><a href="#cb200-17" aria-hidden="true" tabindex="-1"></a>    <span class="co">&quot;&quot;&quot;Reines Rauschen: kein Titel hat echte Prognosekraft.&quot;&quot;&quot;</span></span>
+<span id="cb200-18"><a href="#cb200-18" aria-hidden="true" tabindex="-1"></a>    rng <span class="op">=</span> np.random.default_rng(seed)</span>
+<span id="cb200-19"><a href="#cb200-19" aria-hidden="true" tabindex="-1"></a>    renditen <span class="op">=</span> rng.normal(<span class="fl">0.0003</span>, <span class="fl">0.015</span>, size<span class="op">=</span>(tage, titel))</span>
+<span id="cb200-20"><a href="#cb200-20" aria-hidden="true" tabindex="-1"></a>    index <span class="op">=</span> pd.bdate_range(<span class="st">&quot;2020-01-01&quot;</span>, periods<span class="op">=</span>tage)</span>
+<span id="cb200-21"><a href="#cb200-21" aria-hidden="true" tabindex="-1"></a>    <span class="cf">return</span> pd.DataFrame(renditen, index<span class="op">=</span>index,</span>
+<span id="cb200-22"><a href="#cb200-22" aria-hidden="true" tabindex="-1"></a>                        columns<span class="op">=</span>[<span class="ss">f&quot;T</span><span class="sc">{</span>i<span class="sc">:02d}</span><span class="ss">&quot;</span> <span class="cf">for</span> i <span class="kw">in</span> <span class="bu">range</span>(titel)])</span>
+<span id="cb200-23"><a href="#cb200-23" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb200-24"><a href="#cb200-24" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb200-25"><a href="#cb200-25" aria-hidden="true" tabindex="-1"></a><span class="kw">def</span> strategie(renditen, lookahead<span class="op">=</span><span class="va">False</span>, survivorship<span class="op">=</span><span class="va">False</span>,</span>
+<span id="cb200-26"><a href="#cb200-26" aria-hidden="true" tabindex="-1"></a>              ohne_kosten<span class="op">=</span><span class="va">False</span>, gebuehr<span class="op">=</span><span class="fl">0.0015</span>):</span>
+<span id="cb200-27"><a href="#cb200-27" aria-hidden="true" tabindex="-1"></a>    <span class="co">&quot;&quot;&quot;Einfache Momentum-Strategie mit optional eingebauten Fehlern.&quot;&quot;&quot;</span></span>
+<span id="cb200-28"><a href="#cb200-28" aria-hidden="true" tabindex="-1"></a>    fenster <span class="op">=</span> <span class="dv">60</span></span>
+<span id="cb200-29"><a href="#cb200-29" aria-hidden="true" tabindex="-1"></a>    kapital <span class="op">=</span> [<span class="fl">100.0</span>]</span>
+<span id="cb200-30"><a href="#cb200-30" aria-hidden="true" tabindex="-1"></a>    gewichte <span class="op">=</span> np.ones(renditen.shape[<span class="dv">1</span>]) <span class="op">/</span> renditen.shape[<span class="dv">1</span>]</span>
+<span id="cb200-31"><a href="#cb200-31" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb200-32"><a href="#cb200-32" aria-hidden="true" tabindex="-1"></a>    daten <span class="op">=</span> renditen</span>
+<span id="cb200-33"><a href="#cb200-33" aria-hidden="true" tabindex="-1"></a>    <span class="cf">if</span> survivorship:</span>
+<span id="cb200-34"><a href="#cb200-34" aria-hidden="true" tabindex="-1"></a>        <span class="co"># FEHLER: nur die im Nachhinein besten Titel ins Universum lassen</span></span>
+<span id="cb200-35"><a href="#cb200-35" aria-hidden="true" tabindex="-1"></a>        beste <span class="op">=</span> renditen.<span class="bu">sum</span>().nlargest(renditen.shape[<span class="dv">1</span>] <span class="op">//</span> <span class="dv">2</span>).index</span>
+<span id="cb200-36"><a href="#cb200-36" aria-hidden="true" tabindex="-1"></a>        daten <span class="op">=</span> renditen[beste]</span>
+<span id="cb200-37"><a href="#cb200-37" aria-hidden="true" tabindex="-1"></a>        gewichte <span class="op">=</span> np.ones(<span class="bu">len</span>(beste)) <span class="op">/</span> <span class="bu">len</span>(beste)</span>
+<span id="cb200-38"><a href="#cb200-38" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb200-39"><a href="#cb200-39" aria-hidden="true" tabindex="-1"></a>    <span class="cf">for</span> t <span class="kw">in</span> <span class="bu">range</span>(fenster, <span class="bu">len</span>(daten) <span class="op">-</span> <span class="dv">1</span>):</span>
+<span id="cb200-40"><a href="#cb200-40" aria-hidden="true" tabindex="-1"></a>        <span class="cf">if</span> t <span class="op">%</span> <span class="dv">21</span> <span class="op">==</span> <span class="dv">0</span>:                                  <span class="co"># monatlich</span></span>
+<span id="cb200-41"><a href="#cb200-41" aria-hidden="true" tabindex="-1"></a>            <span class="cf">if</span> lookahead:</span>
+<span id="cb200-42"><a href="#cb200-42" aria-hidden="true" tabindex="-1"></a>                <span class="co"># FEHLER: Signal nutzt die Rendite von MORGEN</span></span>
+<span id="cb200-43"><a href="#cb200-43" aria-hidden="true" tabindex="-1"></a>                signal <span class="op">=</span> daten.iloc[t <span class="op">+</span> <span class="dv">1</span>].values</span>
+<span id="cb200-44"><a href="#cb200-44" aria-hidden="true" tabindex="-1"></a>            <span class="cf">else</span>:</span>
+<span id="cb200-45"><a href="#cb200-45" aria-hidden="true" tabindex="-1"></a>                signal <span class="op">=</span> daten.iloc[t <span class="op">-</span> fenster:t].mean().values</span>
+<span id="cb200-46"><a href="#cb200-46" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb200-47"><a href="#cb200-47" aria-hidden="true" tabindex="-1"></a>            neue <span class="op">=</span> (signal <span class="op">&gt;</span> np.median(signal)).astype(<span class="bu">float</span>)</span>
+<span id="cb200-48"><a href="#cb200-48" aria-hidden="true" tabindex="-1"></a>            neue <span class="op">=</span> neue <span class="op">/</span> neue.<span class="bu">sum</span>() <span class="cf">if</span> neue.<span class="bu">sum</span>() <span class="op">&gt;</span> <span class="dv">0</span> <span class="cf">else</span> gewichte</span>
+<span id="cb200-49"><a href="#cb200-49" aria-hidden="true" tabindex="-1"></a>            <span class="cf">if</span> <span class="kw">not</span> ohne_kosten:</span>
+<span id="cb200-50"><a href="#cb200-50" aria-hidden="true" tabindex="-1"></a>                kapital[<span class="op">-</span><span class="dv">1</span>] <span class="op">*=</span> (<span class="dv">1</span> <span class="op">-</span> np.<span class="bu">abs</span>(neue <span class="op">-</span> gewichte).<span class="bu">sum</span>() <span class="op">*</span> gebuehr)</span>
+<span id="cb200-51"><a href="#cb200-51" aria-hidden="true" tabindex="-1"></a>            gewichte <span class="op">=</span> neue</span>
+<span id="cb200-52"><a href="#cb200-52" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb200-53"><a href="#cb200-53" aria-hidden="true" tabindex="-1"></a>        kapital.append(kapital[<span class="op">-</span><span class="dv">1</span>] <span class="op">*</span> (<span class="dv">1</span> <span class="op">+</span> <span class="bu">float</span>(gewichte <span class="op">@</span> daten.iloc[t <span class="op">+</span> <span class="dv">1</span>].values)))</span>
+<span id="cb200-54"><a href="#cb200-54" aria-hidden="true" tabindex="-1"></a>    <span class="cf">return</span> np.array(kapital)</span>
+<span id="cb200-55"><a href="#cb200-55" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb200-56"><a href="#cb200-56" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb200-57"><a href="#cb200-57" aria-hidden="true" tabindex="-1"></a><span class="kw">def</span> cagr(verlauf, jahre):</span>
+<span id="cb200-58"><a href="#cb200-58" aria-hidden="true" tabindex="-1"></a>    <span class="cf">return</span> (verlauf[<span class="op">-</span><span class="dv">1</span>] <span class="op">/</span> verlauf[<span class="dv">0</span>]) <span class="op">**</span> (<span class="dv">1</span> <span class="op">/</span> jahre) <span class="op">-</span> <span class="dv">1</span></span>
+<span id="cb200-59"><a href="#cb200-59" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb200-60"><a href="#cb200-60" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb200-61"><a href="#cb200-61" aria-hidden="true" tabindex="-1"></a><span class="cf">if</span> <span class="va">__name__</span> <span class="op">==</span> <span class="st">&quot;__main__&quot;</span>:</span>
+<span id="cb200-62"><a href="#cb200-62" aria-hidden="true" tabindex="-1"></a>    renditen <span class="op">=</span> erzeuge_zufallsmarkt()</span>
+<span id="cb200-63"><a href="#cb200-63" aria-hidden="true" tabindex="-1"></a>    jahre <span class="op">=</span> <span class="bu">len</span>(renditen) <span class="op">/</span> <span class="dv">252</span></span>
+<span id="cb200-64"><a href="#cb200-64" aria-hidden="true" tabindex="-1"></a>    markt <span class="op">=</span> <span class="dv">100</span> <span class="op">*</span> (<span class="dv">1</span> <span class="op">+</span> renditen.mean(axis<span class="op">=</span><span class="dv">1</span>)).cumprod().values</span>
+<span id="cb200-65"><a href="#cb200-65" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb200-66"><a href="#cb200-66" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;=&quot;</span> <span class="op">*</span> <span class="dv">84</span>)</span>
+<span id="cb200-67"><a href="#cb200-67" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;  DIE FUENF SELBSTTAEUSCHUNGEN - GEMESSEN AN REINEM RAUSCHEN&quot;</span>)</span>
+<span id="cb200-68"><a href="#cb200-68" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;=&quot;</span> <span class="op">*</span> <span class="dv">84</span>)</span>
+<span id="cb200-69"><a href="#cb200-69" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;Die Daten sind zufaellig erzeugt. Es gibt KEINE echte Prognosekraft.&quot;</span>)</span>
+<span id="cb200-70"><a href="#cb200-70" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;Jede Ueberrendite unten ist daher ein reines Artefakt.</span><span class="ch">\n</span><span class="st">&quot;</span>)</span>
+<span id="cb200-71"><a href="#cb200-71" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;</span><span class="sc">{</span><span class="st">&#39;Variante&#39;</span><span class="sc">:&lt;44}</span><span class="ss"> </span><span class="sc">{</span><span class="st">&#39;CAGR&#39;</span><span class="sc">:&gt;9}</span><span class="ss"> </span><span class="sc">{</span><span class="st">&#39;ggue. Markt&#39;</span><span class="sc">:&gt;13}</span><span class="ss">&quot;</span>)</span>
+<span id="cb200-72"><a href="#cb200-72" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;-&quot;</span> <span class="op">*</span> <span class="dv">84</span>)</span>
+<span id="cb200-73"><a href="#cb200-73" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb200-74"><a href="#cb200-74" aria-hidden="true" tabindex="-1"></a>    basis <span class="op">=</span> cagr(markt, jahre)</span>
+<span id="cb200-75"><a href="#cb200-75" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;</span><span class="sc">{</span><span class="st">&#39;Markt (Gleichgewichtung, Referenz)&#39;</span><span class="sc">:&lt;44}</span><span class="ss"> </span><span class="sc">{</span>basis<span class="op">*</span><span class="dv">100</span><span class="sc">:&gt;8.2f}</span><span class="ss"> % &quot;</span></span>
+<span id="cb200-76"><a href="#cb200-76" aria-hidden="true" tabindex="-1"></a>          <span class="ss">f&quot;</span><span class="sc">{</span><span class="fl">0.0</span><span class="sc">:&gt;12.2f}</span><span class="ss"> %&quot;</span>)</span>
+<span id="cb200-77"><a href="#cb200-77" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb200-78"><a href="#cb200-78" aria-hidden="true" tabindex="-1"></a>    varianten <span class="op">=</span> [</span>
+<span id="cb200-79"><a href="#cb200-79" aria-hidden="true" tabindex="-1"></a>        (<span class="st">&quot;Ehrlich: Signal aus Vergangenheit, mit Kosten&quot;</span>, {}),</span>
+<span id="cb200-80"><a href="#cb200-80" aria-hidden="true" tabindex="-1"></a>        (<span class="st">&quot;FEHLER 1: Lookahead (Signal kennt morgen)&quot;</span>, {<span class="st">&quot;lookahead&quot;</span>: <span class="va">True</span>}),</span>
+<span id="cb200-81"><a href="#cb200-81" aria-hidden="true" tabindex="-1"></a>        (<span class="st">&quot;FEHLER 2: Survivorship (nur Gewinner im Universum)&quot;</span>, {<span class="st">&quot;survivorship&quot;</span>: <span class="va">True</span>}),</span>
+<span id="cb200-82"><a href="#cb200-82" aria-hidden="true" tabindex="-1"></a>        (<span class="st">&quot;FEHLER 3: Transaktionskosten ignoriert&quot;</span>, {<span class="st">&quot;ohne_kosten&quot;</span>: <span class="va">True</span>}),</span>
+<span id="cb200-83"><a href="#cb200-83" aria-hidden="true" tabindex="-1"></a>        (<span class="st">&quot;FEHLER 1+2+3 kombiniert&quot;</span>, {<span class="st">&quot;lookahead&quot;</span>: <span class="va">True</span>, <span class="st">&quot;survivorship&quot;</span>: <span class="va">True</span>,</span>
+<span id="cb200-84"><a href="#cb200-84" aria-hidden="true" tabindex="-1"></a>                                     <span class="st">&quot;ohne_kosten&quot;</span>: <span class="va">True</span>}),</span>
+<span id="cb200-85"><a href="#cb200-85" aria-hidden="true" tabindex="-1"></a>    ]</span>
+<span id="cb200-86"><a href="#cb200-86" aria-hidden="true" tabindex="-1"></a>    <span class="cf">for</span> name, argumente <span class="kw">in</span> varianten:</span>
+<span id="cb200-87"><a href="#cb200-87" aria-hidden="true" tabindex="-1"></a>        verlauf <span class="op">=</span> strategie(renditen, <span class="op">**</span>argumente)</span>
+<span id="cb200-88"><a href="#cb200-88" aria-hidden="true" tabindex="-1"></a>        wert <span class="op">=</span> cagr(verlauf, jahre)</span>
+<span id="cb200-89"><a href="#cb200-89" aria-hidden="true" tabindex="-1"></a>        <span class="bu">print</span>(<span class="ss">f&quot;</span><span class="sc">{</span>name<span class="sc">:&lt;44}</span><span class="ss"> </span><span class="sc">{</span>wert<span class="op">*</span><span class="dv">100</span><span class="sc">:&gt;8.2f}</span><span class="ss"> % </span><span class="sc">{</span>(wert<span class="op">-</span>basis)<span class="op">*</span><span class="dv">100</span><span class="sc">:&gt;+12.2f}</span><span class="ss"> %&quot;</span>)</span>
+<span id="cb200-90"><a href="#cb200-90" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb200-91"><a href="#cb200-91" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;-&quot;</span> <span class="op">*</span> <span class="dv">84</span>)</span>
+<span id="cb200-92"><a href="#cb200-92" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;FEHLER 4 (Overfitting) und FEHLER 5 (Data Snooping) lassen sich so nicht&quot;</span>)</span>
+<span id="cb200-93"><a href="#cb200-93" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;zeigen - sie entstehen erst durch WIEDERHOLTES Probieren. Faustregel:&quot;</span>)</span>
+<span id="cb200-94"><a href="#cb200-94" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;Wer 20 Strategien testet, findet auch in reinem Rauschen eine mit&quot;</span>)</span>
+<span id="cb200-95"><a href="#cb200-95" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;Signifikanz auf dem 5-%-Niveau. Genau das ist der Punkt.&quot;</span>)</span>
+<span id="cb200-96"><a href="#cb200-96" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;=&quot;</span> <span class="op">*</span> <span class="dv">84</span>)</span></code></pre></div>
 <p><strong>Erwartete Ausgabe:</strong></p>
 <pre><code>====================================================================================
   DIE FUENF SELBSTTAEUSCHUNGEN - GEMESSEN AN REINEM RAUSCHEN
@@ -24405,146 +25381,146 @@ FEHLER 1+2+3 kombiniert                          25.41 %       +19.80 %
 <p><code>Backtest_Fallen.py</code> zeigt drei Fehler, die <strong>im</strong> Backtest stecken: Lookahead, Survivorship, vergessene Kosten. Alle drei kann man einem Programm ansehen, wenn man es liest.</p>
 <p>Die beiden übrigen Selbsttäuschungen sind anders gebaut. Sie entstehen nicht im Code, sondern in der <strong>Arbeitsweise davor</strong> — und hinterlassen im Programm keine Spur. Ein Backtest, der zwanzigmal nachjustiert wurde, sieht am Ende genauso sauber aus wie einer, der beim ersten Versuch funktioniert hat.</p>
 <blockquote>
-<p><strong>🐛 Finde den Denkfehler 14.1: Die Strategie mit dem hochsignifikanten Ergebnis</strong></p>
+<p><strong>🐛 Finde den Denkfehler: Die Strategie mit dem hochsignifikanten Ergebnis</strong></p>
 <p>Eine Analystin entwickelt über mehrere Wochen eine Handelsstrategie. Sie probiert verschiedene Signalfenster, Schwellenwerte, Filter und Haltedauern durch — insgesamt rund <strong>hundert Varianten</strong>. Die beste testet sie sauber: kein Lookahead, korrektes Universum, Transaktionskosten berücksichtigt.</p>
 <p>Das Ergebnis über fünf Jahre: <strong>Sharpe-Kennzahl 1,13</strong>, p-Wert <strong>0,0094</strong>. Der Backtest ist handwerklich einwandfrei — jede der drei Fallen aus <code>Backtest_Fallen.py</code> wurde vermieden. Sie stellt die Strategie vor.</p>
 <p><strong>Ihre Aufgabe:</strong> (a) Der Backtest ist korrekt. Warum ist das Ergebnis trotzdem wertlos? (b) Sehen Sie sich unten die letzte Spalte der Tabelle an: Sie bleibt konstant bei 5 %, obwohl die Zahl der Versuche um das Tausendfache wächst. Wieso ist das kein Widerspruch, sondern der Kern des Problems? (c) Welche Zahl fehlt in ihrem Bericht — eine Zahl, die in keinem Backtest-Ergebnis steht und die sie selbst aufschreiben müsste? (d) Nennen Sie drei Gegenmittel und begründen Sie, warum das dritte nur <strong>einmal</strong> verwendbar ist.</p>
 <p><em>Auflösung: <a href="#sec:loesungen-handelsmaschine">Abschnitt A.21</a>.</em></p>
 </blockquote>
 <p>Das folgende Programm macht den Effekt messbar. Es testet Strategien, die <strong>nachweislich</strong> keinerlei Vorteil haben — ihre Tagesergebnisse sind Zufallszahlen mit Erwartungswert exakt null — und zeigt, wie gut die jeweils beste davon aussieht, allein als Funktion der Anzahl der Versuche.</p>
-<div class="sourceCode" id="cb200"><pre class="sourceCode python"><code class="sourceCode python"><span id="cb200-1"><a href="#cb200-1" aria-hidden="true" tabindex="-1"></a><span class="co">#!/usr/bin/env python3</span></span>
-<span id="cb200-2"><a href="#cb200-2" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb200-3"><a href="#cb200-3" aria-hidden="true" tabindex="-1"></a><span class="co"># Data_Snooping.py</span></span>
-<span id="cb200-4"><a href="#cb200-4" aria-hidden="true" tabindex="-1"></a><span class="co">&quot;&quot;&quot;</span></span>
-<span id="cb200-5"><a href="#cb200-5" aria-hidden="true" tabindex="-1"></a><span class="co">Kapitel Handelsmaschine: Die Selbsttaeuschung, die man einem Backtest nicht ansieht.</span></span>
-<span id="cb200-6"><a href="#cb200-6" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb200-7"><a href="#cb200-7" aria-hidden="true" tabindex="-1"></a><span class="co">Backtest_Fallen.py zeigt drei Fehler, die IM Backtest stecken: Lookahead,</span></span>
-<span id="cb200-8"><a href="#cb200-8" aria-hidden="true" tabindex="-1"></a><span class="co">Survivorship, vergessene Kosten. Alle drei kann man einem Programm ansehen,</span></span>
-<span id="cb200-9"><a href="#cb200-9" aria-hidden="true" tabindex="-1"></a><span class="co">wenn man es liest.</span></span>
-<span id="cb200-10"><a href="#cb200-10" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb200-11"><a href="#cb200-11" aria-hidden="true" tabindex="-1"></a><span class="co">Die beiden anderen - Overfitting und Data Snooping - entstehen nicht im</span></span>
-<span id="cb200-12"><a href="#cb200-12" aria-hidden="true" tabindex="-1"></a><span class="co">Backtest, sondern in der ARBEITSWEISE davor. Sie hinterlassen im Code keine</span></span>
-<span id="cb200-13"><a href="#cb200-13" aria-hidden="true" tabindex="-1"></a><span class="co">Spur. Ein Backtest, der zwanzigmal angepasst wurde, sieht am Ende genauso</span></span>
-<span id="cb200-14"><a href="#cb200-14" aria-hidden="true" tabindex="-1"></a><span class="co">sauber aus wie einer, der beim ersten Versuch funktioniert hat.</span></span>
-<span id="cb200-15"><a href="#cb200-15" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb200-16"><a href="#cb200-16" aria-hidden="true" tabindex="-1"></a><span class="co">Dieses Programm macht den Effekt messbar. Es testet Strategien, die</span></span>
-<span id="cb200-17"><a href="#cb200-17" aria-hidden="true" tabindex="-1"></a><span class="co">NACHWEISLICH keinerlei Prognosekraft haben (ihre taeglichen Ergebnisse sind</span></span>
-<span id="cb200-18"><a href="#cb200-18" aria-hidden="true" tabindex="-1"></a><span class="co">Zufallszahlen mit Erwartungswert exakt null), und zeigt, wie gut die jeweils</span></span>
-<span id="cb200-19"><a href="#cb200-19" aria-hidden="true" tabindex="-1"></a><span class="co">BESTE davon aussieht - allein als Funktion der Anzahl der Versuche.</span></span>
-<span id="cb200-20"><a href="#cb200-20" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb200-21"><a href="#cb200-21" aria-hidden="true" tabindex="-1"></a><span class="co">Benoetigt: numpy, scipy</span></span>
-<span id="cb200-22"><a href="#cb200-22" aria-hidden="true" tabindex="-1"></a><span class="co">&quot;&quot;&quot;</span></span>
-<span id="cb200-23"><a href="#cb200-23" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb200-24"><a href="#cb200-24" aria-hidden="true" tabindex="-1"></a><span class="im">from</span> __future__ <span class="im">import</span> annotations</span>
-<span id="cb200-25"><a href="#cb200-25" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb200-26"><a href="#cb200-26" aria-hidden="true" tabindex="-1"></a><span class="im">import</span> numpy <span class="im">as</span> np</span>
-<span id="cb200-27"><a href="#cb200-27" aria-hidden="true" tabindex="-1"></a><span class="im">from</span> scipy <span class="im">import</span> stats</span>
-<span id="cb200-28"><a href="#cb200-28" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb200-29"><a href="#cb200-29" aria-hidden="true" tabindex="-1"></a>HANDELSTAGE <span class="op">=</span> <span class="dv">1260</span>               <span class="co"># fuenf Jahre</span></span>
-<span id="cb200-30"><a href="#cb200-30" aria-hidden="true" tabindex="-1"></a>TAGESSCHWANKUNG <span class="op">=</span> <span class="fl">0.010</span>          <span class="co"># 1 % taeglich</span></span>
-<span id="cb200-31"><a href="#cb200-31" aria-hidden="true" tabindex="-1"></a>WIEDERHOLUNGEN <span class="op">=</span> <span class="dv">300</span>             <span class="co"># damit die Tabelle nicht vom Zufall abhaengt</span></span>
-<span id="cb200-32"><a href="#cb200-32" aria-hidden="true" tabindex="-1"></a>NIVEAU <span class="op">=</span> <span class="fl">0.05</span></span>
-<span id="cb200-33"><a href="#cb200-33" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb200-34"><a href="#cb200-34" aria-hidden="true" tabindex="-1"></a>RNG <span class="op">=</span> np.random.default_rng(<span class="dv">42</span>)</span>
-<span id="cb200-35"><a href="#cb200-35" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb200-36"><a href="#cb200-36" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb200-37"><a href="#cb200-37" aria-hidden="true" tabindex="-1"></a><span class="kw">def</span> bewerte(ergebnisse: np.ndarray) <span class="op">-&gt;</span> <span class="bu">tuple</span>[np.ndarray, np.ndarray]:</span>
-<span id="cb200-38"><a href="#cb200-38" aria-hidden="true" tabindex="-1"></a>    <span class="co">&quot;&quot;&quot;Sharpe-Kennzahl und einseitiger p-Wert je Strategie.</span></span>
-<span id="cb200-39"><a href="#cb200-39" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb200-40"><a href="#cb200-40" aria-hidden="true" tabindex="-1"></a><span class="co">    ergebnisse hat die Form (Strategien, Handelstage). Der p-Wert prueft die</span></span>
-<span id="cb200-41"><a href="#cb200-41" aria-hidden="true" tabindex="-1"></a><span class="co">    Nullhypothese &#39;mittleres Tagesergebnis ist null&#39; - also genau die Frage,</span></span>
-<span id="cb200-42"><a href="#cb200-42" aria-hidden="true" tabindex="-1"></a><span class="co">    die ein Backtest beantworten soll.</span></span>
-<span id="cb200-43"><a href="#cb200-43" aria-hidden="true" tabindex="-1"></a><span class="co">    &quot;&quot;&quot;</span></span>
-<span id="cb200-44"><a href="#cb200-44" aria-hidden="true" tabindex="-1"></a>    mittel <span class="op">=</span> ergebnisse.mean(axis<span class="op">=</span><span class="dv">1</span>)</span>
-<span id="cb200-45"><a href="#cb200-45" aria-hidden="true" tabindex="-1"></a>    streuung <span class="op">=</span> ergebnisse.std(axis<span class="op">=</span><span class="dv">1</span>, ddof<span class="op">=</span><span class="dv">1</span>)</span>
-<span id="cb200-46"><a href="#cb200-46" aria-hidden="true" tabindex="-1"></a>    sharpe <span class="op">=</span> mittel <span class="op">/</span> streuung <span class="op">*</span> np.sqrt(<span class="dv">252</span>)</span>
-<span id="cb200-47"><a href="#cb200-47" aria-hidden="true" tabindex="-1"></a>    t_wert <span class="op">=</span> mittel <span class="op">/</span> (streuung <span class="op">/</span> np.sqrt(ergebnisse.shape[<span class="dv">1</span>]))</span>
-<span id="cb200-48"><a href="#cb200-48" aria-hidden="true" tabindex="-1"></a>    <span class="cf">return</span> sharpe, stats.t.sf(t_wert, ergebnisse.shape[<span class="dv">1</span>] <span class="op">-</span> <span class="dv">1</span>)</span>
-<span id="cb200-49"><a href="#cb200-49" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb200-50"><a href="#cb200-50" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb200-51"><a href="#cb200-51" aria-hidden="true" tabindex="-1"></a><span class="kw">def</span> probiere(anzahl_strategien: <span class="bu">int</span>) <span class="op">-&gt;</span> <span class="bu">tuple</span>[<span class="bu">float</span>, <span class="bu">float</span>, <span class="bu">float</span>, <span class="bu">float</span>]:</span>
-<span id="cb200-52"><a href="#cb200-52" aria-hidden="true" tabindex="-1"></a>    <span class="co">&quot;&quot;&quot;Liefert (beste Sharpe, ihr p-Wert, Anteil scheinbar signifikanter,</span></span>
-<span id="cb200-53"><a href="#cb200-53" aria-hidden="true" tabindex="-1"></a><span class="co">    Anteil, der auch die Bonferroni-Huerde nimmt) - gemittelt ueber</span></span>
-<span id="cb200-54"><a href="#cb200-54" aria-hidden="true" tabindex="-1"></a><span class="co">    WIEDERHOLUNGEN unabhaengige Durchgaenge.&quot;&quot;&quot;</span></span>
-<span id="cb200-55"><a href="#cb200-55" aria-hidden="true" tabindex="-1"></a>    beste_sharpe, beste_p, anteil_signifikant, ueberlebt_bonferroni <span class="op">=</span> [], [], [], []</span>
-<span id="cb200-56"><a href="#cb200-56" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb200-57"><a href="#cb200-57" aria-hidden="true" tabindex="-1"></a>    <span class="cf">for</span> _ <span class="kw">in</span> <span class="bu">range</span>(WIEDERHOLUNGEN):</span>
-<span id="cb200-58"><a href="#cb200-58" aria-hidden="true" tabindex="-1"></a>        <span class="co"># Der springende Punkt: Erwartungswert exakt 0. Keine dieser</span></span>
-<span id="cb200-59"><a href="#cb200-59" aria-hidden="true" tabindex="-1"></a>        <span class="co"># Strategien hat einen echten Vorteil - per Konstruktion.</span></span>
-<span id="cb200-60"><a href="#cb200-60" aria-hidden="true" tabindex="-1"></a>        ergebnisse <span class="op">=</span> RNG.normal(<span class="fl">0.0</span>, TAGESSCHWANKUNG,</span>
-<span id="cb200-61"><a href="#cb200-61" aria-hidden="true" tabindex="-1"></a>                                (anzahl_strategien, HANDELSTAGE))</span>
-<span id="cb200-62"><a href="#cb200-62" aria-hidden="true" tabindex="-1"></a>        sharpe, p_werte <span class="op">=</span> bewerte(ergebnisse)</span>
-<span id="cb200-63"><a href="#cb200-63" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb200-64"><a href="#cb200-64" aria-hidden="true" tabindex="-1"></a>        beste <span class="op">=</span> <span class="bu">int</span>(sharpe.argmax())</span>
-<span id="cb200-65"><a href="#cb200-65" aria-hidden="true" tabindex="-1"></a>        beste_sharpe.append(<span class="bu">float</span>(sharpe[beste]))</span>
-<span id="cb200-66"><a href="#cb200-66" aria-hidden="true" tabindex="-1"></a>        beste_p.append(<span class="bu">float</span>(p_werte[beste]))</span>
-<span id="cb200-67"><a href="#cb200-67" aria-hidden="true" tabindex="-1"></a>        anteil_signifikant.append(<span class="bu">float</span>((p_werte <span class="op">&lt;</span> NIVEAU).mean()))</span>
-<span id="cb200-68"><a href="#cb200-68" aria-hidden="true" tabindex="-1"></a>        <span class="co"># Bonferroni: Wer n Tests macht, muss die Huerde durch n teilen.</span></span>
-<span id="cb200-69"><a href="#cb200-69" aria-hidden="true" tabindex="-1"></a>        ueberlebt_bonferroni.append(</span>
-<span id="cb200-70"><a href="#cb200-70" aria-hidden="true" tabindex="-1"></a>            <span class="bu">float</span>((p_werte <span class="op">&lt;</span> NIVEAU <span class="op">/</span> anzahl_strategien).mean()))</span>
-<span id="cb200-71"><a href="#cb200-71" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb200-72"><a href="#cb200-72" aria-hidden="true" tabindex="-1"></a>    <span class="cf">return</span> (<span class="bu">float</span>(np.mean(beste_sharpe)), <span class="bu">float</span>(np.mean(beste_p)),</span>
-<span id="cb200-73"><a href="#cb200-73" aria-hidden="true" tabindex="-1"></a>            <span class="bu">float</span>(np.mean(anteil_signifikant)),</span>
-<span id="cb200-74"><a href="#cb200-74" aria-hidden="true" tabindex="-1"></a>            <span class="bu">float</span>(np.mean(ueberlebt_bonferroni)))</span>
-<span id="cb200-75"><a href="#cb200-75" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb200-76"><a href="#cb200-76" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb200-77"><a href="#cb200-77" aria-hidden="true" tabindex="-1"></a><span class="cf">if</span> <span class="va">__name__</span> <span class="op">==</span> <span class="st">&quot;__main__&quot;</span>:</span>
-<span id="cb200-78"><a href="#cb200-78" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;=&quot;</span> <span class="op">*</span> <span class="dv">78</span>)</span>
-<span id="cb200-79"><a href="#cb200-79" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;  WIE GUT SIEHT DIE BESTE VON N STRATEGIEN AUS,&quot;</span>)</span>
-<span id="cb200-80"><a href="#cb200-80" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;  WENN KEINE EINZIGE ETWAS TAUGT?&quot;</span>)</span>
-<span id="cb200-81"><a href="#cb200-81" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;=&quot;</span> <span class="op">*</span> <span class="dv">78</span>)</span>
-<span id="cb200-82"><a href="#cb200-82" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;</span><span class="sc">{</span>HANDELSTAGE<span class="sc">}</span><span class="ss"> Handelstage, taegliche Ergebnisse mit Erwartungswert &quot;</span></span>
-<span id="cb200-83"><a href="#cb200-83" aria-hidden="true" tabindex="-1"></a>          <span class="ss">f&quot;EXAKT null.&quot;</span>)</span>
-<span id="cb200-84"><a href="#cb200-84" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;Jede Zeile ist der Mittelwert aus </span><span class="sc">{</span>WIEDERHOLUNGEN<span class="sc">}</span><span class="ss"> unabhaengigen &quot;</span></span>
-<span id="cb200-85"><a href="#cb200-85" aria-hidden="true" tabindex="-1"></a>          <span class="ss">f&quot;Durchgaengen.</span><span class="ch">\n</span><span class="ss">&quot;</span>)</span>
-<span id="cb200-86"><a href="#cb200-86" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb200-87"><a href="#cb200-87" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;</span><span class="sc">{</span><span class="st">&#39;getestet&#39;</span><span class="sc">:&gt;9}</span><span class="ss"> </span><span class="sc">{</span><span class="st">&#39;beste Sharpe&#39;</span><span class="sc">:&gt;14}</span><span class="ss"> </span><span class="sc">{</span><span class="st">&#39;ihr p-Wert&#39;</span><span class="sc">:&gt;12}</span><span class="ss"> &quot;</span></span>
-<span id="cb200-88"><a href="#cb200-88" aria-hidden="true" tabindex="-1"></a>          <span class="ss">f&quot;</span><span class="sc">{</span><span class="st">&#39;scheinbar sign.&#39;</span><span class="sc">:&gt;16}</span><span class="ss">&quot;</span>)</span>
-<span id="cb200-89"><a href="#cb200-89" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;-&quot;</span> <span class="op">*</span> <span class="dv">78</span>)</span>
-<span id="cb200-90"><a href="#cb200-90" aria-hidden="true" tabindex="-1"></a>    ergebnisse <span class="op">=</span> {}</span>
-<span id="cb200-91"><a href="#cb200-91" aria-hidden="true" tabindex="-1"></a>    <span class="cf">for</span> anzahl <span class="kw">in</span> (<span class="dv">1</span>, <span class="dv">10</span>, <span class="dv">100</span>, <span class="dv">1000</span>):</span>
-<span id="cb200-92"><a href="#cb200-92" aria-hidden="true" tabindex="-1"></a>        sharpe, p_wert, anteil, _ <span class="op">=</span> probiere(anzahl)</span>
-<span id="cb200-93"><a href="#cb200-93" aria-hidden="true" tabindex="-1"></a>        ergebnisse[anzahl] <span class="op">=</span> (sharpe, p_wert, anteil)</span>
-<span id="cb200-94"><a href="#cb200-94" aria-hidden="true" tabindex="-1"></a>        <span class="bu">print</span>(<span class="ss">f&quot;</span><span class="sc">{</span>anzahl<span class="sc">:9d}</span><span class="ss"> </span><span class="sc">{</span>sharpe<span class="sc">:14.2f}</span><span class="ss"> </span><span class="sc">{</span>p_wert<span class="sc">:12.4f}</span><span class="ss"> </span><span class="sc">{</span>anteil <span class="op">*</span> <span class="dv">100</span><span class="sc">:15.1f}</span><span class="ss"> %&quot;</span>)</span>
-<span id="cb200-95"><a href="#cb200-95" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;-&quot;</span> <span class="op">*</span> <span class="dv">78</span>)</span>
-<span id="cb200-96"><a href="#cb200-96" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb200-97"><a href="#cb200-97" aria-hidden="true" tabindex="-1"></a>    sharpe_100, p_100, _ <span class="op">=</span> ergebnisse[<span class="dv">100</span>]</span>
-<span id="cb200-98"><a href="#cb200-98" aria-hidden="true" tabindex="-1"></a>    sharpe_1000, p_1000, _ <span class="op">=</span> ergebnisse[<span class="dv">1000</span>]</span>
-<span id="cb200-99"><a href="#cb200-99" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb200-100"><a href="#cb200-100" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;</span><span class="ch">\n</span><span class="st">Lesen Sie die dritte Spalte von unten nach oben:&quot;</span>)</span>
-<span id="cb200-101"><a href="#cb200-101" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;  Wer </span><span class="sc">{</span><span class="dv">1000</span><span class="sc">}</span><span class="ss"> Varianten durchprobiert, findet eine mit p = </span><span class="sc">{</span>p_1000<span class="sc">:.4f}</span><span class="ss"> -&quot;</span>)</span>
-<span id="cb200-102"><a href="#cb200-102" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;  ein Wert, den jede Zeitschrift als &#39;hochsignifikant&#39; druckt.&quot;</span>)</span>
-<span id="cb200-103"><a href="#cb200-103" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;  Wer </span><span class="sc">{</span><span class="dv">100</span><span class="sc">}</span><span class="ss"> probiert, findet p = </span><span class="sc">{</span>p_100<span class="sc">:.4f}</span><span class="ss"> und eine Sharpe-Kennzahl&quot;</span>)</span>
-<span id="cb200-104"><a href="#cb200-104" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;  von </span><span class="sc">{</span>sharpe_100<span class="sc">:.2f}</span><span class="ss"> - damit geht man zum Vorgesetzten.&quot;</span>)</span>
-<span id="cb200-105"><a href="#cb200-105" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;  Und keine dieser Strategien hat auch nur den Hauch eines Vorteils.&quot;</span>)</span>
-<span id="cb200-106"><a href="#cb200-106" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>()</span>
-<span id="cb200-107"><a href="#cb200-107" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;Die LETZTE Spalte bleibt dagegen konstant bei rund 5 %. Das ist kein&quot;</span>)</span>
-<span id="cb200-108"><a href="#cb200-108" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;Widerspruch, sondern die Definition: Ein Test zum 5-%-Niveau irrt in&quot;</span>)</span>
-<span id="cb200-109"><a href="#cb200-109" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;5 </span><span class="sc">% d</span><span class="st">er Faelle. Was sich aendert, ist nicht der Anteil, sondern die&quot;</span>)</span>
-<span id="cb200-110"><a href="#cb200-110" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;ANZAHL - und weil man nur die beste Strategie praesentiert, sieht man&quot;</span>)</span>
-<span id="cb200-111"><a href="#cb200-111" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;von allen Fehlversuchen genau einen: den erfolgreichsten.&quot;</span>)</span>
-<span id="cb200-112"><a href="#cb200-112" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb200-113"><a href="#cb200-113" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;</span><span class="ch">\n</span><span class="st">&quot;</span> <span class="op">+</span> <span class="st">&quot;=&quot;</span> <span class="op">*</span> <span class="dv">78</span>)</span>
-<span id="cb200-114"><a href="#cb200-114" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;  WAS MAN DAGEGEN TUN KANN&quot;</span>)</span>
-<span id="cb200-115"><a href="#cb200-115" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;=&quot;</span> <span class="op">*</span> <span class="dv">78</span>)</span>
-<span id="cb200-116"><a href="#cb200-116" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;1. ZAEHLEN. Notieren Sie, wie viele Varianten Sie ausprobiert haben -&quot;</span>)</span>
-<span id="cb200-117"><a href="#cb200-117" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;   auch die verworfenen, auch die &#39;nur mal schnell&#39;. Ohne diese Zahl&quot;</span>)</span>
-<span id="cb200-118"><a href="#cb200-118" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;   ist kein p-Wert und keine Sharpe-Kennzahl interpretierbar.&quot;</span>)</span>
-<span id="cb200-119"><a href="#cb200-119" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>()</span>
-<span id="cb200-120"><a href="#cb200-120" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;2. KORRIGIEREN. Die Bonferroni-Korrektur teilt die Huerde durch die&quot;</span>)</span>
-<span id="cb200-121"><a href="#cb200-121" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;   Zahl der Versuche:&quot;</span>)</span>
-<span id="cb200-122"><a href="#cb200-122" aria-hidden="true" tabindex="-1"></a>    <span class="cf">for</span> anzahl <span class="kw">in</span> (<span class="dv">10</span>, <span class="dv">100</span>, <span class="dv">1000</span>):</span>
-<span id="cb200-123"><a href="#cb200-123" aria-hidden="true" tabindex="-1"></a>        <span class="bu">print</span>(<span class="ss">f&quot;     bei </span><span class="sc">{</span>anzahl<span class="sc">:5d}</span><span class="ss"> Versuchen: p &lt; </span><span class="sc">{</span>NIVEAU <span class="op">/</span> anzahl<span class="sc">:.5f}</span><span class="ss"> statt &quot;</span></span>
-<span id="cb200-124"><a href="#cb200-124" aria-hidden="true" tabindex="-1"></a>              <span class="ss">f&quot;p &lt; </span><span class="sc">{</span>NIVEAU<span class="sc">:.2f}</span><span class="ss">&quot;</span>)</span>
-<span id="cb200-125"><a href="#cb200-125" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;   Sie ist konservativ, aber sie ist ehrlich. Fuer Handelsstrategien&quot;</span>)</span>
-<span id="cb200-126"><a href="#cb200-126" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;   gibt es verfeinerte Varianten (Deflated Sharpe Ratio nach Bailey&quot;</span>)</span>
-<span id="cb200-127"><a href="#cb200-127" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;   und Lopez de Prado), die dasselbe Prinzip verfolgen.&quot;</span>)</span>
-<span id="cb200-128"><a href="#cb200-128" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>()</span>
-<span id="cb200-129"><a href="#cb200-129" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;3. ZURUECKHALTEN. Legen Sie einen Zeitraum beiseite, BEVOR Sie&quot;</span>)</span>
-<span id="cb200-130"><a href="#cb200-130" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;   anfangen, und ruehren Sie ihn bis zum Schluss nicht an. Er ist&quot;</span>)</span>
-<span id="cb200-131"><a href="#cb200-131" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;   der einzige Test, den Sie nicht durch Probieren verderben koennen -&quot;</span>)</span>
-<span id="cb200-132"><a href="#cb200-132" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;   und er ist genau einmal verwendbar.&quot;</span>)</span>
-<span id="cb200-133"><a href="#cb200-133" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;=&quot;</span> <span class="op">*</span> <span class="dv">78</span>)</span></code></pre></div>
+<div class="sourceCode" id="cb202"><pre class="sourceCode python"><code class="sourceCode python"><span id="cb202-1"><a href="#cb202-1" aria-hidden="true" tabindex="-1"></a><span class="co">#!/usr/bin/env python3</span></span>
+<span id="cb202-2"><a href="#cb202-2" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb202-3"><a href="#cb202-3" aria-hidden="true" tabindex="-1"></a><span class="co"># Data_Snooping.py</span></span>
+<span id="cb202-4"><a href="#cb202-4" aria-hidden="true" tabindex="-1"></a><span class="co">&quot;&quot;&quot;</span></span>
+<span id="cb202-5"><a href="#cb202-5" aria-hidden="true" tabindex="-1"></a><span class="co">Kapitel Handelsmaschine: Die Selbsttaeuschung, die man einem Backtest nicht ansieht.</span></span>
+<span id="cb202-6"><a href="#cb202-6" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb202-7"><a href="#cb202-7" aria-hidden="true" tabindex="-1"></a><span class="co">Backtest_Fallen.py zeigt drei Fehler, die IM Backtest stecken: Lookahead,</span></span>
+<span id="cb202-8"><a href="#cb202-8" aria-hidden="true" tabindex="-1"></a><span class="co">Survivorship, vergessene Kosten. Alle drei kann man einem Programm ansehen,</span></span>
+<span id="cb202-9"><a href="#cb202-9" aria-hidden="true" tabindex="-1"></a><span class="co">wenn man es liest.</span></span>
+<span id="cb202-10"><a href="#cb202-10" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb202-11"><a href="#cb202-11" aria-hidden="true" tabindex="-1"></a><span class="co">Die beiden anderen - Overfitting und Data Snooping - entstehen nicht im</span></span>
+<span id="cb202-12"><a href="#cb202-12" aria-hidden="true" tabindex="-1"></a><span class="co">Backtest, sondern in der ARBEITSWEISE davor. Sie hinterlassen im Code keine</span></span>
+<span id="cb202-13"><a href="#cb202-13" aria-hidden="true" tabindex="-1"></a><span class="co">Spur. Ein Backtest, der zwanzigmal angepasst wurde, sieht am Ende genauso</span></span>
+<span id="cb202-14"><a href="#cb202-14" aria-hidden="true" tabindex="-1"></a><span class="co">sauber aus wie einer, der beim ersten Versuch funktioniert hat.</span></span>
+<span id="cb202-15"><a href="#cb202-15" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb202-16"><a href="#cb202-16" aria-hidden="true" tabindex="-1"></a><span class="co">Dieses Programm macht den Effekt messbar. Es testet Strategien, die</span></span>
+<span id="cb202-17"><a href="#cb202-17" aria-hidden="true" tabindex="-1"></a><span class="co">NACHWEISLICH keinerlei Prognosekraft haben (ihre taeglichen Ergebnisse sind</span></span>
+<span id="cb202-18"><a href="#cb202-18" aria-hidden="true" tabindex="-1"></a><span class="co">Zufallszahlen mit Erwartungswert exakt null), und zeigt, wie gut die jeweils</span></span>
+<span id="cb202-19"><a href="#cb202-19" aria-hidden="true" tabindex="-1"></a><span class="co">BESTE davon aussieht - allein als Funktion der Anzahl der Versuche.</span></span>
+<span id="cb202-20"><a href="#cb202-20" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb202-21"><a href="#cb202-21" aria-hidden="true" tabindex="-1"></a><span class="co">Benoetigt: numpy, scipy</span></span>
+<span id="cb202-22"><a href="#cb202-22" aria-hidden="true" tabindex="-1"></a><span class="co">&quot;&quot;&quot;</span></span>
+<span id="cb202-23"><a href="#cb202-23" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb202-24"><a href="#cb202-24" aria-hidden="true" tabindex="-1"></a><span class="im">from</span> __future__ <span class="im">import</span> annotations</span>
+<span id="cb202-25"><a href="#cb202-25" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb202-26"><a href="#cb202-26" aria-hidden="true" tabindex="-1"></a><span class="im">import</span> numpy <span class="im">as</span> np</span>
+<span id="cb202-27"><a href="#cb202-27" aria-hidden="true" tabindex="-1"></a><span class="im">from</span> scipy <span class="im">import</span> stats</span>
+<span id="cb202-28"><a href="#cb202-28" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb202-29"><a href="#cb202-29" aria-hidden="true" tabindex="-1"></a>HANDELSTAGE <span class="op">=</span> <span class="dv">1260</span>               <span class="co"># fuenf Jahre</span></span>
+<span id="cb202-30"><a href="#cb202-30" aria-hidden="true" tabindex="-1"></a>TAGESSCHWANKUNG <span class="op">=</span> <span class="fl">0.010</span>          <span class="co"># 1 % taeglich</span></span>
+<span id="cb202-31"><a href="#cb202-31" aria-hidden="true" tabindex="-1"></a>WIEDERHOLUNGEN <span class="op">=</span> <span class="dv">300</span>             <span class="co"># damit die Tabelle nicht vom Zufall abhaengt</span></span>
+<span id="cb202-32"><a href="#cb202-32" aria-hidden="true" tabindex="-1"></a>NIVEAU <span class="op">=</span> <span class="fl">0.05</span></span>
+<span id="cb202-33"><a href="#cb202-33" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb202-34"><a href="#cb202-34" aria-hidden="true" tabindex="-1"></a>RNG <span class="op">=</span> np.random.default_rng(<span class="dv">42</span>)</span>
+<span id="cb202-35"><a href="#cb202-35" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb202-36"><a href="#cb202-36" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb202-37"><a href="#cb202-37" aria-hidden="true" tabindex="-1"></a><span class="kw">def</span> bewerte(ergebnisse: np.ndarray) <span class="op">-&gt;</span> <span class="bu">tuple</span>[np.ndarray, np.ndarray]:</span>
+<span id="cb202-38"><a href="#cb202-38" aria-hidden="true" tabindex="-1"></a>    <span class="co">&quot;&quot;&quot;Sharpe-Kennzahl und einseitiger p-Wert je Strategie.</span></span>
+<span id="cb202-39"><a href="#cb202-39" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb202-40"><a href="#cb202-40" aria-hidden="true" tabindex="-1"></a><span class="co">    ergebnisse hat die Form (Strategien, Handelstage). Der p-Wert prueft die</span></span>
+<span id="cb202-41"><a href="#cb202-41" aria-hidden="true" tabindex="-1"></a><span class="co">    Nullhypothese &#39;mittleres Tagesergebnis ist null&#39; - also genau die Frage,</span></span>
+<span id="cb202-42"><a href="#cb202-42" aria-hidden="true" tabindex="-1"></a><span class="co">    die ein Backtest beantworten soll.</span></span>
+<span id="cb202-43"><a href="#cb202-43" aria-hidden="true" tabindex="-1"></a><span class="co">    &quot;&quot;&quot;</span></span>
+<span id="cb202-44"><a href="#cb202-44" aria-hidden="true" tabindex="-1"></a>    mittel <span class="op">=</span> ergebnisse.mean(axis<span class="op">=</span><span class="dv">1</span>)</span>
+<span id="cb202-45"><a href="#cb202-45" aria-hidden="true" tabindex="-1"></a>    streuung <span class="op">=</span> ergebnisse.std(axis<span class="op">=</span><span class="dv">1</span>, ddof<span class="op">=</span><span class="dv">1</span>)</span>
+<span id="cb202-46"><a href="#cb202-46" aria-hidden="true" tabindex="-1"></a>    sharpe <span class="op">=</span> mittel <span class="op">/</span> streuung <span class="op">*</span> np.sqrt(<span class="dv">252</span>)</span>
+<span id="cb202-47"><a href="#cb202-47" aria-hidden="true" tabindex="-1"></a>    t_wert <span class="op">=</span> mittel <span class="op">/</span> (streuung <span class="op">/</span> np.sqrt(ergebnisse.shape[<span class="dv">1</span>]))</span>
+<span id="cb202-48"><a href="#cb202-48" aria-hidden="true" tabindex="-1"></a>    <span class="cf">return</span> sharpe, stats.t.sf(t_wert, ergebnisse.shape[<span class="dv">1</span>] <span class="op">-</span> <span class="dv">1</span>)</span>
+<span id="cb202-49"><a href="#cb202-49" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb202-50"><a href="#cb202-50" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb202-51"><a href="#cb202-51" aria-hidden="true" tabindex="-1"></a><span class="kw">def</span> probiere(anzahl_strategien: <span class="bu">int</span>) <span class="op">-&gt;</span> <span class="bu">tuple</span>[<span class="bu">float</span>, <span class="bu">float</span>, <span class="bu">float</span>, <span class="bu">float</span>]:</span>
+<span id="cb202-52"><a href="#cb202-52" aria-hidden="true" tabindex="-1"></a>    <span class="co">&quot;&quot;&quot;Liefert (beste Sharpe, ihr p-Wert, Anteil scheinbar signifikanter,</span></span>
+<span id="cb202-53"><a href="#cb202-53" aria-hidden="true" tabindex="-1"></a><span class="co">    Anteil, der auch die Bonferroni-Huerde nimmt) - gemittelt ueber</span></span>
+<span id="cb202-54"><a href="#cb202-54" aria-hidden="true" tabindex="-1"></a><span class="co">    WIEDERHOLUNGEN unabhaengige Durchgaenge.&quot;&quot;&quot;</span></span>
+<span id="cb202-55"><a href="#cb202-55" aria-hidden="true" tabindex="-1"></a>    beste_sharpe, beste_p, anteil_signifikant, ueberlebt_bonferroni <span class="op">=</span> [], [], [], []</span>
+<span id="cb202-56"><a href="#cb202-56" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb202-57"><a href="#cb202-57" aria-hidden="true" tabindex="-1"></a>    <span class="cf">for</span> _ <span class="kw">in</span> <span class="bu">range</span>(WIEDERHOLUNGEN):</span>
+<span id="cb202-58"><a href="#cb202-58" aria-hidden="true" tabindex="-1"></a>        <span class="co"># Der springende Punkt: Erwartungswert exakt 0. Keine dieser</span></span>
+<span id="cb202-59"><a href="#cb202-59" aria-hidden="true" tabindex="-1"></a>        <span class="co"># Strategien hat einen echten Vorteil - per Konstruktion.</span></span>
+<span id="cb202-60"><a href="#cb202-60" aria-hidden="true" tabindex="-1"></a>        ergebnisse <span class="op">=</span> RNG.normal(<span class="fl">0.0</span>, TAGESSCHWANKUNG,</span>
+<span id="cb202-61"><a href="#cb202-61" aria-hidden="true" tabindex="-1"></a>                                (anzahl_strategien, HANDELSTAGE))</span>
+<span id="cb202-62"><a href="#cb202-62" aria-hidden="true" tabindex="-1"></a>        sharpe, p_werte <span class="op">=</span> bewerte(ergebnisse)</span>
+<span id="cb202-63"><a href="#cb202-63" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb202-64"><a href="#cb202-64" aria-hidden="true" tabindex="-1"></a>        beste <span class="op">=</span> <span class="bu">int</span>(sharpe.argmax())</span>
+<span id="cb202-65"><a href="#cb202-65" aria-hidden="true" tabindex="-1"></a>        beste_sharpe.append(<span class="bu">float</span>(sharpe[beste]))</span>
+<span id="cb202-66"><a href="#cb202-66" aria-hidden="true" tabindex="-1"></a>        beste_p.append(<span class="bu">float</span>(p_werte[beste]))</span>
+<span id="cb202-67"><a href="#cb202-67" aria-hidden="true" tabindex="-1"></a>        anteil_signifikant.append(<span class="bu">float</span>((p_werte <span class="op">&lt;</span> NIVEAU).mean()))</span>
+<span id="cb202-68"><a href="#cb202-68" aria-hidden="true" tabindex="-1"></a>        <span class="co"># Bonferroni: Wer n Tests macht, muss die Huerde durch n teilen.</span></span>
+<span id="cb202-69"><a href="#cb202-69" aria-hidden="true" tabindex="-1"></a>        ueberlebt_bonferroni.append(</span>
+<span id="cb202-70"><a href="#cb202-70" aria-hidden="true" tabindex="-1"></a>            <span class="bu">float</span>((p_werte <span class="op">&lt;</span> NIVEAU <span class="op">/</span> anzahl_strategien).mean()))</span>
+<span id="cb202-71"><a href="#cb202-71" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb202-72"><a href="#cb202-72" aria-hidden="true" tabindex="-1"></a>    <span class="cf">return</span> (<span class="bu">float</span>(np.mean(beste_sharpe)), <span class="bu">float</span>(np.mean(beste_p)),</span>
+<span id="cb202-73"><a href="#cb202-73" aria-hidden="true" tabindex="-1"></a>            <span class="bu">float</span>(np.mean(anteil_signifikant)),</span>
+<span id="cb202-74"><a href="#cb202-74" aria-hidden="true" tabindex="-1"></a>            <span class="bu">float</span>(np.mean(ueberlebt_bonferroni)))</span>
+<span id="cb202-75"><a href="#cb202-75" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb202-76"><a href="#cb202-76" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb202-77"><a href="#cb202-77" aria-hidden="true" tabindex="-1"></a><span class="cf">if</span> <span class="va">__name__</span> <span class="op">==</span> <span class="st">&quot;__main__&quot;</span>:</span>
+<span id="cb202-78"><a href="#cb202-78" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;=&quot;</span> <span class="op">*</span> <span class="dv">78</span>)</span>
+<span id="cb202-79"><a href="#cb202-79" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;  WIE GUT SIEHT DIE BESTE VON N STRATEGIEN AUS,&quot;</span>)</span>
+<span id="cb202-80"><a href="#cb202-80" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;  WENN KEINE EINZIGE ETWAS TAUGT?&quot;</span>)</span>
+<span id="cb202-81"><a href="#cb202-81" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;=&quot;</span> <span class="op">*</span> <span class="dv">78</span>)</span>
+<span id="cb202-82"><a href="#cb202-82" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;</span><span class="sc">{</span>HANDELSTAGE<span class="sc">}</span><span class="ss"> Handelstage, taegliche Ergebnisse mit Erwartungswert &quot;</span></span>
+<span id="cb202-83"><a href="#cb202-83" aria-hidden="true" tabindex="-1"></a>          <span class="ss">f&quot;EXAKT null.&quot;</span>)</span>
+<span id="cb202-84"><a href="#cb202-84" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;Jede Zeile ist der Mittelwert aus </span><span class="sc">{</span>WIEDERHOLUNGEN<span class="sc">}</span><span class="ss"> unabhaengigen &quot;</span></span>
+<span id="cb202-85"><a href="#cb202-85" aria-hidden="true" tabindex="-1"></a>          <span class="ss">f&quot;Durchgaengen.</span><span class="ch">\n</span><span class="ss">&quot;</span>)</span>
+<span id="cb202-86"><a href="#cb202-86" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb202-87"><a href="#cb202-87" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;</span><span class="sc">{</span><span class="st">&#39;getestet&#39;</span><span class="sc">:&gt;9}</span><span class="ss"> </span><span class="sc">{</span><span class="st">&#39;beste Sharpe&#39;</span><span class="sc">:&gt;14}</span><span class="ss"> </span><span class="sc">{</span><span class="st">&#39;ihr p-Wert&#39;</span><span class="sc">:&gt;12}</span><span class="ss"> &quot;</span></span>
+<span id="cb202-88"><a href="#cb202-88" aria-hidden="true" tabindex="-1"></a>          <span class="ss">f&quot;</span><span class="sc">{</span><span class="st">&#39;scheinbar sign.&#39;</span><span class="sc">:&gt;16}</span><span class="ss">&quot;</span>)</span>
+<span id="cb202-89"><a href="#cb202-89" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;-&quot;</span> <span class="op">*</span> <span class="dv">78</span>)</span>
+<span id="cb202-90"><a href="#cb202-90" aria-hidden="true" tabindex="-1"></a>    ergebnisse <span class="op">=</span> {}</span>
+<span id="cb202-91"><a href="#cb202-91" aria-hidden="true" tabindex="-1"></a>    <span class="cf">for</span> anzahl <span class="kw">in</span> (<span class="dv">1</span>, <span class="dv">10</span>, <span class="dv">100</span>, <span class="dv">1000</span>):</span>
+<span id="cb202-92"><a href="#cb202-92" aria-hidden="true" tabindex="-1"></a>        sharpe, p_wert, anteil, _ <span class="op">=</span> probiere(anzahl)</span>
+<span id="cb202-93"><a href="#cb202-93" aria-hidden="true" tabindex="-1"></a>        ergebnisse[anzahl] <span class="op">=</span> (sharpe, p_wert, anteil)</span>
+<span id="cb202-94"><a href="#cb202-94" aria-hidden="true" tabindex="-1"></a>        <span class="bu">print</span>(<span class="ss">f&quot;</span><span class="sc">{</span>anzahl<span class="sc">:9d}</span><span class="ss"> </span><span class="sc">{</span>sharpe<span class="sc">:14.2f}</span><span class="ss"> </span><span class="sc">{</span>p_wert<span class="sc">:12.4f}</span><span class="ss"> </span><span class="sc">{</span>anteil <span class="op">*</span> <span class="dv">100</span><span class="sc">:15.1f}</span><span class="ss"> %&quot;</span>)</span>
+<span id="cb202-95"><a href="#cb202-95" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;-&quot;</span> <span class="op">*</span> <span class="dv">78</span>)</span>
+<span id="cb202-96"><a href="#cb202-96" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb202-97"><a href="#cb202-97" aria-hidden="true" tabindex="-1"></a>    sharpe_100, p_100, _ <span class="op">=</span> ergebnisse[<span class="dv">100</span>]</span>
+<span id="cb202-98"><a href="#cb202-98" aria-hidden="true" tabindex="-1"></a>    sharpe_1000, p_1000, _ <span class="op">=</span> ergebnisse[<span class="dv">1000</span>]</span>
+<span id="cb202-99"><a href="#cb202-99" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb202-100"><a href="#cb202-100" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;</span><span class="ch">\n</span><span class="st">Lesen Sie die dritte Spalte von unten nach oben:&quot;</span>)</span>
+<span id="cb202-101"><a href="#cb202-101" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;  Wer </span><span class="sc">{</span><span class="dv">1000</span><span class="sc">}</span><span class="ss"> Varianten durchprobiert, findet eine mit p = </span><span class="sc">{</span>p_1000<span class="sc">:.4f}</span><span class="ss"> -&quot;</span>)</span>
+<span id="cb202-102"><a href="#cb202-102" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;  ein Wert, den jede Zeitschrift als &#39;hochsignifikant&#39; druckt.&quot;</span>)</span>
+<span id="cb202-103"><a href="#cb202-103" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;  Wer </span><span class="sc">{</span><span class="dv">100</span><span class="sc">}</span><span class="ss"> probiert, findet p = </span><span class="sc">{</span>p_100<span class="sc">:.4f}</span><span class="ss"> und eine Sharpe-Kennzahl&quot;</span>)</span>
+<span id="cb202-104"><a href="#cb202-104" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;  von </span><span class="sc">{</span>sharpe_100<span class="sc">:.2f}</span><span class="ss"> - damit geht man zum Vorgesetzten.&quot;</span>)</span>
+<span id="cb202-105"><a href="#cb202-105" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;  Und keine dieser Strategien hat auch nur den Hauch eines Vorteils.&quot;</span>)</span>
+<span id="cb202-106"><a href="#cb202-106" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>()</span>
+<span id="cb202-107"><a href="#cb202-107" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;Die LETZTE Spalte bleibt dagegen konstant bei rund 5 %. Das ist kein&quot;</span>)</span>
+<span id="cb202-108"><a href="#cb202-108" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;Widerspruch, sondern die Definition: Ein Test zum 5-%-Niveau irrt in&quot;</span>)</span>
+<span id="cb202-109"><a href="#cb202-109" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;5 </span><span class="sc">% d</span><span class="st">er Faelle. Was sich aendert, ist nicht der Anteil, sondern die&quot;</span>)</span>
+<span id="cb202-110"><a href="#cb202-110" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;ANZAHL - und weil man nur die beste Strategie praesentiert, sieht man&quot;</span>)</span>
+<span id="cb202-111"><a href="#cb202-111" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;von allen Fehlversuchen genau einen: den erfolgreichsten.&quot;</span>)</span>
+<span id="cb202-112"><a href="#cb202-112" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb202-113"><a href="#cb202-113" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;</span><span class="ch">\n</span><span class="st">&quot;</span> <span class="op">+</span> <span class="st">&quot;=&quot;</span> <span class="op">*</span> <span class="dv">78</span>)</span>
+<span id="cb202-114"><a href="#cb202-114" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;  WAS MAN DAGEGEN TUN KANN&quot;</span>)</span>
+<span id="cb202-115"><a href="#cb202-115" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;=&quot;</span> <span class="op">*</span> <span class="dv">78</span>)</span>
+<span id="cb202-116"><a href="#cb202-116" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;1. ZAEHLEN. Notieren Sie, wie viele Varianten Sie ausprobiert haben -&quot;</span>)</span>
+<span id="cb202-117"><a href="#cb202-117" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;   auch die verworfenen, auch die &#39;nur mal schnell&#39;. Ohne diese Zahl&quot;</span>)</span>
+<span id="cb202-118"><a href="#cb202-118" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;   ist kein p-Wert und keine Sharpe-Kennzahl interpretierbar.&quot;</span>)</span>
+<span id="cb202-119"><a href="#cb202-119" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>()</span>
+<span id="cb202-120"><a href="#cb202-120" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;2. KORRIGIEREN. Die Bonferroni-Korrektur teilt die Huerde durch die&quot;</span>)</span>
+<span id="cb202-121"><a href="#cb202-121" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;   Zahl der Versuche:&quot;</span>)</span>
+<span id="cb202-122"><a href="#cb202-122" aria-hidden="true" tabindex="-1"></a>    <span class="cf">for</span> anzahl <span class="kw">in</span> (<span class="dv">10</span>, <span class="dv">100</span>, <span class="dv">1000</span>):</span>
+<span id="cb202-123"><a href="#cb202-123" aria-hidden="true" tabindex="-1"></a>        <span class="bu">print</span>(<span class="ss">f&quot;     bei </span><span class="sc">{</span>anzahl<span class="sc">:5d}</span><span class="ss"> Versuchen: p &lt; </span><span class="sc">{</span>NIVEAU <span class="op">/</span> anzahl<span class="sc">:.5f}</span><span class="ss"> statt &quot;</span></span>
+<span id="cb202-124"><a href="#cb202-124" aria-hidden="true" tabindex="-1"></a>              <span class="ss">f&quot;p &lt; </span><span class="sc">{</span>NIVEAU<span class="sc">:.2f}</span><span class="ss">&quot;</span>)</span>
+<span id="cb202-125"><a href="#cb202-125" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;   Sie ist konservativ, aber sie ist ehrlich. Fuer Handelsstrategien&quot;</span>)</span>
+<span id="cb202-126"><a href="#cb202-126" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;   gibt es verfeinerte Varianten (Deflated Sharpe Ratio nach Bailey&quot;</span>)</span>
+<span id="cb202-127"><a href="#cb202-127" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;   und Lopez de Prado), die dasselbe Prinzip verfolgen.&quot;</span>)</span>
+<span id="cb202-128"><a href="#cb202-128" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>()</span>
+<span id="cb202-129"><a href="#cb202-129" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;3. ZURUECKHALTEN. Legen Sie einen Zeitraum beiseite, BEVOR Sie&quot;</span>)</span>
+<span id="cb202-130"><a href="#cb202-130" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;   anfangen, und ruehren Sie ihn bis zum Schluss nicht an. Er ist&quot;</span>)</span>
+<span id="cb202-131"><a href="#cb202-131" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;   der einzige Test, den Sie nicht durch Probieren verderben koennen -&quot;</span>)</span>
+<span id="cb202-132"><a href="#cb202-132" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;   und er ist genau einmal verwendbar.&quot;</span>)</span>
+<span id="cb202-133"><a href="#cb202-133" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;=&quot;</span> <span class="op">*</span> <span class="dv">78</span>)</span></code></pre></div>
 <p><strong>Erwartete Ausgabe:</strong></p>
 <pre><code>==============================================================================
   WIE GUT SIEHT DIE BESTE VON N STRATEGIEN AUS,
@@ -24601,7 +25577,7 @@ von allen Fehlversuchen genau einen: den erfolgreichsten.
 <hr />
 <h2 id="sec:handelsmaschine-quiz">21.10 Micro-Quiz</h2>
 <blockquote>
-<p><strong>❓ Micro-Quiz 14: Drei Fragen zum Selbstcheck</strong></p>
+<p><strong>❓ Micro-Quiz 21: Drei Fragen zum Selbstcheck</strong></p>
 <p>Genau eine Antwort ist jeweils richtig. Auflösung in <a href="#quiz-loesung-handelsmaschine">Anhang A</a>.</p>
 <p><strong>1. Zwei Strategien haben dieselbe Jahresrendite und dieselbe Sharpe-Kennzahl. Was wissen Sie über ihren Verlauf?</strong> (a) Er ist im Wesentlichen gleich — beide Kennzahlen zusammen beschreiben ihn vollständig. (b) <strong>Nichts.</strong> Beide Kennzahlen mitteln über die Zeit und verlieren die Reihenfolge. Dieselben Tagesrenditen können zu einem Rückschlag von 19 % oder von 98 % führen. (c) Die Strategie mit der höheren Schwankung hat den größeren Rückschlag.</p>
 <p><strong>2. Sie haben 50 Strategievarianten getestet und die beste erreicht p = 0,01. Wie bewerten Sie das?</strong> (a) Hochsignifikant — die Wahrscheinlichkeit eines Zufallsbefunds liegt bei 1 %. (b) Bei 50 Versuchen ist ein p-Wert von 0,01 unauffällig: Schon rein zufällig erwartet man etwa 2,5 Treffer unter dem 5-%-Niveau. Die Bonferroni-Schwelle läge bei 0,001. (c) Der p-Wert ist für Handelsstrategien grundsätzlich ungeeignet.</p>
@@ -24633,6 +25609,104 @@ von allen Fehlversuchen genau einen: den erfolgreichsten.
 </ul>
 <p><strong>Ausblick.</strong> <a href="#kap-praxisfallen">Kapitel 22</a> zieht die Summe aus allen Teilen: die typischen Praxisfallen und der Weg vom Skript zum produktiven System.</p>
 <hr />
+<h1 id="synthese-teil-iv-zwei-domänen-dieselbe-mathematik">Synthese Teil IV — Zwei Domänen, dieselbe Mathematik</h1>
+<p>Sechs Kapitel, zwei Branchen, die sich für unvergleichbar halten. Die Werkstatt plant Maschinen, das Depot plant Titel — und beide lösen dasselbe Problem: <strong>knappe Mittel auf konkurrierende Verwendungen verteilen, unter Unsicherheit.</strong></p>
+<h2 id="dieselbe-struktur-andere-namen">Dieselbe Struktur, andere Namen</h2>
+<table>
+<colgroup>
+<col style="width: 33%" />
+<col style="width: 33%" />
+<col style="width: 33%" />
+</colgroup>
+<thead>
+<tr class="header">
+<th>Werkstatt und Kraftwerk</th>
+<th>Depot und Handel</th>
+<th>Was mathematisch dahintersteht</th>
+</tr>
+</thead>
+<tbody>
+<tr class="odd">
+<td>Produkt, Maschinenstunde</td>
+<td>Titel, Kapital</td>
+<td>Entscheidungsvariable</td>
+</tr>
+<tr class="even">
+<td>Deckungsbeitrag</td>
+<td>erwartete Rendite</td>
+<td>linearer Zielterm</td>
+</tr>
+<tr class="odd">
+<td>Kapazität, Liefervertrag</td>
+<td>Positionsgrenze, Sektorlimit</td>
+<td>Nebenbedingung</td>
+</tr>
+<tr class="even">
+<td>Rüstkosten, Anfahrkosten</td>
+<td>Transaktionskosten</td>
+<td>Fixkosten mit Binärvariable (B1)</td>
+</tr>
+<tr class="odd">
+<td>Lastabwurf, Konventionalstrafe</td>
+<td>Tail-Verlust</td>
+<td>Straf- bzw. Risikoterm</td>
+</tr>
+<tr class="even">
+<td>Wind- und Nachfrageszenarien</td>
+<td>Renditeszenarien</td>
+<td>Szenariomenge</td>
+</tr>
+</tbody>
+</table>
+<p><strong>Und wo die Analogie endet</strong>, benennt <a href="#kap-bruecke">Kapitel 16</a> an drei Stellen ausdrücklich — das ist der wertvollere Teil. Eine Analogie, die man nicht begrenzen kann, ist keine Erkenntnis, sondern eine Redewendung.</p>
+<h2 id="was-dieser-teil-gemessen-hat-2">Was dieser Teil gemessen hat</h2>
+<table>
+<colgroup>
+<col style="width: 33%" />
+<col style="width: 33%" />
+<col style="width: 33%" />
+</colgroup>
+<thead>
+<tr class="header">
+<th>Behauptung</th>
+<th>Gemessen</th>
+<th>Wo</th>
+</tr>
+</thead>
+<tbody>
+<tr class="odd">
+<td>„Planen mit der Prognose ist gut genug.”</td>
+<td>Der Erwartungswert-Plan kostet <strong>149 % mehr</strong> (874 870 € statt 351 356 €) und wirft in <strong>28 von 40</strong> Szenarien Last ab</td>
+<td><a href="#kap-supplychain">Kapitel 17</a></td>
+</tr>
+<tr class="even">
+<td>„Dann sparen wir eben beim Brennstoff.”</td>
+<td>Genau das tut er: 12 725 € gespart, <strong>536 239 €</strong> Lastabwurf bezahlt — das 42-fache. Die Anfahrkosten sind in beiden Plänen gleich</td>
+<td><a href="#kap-supplychain">Kapitel 17</a></td>
+</tr>
+<tr class="odd">
+<td>„Der VaR sagt, wie riskant es ist.”</td>
+<td>VaR <strong>1,86 %</strong>, CVaR <strong>2,99 %</strong> — und der schlechteste Tag der Stichprobe (<strong>−23,0 %</strong>) ändert am VaR <strong>nichts</strong></td>
+<td><a href="#kap-cvar">Kapitel 20</a></td>
+</tr>
+<tr class="even">
+<td>„Die Kovarianzmatrix ist eine Eingabe wie jede andere.”</td>
+<td>Aus kurzen Reihen geschätzt ist sie schlecht konditioniert; die Optimierung setzt dann auf Schätzrauschen</td>
+<td><a href="#kap-finanzdaten">Kapitel 18</a></td>
+</tr>
+</tbody>
+</table>
+<h2 id="drei-fehler-die-dieser-teil-verhindert-2">Drei Fehler, die dieser Teil verhindert</h2>
+<ol type="1">
+<li><strong>Bei Markowitz einsteigen.</strong> Wer <a href="#kap-finanzdaten">Kapitel 18</a> überspringt, optimiert seine eigenen Schätzfehler und wundert sich über Gewichte, die niemand halten würde.</li>
+<li><strong>Den VaR für ein Risikomaß halten.</strong> Er sagt, <strong>ob</strong> die Schwelle gerissen wird, nicht <strong>wie schlimm</strong> es dahinter aussieht — und er ist nicht kohärent. Optimiert wird der CVaR.</li>
+<li><strong>Trägheit unterschätzen.</strong> Im Kraftwerkspark ist nicht die Prognosegüte das Problem, sondern dass sich ein Block mit acht Stunden Mindestlaufzeit um 18 Uhr nicht mehr herbeirufen lässt. Dieselbe Trägheit heißt im Depot Transaktionskosten.</li>
+</ol>
+<h2 id="wenn-sie-nur-eines-mitnehmen-3">Wenn Sie nur eines mitnehmen</h2>
+<blockquote>
+<p><strong>🎯</strong> Wer die Struktur erkennt, kann sein Werkzeug mitnehmen, wenn er die Branche wechselt. Wer nur die Bibliothek kennt, fängt jedes Mal von vorn an — und wer die Grenzen der Analogie nicht kennt, überträgt irgendwann auch das, was nicht überträgt.</p>
+</blockquote>
+<hr />
 <h1 id="teil-praxis">Teil V: Praxis</h1>
 <hr />
 <h1 id="kap-praxisfallen">Kapitel 22: Praxisfallen und der Weg zum produktiven Einsatz</h1>
@@ -24645,6 +25719,7 @@ von allen Fehlversuchen genau einen: den erfolgreichsten.
 <p><strong>Programme:</strong><br />
 <code>Infeasibility_Diagnose.py</code><br />
 <code>Erklaerbarkeit.py</code><br />
+<code>Constraint_Attribution.py</code><br />
 <code>Betriebsueberwachung.py</code><br />
 <code>or_kern.py</code><br />
 <code>Solverwechsel_CPSAT_HiGHS.py</code></p>
@@ -24656,25 +25731,25 @@ von allen Fehlversuchen genau einen: den erfolgreichsten.
 <p>Die vorangegangenen vierzehn Kapitel enden fast alle mit derselben Empfehlung: <em>Prüfen Sie das Ergebnis gegen die Wirklichkeit.</em> Dieses Kapitel beginnt damit, diese Prüfung als wiederverwendbaren Baustein hinzuschreiben.</p>
 <blockquote>
 <p><strong>🚀 In 5 Minuten gelöst: Die Abnahmeprüfung, die in jedes Modell gehört</strong></p>
-<div class="sourceCode" id="cb202"><pre class="sourceCode python"><code class="sourceCode python"><span id="cb202-1"><a href="#cb202-1" aria-hidden="true" tabindex="-1"></a><span class="kw">def</span> pruefe_loesung(x, A, b, kosten, zielwert, ganzzahlig<span class="op">=</span>(), toleranz<span class="op">=</span><span class="fl">1e-6</span>):</span>
-<span id="cb202-2"><a href="#cb202-2" aria-hidden="true" tabindex="-1"></a>    <span class="co">&quot;&quot;&quot;Prueft eine Loesung gegen die Anforderungen - OHNE den Solver zu fragen.&quot;&quot;&quot;</span></span>
-<span id="cb202-3"><a href="#cb202-3" aria-hidden="true" tabindex="-1"></a>    beanstandungen <span class="op">=</span> []</span>
-<span id="cb202-4"><a href="#cb202-4" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb202-5"><a href="#cb202-5" aria-hidden="true" tabindex="-1"></a>    verbrauch <span class="op">=</span> A <span class="op">@</span> x                                   <span class="co"># 1. Werden Grenzen eingehalten?</span></span>
-<span id="cb202-6"><a href="#cb202-6" aria-hidden="true" tabindex="-1"></a>    <span class="cf">for</span> i, (ist, grenze) <span class="kw">in</span> <span class="bu">enumerate</span>(<span class="bu">zip</span>(verbrauch, b)):</span>
-<span id="cb202-7"><a href="#cb202-7" aria-hidden="true" tabindex="-1"></a>        <span class="cf">if</span> ist <span class="op">&gt;</span> grenze <span class="op">+</span> toleranz:</span>
-<span id="cb202-8"><a href="#cb202-8" aria-hidden="true" tabindex="-1"></a>            beanstandungen.append(<span class="ss">f&quot;Bedingung </span><span class="sc">{</span>i<span class="sc">}</span><span class="ss">: </span><span class="sc">{</span>ist<span class="sc">:.4f}</span><span class="ss"> &gt; </span><span class="sc">{</span>grenze<span class="sc">:.4f}</span><span class="ss">&quot;</span>)</span>
-<span id="cb202-9"><a href="#cb202-9" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb202-10"><a href="#cb202-10" aria-hidden="true" tabindex="-1"></a>    <span class="cf">for</span> j <span class="kw">in</span> ganzzahlig:                                <span class="co"># 2. Ist ganzzahlig auch ganzzahlig?</span></span>
-<span id="cb202-11"><a href="#cb202-11" aria-hidden="true" tabindex="-1"></a>        <span class="cf">if</span> <span class="bu">abs</span>(x[j] <span class="op">-</span> <span class="bu">round</span>(x[j])) <span class="op">&gt;</span> toleranz:</span>
-<span id="cb202-12"><a href="#cb202-12" aria-hidden="true" tabindex="-1"></a>            beanstandungen.append(<span class="ss">f&quot;x[</span><span class="sc">{</span>j<span class="sc">}</span><span class="ss">] = </span><span class="sc">{</span>x[j]<span class="sc">!r}</span><span class="ss"> ist nicht ganzzahlig&quot;</span>)</span>
-<span id="cb202-13"><a href="#cb202-13" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb202-14"><a href="#cb202-14" aria-hidden="true" tabindex="-1"></a>    nachgerechnet <span class="op">=</span> <span class="bu">float</span>(kosten <span class="op">@</span> x)                   <span class="co"># 3. Stimmt der Zielwert?</span></span>
-<span id="cb202-15"><a href="#cb202-15" aria-hidden="true" tabindex="-1"></a>    <span class="cf">if</span> <span class="bu">abs</span>(nachgerechnet <span class="op">-</span> zielwert) <span class="op">&gt;</span> toleranz <span class="op">*</span> <span class="bu">max</span>(<span class="fl">1.0</span>, <span class="bu">abs</span>(nachgerechnet)):</span>
-<span id="cb202-16"><a href="#cb202-16" aria-hidden="true" tabindex="-1"></a>        beanstandungen.append(</span>
-<span id="cb202-17"><a href="#cb202-17" aria-hidden="true" tabindex="-1"></a>            <span class="ss">f&quot;Zielwert </span><span class="sc">{</span>zielwert<span class="sc">:.4f}</span><span class="ss"> passt nicht zu den Daten (</span><span class="sc">{</span>nachgerechnet<span class="sc">:.4f}</span><span class="ss">)&quot;</span>)</span>
-<span id="cb202-18"><a href="#cb202-18" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb202-19"><a href="#cb202-19" aria-hidden="true" tabindex="-1"></a>    <span class="cf">return</span> beanstandungen</span></code></pre></div>
+<div class="sourceCode" id="cb204"><pre class="sourceCode python"><code class="sourceCode python"><span id="cb204-1"><a href="#cb204-1" aria-hidden="true" tabindex="-1"></a><span class="kw">def</span> pruefe_loesung(x, A, b, kosten, zielwert, ganzzahlig<span class="op">=</span>(), toleranz<span class="op">=</span><span class="fl">1e-6</span>):</span>
+<span id="cb204-2"><a href="#cb204-2" aria-hidden="true" tabindex="-1"></a>    <span class="co">&quot;&quot;&quot;Prueft eine Loesung gegen die Anforderungen - OHNE den Solver zu fragen.&quot;&quot;&quot;</span></span>
+<span id="cb204-3"><a href="#cb204-3" aria-hidden="true" tabindex="-1"></a>    beanstandungen <span class="op">=</span> []</span>
+<span id="cb204-4"><a href="#cb204-4" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb204-5"><a href="#cb204-5" aria-hidden="true" tabindex="-1"></a>    verbrauch <span class="op">=</span> A <span class="op">@</span> x                                   <span class="co"># 1. Werden Grenzen eingehalten?</span></span>
+<span id="cb204-6"><a href="#cb204-6" aria-hidden="true" tabindex="-1"></a>    <span class="cf">for</span> i, (ist, grenze) <span class="kw">in</span> <span class="bu">enumerate</span>(<span class="bu">zip</span>(verbrauch, b)):</span>
+<span id="cb204-7"><a href="#cb204-7" aria-hidden="true" tabindex="-1"></a>        <span class="cf">if</span> ist <span class="op">&gt;</span> grenze <span class="op">+</span> toleranz:</span>
+<span id="cb204-8"><a href="#cb204-8" aria-hidden="true" tabindex="-1"></a>            beanstandungen.append(<span class="ss">f&quot;Bedingung </span><span class="sc">{</span>i<span class="sc">}</span><span class="ss">: </span><span class="sc">{</span>ist<span class="sc">:.4f}</span><span class="ss"> &gt; </span><span class="sc">{</span>grenze<span class="sc">:.4f}</span><span class="ss">&quot;</span>)</span>
+<span id="cb204-9"><a href="#cb204-9" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb204-10"><a href="#cb204-10" aria-hidden="true" tabindex="-1"></a>    <span class="cf">for</span> j <span class="kw">in</span> ganzzahlig:                                <span class="co"># 2. Ist ganzzahlig auch ganzzahlig?</span></span>
+<span id="cb204-11"><a href="#cb204-11" aria-hidden="true" tabindex="-1"></a>        <span class="cf">if</span> <span class="bu">abs</span>(x[j] <span class="op">-</span> <span class="bu">round</span>(x[j])) <span class="op">&gt;</span> toleranz:</span>
+<span id="cb204-12"><a href="#cb204-12" aria-hidden="true" tabindex="-1"></a>            beanstandungen.append(<span class="ss">f&quot;x[</span><span class="sc">{</span>j<span class="sc">}</span><span class="ss">] = </span><span class="sc">{</span>x[j]<span class="sc">!r}</span><span class="ss"> ist nicht ganzzahlig&quot;</span>)</span>
+<span id="cb204-13"><a href="#cb204-13" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb204-14"><a href="#cb204-14" aria-hidden="true" tabindex="-1"></a>    nachgerechnet <span class="op">=</span> <span class="bu">float</span>(kosten <span class="op">@</span> x)                   <span class="co"># 3. Stimmt der Zielwert?</span></span>
+<span id="cb204-15"><a href="#cb204-15" aria-hidden="true" tabindex="-1"></a>    <span class="cf">if</span> <span class="bu">abs</span>(nachgerechnet <span class="op">-</span> zielwert) <span class="op">&gt;</span> toleranz <span class="op">*</span> <span class="bu">max</span>(<span class="fl">1.0</span>, <span class="bu">abs</span>(nachgerechnet)):</span>
+<span id="cb204-16"><a href="#cb204-16" aria-hidden="true" tabindex="-1"></a>        beanstandungen.append(</span>
+<span id="cb204-17"><a href="#cb204-17" aria-hidden="true" tabindex="-1"></a>            <span class="ss">f&quot;Zielwert </span><span class="sc">{</span>zielwert<span class="sc">:.4f}</span><span class="ss"> passt nicht zu den Daten (</span><span class="sc">{</span>nachgerechnet<span class="sc">:.4f}</span><span class="ss">)&quot;</span>)</span>
+<span id="cb204-18"><a href="#cb204-18" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb204-19"><a href="#cb204-19" aria-hidden="true" tabindex="-1"></a>    <span class="cf">return</span> beanstandungen</span></code></pre></div>
 </blockquote>
 <p><strong>Zwölf Zeilen, drei Prüfungen — und jede davon hätte einen der Denkfehler dieses Buches gefunden:</strong></p>
 <table>
@@ -24724,6 +25799,7 @@ von allen Fehlversuchen genau einen: den erfolgreichsten.
 <li>… die fünf typischen Praxisfallen benennen und je ein Gegenmittel nennen.</li>
 <li>… ein unlösbares Modell in einen „am wenigsten schlechten“ Plan verwandeln.</li>
 <li>… Solver-Ergebnisse erklärbar machen (<em>Explainable OR</em>).</li>
+<li>… für jede Nebenbedingung beziffern, was sie den Plan kostet — und begründen, warum der Schattenpreis diese Frage nur für die <em>nächste</em> Einheit beantwortet.</li>
 <li>… Zeitlimits und Optimalitätslücken sinnvoll setzen.</li>
 <li>… die Architektur einer produktionsreifen OR-Plattform skizzieren.</li>
 <li>… eine <strong>modellunabhängige Abnahmeprüfung</strong> schreiben, die eine Lösung gegen die Anforderungen prüft statt gegen das Modell.</li>
@@ -24743,118 +25819,118 @@ von allen Fehlversuchen genau einen: den erfolgreichsten.
 <li><strong>Falsch:</strong> Das System stürzt ab oder zeigt „Fehler“. Der Disponent steht ohne Plan da.</li>
 <li><strong>Richtig:</strong> <strong>Hierarchische Relaxation.</strong> Jede harte Bedingung, die im Notfall gebrochen werden darf, erhält eine teure Schlupfvariable. So liefert der Solver immer einen Plan — und zeigt zugleich präzise, <strong>wo</strong> es klemmt.</li>
 </ul>
-<div class="sourceCode" id="cb203"><pre class="sourceCode python"><code class="sourceCode python"><span id="cb203-1"><a href="#cb203-1" aria-hidden="true" tabindex="-1"></a><span class="co">#!/usr/bin/env python3</span></span>
-<span id="cb203-2"><a href="#cb203-2" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb203-3"><a href="#cb203-3" aria-hidden="true" tabindex="-1"></a><span class="co"># Infeasibility_Diagnose.py</span></span>
-<span id="cb203-4"><a href="#cb203-4" aria-hidden="true" tabindex="-1"></a><span class="co">&quot;&quot;&quot;</span></span>
-<span id="cb203-5"><a href="#cb203-5" aria-hidden="true" tabindex="-1"></a><span class="co">Kapitel Praxisfallen: Aus INFEASIBLE einen Notfallplan machen.</span></span>
-<span id="cb203-6"><a href="#cb203-6" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb203-7"><a href="#cb203-7" aria-hidden="true" tabindex="-1"></a><span class="co">Demonstriert die hierarchische Relaxation an einem Dienstplan, der in der</span></span>
-<span id="cb203-8"><a href="#cb203-8" aria-hidden="true" tabindex="-1"></a><span class="co">harten Fassung unloesbar ist, und zeigt, wie der Solver die Ursache benennt.</span></span>
-<span id="cb203-9"><a href="#cb203-9" aria-hidden="true" tabindex="-1"></a><span class="co">&quot;&quot;&quot;</span></span>
-<span id="cb203-10"><a href="#cb203-10" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb203-11"><a href="#cb203-11" aria-hidden="true" tabindex="-1"></a><span class="im">from</span> ortools.sat.python <span class="im">import</span> cp_model</span>
-<span id="cb203-12"><a href="#cb203-12" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb203-13"><a href="#cb203-13" aria-hidden="true" tabindex="-1"></a>SLOTS <span class="op">=</span> [<span class="st">&quot;Mo frueh&quot;</span>, <span class="st">&quot;Mo spaet&quot;</span>, <span class="st">&quot;Di frueh&quot;</span>, <span class="st">&quot;Di spaet&quot;</span>]</span>
-<span id="cb203-14"><a href="#cb203-14" aria-hidden="true" tabindex="-1"></a>FAECHER <span class="op">=</span> [<span class="st">&quot;Mathematik&quot;</span>, <span class="st">&quot;Physik&quot;</span>, <span class="st">&quot;Mathematik&quot;</span>, <span class="st">&quot;Chemie&quot;</span>]   <span class="co"># Chemie kann niemand!</span></span>
-<span id="cb203-15"><a href="#cb203-15" aria-hidden="true" tabindex="-1"></a>PERSONAL <span class="op">=</span> [<span class="st">&quot;Alice&quot;</span>, <span class="st">&quot;Bob&quot;</span>, <span class="st">&quot;Carla&quot;</span>]</span>
-<span id="cb203-16"><a href="#cb203-16" aria-hidden="true" tabindex="-1"></a>QUALIFIKATION <span class="op">=</span> {</span>
-<span id="cb203-17"><a href="#cb203-17" aria-hidden="true" tabindex="-1"></a>    <span class="st">&quot;Alice&quot;</span>: {<span class="st">&quot;Mathematik&quot;</span>, <span class="st">&quot;Physik&quot;</span>},</span>
-<span id="cb203-18"><a href="#cb203-18" aria-hidden="true" tabindex="-1"></a>    <span class="st">&quot;Bob&quot;</span>:   {<span class="st">&quot;Mathematik&quot;</span>},</span>
-<span id="cb203-19"><a href="#cb203-19" aria-hidden="true" tabindex="-1"></a>    <span class="st">&quot;Carla&quot;</span>: {<span class="st">&quot;Physik&quot;</span>, <span class="st">&quot;Mathematik&quot;</span>},</span>
-<span id="cb203-20"><a href="#cb203-20" aria-hidden="true" tabindex="-1"></a>}</span>
-<span id="cb203-21"><a href="#cb203-21" aria-hidden="true" tabindex="-1"></a>MAX_PRO_PERSON <span class="op">=</span> <span class="dv">2</span></span>
-<span id="cb203-22"><a href="#cb203-22" aria-hidden="true" tabindex="-1"></a>STRAFE_UNBESETZT <span class="op">=</span> <span class="dv">10_000</span>          <span class="co"># sehr teuer, aber nicht unmoeglich</span></span>
-<span id="cb203-23"><a href="#cb203-23" aria-hidden="true" tabindex="-1"></a>STRAFE_UEBERLAST <span class="op">=</span> <span class="dv">500</span>             <span class="co"># teuer, aber billiger als Ausfall</span></span>
-<span id="cb203-24"><a href="#cb203-24" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb203-25"><a href="#cb203-25" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb203-26"><a href="#cb203-26" aria-hidden="true" tabindex="-1"></a><span class="kw">def</span> plane(harte_fassung: <span class="bu">bool</span>):</span>
-<span id="cb203-27"><a href="#cb203-27" aria-hidden="true" tabindex="-1"></a>    <span class="co">&quot;&quot;&quot;harte_fassung=True: klassisch (kann INFEASIBLE werden).</span></span>
-<span id="cb203-28"><a href="#cb203-28" aria-hidden="true" tabindex="-1"></a><span class="co">       harte_fassung=False: mit Schlupfvariablen (immer loesbar).&quot;&quot;&quot;</span></span>
-<span id="cb203-29"><a href="#cb203-29" aria-hidden="true" tabindex="-1"></a>    modell <span class="op">=</span> cp_model.CpModel()</span>
-<span id="cb203-30"><a href="#cb203-30" aria-hidden="true" tabindex="-1"></a>    x <span class="op">=</span> {(p, s): modell.NewBoolVar(<span class="ss">f&quot;x_</span><span class="sc">{</span>p<span class="sc">}</span><span class="ss">_</span><span class="sc">{</span>s<span class="sc">}</span><span class="ss">&quot;</span>)</span>
-<span id="cb203-31"><a href="#cb203-31" aria-hidden="true" tabindex="-1"></a>         <span class="cf">for</span> p <span class="kw">in</span> PERSONAL <span class="cf">for</span> s <span class="kw">in</span> <span class="bu">range</span>(<span class="bu">len</span>(SLOTS))}</span>
-<span id="cb203-32"><a href="#cb203-32" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb203-33"><a href="#cb203-33" aria-hidden="true" tabindex="-1"></a>    strafen <span class="op">=</span> []</span>
-<span id="cb203-34"><a href="#cb203-34" aria-hidden="true" tabindex="-1"></a>    unbesetzt <span class="op">=</span> {}</span>
-<span id="cb203-35"><a href="#cb203-35" aria-hidden="true" tabindex="-1"></a>    ueberlast <span class="op">=</span> {}</span>
-<span id="cb203-36"><a href="#cb203-36" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb203-37"><a href="#cb203-37" aria-hidden="true" tabindex="-1"></a>    <span class="cf">for</span> s <span class="kw">in</span> <span class="bu">range</span>(<span class="bu">len</span>(SLOTS)):</span>
-<span id="cb203-38"><a href="#cb203-38" aria-hidden="true" tabindex="-1"></a>        <span class="cf">if</span> harte_fassung:</span>
-<span id="cb203-39"><a href="#cb203-39" aria-hidden="true" tabindex="-1"></a>            modell.AddExactlyOne(x[p, s] <span class="cf">for</span> p <span class="kw">in</span> PERSONAL)</span>
-<span id="cb203-40"><a href="#cb203-40" aria-hidden="true" tabindex="-1"></a>        <span class="cf">else</span>:</span>
-<span id="cb203-41"><a href="#cb203-41" aria-hidden="true" tabindex="-1"></a>            <span class="co"># Schlupfvariable: der Slot DARF unbesetzt bleiben - gegen hohe Strafe</span></span>
-<span id="cb203-42"><a href="#cb203-42" aria-hidden="true" tabindex="-1"></a>            unbesetzt[s] <span class="op">=</span> modell.NewBoolVar(<span class="ss">f&quot;unbesetzt_</span><span class="sc">{</span>s<span class="sc">}</span><span class="ss">&quot;</span>)</span>
-<span id="cb203-43"><a href="#cb203-43" aria-hidden="true" tabindex="-1"></a>            modell.AddExactlyOne([x[p, s] <span class="cf">for</span> p <span class="kw">in</span> PERSONAL] <span class="op">+</span> [unbesetzt[s]])</span>
-<span id="cb203-44"><a href="#cb203-44" aria-hidden="true" tabindex="-1"></a>            strafen.append(unbesetzt[s] <span class="op">*</span> STRAFE_UNBESETZT)</span>
-<span id="cb203-45"><a href="#cb203-45" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb203-46"><a href="#cb203-46" aria-hidden="true" tabindex="-1"></a>    <span class="co"># Qualifikation bleibt IMMER hart - fachfremder Unterricht ist keine Option</span></span>
-<span id="cb203-47"><a href="#cb203-47" aria-hidden="true" tabindex="-1"></a>    <span class="cf">for</span> s, fach <span class="kw">in</span> <span class="bu">enumerate</span>(FAECHER):</span>
-<span id="cb203-48"><a href="#cb203-48" aria-hidden="true" tabindex="-1"></a>        <span class="cf">for</span> p <span class="kw">in</span> PERSONAL:</span>
-<span id="cb203-49"><a href="#cb203-49" aria-hidden="true" tabindex="-1"></a>            <span class="cf">if</span> fach <span class="kw">not</span> <span class="kw">in</span> QUALIFIKATION[p]:</span>
-<span id="cb203-50"><a href="#cb203-50" aria-hidden="true" tabindex="-1"></a>                modell.Add(x[p, s] <span class="op">==</span> <span class="dv">0</span>)</span>
-<span id="cb203-51"><a href="#cb203-51" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb203-52"><a href="#cb203-52" aria-hidden="true" tabindex="-1"></a>    <span class="cf">for</span> p <span class="kw">in</span> PERSONAL:</span>
-<span id="cb203-53"><a href="#cb203-53" aria-hidden="true" tabindex="-1"></a>        last <span class="op">=</span> <span class="bu">sum</span>(x[p, s] <span class="cf">for</span> s <span class="kw">in</span> <span class="bu">range</span>(<span class="bu">len</span>(SLOTS)))</span>
-<span id="cb203-54"><a href="#cb203-54" aria-hidden="true" tabindex="-1"></a>        <span class="cf">if</span> harte_fassung:</span>
-<span id="cb203-55"><a href="#cb203-55" aria-hidden="true" tabindex="-1"></a>            modell.Add(last <span class="op">&lt;=</span> MAX_PRO_PERSON)</span>
-<span id="cb203-56"><a href="#cb203-56" aria-hidden="true" tabindex="-1"></a>        <span class="cf">else</span>:</span>
-<span id="cb203-57"><a href="#cb203-57" aria-hidden="true" tabindex="-1"></a>            <span class="co"># Ueberlast erlaubt - aber teuer</span></span>
-<span id="cb203-58"><a href="#cb203-58" aria-hidden="true" tabindex="-1"></a>            ueberlast[p] <span class="op">=</span> modell.NewIntVar(<span class="dv">0</span>, <span class="bu">len</span>(SLOTS), <span class="ss">f&quot;ueberlast_</span><span class="sc">{</span>p<span class="sc">}</span><span class="ss">&quot;</span>)</span>
-<span id="cb203-59"><a href="#cb203-59" aria-hidden="true" tabindex="-1"></a>            modell.Add(last <span class="op">&lt;=</span> MAX_PRO_PERSON <span class="op">+</span> ueberlast[p])</span>
-<span id="cb203-60"><a href="#cb203-60" aria-hidden="true" tabindex="-1"></a>            strafen.append(ueberlast[p] <span class="op">*</span> STRAFE_UEBERLAST)</span>
-<span id="cb203-61"><a href="#cb203-61" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb203-62"><a href="#cb203-62" aria-hidden="true" tabindex="-1"></a>    <span class="cf">if</span> strafen:</span>
-<span id="cb203-63"><a href="#cb203-63" aria-hidden="true" tabindex="-1"></a>        modell.Minimize(<span class="bu">sum</span>(strafen))</span>
-<span id="cb203-64"><a href="#cb203-64" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb203-65"><a href="#cb203-65" aria-hidden="true" tabindex="-1"></a>    loeser <span class="op">=</span> cp_model.CpSolver()</span>
-<span id="cb203-66"><a href="#cb203-66" aria-hidden="true" tabindex="-1"></a>    loeser.parameters.max_time_in_seconds <span class="op">=</span> <span class="fl">5.0</span></span>
-<span id="cb203-67"><a href="#cb203-67" aria-hidden="true" tabindex="-1"></a>    status <span class="op">=</span> loeser.Solve(modell)</span>
-<span id="cb203-68"><a href="#cb203-68" aria-hidden="true" tabindex="-1"></a>    <span class="cf">return</span> loeser, status, x, unbesetzt, ueberlast</span>
-<span id="cb203-69"><a href="#cb203-69" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb203-70"><a href="#cb203-70" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb203-71"><a href="#cb203-71" aria-hidden="true" tabindex="-1"></a><span class="cf">if</span> <span class="va">__name__</span> <span class="op">==</span> <span class="st">&quot;__main__&quot;</span>:</span>
-<span id="cb203-72"><a href="#cb203-72" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;=&quot;</span> <span class="op">*</span> <span class="dv">78</span>)</span>
-<span id="cb203-73"><a href="#cb203-73" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;  VARIANTE A: KLASSISCH MIT LAUTER HARTEN BEDINGUNGEN&quot;</span>)</span>
-<span id="cb203-74"><a href="#cb203-74" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;=&quot;</span> <span class="op">*</span> <span class="dv">78</span>)</span>
-<span id="cb203-75"><a href="#cb203-75" aria-hidden="true" tabindex="-1"></a>    loeser, status, <span class="op">*</span>_ <span class="op">=</span> plane(harte_fassung<span class="op">=</span><span class="va">True</span>)</span>
-<span id="cb203-76"><a href="#cb203-76" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;Solver-Status: </span><span class="sc">{</span>loeser<span class="sc">.</span>StatusName(status)<span class="sc">}</span><span class="ss">&quot;</span>)</span>
-<span id="cb203-77"><a href="#cb203-77" aria-hidden="true" tabindex="-1"></a>    <span class="cf">if</span> status <span class="op">==</span> cp_model.INFEASIBLE:</span>
-<span id="cb203-78"><a href="#cb203-78" aria-hidden="true" tabindex="-1"></a>        <span class="bu">print</span>(<span class="st">&quot;Das System kann keinen Plan liefern. Der Anwender erfaehrt NICHT,&quot;</span>)</span>
-<span id="cb203-79"><a href="#cb203-79" aria-hidden="true" tabindex="-1"></a>        <span class="bu">print</span>(<span class="st">&quot;welche Regel das Problem verursacht - nur, dass es nicht geht.</span><span class="ch">\n</span><span class="st">&quot;</span>)</span>
-<span id="cb203-80"><a href="#cb203-80" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb203-81"><a href="#cb203-81" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;=&quot;</span> <span class="op">*</span> <span class="dv">78</span>)</span>
-<span id="cb203-82"><a href="#cb203-82" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;  VARIANTE B: MIT HIERARCHISCHER RELAXATION&quot;</span>)</span>
-<span id="cb203-83"><a href="#cb203-83" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;=&quot;</span> <span class="op">*</span> <span class="dv">78</span>)</span>
-<span id="cb203-84"><a href="#cb203-84" aria-hidden="true" tabindex="-1"></a>    loeser, status, x, unbesetzt, ueberlast <span class="op">=</span> plane(harte_fassung<span class="op">=</span><span class="va">False</span>)</span>
-<span id="cb203-85"><a href="#cb203-85" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;Solver-Status: </span><span class="sc">{</span>loeser<span class="sc">.</span>StatusName(status)<span class="sc">}</span><span class="ss"> | &quot;</span></span>
-<span id="cb203-86"><a href="#cb203-86" aria-hidden="true" tabindex="-1"></a>          <span class="ss">f&quot;Strafkosten: </span><span class="sc">{</span>loeser<span class="sc">.</span>ObjectiveValue()<span class="sc">:.0f}</span><span class="ch">\n</span><span class="ss">&quot;</span>)</span>
-<span id="cb203-87"><a href="#cb203-87" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb203-88"><a href="#cb203-88" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;</span><span class="sc">{</span><span class="st">&#39;Slot&#39;</span><span class="sc">:&lt;12}</span><span class="ss"> </span><span class="sc">{</span><span class="st">&#39;Fach&#39;</span><span class="sc">:&lt;12}</span><span class="ss"> </span><span class="sc">{</span><span class="st">&#39;Zuweisung&#39;</span><span class="sc">:&lt;18}</span><span class="ss"> </span><span class="sc">{</span><span class="st">&#39;Bemerkung&#39;</span><span class="sc">}</span><span class="ss">&quot;</span>)</span>
-<span id="cb203-89"><a href="#cb203-89" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;-&quot;</span> <span class="op">*</span> <span class="dv">78</span>)</span>
-<span id="cb203-90"><a href="#cb203-90" aria-hidden="true" tabindex="-1"></a>    <span class="cf">for</span> s, slot <span class="kw">in</span> <span class="bu">enumerate</span>(SLOTS):</span>
-<span id="cb203-91"><a href="#cb203-91" aria-hidden="true" tabindex="-1"></a>        <span class="cf">if</span> loeser.Value(unbesetzt[s]):</span>
-<span id="cb203-92"><a href="#cb203-92" aria-hidden="true" tabindex="-1"></a>            <span class="bu">print</span>(<span class="ss">f&quot;</span><span class="sc">{</span>slot<span class="sc">:&lt;12}</span><span class="ss"> </span><span class="sc">{</span>FAECHER[s]<span class="sc">:&lt;12}</span><span class="ss"> </span><span class="sc">{</span><span class="st">&#39;-- UNBESETZT --&#39;</span><span class="sc">:&lt;18}</span><span class="ss"> &quot;</span></span>
-<span id="cb203-93"><a href="#cb203-93" aria-hidden="true" tabindex="-1"></a>                  <span class="ss">f&quot;Kein qualifiziertes Personal verfuegbar&quot;</span>)</span>
-<span id="cb203-94"><a href="#cb203-94" aria-hidden="true" tabindex="-1"></a>        <span class="cf">else</span>:</span>
-<span id="cb203-95"><a href="#cb203-95" aria-hidden="true" tabindex="-1"></a>            person <span class="op">=</span> <span class="bu">next</span>(p <span class="cf">for</span> p <span class="kw">in</span> PERSONAL <span class="cf">if</span> loeser.Value(x[p, s]))</span>
-<span id="cb203-96"><a href="#cb203-96" aria-hidden="true" tabindex="-1"></a>            <span class="bu">print</span>(<span class="ss">f&quot;</span><span class="sc">{</span>slot<span class="sc">:&lt;12}</span><span class="ss"> </span><span class="sc">{</span>FAECHER[s]<span class="sc">:&lt;12}</span><span class="ss"> </span><span class="sc">{</span>person<span class="sc">:&lt;18}</span><span class="ss">&quot;</span>)</span>
-<span id="cb203-97"><a href="#cb203-97" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb203-98"><a href="#cb203-98" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;</span><span class="ch">\n</span><span class="st">--- Diagnose ---&quot;</span>)</span>
-<span id="cb203-99"><a href="#cb203-99" aria-hidden="true" tabindex="-1"></a>    <span class="cf">for</span> s, slot <span class="kw">in</span> <span class="bu">enumerate</span>(SLOTS):</span>
-<span id="cb203-100"><a href="#cb203-100" aria-hidden="true" tabindex="-1"></a>        <span class="cf">if</span> loeser.Value(unbesetzt[s]):</span>
-<span id="cb203-101"><a href="#cb203-101" aria-hidden="true" tabindex="-1"></a>            fach <span class="op">=</span> FAECHER[s]</span>
-<span id="cb203-102"><a href="#cb203-102" aria-hidden="true" tabindex="-1"></a>            qualifiziert <span class="op">=</span> [p <span class="cf">for</span> p <span class="kw">in</span> PERSONAL <span class="cf">if</span> fach <span class="kw">in</span> QUALIFIKATION[p]]</span>
-<span id="cb203-103"><a href="#cb203-103" aria-hidden="true" tabindex="-1"></a>            <span class="bu">print</span>(<span class="ss">f&quot;  &#39;</span><span class="sc">{</span>slot<span class="sc">}</span><span class="ss">&#39; (</span><span class="sc">{</span>fach<span class="sc">}</span><span class="ss">): </span><span class="sc">{</span><span class="bu">len</span>(qualifiziert)<span class="sc">}</span><span class="ss"> qualifizierte Personen &quot;</span></span>
-<span id="cb203-104"><a href="#cb203-104" aria-hidden="true" tabindex="-1"></a>                  <span class="ss">f&quot;</span><span class="sc">{</span>qualifiziert <span class="cf">if</span> qualifiziert <span class="cf">else</span> <span class="st">&#39;-&gt; URSACHE: niemand kann dieses Fach&#39;</span><span class="sc">}</span><span class="ss">&quot;</span>)</span>
-<span id="cb203-105"><a href="#cb203-105" aria-hidden="true" tabindex="-1"></a>    <span class="cf">for</span> p <span class="kw">in</span> PERSONAL:</span>
-<span id="cb203-106"><a href="#cb203-106" aria-hidden="true" tabindex="-1"></a>        <span class="cf">if</span> loeser.Value(ueberlast[p]):</span>
-<span id="cb203-107"><a href="#cb203-107" aria-hidden="true" tabindex="-1"></a>            <span class="bu">print</span>(<span class="ss">f&quot;  </span><span class="sc">{</span>p<span class="sc">}</span><span class="ss"> arbeitet </span><span class="sc">{</span>loeser<span class="sc">.</span>Value(ueberlast[p])<span class="sc">}</span><span class="ss"> Stunden ueber der Grenze.&quot;</span>)</span>
-<span id="cb203-108"><a href="#cb203-108" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb203-109"><a href="#cb203-109" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;</span><span class="ch">\n</span><span class="st">Der Anwender bekommt jetzt einen Plan PLUS eine konkrete Ursache -&quot;</span>)</span>
-<span id="cb203-110"><a href="#cb203-110" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;und kann handeln: Vertretung von aussen holen, Stunde verlegen,&quot;</span>)</span>
-<span id="cb203-111"><a href="#cb203-111" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;oder die Klasse zusammenlegen.&quot;</span>)</span>
-<span id="cb203-112"><a href="#cb203-112" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;=&quot;</span> <span class="op">*</span> <span class="dv">78</span>)</span></code></pre></div>
+<div class="sourceCode" id="cb205"><pre class="sourceCode python"><code class="sourceCode python"><span id="cb205-1"><a href="#cb205-1" aria-hidden="true" tabindex="-1"></a><span class="co">#!/usr/bin/env python3</span></span>
+<span id="cb205-2"><a href="#cb205-2" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb205-3"><a href="#cb205-3" aria-hidden="true" tabindex="-1"></a><span class="co"># Infeasibility_Diagnose.py</span></span>
+<span id="cb205-4"><a href="#cb205-4" aria-hidden="true" tabindex="-1"></a><span class="co">&quot;&quot;&quot;</span></span>
+<span id="cb205-5"><a href="#cb205-5" aria-hidden="true" tabindex="-1"></a><span class="co">Kapitel Praxisfallen: Aus INFEASIBLE einen Notfallplan machen.</span></span>
+<span id="cb205-6"><a href="#cb205-6" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb205-7"><a href="#cb205-7" aria-hidden="true" tabindex="-1"></a><span class="co">Demonstriert die hierarchische Relaxation an einem Dienstplan, der in der</span></span>
+<span id="cb205-8"><a href="#cb205-8" aria-hidden="true" tabindex="-1"></a><span class="co">harten Fassung unloesbar ist, und zeigt, wie der Solver die Ursache benennt.</span></span>
+<span id="cb205-9"><a href="#cb205-9" aria-hidden="true" tabindex="-1"></a><span class="co">&quot;&quot;&quot;</span></span>
+<span id="cb205-10"><a href="#cb205-10" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb205-11"><a href="#cb205-11" aria-hidden="true" tabindex="-1"></a><span class="im">from</span> ortools.sat.python <span class="im">import</span> cp_model</span>
+<span id="cb205-12"><a href="#cb205-12" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb205-13"><a href="#cb205-13" aria-hidden="true" tabindex="-1"></a>SLOTS <span class="op">=</span> [<span class="st">&quot;Mo frueh&quot;</span>, <span class="st">&quot;Mo spaet&quot;</span>, <span class="st">&quot;Di frueh&quot;</span>, <span class="st">&quot;Di spaet&quot;</span>]</span>
+<span id="cb205-14"><a href="#cb205-14" aria-hidden="true" tabindex="-1"></a>FAECHER <span class="op">=</span> [<span class="st">&quot;Mathematik&quot;</span>, <span class="st">&quot;Physik&quot;</span>, <span class="st">&quot;Mathematik&quot;</span>, <span class="st">&quot;Chemie&quot;</span>]   <span class="co"># Chemie kann niemand!</span></span>
+<span id="cb205-15"><a href="#cb205-15" aria-hidden="true" tabindex="-1"></a>PERSONAL <span class="op">=</span> [<span class="st">&quot;Alice&quot;</span>, <span class="st">&quot;Bob&quot;</span>, <span class="st">&quot;Carla&quot;</span>]</span>
+<span id="cb205-16"><a href="#cb205-16" aria-hidden="true" tabindex="-1"></a>QUALIFIKATION <span class="op">=</span> {</span>
+<span id="cb205-17"><a href="#cb205-17" aria-hidden="true" tabindex="-1"></a>    <span class="st">&quot;Alice&quot;</span>: {<span class="st">&quot;Mathematik&quot;</span>, <span class="st">&quot;Physik&quot;</span>},</span>
+<span id="cb205-18"><a href="#cb205-18" aria-hidden="true" tabindex="-1"></a>    <span class="st">&quot;Bob&quot;</span>:   {<span class="st">&quot;Mathematik&quot;</span>},</span>
+<span id="cb205-19"><a href="#cb205-19" aria-hidden="true" tabindex="-1"></a>    <span class="st">&quot;Carla&quot;</span>: {<span class="st">&quot;Physik&quot;</span>, <span class="st">&quot;Mathematik&quot;</span>},</span>
+<span id="cb205-20"><a href="#cb205-20" aria-hidden="true" tabindex="-1"></a>}</span>
+<span id="cb205-21"><a href="#cb205-21" aria-hidden="true" tabindex="-1"></a>MAX_PRO_PERSON <span class="op">=</span> <span class="dv">2</span></span>
+<span id="cb205-22"><a href="#cb205-22" aria-hidden="true" tabindex="-1"></a>STRAFE_UNBESETZT <span class="op">=</span> <span class="dv">10_000</span>          <span class="co"># sehr teuer, aber nicht unmoeglich</span></span>
+<span id="cb205-23"><a href="#cb205-23" aria-hidden="true" tabindex="-1"></a>STRAFE_UEBERLAST <span class="op">=</span> <span class="dv">500</span>             <span class="co"># teuer, aber billiger als Ausfall</span></span>
+<span id="cb205-24"><a href="#cb205-24" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb205-25"><a href="#cb205-25" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb205-26"><a href="#cb205-26" aria-hidden="true" tabindex="-1"></a><span class="kw">def</span> plane(harte_fassung: <span class="bu">bool</span>):</span>
+<span id="cb205-27"><a href="#cb205-27" aria-hidden="true" tabindex="-1"></a>    <span class="co">&quot;&quot;&quot;harte_fassung=True: klassisch (kann INFEASIBLE werden).</span></span>
+<span id="cb205-28"><a href="#cb205-28" aria-hidden="true" tabindex="-1"></a><span class="co">       harte_fassung=False: mit Schlupfvariablen (immer loesbar).&quot;&quot;&quot;</span></span>
+<span id="cb205-29"><a href="#cb205-29" aria-hidden="true" tabindex="-1"></a>    modell <span class="op">=</span> cp_model.CpModel()</span>
+<span id="cb205-30"><a href="#cb205-30" aria-hidden="true" tabindex="-1"></a>    x <span class="op">=</span> {(p, s): modell.NewBoolVar(<span class="ss">f&quot;x_</span><span class="sc">{</span>p<span class="sc">}</span><span class="ss">_</span><span class="sc">{</span>s<span class="sc">}</span><span class="ss">&quot;</span>)</span>
+<span id="cb205-31"><a href="#cb205-31" aria-hidden="true" tabindex="-1"></a>         <span class="cf">for</span> p <span class="kw">in</span> PERSONAL <span class="cf">for</span> s <span class="kw">in</span> <span class="bu">range</span>(<span class="bu">len</span>(SLOTS))}</span>
+<span id="cb205-32"><a href="#cb205-32" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb205-33"><a href="#cb205-33" aria-hidden="true" tabindex="-1"></a>    strafen <span class="op">=</span> []</span>
+<span id="cb205-34"><a href="#cb205-34" aria-hidden="true" tabindex="-1"></a>    unbesetzt <span class="op">=</span> {}</span>
+<span id="cb205-35"><a href="#cb205-35" aria-hidden="true" tabindex="-1"></a>    ueberlast <span class="op">=</span> {}</span>
+<span id="cb205-36"><a href="#cb205-36" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb205-37"><a href="#cb205-37" aria-hidden="true" tabindex="-1"></a>    <span class="cf">for</span> s <span class="kw">in</span> <span class="bu">range</span>(<span class="bu">len</span>(SLOTS)):</span>
+<span id="cb205-38"><a href="#cb205-38" aria-hidden="true" tabindex="-1"></a>        <span class="cf">if</span> harte_fassung:</span>
+<span id="cb205-39"><a href="#cb205-39" aria-hidden="true" tabindex="-1"></a>            modell.AddExactlyOne(x[p, s] <span class="cf">for</span> p <span class="kw">in</span> PERSONAL)</span>
+<span id="cb205-40"><a href="#cb205-40" aria-hidden="true" tabindex="-1"></a>        <span class="cf">else</span>:</span>
+<span id="cb205-41"><a href="#cb205-41" aria-hidden="true" tabindex="-1"></a>            <span class="co"># Schlupfvariable: der Slot DARF unbesetzt bleiben - gegen hohe Strafe</span></span>
+<span id="cb205-42"><a href="#cb205-42" aria-hidden="true" tabindex="-1"></a>            unbesetzt[s] <span class="op">=</span> modell.NewBoolVar(<span class="ss">f&quot;unbesetzt_</span><span class="sc">{</span>s<span class="sc">}</span><span class="ss">&quot;</span>)</span>
+<span id="cb205-43"><a href="#cb205-43" aria-hidden="true" tabindex="-1"></a>            modell.AddExactlyOne([x[p, s] <span class="cf">for</span> p <span class="kw">in</span> PERSONAL] <span class="op">+</span> [unbesetzt[s]])</span>
+<span id="cb205-44"><a href="#cb205-44" aria-hidden="true" tabindex="-1"></a>            strafen.append(unbesetzt[s] <span class="op">*</span> STRAFE_UNBESETZT)</span>
+<span id="cb205-45"><a href="#cb205-45" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb205-46"><a href="#cb205-46" aria-hidden="true" tabindex="-1"></a>    <span class="co"># Qualifikation bleibt IMMER hart - fachfremder Unterricht ist keine Option</span></span>
+<span id="cb205-47"><a href="#cb205-47" aria-hidden="true" tabindex="-1"></a>    <span class="cf">for</span> s, fach <span class="kw">in</span> <span class="bu">enumerate</span>(FAECHER):</span>
+<span id="cb205-48"><a href="#cb205-48" aria-hidden="true" tabindex="-1"></a>        <span class="cf">for</span> p <span class="kw">in</span> PERSONAL:</span>
+<span id="cb205-49"><a href="#cb205-49" aria-hidden="true" tabindex="-1"></a>            <span class="cf">if</span> fach <span class="kw">not</span> <span class="kw">in</span> QUALIFIKATION[p]:</span>
+<span id="cb205-50"><a href="#cb205-50" aria-hidden="true" tabindex="-1"></a>                modell.Add(x[p, s] <span class="op">==</span> <span class="dv">0</span>)</span>
+<span id="cb205-51"><a href="#cb205-51" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb205-52"><a href="#cb205-52" aria-hidden="true" tabindex="-1"></a>    <span class="cf">for</span> p <span class="kw">in</span> PERSONAL:</span>
+<span id="cb205-53"><a href="#cb205-53" aria-hidden="true" tabindex="-1"></a>        last <span class="op">=</span> <span class="bu">sum</span>(x[p, s] <span class="cf">for</span> s <span class="kw">in</span> <span class="bu">range</span>(<span class="bu">len</span>(SLOTS)))</span>
+<span id="cb205-54"><a href="#cb205-54" aria-hidden="true" tabindex="-1"></a>        <span class="cf">if</span> harte_fassung:</span>
+<span id="cb205-55"><a href="#cb205-55" aria-hidden="true" tabindex="-1"></a>            modell.Add(last <span class="op">&lt;=</span> MAX_PRO_PERSON)</span>
+<span id="cb205-56"><a href="#cb205-56" aria-hidden="true" tabindex="-1"></a>        <span class="cf">else</span>:</span>
+<span id="cb205-57"><a href="#cb205-57" aria-hidden="true" tabindex="-1"></a>            <span class="co"># Ueberlast erlaubt - aber teuer</span></span>
+<span id="cb205-58"><a href="#cb205-58" aria-hidden="true" tabindex="-1"></a>            ueberlast[p] <span class="op">=</span> modell.NewIntVar(<span class="dv">0</span>, <span class="bu">len</span>(SLOTS), <span class="ss">f&quot;ueberlast_</span><span class="sc">{</span>p<span class="sc">}</span><span class="ss">&quot;</span>)</span>
+<span id="cb205-59"><a href="#cb205-59" aria-hidden="true" tabindex="-1"></a>            modell.Add(last <span class="op">&lt;=</span> MAX_PRO_PERSON <span class="op">+</span> ueberlast[p])</span>
+<span id="cb205-60"><a href="#cb205-60" aria-hidden="true" tabindex="-1"></a>            strafen.append(ueberlast[p] <span class="op">*</span> STRAFE_UEBERLAST)</span>
+<span id="cb205-61"><a href="#cb205-61" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb205-62"><a href="#cb205-62" aria-hidden="true" tabindex="-1"></a>    <span class="cf">if</span> strafen:</span>
+<span id="cb205-63"><a href="#cb205-63" aria-hidden="true" tabindex="-1"></a>        modell.Minimize(<span class="bu">sum</span>(strafen))</span>
+<span id="cb205-64"><a href="#cb205-64" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb205-65"><a href="#cb205-65" aria-hidden="true" tabindex="-1"></a>    loeser <span class="op">=</span> cp_model.CpSolver()</span>
+<span id="cb205-66"><a href="#cb205-66" aria-hidden="true" tabindex="-1"></a>    loeser.parameters.max_time_in_seconds <span class="op">=</span> <span class="fl">5.0</span></span>
+<span id="cb205-67"><a href="#cb205-67" aria-hidden="true" tabindex="-1"></a>    status <span class="op">=</span> loeser.Solve(modell)</span>
+<span id="cb205-68"><a href="#cb205-68" aria-hidden="true" tabindex="-1"></a>    <span class="cf">return</span> loeser, status, x, unbesetzt, ueberlast</span>
+<span id="cb205-69"><a href="#cb205-69" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb205-70"><a href="#cb205-70" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb205-71"><a href="#cb205-71" aria-hidden="true" tabindex="-1"></a><span class="cf">if</span> <span class="va">__name__</span> <span class="op">==</span> <span class="st">&quot;__main__&quot;</span>:</span>
+<span id="cb205-72"><a href="#cb205-72" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;=&quot;</span> <span class="op">*</span> <span class="dv">78</span>)</span>
+<span id="cb205-73"><a href="#cb205-73" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;  VARIANTE A: KLASSISCH MIT LAUTER HARTEN BEDINGUNGEN&quot;</span>)</span>
+<span id="cb205-74"><a href="#cb205-74" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;=&quot;</span> <span class="op">*</span> <span class="dv">78</span>)</span>
+<span id="cb205-75"><a href="#cb205-75" aria-hidden="true" tabindex="-1"></a>    loeser, status, <span class="op">*</span>_ <span class="op">=</span> plane(harte_fassung<span class="op">=</span><span class="va">True</span>)</span>
+<span id="cb205-76"><a href="#cb205-76" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;Solver-Status: </span><span class="sc">{</span>loeser<span class="sc">.</span>StatusName(status)<span class="sc">}</span><span class="ss">&quot;</span>)</span>
+<span id="cb205-77"><a href="#cb205-77" aria-hidden="true" tabindex="-1"></a>    <span class="cf">if</span> status <span class="op">==</span> cp_model.INFEASIBLE:</span>
+<span id="cb205-78"><a href="#cb205-78" aria-hidden="true" tabindex="-1"></a>        <span class="bu">print</span>(<span class="st">&quot;Das System kann keinen Plan liefern. Der Anwender erfaehrt NICHT,&quot;</span>)</span>
+<span id="cb205-79"><a href="#cb205-79" aria-hidden="true" tabindex="-1"></a>        <span class="bu">print</span>(<span class="st">&quot;welche Regel das Problem verursacht - nur, dass es nicht geht.</span><span class="ch">\n</span><span class="st">&quot;</span>)</span>
+<span id="cb205-80"><a href="#cb205-80" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb205-81"><a href="#cb205-81" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;=&quot;</span> <span class="op">*</span> <span class="dv">78</span>)</span>
+<span id="cb205-82"><a href="#cb205-82" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;  VARIANTE B: MIT HIERARCHISCHER RELAXATION&quot;</span>)</span>
+<span id="cb205-83"><a href="#cb205-83" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;=&quot;</span> <span class="op">*</span> <span class="dv">78</span>)</span>
+<span id="cb205-84"><a href="#cb205-84" aria-hidden="true" tabindex="-1"></a>    loeser, status, x, unbesetzt, ueberlast <span class="op">=</span> plane(harte_fassung<span class="op">=</span><span class="va">False</span>)</span>
+<span id="cb205-85"><a href="#cb205-85" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;Solver-Status: </span><span class="sc">{</span>loeser<span class="sc">.</span>StatusName(status)<span class="sc">}</span><span class="ss"> | &quot;</span></span>
+<span id="cb205-86"><a href="#cb205-86" aria-hidden="true" tabindex="-1"></a>          <span class="ss">f&quot;Strafkosten: </span><span class="sc">{</span>loeser<span class="sc">.</span>ObjectiveValue()<span class="sc">:.0f}</span><span class="ch">\n</span><span class="ss">&quot;</span>)</span>
+<span id="cb205-87"><a href="#cb205-87" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb205-88"><a href="#cb205-88" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;</span><span class="sc">{</span><span class="st">&#39;Slot&#39;</span><span class="sc">:&lt;12}</span><span class="ss"> </span><span class="sc">{</span><span class="st">&#39;Fach&#39;</span><span class="sc">:&lt;12}</span><span class="ss"> </span><span class="sc">{</span><span class="st">&#39;Zuweisung&#39;</span><span class="sc">:&lt;18}</span><span class="ss"> </span><span class="sc">{</span><span class="st">&#39;Bemerkung&#39;</span><span class="sc">}</span><span class="ss">&quot;</span>)</span>
+<span id="cb205-89"><a href="#cb205-89" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;-&quot;</span> <span class="op">*</span> <span class="dv">78</span>)</span>
+<span id="cb205-90"><a href="#cb205-90" aria-hidden="true" tabindex="-1"></a>    <span class="cf">for</span> s, slot <span class="kw">in</span> <span class="bu">enumerate</span>(SLOTS):</span>
+<span id="cb205-91"><a href="#cb205-91" aria-hidden="true" tabindex="-1"></a>        <span class="cf">if</span> loeser.Value(unbesetzt[s]):</span>
+<span id="cb205-92"><a href="#cb205-92" aria-hidden="true" tabindex="-1"></a>            <span class="bu">print</span>(<span class="ss">f&quot;</span><span class="sc">{</span>slot<span class="sc">:&lt;12}</span><span class="ss"> </span><span class="sc">{</span>FAECHER[s]<span class="sc">:&lt;12}</span><span class="ss"> </span><span class="sc">{</span><span class="st">&#39;-- UNBESETZT --&#39;</span><span class="sc">:&lt;18}</span><span class="ss"> &quot;</span></span>
+<span id="cb205-93"><a href="#cb205-93" aria-hidden="true" tabindex="-1"></a>                  <span class="ss">f&quot;Kein qualifiziertes Personal verfuegbar&quot;</span>)</span>
+<span id="cb205-94"><a href="#cb205-94" aria-hidden="true" tabindex="-1"></a>        <span class="cf">else</span>:</span>
+<span id="cb205-95"><a href="#cb205-95" aria-hidden="true" tabindex="-1"></a>            person <span class="op">=</span> <span class="bu">next</span>(p <span class="cf">for</span> p <span class="kw">in</span> PERSONAL <span class="cf">if</span> loeser.Value(x[p, s]))</span>
+<span id="cb205-96"><a href="#cb205-96" aria-hidden="true" tabindex="-1"></a>            <span class="bu">print</span>(<span class="ss">f&quot;</span><span class="sc">{</span>slot<span class="sc">:&lt;12}</span><span class="ss"> </span><span class="sc">{</span>FAECHER[s]<span class="sc">:&lt;12}</span><span class="ss"> </span><span class="sc">{</span>person<span class="sc">:&lt;18}</span><span class="ss">&quot;</span>)</span>
+<span id="cb205-97"><a href="#cb205-97" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb205-98"><a href="#cb205-98" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;</span><span class="ch">\n</span><span class="st">--- Diagnose ---&quot;</span>)</span>
+<span id="cb205-99"><a href="#cb205-99" aria-hidden="true" tabindex="-1"></a>    <span class="cf">for</span> s, slot <span class="kw">in</span> <span class="bu">enumerate</span>(SLOTS):</span>
+<span id="cb205-100"><a href="#cb205-100" aria-hidden="true" tabindex="-1"></a>        <span class="cf">if</span> loeser.Value(unbesetzt[s]):</span>
+<span id="cb205-101"><a href="#cb205-101" aria-hidden="true" tabindex="-1"></a>            fach <span class="op">=</span> FAECHER[s]</span>
+<span id="cb205-102"><a href="#cb205-102" aria-hidden="true" tabindex="-1"></a>            qualifiziert <span class="op">=</span> [p <span class="cf">for</span> p <span class="kw">in</span> PERSONAL <span class="cf">if</span> fach <span class="kw">in</span> QUALIFIKATION[p]]</span>
+<span id="cb205-103"><a href="#cb205-103" aria-hidden="true" tabindex="-1"></a>            <span class="bu">print</span>(<span class="ss">f&quot;  &#39;</span><span class="sc">{</span>slot<span class="sc">}</span><span class="ss">&#39; (</span><span class="sc">{</span>fach<span class="sc">}</span><span class="ss">): </span><span class="sc">{</span><span class="bu">len</span>(qualifiziert)<span class="sc">}</span><span class="ss"> qualifizierte Personen &quot;</span></span>
+<span id="cb205-104"><a href="#cb205-104" aria-hidden="true" tabindex="-1"></a>                  <span class="ss">f&quot;</span><span class="sc">{</span>qualifiziert <span class="cf">if</span> qualifiziert <span class="cf">else</span> <span class="st">&#39;-&gt; URSACHE: niemand kann dieses Fach&#39;</span><span class="sc">}</span><span class="ss">&quot;</span>)</span>
+<span id="cb205-105"><a href="#cb205-105" aria-hidden="true" tabindex="-1"></a>    <span class="cf">for</span> p <span class="kw">in</span> PERSONAL:</span>
+<span id="cb205-106"><a href="#cb205-106" aria-hidden="true" tabindex="-1"></a>        <span class="cf">if</span> loeser.Value(ueberlast[p]):</span>
+<span id="cb205-107"><a href="#cb205-107" aria-hidden="true" tabindex="-1"></a>            <span class="bu">print</span>(<span class="ss">f&quot;  </span><span class="sc">{</span>p<span class="sc">}</span><span class="ss"> arbeitet </span><span class="sc">{</span>loeser<span class="sc">.</span>Value(ueberlast[p])<span class="sc">}</span><span class="ss"> Stunden ueber der Grenze.&quot;</span>)</span>
+<span id="cb205-108"><a href="#cb205-108" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb205-109"><a href="#cb205-109" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;</span><span class="ch">\n</span><span class="st">Der Anwender bekommt jetzt einen Plan PLUS eine konkrete Ursache -&quot;</span>)</span>
+<span id="cb205-110"><a href="#cb205-110" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;und kann handeln: Vertretung von aussen holen, Stunde verlegen,&quot;</span>)</span>
+<span id="cb205-111"><a href="#cb205-111" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;oder die Klasse zusammenlegen.&quot;</span>)</span>
+<span id="cb205-112"><a href="#cb205-112" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;=&quot;</span> <span class="op">*</span> <span class="dv">78</span>)</span></code></pre></div>
 <h3 id="falle-2-der-black-box-effekt">Falle 2 — Der Black-Box-Effekt</h3>
 <p>Ein Planer oder Trader lehnt ein System ab, wenn er die Zuweisungen nicht nachvollziehen kann. <strong>Akzeptanz ist keine Nebensache, sondern Voraussetzung für den Betrieb.</strong></p>
 <p>Jede Entscheidung braucht einen <strong>Constraint-Trace</strong>:</p>
@@ -24867,91 +25943,91 @@ von allen Fehlversuchen genau einen: den erfolgreichsten.
 <p><a href="#kap-lp">Kapitel 5</a> liefert für Frage 3 das Werkzeug. Nutzen Sie es — Schattenpreise sind in Managementgesprächen oft wertvoller als die Lösung selbst.</p>
 </blockquote>
 <p>Ein vollständiger Constraint-Trace beantwortet alle drei Fragen der Faustregel für eine einzelne Zuweisung — inklusive einer Unterscheidung, die in der Praxis oft übersehen wird: eine Bedingung kann <strong>blockieren</strong>, ohne <strong>etwas zu kosten</strong>.</p>
-<div class="sourceCode" id="cb204"><pre class="sourceCode python"><code class="sourceCode python"><span id="cb204-1"><a href="#cb204-1" aria-hidden="true" tabindex="-1"></a><span class="co">#!/usr/bin/env python3</span></span>
-<span id="cb204-2"><a href="#cb204-2" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb204-3"><a href="#cb204-3" aria-hidden="true" tabindex="-1"></a><span class="co"># Erklaerbarkeit.py</span></span>
-<span id="cb204-4"><a href="#cb204-4" aria-hidden="true" tabindex="-1"></a><span class="co">&quot;&quot;&quot;</span></span>
-<span id="cb204-5"><a href="#cb204-5" aria-hidden="true" tabindex="-1"></a><span class="co">Kapitel Praxisfallen: Ein Constraint-Trace, der die drei Fragen der Faustregel fuer</span></span>
-<span id="cb204-6"><a href="#cb204-6" aria-hidden="true" tabindex="-1"></a><span class="co">Erklaerbarkeit (Abschnitt &#39;Die fuenf typischen Praxisfallen&#39;) fuer eine</span></span>
-<span id="cb204-7"><a href="#cb204-7" aria-hidden="true" tabindex="-1"></a><span class="co">einzelne Zuweisung beantwortet:</span></span>
-<span id="cb204-8"><a href="#cb204-8" aria-hidden="true" tabindex="-1"></a><span class="co">Warum diese Loesung? Warum nicht die Alternative? Was wuerde sie verbessern?</span></span>
-<span id="cb204-9"><a href="#cb204-9" aria-hidden="true" tabindex="-1"></a><span class="co">&quot;&quot;&quot;</span></span>
-<span id="cb204-10"><a href="#cb204-10" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb204-11"><a href="#cb204-11" aria-hidden="true" tabindex="-1"></a><span class="im">from</span> ortools.sat.python <span class="im">import</span> cp_model</span>
-<span id="cb204-12"><a href="#cb204-12" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb204-13"><a href="#cb204-13" aria-hidden="true" tabindex="-1"></a>PERSONAL <span class="op">=</span> [<span class="st">&quot;Anna&quot;</span>, <span class="st">&quot;Ben&quot;</span>, <span class="st">&quot;Clara&quot;</span>]</span>
-<span id="cb204-14"><a href="#cb204-14" aria-hidden="true" tabindex="-1"></a>BEREITS_STUNDEN <span class="op">=</span> {<span class="st">&quot;Anna&quot;</span>: <span class="dv">1</span>, <span class="st">&quot;Ben&quot;</span>: <span class="dv">2</span>, <span class="st">&quot;Clara&quot;</span>: <span class="dv">0</span>}   <span class="co"># diese Woche schon geleistet</span></span>
-<span id="cb204-15"><a href="#cb204-15" aria-hidden="true" tabindex="-1"></a>MAX_STUNDEN <span class="op">=</span> <span class="dv">2</span>                                        <span class="co"># gesetzliche Obergrenze</span></span>
-<span id="cb204-16"><a href="#cb204-16" aria-hidden="true" tabindex="-1"></a>STRAFE_VORBELASTUNG <span class="op">=</span> <span class="dv">50</span>                                <span class="co"># pro bereits geleisteter Stunde</span></span>
-<span id="cb204-17"><a href="#cb204-17" aria-hidden="true" tabindex="-1"></a>STRAFKOSTEN_WUNSCH <span class="op">=</span> {<span class="st">&quot;Anna&quot;</span>: <span class="dv">0</span>, <span class="st">&quot;Ben&quot;</span>: <span class="dv">30</span>, <span class="st">&quot;Clara&quot;</span>: <span class="dv">100</span>}</span>
-<span id="cb204-18"><a href="#cb204-18" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb204-19"><a href="#cb204-19" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb204-20"><a href="#cb204-20" aria-hidden="true" tabindex="-1"></a><span class="kw">def</span> loese(max_stunden: <span class="bu">int</span>):</span>
-<span id="cb204-21"><a href="#cb204-21" aria-hidden="true" tabindex="-1"></a>    modell <span class="op">=</span> cp_model.CpModel()</span>
-<span id="cb204-22"><a href="#cb204-22" aria-hidden="true" tabindex="-1"></a>    x <span class="op">=</span> {p: modell.NewBoolVar(<span class="ss">f&quot;x_</span><span class="sc">{</span>p<span class="sc">}</span><span class="ss">&quot;</span>) <span class="cf">for</span> p <span class="kw">in</span> PERSONAL}</span>
-<span id="cb204-23"><a href="#cb204-23" aria-hidden="true" tabindex="-1"></a>    modell.AddExactlyOne(x.values())</span>
-<span id="cb204-24"><a href="#cb204-24" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb204-25"><a href="#cb204-25" aria-hidden="true" tabindex="-1"></a>    kosten <span class="op">=</span> []</span>
-<span id="cb204-26"><a href="#cb204-26" aria-hidden="true" tabindex="-1"></a>    <span class="cf">for</span> p <span class="kw">in</span> PERSONAL:</span>
-<span id="cb204-27"><a href="#cb204-27" aria-hidden="true" tabindex="-1"></a>        <span class="cf">if</span> BEREITS_STUNDEN[p] <span class="op">+</span> <span class="dv">1</span> <span class="op">&gt;</span> max_stunden:</span>
-<span id="cb204-28"><a href="#cb204-28" aria-hidden="true" tabindex="-1"></a>            modell.Add(x[p] <span class="op">==</span> <span class="dv">0</span>)                       <span class="co"># hartes Ausschlusskriterium</span></span>
-<span id="cb204-29"><a href="#cb204-29" aria-hidden="true" tabindex="-1"></a>        strafe <span class="op">=</span> BEREITS_STUNDEN[p] <span class="op">*</span> STRAFE_VORBELASTUNG <span class="op">+</span> STRAFKOSTEN_WUNSCH[p]</span>
-<span id="cb204-30"><a href="#cb204-30" aria-hidden="true" tabindex="-1"></a>        kosten.append(strafe <span class="op">*</span> x[p])</span>
-<span id="cb204-31"><a href="#cb204-31" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb204-32"><a href="#cb204-32" aria-hidden="true" tabindex="-1"></a>    modell.Minimize(<span class="bu">sum</span>(kosten))</span>
-<span id="cb204-33"><a href="#cb204-33" aria-hidden="true" tabindex="-1"></a>    loeser <span class="op">=</span> cp_model.CpSolver()</span>
-<span id="cb204-34"><a href="#cb204-34" aria-hidden="true" tabindex="-1"></a>    status <span class="op">=</span> loeser.Solve(modell)</span>
-<span id="cb204-35"><a href="#cb204-35" aria-hidden="true" tabindex="-1"></a>    <span class="cf">if</span> status <span class="kw">not</span> <span class="kw">in</span> (cp_model.OPTIMAL, cp_model.FEASIBLE):</span>
-<span id="cb204-36"><a href="#cb204-36" aria-hidden="true" tabindex="-1"></a>        <span class="cf">return</span> <span class="va">None</span></span>
-<span id="cb204-37"><a href="#cb204-37" aria-hidden="true" tabindex="-1"></a>    gewinner <span class="op">=</span> <span class="bu">next</span>(p <span class="cf">for</span> p <span class="kw">in</span> PERSONAL <span class="cf">if</span> loeser.Value(x[p]))</span>
-<span id="cb204-38"><a href="#cb204-38" aria-hidden="true" tabindex="-1"></a>    <span class="cf">return</span> gewinner, loeser.ObjectiveValue()</span>
-<span id="cb204-39"><a href="#cb204-39" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb204-40"><a href="#cb204-40" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb204-41"><a href="#cb204-41" aria-hidden="true" tabindex="-1"></a><span class="kw">def</span> gesamtkosten(p: <span class="bu">str</span>) <span class="op">-&gt;</span> <span class="bu">int</span>:</span>
-<span id="cb204-42"><a href="#cb204-42" aria-hidden="true" tabindex="-1"></a>    <span class="cf">return</span> BEREITS_STUNDEN[p] <span class="op">*</span> STRAFE_VORBELASTUNG <span class="op">+</span> STRAFKOSTEN_WUNSCH[p]</span>
-<span id="cb204-43"><a href="#cb204-43" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb204-44"><a href="#cb204-44" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb204-45"><a href="#cb204-45" aria-hidden="true" tabindex="-1"></a><span class="cf">if</span> <span class="va">__name__</span> <span class="op">==</span> <span class="st">&quot;__main__&quot;</span>:</span>
-<span id="cb204-46"><a href="#cb204-46" aria-hidden="true" tabindex="-1"></a>    gewinner, kosten_opt <span class="op">=</span> loese(MAX_STUNDEN)</span>
-<span id="cb204-47"><a href="#cb204-47" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb204-48"><a href="#cb204-48" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;=&quot;</span> <span class="op">*</span> <span class="dv">78</span>)</span>
-<span id="cb204-49"><a href="#cb204-49" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;  CONSTRAINT-TRACE: Warum bekommt&quot;</span>, gewinner, <span class="st">&quot;die Vertretungsstunde?&quot;</span>)</span>
-<span id="cb204-50"><a href="#cb204-50" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;=&quot;</span> <span class="op">*</span> <span class="dv">78</span>)</span>
-<span id="cb204-51"><a href="#cb204-51" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb204-52"><a href="#cb204-52" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;</span><span class="ch">\n</span><span class="st">1. WARUM DIESE LOESUNG?&quot;</span>)</span>
-<span id="cb204-53"><a href="#cb204-53" aria-hidden="true" tabindex="-1"></a>    v, w <span class="op">=</span> BEREITS_STUNDEN[gewinner] <span class="op">*</span> STRAFE_VORBELASTUNG, STRAFKOSTEN_WUNSCH[gewinner]</span>
-<span id="cb204-54"><a href="#cb204-54" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;   </span><span class="sc">{</span>gewinner<span class="sc">}</span><span class="ss">: Vorbelastung </span><span class="sc">{</span>v<span class="sc">}</span><span class="ss"> Strafpunkte + Wunsch </span><span class="sc">{</span>w<span class="sc">}</span><span class="ss"> Strafpunkte &quot;</span></span>
-<span id="cb204-55"><a href="#cb204-55" aria-hidden="true" tabindex="-1"></a>          <span class="ss">f&quot;= </span><span class="sc">{</span>v <span class="op">+</span> w<span class="sc">}</span><span class="ss"> Strafpunkte insgesamt (Minimum).&quot;</span>)</span>
-<span id="cb204-56"><a href="#cb204-56" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb204-57"><a href="#cb204-57" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;</span><span class="ch">\n</span><span class="st">2. WARUM NICHT DIE NAHELIEGENDEN ALTERNATIVEN?&quot;</span>)</span>
-<span id="cb204-58"><a href="#cb204-58" aria-hidden="true" tabindex="-1"></a>    <span class="cf">for</span> p <span class="kw">in</span> PERSONAL:</span>
-<span id="cb204-59"><a href="#cb204-59" aria-hidden="true" tabindex="-1"></a>        <span class="cf">if</span> p <span class="op">==</span> gewinner:</span>
-<span id="cb204-60"><a href="#cb204-60" aria-hidden="true" tabindex="-1"></a>            <span class="cf">continue</span></span>
-<span id="cb204-61"><a href="#cb204-61" aria-hidden="true" tabindex="-1"></a>        <span class="cf">if</span> BEREITS_STUNDEN[p] <span class="op">+</span> <span class="dv">1</span> <span class="op">&gt;</span> MAX_STUNDEN:</span>
-<span id="cb204-62"><a href="#cb204-62" aria-hidden="true" tabindex="-1"></a>            <span class="bu">print</span>(<span class="ss">f&quot;   </span><span class="sc">{</span>p<span class="sc">}</span><span class="ss">: AUSGESCHLOSSEN - hat bereits </span><span class="sc">{</span>BEREITS_STUNDEN[p]<span class="sc">}</span><span class="ss"> Stunden, &quot;</span></span>
-<span id="cb204-63"><a href="#cb204-63" aria-hidden="true" tabindex="-1"></a>                  <span class="ss">f&quot;eine dritte würde die Obergrenze von </span><span class="sc">{</span>MAX_STUNDEN<span class="sc">}</span><span class="ss"> Stunden verletzen &quot;</span></span>
-<span id="cb204-64"><a href="#cb204-64" aria-hidden="true" tabindex="-1"></a>                  <span class="ss">f&quot;(harte Bedingung, nicht verhandelbar).&quot;</span>)</span>
-<span id="cb204-65"><a href="#cb204-65" aria-hidden="true" tabindex="-1"></a>        <span class="cf">else</span>:</span>
-<span id="cb204-66"><a href="#cb204-66" aria-hidden="true" tabindex="-1"></a>            differenz <span class="op">=</span> gesamtkosten(p) <span class="op">-</span> kosten_opt</span>
-<span id="cb204-67"><a href="#cb204-67" aria-hidden="true" tabindex="-1"></a>            <span class="bu">print</span>(<span class="ss">f&quot;   </span><span class="sc">{</span>p<span class="sc">}</span><span class="ss">: zulässig, aber </span><span class="sc">{</span>differenz<span class="sc">:.0f}</span><span class="ss"> Strafpunkte teurer als &quot;</span></span>
-<span id="cb204-68"><a href="#cb204-68" aria-hidden="true" tabindex="-1"></a>                  <span class="ss">f&quot;</span><span class="sc">{</span>gewinner<span class="sc">}</span><span class="ss"> (</span><span class="sc">{</span>gesamtkosten(p)<span class="sc">:.0f}</span><span class="ss"> statt </span><span class="sc">{</span>kosten_opt<span class="sc">:.0f}</span><span class="ss">).&quot;</span>)</span>
-<span id="cb204-69"><a href="#cb204-69" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb204-70"><a href="#cb204-70" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;</span><span class="ch">\n</span><span class="st">3. WAS WUERDE DIE LOESUNG VERBESSERN?&quot;</span>)</span>
-<span id="cb204-71"><a href="#cb204-71" aria-hidden="true" tabindex="-1"></a>    gewinner_gelockert, kosten_gelockert <span class="op">=</span> loese(MAX_STUNDEN <span class="op">+</span> <span class="dv">1</span>)</span>
-<span id="cb204-72"><a href="#cb204-72" aria-hidden="true" tabindex="-1"></a>    <span class="cf">if</span> kosten_gelockert <span class="op">&lt;</span> kosten_opt:</span>
-<span id="cb204-73"><a href="#cb204-73" aria-hidden="true" tabindex="-1"></a>        <span class="bu">print</span>(<span class="ss">f&quot;   Obergrenze auf </span><span class="sc">{</span>MAX_STUNDEN <span class="op">+</span> <span class="dv">1</span><span class="sc">}</span><span class="ss"> Stunden gelockert: </span><span class="sc">{</span>gewinner_gelockert<span class="sc">}</span><span class="ss"> &quot;</span></span>
-<span id="cb204-74"><a href="#cb204-74" aria-hidden="true" tabindex="-1"></a>              <span class="ss">f&quot;uebernimmt jetzt zu </span><span class="sc">{</span>kosten_gelockert<span class="sc">:.0f}</span><span class="ss"> Strafpunkten &quot;</span></span>
-<span id="cb204-75"><a href="#cb204-75" aria-hidden="true" tabindex="-1"></a>              <span class="ss">f&quot;(</span><span class="sc">{</span>kosten_opt <span class="op">-</span> kosten_gelockert<span class="sc">:.0f}</span><span class="ss"> weniger als heute).&quot;</span>)</span>
-<span id="cb204-76"><a href="#cb204-76" aria-hidden="true" tabindex="-1"></a>        <span class="bu">print</span>(<span class="st">&quot;   -&gt; Diese Bedingung hat tatsaechlich einen Preis.&quot;</span>)</span>
-<span id="cb204-77"><a href="#cb204-77" aria-hidden="true" tabindex="-1"></a>    <span class="cf">else</span>:</span>
-<span id="cb204-78"><a href="#cb204-78" aria-hidden="true" tabindex="-1"></a>        <span class="bu">print</span>(<span class="ss">f&quot;   Obergrenze auf </span><span class="sc">{</span>MAX_STUNDEN <span class="op">+</span> <span class="dv">1</span><span class="sc">}</span><span class="ss"> Stunden gelockert: Ergebnis bleibt bei &quot;</span></span>
-<span id="cb204-79"><a href="#cb204-79" aria-hidden="true" tabindex="-1"></a>              <span class="ss">f&quot;</span><span class="sc">{</span>gewinner<span class="sc">}</span><span class="ss"> mit </span><span class="sc">{</span>kosten_gelockert<span class="sc">:.0f}</span><span class="ss"> Strafpunkten (unveraendert).&quot;</span>)</span>
-<span id="cb204-80"><a href="#cb204-80" aria-hidden="true" tabindex="-1"></a>        blockiert <span class="op">=</span> <span class="st">&quot;, &quot;</span>.join(p <span class="cf">for</span> p <span class="kw">in</span> PERSONAL</span>
-<span id="cb204-81"><a href="#cb204-81" aria-hidden="true" tabindex="-1"></a>                               <span class="cf">if</span> BEREITS_STUNDEN[p] <span class="op">+</span> <span class="dv">1</span> <span class="op">&gt;</span> MAX_STUNDEN <span class="kw">and</span> p <span class="op">!=</span> gewinner)</span>
-<span id="cb204-82"><a href="#cb204-82" aria-hidden="true" tabindex="-1"></a>        <span class="bu">print</span>(<span class="ss">f&quot;   -&gt; Die Obergrenze blockiert zwar </span><span class="sc">{</span>blockiert<span class="sc">}</span><span class="ss">, kostet aber gerade NICHTS:&quot;</span>)</span>
-<span id="cb204-83"><a href="#cb204-83" aria-hidden="true" tabindex="-1"></a>        <span class="bu">print</span>(<span class="st">&quot;   Selbst ohne sie waere die Loesung dieselbe.&quot;</span>)</span>
-<span id="cb204-84"><a href="#cb204-84" aria-hidden="true" tabindex="-1"></a>        <span class="bu">print</span>(<span class="st">&quot;   Blockierend und kostenrelevant sind zwei verschiedene Dinge.&quot;</span>)</span>
-<span id="cb204-85"><a href="#cb204-85" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;=&quot;</span> <span class="op">*</span> <span class="dv">78</span>)</span></code></pre></div>
+<div class="sourceCode" id="cb206"><pre class="sourceCode python"><code class="sourceCode python"><span id="cb206-1"><a href="#cb206-1" aria-hidden="true" tabindex="-1"></a><span class="co">#!/usr/bin/env python3</span></span>
+<span id="cb206-2"><a href="#cb206-2" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb206-3"><a href="#cb206-3" aria-hidden="true" tabindex="-1"></a><span class="co"># Erklaerbarkeit.py</span></span>
+<span id="cb206-4"><a href="#cb206-4" aria-hidden="true" tabindex="-1"></a><span class="co">&quot;&quot;&quot;</span></span>
+<span id="cb206-5"><a href="#cb206-5" aria-hidden="true" tabindex="-1"></a><span class="co">Kapitel Praxisfallen: Ein Constraint-Trace, der die drei Fragen der Faustregel fuer</span></span>
+<span id="cb206-6"><a href="#cb206-6" aria-hidden="true" tabindex="-1"></a><span class="co">Erklaerbarkeit (Abschnitt &#39;Die fuenf typischen Praxisfallen&#39;) fuer eine</span></span>
+<span id="cb206-7"><a href="#cb206-7" aria-hidden="true" tabindex="-1"></a><span class="co">einzelne Zuweisung beantwortet:</span></span>
+<span id="cb206-8"><a href="#cb206-8" aria-hidden="true" tabindex="-1"></a><span class="co">Warum diese Loesung? Warum nicht die Alternative? Was wuerde sie verbessern?</span></span>
+<span id="cb206-9"><a href="#cb206-9" aria-hidden="true" tabindex="-1"></a><span class="co">&quot;&quot;&quot;</span></span>
+<span id="cb206-10"><a href="#cb206-10" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb206-11"><a href="#cb206-11" aria-hidden="true" tabindex="-1"></a><span class="im">from</span> ortools.sat.python <span class="im">import</span> cp_model</span>
+<span id="cb206-12"><a href="#cb206-12" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb206-13"><a href="#cb206-13" aria-hidden="true" tabindex="-1"></a>PERSONAL <span class="op">=</span> [<span class="st">&quot;Anna&quot;</span>, <span class="st">&quot;Ben&quot;</span>, <span class="st">&quot;Clara&quot;</span>]</span>
+<span id="cb206-14"><a href="#cb206-14" aria-hidden="true" tabindex="-1"></a>BEREITS_STUNDEN <span class="op">=</span> {<span class="st">&quot;Anna&quot;</span>: <span class="dv">1</span>, <span class="st">&quot;Ben&quot;</span>: <span class="dv">2</span>, <span class="st">&quot;Clara&quot;</span>: <span class="dv">0</span>}   <span class="co"># diese Woche schon geleistet</span></span>
+<span id="cb206-15"><a href="#cb206-15" aria-hidden="true" tabindex="-1"></a>MAX_STUNDEN <span class="op">=</span> <span class="dv">2</span>                                        <span class="co"># gesetzliche Obergrenze</span></span>
+<span id="cb206-16"><a href="#cb206-16" aria-hidden="true" tabindex="-1"></a>STRAFE_VORBELASTUNG <span class="op">=</span> <span class="dv">50</span>                                <span class="co"># pro bereits geleisteter Stunde</span></span>
+<span id="cb206-17"><a href="#cb206-17" aria-hidden="true" tabindex="-1"></a>STRAFKOSTEN_WUNSCH <span class="op">=</span> {<span class="st">&quot;Anna&quot;</span>: <span class="dv">0</span>, <span class="st">&quot;Ben&quot;</span>: <span class="dv">30</span>, <span class="st">&quot;Clara&quot;</span>: <span class="dv">100</span>}</span>
+<span id="cb206-18"><a href="#cb206-18" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb206-19"><a href="#cb206-19" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb206-20"><a href="#cb206-20" aria-hidden="true" tabindex="-1"></a><span class="kw">def</span> loese(max_stunden: <span class="bu">int</span>):</span>
+<span id="cb206-21"><a href="#cb206-21" aria-hidden="true" tabindex="-1"></a>    modell <span class="op">=</span> cp_model.CpModel()</span>
+<span id="cb206-22"><a href="#cb206-22" aria-hidden="true" tabindex="-1"></a>    x <span class="op">=</span> {p: modell.NewBoolVar(<span class="ss">f&quot;x_</span><span class="sc">{</span>p<span class="sc">}</span><span class="ss">&quot;</span>) <span class="cf">for</span> p <span class="kw">in</span> PERSONAL}</span>
+<span id="cb206-23"><a href="#cb206-23" aria-hidden="true" tabindex="-1"></a>    modell.AddExactlyOne(x.values())</span>
+<span id="cb206-24"><a href="#cb206-24" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb206-25"><a href="#cb206-25" aria-hidden="true" tabindex="-1"></a>    kosten <span class="op">=</span> []</span>
+<span id="cb206-26"><a href="#cb206-26" aria-hidden="true" tabindex="-1"></a>    <span class="cf">for</span> p <span class="kw">in</span> PERSONAL:</span>
+<span id="cb206-27"><a href="#cb206-27" aria-hidden="true" tabindex="-1"></a>        <span class="cf">if</span> BEREITS_STUNDEN[p] <span class="op">+</span> <span class="dv">1</span> <span class="op">&gt;</span> max_stunden:</span>
+<span id="cb206-28"><a href="#cb206-28" aria-hidden="true" tabindex="-1"></a>            modell.Add(x[p] <span class="op">==</span> <span class="dv">0</span>)                       <span class="co"># hartes Ausschlusskriterium</span></span>
+<span id="cb206-29"><a href="#cb206-29" aria-hidden="true" tabindex="-1"></a>        strafe <span class="op">=</span> BEREITS_STUNDEN[p] <span class="op">*</span> STRAFE_VORBELASTUNG <span class="op">+</span> STRAFKOSTEN_WUNSCH[p]</span>
+<span id="cb206-30"><a href="#cb206-30" aria-hidden="true" tabindex="-1"></a>        kosten.append(strafe <span class="op">*</span> x[p])</span>
+<span id="cb206-31"><a href="#cb206-31" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb206-32"><a href="#cb206-32" aria-hidden="true" tabindex="-1"></a>    modell.Minimize(<span class="bu">sum</span>(kosten))</span>
+<span id="cb206-33"><a href="#cb206-33" aria-hidden="true" tabindex="-1"></a>    loeser <span class="op">=</span> cp_model.CpSolver()</span>
+<span id="cb206-34"><a href="#cb206-34" aria-hidden="true" tabindex="-1"></a>    status <span class="op">=</span> loeser.Solve(modell)</span>
+<span id="cb206-35"><a href="#cb206-35" aria-hidden="true" tabindex="-1"></a>    <span class="cf">if</span> status <span class="kw">not</span> <span class="kw">in</span> (cp_model.OPTIMAL, cp_model.FEASIBLE):</span>
+<span id="cb206-36"><a href="#cb206-36" aria-hidden="true" tabindex="-1"></a>        <span class="cf">return</span> <span class="va">None</span></span>
+<span id="cb206-37"><a href="#cb206-37" aria-hidden="true" tabindex="-1"></a>    gewinner <span class="op">=</span> <span class="bu">next</span>(p <span class="cf">for</span> p <span class="kw">in</span> PERSONAL <span class="cf">if</span> loeser.Value(x[p]))</span>
+<span id="cb206-38"><a href="#cb206-38" aria-hidden="true" tabindex="-1"></a>    <span class="cf">return</span> gewinner, loeser.ObjectiveValue()</span>
+<span id="cb206-39"><a href="#cb206-39" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb206-40"><a href="#cb206-40" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb206-41"><a href="#cb206-41" aria-hidden="true" tabindex="-1"></a><span class="kw">def</span> gesamtkosten(p: <span class="bu">str</span>) <span class="op">-&gt;</span> <span class="bu">int</span>:</span>
+<span id="cb206-42"><a href="#cb206-42" aria-hidden="true" tabindex="-1"></a>    <span class="cf">return</span> BEREITS_STUNDEN[p] <span class="op">*</span> STRAFE_VORBELASTUNG <span class="op">+</span> STRAFKOSTEN_WUNSCH[p]</span>
+<span id="cb206-43"><a href="#cb206-43" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb206-44"><a href="#cb206-44" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb206-45"><a href="#cb206-45" aria-hidden="true" tabindex="-1"></a><span class="cf">if</span> <span class="va">__name__</span> <span class="op">==</span> <span class="st">&quot;__main__&quot;</span>:</span>
+<span id="cb206-46"><a href="#cb206-46" aria-hidden="true" tabindex="-1"></a>    gewinner, kosten_opt <span class="op">=</span> loese(MAX_STUNDEN)</span>
+<span id="cb206-47"><a href="#cb206-47" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb206-48"><a href="#cb206-48" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;=&quot;</span> <span class="op">*</span> <span class="dv">78</span>)</span>
+<span id="cb206-49"><a href="#cb206-49" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;  CONSTRAINT-TRACE: Warum bekommt&quot;</span>, gewinner, <span class="st">&quot;die Vertretungsstunde?&quot;</span>)</span>
+<span id="cb206-50"><a href="#cb206-50" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;=&quot;</span> <span class="op">*</span> <span class="dv">78</span>)</span>
+<span id="cb206-51"><a href="#cb206-51" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb206-52"><a href="#cb206-52" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;</span><span class="ch">\n</span><span class="st">1. WARUM DIESE LOESUNG?&quot;</span>)</span>
+<span id="cb206-53"><a href="#cb206-53" aria-hidden="true" tabindex="-1"></a>    v, w <span class="op">=</span> BEREITS_STUNDEN[gewinner] <span class="op">*</span> STRAFE_VORBELASTUNG, STRAFKOSTEN_WUNSCH[gewinner]</span>
+<span id="cb206-54"><a href="#cb206-54" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;   </span><span class="sc">{</span>gewinner<span class="sc">}</span><span class="ss">: Vorbelastung </span><span class="sc">{</span>v<span class="sc">}</span><span class="ss"> Strafpunkte + Wunsch </span><span class="sc">{</span>w<span class="sc">}</span><span class="ss"> Strafpunkte &quot;</span></span>
+<span id="cb206-55"><a href="#cb206-55" aria-hidden="true" tabindex="-1"></a>          <span class="ss">f&quot;= </span><span class="sc">{</span>v <span class="op">+</span> w<span class="sc">}</span><span class="ss"> Strafpunkte insgesamt (Minimum).&quot;</span>)</span>
+<span id="cb206-56"><a href="#cb206-56" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb206-57"><a href="#cb206-57" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;</span><span class="ch">\n</span><span class="st">2. WARUM NICHT DIE NAHELIEGENDEN ALTERNATIVEN?&quot;</span>)</span>
+<span id="cb206-58"><a href="#cb206-58" aria-hidden="true" tabindex="-1"></a>    <span class="cf">for</span> p <span class="kw">in</span> PERSONAL:</span>
+<span id="cb206-59"><a href="#cb206-59" aria-hidden="true" tabindex="-1"></a>        <span class="cf">if</span> p <span class="op">==</span> gewinner:</span>
+<span id="cb206-60"><a href="#cb206-60" aria-hidden="true" tabindex="-1"></a>            <span class="cf">continue</span></span>
+<span id="cb206-61"><a href="#cb206-61" aria-hidden="true" tabindex="-1"></a>        <span class="cf">if</span> BEREITS_STUNDEN[p] <span class="op">+</span> <span class="dv">1</span> <span class="op">&gt;</span> MAX_STUNDEN:</span>
+<span id="cb206-62"><a href="#cb206-62" aria-hidden="true" tabindex="-1"></a>            <span class="bu">print</span>(<span class="ss">f&quot;   </span><span class="sc">{</span>p<span class="sc">}</span><span class="ss">: AUSGESCHLOSSEN - hat bereits </span><span class="sc">{</span>BEREITS_STUNDEN[p]<span class="sc">}</span><span class="ss"> Stunden, &quot;</span></span>
+<span id="cb206-63"><a href="#cb206-63" aria-hidden="true" tabindex="-1"></a>                  <span class="ss">f&quot;eine dritte würde die Obergrenze von </span><span class="sc">{</span>MAX_STUNDEN<span class="sc">}</span><span class="ss"> Stunden verletzen &quot;</span></span>
+<span id="cb206-64"><a href="#cb206-64" aria-hidden="true" tabindex="-1"></a>                  <span class="ss">f&quot;(harte Bedingung, nicht verhandelbar).&quot;</span>)</span>
+<span id="cb206-65"><a href="#cb206-65" aria-hidden="true" tabindex="-1"></a>        <span class="cf">else</span>:</span>
+<span id="cb206-66"><a href="#cb206-66" aria-hidden="true" tabindex="-1"></a>            differenz <span class="op">=</span> gesamtkosten(p) <span class="op">-</span> kosten_opt</span>
+<span id="cb206-67"><a href="#cb206-67" aria-hidden="true" tabindex="-1"></a>            <span class="bu">print</span>(<span class="ss">f&quot;   </span><span class="sc">{</span>p<span class="sc">}</span><span class="ss">: zulässig, aber </span><span class="sc">{</span>differenz<span class="sc">:.0f}</span><span class="ss"> Strafpunkte teurer als &quot;</span></span>
+<span id="cb206-68"><a href="#cb206-68" aria-hidden="true" tabindex="-1"></a>                  <span class="ss">f&quot;</span><span class="sc">{</span>gewinner<span class="sc">}</span><span class="ss"> (</span><span class="sc">{</span>gesamtkosten(p)<span class="sc">:.0f}</span><span class="ss"> statt </span><span class="sc">{</span>kosten_opt<span class="sc">:.0f}</span><span class="ss">).&quot;</span>)</span>
+<span id="cb206-69"><a href="#cb206-69" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb206-70"><a href="#cb206-70" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;</span><span class="ch">\n</span><span class="st">3. WAS WUERDE DIE LOESUNG VERBESSERN?&quot;</span>)</span>
+<span id="cb206-71"><a href="#cb206-71" aria-hidden="true" tabindex="-1"></a>    gewinner_gelockert, kosten_gelockert <span class="op">=</span> loese(MAX_STUNDEN <span class="op">+</span> <span class="dv">1</span>)</span>
+<span id="cb206-72"><a href="#cb206-72" aria-hidden="true" tabindex="-1"></a>    <span class="cf">if</span> kosten_gelockert <span class="op">&lt;</span> kosten_opt:</span>
+<span id="cb206-73"><a href="#cb206-73" aria-hidden="true" tabindex="-1"></a>        <span class="bu">print</span>(<span class="ss">f&quot;   Obergrenze auf </span><span class="sc">{</span>MAX_STUNDEN <span class="op">+</span> <span class="dv">1</span><span class="sc">}</span><span class="ss"> Stunden gelockert: </span><span class="sc">{</span>gewinner_gelockert<span class="sc">}</span><span class="ss"> &quot;</span></span>
+<span id="cb206-74"><a href="#cb206-74" aria-hidden="true" tabindex="-1"></a>              <span class="ss">f&quot;uebernimmt jetzt zu </span><span class="sc">{</span>kosten_gelockert<span class="sc">:.0f}</span><span class="ss"> Strafpunkten &quot;</span></span>
+<span id="cb206-75"><a href="#cb206-75" aria-hidden="true" tabindex="-1"></a>              <span class="ss">f&quot;(</span><span class="sc">{</span>kosten_opt <span class="op">-</span> kosten_gelockert<span class="sc">:.0f}</span><span class="ss"> weniger als heute).&quot;</span>)</span>
+<span id="cb206-76"><a href="#cb206-76" aria-hidden="true" tabindex="-1"></a>        <span class="bu">print</span>(<span class="st">&quot;   -&gt; Diese Bedingung hat tatsaechlich einen Preis.&quot;</span>)</span>
+<span id="cb206-77"><a href="#cb206-77" aria-hidden="true" tabindex="-1"></a>    <span class="cf">else</span>:</span>
+<span id="cb206-78"><a href="#cb206-78" aria-hidden="true" tabindex="-1"></a>        <span class="bu">print</span>(<span class="ss">f&quot;   Obergrenze auf </span><span class="sc">{</span>MAX_STUNDEN <span class="op">+</span> <span class="dv">1</span><span class="sc">}</span><span class="ss"> Stunden gelockert: Ergebnis bleibt bei &quot;</span></span>
+<span id="cb206-79"><a href="#cb206-79" aria-hidden="true" tabindex="-1"></a>              <span class="ss">f&quot;</span><span class="sc">{</span>gewinner<span class="sc">}</span><span class="ss"> mit </span><span class="sc">{</span>kosten_gelockert<span class="sc">:.0f}</span><span class="ss"> Strafpunkten (unveraendert).&quot;</span>)</span>
+<span id="cb206-80"><a href="#cb206-80" aria-hidden="true" tabindex="-1"></a>        blockiert <span class="op">=</span> <span class="st">&quot;, &quot;</span>.join(p <span class="cf">for</span> p <span class="kw">in</span> PERSONAL</span>
+<span id="cb206-81"><a href="#cb206-81" aria-hidden="true" tabindex="-1"></a>                               <span class="cf">if</span> BEREITS_STUNDEN[p] <span class="op">+</span> <span class="dv">1</span> <span class="op">&gt;</span> MAX_STUNDEN <span class="kw">and</span> p <span class="op">!=</span> gewinner)</span>
+<span id="cb206-82"><a href="#cb206-82" aria-hidden="true" tabindex="-1"></a>        <span class="bu">print</span>(<span class="ss">f&quot;   -&gt; Die Obergrenze blockiert zwar </span><span class="sc">{</span>blockiert<span class="sc">}</span><span class="ss">, kostet aber gerade NICHTS:&quot;</span>)</span>
+<span id="cb206-83"><a href="#cb206-83" aria-hidden="true" tabindex="-1"></a>        <span class="bu">print</span>(<span class="st">&quot;   Selbst ohne sie waere die Loesung dieselbe.&quot;</span>)</span>
+<span id="cb206-84"><a href="#cb206-84" aria-hidden="true" tabindex="-1"></a>        <span class="bu">print</span>(<span class="st">&quot;   Blockierend und kostenrelevant sind zwei verschiedene Dinge.&quot;</span>)</span>
+<span id="cb206-85"><a href="#cb206-85" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;=&quot;</span> <span class="op">*</span> <span class="dv">78</span>)</span></code></pre></div>
 <p><strong>Erwartete Ausgabe:</strong></p>
 <pre><code>==============================================================================
   CONSTRAINT-TRACE: Warum bekommt Anna die Vertretungsstunde?
@@ -24971,6 +26047,7 @@ von allen Fehlversuchen genau einen: den erfolgreichsten.
    Blockierend und kostenrelevant sind zwei verschiedene Dinge.
 ==============================================================================</code></pre>
 <p>Der letzte Punkt ist der eigentliche Lerneffekt: Die Obergrenze schließt Ben zwar technisch aus, aber selbst wenn er dürfte, wäre er wegen seiner Vorbelastung immer noch teurer als Anna. <strong>Eine bindende Bedingung zu lockern hilft nur, wenn sie tatsächlich die kostenrelevante ist</strong> — sonst ist die Mühe umsonst.</p>
+<p>Derselbe Unterschied kehrt auf Modellebene wieder, und dort lässt er sich in Euro beziffern: <a href="#sec:praxisfallen-attribution">Abschnitt 22.4</a> misst für jede Bedingung, was sie den ganzen Plan kostet — und baut daraus einen Bericht, den man vorlegen kann.</p>
 <h3 id="falle-3-regimewechsel-und-schätzfehler">Falle 3 — Regimewechsel und Schätzfehler</h3>
 <p>Ein Modell, das auf einer mehrjährigen Aufwärtsphase kalibriert wurde, kennt keine Liquiditätskrise und keine Zinswende.</p>
 <ul>
@@ -25018,7 +26095,438 @@ von allen Fehlversuchen genau einen: den erfolgreichsten.
 <p>Dem gegenüber steht die <strong>Datenunsicherheit</strong>: Ihre Nachfrageprognose ist um ±10 % genau, Ihre Fahrzeiten um ±15 %. Die letzten 2 % Optimalität in einem Modell zu erkämpfen, dessen Eingangsdaten um 10 % schwanken, ist verlorene Zeit. <strong>Optimieren Sie nicht genauer, als Ihre Daten sind.</strong></p>
 </blockquote>
 <hr />
-<h2 id="sec:praxisfallen-architektur-einer-produktionsreifen-or-plattform">22.4 Architektur einer produktionsreifen OR-Plattform</h2>
+<h2 id="sec:praxisfallen-attribution">22.4 Constraint Attribution: welche Bedingung kostet wie viel?</h2>
+<p>Der Constraint-Trace beantwortet „warum <strong>diese</strong> Zuweisung?“. Der Deletion Filter in <a href="#anhang-fehlerdiagnose">Anhang C</a> beantwortet „warum geht es <strong>gar nicht</strong>?“. Der häufigste Fall in der Praxis liegt dazwischen, und für ihn hat bisher niemand ein Werkzeug bekommen:</p>
+<blockquote>
+<p><em>Das Modell rechnet. Der Plan ist zulässig. Und trotzdem ist er enttäuschend — nur weiß niemand, woran es liegt.</em></p>
+</blockquote>
+<p>Die Antwort heißt <strong>Constraint Attribution</strong>: Jede Bedingungsgruppe wird einzeln gelockert, und gemessen wird, was sich am Zielwert ändert. Das ist dasselbe Verfahren wie der Deletion Filter — nur mit <strong>Kosten</strong> statt Zulässigkeit als Kriterium.</p>
+<p>Gerechnet wird auf derselben Fabrik wie die Konfliktsuche in <a href="#anhang-fehlerdiagnose">Anhang C</a>, aber <strong>nach der Reparatur</strong>: Dort war die Lackierkapazität von 150 Stunden der Kern des Widerspruchs (<span class="math inline">2 \cdot 40 + 3 \cdot 30 = 170 &gt; 150</span>). Eine zweite Schicht hat sie auf 210 gebracht, der Mindestumsatz wurde auf 10 000 € gesenkt. Jetzt ist das Modell lösbar — und die Frage lautet nicht mehr „warum nicht?“, sondern „was kostet uns was?“.</p>
+<div class="sourceCode" id="cb208"><pre class="sourceCode python"><code class="sourceCode python"><span id="cb208-1"><a href="#cb208-1" aria-hidden="true" tabindex="-1"></a><span class="co">#!/usr/bin/env python3</span></span>
+<span id="cb208-2"><a href="#cb208-2" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb208-3"><a href="#cb208-3" aria-hidden="true" tabindex="-1"></a><span class="co"># Constraint_Attribution.py</span></span>
+<span id="cb208-4"><a href="#cb208-4" aria-hidden="true" tabindex="-1"></a><span class="co">&quot;&quot;&quot;</span></span>
+<span id="cb208-5"><a href="#cb208-5" aria-hidden="true" tabindex="-1"></a><span class="co">Kapitel Praxisfallen: Welche Bedingung kostet wie viel - und was sagt man</span></span>
+<span id="cb208-6"><a href="#cb208-6" aria-hidden="true" tabindex="-1"></a><span class="co">dem Management?</span></span>
+<span id="cb208-7"><a href="#cb208-7" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb208-8"><a href="#cb208-8" aria-hidden="true" tabindex="-1"></a><span class="co">Zwischen den beiden bekannten Faellen klafft eine Luecke:</span></span>
+<span id="cb208-9"><a href="#cb208-9" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb208-10"><a href="#cb208-10" aria-hidden="true" tabindex="-1"></a><span class="co">  * Erklaerbarkeit.py beantwortet &quot;warum diese eine Zuweisung?&quot;</span></span>
+<span id="cb208-11"><a href="#cb208-11" aria-hidden="true" tabindex="-1"></a><span class="co">  * Konfliktsuche.py (Anhang Fehlerdiagnose) beantwortet &quot;warum geht es gar</span></span>
+<span id="cb208-12"><a href="#cb208-12" aria-hidden="true" tabindex="-1"></a><span class="co">    nicht?&quot;</span></span>
+<span id="cb208-13"><a href="#cb208-13" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb208-14"><a href="#cb208-14" aria-hidden="true" tabindex="-1"></a><span class="co">Der haeufigste Fall in der Praxis liegt dazwischen: Das Modell rechnet, der</span></span>
+<span id="cb208-15"><a href="#cb208-15" aria-hidden="true" tabindex="-1"></a><span class="co">Plan ist zulaessig - und trotzdem unbefriedigend. Niemand weiss, WORAN es</span></span>
+<span id="cb208-16"><a href="#cb208-16" aria-hidden="true" tabindex="-1"></a><span class="co">liegt. Genau das beantwortet Constraint Attribution.</span></span>
+<span id="cb208-17"><a href="#cb208-17" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb208-18"><a href="#cb208-18" aria-hidden="true" tabindex="-1"></a><span class="co">Gerechnet wird auf derselben Fabrik wie in Konfliktsuche.py, nur nach der</span></span>
+<span id="cb208-19"><a href="#cb208-19" aria-hidden="true" tabindex="-1"></a><span class="co">Reparatur: Dort war die Lackierkapazitaet von 150 Stunden der Kern des</span></span>
+<span id="cb208-20"><a href="#cb208-20" aria-hidden="true" tabindex="-1"></a><span class="co">Widerspruchs (2*40 + 3*30 = 170 &gt; 150). Eine zweite Schicht hat sie auf 210</span></span>
+<span id="cb208-21"><a href="#cb208-21" aria-hidden="true" tabindex="-1"></a><span class="co">gebracht, und der Mindestumsatz wurde auf 10.000 EUR gesenkt. Jetzt ist das</span></span>
+<span id="cb208-22"><a href="#cb208-22" aria-hidden="true" tabindex="-1"></a><span class="co">Modell loesbar - und die Frage lautet nicht mehr &quot;warum nicht?&quot;, sondern</span></span>
+<span id="cb208-23"><a href="#cb208-23" aria-hidden="true" tabindex="-1"></a><span class="co">&quot;was kostet uns was?&quot;.</span></span>
+<span id="cb208-24"><a href="#cb208-24" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb208-25"><a href="#cb208-25" aria-hidden="true" tabindex="-1"></a><span class="co">Gezeigt werden vier Dinge:</span></span>
+<span id="cb208-26"><a href="#cb208-26" aria-hidden="true" tabindex="-1"></a><span class="co">  1. Welche Bedingungen binden - und dass &quot;bindend&quot; nicht &quot;teuer&quot; heisst.</span></span>
+<span id="cb208-27"><a href="#cb208-27" aria-hidden="true" tabindex="-1"></a><span class="co">  2. Dass der Schattenpreis eine MOMENTAUFNAHME ist: hochgerechnet auf eine</span></span>
+<span id="cb208-28"><a href="#cb208-28" aria-hidden="true" tabindex="-1"></a><span class="co">     realistische Sonderschicht verspricht er hier das Doppelte des</span></span>
+<span id="cb208-29"><a href="#cb208-29" aria-hidden="true" tabindex="-1"></a><span class="co">     tatsaechlichen Nutzens.</span></span>
+<span id="cb208-30"><a href="#cb208-30" aria-hidden="true" tabindex="-1"></a><span class="co">  3. Dass ein Wunsch aus dem Vertrieb nicht teuer, sondern unmoeglich sein</span></span>
+<span id="cb208-31"><a href="#cb208-31" aria-hidden="true" tabindex="-1"></a><span class="co">     kann - und welche Bedingungen ihn gemeinsam blockieren.</span></span>
+<span id="cb208-32"><a href="#cb208-32" aria-hidden="true" tabindex="-1"></a><span class="co">  4. Wie aus alledem ein Bericht in Alltagssprache wird.</span></span>
+<span id="cb208-33"><a href="#cb208-33" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb208-34"><a href="#cb208-34" aria-hidden="true" tabindex="-1"></a><span class="co">Benoetigt: numpy, scipy</span></span>
+<span id="cb208-35"><a href="#cb208-35" aria-hidden="true" tabindex="-1"></a><span class="co">&quot;&quot;&quot;</span></span>
+<span id="cb208-36"><a href="#cb208-36" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb208-37"><a href="#cb208-37" aria-hidden="true" tabindex="-1"></a><span class="im">from</span> __future__ <span class="im">import</span> annotations</span>
+<span id="cb208-38"><a href="#cb208-38" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb208-39"><a href="#cb208-39" aria-hidden="true" tabindex="-1"></a><span class="im">import</span> textwrap</span>
+<span id="cb208-40"><a href="#cb208-40" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb208-41"><a href="#cb208-41" aria-hidden="true" tabindex="-1"></a><span class="im">import</span> numpy <span class="im">as</span> np</span>
+<span id="cb208-42"><a href="#cb208-42" aria-hidden="true" tabindex="-1"></a><span class="im">from</span> scipy.optimize <span class="im">import</span> linprog</span>
+<span id="cb208-43"><a href="#cb208-43" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb208-44"><a href="#cb208-44" aria-hidden="true" tabindex="-1"></a>PRODUKTE <span class="op">=</span> [<span class="st">&quot;Rahmen&quot;</span>, <span class="st">&quot;Gehaeuse&quot;</span>, <span class="st">&quot;Deckel&quot;</span>, <span class="st">&quot;Traeger&quot;</span>, <span class="st">&quot;Halter&quot;</span>]</span>
+<span id="cb208-45"><a href="#cb208-45" aria-hidden="true" tabindex="-1"></a>DECKUNGSBEITRAG <span class="op">=</span> np.array([<span class="fl">35.0</span>, <span class="fl">28.0</span>, <span class="fl">9.0</span>, <span class="fl">22.0</span>, <span class="fl">6.0</span>])   <span class="co"># EUR je Stueck</span></span>
+<span id="cb208-46"><a href="#cb208-46" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb208-47"><a href="#cb208-47" aria-hidden="true" tabindex="-1"></a><span class="co"># Dieselben Bedingungen wie in Konfliktsuche.py, mit den beiden Reparaturen.</span></span>
+<span id="cb208-48"><a href="#cb208-48" aria-hidden="true" tabindex="-1"></a><span class="co"># Der sprechende Name ist keine Kosmetik: Ohne ihn ist kein Bericht moeglich,</span></span>
+<span id="cb208-49"><a href="#cb208-49" aria-hidden="true" tabindex="-1"></a><span class="co"># der jemandem ausserhalb der Modellierung etwas sagt.</span></span>
+<span id="cb208-50"><a href="#cb208-50" aria-hidden="true" tabindex="-1"></a>BEDINGUNGEN: <span class="bu">list</span>[<span class="bu">tuple</span>[<span class="bu">str</span>, <span class="bu">list</span>[<span class="bu">float</span>], <span class="bu">str</span>, <span class="bu">float</span>]] <span class="op">=</span> [</span>
+<span id="cb208-51"><a href="#cb208-51" aria-hidden="true" tabindex="-1"></a>    (<span class="st">&quot;Kapazitaet Montage&quot;</span>,       [<span class="dv">3</span>, <span class="dv">2</span>, <span class="dv">1</span>, <span class="dv">4</span>, <span class="dv">2</span>],      <span class="st">&quot;&lt;=&quot;</span>,   <span class="dv">400</span>),</span>
+<span id="cb208-52"><a href="#cb208-52" aria-hidden="true" tabindex="-1"></a>    (<span class="st">&quot;Kapazitaet Lackieren&quot;</span>,     [<span class="dv">2</span>, <span class="dv">3</span>, <span class="dv">0</span>, <span class="dv">1</span>, <span class="dv">0</span>],      <span class="st">&quot;&lt;=&quot;</span>,   <span class="dv">210</span>),</span>
+<span id="cb208-53"><a href="#cb208-53" aria-hidden="true" tabindex="-1"></a>    (<span class="st">&quot;Kapazitaet Pruefung&quot;</span>,      [<span class="dv">1</span>, <span class="dv">1</span>, <span class="dv">1</span>, <span class="dv">1</span>, <span class="dv">1</span>],      <span class="st">&quot;&lt;=&quot;</span>,   <span class="dv">300</span>),</span>
+<span id="cb208-54"><a href="#cb208-54" aria-hidden="true" tabindex="-1"></a>    (<span class="st">&quot;Liefervertrag Rahmen&quot;</span>,     [<span class="dv">1</span>, <span class="dv">0</span>, <span class="dv">0</span>, <span class="dv">0</span>, <span class="dv">0</span>],      <span class="st">&quot;&gt;=&quot;</span>,    <span class="dv">40</span>),</span>
+<span id="cb208-55"><a href="#cb208-55" aria-hidden="true" tabindex="-1"></a>    (<span class="st">&quot;Liefervertrag Gehaeuse&quot;</span>,   [<span class="dv">0</span>, <span class="dv">1</span>, <span class="dv">0</span>, <span class="dv">0</span>, <span class="dv">0</span>],      <span class="st">&quot;&gt;=&quot;</span>,    <span class="dv">30</span>),</span>
+<span id="cb208-56"><a href="#cb208-56" aria-hidden="true" tabindex="-1"></a>    (<span class="st">&quot;Liefervertrag Deckel&quot;</span>,     [<span class="dv">0</span>, <span class="dv">0</span>, <span class="dv">1</span>, <span class="dv">0</span>, <span class="dv">0</span>],      <span class="st">&quot;&gt;=&quot;</span>,    <span class="dv">20</span>),</span>
+<span id="cb208-57"><a href="#cb208-57" aria-hidden="true" tabindex="-1"></a>    (<span class="st">&quot;Liefervertrag Traeger&quot;</span>,    [<span class="dv">0</span>, <span class="dv">0</span>, <span class="dv">0</span>, <span class="dv">1</span>, <span class="dv">0</span>],      <span class="st">&quot;&gt;=&quot;</span>,    <span class="dv">25</span>),</span>
+<span id="cb208-58"><a href="#cb208-58" aria-hidden="true" tabindex="-1"></a>    (<span class="st">&quot;Marktgrenze Rahmen&quot;</span>,       [<span class="dv">1</span>, <span class="dv">0</span>, <span class="dv">0</span>, <span class="dv">0</span>, <span class="dv">0</span>],      <span class="st">&quot;&lt;=&quot;</span>,   <span class="dv">120</span>),</span>
+<span id="cb208-59"><a href="#cb208-59" aria-hidden="true" tabindex="-1"></a>    (<span class="st">&quot;Marktgrenze Gehaeuse&quot;</span>,     [<span class="dv">0</span>, <span class="dv">1</span>, <span class="dv">0</span>, <span class="dv">0</span>, <span class="dv">0</span>],      <span class="st">&quot;&lt;=&quot;</span>,    <span class="dv">90</span>),</span>
+<span id="cb208-60"><a href="#cb208-60" aria-hidden="true" tabindex="-1"></a>    (<span class="st">&quot;Marktgrenze Deckel&quot;</span>,       [<span class="dv">0</span>, <span class="dv">0</span>, <span class="dv">1</span>, <span class="dv">0</span>, <span class="dv">0</span>],      <span class="st">&quot;&lt;=&quot;</span>,   <span class="dv">150</span>),</span>
+<span id="cb208-61"><a href="#cb208-61" aria-hidden="true" tabindex="-1"></a>    (<span class="st">&quot;Marktgrenze Halter&quot;</span>,       [<span class="dv">0</span>, <span class="dv">0</span>, <span class="dv">0</span>, <span class="dv">0</span>, <span class="dv">1</span>],      <span class="st">&quot;&lt;=&quot;</span>,   <span class="dv">200</span>),</span>
+<span id="cb208-62"><a href="#cb208-62" aria-hidden="true" tabindex="-1"></a>    (<span class="st">&quot;Mindestumsatz&quot;</span>,            [<span class="dv">90</span>, <span class="dv">70</span>, <span class="dv">30</span>, <span class="dv">60</span>, <span class="dv">20</span>], <span class="st">&quot;&gt;=&quot;</span>, <span class="dv">10000</span>),</span>
+<span id="cb208-63"><a href="#cb208-63" aria-hidden="true" tabindex="-1"></a>    (<span class="st">&quot;Sortimentsbreite&quot;</span>,         [<span class="dv">0</span>, <span class="dv">0</span>, <span class="dv">1</span>, <span class="dv">1</span>, <span class="dv">1</span>],      <span class="st">&quot;&gt;=&quot;</span>,   <span class="dv">100</span>),</span>
+<span id="cb208-64"><a href="#cb208-64" aria-hidden="true" tabindex="-1"></a>    (<span class="st">&quot;Lackierbudget Schicht 2&quot;</span>,  [<span class="dv">0</span>, <span class="dv">1</span>, <span class="dv">0</span>, <span class="dv">1</span>, <span class="dv">0</span>],      <span class="st">&quot;&lt;=&quot;</span>,    <span class="dv">55</span>),</span>
+<span id="cb208-65"><a href="#cb208-65" aria-hidden="true" tabindex="-1"></a>]</span>
+<span id="cb208-66"><a href="#cb208-66" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb208-67"><a href="#cb208-67" aria-hidden="true" tabindex="-1"></a><span class="co"># Was liesse sich im Ernstfall wirklich bewegen - und um wie viel? Nicht &quot;eine</span></span>
+<span id="cb208-68"><a href="#cb208-68" aria-hidden="true" tabindex="-1"></a><span class="co"># Einheit&quot;, sondern der Schritt, den ein Planer tatsaechlich gehen kann: eine</span></span>
+<span id="cb208-69"><a href="#cb208-69" aria-hidden="true" tabindex="-1"></a><span class="co"># Sonderschicht, ein nachverhandelter Vertrag. Genau an dieser Groesse</span></span>
+<span id="cb208-70"><a href="#cb208-70" aria-hidden="true" tabindex="-1"></a><span class="co"># scheitert das blosse Hochrechnen des Schattenpreises.</span></span>
+<span id="cb208-71"><a href="#cb208-71" aria-hidden="true" tabindex="-1"></a>STELLSCHRAUBEN: <span class="bu">dict</span>[<span class="bu">str</span>, <span class="bu">tuple</span>[<span class="bu">float</span>, <span class="bu">str</span>]] <span class="op">=</span> {</span>
+<span id="cb208-72"><a href="#cb208-72" aria-hidden="true" tabindex="-1"></a>    <span class="st">&quot;Kapazitaet Montage&quot;</span>:      (<span class="op">+</span><span class="dv">50</span>, <span class="st">&quot;eine Sonderschicht Montage&quot;</span>),</span>
+<span id="cb208-73"><a href="#cb208-73" aria-hidden="true" tabindex="-1"></a>    <span class="st">&quot;Kapazitaet Lackieren&quot;</span>:    (<span class="op">+</span><span class="dv">30</span>, <span class="st">&quot;eine Sonderschicht Lackieren&quot;</span>),</span>
+<span id="cb208-74"><a href="#cb208-74" aria-hidden="true" tabindex="-1"></a>    <span class="st">&quot;Kapazitaet Pruefung&quot;</span>:     (<span class="op">+</span><span class="dv">50</span>, <span class="st">&quot;eine Sonderschicht Pruefung&quot;</span>),</span>
+<span id="cb208-75"><a href="#cb208-75" aria-hidden="true" tabindex="-1"></a>    <span class="st">&quot;Lackierbudget Schicht 2&quot;</span>: (<span class="op">+</span><span class="dv">10</span>, <span class="st">&quot;10 Stunden mehr Budget in Schicht 2&quot;</span>),</span>
+<span id="cb208-76"><a href="#cb208-76" aria-hidden="true" tabindex="-1"></a>    <span class="st">&quot;Liefervertrag Traeger&quot;</span>:   (<span class="op">-</span><span class="dv">10</span>, <span class="st">&quot;10 Stueck weniger Abnahmepflicht Traeger&quot;</span>),</span>
+<span id="cb208-77"><a href="#cb208-77" aria-hidden="true" tabindex="-1"></a>    <span class="st">&quot;Liefervertrag Gehaeuse&quot;</span>:  (<span class="op">-</span><span class="dv">10</span>, <span class="st">&quot;10 Stueck weniger Abnahmepflicht Gehaeuse&quot;</span>),</span>
+<span id="cb208-78"><a href="#cb208-78" aria-hidden="true" tabindex="-1"></a>}</span>
+<span id="cb208-79"><a href="#cb208-79" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb208-80"><a href="#cb208-80" aria-hidden="true" tabindex="-1"></a>WUNSCH_MENGE <span class="op">=</span> <span class="fl">55.0</span>      <span class="co"># der Vertrieb haette gern mehr Rahmen</span></span>
+<span id="cb208-81"><a href="#cb208-81" aria-hidden="true" tabindex="-1"></a>WUNSCH_PRODUKT <span class="op">=</span> <span class="st">&quot;Rahmen&quot;</span></span>
+<span id="cb208-82"><a href="#cb208-82" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb208-83"><a href="#cb208-83" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb208-84"><a href="#cb208-84" aria-hidden="true" tabindex="-1"></a><span class="kw">def</span> loese(bedingungen: <span class="bu">list</span>[<span class="bu">tuple</span>[<span class="bu">str</span>, <span class="bu">list</span>[<span class="bu">float</span>], <span class="bu">str</span>, <span class="bu">float</span>]]):</span>
+<span id="cb208-85"><a href="#cb208-85" aria-hidden="true" tabindex="-1"></a>    <span class="co">&quot;&quot;&quot;Maximiert den Deckungsbeitrag. linprog minimiert, daher das Vorzeichen.&quot;&quot;&quot;</span></span>
+<span id="cb208-86"><a href="#cb208-86" aria-hidden="true" tabindex="-1"></a>    matrix, rechte_seite <span class="op">=</span> [], []</span>
+<span id="cb208-87"><a href="#cb208-87" aria-hidden="true" tabindex="-1"></a>    <span class="cf">for</span> _, koeffizienten, richtung, grenze <span class="kw">in</span> bedingungen:</span>
+<span id="cb208-88"><a href="#cb208-88" aria-hidden="true" tabindex="-1"></a>        zeile <span class="op">=</span> np.array(koeffizienten, dtype<span class="op">=</span><span class="bu">float</span>)</span>
+<span id="cb208-89"><a href="#cb208-89" aria-hidden="true" tabindex="-1"></a>        matrix.append(zeile <span class="cf">if</span> richtung <span class="op">==</span> <span class="st">&quot;&lt;=&quot;</span> <span class="cf">else</span> <span class="op">-</span>zeile)</span>
+<span id="cb208-90"><a href="#cb208-90" aria-hidden="true" tabindex="-1"></a>        rechte_seite.append(grenze <span class="cf">if</span> richtung <span class="op">==</span> <span class="st">&quot;&lt;=&quot;</span> <span class="cf">else</span> <span class="op">-</span>grenze)</span>
+<span id="cb208-91"><a href="#cb208-91" aria-hidden="true" tabindex="-1"></a>    <span class="cf">return</span> linprog(<span class="op">-</span>DECKUNGSBEITRAG,</span>
+<span id="cb208-92"><a href="#cb208-92" aria-hidden="true" tabindex="-1"></a>                   A_ub<span class="op">=</span>np.array(matrix), b_ub<span class="op">=</span>np.array(rechte_seite),</span>
+<span id="cb208-93"><a href="#cb208-93" aria-hidden="true" tabindex="-1"></a>                   bounds<span class="op">=</span>[(<span class="dv">0</span>, <span class="va">None</span>)] <span class="op">*</span> <span class="bu">len</span>(PRODUKTE), method<span class="op">=</span><span class="st">&quot;highs&quot;</span>)</span>
+<span id="cb208-94"><a href="#cb208-94" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb208-95"><a href="#cb208-95" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb208-96"><a href="#cb208-96" aria-hidden="true" tabindex="-1"></a><span class="kw">def</span> geaendert(name: <span class="bu">str</span>, delta: <span class="bu">float</span>,</span>
+<span id="cb208-97"><a href="#cb208-97" aria-hidden="true" tabindex="-1"></a>              basis<span class="op">=</span><span class="va">None</span>) <span class="op">-&gt;</span> <span class="bu">list</span>[<span class="bu">tuple</span>[<span class="bu">str</span>, <span class="bu">list</span>[<span class="bu">float</span>], <span class="bu">str</span>, <span class="bu">float</span>]]:</span>
+<span id="cb208-98"><a href="#cb208-98" aria-hidden="true" tabindex="-1"></a>    <span class="co">&quot;&quot;&quot;Dieselben Bedingungen, eine davon um delta verschoben.&quot;&quot;&quot;</span></span>
+<span id="cb208-99"><a href="#cb208-99" aria-hidden="true" tabindex="-1"></a>    <span class="cf">return</span> [(n, k, r, g <span class="op">+</span> delta <span class="cf">if</span> n <span class="op">==</span> name <span class="cf">else</span> g)</span>
+<span id="cb208-100"><a href="#cb208-100" aria-hidden="true" tabindex="-1"></a>            <span class="cf">for</span> n, k, r, g <span class="kw">in</span> (basis <span class="kw">or</span> BEDINGUNGEN)]</span>
+<span id="cb208-101"><a href="#cb208-101" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb208-102"><a href="#cb208-102" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb208-103"><a href="#cb208-103" aria-hidden="true" tabindex="-1"></a><span class="kw">def</span> auswertung(ergebnis, bedingungen<span class="op">=</span><span class="va">None</span>):</span>
+<span id="cb208-104"><a href="#cb208-104" aria-hidden="true" tabindex="-1"></a>    <span class="co">&quot;&quot;&quot;Schlupf und Schattenpreis je Bedingung.&quot;&quot;&quot;</span></span>
+<span id="cb208-105"><a href="#cb208-105" aria-hidden="true" tabindex="-1"></a>    x <span class="op">=</span> ergebnis.x</span>
+<span id="cb208-106"><a href="#cb208-106" aria-hidden="true" tabindex="-1"></a>    dual <span class="op">=</span> ergebnis.ineqlin.marginals</span>
+<span id="cb208-107"><a href="#cb208-107" aria-hidden="true" tabindex="-1"></a>    zeilen <span class="op">=</span> []</span>
+<span id="cb208-108"><a href="#cb208-108" aria-hidden="true" tabindex="-1"></a>    <span class="cf">for</span> i, (name, koeff, richtung, grenze) <span class="kw">in</span> <span class="bu">enumerate</span>(bedingungen <span class="kw">or</span> BEDINGUNGEN):</span>
+<span id="cb208-109"><a href="#cb208-109" aria-hidden="true" tabindex="-1"></a>        links <span class="op">=</span> <span class="bu">float</span>(np.array(koeff, dtype<span class="op">=</span><span class="bu">float</span>) <span class="op">@</span> x)</span>
+<span id="cb208-110"><a href="#cb208-110" aria-hidden="true" tabindex="-1"></a>        schlupf <span class="op">=</span> (grenze <span class="op">-</span> links) <span class="cf">if</span> richtung <span class="op">==</span> <span class="st">&quot;&lt;=&quot;</span> <span class="cf">else</span> (links <span class="op">-</span> grenze)</span>
+<span id="cb208-111"><a href="#cb208-111" aria-hidden="true" tabindex="-1"></a>        zeilen.append((name, links, richtung, grenze, schlupf, <span class="bu">abs</span>(dual[i])))</span>
+<span id="cb208-112"><a href="#cb208-112" aria-hidden="true" tabindex="-1"></a>    <span class="cf">return</span> zeilen</span>
+<span id="cb208-113"><a href="#cb208-113" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb208-114"><a href="#cb208-114" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb208-115"><a href="#cb208-115" aria-hidden="true" tabindex="-1"></a><span class="kw">def</span> blockierer(bedingungen, zusatz) <span class="op">-&gt;</span> <span class="bu">list</span>[<span class="bu">str</span>]:</span>
+<span id="cb208-116"><a href="#cb208-116" aria-hidden="true" tabindex="-1"></a>    <span class="co">&quot;&quot;&quot;Welche Bedingungen verhindern &#39;zusatz&#39; - einzeln weggelassen.</span></span>
+<span id="cb208-117"><a href="#cb208-117" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb208-118"><a href="#cb208-118" aria-hidden="true" tabindex="-1"></a><span class="co">    Dasselbe Vorgehen wie der Deletion Filter in Konfliktsuche.py, nur mit</span></span>
+<span id="cb208-119"><a href="#cb208-119" aria-hidden="true" tabindex="-1"></a><span class="co">    umgekehrtem Vorzeichen: Dort wird gesucht, was den Widerspruch AUSMACHT,</span></span>
+<span id="cb208-120"><a href="#cb208-120" aria-hidden="true" tabindex="-1"></a><span class="co">    hier, was einen Wunsch VERHINDERT. Wird das Modell ohne eine Bedingung</span></span>
+<span id="cb208-121"><a href="#cb208-121" aria-hidden="true" tabindex="-1"></a><span class="co">    loesbar, gehoert sie zum Konflikt.</span></span>
+<span id="cb208-122"><a href="#cb208-122" aria-hidden="true" tabindex="-1"></a><span class="co">    &quot;&quot;&quot;</span></span>
+<span id="cb208-123"><a href="#cb208-123" aria-hidden="true" tabindex="-1"></a>    gefunden <span class="op">=</span> []</span>
+<span id="cb208-124"><a href="#cb208-124" aria-hidden="true" tabindex="-1"></a>    <span class="cf">for</span> i, (name, _, _, _) <span class="kw">in</span> <span class="bu">enumerate</span>(bedingungen):</span>
+<span id="cb208-125"><a href="#cb208-125" aria-hidden="true" tabindex="-1"></a>        rest <span class="op">=</span> [c <span class="cf">for</span> j, c <span class="kw">in</span> <span class="bu">enumerate</span>(bedingungen) <span class="cf">if</span> j <span class="op">!=</span> i] <span class="op">+</span> [zusatz]</span>
+<span id="cb208-126"><a href="#cb208-126" aria-hidden="true" tabindex="-1"></a>        <span class="cf">if</span> loese(rest).success:</span>
+<span id="cb208-127"><a href="#cb208-127" aria-hidden="true" tabindex="-1"></a>            gefunden.append(name)</span>
+<span id="cb208-128"><a href="#cb208-128" aria-hidden="true" tabindex="-1"></a>    <span class="cf">return</span> gefunden</span>
+<span id="cb208-129"><a href="#cb208-129" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb208-130"><a href="#cb208-130" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb208-131"><a href="#cb208-131" aria-hidden="true" tabindex="-1"></a><span class="kw">def</span> euro(betrag: <span class="bu">float</span>) <span class="op">-&gt;</span> <span class="bu">str</span>:</span>
+<span id="cb208-132"><a href="#cb208-132" aria-hidden="true" tabindex="-1"></a>    <span class="cf">return</span> <span class="ss">f&quot;</span><span class="sc">{</span>betrag<span class="sc">:,.2f}</span><span class="ss"> EUR&quot;</span></span>
+<span id="cb208-133"><a href="#cb208-133" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb208-134"><a href="#cb208-134" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb208-135"><a href="#cb208-135" aria-hidden="true" tabindex="-1"></a><span class="cf">if</span> <span class="va">__name__</span> <span class="op">==</span> <span class="st">&quot;__main__&quot;</span>:</span>
+<span id="cb208-136"><a href="#cb208-136" aria-hidden="true" tabindex="-1"></a>    basis <span class="op">=</span> loese(BEDINGUNGEN)</span>
+<span id="cb208-137"><a href="#cb208-137" aria-hidden="true" tabindex="-1"></a>    db_basis <span class="op">=</span> <span class="op">-</span>basis.fun</span>
+<span id="cb208-138"><a href="#cb208-138" aria-hidden="true" tabindex="-1"></a>    plan <span class="op">=</span> <span class="bu">dict</span>(<span class="bu">zip</span>(PRODUKTE, basis.x))</span>
+<span id="cb208-139"><a href="#cb208-139" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb208-140"><a href="#cb208-140" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;=&quot;</span> <span class="op">*</span> <span class="dv">78</span>)</span>
+<span id="cb208-141"><a href="#cb208-141" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;  CONSTRAINT ATTRIBUTION: Was kostet uns welche Bedingung?&quot;</span>)</span>
+<span id="cb208-142"><a href="#cb208-142" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;=&quot;</span> <span class="op">*</span> <span class="dv">78</span>)</span>
+<span id="cb208-143"><a href="#cb208-143" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;Status: </span><span class="sc">{</span>basis<span class="sc">.</span>message<span class="sc">.</span>split(<span class="st">&#39;(&#39;</span>)[<span class="dv">0</span>]<span class="sc">.</span>strip()<span class="sc">}</span><span class="ss">&quot;</span>)</span>
+<span id="cb208-144"><a href="#cb208-144" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;Deckungsbeitrag des Plans: </span><span class="sc">{</span>euro(db_basis)<span class="sc">}</span><span class="ch">\n</span><span class="ss">&quot;</span>)</span>
+<span id="cb208-145"><a href="#cb208-145" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;  &quot;</span> <span class="op">+</span> <span class="st">&quot;  &quot;</span>.join(<span class="ss">f&quot;</span><span class="sc">{</span>p<span class="sc">}</span><span class="ss">: </span><span class="sc">{</span>m<span class="sc">:.1f}</span><span class="ss">&quot;</span> <span class="cf">for</span> p, m <span class="kw">in</span> plan.items()))</span>
+<span id="cb208-146"><a href="#cb208-146" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb208-147"><a href="#cb208-147" aria-hidden="true" tabindex="-1"></a>    <span class="co"># --- 1. Wer begrenzt den Plan? -----------------------------------------</span></span>
+<span id="cb208-148"><a href="#cb208-148" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;</span><span class="ch">\n</span><span class="st">&quot;</span> <span class="op">+</span> <span class="st">&quot;=&quot;</span> <span class="op">*</span> <span class="dv">78</span>)</span>
+<span id="cb208-149"><a href="#cb208-149" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;  (1) Welche Bedingungen binden - und was kostet die naechste Einheit?&quot;</span>)</span>
+<span id="cb208-150"><a href="#cb208-150" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;=&quot;</span> <span class="op">*</span> <span class="dv">78</span>)</span>
+<span id="cb208-151"><a href="#cb208-151" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;</span><span class="sc">{</span><span class="st">&#39;Bedingung&#39;</span><span class="sc">:&lt;24}</span><span class="ss"> </span><span class="sc">{</span><span class="st">&#39;genutzt&#39;</span><span class="sc">:&gt;9}</span><span class="ss"> </span><span class="sc">{</span><span class="st">&#39;Grenze&#39;</span><span class="sc">:&gt;7}</span><span class="ss"> </span><span class="sc">{</span><span class="st">&#39;Schlupf&#39;</span><span class="sc">:&gt;8}</span><span class="ss"> &quot;</span></span>
+<span id="cb208-152"><a href="#cb208-152" aria-hidden="true" tabindex="-1"></a>          <span class="ss">f&quot;</span><span class="sc">{</span><span class="st">&#39;Schattenpreis&#39;</span><span class="sc">:&gt;11}</span><span class="ss">&quot;</span>)</span>
+<span id="cb208-153"><a href="#cb208-153" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;-&quot;</span> <span class="op">*</span> <span class="dv">78</span>)</span>
+<span id="cb208-154"><a href="#cb208-154" aria-hidden="true" tabindex="-1"></a>    bindend <span class="op">=</span> []</span>
+<span id="cb208-155"><a href="#cb208-155" aria-hidden="true" tabindex="-1"></a>    <span class="cf">for</span> name, links, richtung, grenze, schlupf, dual <span class="kw">in</span> auswertung(basis):</span>
+<span id="cb208-156"><a href="#cb208-156" aria-hidden="true" tabindex="-1"></a>        marke <span class="op">=</span> <span class="st">&quot;&quot;</span></span>
+<span id="cb208-157"><a href="#cb208-157" aria-hidden="true" tabindex="-1"></a>        <span class="cf">if</span> <span class="bu">abs</span>(schlupf) <span class="op">&lt;</span> <span class="fl">1e-6</span>:</span>
+<span id="cb208-158"><a href="#cb208-158" aria-hidden="true" tabindex="-1"></a>            bindend.append((name, dual))</span>
+<span id="cb208-159"><a href="#cb208-159" aria-hidden="true" tabindex="-1"></a>            marke <span class="op">=</span> <span class="st">&quot;  &lt;-- bindend&quot;</span></span>
+<span id="cb208-160"><a href="#cb208-160" aria-hidden="true" tabindex="-1"></a>        <span class="bu">print</span>(<span class="ss">f&quot;</span><span class="sc">{</span>name<span class="sc">:&lt;24}</span><span class="ss"> </span><span class="sc">{</span>links<span class="sc">:&gt;9.1f}</span><span class="ss"> </span><span class="sc">{</span>grenze<span class="sc">:&gt;7.0f}</span><span class="ss"> </span><span class="sc">{</span>schlupf<span class="sc">:&gt;8.1f}</span><span class="ss"> &quot;</span></span>
+<span id="cb208-161"><a href="#cb208-161" aria-hidden="true" tabindex="-1"></a>              <span class="ss">f&quot;</span><span class="sc">{</span>dual<span class="sc">:&gt;11.2f}{</span>marke<span class="sc">}</span><span class="ss">&quot;</span>)</span>
+<span id="cb208-162"><a href="#cb208-162" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb208-163"><a href="#cb208-163" aria-hidden="true" tabindex="-1"></a>    ohne_preis <span class="op">=</span> [n <span class="cf">for</span> n, d <span class="kw">in</span> bindend <span class="cf">if</span> d <span class="op">&lt;</span> <span class="fl">1e-9</span>]</span>
+<span id="cb208-164"><a href="#cb208-164" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;</span><span class="ch">\n</span><span class="ss">  </span><span class="sc">{</span><span class="bu">len</span>(bindend)<span class="sc">}</span><span class="ss"> Bedingungen binden. Aber: &quot;</span></span>
+<span id="cb208-165"><a href="#cb208-165" aria-hidden="true" tabindex="-1"></a>          <span class="ss">f&quot;</span><span class="sc">{</span><span class="st">&#39;, &#39;</span><span class="sc">.</span>join(ohne_preis)<span class="sc">}</span><span class="ss"> bindet&quot;</span>)</span>
+<span id="cb208-166"><a href="#cb208-166" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;  mit einem Schattenpreis von 0,00 EUR - sie beruehrt den Plan, ohne ihn&quot;</span>)</span>
+<span id="cb208-167"><a href="#cb208-167" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;  zu verteuern. Bindend und kostenrelevant sind zwei verschiedene Dinge.&quot;</span>)</span>
+<span id="cb208-168"><a href="#cb208-168" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb208-169"><a href="#cb208-169" aria-hidden="true" tabindex="-1"></a>    <span class="co"># --- 2. Der Schattenpreis als Momentaufnahme ---------------------------</span></span>
+<span id="cb208-170"><a href="#cb208-170" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;</span><span class="ch">\n</span><span class="st">&quot;</span> <span class="op">+</span> <span class="st">&quot;=&quot;</span> <span class="op">*</span> <span class="dv">78</span>)</span>
+<span id="cb208-171"><a href="#cb208-171" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;  (2) Was der Schattenpreis verschweigt&quot;</span>)</span>
+<span id="cb208-172"><a href="#cb208-172" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;=&quot;</span> <span class="op">*</span> <span class="dv">78</span>)</span>
+<span id="cb208-173"><a href="#cb208-173" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;Der Schattenpreis gilt fuer die NAECHSTE Einheit. Ein Planer kauft aber&quot;</span>)</span>
+<span id="cb208-174"><a href="#cb208-174" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;keine Einheit, sondern eine ganze Schicht. Beides gegenuebergestellt:</span><span class="ch">\n</span><span class="st">&quot;</span>)</span>
+<span id="cb208-175"><a href="#cb208-175" aria-hidden="true" tabindex="-1"></a>    preise <span class="op">=</span> {name: dual <span class="cf">for</span> name, <span class="op">*</span>_, dual <span class="kw">in</span> auswertung(basis)}</span>
+<span id="cb208-176"><a href="#cb208-176" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;</span><span class="sc">{</span><span class="st">&#39;Stellschraube&#39;</span><span class="sc">:&lt;24}</span><span class="ss"> </span><span class="sc">{</span><span class="st">&#39;Preis&#39;</span><span class="sc">:&gt;9}</span><span class="ss"> </span><span class="sc">{</span><span class="st">&#39;Schritt&#39;</span><span class="sc">:&gt;7}</span><span class="ss"> &quot;</span></span>
+<span id="cb208-177"><a href="#cb208-177" aria-hidden="true" tabindex="-1"></a>          <span class="ss">f&quot;</span><span class="sc">{</span><span class="st">&#39;hochgerechnet&#39;</span><span class="sc">:&gt;13}</span><span class="ss"> </span><span class="sc">{</span><span class="st">&#39;gemessen&#39;</span><span class="sc">:&gt;9}</span><span class="ss"> </span><span class="sc">{</span><span class="st">&#39;Abw.&#39;</span><span class="sc">:&gt;9}</span><span class="ss">&quot;</span>)</span>
+<span id="cb208-178"><a href="#cb208-178" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;-&quot;</span> <span class="op">*</span> <span class="dv">78</span>)</span>
+<span id="cb208-179"><a href="#cb208-179" aria-hidden="true" tabindex="-1"></a>    wirkung <span class="op">=</span> {}</span>
+<span id="cb208-180"><a href="#cb208-180" aria-hidden="true" tabindex="-1"></a>    <span class="cf">for</span> name, (delta, _) <span class="kw">in</span> STELLSCHRAUBEN.items():</span>
+<span id="cb208-181"><a href="#cb208-181" aria-hidden="true" tabindex="-1"></a>        ergebnis <span class="op">=</span> loese(geaendert(name, delta))</span>
+<span id="cb208-182"><a href="#cb208-182" aria-hidden="true" tabindex="-1"></a>        echt <span class="op">=</span> (<span class="op">-</span>ergebnis.fun) <span class="op">-</span> db_basis <span class="cf">if</span> ergebnis.success <span class="cf">else</span> <span class="fl">0.0</span></span>
+<span id="cb208-183"><a href="#cb208-183" aria-hidden="true" tabindex="-1"></a>        linear <span class="op">=</span> preise[name] <span class="op">*</span> <span class="bu">abs</span>(delta)</span>
+<span id="cb208-184"><a href="#cb208-184" aria-hidden="true" tabindex="-1"></a>        wirkung[name] <span class="op">=</span> echt</span>
+<span id="cb208-185"><a href="#cb208-185" aria-hidden="true" tabindex="-1"></a>        <span class="bu">print</span>(<span class="ss">f&quot;</span><span class="sc">{</span>name<span class="sc">:&lt;24}</span><span class="ss"> </span><span class="sc">{</span>preise[name]<span class="sc">:&gt;9.2f}</span><span class="ss"> </span><span class="sc">{</span>delta<span class="sc">:&gt;+7.0f}</span><span class="ss"> &quot;</span></span>
+<span id="cb208-186"><a href="#cb208-186" aria-hidden="true" tabindex="-1"></a>              <span class="ss">f&quot;</span><span class="sc">{</span>linear<span class="sc">:&gt;13.2f}</span><span class="ss"> </span><span class="sc">{</span>echt<span class="sc">:&gt;9.2f}</span><span class="ss"> </span><span class="sc">{</span>echt <span class="op">-</span> linear<span class="sc">:&gt;+9.2f}</span><span class="ss">&quot;</span>)</span>
+<span id="cb208-187"><a href="#cb208-187" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb208-188"><a href="#cb208-188" aria-hidden="true" tabindex="-1"></a>    <span class="co"># Wo endet der Gueltigkeitsbereich? Schrittweise nachfahren.</span></span>
+<span id="cb208-189"><a href="#cb208-189" aria-hidden="true" tabindex="-1"></a>    abweichler <span class="op">=</span> <span class="bu">max</span>(STELLSCHRAUBEN,</span>
+<span id="cb208-190"><a href="#cb208-190" aria-hidden="true" tabindex="-1"></a>                     key<span class="op">=</span><span class="kw">lambda</span> n: preise[n] <span class="op">*</span> <span class="bu">abs</span>(STELLSCHRAUBEN[n][<span class="dv">0</span>]) <span class="op">-</span> wirkung[n])</span>
+<span id="cb208-191"><a href="#cb208-191" aria-hidden="true" tabindex="-1"></a>    delta_max <span class="op">=</span> STELLSCHRAUBEN[abweichler][<span class="dv">0</span>]</span>
+<span id="cb208-192"><a href="#cb208-192" aria-hidden="true" tabindex="-1"></a>    grenze_gueltig <span class="op">=</span> <span class="fl">0.0</span></span>
+<span id="cb208-193"><a href="#cb208-193" aria-hidden="true" tabindex="-1"></a>    schritt <span class="op">=</span> delta_max <span class="op">/</span> <span class="fl">60.0</span></span>
+<span id="cb208-194"><a href="#cb208-194" aria-hidden="true" tabindex="-1"></a>    vorher <span class="op">=</span> db_basis</span>
+<span id="cb208-195"><a href="#cb208-195" aria-hidden="true" tabindex="-1"></a>    <span class="cf">for</span> i <span class="kw">in</span> <span class="bu">range</span>(<span class="dv">1</span>, <span class="dv">61</span>):</span>
+<span id="cb208-196"><a href="#cb208-196" aria-hidden="true" tabindex="-1"></a>        d <span class="op">=</span> schritt <span class="op">*</span> i</span>
+<span id="cb208-197"><a href="#cb208-197" aria-hidden="true" tabindex="-1"></a>        e <span class="op">=</span> loese(geaendert(abweichler, d))</span>
+<span id="cb208-198"><a href="#cb208-198" aria-hidden="true" tabindex="-1"></a>        db <span class="op">=</span> <span class="op">-</span>e.fun <span class="cf">if</span> e.success <span class="cf">else</span> vorher</span>
+<span id="cb208-199"><a href="#cb208-199" aria-hidden="true" tabindex="-1"></a>        <span class="cf">if</span> db <span class="op">-</span> vorher <span class="op">&gt;</span> <span class="fl">1e-9</span>:</span>
+<span id="cb208-200"><a href="#cb208-200" aria-hidden="true" tabindex="-1"></a>            grenze_gueltig <span class="op">=</span> d</span>
+<span id="cb208-201"><a href="#cb208-201" aria-hidden="true" tabindex="-1"></a>        vorher <span class="op">=</span> db</span>
+<span id="cb208-202"><a href="#cb208-202" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;</span><span class="ch">\n</span><span class="ss">  &#39;</span><span class="sc">{</span>abweichler<span class="sc">}</span><span class="ss">&#39;: hochgerechnet &quot;</span></span>
+<span id="cb208-203"><a href="#cb208-203" aria-hidden="true" tabindex="-1"></a>          <span class="ss">f&quot;</span><span class="sc">{</span>preise[abweichler] <span class="op">*</span> <span class="bu">abs</span>(delta_max)<span class="sc">:.2f}</span><span class="ss"> EUR, tatsaechlich &quot;</span></span>
+<span id="cb208-204"><a href="#cb208-204" aria-hidden="true" tabindex="-1"></a>          <span class="ss">f&quot;</span><span class="sc">{</span>wirkung[abweichler]<span class="sc">:.2f}</span><span class="ss"> EUR.&quot;</span>)</span>
+<span id="cb208-205"><a href="#cb208-205" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;  Der Preis von </span><span class="sc">{</span>preise[abweichler]<span class="sc">:.2f}</span><span class="ss"> EUR gilt nur bis &quot;</span></span>
+<span id="cb208-206"><a href="#cb208-206" aria-hidden="true" tabindex="-1"></a>          <span class="ss">f&quot;+</span><span class="sc">{</span>grenze_gueltig<span class="sc">:.0f}</span><span class="ss"> Stunden. Jede weitere Stunde&quot;</span>)</span>
+<span id="cb208-207"><a href="#cb208-207" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;  dieser Sonderschicht bringt exakt nichts - der Engpass ist dann ein anderer.&quot;</span>)</span>
+<span id="cb208-208"><a href="#cb208-208" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb208-209"><a href="#cb208-209" aria-hidden="true" tabindex="-1"></a>    nach_preis <span class="op">=</span> <span class="bu">sorted</span>(STELLSCHRAUBEN, key<span class="op">=</span><span class="kw">lambda</span> n: <span class="op">-</span>preise[n])[<span class="dv">0</span>]</span>
+<span id="cb208-210"><a href="#cb208-210" aria-hidden="true" tabindex="-1"></a>    nach_wirkung <span class="op">=</span> <span class="bu">max</span>(wirkung, key<span class="op">=</span>wirkung.get)</span>
+<span id="cb208-211"><a href="#cb208-211" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;</span><span class="ch">\n</span><span class="ss">  Und die Ranglisten drehen sich: Nach Schattenpreis fuehrt&quot;</span>)</span>
+<span id="cb208-212"><a href="#cb208-212" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;  &#39;</span><span class="sc">{</span>nach_preis<span class="sc">}</span><span class="ss">&#39; (</span><span class="sc">{</span>preise[nach_preis]<span class="sc">:.2f}</span><span class="ss"> EUR je Einheit),&quot;</span>)</span>
+<span id="cb208-213"><a href="#cb208-213" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;  nach tatsaechlicher Wirkung &#39;</span><span class="sc">{</span>nach_wirkung<span class="sc">}</span><span class="ss">&#39; &quot;</span></span>
+<span id="cb208-214"><a href="#cb208-214" aria-hidden="true" tabindex="-1"></a>          <span class="ss">f&quot;(</span><span class="sc">{</span>wirkung[nach_wirkung]<span class="sc">:.2f}</span><span class="ss"> EUR).&quot;</span>)</span>
+<span id="cb208-215"><a href="#cb208-215" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;  Der Schattenpreis sagt, was eine Einheit wert ist - nicht, wie viele&quot;</span>)</span>
+<span id="cb208-216"><a href="#cb208-216" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;  Einheiten zu haben sind.&quot;</span>)</span>
+<span id="cb208-217"><a href="#cb208-217" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb208-218"><a href="#cb208-218" aria-hidden="true" tabindex="-1"></a>    <span class="co"># --- 3. Der Wunsch aus dem Vertrieb ------------------------------------</span></span>
+<span id="cb208-219"><a href="#cb208-219" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;</span><span class="ch">\n</span><span class="st">&quot;</span> <span class="op">+</span> <span class="st">&quot;=&quot;</span> <span class="op">*</span> <span class="dv">78</span>)</span>
+<span id="cb208-220"><a href="#cb208-220" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;  (3) Was-waere-wenn: mindestens </span><span class="sc">{</span>WUNSCH_MENGE<span class="sc">:.0f}</span><span class="ss"> &quot;</span></span>
+<span id="cb208-221"><a href="#cb208-221" aria-hidden="true" tabindex="-1"></a>          <span class="ss">f&quot;</span><span class="sc">{</span>WUNSCH_PRODUKT<span class="sc">}</span><span class="ss"> statt </span><span class="sc">{</span>plan[WUNSCH_PRODUKT]<span class="sc">:.1f}</span><span class="ss">&quot;</span>)</span>
+<span id="cb208-222"><a href="#cb208-222" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;=&quot;</span> <span class="op">*</span> <span class="dv">78</span>)</span>
+<span id="cb208-223"><a href="#cb208-223" aria-hidden="true" tabindex="-1"></a>    wunsch <span class="op">=</span> (<span class="ss">f&quot;Wunsch Vertrieb </span><span class="sc">{</span>WUNSCH_PRODUKT<span class="sc">}</span><span class="ss">&quot;</span>,</span>
+<span id="cb208-224"><a href="#cb208-224" aria-hidden="true" tabindex="-1"></a>              [<span class="dv">1</span> <span class="cf">if</span> p <span class="op">==</span> WUNSCH_PRODUKT <span class="cf">else</span> <span class="dv">0</span> <span class="cf">for</span> p <span class="kw">in</span> PRODUKTE], <span class="st">&quot;&gt;=&quot;</span>, WUNSCH_MENGE)</span>
+<span id="cb208-225"><a href="#cb208-225" aria-hidden="true" tabindex="-1"></a>    mit_wunsch <span class="op">=</span> loese(BEDINGUNGEN <span class="op">+</span> [wunsch])</span>
+<span id="cb208-226"><a href="#cb208-226" aria-hidden="true" tabindex="-1"></a>    schuldige: <span class="bu">list</span>[<span class="bu">str</span>] <span class="op">=</span> []</span>
+<span id="cb208-227"><a href="#cb208-227" aria-hidden="true" tabindex="-1"></a>    engpass <span class="op">=</span> noetig <span class="op">=</span> <span class="va">None</span></span>
+<span id="cb208-228"><a href="#cb208-228" aria-hidden="true" tabindex="-1"></a>    wunsch_gratis <span class="op">=</span> <span class="va">False</span></span>
+<span id="cb208-229"><a href="#cb208-229" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb208-230"><a href="#cb208-230" aria-hidden="true" tabindex="-1"></a>    <span class="cf">if</span> mit_wunsch.success:</span>
+<span id="cb208-231"><a href="#cb208-231" aria-hidden="true" tabindex="-1"></a>        <span class="bu">print</span>(<span class="ss">f&quot;Erfuellbar, kostet </span><span class="sc">{</span>euro(db_basis <span class="op">-</span> (<span class="op">-</span>mit_wunsch.fun))<span class="sc">}</span><span class="ss">.&quot;</span>)</span>
+<span id="cb208-232"><a href="#cb208-232" aria-hidden="true" tabindex="-1"></a>    <span class="cf">else</span>:</span>
+<span id="cb208-233"><a href="#cb208-233" aria-hidden="true" tabindex="-1"></a>        schuldige <span class="op">=</span> blockierer(BEDINGUNGEN, wunsch)</span>
+<span id="cb208-234"><a href="#cb208-234" aria-hidden="true" tabindex="-1"></a>        <span class="bu">print</span>(<span class="st">&quot;Der Wunsch ist nicht teuer - er ist UNMOEGLICH.</span><span class="ch">\n</span><span class="st">&quot;</span>)</span>
+<span id="cb208-235"><a href="#cb208-235" aria-hidden="true" tabindex="-1"></a>        <span class="bu">print</span>(<span class="ss">f&quot;Blockiert wird er von </span><span class="sc">{</span><span class="bu">len</span>(schuldige)<span class="sc">}</span><span class="ss"> Bedingungen gemeinsam. &quot;</span></span>
+<span id="cb208-236"><a href="#cb208-236" aria-hidden="true" tabindex="-1"></a>              <span class="ss">f&quot;Faellt eine davon&quot;</span>)</span>
+<span id="cb208-237"><a href="#cb208-237" aria-hidden="true" tabindex="-1"></a>        <span class="bu">print</span>(<span class="st">&quot;weg, ist er erfuellbar; keine allein ist &#39;der&#39; Grund:&quot;</span>)</span>
+<span id="cb208-238"><a href="#cb208-238" aria-hidden="true" tabindex="-1"></a>        <span class="cf">for</span> name <span class="kw">in</span> schuldige:</span>
+<span id="cb208-239"><a href="#cb208-239" aria-hidden="true" tabindex="-1"></a>            e <span class="op">=</span> loese([c <span class="cf">for</span> c <span class="kw">in</span> BEDINGUNGEN <span class="cf">if</span> c[<span class="dv">0</span>] <span class="op">!=</span> name] <span class="op">+</span> [wunsch])</span>
+<span id="cb208-240"><a href="#cb208-240" aria-hidden="true" tabindex="-1"></a>            <span class="bu">print</span>(<span class="ss">f&quot;   ohne &#39;</span><span class="sc">{</span>name<span class="sc">}</span><span class="ss">&#39;: moeglich, Deckungsbeitrag </span><span class="sc">{</span>euro(<span class="op">-</span>e.fun)<span class="sc">}</span><span class="ss">&quot;</span>)</span>
+<span id="cb208-241"><a href="#cb208-241" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb208-242"><a href="#cb208-242" aria-hidden="true" tabindex="-1"></a>        engpass <span class="op">=</span> <span class="bu">next</span>((n <span class="cf">for</span> n <span class="kw">in</span> schuldige <span class="cf">if</span> n <span class="kw">in</span> STELLSCHRAUBEN), schuldige[<span class="dv">0</span>])</span>
+<span id="cb208-243"><a href="#cb208-243" aria-hidden="true" tabindex="-1"></a>        <span class="cf">for</span> schritt <span class="kw">in</span> <span class="bu">range</span>(<span class="dv">1</span>, <span class="dv">61</span>):</span>
+<span id="cb208-244"><a href="#cb208-244" aria-hidden="true" tabindex="-1"></a>            <span class="cf">if</span> loese(geaendert(engpass, schritt) <span class="op">+</span> [wunsch]).success:</span>
+<span id="cb208-245"><a href="#cb208-245" aria-hidden="true" tabindex="-1"></a>                noetig <span class="op">=</span> schritt</span>
+<span id="cb208-246"><a href="#cb208-246" aria-hidden="true" tabindex="-1"></a>                <span class="cf">break</span></span>
+<span id="cb208-247"><a href="#cb208-247" aria-hidden="true" tabindex="-1"></a>        <span class="cf">if</span> noetig <span class="kw">is</span> <span class="kw">not</span> <span class="va">None</span>:</span>
+<span id="cb208-248"><a href="#cb208-248" aria-hidden="true" tabindex="-1"></a>            e <span class="op">=</span> loese(geaendert(engpass, noetig) <span class="op">+</span> [wunsch])</span>
+<span id="cb208-249"><a href="#cb208-249" aria-hidden="true" tabindex="-1"></a>            ohne <span class="op">=</span> loese(geaendert(engpass, noetig))</span>
+<span id="cb208-250"><a href="#cb208-250" aria-hidden="true" tabindex="-1"></a>            wunsch_gratis <span class="op">=</span> <span class="bu">abs</span>((<span class="op">-</span>e.fun) <span class="op">-</span> (<span class="op">-</span>ohne.fun)) <span class="op">&lt;</span> <span class="fl">1e-6</span></span>
+<span id="cb208-251"><a href="#cb208-251" aria-hidden="true" tabindex="-1"></a>            <span class="bu">print</span>(<span class="ss">f&quot;</span><span class="ch">\n</span><span class="ss">   Mit +</span><span class="sc">{</span>noetig<span class="sc">}</span><span class="ss"> bei &#39;</span><span class="sc">{</span>engpass<span class="sc">}</span><span class="ss">&#39; wird der Wunsch erfuellbar:&quot;</span>)</span>
+<span id="cb208-252"><a href="#cb208-252" aria-hidden="true" tabindex="-1"></a>            <span class="bu">print</span>(<span class="ss">f&quot;   Deckungsbeitrag </span><span class="sc">{</span>euro(<span class="op">-</span>e.fun)<span class="sc">}</span><span class="ss"> &quot;</span></span>
+<span id="cb208-253"><a href="#cb208-253" aria-hidden="true" tabindex="-1"></a>                  <span class="ss">f&quot;(</span><span class="sc">{</span><span class="op">-</span>e<span class="sc">.</span>fun <span class="op">-</span> db_basis<span class="sc">:+,.2f}</span><span class="ss"> gegenueber heute).&quot;</span>)</span>
+<span id="cb208-254"><a href="#cb208-254" aria-hidden="true" tabindex="-1"></a>            <span class="cf">if</span> wunsch_gratis:</span>
+<span id="cb208-255"><a href="#cb208-255" aria-hidden="true" tabindex="-1"></a>                <span class="bu">print</span>(<span class="ss">f&quot;   Und ohne den Wunsch ergaebe dieselbe Lockerung &quot;</span></span>
+<span id="cb208-256"><a href="#cb208-256" aria-hidden="true" tabindex="-1"></a>                      <span class="ss">f&quot;</span><span class="sc">{</span>euro(<span class="op">-</span>ohne.fun)<span class="sc">}</span><span class="ss"> bei&quot;</span>)</span>
+<span id="cb208-257"><a href="#cb208-257" aria-hidden="true" tabindex="-1"></a>                <span class="bu">print</span>(<span class="ss">f&quot;   </span><span class="sc">{</span>ohne<span class="sc">.</span>x[PRODUKTE.index(WUNSCH_PRODUKT)]<span class="sc">:.0f}</span><span class="ss"> &quot;</span></span>
+<span id="cb208-258"><a href="#cb208-258" aria-hidden="true" tabindex="-1"></a>                      <span class="ss">f&quot;</span><span class="sc">{</span>WUNSCH_PRODUKT<span class="sc">}</span><span class="ss"> - der Wunsch kostet also NICHTS.&quot;</span>)</span>
+<span id="cb208-259"><a href="#cb208-259" aria-hidden="true" tabindex="-1"></a>                <span class="bu">print</span>(<span class="st">&quot;   Er war nie das Problem. Der Engpass war es.&quot;</span>)</span>
+<span id="cb208-260"><a href="#cb208-260" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb208-261"><a href="#cb208-261" aria-hidden="true" tabindex="-1"></a>    <span class="co"># --- 4. Der Bericht ----------------------------------------------------</span></span>
+<span id="cb208-262"><a href="#cb208-262" aria-hidden="true" tabindex="-1"></a>    <span class="co"># Aus denselben Zahlen, die oben in Tabellen stehen, wird hier Prosa. Kein</span></span>
+<span id="cb208-263"><a href="#cb208-263" aria-hidden="true" tabindex="-1"></a>    <span class="co"># Satz enthaelt eine Zahl, die nicht vorher gerechnet wurde - das ist der</span></span>
+<span id="cb208-264"><a href="#cb208-264" aria-hidden="true" tabindex="-1"></a>    <span class="co"># ganze Trick und zugleich die Bedingung dafuer, dass der Bericht nicht</span></span>
+<span id="cb208-265"><a href="#cb208-265" aria-hidden="true" tabindex="-1"></a>    <span class="co"># irgendwann leise falsch wird.</span></span>
+<span id="cb208-266"><a href="#cb208-266" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;</span><span class="ch">\n</span><span class="st">&quot;</span> <span class="op">+</span> <span class="st">&quot;=&quot;</span> <span class="op">*</span> <span class="dv">78</span>)</span>
+<span id="cb208-267"><a href="#cb208-267" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;  (4) Und so steht es in der Vorlage fuer die Abteilungsleiterrunde&quot;</span>)</span>
+<span id="cb208-268"><a href="#cb208-268" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;=&quot;</span> <span class="op">*</span> <span class="dv">78</span>)</span>
+<span id="cb208-269"><a href="#cb208-269" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb208-270"><a href="#cb208-270" aria-hidden="true" tabindex="-1"></a>    teuerste <span class="op">=</span> <span class="bu">sorted</span>(((n, d) <span class="cf">for</span> n, d <span class="kw">in</span> bindend <span class="cf">if</span> d <span class="op">&gt;</span> <span class="dv">0</span>), key<span class="op">=</span><span class="kw">lambda</span> t: <span class="op">-</span>t[<span class="dv">1</span>])</span>
+<span id="cb208-271"><a href="#cb208-271" aria-hidden="true" tabindex="-1"></a>    gross <span class="op">=</span> STELLSCHRAUBEN[nach_wirkung][<span class="dv">1</span>]</span>
+<span id="cb208-272"><a href="#cb208-272" aria-hidden="true" tabindex="-1"></a>    klein <span class="op">=</span> STELLSCHRAUBEN[abweichler][<span class="dv">1</span>]</span>
+<span id="cb208-273"><a href="#cb208-273" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb208-274"><a href="#cb208-274" aria-hidden="true" tabindex="-1"></a>    absaetze <span class="op">=</span> [</span>
+<span id="cb208-275"><a href="#cb208-275" aria-hidden="true" tabindex="-1"></a>        <span class="ss">f&quot;Der Plan bringt </span><span class="sc">{</span>euro(db_basis)<span class="sc">}</span><span class="ss"> Deckungsbeitrag. Begrenzt wird er von &quot;</span></span>
+<span id="cb208-276"><a href="#cb208-276" aria-hidden="true" tabindex="-1"></a>        <span class="ss">f&quot;</span><span class="sc">{</span><span class="bu">len</span>(bindend)<span class="sc">}</span><span class="ss"> Bedingungen, von denen </span><span class="sc">{</span><span class="bu">len</span>(teuerste)<span class="sc">}</span><span class="ss"> tatsaechlich Geld &quot;</span></span>
+<span id="cb208-277"><a href="#cb208-277" aria-hidden="true" tabindex="-1"></a>        <span class="ss">f&quot;kosten; </span><span class="ch">\&quot;</span><span class="sc">{</span>ohne_preis[<span class="dv">0</span>]<span class="sc">}</span><span class="ch">\&quot;</span><span class="ss"> beruehrt den Plan, ohne ihn zu verteuern.&quot;</span>,</span>
+<span id="cb208-278"><a href="#cb208-278" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb208-279"><a href="#cb208-279" aria-hidden="true" tabindex="-1"></a>        <span class="ss">f&quot;Teuerste Bindung ist </span><span class="ch">\&quot;</span><span class="sc">{</span>teuerste[<span class="dv">0</span>][<span class="dv">0</span>]<span class="sc">}</span><span class="ch">\&quot;</span><span class="ss"> mit &quot;</span></span>
+<span id="cb208-280"><a href="#cb208-280" aria-hidden="true" tabindex="-1"></a>        <span class="ss">f&quot;</span><span class="sc">{</span>teuerste[<span class="dv">0</span>][<span class="dv">1</span>]<span class="sc">:.2f}</span><span class="ss"> EUR je Einheit, gefolgt von </span><span class="ch">\&quot;</span><span class="sc">{</span>teuerste[<span class="dv">1</span>][<span class="dv">0</span>]<span class="sc">}</span><span class="ch">\&quot;</span><span class="ss"> &quot;</span></span>
+<span id="cb208-281"><a href="#cb208-281" aria-hidden="true" tabindex="-1"></a>        <span class="ss">f&quot;mit </span><span class="sc">{</span>teuerste[<span class="dv">1</span>][<span class="dv">1</span>]<span class="sc">:.2f}</span><span class="ss"> EUR.&quot;</span>,</span>
+<span id="cb208-282"><a href="#cb208-282" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb208-283"><a href="#cb208-283" aria-hidden="true" tabindex="-1"></a>        <span class="ss">f&quot;Die groesste einzelne Verbesserung bringt </span><span class="sc">{</span>gross<span class="sc">}</span><span class="ss">: &quot;</span></span>
+<span id="cb208-284"><a href="#cb208-284" aria-hidden="true" tabindex="-1"></a>        <span class="ss">f&quot;</span><span class="sc">{</span>euro(wirkung[nach_wirkung])<span class="sc">}</span><span class="ss"> mehr Deckungsbeitrag. </span><span class="sc">{</span>klein[<span class="dv">0</span>]<span class="sc">.</span>upper()<span class="sc">}{</span>klein[<span class="dv">1</span>:]<span class="sc">}</span><span class="ss"> &quot;</span></span>
+<span id="cb208-285"><a href="#cb208-285" aria-hidden="true" tabindex="-1"></a>        <span class="ss">f&quot;dagegen bringt nur </span><span class="sc">{</span>euro(wirkung[abweichler])<span class="sc">}</span><span class="ss"> statt der rechnerischen &quot;</span></span>
+<span id="cb208-286"><a href="#cb208-286" aria-hidden="true" tabindex="-1"></a>        <span class="ss">f&quot;</span><span class="sc">{</span>euro(preise[abweichler] <span class="op">*</span> <span class="bu">abs</span>(delta_max))<span class="sc">}</span><span class="ss"> - ab +</span><span class="sc">{</span>grenze_gueltig<span class="sc">:.0f}</span><span class="ss"> &quot;</span></span>
+<span id="cb208-287"><a href="#cb208-287" aria-hidden="true" tabindex="-1"></a>        <span class="ss">f&quot;Stunden begrenzt uns etwas anderes. Wer die ganze Schicht bezahlt, &quot;</span></span>
+<span id="cb208-288"><a href="#cb208-288" aria-hidden="true" tabindex="-1"></a>        <span class="ss">f&quot;bezahlt die zweite Haelfte umsonst.&quot;</span>,</span>
+<span id="cb208-289"><a href="#cb208-289" aria-hidden="true" tabindex="-1"></a>    ]</span>
+<span id="cb208-290"><a href="#cb208-290" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb208-291"><a href="#cb208-291" aria-hidden="true" tabindex="-1"></a>    <span class="cf">if</span> schuldige <span class="kw">and</span> noetig <span class="kw">is</span> <span class="kw">not</span> <span class="va">None</span>:</span>
+<span id="cb208-292"><a href="#cb208-292" aria-hidden="true" tabindex="-1"></a>        namen <span class="op">=</span> <span class="st">&quot;, &quot;</span>.join(<span class="ss">f&#39;&quot;</span><span class="sc">{</span>s<span class="sc">}</span><span class="ss">&quot;&#39;</span> <span class="cf">for</span> s <span class="kw">in</span> schuldige)</span>
+<span id="cb208-293"><a href="#cb208-293" aria-hidden="true" tabindex="-1"></a>        satz <span class="op">=</span> (<span class="ss">f&quot;Zum Wunsch des Vertriebs (</span><span class="sc">{</span>WUNSCH_MENGE<span class="sc">:.0f}</span><span class="ss"> </span><span class="sc">{</span>WUNSCH_PRODUKT<span class="sc">}</span><span class="ss"> statt &quot;</span></span>
+<span id="cb208-294"><a href="#cb208-294" aria-hidden="true" tabindex="-1"></a>                <span class="ss">f&quot;</span><span class="sc">{</span>plan[WUNSCH_PRODUKT]<span class="sc">:.1f}</span><span class="ss">): Er ist mit der heutigen Ausstattung &quot;</span></span>
+<span id="cb208-295"><a href="#cb208-295" aria-hidden="true" tabindex="-1"></a>                <span class="ss">f&quot;nicht erfuellbar - nicht aus Kostengruenden, sondern weil </span><span class="sc">{</span>namen<span class="sc">}</span><span class="ss"> &quot;</span></span>
+<span id="cb208-296"><a href="#cb208-296" aria-hidden="true" tabindex="-1"></a>                <span class="ss">f&quot;ihn gemeinsam blockieren. Mit +</span><span class="sc">{</span>noetig<span class="sc">}</span><span class="ss"> Stunden bei &quot;</span></span>
+<span id="cb208-297"><a href="#cb208-297" aria-hidden="true" tabindex="-1"></a>                <span class="ss">f&#39;&quot;</span><span class="sc">{</span>engpass<span class="sc">}</span><span class="ss">&quot; wird er moeglich&#39;</span>)</span>
+<span id="cb208-298"><a href="#cb208-298" aria-hidden="true" tabindex="-1"></a>        satz <span class="op">+=</span> (<span class="st">&quot;, und er kostet dann nichts: Der Plan waehlt diese Menge von &quot;</span></span>
+<span id="cb208-299"><a href="#cb208-299" aria-hidden="true" tabindex="-1"></a>                 <span class="st">&quot;sich aus.&quot;</span> <span class="cf">if</span> wunsch_gratis <span class="cf">else</span> <span class="st">&quot;.&quot;</span>)</span>
+<span id="cb208-300"><a href="#cb208-300" aria-hidden="true" tabindex="-1"></a>        absaetze.append(satz)</span>
+<span id="cb208-301"><a href="#cb208-301" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb208-302"><a href="#cb208-302" aria-hidden="true" tabindex="-1"></a>    <span class="cf">for</span> absatz <span class="kw">in</span> absaetze:</span>
+<span id="cb208-303"><a href="#cb208-303" aria-hidden="true" tabindex="-1"></a>        <span class="bu">print</span>()</span>
+<span id="cb208-304"><a href="#cb208-304" aria-hidden="true" tabindex="-1"></a>        <span class="bu">print</span>(textwrap.fill(absatz, width<span class="op">=</span><span class="dv">76</span>))</span>
+<span id="cb208-305"><a href="#cb208-305" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;</span><span class="ch">\n</span><span class="st">&quot;</span> <span class="op">+</span> <span class="st">&quot;=&quot;</span> <span class="op">*</span> <span class="dv">78</span>)</span></code></pre></div>
+<p><strong>Ausgabe:</strong></p>
+<pre><code>==============================================================================
+  CONSTRAINT ATTRIBUTION: Was kostet uns welche Bedingung?
+==============================================================================
+Status: Optimization terminated successfully.
+Deckungsbeitrag des Plans: 3,930.00 EUR
+
+  Rahmen: 47.5  Gehaeuse: 30.0  Deckel: 97.5  Traeger: 25.0  Halter: 0.0
+
+==============================================================================
+  (1) Welche Bedingungen binden - und was kostet die naechste Einheit?
+==============================================================================
+Bedingung                  genutzt  Grenze  Schlupf Schattenpreis
+------------------------------------------------------------------------------
+Kapazitaet Montage           400.0     400      0.0        9.00  &lt;-- bindend
+Kapazitaet Lackieren         210.0     210      0.0        4.00  &lt;-- bindend
+Kapazitaet Pruefung          200.0     300    100.0        0.00
+Liefervertrag Rahmen          47.5      40      7.5        0.00
+Liefervertrag Gehaeuse        30.0      30      0.0        2.00  &lt;-- bindend
+Liefervertrag Deckel          97.5      20     77.5        0.00
+Liefervertrag Traeger         25.0      25      0.0       18.00  &lt;-- bindend
+Marktgrenze Rahmen            47.5     120     72.5        0.00
+Marktgrenze Gehaeuse          30.0      90     60.0        0.00
+Marktgrenze Deckel            97.5     150     52.5        0.00
+Marktgrenze Halter             0.0     200    200.0        0.00
+Mindestumsatz              10800.0   10000    800.0        0.00
+Sortimentsbreite             122.5     100     22.5        0.00
+Lackierbudget Schicht 2       55.0      55      0.0        0.00  &lt;-- bindend
+
+  5 Bedingungen binden. Aber: Lackierbudget Schicht 2 bindet
+  mit einem Schattenpreis von 0,00 EUR - sie beruehrt den Plan, ohne ihn
+  zu verteuern. Bindend und kostenrelevant sind zwei verschiedene Dinge.
+
+==============================================================================
+  (2) Was der Schattenpreis verschweigt
+==============================================================================
+Der Schattenpreis gilt fuer die NAECHSTE Einheit. Ein Planer kauft aber
+keine Einheit, sondern eine ganze Schicht. Beides gegenuebergestellt:
+
+Stellschraube                Preis Schritt hochgerechnet  gemessen      Abw.
+------------------------------------------------------------------------------
+Kapazitaet Montage            9.00     +50        450.00    450.00     +0.00
+Kapazitaet Lackieren          4.00     +30        120.00     60.00    -60.00
+Kapazitaet Pruefung           0.00     +50          0.00      0.00     +0.00
+Lackierbudget Schicht 2       0.00     +10          0.00      0.00     +0.00
+Liefervertrag Traeger        18.00     -10        180.00    180.00     +0.00
+Liefervertrag Gehaeuse        2.00     -10         20.00     18.00     -2.00
+
+  &#39;Kapazitaet Lackieren&#39;: hochgerechnet 120.00 EUR, tatsaechlich 60.00 EUR.
+  Der Preis von 4.00 EUR gilt nur bis +15 Stunden. Jede weitere Stunde
+  dieser Sonderschicht bringt exakt nichts - der Engpass ist dann ein anderer.
+
+  Und die Ranglisten drehen sich: Nach Schattenpreis fuehrt
+  &#39;Liefervertrag Traeger&#39; (18.00 EUR je Einheit),
+  nach tatsaechlicher Wirkung &#39;Kapazitaet Montage&#39; (450.00 EUR).
+  Der Schattenpreis sagt, was eine Einheit wert ist - nicht, wie viele
+  Einheiten zu haben sind.
+
+==============================================================================
+  (3) Was-waere-wenn: mindestens 55 Rahmen statt 47.5
+==============================================================================
+Der Wunsch ist nicht teuer - er ist UNMOEGLICH.
+
+Blockiert wird er von 3 Bedingungen gemeinsam. Faellt eine davon
+weg, ist er erfuellbar; keine allein ist &#39;der&#39; Grund:
+   ohne &#39;Kapazitaet Lackieren&#39;: moeglich, Deckungsbeitrag 3,990.00 EUR
+   ohne &#39;Liefervertrag Gehaeuse&#39;: moeglich, Deckungsbeitrag 3,948.00 EUR
+   ohne &#39;Liefervertrag Traeger&#39;: moeglich, Deckungsbeitrag 4,320.00 EUR
+
+   Mit +15 bei &#39;Kapazitaet Lackieren&#39; wird der Wunsch erfuellbar:
+   Deckungsbeitrag 3,990.00 EUR (+60.00 gegenueber heute).
+   Und ohne den Wunsch ergaebe dieselbe Lockerung 3,990.00 EUR bei
+   55 Rahmen - der Wunsch kostet also NICHTS.
+   Er war nie das Problem. Der Engpass war es.
+
+==============================================================================
+  (4) Und so steht es in der Vorlage fuer die Abteilungsleiterrunde
+==============================================================================
+
+Der Plan bringt 3,930.00 EUR Deckungsbeitrag. Begrenzt wird er von 5
+Bedingungen, von denen 4 tatsaechlich Geld kosten; &quot;Lackierbudget Schicht 2&quot;
+beruehrt den Plan, ohne ihn zu verteuern.
+
+Teuerste Bindung ist &quot;Liefervertrag Traeger&quot; mit 18.00 EUR je Einheit,
+gefolgt von &quot;Kapazitaet Montage&quot; mit 9.00 EUR.
+
+Die groesste einzelne Verbesserung bringt eine Sonderschicht Montage: 450.00
+EUR mehr Deckungsbeitrag. Eine Sonderschicht Lackieren dagegen bringt nur
+60.00 EUR statt der rechnerischen 120.00 EUR - ab +15 Stunden begrenzt uns
+etwas anderes. Wer die ganze Schicht bezahlt, bezahlt die zweite Haelfte
+umsonst.
+
+Zum Wunsch des Vertriebs (55 Rahmen statt 47.5): Er ist mit der heutigen
+Ausstattung nicht erfuellbar - nicht aus Kostengruenden, sondern weil
+&quot;Kapazitaet Lackieren&quot;, &quot;Liefervertrag Gehaeuse&quot;, &quot;Liefervertrag Traeger&quot;
+ihn gemeinsam blockieren. Mit +15 Stunden bei &quot;Kapazitaet Lackieren&quot; wird er
+moeglich, und er kostet dann nichts: Der Plan waehlt diese Menge von sich
+aus.
+
+==============================================================================</code></pre>
+<h3 id="drei-befunde-und-keiner-steht-im-solverergebnis">Drei Befunde, und keiner steht im Solverergebnis</h3>
+<p><strong>Erstens: bindend heißt nicht teuer.</strong> Fünf Bedingungen binden, aber „Lackierbudget Schicht 2“ tut es mit einem Schattenpreis von <strong>0,00 €</strong>. Sie berührt den Plan, ohne ihn zu verteuern — wer sie nachverhandelt, gewinnt nichts. Das ist derselbe Unterschied, den <code>Erklaerbarkeit.py</code> oben an einer einzelnen Zuweisung zeigt, hier im Dualwert eines LP.</p>
+<p><strong>Zweitens: Der Schattenpreis ist eine Momentaufnahme.</strong> Er gilt für die <strong>nächste</strong> Einheit. Ein Planer kauft aber keine Einheit, sondern eine Schicht. Für die Lackiererei verspricht die Hochrechnung <span class="math inline">4{,}00 \cdot 30 = 120</span> €; gemessen kommen <strong>60 €</strong>. Der Preis von 4,00 € gilt exakt bis <strong>+15 Stunden</strong>, danach begrenzt etwas anderes — <strong>die zweite Hälfte der Sonderschicht wäre bezahlt und wirkungslos.</strong></p>
+<p>Und die Ranglisten drehen sich dabei um: Nach Schattenpreis führt der Trägervertrag mit 18,00 € je Stück, nach tatsächlicher Wirkung die Montage-Sonderschicht mit 450 €. Der Schattenpreis sagt, was <strong>eine</strong> Einheit wert ist — nicht, wie viele Einheiten zu haben sind. Für die Frage „welchen Hebel ziehen wir?“ ist das der entscheidende Unterschied.</p>
+<p><strong>Drittens: Ein Wunsch kann unmöglich statt teuer sein.</strong> Der Vertrieb hätte gern 55 Rahmen statt 47,5. Das Modell antwortet nicht mit einem Preis, sondern mit <code>INFEASIBLE</code> — und drei Bedingungen blockieren den Wunsch <strong>gemeinsam</strong>: Fällt eine davon weg, ist er erfüllbar, keine allein ist „der“ Grund. Genau die Struktur, die <a href="#anhang-fehlerdiagnose">Anhang C</a> für den unlösbaren Fall beschreibt, hier auf einen Wunsch angewandt.</p>
+<p>Die Pointe steht am Ende: Mit +15 Stunden Lackierkapazität wird der Wunsch erfüllbar — und kostet dann <strong>nichts</strong>. Der Plan wählt diese Menge von sich aus, sobald der Engpass weg ist. Der Konflikt bestand nie zwischen Vertrieb und Produktion. Er bestand zwischen dem Vertrieb und der Lackiererei, und niemand wusste das.</p>
+<blockquote>
+<p><strong>🎯 Die drei Fragen, jetzt auf Modellebene</strong> Die Faustregel oben stellt sie für eine einzelne Zuweisung. Constraint Attribution stellt dieselben drei für den <strong>ganzen Plan</strong>: 1. <strong>Warum dieser Zielwert?</strong> — welche Bedingungen binden, und welche davon kosten Geld. 2. <strong>Warum nicht besser?</strong> — was eine realistische Lockerung wirklich bringt, gemessen statt hochgerechnet. 3. <strong>Was ist mit meinem Wunsch?</strong> — erfüllbar und zu welchem Preis, oder unmöglich und warum.</p>
+</blockquote>
+<h3 id="vom-zahlenwerk-zur-vorlage">Vom Zahlenwerk zur Vorlage</h3>
+<p>Alle drei Antworten stehen bis hierhin in Tabellen. Tabellen liest niemand in einer Abteilungsleiterrunde. Teil (4) des Programms baut aus <strong>denselben</strong> Zahlen einen Text — und das ist weniger trivial, als es aussieht:</p>
+<ul>
+<li><strong>Kein Satz enthält eine Zahl, die nicht vorher gerechnet wurde.</strong> Auch nicht die Rangfolge, auch nicht die Namen der blockierenden Bedingungen. Sobald sich das Modell ändert, ändert sich der Bericht mit — er kann nicht leise falsch werden.</li>
+<li><strong>Der sprechende Name jeder Bedingung ist die Voraussetzung dafür.</strong> <code>A_ub[7]</code> ergibt keinen Satz. Deshalb tragen die Bedingungen in beiden Programmen einen Namen, und deshalb ist das keine Kosmetik.</li>
+</ul>
+<blockquote>
+<p><strong>⚠️ Was ein solcher Bericht nicht leistet</strong> Er erklärt das <strong>Modell</strong>, nicht die <strong>Wirklichkeit</strong>. „Liefervertrag Träger kostet 18 € je Stück“ heißt: <em>in diesem Modell, mit diesen Deckungsbeiträgen</em>. Ist ein Deckungsbeitrag falsch geschätzt, ist der Bericht überzeugend <strong>und</strong> falsch — die gefährlichste Kombination. Ein generierter Text macht ein Modell nicht richtiger, nur schwerer anzuzweifeln. Deshalb gehört zu jedem solchen Bericht die Angabe, worauf er beruht.</p>
+</blockquote>
+<hr />
+<h2 id="sec:praxisfallen-architektur-einer-produktionsreifen-or-plattform">22.5 Architektur einer produktionsreifen OR-Plattform</h2>
 <figure>
 <img src="bilder_04/kap15_or_plattform.svg" alt="Abb. 22.2: Architektur einer produktionsreifen OR-Plattform" />
 <figcaption aria-hidden="true">Abb. 22.2: Architektur einer produktionsreifen OR-Plattform</figcaption>
@@ -25082,7 +26590,7 @@ von allen Fehlversuchen genau einen: den erfolgreichsten.
 <p><strong>⚠️ Der häufigste Projektfehler</strong> Nicht das Modell scheitert, sondern die <strong>Einführung</strong>. Ein technisch überlegener Plan, den die Disponentin nicht versteht und dem sie nicht traut, wird umgangen — sie plant weiter in ihrer Tabelle. Rechnen Sie mindestens so viel Zeit für Erklärbarkeit, Schulung und schrittweise Einführung ein wie für das Modell selbst.</p>
 </blockquote>
 <hr />
-<h2 id="sec:praxisfallen-or-kern">22.5 Der gemeinsame Unterbau: <code>or_kern.py</code></h2>
+<h2 id="sec:praxisfallen-or-kern">22.6 Der gemeinsame Unterbau: <code>or_kern.py</code></h2>
 <p>Die fünf Prinzipien oben beschreiben eine Plattform. Der Weg dorthin beginnt aber viel kleiner — mit der Frage, welche Teile eines Optimierungsprogramms <strong>immer dieselben</strong> sind.</p>
 <p>Sehen Sie sich die Programme dieses Buchs an: Jedes liest Daten ein, baut ein Modell, wertet einen Solverstatus aus und prüft das Ergebnis. Nur der mittlere Schritt ist wirklich problemspezifisch. Die anderen drei schreibt man in jedem Projekt neu — und macht dabei jedes Mal dieselben Fehler.</p>
 <h3 id="die-vier-schichten">Die vier Schichten</h3>
@@ -25199,510 +26707,510 @@ von allen Fehlversuchen genau einen: den erfolgreichsten.
 <p><strong>⚠️ Eine Besonderheit beim Import</strong></p>
 <p><code>or_kern.py</code> importiert von sich aus <strong>keine</strong> Solverbibliothek. Die Statusübersetzer laden ihre Bibliothek erst beim Aufruf. Das ist kein Stilmittel, sondern notwendig: <code>ortools</code> und <code>highspy</code> vertragen sich nicht im selben Prozess (<a href="#sec:oekosystem-ein-system-vier-programmieransaetze">Abschnitt 3.5</a>). Ein Modul, das beide importierte, wäre mit keinem von beiden benutzbar.</p>
 </blockquote>
-<div class="sourceCode" id="cb206"><pre class="sourceCode python"><code class="sourceCode python"><span id="cb206-1"><a href="#cb206-1" aria-hidden="true" tabindex="-1"></a><span class="co">#!/usr/bin/env python3</span></span>
-<span id="cb206-2"><a href="#cb206-2" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb206-3"><a href="#cb206-3" aria-hidden="true" tabindex="-1"></a><span class="co"># or_kern.py</span></span>
-<span id="cb206-4"><a href="#cb206-4" aria-hidden="true" tabindex="-1"></a><span class="co">&quot;&quot;&quot;</span></span>
-<span id="cb206-5"><a href="#cb206-5" aria-hidden="true" tabindex="-1"></a><span class="co">Kapitel Praxisfallen: Der gemeinsame Unterbau fuer produktionsreife OR-Modelle.</span></span>
-<span id="cb206-6"><a href="#cb206-6" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb206-7"><a href="#cb206-7" aria-hidden="true" tabindex="-1"></a><span class="co">Alle Beispiele dieses Buchs loesen dieselben vier Aufgaben immer wieder:</span></span>
-<span id="cb206-8"><a href="#cb206-8" aria-hidden="true" tabindex="-1"></a><span class="co">Daten einlesen und pruefen, ein Modell bauen, den Solverstatus auswerten, die</span></span>
-<span id="cb206-9"><a href="#cb206-9" aria-hidden="true" tabindex="-1"></a><span class="co">Loesung gegen die Wirklichkeit kontrollieren. Dieses Modul zieht diese vier</span></span>
-<span id="cb206-10"><a href="#cb206-10" aria-hidden="true" tabindex="-1"></a><span class="co">Aufgaben aus den Einzelprogrammen heraus.</span></span>
-<span id="cb206-11"><a href="#cb206-11" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb206-12"><a href="#cb206-12" aria-hidden="true" tabindex="-1"></a><span class="co">    Rohdaten (Excel/CSV)</span></span>
-<span id="cb206-13"><a href="#cb206-13" aria-hidden="true" tabindex="-1"></a><span class="co">        -&gt; Domaenenmodell (Pydantic, geprueft)</span></span>
-<span id="cb206-14"><a href="#cb206-14" aria-hidden="true" tabindex="-1"></a><span class="co">            -&gt; Modellbauer (solverabhaengig)</span></span>
-<span id="cb206-15"><a href="#cb206-15" aria-hidden="true" tabindex="-1"></a><span class="co">                -&gt; Loesung (DTO, solverunabhaengig)</span></span>
-<span id="cb206-16"><a href="#cb206-16" aria-hidden="true" tabindex="-1"></a><span class="co">                    -&gt; Abnahmepruefung</span></span>
-<span id="cb206-17"><a href="#cb206-17" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb206-18"><a href="#cb206-18" aria-hidden="true" tabindex="-1"></a><span class="co">Der Sinn dieser Trennung: Die Domaenenschicht weiss nichts von Solvern, die</span></span>
-<span id="cb206-19"><a href="#cb206-19" aria-hidden="true" tabindex="-1"></a><span class="co">Loesungsschicht weiss nichts vom Modellaufbau. Wer den Solver wechselt, tauscht</span></span>
-<span id="cb206-20"><a href="#cb206-20" aria-hidden="true" tabindex="-1"></a><span class="co">genau EINEN Baustein aus - der Rest bleibt.</span></span>
-<span id="cb206-21"><a href="#cb206-21" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb206-22"><a href="#cb206-22" aria-hidden="true" tabindex="-1"></a><span class="co">WICHTIG ZUM IMPORT: Dieses Modul importiert von sich aus KEINE Solver-</span></span>
-<span id="cb206-23"><a href="#cb206-23" aria-hidden="true" tabindex="-1"></a><span class="co">bibliothek. Der Grund steht im Kapitel Oekosystem: ortools und highspy vertragen sich</span></span>
-<span id="cb206-24"><a href="#cb206-24" aria-hidden="true" tabindex="-1"></a><span class="co">nicht im selben Prozess. Die Statusuebersetzer laden ihre Bibliothek erst,</span></span>
-<span id="cb206-25"><a href="#cb206-25" aria-hidden="true" tabindex="-1"></a><span class="co">wenn sie aufgerufen werden - so bleibt or_kern.py mit jedem Solver benutzbar.</span></span>
-<span id="cb206-26"><a href="#cb206-26" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb206-27"><a href="#cb206-27" aria-hidden="true" tabindex="-1"></a><span class="co">Benoetigt: pydantic (v2), numpy; optional pandas und openpyxl fuer Excel.</span></span>
-<span id="cb206-28"><a href="#cb206-28" aria-hidden="true" tabindex="-1"></a><span class="co">&quot;&quot;&quot;</span></span>
-<span id="cb206-29"><a href="#cb206-29" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb206-30"><a href="#cb206-30" aria-hidden="true" tabindex="-1"></a><span class="im">from</span> __future__ <span class="im">import</span> annotations</span>
-<span id="cb206-31"><a href="#cb206-31" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb206-32"><a href="#cb206-32" aria-hidden="true" tabindex="-1"></a><span class="im">from</span> enum <span class="im">import</span> Enum</span>
-<span id="cb206-33"><a href="#cb206-33" aria-hidden="true" tabindex="-1"></a><span class="im">from</span> typing <span class="im">import</span> Annotated, Any, Sequence</span>
-<span id="cb206-34"><a href="#cb206-34" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb206-35"><a href="#cb206-35" aria-hidden="true" tabindex="-1"></a><span class="im">import</span> numpy <span class="im">as</span> np</span>
-<span id="cb206-36"><a href="#cb206-36" aria-hidden="true" tabindex="-1"></a><span class="im">from</span> pydantic <span class="im">import</span> BaseModel, Field, model_validator</span>
-<span id="cb206-37"><a href="#cb206-37" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb206-38"><a href="#cb206-38" aria-hidden="true" tabindex="-1"></a><span class="co"># Wiederverwendbare Feldtypen. Sie tragen die Pruefung im Typ, nicht im Code -</span></span>
-<span id="cb206-39"><a href="#cb206-39" aria-hidden="true" tabindex="-1"></a><span class="co"># damit gilt sie ueberall, wo der Typ verwendet wird.</span></span>
-<span id="cb206-40"><a href="#cb206-40" aria-hidden="true" tabindex="-1"></a>PositiveZahl <span class="op">=</span> Annotated[<span class="bu">float</span>, Field(gt<span class="op">=</span><span class="dv">0</span>)]</span>
-<span id="cb206-41"><a href="#cb206-41" aria-hidden="true" tabindex="-1"></a>NichtNegativ <span class="op">=</span> Annotated[<span class="bu">float</span>, Field(ge<span class="op">=</span><span class="dv">0</span>)]</span>
-<span id="cb206-42"><a href="#cb206-42" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb206-43"><a href="#cb206-43" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb206-44"><a href="#cb206-44" aria-hidden="true" tabindex="-1"></a><span class="co"># --- 1. Solverstatus: eine Sprache fuer fuenf Bibliotheken -------------------</span></span>
-<span id="cb206-45"><a href="#cb206-45" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb206-46"><a href="#cb206-46" aria-hidden="true" tabindex="-1"></a><span class="kw">class</span> SolverStatus(<span class="bu">str</span>, Enum):</span>
-<span id="cb206-47"><a href="#cb206-47" aria-hidden="true" tabindex="-1"></a>    <span class="co">&quot;&quot;&quot;Was ein Solverlauf ergeben hat - unabhaengig davon, wer gerechnet hat.</span></span>
-<span id="cb206-48"><a href="#cb206-48" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb206-49"><a href="#cb206-49" aria-hidden="true" tabindex="-1"></a><span class="co">    Die fuenf im Buch verwendeten Bibliotheken benennen dasselbe Ergebnis</span></span>
-<span id="cb206-50"><a href="#cb206-50" aria-hidden="true" tabindex="-1"></a><span class="co">    unterschiedlich: &#39;Optimal&#39;, &#39;OPTIMAL&#39;, 2, &#39;optimal&#39;. Wer darauf direkt</span></span>
-<span id="cb206-51"><a href="#cb206-51" aria-hidden="true" tabindex="-1"></a><span class="co">    prueft, bindet seinen Auswertungscode an eine Bibliothek.</span></span>
-<span id="cb206-52"><a href="#cb206-52" aria-hidden="true" tabindex="-1"></a><span class="co">    &quot;&quot;&quot;</span></span>
-<span id="cb206-53"><a href="#cb206-53" aria-hidden="true" tabindex="-1"></a>    OPTIMAL <span class="op">=</span> <span class="st">&quot;optimal&quot;</span>              <span class="co"># beweisbar bestmoeglich</span></span>
-<span id="cb206-54"><a href="#cb206-54" aria-hidden="true" tabindex="-1"></a>    ZULAESSIG <span class="op">=</span> <span class="st">&quot;zulaessig&quot;</span>          <span class="co"># brauchbare Loesung, Beweis fehlt</span></span>
-<span id="cb206-55"><a href="#cb206-55" aria-hidden="true" tabindex="-1"></a>    UNZULAESSIG <span class="op">=</span> <span class="st">&quot;unzulaessig&quot;</span>      <span class="co"># es gibt keine Loesung (Aussage ueber das Modell)</span></span>
-<span id="cb206-56"><a href="#cb206-56" aria-hidden="true" tabindex="-1"></a>    UNBESCHRAENKT <span class="op">=</span> <span class="st">&quot;unbeschraenkt&quot;</span>  <span class="co"># Ziel waechst ins Unendliche</span></span>
-<span id="cb206-57"><a href="#cb206-57" aria-hidden="true" tabindex="-1"></a>    ZEITLIMIT <span class="op">=</span> <span class="st">&quot;zeitlimit&quot;</span>          <span class="co"># abgebrochen, nichts Brauchbares gefunden</span></span>
-<span id="cb206-58"><a href="#cb206-58" aria-hidden="true" tabindex="-1"></a>    FEHLERHAFT <span class="op">=</span> <span class="st">&quot;fehlerhaft&quot;</span>        <span class="co"># das Modell ist kein gueltiges Modell</span></span>
-<span id="cb206-59"><a href="#cb206-59" aria-hidden="true" tabindex="-1"></a>    UNBEKANNT <span class="op">=</span> <span class="st">&quot;unbekannt&quot;</span>          <span class="co"># alles Uebrige</span></span>
-<span id="cb206-60"><a href="#cb206-60" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb206-61"><a href="#cb206-61" aria-hidden="true" tabindex="-1"></a>    <span class="at">@property</span></span>
-<span id="cb206-62"><a href="#cb206-62" aria-hidden="true" tabindex="-1"></a>    <span class="kw">def</span> brauchbar(<span class="va">self</span>) <span class="op">-&gt;</span> <span class="bu">bool</span>:</span>
-<span id="cb206-63"><a href="#cb206-63" aria-hidden="true" tabindex="-1"></a>        <span class="co">&quot;&quot;&quot;Habe ich etwas in der Hand, das ich ausfuehren kann?&quot;&quot;&quot;</span></span>
-<span id="cb206-64"><a href="#cb206-64" aria-hidden="true" tabindex="-1"></a>        <span class="cf">return</span> <span class="va">self</span> <span class="kw">in</span> (SolverStatus.OPTIMAL, SolverStatus.ZULAESSIG)</span>
-<span id="cb206-65"><a href="#cb206-65" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb206-66"><a href="#cb206-66" aria-hidden="true" tabindex="-1"></a>    <span class="at">@property</span></span>
-<span id="cb206-67"><a href="#cb206-67" aria-hidden="true" tabindex="-1"></a>    <span class="kw">def</span> modellfehler(<span class="va">self</span>) <span class="op">-&gt;</span> <span class="bu">bool</span>:</span>
-<span id="cb206-68"><a href="#cb206-68" aria-hidden="true" tabindex="-1"></a>        <span class="co">&quot;&quot;&quot;Liegt die Ursache im Modell (und nicht in der Rechenzeit)?&quot;&quot;&quot;</span></span>
-<span id="cb206-69"><a href="#cb206-69" aria-hidden="true" tabindex="-1"></a>        <span class="cf">return</span> <span class="va">self</span> <span class="kw">in</span> (SolverStatus.UNZULAESSIG, SolverStatus.UNBESCHRAENKT,</span>
-<span id="cb206-70"><a href="#cb206-70" aria-hidden="true" tabindex="-1"></a>                        SolverStatus.FEHLERHAFT)</span>
-<span id="cb206-71"><a href="#cb206-71" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb206-72"><a href="#cb206-72" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb206-73"><a href="#cb206-73" aria-hidden="true" tabindex="-1"></a><span class="kw">def</span> status_von_pywraplp(rohstatus: <span class="bu">int</span>) <span class="op">-&gt;</span> SolverStatus:</span>
-<span id="cb206-74"><a href="#cb206-74" aria-hidden="true" tabindex="-1"></a>    <span class="co">&quot;&quot;&quot;OR-Tools linear_solver (GLOP, SCIP, CBC).&quot;&quot;&quot;</span></span>
-<span id="cb206-75"><a href="#cb206-75" aria-hidden="true" tabindex="-1"></a>    <span class="im">from</span> ortools.linear_solver <span class="im">import</span> pywraplp</span>
-<span id="cb206-76"><a href="#cb206-76" aria-hidden="true" tabindex="-1"></a>    zuordnung <span class="op">=</span> {</span>
-<span id="cb206-77"><a href="#cb206-77" aria-hidden="true" tabindex="-1"></a>        pywraplp.Solver.OPTIMAL: SolverStatus.OPTIMAL,</span>
-<span id="cb206-78"><a href="#cb206-78" aria-hidden="true" tabindex="-1"></a>        pywraplp.Solver.FEASIBLE: SolverStatus.ZULAESSIG,</span>
-<span id="cb206-79"><a href="#cb206-79" aria-hidden="true" tabindex="-1"></a>        pywraplp.Solver.INFEASIBLE: SolverStatus.UNZULAESSIG,</span>
-<span id="cb206-80"><a href="#cb206-80" aria-hidden="true" tabindex="-1"></a>        pywraplp.Solver.UNBOUNDED: SolverStatus.UNBESCHRAENKT,</span>
-<span id="cb206-81"><a href="#cb206-81" aria-hidden="true" tabindex="-1"></a>        pywraplp.Solver.ABNORMAL: SolverStatus.FEHLERHAFT,</span>
-<span id="cb206-82"><a href="#cb206-82" aria-hidden="true" tabindex="-1"></a>        pywraplp.Solver.NOT_SOLVED: SolverStatus.ZEITLIMIT,</span>
-<span id="cb206-83"><a href="#cb206-83" aria-hidden="true" tabindex="-1"></a>    }</span>
-<span id="cb206-84"><a href="#cb206-84" aria-hidden="true" tabindex="-1"></a>    <span class="cf">return</span> zuordnung.get(rohstatus, SolverStatus.UNBEKANNT)</span>
-<span id="cb206-85"><a href="#cb206-85" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb206-86"><a href="#cb206-86" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb206-87"><a href="#cb206-87" aria-hidden="true" tabindex="-1"></a><span class="kw">def</span> status_von_cpsat(rohstatus: <span class="bu">int</span>) <span class="op">-&gt;</span> SolverStatus:</span>
-<span id="cb206-88"><a href="#cb206-88" aria-hidden="true" tabindex="-1"></a>    <span class="co">&quot;&quot;&quot;OR-Tools CP-SAT (siehe Kapitel CP-SAT, alle fuenf Faelle).&quot;&quot;&quot;</span></span>
-<span id="cb206-89"><a href="#cb206-89" aria-hidden="true" tabindex="-1"></a>    <span class="im">from</span> ortools.sat.python <span class="im">import</span> cp_model</span>
-<span id="cb206-90"><a href="#cb206-90" aria-hidden="true" tabindex="-1"></a>    zuordnung <span class="op">=</span> {</span>
-<span id="cb206-91"><a href="#cb206-91" aria-hidden="true" tabindex="-1"></a>        cp_model.OPTIMAL: SolverStatus.OPTIMAL,</span>
-<span id="cb206-92"><a href="#cb206-92" aria-hidden="true" tabindex="-1"></a>        cp_model.FEASIBLE: SolverStatus.ZULAESSIG,</span>
-<span id="cb206-93"><a href="#cb206-93" aria-hidden="true" tabindex="-1"></a>        cp_model.INFEASIBLE: SolverStatus.UNZULAESSIG,</span>
-<span id="cb206-94"><a href="#cb206-94" aria-hidden="true" tabindex="-1"></a>        cp_model.MODEL_INVALID: SolverStatus.FEHLERHAFT,</span>
-<span id="cb206-95"><a href="#cb206-95" aria-hidden="true" tabindex="-1"></a>        cp_model.UNKNOWN: SolverStatus.ZEITLIMIT,</span>
-<span id="cb206-96"><a href="#cb206-96" aria-hidden="true" tabindex="-1"></a>    }</span>
-<span id="cb206-97"><a href="#cb206-97" aria-hidden="true" tabindex="-1"></a>    <span class="cf">return</span> zuordnung.get(rohstatus, SolverStatus.UNBEKANNT)</span>
-<span id="cb206-98"><a href="#cb206-98" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb206-99"><a href="#cb206-99" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb206-100"><a href="#cb206-100" aria-hidden="true" tabindex="-1"></a><span class="kw">def</span> status_von_highs(statustext: <span class="bu">str</span>) <span class="op">-&gt;</span> SolverStatus:</span>
-<span id="cb206-101"><a href="#cb206-101" aria-hidden="true" tabindex="-1"></a>    <span class="co">&quot;&quot;&quot;HiGHS ueber highspy - hier kommt der Status als Text.&quot;&quot;&quot;</span></span>
-<span id="cb206-102"><a href="#cb206-102" aria-hidden="true" tabindex="-1"></a>    zuordnung <span class="op">=</span> {</span>
-<span id="cb206-103"><a href="#cb206-103" aria-hidden="true" tabindex="-1"></a>        <span class="st">&quot;Optimal&quot;</span>: SolverStatus.OPTIMAL,</span>
-<span id="cb206-104"><a href="#cb206-104" aria-hidden="true" tabindex="-1"></a>        <span class="st">&quot;Time limit reached&quot;</span>: SolverStatus.ZULAESSIG,   <span class="co"># meist mit Loesung</span></span>
-<span id="cb206-105"><a href="#cb206-105" aria-hidden="true" tabindex="-1"></a>        <span class="st">&quot;Solution limit reached&quot;</span>: SolverStatus.ZULAESSIG,</span>
-<span id="cb206-106"><a href="#cb206-106" aria-hidden="true" tabindex="-1"></a>        <span class="st">&quot;Infeasible&quot;</span>: SolverStatus.UNZULAESSIG,</span>
-<span id="cb206-107"><a href="#cb206-107" aria-hidden="true" tabindex="-1"></a>        <span class="st">&quot;Unbounded&quot;</span>: SolverStatus.UNBESCHRAENKT,</span>
-<span id="cb206-108"><a href="#cb206-108" aria-hidden="true" tabindex="-1"></a>        <span class="st">&quot;Primal infeasible or unbounded&quot;</span>: SolverStatus.UNZULAESSIG,</span>
-<span id="cb206-109"><a href="#cb206-109" aria-hidden="true" tabindex="-1"></a>        <span class="st">&quot;Model error&quot;</span>: SolverStatus.FEHLERHAFT,</span>
-<span id="cb206-110"><a href="#cb206-110" aria-hidden="true" tabindex="-1"></a>    }</span>
-<span id="cb206-111"><a href="#cb206-111" aria-hidden="true" tabindex="-1"></a>    <span class="cf">return</span> zuordnung.get(statustext, SolverStatus.UNBEKANNT)</span>
-<span id="cb206-112"><a href="#cb206-112" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb206-113"><a href="#cb206-113" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb206-114"><a href="#cb206-114" aria-hidden="true" tabindex="-1"></a><span class="kw">def</span> status_von_scipy(ergebnis: Any) <span class="op">-&gt;</span> SolverStatus:</span>
-<span id="cb206-115"><a href="#cb206-115" aria-hidden="true" tabindex="-1"></a>    <span class="co">&quot;&quot;&quot;scipy.optimize.linprog und milp liefern ein Ergebnisobjekt mit .status.&quot;&quot;&quot;</span></span>
-<span id="cb206-116"><a href="#cb206-116" aria-hidden="true" tabindex="-1"></a>    zuordnung <span class="op">=</span> {</span>
-<span id="cb206-117"><a href="#cb206-117" aria-hidden="true" tabindex="-1"></a>        <span class="dv">0</span>: SolverStatus.OPTIMAL,</span>
-<span id="cb206-118"><a href="#cb206-118" aria-hidden="true" tabindex="-1"></a>        <span class="dv">1</span>: SolverStatus.ZEITLIMIT,        <span class="co"># Iterations-/Zeitgrenze</span></span>
-<span id="cb206-119"><a href="#cb206-119" aria-hidden="true" tabindex="-1"></a>        <span class="dv">2</span>: SolverStatus.UNZULAESSIG,</span>
-<span id="cb206-120"><a href="#cb206-120" aria-hidden="true" tabindex="-1"></a>        <span class="dv">3</span>: SolverStatus.UNBESCHRAENKT,</span>
-<span id="cb206-121"><a href="#cb206-121" aria-hidden="true" tabindex="-1"></a>        <span class="dv">4</span>: SolverStatus.FEHLERHAFT,       <span class="co"># numerische Schwierigkeiten</span></span>
-<span id="cb206-122"><a href="#cb206-122" aria-hidden="true" tabindex="-1"></a>    }</span>
-<span id="cb206-123"><a href="#cb206-123" aria-hidden="true" tabindex="-1"></a>    <span class="cf">return</span> zuordnung.get(<span class="bu">int</span>(ergebnis.status), SolverStatus.UNBEKANNT)</span>
-<span id="cb206-124"><a href="#cb206-124" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb206-125"><a href="#cb206-125" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb206-126"><a href="#cb206-126" aria-hidden="true" tabindex="-1"></a><span class="kw">def</span> status_von_cvxpy(statustext: <span class="bu">str</span>) <span class="op">-&gt;</span> SolverStatus:</span>
-<span id="cb206-127"><a href="#cb206-127" aria-hidden="true" tabindex="-1"></a>    <span class="co">&quot;&quot;&quot;CVXPY - Statuszeichenketten wie &#39;optimal&#39; oder &#39;infeasible&#39;.&quot;&quot;&quot;</span></span>
-<span id="cb206-128"><a href="#cb206-128" aria-hidden="true" tabindex="-1"></a>    zuordnung <span class="op">=</span> {</span>
-<span id="cb206-129"><a href="#cb206-129" aria-hidden="true" tabindex="-1"></a>        <span class="st">&quot;optimal&quot;</span>: SolverStatus.OPTIMAL,</span>
-<span id="cb206-130"><a href="#cb206-130" aria-hidden="true" tabindex="-1"></a>        <span class="st">&quot;optimal_inaccurate&quot;</span>: SolverStatus.ZULAESSIG,</span>
-<span id="cb206-131"><a href="#cb206-131" aria-hidden="true" tabindex="-1"></a>        <span class="st">&quot;infeasible&quot;</span>: SolverStatus.UNZULAESSIG,</span>
-<span id="cb206-132"><a href="#cb206-132" aria-hidden="true" tabindex="-1"></a>        <span class="st">&quot;infeasible_inaccurate&quot;</span>: SolverStatus.UNZULAESSIG,</span>
-<span id="cb206-133"><a href="#cb206-133" aria-hidden="true" tabindex="-1"></a>        <span class="st">&quot;unbounded&quot;</span>: SolverStatus.UNBESCHRAENKT,</span>
-<span id="cb206-134"><a href="#cb206-134" aria-hidden="true" tabindex="-1"></a>        <span class="st">&quot;unbounded_inaccurate&quot;</span>: SolverStatus.UNBESCHRAENKT,</span>
-<span id="cb206-135"><a href="#cb206-135" aria-hidden="true" tabindex="-1"></a>    }</span>
-<span id="cb206-136"><a href="#cb206-136" aria-hidden="true" tabindex="-1"></a>    <span class="cf">return</span> zuordnung.get(statustext, SolverStatus.UNBEKANNT)</span>
-<span id="cb206-137"><a href="#cb206-137" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb206-138"><a href="#cb206-138" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb206-139"><a href="#cb206-139" aria-hidden="true" tabindex="-1"></a><span class="co"># --- 2. Die Loesung als solverunabhaengiges Datenobjekt ----------------------</span></span>
-<span id="cb206-140"><a href="#cb206-140" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb206-141"><a href="#cb206-141" aria-hidden="true" tabindex="-1"></a><span class="kw">class</span> Loesung(BaseModel):</span>
-<span id="cb206-142"><a href="#cb206-142" aria-hidden="true" tabindex="-1"></a>    <span class="co">&quot;&quot;&quot;Das Ergebnis eines Solverlaufs, so wie es weiterverarbeitet wird.</span></span>
-<span id="cb206-143"><a href="#cb206-143" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb206-144"><a href="#cb206-144" aria-hidden="true" tabindex="-1"></a><span class="co">    Bewusst OHNE Referenz auf Solver, Modell oder Variablen: Ein Bericht, ein</span></span>
-<span id="cb206-145"><a href="#cb206-145" aria-hidden="true" tabindex="-1"></a><span class="co">    Test oder eine Weiterverarbeitung soll nicht wissen muessen, womit</span></span>
-<span id="cb206-146"><a href="#cb206-146" aria-hidden="true" tabindex="-1"></a><span class="co">    gerechnet wurde.</span></span>
-<span id="cb206-147"><a href="#cb206-147" aria-hidden="true" tabindex="-1"></a><span class="co">    &quot;&quot;&quot;</span></span>
-<span id="cb206-148"><a href="#cb206-148" aria-hidden="true" tabindex="-1"></a>    status: SolverStatus</span>
-<span id="cb206-149"><a href="#cb206-149" aria-hidden="true" tabindex="-1"></a>    werte: <span class="bu">dict</span>[<span class="bu">str</span>, <span class="bu">float</span>] <span class="op">=</span> Field(default_factory<span class="op">=</span><span class="bu">dict</span>)</span>
-<span id="cb206-150"><a href="#cb206-150" aria-hidden="true" tabindex="-1"></a>    zielwert: <span class="bu">float</span> <span class="op">|</span> <span class="va">None</span> <span class="op">=</span> <span class="va">None</span></span>
-<span id="cb206-151"><a href="#cb206-151" aria-hidden="true" tabindex="-1"></a>    schranke: <span class="bu">float</span> <span class="op">|</span> <span class="va">None</span> <span class="op">=</span> <span class="va">None</span></span>
-<span id="cb206-152"><a href="#cb206-152" aria-hidden="true" tabindex="-1"></a>    laufzeit: <span class="bu">float</span> <span class="op">|</span> <span class="va">None</span> <span class="op">=</span> <span class="va">None</span></span>
-<span id="cb206-153"><a href="#cb206-153" aria-hidden="true" tabindex="-1"></a>    <span class="co"># Schattenpreise je Nebenbedingung, sofern der Solver sie liefert</span></span>
-<span id="cb206-154"><a href="#cb206-154" aria-hidden="true" tabindex="-1"></a>    <span class="co"># (nur bei kontinuierlichen Problemen, siehe Kapitel LP). Auch das ist</span></span>
-<span id="cb206-155"><a href="#cb206-155" aria-hidden="true" tabindex="-1"></a>    <span class="co"># ein solverunabhaengiger Begriff und gehoert deshalb hierher.</span></span>
-<span id="cb206-156"><a href="#cb206-156" aria-hidden="true" tabindex="-1"></a>    schattenpreise: <span class="bu">dict</span>[<span class="bu">str</span>, <span class="bu">float</span>] <span class="op">=</span> Field(default_factory<span class="op">=</span><span class="bu">dict</span>)</span>
-<span id="cb206-157"><a href="#cb206-157" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb206-158"><a href="#cb206-158" aria-hidden="true" tabindex="-1"></a>    <span class="at">@property</span></span>
-<span id="cb206-159"><a href="#cb206-159" aria-hidden="true" tabindex="-1"></a>    <span class="kw">def</span> gap(<span class="va">self</span>) <span class="op">-&gt;</span> <span class="bu">float</span> <span class="op">|</span> <span class="va">None</span>:</span>
-<span id="cb206-160"><a href="#cb206-160" aria-hidden="true" tabindex="-1"></a>        <span class="co">&quot;&quot;&quot;Relativer Abstand zwischen gefundener Loesung und bewiesener Schranke.</span></span>
-<span id="cb206-161"><a href="#cb206-161" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb206-162"><a href="#cb206-162" aria-hidden="true" tabindex="-1"></a><span class="co">        Das ist die Zahl fuer den Bericht: keine Schaetzung, sondern eine</span></span>
-<span id="cb206-163"><a href="#cb206-163" aria-hidden="true" tabindex="-1"></a><span class="co">        Zusage - schlechter als das kann die Loesung nicht sein.</span></span>
-<span id="cb206-164"><a href="#cb206-164" aria-hidden="true" tabindex="-1"></a><span class="co">        &quot;&quot;&quot;</span></span>
-<span id="cb206-165"><a href="#cb206-165" aria-hidden="true" tabindex="-1"></a>        <span class="cf">if</span> <span class="va">self</span>.zielwert <span class="kw">is</span> <span class="va">None</span> <span class="kw">or</span> <span class="va">self</span>.schranke <span class="kw">is</span> <span class="va">None</span>:</span>
-<span id="cb206-166"><a href="#cb206-166" aria-hidden="true" tabindex="-1"></a>            <span class="cf">return</span> <span class="va">None</span></span>
-<span id="cb206-167"><a href="#cb206-167" aria-hidden="true" tabindex="-1"></a>        nenner <span class="op">=</span> <span class="bu">max</span>(<span class="bu">abs</span>(<span class="va">self</span>.zielwert), <span class="fl">1e-9</span>)</span>
-<span id="cb206-168"><a href="#cb206-168" aria-hidden="true" tabindex="-1"></a>        <span class="cf">return</span> <span class="bu">abs</span>(<span class="va">self</span>.zielwert <span class="op">-</span> <span class="va">self</span>.schranke) <span class="op">/</span> nenner</span>
-<span id="cb206-169"><a href="#cb206-169" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb206-170"><a href="#cb206-170" aria-hidden="true" tabindex="-1"></a>    <span class="kw">def</span> als_bericht(<span class="va">self</span>) <span class="op">-&gt;</span> <span class="bu">str</span>:</span>
-<span id="cb206-171"><a href="#cb206-171" aria-hidden="true" tabindex="-1"></a>        <span class="co">&quot;&quot;&quot;Eine Zeile fuers Betriebsprotokoll - siehe Betriebsueberwachung.py.&quot;&quot;&quot;</span></span>
-<span id="cb206-172"><a href="#cb206-172" aria-hidden="true" tabindex="-1"></a>        teile <span class="op">=</span> [<span class="ss">f&quot;Status: </span><span class="sc">{</span><span class="va">self</span><span class="sc">.</span>status<span class="sc">.</span>value<span class="sc">}</span><span class="ss">&quot;</span>]</span>
-<span id="cb206-173"><a href="#cb206-173" aria-hidden="true" tabindex="-1"></a>        <span class="cf">if</span> <span class="va">self</span>.zielwert <span class="kw">is</span> <span class="kw">not</span> <span class="va">None</span>:</span>
-<span id="cb206-174"><a href="#cb206-174" aria-hidden="true" tabindex="-1"></a>            teile.append(<span class="ss">f&quot;Zielwert: </span><span class="sc">{</span><span class="va">self</span><span class="sc">.</span>zielwert<span class="sc">:,.2f}</span><span class="ss">&quot;</span>)</span>
-<span id="cb206-175"><a href="#cb206-175" aria-hidden="true" tabindex="-1"></a>        <span class="cf">if</span> <span class="va">self</span>.gap <span class="kw">is</span> <span class="kw">not</span> <span class="va">None</span>:</span>
-<span id="cb206-176"><a href="#cb206-176" aria-hidden="true" tabindex="-1"></a>            teile.append(<span class="ss">f&quot;Gap: </span><span class="sc">{</span><span class="va">self</span><span class="sc">.</span>gap<span class="sc">:.2%}</span><span class="ss">&quot;</span>)</span>
-<span id="cb206-177"><a href="#cb206-177" aria-hidden="true" tabindex="-1"></a>        <span class="cf">if</span> <span class="va">self</span>.laufzeit <span class="kw">is</span> <span class="kw">not</span> <span class="va">None</span>:</span>
-<span id="cb206-178"><a href="#cb206-178" aria-hidden="true" tabindex="-1"></a>            teile.append(<span class="ss">f&quot;Zeit: </span><span class="sc">{</span><span class="va">self</span><span class="sc">.</span>laufzeit<span class="sc">:.2f}</span><span class="ss">s&quot;</span>)</span>
-<span id="cb206-179"><a href="#cb206-179" aria-hidden="true" tabindex="-1"></a>        <span class="cf">return</span> <span class="st">&quot; | &quot;</span>.join(teile)</span>
-<span id="cb206-180"><a href="#cb206-180" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb206-181"><a href="#cb206-181" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb206-182"><a href="#cb206-182" aria-hidden="true" tabindex="-1"></a><span class="co"># --- 3. Domaenenmodell: die Fakten, bevor ein Solver sie sieht ---------------</span></span>
-<span id="cb206-183"><a href="#cb206-183" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb206-184"><a href="#cb206-184" aria-hidden="true" tabindex="-1"></a><span class="kw">class</span> Produkt(BaseModel):</span>
-<span id="cb206-185"><a href="#cb206-185" aria-hidden="true" tabindex="-1"></a>    <span class="co">&quot;&quot;&quot;Ein Produkt mit Deckungsbeitrag und Ressourcenverbrauch.&quot;&quot;&quot;</span></span>
-<span id="cb206-186"><a href="#cb206-186" aria-hidden="true" tabindex="-1"></a>    name: <span class="bu">str</span> <span class="op">=</span> Field(min_length<span class="op">=</span><span class="dv">1</span>)</span>
-<span id="cb206-187"><a href="#cb206-187" aria-hidden="true" tabindex="-1"></a>    deckungsbeitrag: <span class="bu">float</span></span>
-<span id="cb206-188"><a href="#cb206-188" aria-hidden="true" tabindex="-1"></a>    verbrauch: <span class="bu">dict</span>[<span class="bu">str</span>, NichtNegativ]</span>
-<span id="cb206-189"><a href="#cb206-189" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb206-190"><a href="#cb206-190" aria-hidden="true" tabindex="-1"></a>    model_config <span class="op">=</span> {<span class="st">&quot;frozen&quot;</span>: <span class="va">True</span>}      <span class="co"># Stammdaten aendern sich nicht im Lauf</span></span>
-<span id="cb206-191"><a href="#cb206-191" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb206-192"><a href="#cb206-192" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb206-193"><a href="#cb206-193" aria-hidden="true" tabindex="-1"></a><span class="kw">class</span> Produktionsproblem(BaseModel):</span>
-<span id="cb206-194"><a href="#cb206-194" aria-hidden="true" tabindex="-1"></a>    <span class="co">&quot;&quot;&quot;Produktionsprogrammplanung - das Modell aus Kapitel Einfuehrung.</span></span>
-<span id="cb206-195"><a href="#cb206-195" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb206-196"><a href="#cb206-196" aria-hidden="true" tabindex="-1"></a><span class="co">    Die Pruefungen stehen hier und nicht im Solvercode. Damit gelten sie</span></span>
-<span id="cb206-197"><a href="#cb206-197" aria-hidden="true" tabindex="-1"></a><span class="co">    unabhaengig davon, mit welcher Bibliothek spaeter gerechnet wird - und sie</span></span>
-<span id="cb206-198"><a href="#cb206-198" aria-hidden="true" tabindex="-1"></a><span class="co">    schlagen beim EINLESEN zu, wo der Fehler noch zuzuordnen ist.</span></span>
-<span id="cb206-199"><a href="#cb206-199" aria-hidden="true" tabindex="-1"></a><span class="co">    &quot;&quot;&quot;</span></span>
-<span id="cb206-200"><a href="#cb206-200" aria-hidden="true" tabindex="-1"></a>    produkte: <span class="bu">list</span>[Produkt] <span class="op">=</span> Field(min_length<span class="op">=</span><span class="dv">1</span>)</span>
-<span id="cb206-201"><a href="#cb206-201" aria-hidden="true" tabindex="-1"></a>    kapazitaeten: <span class="bu">dict</span>[<span class="bu">str</span>, PositiveZahl]</span>
-<span id="cb206-202"><a href="#cb206-202" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb206-203"><a href="#cb206-203" aria-hidden="true" tabindex="-1"></a>    <span class="at">@model_validator</span>(mode<span class="op">=</span><span class="st">&quot;after&quot;</span>)</span>
-<span id="cb206-204"><a href="#cb206-204" aria-hidden="true" tabindex="-1"></a>    <span class="kw">def</span> pruefe_ressourcen(<span class="va">self</span>) <span class="op">-&gt;</span> <span class="st">&quot;Produktionsproblem&quot;</span>:</span>
-<span id="cb206-205"><a href="#cb206-205" aria-hidden="true" tabindex="-1"></a>        namen <span class="op">=</span> [p.name <span class="cf">for</span> p <span class="kw">in</span> <span class="va">self</span>.produkte]</span>
-<span id="cb206-206"><a href="#cb206-206" aria-hidden="true" tabindex="-1"></a>        <span class="cf">if</span> <span class="bu">len</span>(<span class="bu">set</span>(namen)) <span class="op">!=</span> <span class="bu">len</span>(namen):</span>
-<span id="cb206-207"><a href="#cb206-207" aria-hidden="true" tabindex="-1"></a>            doppelt <span class="op">=</span> <span class="bu">sorted</span>({n <span class="cf">for</span> n <span class="kw">in</span> namen <span class="cf">if</span> namen.count(n) <span class="op">&gt;</span> <span class="dv">1</span>})</span>
-<span id="cb206-208"><a href="#cb206-208" aria-hidden="true" tabindex="-1"></a>            <span class="cf">raise</span> <span class="pp">ValueError</span>(<span class="ss">f&quot;Produktnamen kommen mehrfach vor: </span><span class="sc">{</span>doppelt<span class="sc">}</span><span class="ss">&quot;</span>)</span>
-<span id="cb206-209"><a href="#cb206-209" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb206-210"><a href="#cb206-210" aria-hidden="true" tabindex="-1"></a>        <span class="cf">for</span> produkt <span class="kw">in</span> <span class="va">self</span>.produkte:</span>
-<span id="cb206-211"><a href="#cb206-211" aria-hidden="true" tabindex="-1"></a>            unbekannt <span class="op">=</span> <span class="bu">set</span>(produkt.verbrauch) <span class="op">-</span> <span class="bu">set</span>(<span class="va">self</span>.kapazitaeten)</span>
-<span id="cb206-212"><a href="#cb206-212" aria-hidden="true" tabindex="-1"></a>            <span class="cf">if</span> unbekannt:</span>
-<span id="cb206-213"><a href="#cb206-213" aria-hidden="true" tabindex="-1"></a>                <span class="cf">raise</span> <span class="pp">ValueError</span>(</span>
-<span id="cb206-214"><a href="#cb206-214" aria-hidden="true" tabindex="-1"></a>                    <span class="ss">f&quot;Produkt &#39;</span><span class="sc">{</span>produkt<span class="sc">.</span>name<span class="sc">}</span><span class="ss">&#39; verbraucht Ressourcen ohne &quot;</span></span>
-<span id="cb206-215"><a href="#cb206-215" aria-hidden="true" tabindex="-1"></a>                    <span class="ss">f&quot;Kapazitaetsangabe: </span><span class="sc">{</span><span class="bu">sorted</span>(unbekannt)<span class="sc">}</span><span class="ss">&quot;</span>)</span>
-<span id="cb206-216"><a href="#cb206-216" aria-hidden="true" tabindex="-1"></a>        <span class="cf">return</span> <span class="va">self</span></span>
-<span id="cb206-217"><a href="#cb206-217" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb206-218"><a href="#cb206-218" aria-hidden="true" tabindex="-1"></a>    <span class="at">@property</span></span>
-<span id="cb206-219"><a href="#cb206-219" aria-hidden="true" tabindex="-1"></a>    <span class="kw">def</span> ressourcen(<span class="va">self</span>) <span class="op">-&gt;</span> <span class="bu">list</span>[<span class="bu">str</span>]:</span>
-<span id="cb206-220"><a href="#cb206-220" aria-hidden="true" tabindex="-1"></a>        <span class="co">&quot;&quot;&quot;Feste Reihenfolge - siehe die Spaltenfalle in Kapitel Finanzdaten.&quot;&quot;&quot;</span></span>
-<span id="cb206-221"><a href="#cb206-221" aria-hidden="true" tabindex="-1"></a>        <span class="cf">return</span> <span class="bu">sorted</span>(<span class="va">self</span>.kapazitaeten)</span>
-<span id="cb206-222"><a href="#cb206-222" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb206-223"><a href="#cb206-223" aria-hidden="true" tabindex="-1"></a>    <span class="kw">def</span> verbrauchsmatrix(<span class="va">self</span>) <span class="op">-&gt;</span> np.ndarray:</span>
-<span id="cb206-224"><a href="#cb206-224" aria-hidden="true" tabindex="-1"></a>        <span class="co">&quot;&quot;&quot;Zeilen = Ressourcen, Spalten = Produkte (Matrixform, Kapitel Fundament).&quot;&quot;&quot;</span></span>
-<span id="cb206-225"><a href="#cb206-225" aria-hidden="true" tabindex="-1"></a>        <span class="cf">return</span> np.array([[p.verbrauch.get(r, <span class="fl">0.0</span>) <span class="cf">for</span> p <span class="kw">in</span> <span class="va">self</span>.produkte]</span>
-<span id="cb206-226"><a href="#cb206-226" aria-hidden="true" tabindex="-1"></a>                         <span class="cf">for</span> r <span class="kw">in</span> <span class="va">self</span>.ressourcen])</span>
-<span id="cb206-227"><a href="#cb206-227" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb206-228"><a href="#cb206-228" aria-hidden="true" tabindex="-1"></a>    <span class="kw">def</span> kapazitaetsvektor(<span class="va">self</span>) <span class="op">-&gt;</span> np.ndarray:</span>
-<span id="cb206-229"><a href="#cb206-229" aria-hidden="true" tabindex="-1"></a>        <span class="cf">return</span> np.array([<span class="va">self</span>.kapazitaeten[r] <span class="cf">for</span> r <span class="kw">in</span> <span class="va">self</span>.ressourcen])</span>
-<span id="cb206-230"><a href="#cb206-230" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb206-231"><a href="#cb206-231" aria-hidden="true" tabindex="-1"></a>    <span class="kw">def</span> deckungsbeitragsvektor(<span class="va">self</span>) <span class="op">-&gt;</span> np.ndarray:</span>
-<span id="cb206-232"><a href="#cb206-232" aria-hidden="true" tabindex="-1"></a>        <span class="cf">return</span> np.array([p.deckungsbeitrag <span class="cf">for</span> p <span class="kw">in</span> <span class="va">self</span>.produkte])</span>
-<span id="cb206-233"><a href="#cb206-233" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb206-234"><a href="#cb206-234" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb206-235"><a href="#cb206-235" aria-hidden="true" tabindex="-1"></a><span class="co"># --- 4. Abnahmepruefung: Loesung gegen Anforderung, ohne Solver --------------</span></span>
-<span id="cb206-236"><a href="#cb206-236" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb206-237"><a href="#cb206-237" aria-hidden="true" tabindex="-1"></a><span class="kw">def</span> pruefe_loesung(problem: Produktionsproblem, loesung: Loesung,</span>
-<span id="cb206-238"><a href="#cb206-238" aria-hidden="true" tabindex="-1"></a>                   ganzzahlig: Sequence[<span class="bu">str</span>] <span class="op">=</span> (),</span>
-<span id="cb206-239"><a href="#cb206-239" aria-hidden="true" tabindex="-1"></a>                   toleranz: <span class="bu">float</span> <span class="op">=</span> <span class="fl">1e-6</span>) <span class="op">-&gt;</span> <span class="bu">list</span>[<span class="bu">str</span>]:</span>
-<span id="cb206-240"><a href="#cb206-240" aria-hidden="true" tabindex="-1"></a>    <span class="co">&quot;&quot;&quot;Prueft eine Loesung gegen die Anforderungen - OHNE den Solver zu fragen.</span></span>
-<span id="cb206-241"><a href="#cb206-241" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb206-242"><a href="#cb206-242" aria-hidden="true" tabindex="-1"></a><span class="co">    Diese Funktion darf ausdruecklich KEIN Solverobjekt und keine</span></span>
-<span id="cb206-243"><a href="#cb206-243" aria-hidden="true" tabindex="-1"></a><span class="co">    Modellvariable benutzen. Eine Pruefung aus denselben Bausteinen wie das</span></span>
-<span id="cb206-244"><a href="#cb206-244" aria-hidden="true" tabindex="-1"></a><span class="co">    Modell prueft das Modell gegen sich selbst und findet nichts (siehe die</span></span>
-<span id="cb206-245"><a href="#cb206-245" aria-hidden="true" tabindex="-1"></a><span class="co">    Denkfehler in den Kapiteln Graphen und MILP).</span></span>
-<span id="cb206-246"><a href="#cb206-246" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb206-247"><a href="#cb206-247" aria-hidden="true" tabindex="-1"></a><span class="co">    Liefert eine Liste von Beanstandungen; leer heisst bestanden.</span></span>
-<span id="cb206-248"><a href="#cb206-248" aria-hidden="true" tabindex="-1"></a><span class="co">    &quot;&quot;&quot;</span></span>
-<span id="cb206-249"><a href="#cb206-249" aria-hidden="true" tabindex="-1"></a>    beanstandungen: <span class="bu">list</span>[<span class="bu">str</span>] <span class="op">=</span> []</span>
-<span id="cb206-250"><a href="#cb206-250" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb206-251"><a href="#cb206-251" aria-hidden="true" tabindex="-1"></a>    <span class="cf">if</span> <span class="kw">not</span> loesung.status.brauchbar:</span>
-<span id="cb206-252"><a href="#cb206-252" aria-hidden="true" tabindex="-1"></a>        <span class="cf">return</span> [<span class="ss">f&quot;Kein verwertbares Ergebnis (Status: </span><span class="sc">{</span>loesung<span class="sc">.</span>status<span class="sc">.</span>value<span class="sc">}</span><span class="ss">)&quot;</span>]</span>
-<span id="cb206-253"><a href="#cb206-253" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb206-254"><a href="#cb206-254" aria-hidden="true" tabindex="-1"></a>    fehlend <span class="op">=</span> [p.name <span class="cf">for</span> p <span class="kw">in</span> problem.produkte <span class="cf">if</span> p.name <span class="kw">not</span> <span class="kw">in</span> loesung.werte]</span>
-<span id="cb206-255"><a href="#cb206-255" aria-hidden="true" tabindex="-1"></a>    <span class="cf">if</span> fehlend:</span>
-<span id="cb206-256"><a href="#cb206-256" aria-hidden="true" tabindex="-1"></a>        <span class="cf">return</span> [<span class="ss">f&quot;Loesung enthaelt keine Werte fuer: </span><span class="sc">{</span>fehlend<span class="sc">}</span><span class="ss">&quot;</span>]</span>
-<span id="cb206-257"><a href="#cb206-257" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb206-258"><a href="#cb206-258" aria-hidden="true" tabindex="-1"></a>    mengen <span class="op">=</span> np.array([loesung.werte[p.name] <span class="cf">for</span> p <span class="kw">in</span> problem.produkte])</span>
-<span id="cb206-259"><a href="#cb206-259" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb206-260"><a href="#cb206-260" aria-hidden="true" tabindex="-1"></a>    <span class="cf">if</span> (mengen <span class="op">&lt;</span> <span class="op">-</span>toleranz).<span class="bu">any</span>():</span>
-<span id="cb206-261"><a href="#cb206-261" aria-hidden="true" tabindex="-1"></a>        negativ <span class="op">=</span> [p.name <span class="cf">for</span> p, m <span class="kw">in</span> <span class="bu">zip</span>(problem.produkte, mengen) <span class="cf">if</span> m <span class="op">&lt;</span> <span class="op">-</span>toleranz]</span>
-<span id="cb206-262"><a href="#cb206-262" aria-hidden="true" tabindex="-1"></a>        beanstandungen.append(<span class="ss">f&quot;negative Mengen bei: </span><span class="sc">{</span>negativ<span class="sc">}</span><span class="ss">&quot;</span>)</span>
-<span id="cb206-263"><a href="#cb206-263" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb206-264"><a href="#cb206-264" aria-hidden="true" tabindex="-1"></a>    verbrauch <span class="op">=</span> problem.verbrauchsmatrix() <span class="op">@</span> mengen</span>
-<span id="cb206-265"><a href="#cb206-265" aria-hidden="true" tabindex="-1"></a>    <span class="cf">for</span> ressource, ist, grenze <span class="kw">in</span> <span class="bu">zip</span>(problem.ressourcen, verbrauch,</span>
-<span id="cb206-266"><a href="#cb206-266" aria-hidden="true" tabindex="-1"></a>                                      problem.kapazitaetsvektor()):</span>
-<span id="cb206-267"><a href="#cb206-267" aria-hidden="true" tabindex="-1"></a>        <span class="cf">if</span> ist <span class="op">&gt;</span> grenze <span class="op">+</span> toleranz:</span>
-<span id="cb206-268"><a href="#cb206-268" aria-hidden="true" tabindex="-1"></a>            beanstandungen.append(</span>
-<span id="cb206-269"><a href="#cb206-269" aria-hidden="true" tabindex="-1"></a>                <span class="ss">f&quot;</span><span class="sc">{</span>ressource<span class="sc">}</span><span class="ss">: Verbrauch </span><span class="sc">{</span>ist<span class="sc">:,.3f}</span><span class="ss"> ueber Kapazitaet </span><span class="sc">{</span>grenze<span class="sc">:,.3f}</span><span class="ss">&quot;</span>)</span>
-<span id="cb206-270"><a href="#cb206-270" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb206-271"><a href="#cb206-271" aria-hidden="true" tabindex="-1"></a>    <span class="cf">for</span> name <span class="kw">in</span> ganzzahlig:</span>
-<span id="cb206-272"><a href="#cb206-272" aria-hidden="true" tabindex="-1"></a>        wert <span class="op">=</span> loesung.werte[name]</span>
-<span id="cb206-273"><a href="#cb206-273" aria-hidden="true" tabindex="-1"></a>        <span class="cf">if</span> <span class="bu">abs</span>(wert <span class="op">-</span> <span class="bu">round</span>(wert)) <span class="op">&gt;</span> toleranz:</span>
-<span id="cb206-274"><a href="#cb206-274" aria-hidden="true" tabindex="-1"></a>            beanstandungen.append(<span class="ss">f&quot;&#39;</span><span class="sc">{</span>name<span class="sc">}</span><span class="ss">&#39; = </span><span class="sc">{</span>wert<span class="sc">!r}</span><span class="ss"> ist nicht ganzzahlig&quot;</span>)</span>
-<span id="cb206-275"><a href="#cb206-275" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb206-276"><a href="#cb206-276" aria-hidden="true" tabindex="-1"></a>    <span class="cf">if</span> loesung.zielwert <span class="kw">is</span> <span class="kw">not</span> <span class="va">None</span>:</span>
-<span id="cb206-277"><a href="#cb206-277" aria-hidden="true" tabindex="-1"></a>        nachgerechnet <span class="op">=</span> <span class="bu">float</span>(problem.deckungsbeitragsvektor() <span class="op">@</span> mengen)</span>
-<span id="cb206-278"><a href="#cb206-278" aria-hidden="true" tabindex="-1"></a>        <span class="cf">if</span> <span class="bu">abs</span>(nachgerechnet <span class="op">-</span> loesung.zielwert) <span class="op">&gt;</span> toleranz <span class="op">*</span> <span class="bu">max</span>(<span class="fl">1.0</span>, <span class="bu">abs</span>(nachgerechnet)):</span>
-<span id="cb206-279"><a href="#cb206-279" aria-hidden="true" tabindex="-1"></a>            beanstandungen.append(</span>
-<span id="cb206-280"><a href="#cb206-280" aria-hidden="true" tabindex="-1"></a>                <span class="ss">f&quot;Zielwert </span><span class="sc">{</span>loesung<span class="sc">.</span>zielwert<span class="sc">:,.4f}</span><span class="ss"> passt nicht zu den Mengen &quot;</span></span>
-<span id="cb206-281"><a href="#cb206-281" aria-hidden="true" tabindex="-1"></a>                <span class="ss">f&quot;(nachgerechnet </span><span class="sc">{</span>nachgerechnet<span class="sc">:,.4f}</span><span class="ss">)&quot;</span>)</span>
-<span id="cb206-282"><a href="#cb206-282" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb206-283"><a href="#cb206-283" aria-hidden="true" tabindex="-1"></a>    <span class="cf">return</span> beanstandungen</span>
-<span id="cb206-284"><a href="#cb206-284" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb206-285"><a href="#cb206-285" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb206-286"><a href="#cb206-286" aria-hidden="true" tabindex="-1"></a><span class="co"># --- 5. Ein Modellbauer je Solver - austauschbar ----------------------------</span></span>
-<span id="cb206-287"><a href="#cb206-287" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb206-288"><a href="#cb206-288" aria-hidden="true" tabindex="-1"></a><span class="kw">def</span> loese_mit_glop(problem: Produktionsproblem) <span class="op">-&gt;</span> Loesung:</span>
-<span id="cb206-289"><a href="#cb206-289" aria-hidden="true" tabindex="-1"></a>    <span class="co">&quot;&quot;&quot;Modellbauer fuer OR-Tools GLOP (kontinuierlich).&quot;&quot;&quot;</span></span>
-<span id="cb206-290"><a href="#cb206-290" aria-hidden="true" tabindex="-1"></a>    <span class="im">import</span> time</span>
-<span id="cb206-291"><a href="#cb206-291" aria-hidden="true" tabindex="-1"></a>    <span class="im">from</span> ortools.linear_solver <span class="im">import</span> pywraplp</span>
-<span id="cb206-292"><a href="#cb206-292" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb206-293"><a href="#cb206-293" aria-hidden="true" tabindex="-1"></a>    solver <span class="op">=</span> pywraplp.Solver.CreateSolver(<span class="st">&quot;GLOP&quot;</span>)</span>
-<span id="cb206-294"><a href="#cb206-294" aria-hidden="true" tabindex="-1"></a>    menge <span class="op">=</span> {p.name: solver.NumVar(<span class="dv">0</span>, solver.infinity(), p.name)</span>
-<span id="cb206-295"><a href="#cb206-295" aria-hidden="true" tabindex="-1"></a>             <span class="cf">for</span> p <span class="kw">in</span> problem.produkte}</span>
-<span id="cb206-296"><a href="#cb206-296" aria-hidden="true" tabindex="-1"></a>    <span class="co"># Die Nebenbedingung wird gemerkt - ohne die Referenz gibt es spaeter</span></span>
-<span id="cb206-297"><a href="#cb206-297" aria-hidden="true" tabindex="-1"></a>    <span class="co"># keinen Schattenpreis (siehe Kapitel LP).</span></span>
-<span id="cb206-298"><a href="#cb206-298" aria-hidden="true" tabindex="-1"></a>    bedingung <span class="op">=</span> {}</span>
-<span id="cb206-299"><a href="#cb206-299" aria-hidden="true" tabindex="-1"></a>    <span class="cf">for</span> ressource <span class="kw">in</span> problem.ressourcen:</span>
-<span id="cb206-300"><a href="#cb206-300" aria-hidden="true" tabindex="-1"></a>        bedingung[ressource] <span class="op">=</span> solver.Add(</span>
-<span id="cb206-301"><a href="#cb206-301" aria-hidden="true" tabindex="-1"></a>            <span class="bu">sum</span>(menge[p.name] <span class="op">*</span> p.verbrauch.get(ressource, <span class="fl">0.0</span>)</span>
-<span id="cb206-302"><a href="#cb206-302" aria-hidden="true" tabindex="-1"></a>                <span class="cf">for</span> p <span class="kw">in</span> problem.produkte)</span>
-<span id="cb206-303"><a href="#cb206-303" aria-hidden="true" tabindex="-1"></a>            <span class="op">&lt;=</span> problem.kapazitaeten[ressource], name<span class="op">=</span>ressource)</span>
-<span id="cb206-304"><a href="#cb206-304" aria-hidden="true" tabindex="-1"></a>    solver.Maximize(<span class="bu">sum</span>(menge[p.name] <span class="op">*</span> p.deckungsbeitrag <span class="cf">for</span> p <span class="kw">in</span> problem.produkte))</span>
-<span id="cb206-305"><a href="#cb206-305" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb206-306"><a href="#cb206-306" aria-hidden="true" tabindex="-1"></a>    t0 <span class="op">=</span> time.perf_counter()</span>
-<span id="cb206-307"><a href="#cb206-307" aria-hidden="true" tabindex="-1"></a>    rohstatus <span class="op">=</span> solver.Solve()</span>
-<span id="cb206-308"><a href="#cb206-308" aria-hidden="true" tabindex="-1"></a>    laufzeit <span class="op">=</span> time.perf_counter() <span class="op">-</span> t0</span>
-<span id="cb206-309"><a href="#cb206-309" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb206-310"><a href="#cb206-310" aria-hidden="true" tabindex="-1"></a>    status <span class="op">=</span> status_von_pywraplp(rohstatus)</span>
-<span id="cb206-311"><a href="#cb206-311" aria-hidden="true" tabindex="-1"></a>    <span class="cf">if</span> <span class="kw">not</span> status.brauchbar:</span>
-<span id="cb206-312"><a href="#cb206-312" aria-hidden="true" tabindex="-1"></a>        <span class="cf">return</span> Loesung(status<span class="op">=</span>status, laufzeit<span class="op">=</span>laufzeit)</span>
-<span id="cb206-313"><a href="#cb206-313" aria-hidden="true" tabindex="-1"></a>    <span class="cf">return</span> Loesung(status<span class="op">=</span>status,</span>
-<span id="cb206-314"><a href="#cb206-314" aria-hidden="true" tabindex="-1"></a>                   werte<span class="op">=</span>{name: v.solution_value() <span class="cf">for</span> name, v <span class="kw">in</span> menge.items()},</span>
-<span id="cb206-315"><a href="#cb206-315" aria-hidden="true" tabindex="-1"></a>                   zielwert<span class="op">=</span>solver.Objective().Value(),</span>
-<span id="cb206-316"><a href="#cb206-316" aria-hidden="true" tabindex="-1"></a>                   schranke<span class="op">=</span>solver.Objective().Value(),</span>
-<span id="cb206-317"><a href="#cb206-317" aria-hidden="true" tabindex="-1"></a>                   schattenpreise<span class="op">=</span>{r: b.dual_value() <span class="cf">for</span> r, b <span class="kw">in</span> bedingung.items()},</span>
-<span id="cb206-318"><a href="#cb206-318" aria-hidden="true" tabindex="-1"></a>                   laufzeit<span class="op">=</span>laufzeit)</span>
-<span id="cb206-319"><a href="#cb206-319" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb206-320"><a href="#cb206-320" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb206-321"><a href="#cb206-321" aria-hidden="true" tabindex="-1"></a><span class="kw">def</span> loese_mit_scipy(problem: Produktionsproblem) <span class="op">-&gt;</span> Loesung:</span>
-<span id="cb206-322"><a href="#cb206-322" aria-hidden="true" tabindex="-1"></a>    <span class="co">&quot;&quot;&quot;Derselbe Fall mit scipy.optimize.linprog - anderer Solver, gleiche Loesung.</span></span>
-<span id="cb206-323"><a href="#cb206-323" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb206-324"><a href="#cb206-324" aria-hidden="true" tabindex="-1"></a><span class="co">    Beachten Sie, wie wenig hier steht: Die Daten kommen fertig geprueft aus</span></span>
-<span id="cb206-325"><a href="#cb206-325" aria-hidden="true" tabindex="-1"></a><span class="co">    dem Domaenenmodell, die Auswertung geht ans gemeinsame Loesung-Objekt.</span></span>
-<span id="cb206-326"><a href="#cb206-326" aria-hidden="true" tabindex="-1"></a><span class="co">    Genau das ist der Ertrag der Trennung.</span></span>
-<span id="cb206-327"><a href="#cb206-327" aria-hidden="true" tabindex="-1"></a><span class="co">    &quot;&quot;&quot;</span></span>
-<span id="cb206-328"><a href="#cb206-328" aria-hidden="true" tabindex="-1"></a>    <span class="im">import</span> time</span>
-<span id="cb206-329"><a href="#cb206-329" aria-hidden="true" tabindex="-1"></a>    <span class="im">from</span> scipy.optimize <span class="im">import</span> linprog</span>
-<span id="cb206-330"><a href="#cb206-330" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb206-331"><a href="#cb206-331" aria-hidden="true" tabindex="-1"></a>    t0 <span class="op">=</span> time.perf_counter()</span>
-<span id="cb206-332"><a href="#cb206-332" aria-hidden="true" tabindex="-1"></a>    ergebnis <span class="op">=</span> linprog(c<span class="op">=-</span>problem.deckungsbeitragsvektor(),      <span class="co"># linprog minimiert</span></span>
-<span id="cb206-333"><a href="#cb206-333" aria-hidden="true" tabindex="-1"></a>                       A_ub<span class="op">=</span>problem.verbrauchsmatrix(),</span>
-<span id="cb206-334"><a href="#cb206-334" aria-hidden="true" tabindex="-1"></a>                       b_ub<span class="op">=</span>problem.kapazitaetsvektor(),</span>
-<span id="cb206-335"><a href="#cb206-335" aria-hidden="true" tabindex="-1"></a>                       bounds<span class="op">=</span>(<span class="dv">0</span>, <span class="va">None</span>), method<span class="op">=</span><span class="st">&quot;highs&quot;</span>)</span>
-<span id="cb206-336"><a href="#cb206-336" aria-hidden="true" tabindex="-1"></a>    laufzeit <span class="op">=</span> time.perf_counter() <span class="op">-</span> t0</span>
-<span id="cb206-337"><a href="#cb206-337" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb206-338"><a href="#cb206-338" aria-hidden="true" tabindex="-1"></a>    status <span class="op">=</span> status_von_scipy(ergebnis)</span>
-<span id="cb206-339"><a href="#cb206-339" aria-hidden="true" tabindex="-1"></a>    <span class="cf">if</span> <span class="kw">not</span> status.brauchbar:</span>
-<span id="cb206-340"><a href="#cb206-340" aria-hidden="true" tabindex="-1"></a>        <span class="cf">return</span> Loesung(status<span class="op">=</span>status, laufzeit<span class="op">=</span>laufzeit)</span>
-<span id="cb206-341"><a href="#cb206-341" aria-hidden="true" tabindex="-1"></a>    <span class="co"># linprog rechnet minimierend mit negierten Kosten - die Dualwerte</span></span>
-<span id="cb206-342"><a href="#cb206-342" aria-hidden="true" tabindex="-1"></a>    <span class="co"># muessen entsprechend zurueckgedreht werden.</span></span>
-<span id="cb206-343"><a href="#cb206-343" aria-hidden="true" tabindex="-1"></a>    <span class="cf">return</span> Loesung(status<span class="op">=</span>status,</span>
-<span id="cb206-344"><a href="#cb206-344" aria-hidden="true" tabindex="-1"></a>                   werte<span class="op">=</span>{p.name: <span class="bu">float</span>(x)</span>
-<span id="cb206-345"><a href="#cb206-345" aria-hidden="true" tabindex="-1"></a>                          <span class="cf">for</span> p, x <span class="kw">in</span> <span class="bu">zip</span>(problem.produkte, ergebnis.x)},</span>
-<span id="cb206-346"><a href="#cb206-346" aria-hidden="true" tabindex="-1"></a>                   zielwert<span class="op">=</span><span class="bu">float</span>(<span class="op">-</span>ergebnis.fun),</span>
-<span id="cb206-347"><a href="#cb206-347" aria-hidden="true" tabindex="-1"></a>                   schranke<span class="op">=</span><span class="bu">float</span>(<span class="op">-</span>ergebnis.fun),</span>
-<span id="cb206-348"><a href="#cb206-348" aria-hidden="true" tabindex="-1"></a>                   schattenpreise<span class="op">=</span>{r: <span class="bu">float</span>(<span class="op">-</span>m) <span class="cf">for</span> r, m <span class="kw">in</span></span>
-<span id="cb206-349"><a href="#cb206-349" aria-hidden="true" tabindex="-1"></a>                                   <span class="bu">zip</span>(problem.ressourcen,</span>
-<span id="cb206-350"><a href="#cb206-350" aria-hidden="true" tabindex="-1"></a>                                       ergebnis.ineqlin.marginals)},</span>
-<span id="cb206-351"><a href="#cb206-351" aria-hidden="true" tabindex="-1"></a>                   laufzeit<span class="op">=</span>laufzeit)</span>
-<span id="cb206-352"><a href="#cb206-352" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb206-353"><a href="#cb206-353" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb206-354"><a href="#cb206-354" aria-hidden="true" tabindex="-1"></a><span class="co"># --- 6. Ein- und Ausgabe: Tabellen sind die Wirklichkeit ---------------------</span></span>
-<span id="cb206-355"><a href="#cb206-355" aria-hidden="true" tabindex="-1"></a><span class="co">#</span></span>
-<span id="cb206-356"><a href="#cb206-356" aria-hidden="true" tabindex="-1"></a><span class="co"># In den meisten Betrieben liegen die Zahlen in einer Tabellenkalkulation</span></span>
-<span id="cb206-357"><a href="#cb206-357" aria-hidden="true" tabindex="-1"></a><span class="co"># (Kapitel Einfuehrung). Diese beiden Funktionen sind die einzige Stelle im</span></span>
-<span id="cb206-358"><a href="#cb206-358" aria-hidden="true" tabindex="-1"></a><span class="co"># Modul, die das weiss - alles andere arbeitet mit dem Domaenenmodell.</span></span>
-<span id="cb206-359"><a href="#cb206-359" aria-hidden="true" tabindex="-1"></a><span class="co">#</span></span>
-<span id="cb206-360"><a href="#cb206-360" aria-hidden="true" tabindex="-1"></a><span class="co"># pandas und openpyxl werden bewusst erst hier importiert: Wer or_kern nur</span></span>
-<span id="cb206-361"><a href="#cb206-361" aria-hidden="true" tabindex="-1"></a><span class="co"># fuer Statusauswertung und Pruefung benutzt, soll sie nicht installieren</span></span>
-<span id="cb206-362"><a href="#cb206-362" aria-hidden="true" tabindex="-1"></a><span class="co"># muessen.</span></span>
-<span id="cb206-363"><a href="#cb206-363" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb206-364"><a href="#cb206-364" aria-hidden="true" tabindex="-1"></a>STAMMSPALTEN <span class="op">=</span> (<span class="st">&quot;Produkt&quot;</span>, <span class="st">&quot;Deckungsbeitrag&quot;</span>)</span>
-<span id="cb206-365"><a href="#cb206-365" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb206-366"><a href="#cb206-366" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb206-367"><a href="#cb206-367" aria-hidden="true" tabindex="-1"></a><span class="kw">def</span> lade_produktionsproblem(pfad: <span class="bu">str</span>, blatt_produkte: <span class="bu">str</span> <span class="op">=</span> <span class="st">&quot;Produkte&quot;</span>,</span>
-<span id="cb206-368"><a href="#cb206-368" aria-hidden="true" tabindex="-1"></a>                            blatt_kapazitaeten: <span class="bu">str</span> <span class="op">=</span> <span class="st">&quot;Kapazitaeten&quot;</span></span>
-<span id="cb206-369"><a href="#cb206-369" aria-hidden="true" tabindex="-1"></a>                            ) <span class="op">-&gt;</span> Produktionsproblem:</span>
-<span id="cb206-370"><a href="#cb206-370" aria-hidden="true" tabindex="-1"></a>    <span class="co">&quot;&quot;&quot;Liest eine Excel-Mappe und liefert ein geprueftes Domaenenmodell.</span></span>
-<span id="cb206-371"><a href="#cb206-371" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb206-372"><a href="#cb206-372" aria-hidden="true" tabindex="-1"></a><span class="co">    Alle Spalten ausser &#39;Produkt&#39; und &#39;Deckungsbeitrag&#39; gelten als</span></span>
-<span id="cb206-373"><a href="#cb206-373" aria-hidden="true" tabindex="-1"></a><span class="co">    Verbrauchsspalten - eine neue Ressource ist damit eine neue SPALTE in der</span></span>
-<span id="cb206-374"><a href="#cb206-374" aria-hidden="true" tabindex="-1"></a><span class="co">    Mappe und erfordert keine Codeaenderung.</span></span>
-<span id="cb206-375"><a href="#cb206-375" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb206-376"><a href="#cb206-376" aria-hidden="true" tabindex="-1"></a><span class="co">    Die eigentliche Pruefung passiert nicht hier, sondern im Konstruktor von</span></span>
-<span id="cb206-377"><a href="#cb206-377" aria-hidden="true" tabindex="-1"></a><span class="co">    Produktionsproblem. Diese Funktion uebersetzt nur Tabelle in Objekt; was</span></span>
-<span id="cb206-378"><a href="#cb206-378" aria-hidden="true" tabindex="-1"></a><span class="co">    ein gueltiges Problem ist, steht an genau einer Stelle.</span></span>
-<span id="cb206-379"><a href="#cb206-379" aria-hidden="true" tabindex="-1"></a><span class="co">    &quot;&quot;&quot;</span></span>
-<span id="cb206-380"><a href="#cb206-380" aria-hidden="true" tabindex="-1"></a>    <span class="im">import</span> pandas <span class="im">as</span> pd</span>
-<span id="cb206-381"><a href="#cb206-381" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb206-382"><a href="#cb206-382" aria-hidden="true" tabindex="-1"></a>    produkte_tabelle <span class="op">=</span> pd.read_excel(pfad, sheet_name<span class="op">=</span>blatt_produkte)</span>
-<span id="cb206-383"><a href="#cb206-383" aria-hidden="true" tabindex="-1"></a>    kapazitaeten_tabelle <span class="op">=</span> pd.read_excel(pfad, sheet_name<span class="op">=</span>blatt_kapazitaeten)</span>
-<span id="cb206-384"><a href="#cb206-384" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb206-385"><a href="#cb206-385" aria-hidden="true" tabindex="-1"></a>    fehlende <span class="op">=</span> [s <span class="cf">for</span> s <span class="kw">in</span> STAMMSPALTEN <span class="cf">if</span> s <span class="kw">not</span> <span class="kw">in</span> produkte_tabelle.columns]</span>
-<span id="cb206-386"><a href="#cb206-386" aria-hidden="true" tabindex="-1"></a>    <span class="cf">if</span> fehlende:</span>
-<span id="cb206-387"><a href="#cb206-387" aria-hidden="true" tabindex="-1"></a>        <span class="cf">raise</span> <span class="pp">ValueError</span>(<span class="ss">f&quot;Blatt &#39;</span><span class="sc">{</span>blatt_produkte<span class="sc">}</span><span class="ss">&#39;: Spalten fehlen: </span><span class="sc">{</span>fehlende<span class="sc">}</span><span class="ss">&quot;</span>)</span>
-<span id="cb206-388"><a href="#cb206-388" aria-hidden="true" tabindex="-1"></a>    <span class="cf">if</span> produkte_tabelle.isna().<span class="bu">any</span>().<span class="bu">any</span>():</span>
-<span id="cb206-389"><a href="#cb206-389" aria-hidden="true" tabindex="-1"></a>        zeilen <span class="op">=</span> produkte_tabelle[produkte_tabelle.isna().<span class="bu">any</span>(axis<span class="op">=</span><span class="dv">1</span>)].index.tolist()</span>
-<span id="cb206-390"><a href="#cb206-390" aria-hidden="true" tabindex="-1"></a>        <span class="cf">raise</span> <span class="pp">ValueError</span>(<span class="ss">f&quot;Blatt &#39;</span><span class="sc">{</span>blatt_produkte<span class="sc">}</span><span class="ss">&#39;: leere Zellen in Zeile(n) </span><span class="sc">{</span>zeilen<span class="sc">}</span><span class="ss">&quot;</span>)</span>
-<span id="cb206-391"><a href="#cb206-391" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb206-392"><a href="#cb206-392" aria-hidden="true" tabindex="-1"></a>    ressourcen <span class="op">=</span> [s <span class="cf">for</span> s <span class="kw">in</span> produkte_tabelle.columns <span class="cf">if</span> s <span class="kw">not</span> <span class="kw">in</span> STAMMSPALTEN]</span>
-<span id="cb206-393"><a href="#cb206-393" aria-hidden="true" tabindex="-1"></a>    produkte <span class="op">=</span> [</span>
-<span id="cb206-394"><a href="#cb206-394" aria-hidden="true" tabindex="-1"></a>        Produkt(name<span class="op">=</span><span class="bu">str</span>(zeile.Produkt),</span>
-<span id="cb206-395"><a href="#cb206-395" aria-hidden="true" tabindex="-1"></a>                deckungsbeitrag<span class="op">=</span><span class="bu">float</span>(zeile.Deckungsbeitrag),</span>
-<span id="cb206-396"><a href="#cb206-396" aria-hidden="true" tabindex="-1"></a>                verbrauch<span class="op">=</span>{r: <span class="bu">float</span>(<span class="bu">getattr</span>(zeile, r)) <span class="cf">for</span> r <span class="kw">in</span> ressourcen})</span>
-<span id="cb206-397"><a href="#cb206-397" aria-hidden="true" tabindex="-1"></a>        <span class="cf">for</span> zeile <span class="kw">in</span> produkte_tabelle.itertuples()</span>
-<span id="cb206-398"><a href="#cb206-398" aria-hidden="true" tabindex="-1"></a>    ]</span>
-<span id="cb206-399"><a href="#cb206-399" aria-hidden="true" tabindex="-1"></a>    kapazitaeten <span class="op">=</span> {<span class="bu">str</span>(z.Ressource): <span class="bu">float</span>(z.Verfuegbar)</span>
-<span id="cb206-400"><a href="#cb206-400" aria-hidden="true" tabindex="-1"></a>                    <span class="cf">for</span> z <span class="kw">in</span> kapazitaeten_tabelle.itertuples()}</span>
-<span id="cb206-401"><a href="#cb206-401" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb206-402"><a href="#cb206-402" aria-hidden="true" tabindex="-1"></a>    <span class="cf">return</span> Produktionsproblem(produkte<span class="op">=</span>produkte, kapazitaeten<span class="op">=</span>kapazitaeten)</span>
-<span id="cb206-403"><a href="#cb206-403" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb206-404"><a href="#cb206-404" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb206-405"><a href="#cb206-405" aria-hidden="true" tabindex="-1"></a><span class="kw">def</span> schreibe_ergebnis(pfad: <span class="bu">str</span>, problem: Produktionsproblem,</span>
-<span id="cb206-406"><a href="#cb206-406" aria-hidden="true" tabindex="-1"></a>                      loesung: Loesung) <span class="op">-&gt;</span> <span class="va">None</span>:</span>
-<span id="cb206-407"><a href="#cb206-407" aria-hidden="true" tabindex="-1"></a>    <span class="co">&quot;&quot;&quot;Schreibt Plan und Kennzahlen als zwei Blaetter zurueck nach Excel.</span></span>
-<span id="cb206-408"><a href="#cb206-408" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb206-409"><a href="#cb206-409" aria-hidden="true" tabindex="-1"></a><span class="co">    Die Fachabteilung bekommt das Ergebnis im Format, das sie ohnehin benutzt.</span></span>
-<span id="cb206-410"><a href="#cb206-410" aria-hidden="true" tabindex="-1"></a><span class="co">    Akzeptanz entscheidet ueber Projekterfolg (Kapitel Praxisfallen).</span></span>
-<span id="cb206-411"><a href="#cb206-411" aria-hidden="true" tabindex="-1"></a><span class="co">    &quot;&quot;&quot;</span></span>
-<span id="cb206-412"><a href="#cb206-412" aria-hidden="true" tabindex="-1"></a>    <span class="im">import</span> pandas <span class="im">as</span> pd</span>
-<span id="cb206-413"><a href="#cb206-413" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb206-414"><a href="#cb206-414" aria-hidden="true" tabindex="-1"></a>    <span class="cf">if</span> <span class="kw">not</span> loesung.status.brauchbar:</span>
-<span id="cb206-415"><a href="#cb206-415" aria-hidden="true" tabindex="-1"></a>        <span class="cf">raise</span> <span class="pp">ValueError</span>(<span class="ss">f&quot;Nichts zu schreiben - Status: </span><span class="sc">{</span>loesung<span class="sc">.</span>status<span class="sc">.</span>value<span class="sc">}</span><span class="ss">&quot;</span>)</span>
-<span id="cb206-416"><a href="#cb206-416" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb206-417"><a href="#cb206-417" aria-hidden="true" tabindex="-1"></a>    mengen <span class="op">=</span> np.array([loesung.werte[p.name] <span class="cf">for</span> p <span class="kw">in</span> problem.produkte])</span>
-<span id="cb206-418"><a href="#cb206-418" aria-hidden="true" tabindex="-1"></a>    plan <span class="op">=</span> pd.DataFrame({</span>
-<span id="cb206-419"><a href="#cb206-419" aria-hidden="true" tabindex="-1"></a>        <span class="st">&quot;Produkt&quot;</span>: [p.name <span class="cf">for</span> p <span class="kw">in</span> problem.produkte],</span>
-<span id="cb206-420"><a href="#cb206-420" aria-hidden="true" tabindex="-1"></a>        <span class="st">&quot;Menge&quot;</span>: mengen,</span>
-<span id="cb206-421"><a href="#cb206-421" aria-hidden="true" tabindex="-1"></a>        <span class="st">&quot;Deckungsbeitrag&quot;</span>: mengen <span class="op">*</span> problem.deckungsbeitragsvektor(),</span>
-<span id="cb206-422"><a href="#cb206-422" aria-hidden="true" tabindex="-1"></a>    })</span>
-<span id="cb206-423"><a href="#cb206-423" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb206-424"><a href="#cb206-424" aria-hidden="true" tabindex="-1"></a>    verbrauch <span class="op">=</span> problem.verbrauchsmatrix() <span class="op">@</span> mengen</span>
-<span id="cb206-425"><a href="#cb206-425" aria-hidden="true" tabindex="-1"></a>    kennzahlen: <span class="bu">dict</span>[<span class="bu">str</span>, <span class="bu">float</span> <span class="op">|</span> <span class="bu">str</span>] <span class="op">=</span> {</span>
-<span id="cb206-426"><a href="#cb206-426" aria-hidden="true" tabindex="-1"></a>        <span class="st">&quot;Status&quot;</span>: loesung.status.value,</span>
-<span id="cb206-427"><a href="#cb206-427" aria-hidden="true" tabindex="-1"></a>        <span class="st">&quot;Gesamtdeckungsbeitrag&quot;</span>: loesung.zielwert <span class="kw">or</span> <span class="fl">0.0</span>,</span>
-<span id="cb206-428"><a href="#cb206-428" aria-hidden="true" tabindex="-1"></a>    }</span>
-<span id="cb206-429"><a href="#cb206-429" aria-hidden="true" tabindex="-1"></a>    <span class="cf">for</span> ressource, ist, grenze <span class="kw">in</span> <span class="bu">zip</span>(problem.ressourcen, verbrauch,</span>
-<span id="cb206-430"><a href="#cb206-430" aria-hidden="true" tabindex="-1"></a>                                      problem.kapazitaetsvektor()):</span>
-<span id="cb206-431"><a href="#cb206-431" aria-hidden="true" tabindex="-1"></a>        kennzahlen[<span class="ss">f&quot;</span><span class="sc">{</span>ressource<span class="sc">}</span><span class="ss">: Verbrauch&quot;</span>] <span class="op">=</span> <span class="bu">float</span>(ist)</span>
-<span id="cb206-432"><a href="#cb206-432" aria-hidden="true" tabindex="-1"></a>        kennzahlen[<span class="ss">f&quot;</span><span class="sc">{</span>ressource<span class="sc">}</span><span class="ss">: Auslastung %&quot;</span>] <span class="op">=</span> <span class="bu">float</span>(<span class="fl">100.0</span> <span class="op">*</span> ist <span class="op">/</span> grenze)</span>
-<span id="cb206-433"><a href="#cb206-433" aria-hidden="true" tabindex="-1"></a>        <span class="cf">if</span> ressource <span class="kw">in</span> loesung.schattenpreise:</span>
-<span id="cb206-434"><a href="#cb206-434" aria-hidden="true" tabindex="-1"></a>            kennzahlen[<span class="ss">f&quot;</span><span class="sc">{</span>ressource<span class="sc">}</span><span class="ss">: Schattenpreis&quot;</span>] <span class="op">=</span> <span class="op">\</span></span>
-<span id="cb206-435"><a href="#cb206-435" aria-hidden="true" tabindex="-1"></a>                loesung.schattenpreise[ressource]</span>
-<span id="cb206-436"><a href="#cb206-436" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb206-437"><a href="#cb206-437" aria-hidden="true" tabindex="-1"></a>    kennzahlen_tabelle <span class="op">=</span> pd.DataFrame({</span>
-<span id="cb206-438"><a href="#cb206-438" aria-hidden="true" tabindex="-1"></a>        <span class="st">&quot;Kennzahl&quot;</span>: <span class="bu">list</span>(kennzahlen),</span>
-<span id="cb206-439"><a href="#cb206-439" aria-hidden="true" tabindex="-1"></a>        <span class="st">&quot;Wert&quot;</span>: [<span class="bu">round</span>(w, <span class="dv">2</span>) <span class="cf">if</span> <span class="bu">isinstance</span>(w, <span class="bu">float</span>) <span class="cf">else</span> w</span>
-<span id="cb206-440"><a href="#cb206-440" aria-hidden="true" tabindex="-1"></a>                 <span class="cf">for</span> w <span class="kw">in</span> kennzahlen.values()],</span>
-<span id="cb206-441"><a href="#cb206-441" aria-hidden="true" tabindex="-1"></a>    })</span>
-<span id="cb206-442"><a href="#cb206-442" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb206-443"><a href="#cb206-443" aria-hidden="true" tabindex="-1"></a>    <span class="cf">with</span> pd.ExcelWriter(pfad, engine<span class="op">=</span><span class="st">&quot;openpyxl&quot;</span>) <span class="im">as</span> mappe:</span>
-<span id="cb206-444"><a href="#cb206-444" aria-hidden="true" tabindex="-1"></a>        plan.<span class="bu">round</span>(<span class="dv">2</span>).to_excel(mappe, sheet_name<span class="op">=</span><span class="st">&quot;Plan&quot;</span>, index<span class="op">=</span><span class="va">False</span>)</span>
-<span id="cb206-445"><a href="#cb206-445" aria-hidden="true" tabindex="-1"></a>        kennzahlen_tabelle.to_excel(mappe, sheet_name<span class="op">=</span><span class="st">&quot;Kennzahlen&quot;</span>, index<span class="op">=</span><span class="va">False</span>)</span>
-<span id="cb206-446"><a href="#cb206-446" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb206-447"><a href="#cb206-447" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb206-448"><a href="#cb206-448" aria-hidden="true" tabindex="-1"></a><span class="cf">if</span> <span class="va">__name__</span> <span class="op">==</span> <span class="st">&quot;__main__&quot;</span>:</span>
-<span id="cb206-449"><a href="#cb206-449" aria-hidden="true" tabindex="-1"></a>    <span class="co"># Die Schreinerei aus Kapitel Einfuehrung - jetzt als Domaenenmodell.</span></span>
-<span id="cb206-450"><a href="#cb206-450" aria-hidden="true" tabindex="-1"></a>    schreinerei <span class="op">=</span> Produktionsproblem(</span>
-<span id="cb206-451"><a href="#cb206-451" aria-hidden="true" tabindex="-1"></a>        produkte<span class="op">=</span>[</span>
-<span id="cb206-452"><a href="#cb206-452" aria-hidden="true" tabindex="-1"></a>            Produkt(name<span class="op">=</span><span class="st">&quot;Tisch&quot;</span>, deckungsbeitrag<span class="op">=</span><span class="fl">240.0</span>,</span>
-<span id="cb206-453"><a href="#cb206-453" aria-hidden="true" tabindex="-1"></a>                    verbrauch<span class="op">=</span>{<span class="st">&quot;Montagestunden&quot;</span>: <span class="fl">3.0</span>, <span class="st">&quot;Plattenmaterial&quot;</span>: <span class="fl">6.0</span>}),</span>
-<span id="cb206-454"><a href="#cb206-454" aria-hidden="true" tabindex="-1"></a>            Produkt(name<span class="op">=</span><span class="st">&quot;Stuhl&quot;</span>, deckungsbeitrag<span class="op">=</span><span class="fl">60.0</span>,</span>
-<span id="cb206-455"><a href="#cb206-455" aria-hidden="true" tabindex="-1"></a>                    verbrauch<span class="op">=</span>{<span class="st">&quot;Montagestunden&quot;</span>: <span class="fl">1.0</span>, <span class="st">&quot;Plattenmaterial&quot;</span>: <span class="fl">1.0</span>}),</span>
-<span id="cb206-456"><a href="#cb206-456" aria-hidden="true" tabindex="-1"></a>        ],</span>
-<span id="cb206-457"><a href="#cb206-457" aria-hidden="true" tabindex="-1"></a>        kapazitaeten<span class="op">=</span>{<span class="st">&quot;Montagestunden&quot;</span>: <span class="fl">150.0</span>, <span class="st">&quot;Plattenmaterial&quot;</span>: <span class="fl">240.0</span>},</span>
-<span id="cb206-458"><a href="#cb206-458" aria-hidden="true" tabindex="-1"></a>    )</span>
-<span id="cb206-459"><a href="#cb206-459" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb206-460"><a href="#cb206-460" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;=&quot;</span> <span class="op">*</span> <span class="dv">78</span>)</span>
-<span id="cb206-461"><a href="#cb206-461" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;  DERSELBE FALL, ZWEI SOLVER, EIN AUSWERTUNGSCODE&quot;</span>)</span>
-<span id="cb206-462"><a href="#cb206-462" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;=&quot;</span> <span class="op">*</span> <span class="dv">78</span>)</span>
-<span id="cb206-463"><a href="#cb206-463" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb206-464"><a href="#cb206-464" aria-hidden="true" tabindex="-1"></a>    <span class="cf">for</span> name, bauer <span class="kw">in</span> [(<span class="st">&quot;OR-Tools GLOP&quot;</span>, loese_mit_glop),</span>
-<span id="cb206-465"><a href="#cb206-465" aria-hidden="true" tabindex="-1"></a>                        (<span class="st">&quot;scipy / HiGHS&quot;</span>, loese_mit_scipy)]:</span>
-<span id="cb206-466"><a href="#cb206-466" aria-hidden="true" tabindex="-1"></a>        loesung <span class="op">=</span> bauer(schreinerei)</span>
-<span id="cb206-467"><a href="#cb206-467" aria-hidden="true" tabindex="-1"></a>        beanstandungen <span class="op">=</span> pruefe_loesung(schreinerei, loesung)</span>
-<span id="cb206-468"><a href="#cb206-468" aria-hidden="true" tabindex="-1"></a>        <span class="bu">print</span>(<span class="ss">f&quot;</span><span class="ch">\n</span><span class="sc">{</span>name<span class="sc">}</span><span class="ss">&quot;</span>)</span>
-<span id="cb206-469"><a href="#cb206-469" aria-hidden="true" tabindex="-1"></a>        <span class="bu">print</span>(<span class="ss">f&quot;  </span><span class="sc">{</span>loesung<span class="sc">.</span>als_bericht()<span class="sc">}</span><span class="ss">&quot;</span>)</span>
-<span id="cb206-470"><a href="#cb206-470" aria-hidden="true" tabindex="-1"></a>        <span class="cf">for</span> produkt, menge <span class="kw">in</span> loesung.werte.items():</span>
-<span id="cb206-471"><a href="#cb206-471" aria-hidden="true" tabindex="-1"></a>            <span class="bu">print</span>(<span class="ss">f&quot;    </span><span class="sc">{</span>produkt<span class="sc">:&lt;10}</span><span class="ss"> </span><span class="sc">{</span>menge<span class="sc">:8.2f}</span><span class="ss">&quot;</span>)</span>
-<span id="cb206-472"><a href="#cb206-472" aria-hidden="true" tabindex="-1"></a>        <span class="bu">print</span>(<span class="ss">f&quot;  Abnahmepruefung: &quot;</span></span>
-<span id="cb206-473"><a href="#cb206-473" aria-hidden="true" tabindex="-1"></a>              <span class="ss">f&quot;</span><span class="sc">{</span><span class="st">&#39;bestanden&#39;</span> <span class="cf">if</span> <span class="kw">not</span> beanstandungen <span class="cf">else</span> beanstandungen<span class="sc">}</span><span class="ss">&quot;</span>)</span>
-<span id="cb206-474"><a href="#cb206-474" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb206-475"><a href="#cb206-475" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;</span><span class="ch">\n</span><span class="st">&quot;</span> <span class="op">+</span> <span class="st">&quot;=&quot;</span> <span class="op">*</span> <span class="dv">78</span>)</span>
-<span id="cb206-476"><a href="#cb206-476" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;  WAS DIE PRUEFUNGEN ABFANGEN&quot;</span>)</span>
-<span id="cb206-477"><a href="#cb206-477" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;=&quot;</span> <span class="op">*</span> <span class="dv">78</span>)</span>
-<span id="cb206-478"><a href="#cb206-478" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb206-479"><a href="#cb206-479" aria-hidden="true" tabindex="-1"></a>    faelle <span class="op">=</span> [</span>
-<span id="cb206-480"><a href="#cb206-480" aria-hidden="true" tabindex="-1"></a>        (<span class="st">&quot;Kapazitaet 0&quot;</span>, <span class="bu">dict</span>(</span>
-<span id="cb206-481"><a href="#cb206-481" aria-hidden="true" tabindex="-1"></a>            produkte<span class="op">=</span>schreinerei.produkte,</span>
-<span id="cb206-482"><a href="#cb206-482" aria-hidden="true" tabindex="-1"></a>            kapazitaeten<span class="op">=</span>{<span class="st">&quot;Montagestunden&quot;</span>: <span class="fl">0.0</span>, <span class="st">&quot;Plattenmaterial&quot;</span>: <span class="fl">240.0</span>})),</span>
-<span id="cb206-483"><a href="#cb206-483" aria-hidden="true" tabindex="-1"></a>        (<span class="st">&quot;Ressource ohne Kapazitaet&quot;</span>, <span class="bu">dict</span>(</span>
-<span id="cb206-484"><a href="#cb206-484" aria-hidden="true" tabindex="-1"></a>            produkte<span class="op">=</span>[Produkt(name<span class="op">=</span><span class="st">&quot;Regal&quot;</span>, deckungsbeitrag<span class="op">=</span><span class="fl">130.0</span>,</span>
-<span id="cb206-485"><a href="#cb206-485" aria-hidden="true" tabindex="-1"></a>                              verbrauch<span class="op">=</span>{<span class="st">&quot;Lackieren&quot;</span>: <span class="fl">2.0</span>})],</span>
-<span id="cb206-486"><a href="#cb206-486" aria-hidden="true" tabindex="-1"></a>            kapazitaeten<span class="op">=</span>{<span class="st">&quot;Montagestunden&quot;</span>: <span class="fl">150.0</span>})),</span>
-<span id="cb206-487"><a href="#cb206-487" aria-hidden="true" tabindex="-1"></a>        (<span class="st">&quot;doppelter Produktname&quot;</span>, <span class="bu">dict</span>(</span>
-<span id="cb206-488"><a href="#cb206-488" aria-hidden="true" tabindex="-1"></a>            produkte<span class="op">=</span>[schreinerei.produkte[<span class="dv">0</span>], schreinerei.produkte[<span class="dv">0</span>]],</span>
-<span id="cb206-489"><a href="#cb206-489" aria-hidden="true" tabindex="-1"></a>            kapazitaeten<span class="op">=</span>schreinerei.kapazitaeten)),</span>
-<span id="cb206-490"><a href="#cb206-490" aria-hidden="true" tabindex="-1"></a>    ]</span>
-<span id="cb206-491"><a href="#cb206-491" aria-hidden="true" tabindex="-1"></a>    <span class="cf">for</span> beschreibung, daten <span class="kw">in</span> faelle:</span>
-<span id="cb206-492"><a href="#cb206-492" aria-hidden="true" tabindex="-1"></a>        <span class="cf">try</span>:</span>
-<span id="cb206-493"><a href="#cb206-493" aria-hidden="true" tabindex="-1"></a>            Produktionsproblem(<span class="op">**</span>daten)</span>
-<span id="cb206-494"><a href="#cb206-494" aria-hidden="true" tabindex="-1"></a>            <span class="bu">print</span>(<span class="ss">f&quot;  </span><span class="sc">{</span>beschreibung<span class="sc">:&lt;28}</span><span class="ss"> NICHT erkannt (!)&quot;</span>)</span>
-<span id="cb206-495"><a href="#cb206-495" aria-hidden="true" tabindex="-1"></a>        <span class="cf">except</span> <span class="pp">Exception</span> <span class="im">as</span> fehler:</span>
-<span id="cb206-496"><a href="#cb206-496" aria-hidden="true" tabindex="-1"></a>            meldung <span class="op">=</span> <span class="bu">str</span>(fehler).splitlines()</span>
-<span id="cb206-497"><a href="#cb206-497" aria-hidden="true" tabindex="-1"></a>            kern <span class="op">=</span> <span class="bu">next</span>((z.strip() <span class="cf">for</span> z <span class="kw">in</span> meldung</span>
-<span id="cb206-498"><a href="#cb206-498" aria-hidden="true" tabindex="-1"></a>                         <span class="cf">if</span> <span class="st">&quot;Value error&quot;</span> <span class="kw">in</span> z <span class="kw">or</span> <span class="st">&quot;greater than&quot;</span> <span class="kw">in</span> z), meldung[<span class="op">-</span><span class="dv">1</span>])</span>
-<span id="cb206-499"><a href="#cb206-499" aria-hidden="true" tabindex="-1"></a>            <span class="bu">print</span>(<span class="ss">f&quot;  </span><span class="sc">{</span>beschreibung<span class="sc">:&lt;28}</span><span class="ss"> abgefangen: </span><span class="sc">{</span>kern[:<span class="dv">44</span>]<span class="sc">}</span><span class="ss">&quot;</span>)</span>
-<span id="cb206-500"><a href="#cb206-500" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb206-501"><a href="#cb206-501" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;</span><span class="ch">\n</span><span class="st">Alle drei scheitern beim EINLESEN - nicht erst beim Loesen und&quot;</span>)</span>
-<span id="cb206-502"><a href="#cb206-502" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;schon gar nicht erst im Bericht. Das ist der ganze Zweck der&quot;</span>)</span>
-<span id="cb206-503"><a href="#cb206-503" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;Domaenenschicht.&quot;</span>)</span>
-<span id="cb206-504"><a href="#cb206-504" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;=&quot;</span> <span class="op">*</span> <span class="dv">78</span>)</span></code></pre></div>
+<div class="sourceCode" id="cb210"><pre class="sourceCode python"><code class="sourceCode python"><span id="cb210-1"><a href="#cb210-1" aria-hidden="true" tabindex="-1"></a><span class="co">#!/usr/bin/env python3</span></span>
+<span id="cb210-2"><a href="#cb210-2" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb210-3"><a href="#cb210-3" aria-hidden="true" tabindex="-1"></a><span class="co"># or_kern.py</span></span>
+<span id="cb210-4"><a href="#cb210-4" aria-hidden="true" tabindex="-1"></a><span class="co">&quot;&quot;&quot;</span></span>
+<span id="cb210-5"><a href="#cb210-5" aria-hidden="true" tabindex="-1"></a><span class="co">Kapitel Praxisfallen: Der gemeinsame Unterbau fuer produktionsreife OR-Modelle.</span></span>
+<span id="cb210-6"><a href="#cb210-6" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb210-7"><a href="#cb210-7" aria-hidden="true" tabindex="-1"></a><span class="co">Alle Beispiele dieses Buchs loesen dieselben vier Aufgaben immer wieder:</span></span>
+<span id="cb210-8"><a href="#cb210-8" aria-hidden="true" tabindex="-1"></a><span class="co">Daten einlesen und pruefen, ein Modell bauen, den Solverstatus auswerten, die</span></span>
+<span id="cb210-9"><a href="#cb210-9" aria-hidden="true" tabindex="-1"></a><span class="co">Loesung gegen die Wirklichkeit kontrollieren. Dieses Modul zieht diese vier</span></span>
+<span id="cb210-10"><a href="#cb210-10" aria-hidden="true" tabindex="-1"></a><span class="co">Aufgaben aus den Einzelprogrammen heraus.</span></span>
+<span id="cb210-11"><a href="#cb210-11" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb210-12"><a href="#cb210-12" aria-hidden="true" tabindex="-1"></a><span class="co">    Rohdaten (Excel/CSV)</span></span>
+<span id="cb210-13"><a href="#cb210-13" aria-hidden="true" tabindex="-1"></a><span class="co">        -&gt; Domaenenmodell (Pydantic, geprueft)</span></span>
+<span id="cb210-14"><a href="#cb210-14" aria-hidden="true" tabindex="-1"></a><span class="co">            -&gt; Modellbauer (solverabhaengig)</span></span>
+<span id="cb210-15"><a href="#cb210-15" aria-hidden="true" tabindex="-1"></a><span class="co">                -&gt; Loesung (DTO, solverunabhaengig)</span></span>
+<span id="cb210-16"><a href="#cb210-16" aria-hidden="true" tabindex="-1"></a><span class="co">                    -&gt; Abnahmepruefung</span></span>
+<span id="cb210-17"><a href="#cb210-17" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb210-18"><a href="#cb210-18" aria-hidden="true" tabindex="-1"></a><span class="co">Der Sinn dieser Trennung: Die Domaenenschicht weiss nichts von Solvern, die</span></span>
+<span id="cb210-19"><a href="#cb210-19" aria-hidden="true" tabindex="-1"></a><span class="co">Loesungsschicht weiss nichts vom Modellaufbau. Wer den Solver wechselt, tauscht</span></span>
+<span id="cb210-20"><a href="#cb210-20" aria-hidden="true" tabindex="-1"></a><span class="co">genau EINEN Baustein aus - der Rest bleibt.</span></span>
+<span id="cb210-21"><a href="#cb210-21" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb210-22"><a href="#cb210-22" aria-hidden="true" tabindex="-1"></a><span class="co">WICHTIG ZUM IMPORT: Dieses Modul importiert von sich aus KEINE Solver-</span></span>
+<span id="cb210-23"><a href="#cb210-23" aria-hidden="true" tabindex="-1"></a><span class="co">bibliothek. Der Grund steht im Kapitel Oekosystem: ortools und highspy vertragen sich</span></span>
+<span id="cb210-24"><a href="#cb210-24" aria-hidden="true" tabindex="-1"></a><span class="co">nicht im selben Prozess. Die Statusuebersetzer laden ihre Bibliothek erst,</span></span>
+<span id="cb210-25"><a href="#cb210-25" aria-hidden="true" tabindex="-1"></a><span class="co">wenn sie aufgerufen werden - so bleibt or_kern.py mit jedem Solver benutzbar.</span></span>
+<span id="cb210-26"><a href="#cb210-26" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb210-27"><a href="#cb210-27" aria-hidden="true" tabindex="-1"></a><span class="co">Benoetigt: pydantic (v2), numpy; optional pandas und openpyxl fuer Excel.</span></span>
+<span id="cb210-28"><a href="#cb210-28" aria-hidden="true" tabindex="-1"></a><span class="co">&quot;&quot;&quot;</span></span>
+<span id="cb210-29"><a href="#cb210-29" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb210-30"><a href="#cb210-30" aria-hidden="true" tabindex="-1"></a><span class="im">from</span> __future__ <span class="im">import</span> annotations</span>
+<span id="cb210-31"><a href="#cb210-31" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb210-32"><a href="#cb210-32" aria-hidden="true" tabindex="-1"></a><span class="im">from</span> enum <span class="im">import</span> Enum</span>
+<span id="cb210-33"><a href="#cb210-33" aria-hidden="true" tabindex="-1"></a><span class="im">from</span> typing <span class="im">import</span> Annotated, Any, Sequence</span>
+<span id="cb210-34"><a href="#cb210-34" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb210-35"><a href="#cb210-35" aria-hidden="true" tabindex="-1"></a><span class="im">import</span> numpy <span class="im">as</span> np</span>
+<span id="cb210-36"><a href="#cb210-36" aria-hidden="true" tabindex="-1"></a><span class="im">from</span> pydantic <span class="im">import</span> BaseModel, Field, model_validator</span>
+<span id="cb210-37"><a href="#cb210-37" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb210-38"><a href="#cb210-38" aria-hidden="true" tabindex="-1"></a><span class="co"># Wiederverwendbare Feldtypen. Sie tragen die Pruefung im Typ, nicht im Code -</span></span>
+<span id="cb210-39"><a href="#cb210-39" aria-hidden="true" tabindex="-1"></a><span class="co"># damit gilt sie ueberall, wo der Typ verwendet wird.</span></span>
+<span id="cb210-40"><a href="#cb210-40" aria-hidden="true" tabindex="-1"></a>PositiveZahl <span class="op">=</span> Annotated[<span class="bu">float</span>, Field(gt<span class="op">=</span><span class="dv">0</span>)]</span>
+<span id="cb210-41"><a href="#cb210-41" aria-hidden="true" tabindex="-1"></a>NichtNegativ <span class="op">=</span> Annotated[<span class="bu">float</span>, Field(ge<span class="op">=</span><span class="dv">0</span>)]</span>
+<span id="cb210-42"><a href="#cb210-42" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb210-43"><a href="#cb210-43" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb210-44"><a href="#cb210-44" aria-hidden="true" tabindex="-1"></a><span class="co"># --- 1. Solverstatus: eine Sprache fuer fuenf Bibliotheken -------------------</span></span>
+<span id="cb210-45"><a href="#cb210-45" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb210-46"><a href="#cb210-46" aria-hidden="true" tabindex="-1"></a><span class="kw">class</span> SolverStatus(<span class="bu">str</span>, Enum):</span>
+<span id="cb210-47"><a href="#cb210-47" aria-hidden="true" tabindex="-1"></a>    <span class="co">&quot;&quot;&quot;Was ein Solverlauf ergeben hat - unabhaengig davon, wer gerechnet hat.</span></span>
+<span id="cb210-48"><a href="#cb210-48" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb210-49"><a href="#cb210-49" aria-hidden="true" tabindex="-1"></a><span class="co">    Die fuenf im Buch verwendeten Bibliotheken benennen dasselbe Ergebnis</span></span>
+<span id="cb210-50"><a href="#cb210-50" aria-hidden="true" tabindex="-1"></a><span class="co">    unterschiedlich: &#39;Optimal&#39;, &#39;OPTIMAL&#39;, 2, &#39;optimal&#39;. Wer darauf direkt</span></span>
+<span id="cb210-51"><a href="#cb210-51" aria-hidden="true" tabindex="-1"></a><span class="co">    prueft, bindet seinen Auswertungscode an eine Bibliothek.</span></span>
+<span id="cb210-52"><a href="#cb210-52" aria-hidden="true" tabindex="-1"></a><span class="co">    &quot;&quot;&quot;</span></span>
+<span id="cb210-53"><a href="#cb210-53" aria-hidden="true" tabindex="-1"></a>    OPTIMAL <span class="op">=</span> <span class="st">&quot;optimal&quot;</span>              <span class="co"># beweisbar bestmoeglich</span></span>
+<span id="cb210-54"><a href="#cb210-54" aria-hidden="true" tabindex="-1"></a>    ZULAESSIG <span class="op">=</span> <span class="st">&quot;zulaessig&quot;</span>          <span class="co"># brauchbare Loesung, Beweis fehlt</span></span>
+<span id="cb210-55"><a href="#cb210-55" aria-hidden="true" tabindex="-1"></a>    UNZULAESSIG <span class="op">=</span> <span class="st">&quot;unzulaessig&quot;</span>      <span class="co"># es gibt keine Loesung (Aussage ueber das Modell)</span></span>
+<span id="cb210-56"><a href="#cb210-56" aria-hidden="true" tabindex="-1"></a>    UNBESCHRAENKT <span class="op">=</span> <span class="st">&quot;unbeschraenkt&quot;</span>  <span class="co"># Ziel waechst ins Unendliche</span></span>
+<span id="cb210-57"><a href="#cb210-57" aria-hidden="true" tabindex="-1"></a>    ZEITLIMIT <span class="op">=</span> <span class="st">&quot;zeitlimit&quot;</span>          <span class="co"># abgebrochen, nichts Brauchbares gefunden</span></span>
+<span id="cb210-58"><a href="#cb210-58" aria-hidden="true" tabindex="-1"></a>    FEHLERHAFT <span class="op">=</span> <span class="st">&quot;fehlerhaft&quot;</span>        <span class="co"># das Modell ist kein gueltiges Modell</span></span>
+<span id="cb210-59"><a href="#cb210-59" aria-hidden="true" tabindex="-1"></a>    UNBEKANNT <span class="op">=</span> <span class="st">&quot;unbekannt&quot;</span>          <span class="co"># alles Uebrige</span></span>
+<span id="cb210-60"><a href="#cb210-60" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb210-61"><a href="#cb210-61" aria-hidden="true" tabindex="-1"></a>    <span class="at">@property</span></span>
+<span id="cb210-62"><a href="#cb210-62" aria-hidden="true" tabindex="-1"></a>    <span class="kw">def</span> brauchbar(<span class="va">self</span>) <span class="op">-&gt;</span> <span class="bu">bool</span>:</span>
+<span id="cb210-63"><a href="#cb210-63" aria-hidden="true" tabindex="-1"></a>        <span class="co">&quot;&quot;&quot;Habe ich etwas in der Hand, das ich ausfuehren kann?&quot;&quot;&quot;</span></span>
+<span id="cb210-64"><a href="#cb210-64" aria-hidden="true" tabindex="-1"></a>        <span class="cf">return</span> <span class="va">self</span> <span class="kw">in</span> (SolverStatus.OPTIMAL, SolverStatus.ZULAESSIG)</span>
+<span id="cb210-65"><a href="#cb210-65" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb210-66"><a href="#cb210-66" aria-hidden="true" tabindex="-1"></a>    <span class="at">@property</span></span>
+<span id="cb210-67"><a href="#cb210-67" aria-hidden="true" tabindex="-1"></a>    <span class="kw">def</span> modellfehler(<span class="va">self</span>) <span class="op">-&gt;</span> <span class="bu">bool</span>:</span>
+<span id="cb210-68"><a href="#cb210-68" aria-hidden="true" tabindex="-1"></a>        <span class="co">&quot;&quot;&quot;Liegt die Ursache im Modell (und nicht in der Rechenzeit)?&quot;&quot;&quot;</span></span>
+<span id="cb210-69"><a href="#cb210-69" aria-hidden="true" tabindex="-1"></a>        <span class="cf">return</span> <span class="va">self</span> <span class="kw">in</span> (SolverStatus.UNZULAESSIG, SolverStatus.UNBESCHRAENKT,</span>
+<span id="cb210-70"><a href="#cb210-70" aria-hidden="true" tabindex="-1"></a>                        SolverStatus.FEHLERHAFT)</span>
+<span id="cb210-71"><a href="#cb210-71" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb210-72"><a href="#cb210-72" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb210-73"><a href="#cb210-73" aria-hidden="true" tabindex="-1"></a><span class="kw">def</span> status_von_pywraplp(rohstatus: <span class="bu">int</span>) <span class="op">-&gt;</span> SolverStatus:</span>
+<span id="cb210-74"><a href="#cb210-74" aria-hidden="true" tabindex="-1"></a>    <span class="co">&quot;&quot;&quot;OR-Tools linear_solver (GLOP, SCIP, CBC).&quot;&quot;&quot;</span></span>
+<span id="cb210-75"><a href="#cb210-75" aria-hidden="true" tabindex="-1"></a>    <span class="im">from</span> ortools.linear_solver <span class="im">import</span> pywraplp</span>
+<span id="cb210-76"><a href="#cb210-76" aria-hidden="true" tabindex="-1"></a>    zuordnung <span class="op">=</span> {</span>
+<span id="cb210-77"><a href="#cb210-77" aria-hidden="true" tabindex="-1"></a>        pywraplp.Solver.OPTIMAL: SolverStatus.OPTIMAL,</span>
+<span id="cb210-78"><a href="#cb210-78" aria-hidden="true" tabindex="-1"></a>        pywraplp.Solver.FEASIBLE: SolverStatus.ZULAESSIG,</span>
+<span id="cb210-79"><a href="#cb210-79" aria-hidden="true" tabindex="-1"></a>        pywraplp.Solver.INFEASIBLE: SolverStatus.UNZULAESSIG,</span>
+<span id="cb210-80"><a href="#cb210-80" aria-hidden="true" tabindex="-1"></a>        pywraplp.Solver.UNBOUNDED: SolverStatus.UNBESCHRAENKT,</span>
+<span id="cb210-81"><a href="#cb210-81" aria-hidden="true" tabindex="-1"></a>        pywraplp.Solver.ABNORMAL: SolverStatus.FEHLERHAFT,</span>
+<span id="cb210-82"><a href="#cb210-82" aria-hidden="true" tabindex="-1"></a>        pywraplp.Solver.NOT_SOLVED: SolverStatus.ZEITLIMIT,</span>
+<span id="cb210-83"><a href="#cb210-83" aria-hidden="true" tabindex="-1"></a>    }</span>
+<span id="cb210-84"><a href="#cb210-84" aria-hidden="true" tabindex="-1"></a>    <span class="cf">return</span> zuordnung.get(rohstatus, SolverStatus.UNBEKANNT)</span>
+<span id="cb210-85"><a href="#cb210-85" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb210-86"><a href="#cb210-86" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb210-87"><a href="#cb210-87" aria-hidden="true" tabindex="-1"></a><span class="kw">def</span> status_von_cpsat(rohstatus: <span class="bu">int</span>) <span class="op">-&gt;</span> SolverStatus:</span>
+<span id="cb210-88"><a href="#cb210-88" aria-hidden="true" tabindex="-1"></a>    <span class="co">&quot;&quot;&quot;OR-Tools CP-SAT (siehe Kapitel CP-SAT, alle fuenf Faelle).&quot;&quot;&quot;</span></span>
+<span id="cb210-89"><a href="#cb210-89" aria-hidden="true" tabindex="-1"></a>    <span class="im">from</span> ortools.sat.python <span class="im">import</span> cp_model</span>
+<span id="cb210-90"><a href="#cb210-90" aria-hidden="true" tabindex="-1"></a>    zuordnung <span class="op">=</span> {</span>
+<span id="cb210-91"><a href="#cb210-91" aria-hidden="true" tabindex="-1"></a>        cp_model.OPTIMAL: SolverStatus.OPTIMAL,</span>
+<span id="cb210-92"><a href="#cb210-92" aria-hidden="true" tabindex="-1"></a>        cp_model.FEASIBLE: SolverStatus.ZULAESSIG,</span>
+<span id="cb210-93"><a href="#cb210-93" aria-hidden="true" tabindex="-1"></a>        cp_model.INFEASIBLE: SolverStatus.UNZULAESSIG,</span>
+<span id="cb210-94"><a href="#cb210-94" aria-hidden="true" tabindex="-1"></a>        cp_model.MODEL_INVALID: SolverStatus.FEHLERHAFT,</span>
+<span id="cb210-95"><a href="#cb210-95" aria-hidden="true" tabindex="-1"></a>        cp_model.UNKNOWN: SolverStatus.ZEITLIMIT,</span>
+<span id="cb210-96"><a href="#cb210-96" aria-hidden="true" tabindex="-1"></a>    }</span>
+<span id="cb210-97"><a href="#cb210-97" aria-hidden="true" tabindex="-1"></a>    <span class="cf">return</span> zuordnung.get(rohstatus, SolverStatus.UNBEKANNT)</span>
+<span id="cb210-98"><a href="#cb210-98" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb210-99"><a href="#cb210-99" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb210-100"><a href="#cb210-100" aria-hidden="true" tabindex="-1"></a><span class="kw">def</span> status_von_highs(statustext: <span class="bu">str</span>) <span class="op">-&gt;</span> SolverStatus:</span>
+<span id="cb210-101"><a href="#cb210-101" aria-hidden="true" tabindex="-1"></a>    <span class="co">&quot;&quot;&quot;HiGHS ueber highspy - hier kommt der Status als Text.&quot;&quot;&quot;</span></span>
+<span id="cb210-102"><a href="#cb210-102" aria-hidden="true" tabindex="-1"></a>    zuordnung <span class="op">=</span> {</span>
+<span id="cb210-103"><a href="#cb210-103" aria-hidden="true" tabindex="-1"></a>        <span class="st">&quot;Optimal&quot;</span>: SolverStatus.OPTIMAL,</span>
+<span id="cb210-104"><a href="#cb210-104" aria-hidden="true" tabindex="-1"></a>        <span class="st">&quot;Time limit reached&quot;</span>: SolverStatus.ZULAESSIG,   <span class="co"># meist mit Loesung</span></span>
+<span id="cb210-105"><a href="#cb210-105" aria-hidden="true" tabindex="-1"></a>        <span class="st">&quot;Solution limit reached&quot;</span>: SolverStatus.ZULAESSIG,</span>
+<span id="cb210-106"><a href="#cb210-106" aria-hidden="true" tabindex="-1"></a>        <span class="st">&quot;Infeasible&quot;</span>: SolverStatus.UNZULAESSIG,</span>
+<span id="cb210-107"><a href="#cb210-107" aria-hidden="true" tabindex="-1"></a>        <span class="st">&quot;Unbounded&quot;</span>: SolverStatus.UNBESCHRAENKT,</span>
+<span id="cb210-108"><a href="#cb210-108" aria-hidden="true" tabindex="-1"></a>        <span class="st">&quot;Primal infeasible or unbounded&quot;</span>: SolverStatus.UNZULAESSIG,</span>
+<span id="cb210-109"><a href="#cb210-109" aria-hidden="true" tabindex="-1"></a>        <span class="st">&quot;Model error&quot;</span>: SolverStatus.FEHLERHAFT,</span>
+<span id="cb210-110"><a href="#cb210-110" aria-hidden="true" tabindex="-1"></a>    }</span>
+<span id="cb210-111"><a href="#cb210-111" aria-hidden="true" tabindex="-1"></a>    <span class="cf">return</span> zuordnung.get(statustext, SolverStatus.UNBEKANNT)</span>
+<span id="cb210-112"><a href="#cb210-112" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb210-113"><a href="#cb210-113" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb210-114"><a href="#cb210-114" aria-hidden="true" tabindex="-1"></a><span class="kw">def</span> status_von_scipy(ergebnis: Any) <span class="op">-&gt;</span> SolverStatus:</span>
+<span id="cb210-115"><a href="#cb210-115" aria-hidden="true" tabindex="-1"></a>    <span class="co">&quot;&quot;&quot;scipy.optimize.linprog und milp liefern ein Ergebnisobjekt mit .status.&quot;&quot;&quot;</span></span>
+<span id="cb210-116"><a href="#cb210-116" aria-hidden="true" tabindex="-1"></a>    zuordnung <span class="op">=</span> {</span>
+<span id="cb210-117"><a href="#cb210-117" aria-hidden="true" tabindex="-1"></a>        <span class="dv">0</span>: SolverStatus.OPTIMAL,</span>
+<span id="cb210-118"><a href="#cb210-118" aria-hidden="true" tabindex="-1"></a>        <span class="dv">1</span>: SolverStatus.ZEITLIMIT,        <span class="co"># Iterations-/Zeitgrenze</span></span>
+<span id="cb210-119"><a href="#cb210-119" aria-hidden="true" tabindex="-1"></a>        <span class="dv">2</span>: SolverStatus.UNZULAESSIG,</span>
+<span id="cb210-120"><a href="#cb210-120" aria-hidden="true" tabindex="-1"></a>        <span class="dv">3</span>: SolverStatus.UNBESCHRAENKT,</span>
+<span id="cb210-121"><a href="#cb210-121" aria-hidden="true" tabindex="-1"></a>        <span class="dv">4</span>: SolverStatus.FEHLERHAFT,       <span class="co"># numerische Schwierigkeiten</span></span>
+<span id="cb210-122"><a href="#cb210-122" aria-hidden="true" tabindex="-1"></a>    }</span>
+<span id="cb210-123"><a href="#cb210-123" aria-hidden="true" tabindex="-1"></a>    <span class="cf">return</span> zuordnung.get(<span class="bu">int</span>(ergebnis.status), SolverStatus.UNBEKANNT)</span>
+<span id="cb210-124"><a href="#cb210-124" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb210-125"><a href="#cb210-125" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb210-126"><a href="#cb210-126" aria-hidden="true" tabindex="-1"></a><span class="kw">def</span> status_von_cvxpy(statustext: <span class="bu">str</span>) <span class="op">-&gt;</span> SolverStatus:</span>
+<span id="cb210-127"><a href="#cb210-127" aria-hidden="true" tabindex="-1"></a>    <span class="co">&quot;&quot;&quot;CVXPY - Statuszeichenketten wie &#39;optimal&#39; oder &#39;infeasible&#39;.&quot;&quot;&quot;</span></span>
+<span id="cb210-128"><a href="#cb210-128" aria-hidden="true" tabindex="-1"></a>    zuordnung <span class="op">=</span> {</span>
+<span id="cb210-129"><a href="#cb210-129" aria-hidden="true" tabindex="-1"></a>        <span class="st">&quot;optimal&quot;</span>: SolverStatus.OPTIMAL,</span>
+<span id="cb210-130"><a href="#cb210-130" aria-hidden="true" tabindex="-1"></a>        <span class="st">&quot;optimal_inaccurate&quot;</span>: SolverStatus.ZULAESSIG,</span>
+<span id="cb210-131"><a href="#cb210-131" aria-hidden="true" tabindex="-1"></a>        <span class="st">&quot;infeasible&quot;</span>: SolverStatus.UNZULAESSIG,</span>
+<span id="cb210-132"><a href="#cb210-132" aria-hidden="true" tabindex="-1"></a>        <span class="st">&quot;infeasible_inaccurate&quot;</span>: SolverStatus.UNZULAESSIG,</span>
+<span id="cb210-133"><a href="#cb210-133" aria-hidden="true" tabindex="-1"></a>        <span class="st">&quot;unbounded&quot;</span>: SolverStatus.UNBESCHRAENKT,</span>
+<span id="cb210-134"><a href="#cb210-134" aria-hidden="true" tabindex="-1"></a>        <span class="st">&quot;unbounded_inaccurate&quot;</span>: SolverStatus.UNBESCHRAENKT,</span>
+<span id="cb210-135"><a href="#cb210-135" aria-hidden="true" tabindex="-1"></a>    }</span>
+<span id="cb210-136"><a href="#cb210-136" aria-hidden="true" tabindex="-1"></a>    <span class="cf">return</span> zuordnung.get(statustext, SolverStatus.UNBEKANNT)</span>
+<span id="cb210-137"><a href="#cb210-137" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb210-138"><a href="#cb210-138" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb210-139"><a href="#cb210-139" aria-hidden="true" tabindex="-1"></a><span class="co"># --- 2. Die Loesung als solverunabhaengiges Datenobjekt ----------------------</span></span>
+<span id="cb210-140"><a href="#cb210-140" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb210-141"><a href="#cb210-141" aria-hidden="true" tabindex="-1"></a><span class="kw">class</span> Loesung(BaseModel):</span>
+<span id="cb210-142"><a href="#cb210-142" aria-hidden="true" tabindex="-1"></a>    <span class="co">&quot;&quot;&quot;Das Ergebnis eines Solverlaufs, so wie es weiterverarbeitet wird.</span></span>
+<span id="cb210-143"><a href="#cb210-143" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb210-144"><a href="#cb210-144" aria-hidden="true" tabindex="-1"></a><span class="co">    Bewusst OHNE Referenz auf Solver, Modell oder Variablen: Ein Bericht, ein</span></span>
+<span id="cb210-145"><a href="#cb210-145" aria-hidden="true" tabindex="-1"></a><span class="co">    Test oder eine Weiterverarbeitung soll nicht wissen muessen, womit</span></span>
+<span id="cb210-146"><a href="#cb210-146" aria-hidden="true" tabindex="-1"></a><span class="co">    gerechnet wurde.</span></span>
+<span id="cb210-147"><a href="#cb210-147" aria-hidden="true" tabindex="-1"></a><span class="co">    &quot;&quot;&quot;</span></span>
+<span id="cb210-148"><a href="#cb210-148" aria-hidden="true" tabindex="-1"></a>    status: SolverStatus</span>
+<span id="cb210-149"><a href="#cb210-149" aria-hidden="true" tabindex="-1"></a>    werte: <span class="bu">dict</span>[<span class="bu">str</span>, <span class="bu">float</span>] <span class="op">=</span> Field(default_factory<span class="op">=</span><span class="bu">dict</span>)</span>
+<span id="cb210-150"><a href="#cb210-150" aria-hidden="true" tabindex="-1"></a>    zielwert: <span class="bu">float</span> <span class="op">|</span> <span class="va">None</span> <span class="op">=</span> <span class="va">None</span></span>
+<span id="cb210-151"><a href="#cb210-151" aria-hidden="true" tabindex="-1"></a>    schranke: <span class="bu">float</span> <span class="op">|</span> <span class="va">None</span> <span class="op">=</span> <span class="va">None</span></span>
+<span id="cb210-152"><a href="#cb210-152" aria-hidden="true" tabindex="-1"></a>    laufzeit: <span class="bu">float</span> <span class="op">|</span> <span class="va">None</span> <span class="op">=</span> <span class="va">None</span></span>
+<span id="cb210-153"><a href="#cb210-153" aria-hidden="true" tabindex="-1"></a>    <span class="co"># Schattenpreise je Nebenbedingung, sofern der Solver sie liefert</span></span>
+<span id="cb210-154"><a href="#cb210-154" aria-hidden="true" tabindex="-1"></a>    <span class="co"># (nur bei kontinuierlichen Problemen, siehe Kapitel LP). Auch das ist</span></span>
+<span id="cb210-155"><a href="#cb210-155" aria-hidden="true" tabindex="-1"></a>    <span class="co"># ein solverunabhaengiger Begriff und gehoert deshalb hierher.</span></span>
+<span id="cb210-156"><a href="#cb210-156" aria-hidden="true" tabindex="-1"></a>    schattenpreise: <span class="bu">dict</span>[<span class="bu">str</span>, <span class="bu">float</span>] <span class="op">=</span> Field(default_factory<span class="op">=</span><span class="bu">dict</span>)</span>
+<span id="cb210-157"><a href="#cb210-157" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb210-158"><a href="#cb210-158" aria-hidden="true" tabindex="-1"></a>    <span class="at">@property</span></span>
+<span id="cb210-159"><a href="#cb210-159" aria-hidden="true" tabindex="-1"></a>    <span class="kw">def</span> gap(<span class="va">self</span>) <span class="op">-&gt;</span> <span class="bu">float</span> <span class="op">|</span> <span class="va">None</span>:</span>
+<span id="cb210-160"><a href="#cb210-160" aria-hidden="true" tabindex="-1"></a>        <span class="co">&quot;&quot;&quot;Relativer Abstand zwischen gefundener Loesung und bewiesener Schranke.</span></span>
+<span id="cb210-161"><a href="#cb210-161" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb210-162"><a href="#cb210-162" aria-hidden="true" tabindex="-1"></a><span class="co">        Das ist die Zahl fuer den Bericht: keine Schaetzung, sondern eine</span></span>
+<span id="cb210-163"><a href="#cb210-163" aria-hidden="true" tabindex="-1"></a><span class="co">        Zusage - schlechter als das kann die Loesung nicht sein.</span></span>
+<span id="cb210-164"><a href="#cb210-164" aria-hidden="true" tabindex="-1"></a><span class="co">        &quot;&quot;&quot;</span></span>
+<span id="cb210-165"><a href="#cb210-165" aria-hidden="true" tabindex="-1"></a>        <span class="cf">if</span> <span class="va">self</span>.zielwert <span class="kw">is</span> <span class="va">None</span> <span class="kw">or</span> <span class="va">self</span>.schranke <span class="kw">is</span> <span class="va">None</span>:</span>
+<span id="cb210-166"><a href="#cb210-166" aria-hidden="true" tabindex="-1"></a>            <span class="cf">return</span> <span class="va">None</span></span>
+<span id="cb210-167"><a href="#cb210-167" aria-hidden="true" tabindex="-1"></a>        nenner <span class="op">=</span> <span class="bu">max</span>(<span class="bu">abs</span>(<span class="va">self</span>.zielwert), <span class="fl">1e-9</span>)</span>
+<span id="cb210-168"><a href="#cb210-168" aria-hidden="true" tabindex="-1"></a>        <span class="cf">return</span> <span class="bu">abs</span>(<span class="va">self</span>.zielwert <span class="op">-</span> <span class="va">self</span>.schranke) <span class="op">/</span> nenner</span>
+<span id="cb210-169"><a href="#cb210-169" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb210-170"><a href="#cb210-170" aria-hidden="true" tabindex="-1"></a>    <span class="kw">def</span> als_bericht(<span class="va">self</span>) <span class="op">-&gt;</span> <span class="bu">str</span>:</span>
+<span id="cb210-171"><a href="#cb210-171" aria-hidden="true" tabindex="-1"></a>        <span class="co">&quot;&quot;&quot;Eine Zeile fuers Betriebsprotokoll - siehe Betriebsueberwachung.py.&quot;&quot;&quot;</span></span>
+<span id="cb210-172"><a href="#cb210-172" aria-hidden="true" tabindex="-1"></a>        teile <span class="op">=</span> [<span class="ss">f&quot;Status: </span><span class="sc">{</span><span class="va">self</span><span class="sc">.</span>status<span class="sc">.</span>value<span class="sc">}</span><span class="ss">&quot;</span>]</span>
+<span id="cb210-173"><a href="#cb210-173" aria-hidden="true" tabindex="-1"></a>        <span class="cf">if</span> <span class="va">self</span>.zielwert <span class="kw">is</span> <span class="kw">not</span> <span class="va">None</span>:</span>
+<span id="cb210-174"><a href="#cb210-174" aria-hidden="true" tabindex="-1"></a>            teile.append(<span class="ss">f&quot;Zielwert: </span><span class="sc">{</span><span class="va">self</span><span class="sc">.</span>zielwert<span class="sc">:,.2f}</span><span class="ss">&quot;</span>)</span>
+<span id="cb210-175"><a href="#cb210-175" aria-hidden="true" tabindex="-1"></a>        <span class="cf">if</span> <span class="va">self</span>.gap <span class="kw">is</span> <span class="kw">not</span> <span class="va">None</span>:</span>
+<span id="cb210-176"><a href="#cb210-176" aria-hidden="true" tabindex="-1"></a>            teile.append(<span class="ss">f&quot;Gap: </span><span class="sc">{</span><span class="va">self</span><span class="sc">.</span>gap<span class="sc">:.2%}</span><span class="ss">&quot;</span>)</span>
+<span id="cb210-177"><a href="#cb210-177" aria-hidden="true" tabindex="-1"></a>        <span class="cf">if</span> <span class="va">self</span>.laufzeit <span class="kw">is</span> <span class="kw">not</span> <span class="va">None</span>:</span>
+<span id="cb210-178"><a href="#cb210-178" aria-hidden="true" tabindex="-1"></a>            teile.append(<span class="ss">f&quot;Zeit: </span><span class="sc">{</span><span class="va">self</span><span class="sc">.</span>laufzeit<span class="sc">:.2f}</span><span class="ss">s&quot;</span>)</span>
+<span id="cb210-179"><a href="#cb210-179" aria-hidden="true" tabindex="-1"></a>        <span class="cf">return</span> <span class="st">&quot; | &quot;</span>.join(teile)</span>
+<span id="cb210-180"><a href="#cb210-180" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb210-181"><a href="#cb210-181" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb210-182"><a href="#cb210-182" aria-hidden="true" tabindex="-1"></a><span class="co"># --- 3. Domaenenmodell: die Fakten, bevor ein Solver sie sieht ---------------</span></span>
+<span id="cb210-183"><a href="#cb210-183" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb210-184"><a href="#cb210-184" aria-hidden="true" tabindex="-1"></a><span class="kw">class</span> Produkt(BaseModel):</span>
+<span id="cb210-185"><a href="#cb210-185" aria-hidden="true" tabindex="-1"></a>    <span class="co">&quot;&quot;&quot;Ein Produkt mit Deckungsbeitrag und Ressourcenverbrauch.&quot;&quot;&quot;</span></span>
+<span id="cb210-186"><a href="#cb210-186" aria-hidden="true" tabindex="-1"></a>    name: <span class="bu">str</span> <span class="op">=</span> Field(min_length<span class="op">=</span><span class="dv">1</span>)</span>
+<span id="cb210-187"><a href="#cb210-187" aria-hidden="true" tabindex="-1"></a>    deckungsbeitrag: <span class="bu">float</span></span>
+<span id="cb210-188"><a href="#cb210-188" aria-hidden="true" tabindex="-1"></a>    verbrauch: <span class="bu">dict</span>[<span class="bu">str</span>, NichtNegativ]</span>
+<span id="cb210-189"><a href="#cb210-189" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb210-190"><a href="#cb210-190" aria-hidden="true" tabindex="-1"></a>    model_config <span class="op">=</span> {<span class="st">&quot;frozen&quot;</span>: <span class="va">True</span>}      <span class="co"># Stammdaten aendern sich nicht im Lauf</span></span>
+<span id="cb210-191"><a href="#cb210-191" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb210-192"><a href="#cb210-192" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb210-193"><a href="#cb210-193" aria-hidden="true" tabindex="-1"></a><span class="kw">class</span> Produktionsproblem(BaseModel):</span>
+<span id="cb210-194"><a href="#cb210-194" aria-hidden="true" tabindex="-1"></a>    <span class="co">&quot;&quot;&quot;Produktionsprogrammplanung - das Modell aus Kapitel Einfuehrung.</span></span>
+<span id="cb210-195"><a href="#cb210-195" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb210-196"><a href="#cb210-196" aria-hidden="true" tabindex="-1"></a><span class="co">    Die Pruefungen stehen hier und nicht im Solvercode. Damit gelten sie</span></span>
+<span id="cb210-197"><a href="#cb210-197" aria-hidden="true" tabindex="-1"></a><span class="co">    unabhaengig davon, mit welcher Bibliothek spaeter gerechnet wird - und sie</span></span>
+<span id="cb210-198"><a href="#cb210-198" aria-hidden="true" tabindex="-1"></a><span class="co">    schlagen beim EINLESEN zu, wo der Fehler noch zuzuordnen ist.</span></span>
+<span id="cb210-199"><a href="#cb210-199" aria-hidden="true" tabindex="-1"></a><span class="co">    &quot;&quot;&quot;</span></span>
+<span id="cb210-200"><a href="#cb210-200" aria-hidden="true" tabindex="-1"></a>    produkte: <span class="bu">list</span>[Produkt] <span class="op">=</span> Field(min_length<span class="op">=</span><span class="dv">1</span>)</span>
+<span id="cb210-201"><a href="#cb210-201" aria-hidden="true" tabindex="-1"></a>    kapazitaeten: <span class="bu">dict</span>[<span class="bu">str</span>, PositiveZahl]</span>
+<span id="cb210-202"><a href="#cb210-202" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb210-203"><a href="#cb210-203" aria-hidden="true" tabindex="-1"></a>    <span class="at">@model_validator</span>(mode<span class="op">=</span><span class="st">&quot;after&quot;</span>)</span>
+<span id="cb210-204"><a href="#cb210-204" aria-hidden="true" tabindex="-1"></a>    <span class="kw">def</span> pruefe_ressourcen(<span class="va">self</span>) <span class="op">-&gt;</span> <span class="st">&quot;Produktionsproblem&quot;</span>:</span>
+<span id="cb210-205"><a href="#cb210-205" aria-hidden="true" tabindex="-1"></a>        namen <span class="op">=</span> [p.name <span class="cf">for</span> p <span class="kw">in</span> <span class="va">self</span>.produkte]</span>
+<span id="cb210-206"><a href="#cb210-206" aria-hidden="true" tabindex="-1"></a>        <span class="cf">if</span> <span class="bu">len</span>(<span class="bu">set</span>(namen)) <span class="op">!=</span> <span class="bu">len</span>(namen):</span>
+<span id="cb210-207"><a href="#cb210-207" aria-hidden="true" tabindex="-1"></a>            doppelt <span class="op">=</span> <span class="bu">sorted</span>({n <span class="cf">for</span> n <span class="kw">in</span> namen <span class="cf">if</span> namen.count(n) <span class="op">&gt;</span> <span class="dv">1</span>})</span>
+<span id="cb210-208"><a href="#cb210-208" aria-hidden="true" tabindex="-1"></a>            <span class="cf">raise</span> <span class="pp">ValueError</span>(<span class="ss">f&quot;Produktnamen kommen mehrfach vor: </span><span class="sc">{</span>doppelt<span class="sc">}</span><span class="ss">&quot;</span>)</span>
+<span id="cb210-209"><a href="#cb210-209" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb210-210"><a href="#cb210-210" aria-hidden="true" tabindex="-1"></a>        <span class="cf">for</span> produkt <span class="kw">in</span> <span class="va">self</span>.produkte:</span>
+<span id="cb210-211"><a href="#cb210-211" aria-hidden="true" tabindex="-1"></a>            unbekannt <span class="op">=</span> <span class="bu">set</span>(produkt.verbrauch) <span class="op">-</span> <span class="bu">set</span>(<span class="va">self</span>.kapazitaeten)</span>
+<span id="cb210-212"><a href="#cb210-212" aria-hidden="true" tabindex="-1"></a>            <span class="cf">if</span> unbekannt:</span>
+<span id="cb210-213"><a href="#cb210-213" aria-hidden="true" tabindex="-1"></a>                <span class="cf">raise</span> <span class="pp">ValueError</span>(</span>
+<span id="cb210-214"><a href="#cb210-214" aria-hidden="true" tabindex="-1"></a>                    <span class="ss">f&quot;Produkt &#39;</span><span class="sc">{</span>produkt<span class="sc">.</span>name<span class="sc">}</span><span class="ss">&#39; verbraucht Ressourcen ohne &quot;</span></span>
+<span id="cb210-215"><a href="#cb210-215" aria-hidden="true" tabindex="-1"></a>                    <span class="ss">f&quot;Kapazitaetsangabe: </span><span class="sc">{</span><span class="bu">sorted</span>(unbekannt)<span class="sc">}</span><span class="ss">&quot;</span>)</span>
+<span id="cb210-216"><a href="#cb210-216" aria-hidden="true" tabindex="-1"></a>        <span class="cf">return</span> <span class="va">self</span></span>
+<span id="cb210-217"><a href="#cb210-217" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb210-218"><a href="#cb210-218" aria-hidden="true" tabindex="-1"></a>    <span class="at">@property</span></span>
+<span id="cb210-219"><a href="#cb210-219" aria-hidden="true" tabindex="-1"></a>    <span class="kw">def</span> ressourcen(<span class="va">self</span>) <span class="op">-&gt;</span> <span class="bu">list</span>[<span class="bu">str</span>]:</span>
+<span id="cb210-220"><a href="#cb210-220" aria-hidden="true" tabindex="-1"></a>        <span class="co">&quot;&quot;&quot;Feste Reihenfolge - siehe die Spaltenfalle in Kapitel Finanzdaten.&quot;&quot;&quot;</span></span>
+<span id="cb210-221"><a href="#cb210-221" aria-hidden="true" tabindex="-1"></a>        <span class="cf">return</span> <span class="bu">sorted</span>(<span class="va">self</span>.kapazitaeten)</span>
+<span id="cb210-222"><a href="#cb210-222" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb210-223"><a href="#cb210-223" aria-hidden="true" tabindex="-1"></a>    <span class="kw">def</span> verbrauchsmatrix(<span class="va">self</span>) <span class="op">-&gt;</span> np.ndarray:</span>
+<span id="cb210-224"><a href="#cb210-224" aria-hidden="true" tabindex="-1"></a>        <span class="co">&quot;&quot;&quot;Zeilen = Ressourcen, Spalten = Produkte (Matrixform, Kapitel Fundament).&quot;&quot;&quot;</span></span>
+<span id="cb210-225"><a href="#cb210-225" aria-hidden="true" tabindex="-1"></a>        <span class="cf">return</span> np.array([[p.verbrauch.get(r, <span class="fl">0.0</span>) <span class="cf">for</span> p <span class="kw">in</span> <span class="va">self</span>.produkte]</span>
+<span id="cb210-226"><a href="#cb210-226" aria-hidden="true" tabindex="-1"></a>                         <span class="cf">for</span> r <span class="kw">in</span> <span class="va">self</span>.ressourcen])</span>
+<span id="cb210-227"><a href="#cb210-227" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb210-228"><a href="#cb210-228" aria-hidden="true" tabindex="-1"></a>    <span class="kw">def</span> kapazitaetsvektor(<span class="va">self</span>) <span class="op">-&gt;</span> np.ndarray:</span>
+<span id="cb210-229"><a href="#cb210-229" aria-hidden="true" tabindex="-1"></a>        <span class="cf">return</span> np.array([<span class="va">self</span>.kapazitaeten[r] <span class="cf">for</span> r <span class="kw">in</span> <span class="va">self</span>.ressourcen])</span>
+<span id="cb210-230"><a href="#cb210-230" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb210-231"><a href="#cb210-231" aria-hidden="true" tabindex="-1"></a>    <span class="kw">def</span> deckungsbeitragsvektor(<span class="va">self</span>) <span class="op">-&gt;</span> np.ndarray:</span>
+<span id="cb210-232"><a href="#cb210-232" aria-hidden="true" tabindex="-1"></a>        <span class="cf">return</span> np.array([p.deckungsbeitrag <span class="cf">for</span> p <span class="kw">in</span> <span class="va">self</span>.produkte])</span>
+<span id="cb210-233"><a href="#cb210-233" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb210-234"><a href="#cb210-234" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb210-235"><a href="#cb210-235" aria-hidden="true" tabindex="-1"></a><span class="co"># --- 4. Abnahmepruefung: Loesung gegen Anforderung, ohne Solver --------------</span></span>
+<span id="cb210-236"><a href="#cb210-236" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb210-237"><a href="#cb210-237" aria-hidden="true" tabindex="-1"></a><span class="kw">def</span> pruefe_loesung(problem: Produktionsproblem, loesung: Loesung,</span>
+<span id="cb210-238"><a href="#cb210-238" aria-hidden="true" tabindex="-1"></a>                   ganzzahlig: Sequence[<span class="bu">str</span>] <span class="op">=</span> (),</span>
+<span id="cb210-239"><a href="#cb210-239" aria-hidden="true" tabindex="-1"></a>                   toleranz: <span class="bu">float</span> <span class="op">=</span> <span class="fl">1e-6</span>) <span class="op">-&gt;</span> <span class="bu">list</span>[<span class="bu">str</span>]:</span>
+<span id="cb210-240"><a href="#cb210-240" aria-hidden="true" tabindex="-1"></a>    <span class="co">&quot;&quot;&quot;Prueft eine Loesung gegen die Anforderungen - OHNE den Solver zu fragen.</span></span>
+<span id="cb210-241"><a href="#cb210-241" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb210-242"><a href="#cb210-242" aria-hidden="true" tabindex="-1"></a><span class="co">    Diese Funktion darf ausdruecklich KEIN Solverobjekt und keine</span></span>
+<span id="cb210-243"><a href="#cb210-243" aria-hidden="true" tabindex="-1"></a><span class="co">    Modellvariable benutzen. Eine Pruefung aus denselben Bausteinen wie das</span></span>
+<span id="cb210-244"><a href="#cb210-244" aria-hidden="true" tabindex="-1"></a><span class="co">    Modell prueft das Modell gegen sich selbst und findet nichts (siehe die</span></span>
+<span id="cb210-245"><a href="#cb210-245" aria-hidden="true" tabindex="-1"></a><span class="co">    Denkfehler in den Kapiteln Graphen und MILP).</span></span>
+<span id="cb210-246"><a href="#cb210-246" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb210-247"><a href="#cb210-247" aria-hidden="true" tabindex="-1"></a><span class="co">    Liefert eine Liste von Beanstandungen; leer heisst bestanden.</span></span>
+<span id="cb210-248"><a href="#cb210-248" aria-hidden="true" tabindex="-1"></a><span class="co">    &quot;&quot;&quot;</span></span>
+<span id="cb210-249"><a href="#cb210-249" aria-hidden="true" tabindex="-1"></a>    beanstandungen: <span class="bu">list</span>[<span class="bu">str</span>] <span class="op">=</span> []</span>
+<span id="cb210-250"><a href="#cb210-250" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb210-251"><a href="#cb210-251" aria-hidden="true" tabindex="-1"></a>    <span class="cf">if</span> <span class="kw">not</span> loesung.status.brauchbar:</span>
+<span id="cb210-252"><a href="#cb210-252" aria-hidden="true" tabindex="-1"></a>        <span class="cf">return</span> [<span class="ss">f&quot;Kein verwertbares Ergebnis (Status: </span><span class="sc">{</span>loesung<span class="sc">.</span>status<span class="sc">.</span>value<span class="sc">}</span><span class="ss">)&quot;</span>]</span>
+<span id="cb210-253"><a href="#cb210-253" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb210-254"><a href="#cb210-254" aria-hidden="true" tabindex="-1"></a>    fehlend <span class="op">=</span> [p.name <span class="cf">for</span> p <span class="kw">in</span> problem.produkte <span class="cf">if</span> p.name <span class="kw">not</span> <span class="kw">in</span> loesung.werte]</span>
+<span id="cb210-255"><a href="#cb210-255" aria-hidden="true" tabindex="-1"></a>    <span class="cf">if</span> fehlend:</span>
+<span id="cb210-256"><a href="#cb210-256" aria-hidden="true" tabindex="-1"></a>        <span class="cf">return</span> [<span class="ss">f&quot;Loesung enthaelt keine Werte fuer: </span><span class="sc">{</span>fehlend<span class="sc">}</span><span class="ss">&quot;</span>]</span>
+<span id="cb210-257"><a href="#cb210-257" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb210-258"><a href="#cb210-258" aria-hidden="true" tabindex="-1"></a>    mengen <span class="op">=</span> np.array([loesung.werte[p.name] <span class="cf">for</span> p <span class="kw">in</span> problem.produkte])</span>
+<span id="cb210-259"><a href="#cb210-259" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb210-260"><a href="#cb210-260" aria-hidden="true" tabindex="-1"></a>    <span class="cf">if</span> (mengen <span class="op">&lt;</span> <span class="op">-</span>toleranz).<span class="bu">any</span>():</span>
+<span id="cb210-261"><a href="#cb210-261" aria-hidden="true" tabindex="-1"></a>        negativ <span class="op">=</span> [p.name <span class="cf">for</span> p, m <span class="kw">in</span> <span class="bu">zip</span>(problem.produkte, mengen) <span class="cf">if</span> m <span class="op">&lt;</span> <span class="op">-</span>toleranz]</span>
+<span id="cb210-262"><a href="#cb210-262" aria-hidden="true" tabindex="-1"></a>        beanstandungen.append(<span class="ss">f&quot;negative Mengen bei: </span><span class="sc">{</span>negativ<span class="sc">}</span><span class="ss">&quot;</span>)</span>
+<span id="cb210-263"><a href="#cb210-263" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb210-264"><a href="#cb210-264" aria-hidden="true" tabindex="-1"></a>    verbrauch <span class="op">=</span> problem.verbrauchsmatrix() <span class="op">@</span> mengen</span>
+<span id="cb210-265"><a href="#cb210-265" aria-hidden="true" tabindex="-1"></a>    <span class="cf">for</span> ressource, ist, grenze <span class="kw">in</span> <span class="bu">zip</span>(problem.ressourcen, verbrauch,</span>
+<span id="cb210-266"><a href="#cb210-266" aria-hidden="true" tabindex="-1"></a>                                      problem.kapazitaetsvektor()):</span>
+<span id="cb210-267"><a href="#cb210-267" aria-hidden="true" tabindex="-1"></a>        <span class="cf">if</span> ist <span class="op">&gt;</span> grenze <span class="op">+</span> toleranz:</span>
+<span id="cb210-268"><a href="#cb210-268" aria-hidden="true" tabindex="-1"></a>            beanstandungen.append(</span>
+<span id="cb210-269"><a href="#cb210-269" aria-hidden="true" tabindex="-1"></a>                <span class="ss">f&quot;</span><span class="sc">{</span>ressource<span class="sc">}</span><span class="ss">: Verbrauch </span><span class="sc">{</span>ist<span class="sc">:,.3f}</span><span class="ss"> ueber Kapazitaet </span><span class="sc">{</span>grenze<span class="sc">:,.3f}</span><span class="ss">&quot;</span>)</span>
+<span id="cb210-270"><a href="#cb210-270" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb210-271"><a href="#cb210-271" aria-hidden="true" tabindex="-1"></a>    <span class="cf">for</span> name <span class="kw">in</span> ganzzahlig:</span>
+<span id="cb210-272"><a href="#cb210-272" aria-hidden="true" tabindex="-1"></a>        wert <span class="op">=</span> loesung.werte[name]</span>
+<span id="cb210-273"><a href="#cb210-273" aria-hidden="true" tabindex="-1"></a>        <span class="cf">if</span> <span class="bu">abs</span>(wert <span class="op">-</span> <span class="bu">round</span>(wert)) <span class="op">&gt;</span> toleranz:</span>
+<span id="cb210-274"><a href="#cb210-274" aria-hidden="true" tabindex="-1"></a>            beanstandungen.append(<span class="ss">f&quot;&#39;</span><span class="sc">{</span>name<span class="sc">}</span><span class="ss">&#39; = </span><span class="sc">{</span>wert<span class="sc">!r}</span><span class="ss"> ist nicht ganzzahlig&quot;</span>)</span>
+<span id="cb210-275"><a href="#cb210-275" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb210-276"><a href="#cb210-276" aria-hidden="true" tabindex="-1"></a>    <span class="cf">if</span> loesung.zielwert <span class="kw">is</span> <span class="kw">not</span> <span class="va">None</span>:</span>
+<span id="cb210-277"><a href="#cb210-277" aria-hidden="true" tabindex="-1"></a>        nachgerechnet <span class="op">=</span> <span class="bu">float</span>(problem.deckungsbeitragsvektor() <span class="op">@</span> mengen)</span>
+<span id="cb210-278"><a href="#cb210-278" aria-hidden="true" tabindex="-1"></a>        <span class="cf">if</span> <span class="bu">abs</span>(nachgerechnet <span class="op">-</span> loesung.zielwert) <span class="op">&gt;</span> toleranz <span class="op">*</span> <span class="bu">max</span>(<span class="fl">1.0</span>, <span class="bu">abs</span>(nachgerechnet)):</span>
+<span id="cb210-279"><a href="#cb210-279" aria-hidden="true" tabindex="-1"></a>            beanstandungen.append(</span>
+<span id="cb210-280"><a href="#cb210-280" aria-hidden="true" tabindex="-1"></a>                <span class="ss">f&quot;Zielwert </span><span class="sc">{</span>loesung<span class="sc">.</span>zielwert<span class="sc">:,.4f}</span><span class="ss"> passt nicht zu den Mengen &quot;</span></span>
+<span id="cb210-281"><a href="#cb210-281" aria-hidden="true" tabindex="-1"></a>                <span class="ss">f&quot;(nachgerechnet </span><span class="sc">{</span>nachgerechnet<span class="sc">:,.4f}</span><span class="ss">)&quot;</span>)</span>
+<span id="cb210-282"><a href="#cb210-282" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb210-283"><a href="#cb210-283" aria-hidden="true" tabindex="-1"></a>    <span class="cf">return</span> beanstandungen</span>
+<span id="cb210-284"><a href="#cb210-284" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb210-285"><a href="#cb210-285" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb210-286"><a href="#cb210-286" aria-hidden="true" tabindex="-1"></a><span class="co"># --- 5. Ein Modellbauer je Solver - austauschbar ----------------------------</span></span>
+<span id="cb210-287"><a href="#cb210-287" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb210-288"><a href="#cb210-288" aria-hidden="true" tabindex="-1"></a><span class="kw">def</span> loese_mit_glop(problem: Produktionsproblem) <span class="op">-&gt;</span> Loesung:</span>
+<span id="cb210-289"><a href="#cb210-289" aria-hidden="true" tabindex="-1"></a>    <span class="co">&quot;&quot;&quot;Modellbauer fuer OR-Tools GLOP (kontinuierlich).&quot;&quot;&quot;</span></span>
+<span id="cb210-290"><a href="#cb210-290" aria-hidden="true" tabindex="-1"></a>    <span class="im">import</span> time</span>
+<span id="cb210-291"><a href="#cb210-291" aria-hidden="true" tabindex="-1"></a>    <span class="im">from</span> ortools.linear_solver <span class="im">import</span> pywraplp</span>
+<span id="cb210-292"><a href="#cb210-292" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb210-293"><a href="#cb210-293" aria-hidden="true" tabindex="-1"></a>    solver <span class="op">=</span> pywraplp.Solver.CreateSolver(<span class="st">&quot;GLOP&quot;</span>)</span>
+<span id="cb210-294"><a href="#cb210-294" aria-hidden="true" tabindex="-1"></a>    menge <span class="op">=</span> {p.name: solver.NumVar(<span class="dv">0</span>, solver.infinity(), p.name)</span>
+<span id="cb210-295"><a href="#cb210-295" aria-hidden="true" tabindex="-1"></a>             <span class="cf">for</span> p <span class="kw">in</span> problem.produkte}</span>
+<span id="cb210-296"><a href="#cb210-296" aria-hidden="true" tabindex="-1"></a>    <span class="co"># Die Nebenbedingung wird gemerkt - ohne die Referenz gibt es spaeter</span></span>
+<span id="cb210-297"><a href="#cb210-297" aria-hidden="true" tabindex="-1"></a>    <span class="co"># keinen Schattenpreis (siehe Kapitel LP).</span></span>
+<span id="cb210-298"><a href="#cb210-298" aria-hidden="true" tabindex="-1"></a>    bedingung <span class="op">=</span> {}</span>
+<span id="cb210-299"><a href="#cb210-299" aria-hidden="true" tabindex="-1"></a>    <span class="cf">for</span> ressource <span class="kw">in</span> problem.ressourcen:</span>
+<span id="cb210-300"><a href="#cb210-300" aria-hidden="true" tabindex="-1"></a>        bedingung[ressource] <span class="op">=</span> solver.Add(</span>
+<span id="cb210-301"><a href="#cb210-301" aria-hidden="true" tabindex="-1"></a>            <span class="bu">sum</span>(menge[p.name] <span class="op">*</span> p.verbrauch.get(ressource, <span class="fl">0.0</span>)</span>
+<span id="cb210-302"><a href="#cb210-302" aria-hidden="true" tabindex="-1"></a>                <span class="cf">for</span> p <span class="kw">in</span> problem.produkte)</span>
+<span id="cb210-303"><a href="#cb210-303" aria-hidden="true" tabindex="-1"></a>            <span class="op">&lt;=</span> problem.kapazitaeten[ressource], name<span class="op">=</span>ressource)</span>
+<span id="cb210-304"><a href="#cb210-304" aria-hidden="true" tabindex="-1"></a>    solver.Maximize(<span class="bu">sum</span>(menge[p.name] <span class="op">*</span> p.deckungsbeitrag <span class="cf">for</span> p <span class="kw">in</span> problem.produkte))</span>
+<span id="cb210-305"><a href="#cb210-305" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb210-306"><a href="#cb210-306" aria-hidden="true" tabindex="-1"></a>    t0 <span class="op">=</span> time.perf_counter()</span>
+<span id="cb210-307"><a href="#cb210-307" aria-hidden="true" tabindex="-1"></a>    rohstatus <span class="op">=</span> solver.Solve()</span>
+<span id="cb210-308"><a href="#cb210-308" aria-hidden="true" tabindex="-1"></a>    laufzeit <span class="op">=</span> time.perf_counter() <span class="op">-</span> t0</span>
+<span id="cb210-309"><a href="#cb210-309" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb210-310"><a href="#cb210-310" aria-hidden="true" tabindex="-1"></a>    status <span class="op">=</span> status_von_pywraplp(rohstatus)</span>
+<span id="cb210-311"><a href="#cb210-311" aria-hidden="true" tabindex="-1"></a>    <span class="cf">if</span> <span class="kw">not</span> status.brauchbar:</span>
+<span id="cb210-312"><a href="#cb210-312" aria-hidden="true" tabindex="-1"></a>        <span class="cf">return</span> Loesung(status<span class="op">=</span>status, laufzeit<span class="op">=</span>laufzeit)</span>
+<span id="cb210-313"><a href="#cb210-313" aria-hidden="true" tabindex="-1"></a>    <span class="cf">return</span> Loesung(status<span class="op">=</span>status,</span>
+<span id="cb210-314"><a href="#cb210-314" aria-hidden="true" tabindex="-1"></a>                   werte<span class="op">=</span>{name: v.solution_value() <span class="cf">for</span> name, v <span class="kw">in</span> menge.items()},</span>
+<span id="cb210-315"><a href="#cb210-315" aria-hidden="true" tabindex="-1"></a>                   zielwert<span class="op">=</span>solver.Objective().Value(),</span>
+<span id="cb210-316"><a href="#cb210-316" aria-hidden="true" tabindex="-1"></a>                   schranke<span class="op">=</span>solver.Objective().Value(),</span>
+<span id="cb210-317"><a href="#cb210-317" aria-hidden="true" tabindex="-1"></a>                   schattenpreise<span class="op">=</span>{r: b.dual_value() <span class="cf">for</span> r, b <span class="kw">in</span> bedingung.items()},</span>
+<span id="cb210-318"><a href="#cb210-318" aria-hidden="true" tabindex="-1"></a>                   laufzeit<span class="op">=</span>laufzeit)</span>
+<span id="cb210-319"><a href="#cb210-319" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb210-320"><a href="#cb210-320" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb210-321"><a href="#cb210-321" aria-hidden="true" tabindex="-1"></a><span class="kw">def</span> loese_mit_scipy(problem: Produktionsproblem) <span class="op">-&gt;</span> Loesung:</span>
+<span id="cb210-322"><a href="#cb210-322" aria-hidden="true" tabindex="-1"></a>    <span class="co">&quot;&quot;&quot;Derselbe Fall mit scipy.optimize.linprog - anderer Solver, gleiche Loesung.</span></span>
+<span id="cb210-323"><a href="#cb210-323" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb210-324"><a href="#cb210-324" aria-hidden="true" tabindex="-1"></a><span class="co">    Beachten Sie, wie wenig hier steht: Die Daten kommen fertig geprueft aus</span></span>
+<span id="cb210-325"><a href="#cb210-325" aria-hidden="true" tabindex="-1"></a><span class="co">    dem Domaenenmodell, die Auswertung geht ans gemeinsame Loesung-Objekt.</span></span>
+<span id="cb210-326"><a href="#cb210-326" aria-hidden="true" tabindex="-1"></a><span class="co">    Genau das ist der Ertrag der Trennung.</span></span>
+<span id="cb210-327"><a href="#cb210-327" aria-hidden="true" tabindex="-1"></a><span class="co">    &quot;&quot;&quot;</span></span>
+<span id="cb210-328"><a href="#cb210-328" aria-hidden="true" tabindex="-1"></a>    <span class="im">import</span> time</span>
+<span id="cb210-329"><a href="#cb210-329" aria-hidden="true" tabindex="-1"></a>    <span class="im">from</span> scipy.optimize <span class="im">import</span> linprog</span>
+<span id="cb210-330"><a href="#cb210-330" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb210-331"><a href="#cb210-331" aria-hidden="true" tabindex="-1"></a>    t0 <span class="op">=</span> time.perf_counter()</span>
+<span id="cb210-332"><a href="#cb210-332" aria-hidden="true" tabindex="-1"></a>    ergebnis <span class="op">=</span> linprog(c<span class="op">=-</span>problem.deckungsbeitragsvektor(),      <span class="co"># linprog minimiert</span></span>
+<span id="cb210-333"><a href="#cb210-333" aria-hidden="true" tabindex="-1"></a>                       A_ub<span class="op">=</span>problem.verbrauchsmatrix(),</span>
+<span id="cb210-334"><a href="#cb210-334" aria-hidden="true" tabindex="-1"></a>                       b_ub<span class="op">=</span>problem.kapazitaetsvektor(),</span>
+<span id="cb210-335"><a href="#cb210-335" aria-hidden="true" tabindex="-1"></a>                       bounds<span class="op">=</span>(<span class="dv">0</span>, <span class="va">None</span>), method<span class="op">=</span><span class="st">&quot;highs&quot;</span>)</span>
+<span id="cb210-336"><a href="#cb210-336" aria-hidden="true" tabindex="-1"></a>    laufzeit <span class="op">=</span> time.perf_counter() <span class="op">-</span> t0</span>
+<span id="cb210-337"><a href="#cb210-337" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb210-338"><a href="#cb210-338" aria-hidden="true" tabindex="-1"></a>    status <span class="op">=</span> status_von_scipy(ergebnis)</span>
+<span id="cb210-339"><a href="#cb210-339" aria-hidden="true" tabindex="-1"></a>    <span class="cf">if</span> <span class="kw">not</span> status.brauchbar:</span>
+<span id="cb210-340"><a href="#cb210-340" aria-hidden="true" tabindex="-1"></a>        <span class="cf">return</span> Loesung(status<span class="op">=</span>status, laufzeit<span class="op">=</span>laufzeit)</span>
+<span id="cb210-341"><a href="#cb210-341" aria-hidden="true" tabindex="-1"></a>    <span class="co"># linprog rechnet minimierend mit negierten Kosten - die Dualwerte</span></span>
+<span id="cb210-342"><a href="#cb210-342" aria-hidden="true" tabindex="-1"></a>    <span class="co"># muessen entsprechend zurueckgedreht werden.</span></span>
+<span id="cb210-343"><a href="#cb210-343" aria-hidden="true" tabindex="-1"></a>    <span class="cf">return</span> Loesung(status<span class="op">=</span>status,</span>
+<span id="cb210-344"><a href="#cb210-344" aria-hidden="true" tabindex="-1"></a>                   werte<span class="op">=</span>{p.name: <span class="bu">float</span>(x)</span>
+<span id="cb210-345"><a href="#cb210-345" aria-hidden="true" tabindex="-1"></a>                          <span class="cf">for</span> p, x <span class="kw">in</span> <span class="bu">zip</span>(problem.produkte, ergebnis.x)},</span>
+<span id="cb210-346"><a href="#cb210-346" aria-hidden="true" tabindex="-1"></a>                   zielwert<span class="op">=</span><span class="bu">float</span>(<span class="op">-</span>ergebnis.fun),</span>
+<span id="cb210-347"><a href="#cb210-347" aria-hidden="true" tabindex="-1"></a>                   schranke<span class="op">=</span><span class="bu">float</span>(<span class="op">-</span>ergebnis.fun),</span>
+<span id="cb210-348"><a href="#cb210-348" aria-hidden="true" tabindex="-1"></a>                   schattenpreise<span class="op">=</span>{r: <span class="bu">float</span>(<span class="op">-</span>m) <span class="cf">for</span> r, m <span class="kw">in</span></span>
+<span id="cb210-349"><a href="#cb210-349" aria-hidden="true" tabindex="-1"></a>                                   <span class="bu">zip</span>(problem.ressourcen,</span>
+<span id="cb210-350"><a href="#cb210-350" aria-hidden="true" tabindex="-1"></a>                                       ergebnis.ineqlin.marginals)},</span>
+<span id="cb210-351"><a href="#cb210-351" aria-hidden="true" tabindex="-1"></a>                   laufzeit<span class="op">=</span>laufzeit)</span>
+<span id="cb210-352"><a href="#cb210-352" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb210-353"><a href="#cb210-353" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb210-354"><a href="#cb210-354" aria-hidden="true" tabindex="-1"></a><span class="co"># --- 6. Ein- und Ausgabe: Tabellen sind die Wirklichkeit ---------------------</span></span>
+<span id="cb210-355"><a href="#cb210-355" aria-hidden="true" tabindex="-1"></a><span class="co">#</span></span>
+<span id="cb210-356"><a href="#cb210-356" aria-hidden="true" tabindex="-1"></a><span class="co"># In den meisten Betrieben liegen die Zahlen in einer Tabellenkalkulation</span></span>
+<span id="cb210-357"><a href="#cb210-357" aria-hidden="true" tabindex="-1"></a><span class="co"># (Kapitel Einfuehrung). Diese beiden Funktionen sind die einzige Stelle im</span></span>
+<span id="cb210-358"><a href="#cb210-358" aria-hidden="true" tabindex="-1"></a><span class="co"># Modul, die das weiss - alles andere arbeitet mit dem Domaenenmodell.</span></span>
+<span id="cb210-359"><a href="#cb210-359" aria-hidden="true" tabindex="-1"></a><span class="co">#</span></span>
+<span id="cb210-360"><a href="#cb210-360" aria-hidden="true" tabindex="-1"></a><span class="co"># pandas und openpyxl werden bewusst erst hier importiert: Wer or_kern nur</span></span>
+<span id="cb210-361"><a href="#cb210-361" aria-hidden="true" tabindex="-1"></a><span class="co"># fuer Statusauswertung und Pruefung benutzt, soll sie nicht installieren</span></span>
+<span id="cb210-362"><a href="#cb210-362" aria-hidden="true" tabindex="-1"></a><span class="co"># muessen.</span></span>
+<span id="cb210-363"><a href="#cb210-363" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb210-364"><a href="#cb210-364" aria-hidden="true" tabindex="-1"></a>STAMMSPALTEN <span class="op">=</span> (<span class="st">&quot;Produkt&quot;</span>, <span class="st">&quot;Deckungsbeitrag&quot;</span>)</span>
+<span id="cb210-365"><a href="#cb210-365" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb210-366"><a href="#cb210-366" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb210-367"><a href="#cb210-367" aria-hidden="true" tabindex="-1"></a><span class="kw">def</span> lade_produktionsproblem(pfad: <span class="bu">str</span>, blatt_produkte: <span class="bu">str</span> <span class="op">=</span> <span class="st">&quot;Produkte&quot;</span>,</span>
+<span id="cb210-368"><a href="#cb210-368" aria-hidden="true" tabindex="-1"></a>                            blatt_kapazitaeten: <span class="bu">str</span> <span class="op">=</span> <span class="st">&quot;Kapazitaeten&quot;</span></span>
+<span id="cb210-369"><a href="#cb210-369" aria-hidden="true" tabindex="-1"></a>                            ) <span class="op">-&gt;</span> Produktionsproblem:</span>
+<span id="cb210-370"><a href="#cb210-370" aria-hidden="true" tabindex="-1"></a>    <span class="co">&quot;&quot;&quot;Liest eine Excel-Mappe und liefert ein geprueftes Domaenenmodell.</span></span>
+<span id="cb210-371"><a href="#cb210-371" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb210-372"><a href="#cb210-372" aria-hidden="true" tabindex="-1"></a><span class="co">    Alle Spalten ausser &#39;Produkt&#39; und &#39;Deckungsbeitrag&#39; gelten als</span></span>
+<span id="cb210-373"><a href="#cb210-373" aria-hidden="true" tabindex="-1"></a><span class="co">    Verbrauchsspalten - eine neue Ressource ist damit eine neue SPALTE in der</span></span>
+<span id="cb210-374"><a href="#cb210-374" aria-hidden="true" tabindex="-1"></a><span class="co">    Mappe und erfordert keine Codeaenderung.</span></span>
+<span id="cb210-375"><a href="#cb210-375" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb210-376"><a href="#cb210-376" aria-hidden="true" tabindex="-1"></a><span class="co">    Die eigentliche Pruefung passiert nicht hier, sondern im Konstruktor von</span></span>
+<span id="cb210-377"><a href="#cb210-377" aria-hidden="true" tabindex="-1"></a><span class="co">    Produktionsproblem. Diese Funktion uebersetzt nur Tabelle in Objekt; was</span></span>
+<span id="cb210-378"><a href="#cb210-378" aria-hidden="true" tabindex="-1"></a><span class="co">    ein gueltiges Problem ist, steht an genau einer Stelle.</span></span>
+<span id="cb210-379"><a href="#cb210-379" aria-hidden="true" tabindex="-1"></a><span class="co">    &quot;&quot;&quot;</span></span>
+<span id="cb210-380"><a href="#cb210-380" aria-hidden="true" tabindex="-1"></a>    <span class="im">import</span> pandas <span class="im">as</span> pd</span>
+<span id="cb210-381"><a href="#cb210-381" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb210-382"><a href="#cb210-382" aria-hidden="true" tabindex="-1"></a>    produkte_tabelle <span class="op">=</span> pd.read_excel(pfad, sheet_name<span class="op">=</span>blatt_produkte)</span>
+<span id="cb210-383"><a href="#cb210-383" aria-hidden="true" tabindex="-1"></a>    kapazitaeten_tabelle <span class="op">=</span> pd.read_excel(pfad, sheet_name<span class="op">=</span>blatt_kapazitaeten)</span>
+<span id="cb210-384"><a href="#cb210-384" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb210-385"><a href="#cb210-385" aria-hidden="true" tabindex="-1"></a>    fehlende <span class="op">=</span> [s <span class="cf">for</span> s <span class="kw">in</span> STAMMSPALTEN <span class="cf">if</span> s <span class="kw">not</span> <span class="kw">in</span> produkte_tabelle.columns]</span>
+<span id="cb210-386"><a href="#cb210-386" aria-hidden="true" tabindex="-1"></a>    <span class="cf">if</span> fehlende:</span>
+<span id="cb210-387"><a href="#cb210-387" aria-hidden="true" tabindex="-1"></a>        <span class="cf">raise</span> <span class="pp">ValueError</span>(<span class="ss">f&quot;Blatt &#39;</span><span class="sc">{</span>blatt_produkte<span class="sc">}</span><span class="ss">&#39;: Spalten fehlen: </span><span class="sc">{</span>fehlende<span class="sc">}</span><span class="ss">&quot;</span>)</span>
+<span id="cb210-388"><a href="#cb210-388" aria-hidden="true" tabindex="-1"></a>    <span class="cf">if</span> produkte_tabelle.isna().<span class="bu">any</span>().<span class="bu">any</span>():</span>
+<span id="cb210-389"><a href="#cb210-389" aria-hidden="true" tabindex="-1"></a>        zeilen <span class="op">=</span> produkte_tabelle[produkte_tabelle.isna().<span class="bu">any</span>(axis<span class="op">=</span><span class="dv">1</span>)].index.tolist()</span>
+<span id="cb210-390"><a href="#cb210-390" aria-hidden="true" tabindex="-1"></a>        <span class="cf">raise</span> <span class="pp">ValueError</span>(<span class="ss">f&quot;Blatt &#39;</span><span class="sc">{</span>blatt_produkte<span class="sc">}</span><span class="ss">&#39;: leere Zellen in Zeile(n) </span><span class="sc">{</span>zeilen<span class="sc">}</span><span class="ss">&quot;</span>)</span>
+<span id="cb210-391"><a href="#cb210-391" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb210-392"><a href="#cb210-392" aria-hidden="true" tabindex="-1"></a>    ressourcen <span class="op">=</span> [s <span class="cf">for</span> s <span class="kw">in</span> produkte_tabelle.columns <span class="cf">if</span> s <span class="kw">not</span> <span class="kw">in</span> STAMMSPALTEN]</span>
+<span id="cb210-393"><a href="#cb210-393" aria-hidden="true" tabindex="-1"></a>    produkte <span class="op">=</span> [</span>
+<span id="cb210-394"><a href="#cb210-394" aria-hidden="true" tabindex="-1"></a>        Produkt(name<span class="op">=</span><span class="bu">str</span>(zeile.Produkt),</span>
+<span id="cb210-395"><a href="#cb210-395" aria-hidden="true" tabindex="-1"></a>                deckungsbeitrag<span class="op">=</span><span class="bu">float</span>(zeile.Deckungsbeitrag),</span>
+<span id="cb210-396"><a href="#cb210-396" aria-hidden="true" tabindex="-1"></a>                verbrauch<span class="op">=</span>{r: <span class="bu">float</span>(<span class="bu">getattr</span>(zeile, r)) <span class="cf">for</span> r <span class="kw">in</span> ressourcen})</span>
+<span id="cb210-397"><a href="#cb210-397" aria-hidden="true" tabindex="-1"></a>        <span class="cf">for</span> zeile <span class="kw">in</span> produkte_tabelle.itertuples()</span>
+<span id="cb210-398"><a href="#cb210-398" aria-hidden="true" tabindex="-1"></a>    ]</span>
+<span id="cb210-399"><a href="#cb210-399" aria-hidden="true" tabindex="-1"></a>    kapazitaeten <span class="op">=</span> {<span class="bu">str</span>(z.Ressource): <span class="bu">float</span>(z.Verfuegbar)</span>
+<span id="cb210-400"><a href="#cb210-400" aria-hidden="true" tabindex="-1"></a>                    <span class="cf">for</span> z <span class="kw">in</span> kapazitaeten_tabelle.itertuples()}</span>
+<span id="cb210-401"><a href="#cb210-401" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb210-402"><a href="#cb210-402" aria-hidden="true" tabindex="-1"></a>    <span class="cf">return</span> Produktionsproblem(produkte<span class="op">=</span>produkte, kapazitaeten<span class="op">=</span>kapazitaeten)</span>
+<span id="cb210-403"><a href="#cb210-403" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb210-404"><a href="#cb210-404" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb210-405"><a href="#cb210-405" aria-hidden="true" tabindex="-1"></a><span class="kw">def</span> schreibe_ergebnis(pfad: <span class="bu">str</span>, problem: Produktionsproblem,</span>
+<span id="cb210-406"><a href="#cb210-406" aria-hidden="true" tabindex="-1"></a>                      loesung: Loesung) <span class="op">-&gt;</span> <span class="va">None</span>:</span>
+<span id="cb210-407"><a href="#cb210-407" aria-hidden="true" tabindex="-1"></a>    <span class="co">&quot;&quot;&quot;Schreibt Plan und Kennzahlen als zwei Blaetter zurueck nach Excel.</span></span>
+<span id="cb210-408"><a href="#cb210-408" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb210-409"><a href="#cb210-409" aria-hidden="true" tabindex="-1"></a><span class="co">    Die Fachabteilung bekommt das Ergebnis im Format, das sie ohnehin benutzt.</span></span>
+<span id="cb210-410"><a href="#cb210-410" aria-hidden="true" tabindex="-1"></a><span class="co">    Akzeptanz entscheidet ueber Projekterfolg (Kapitel Praxisfallen).</span></span>
+<span id="cb210-411"><a href="#cb210-411" aria-hidden="true" tabindex="-1"></a><span class="co">    &quot;&quot;&quot;</span></span>
+<span id="cb210-412"><a href="#cb210-412" aria-hidden="true" tabindex="-1"></a>    <span class="im">import</span> pandas <span class="im">as</span> pd</span>
+<span id="cb210-413"><a href="#cb210-413" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb210-414"><a href="#cb210-414" aria-hidden="true" tabindex="-1"></a>    <span class="cf">if</span> <span class="kw">not</span> loesung.status.brauchbar:</span>
+<span id="cb210-415"><a href="#cb210-415" aria-hidden="true" tabindex="-1"></a>        <span class="cf">raise</span> <span class="pp">ValueError</span>(<span class="ss">f&quot;Nichts zu schreiben - Status: </span><span class="sc">{</span>loesung<span class="sc">.</span>status<span class="sc">.</span>value<span class="sc">}</span><span class="ss">&quot;</span>)</span>
+<span id="cb210-416"><a href="#cb210-416" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb210-417"><a href="#cb210-417" aria-hidden="true" tabindex="-1"></a>    mengen <span class="op">=</span> np.array([loesung.werte[p.name] <span class="cf">for</span> p <span class="kw">in</span> problem.produkte])</span>
+<span id="cb210-418"><a href="#cb210-418" aria-hidden="true" tabindex="-1"></a>    plan <span class="op">=</span> pd.DataFrame({</span>
+<span id="cb210-419"><a href="#cb210-419" aria-hidden="true" tabindex="-1"></a>        <span class="st">&quot;Produkt&quot;</span>: [p.name <span class="cf">for</span> p <span class="kw">in</span> problem.produkte],</span>
+<span id="cb210-420"><a href="#cb210-420" aria-hidden="true" tabindex="-1"></a>        <span class="st">&quot;Menge&quot;</span>: mengen,</span>
+<span id="cb210-421"><a href="#cb210-421" aria-hidden="true" tabindex="-1"></a>        <span class="st">&quot;Deckungsbeitrag&quot;</span>: mengen <span class="op">*</span> problem.deckungsbeitragsvektor(),</span>
+<span id="cb210-422"><a href="#cb210-422" aria-hidden="true" tabindex="-1"></a>    })</span>
+<span id="cb210-423"><a href="#cb210-423" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb210-424"><a href="#cb210-424" aria-hidden="true" tabindex="-1"></a>    verbrauch <span class="op">=</span> problem.verbrauchsmatrix() <span class="op">@</span> mengen</span>
+<span id="cb210-425"><a href="#cb210-425" aria-hidden="true" tabindex="-1"></a>    kennzahlen: <span class="bu">dict</span>[<span class="bu">str</span>, <span class="bu">float</span> <span class="op">|</span> <span class="bu">str</span>] <span class="op">=</span> {</span>
+<span id="cb210-426"><a href="#cb210-426" aria-hidden="true" tabindex="-1"></a>        <span class="st">&quot;Status&quot;</span>: loesung.status.value,</span>
+<span id="cb210-427"><a href="#cb210-427" aria-hidden="true" tabindex="-1"></a>        <span class="st">&quot;Gesamtdeckungsbeitrag&quot;</span>: loesung.zielwert <span class="kw">or</span> <span class="fl">0.0</span>,</span>
+<span id="cb210-428"><a href="#cb210-428" aria-hidden="true" tabindex="-1"></a>    }</span>
+<span id="cb210-429"><a href="#cb210-429" aria-hidden="true" tabindex="-1"></a>    <span class="cf">for</span> ressource, ist, grenze <span class="kw">in</span> <span class="bu">zip</span>(problem.ressourcen, verbrauch,</span>
+<span id="cb210-430"><a href="#cb210-430" aria-hidden="true" tabindex="-1"></a>                                      problem.kapazitaetsvektor()):</span>
+<span id="cb210-431"><a href="#cb210-431" aria-hidden="true" tabindex="-1"></a>        kennzahlen[<span class="ss">f&quot;</span><span class="sc">{</span>ressource<span class="sc">}</span><span class="ss">: Verbrauch&quot;</span>] <span class="op">=</span> <span class="bu">float</span>(ist)</span>
+<span id="cb210-432"><a href="#cb210-432" aria-hidden="true" tabindex="-1"></a>        kennzahlen[<span class="ss">f&quot;</span><span class="sc">{</span>ressource<span class="sc">}</span><span class="ss">: Auslastung %&quot;</span>] <span class="op">=</span> <span class="bu">float</span>(<span class="fl">100.0</span> <span class="op">*</span> ist <span class="op">/</span> grenze)</span>
+<span id="cb210-433"><a href="#cb210-433" aria-hidden="true" tabindex="-1"></a>        <span class="cf">if</span> ressource <span class="kw">in</span> loesung.schattenpreise:</span>
+<span id="cb210-434"><a href="#cb210-434" aria-hidden="true" tabindex="-1"></a>            kennzahlen[<span class="ss">f&quot;</span><span class="sc">{</span>ressource<span class="sc">}</span><span class="ss">: Schattenpreis&quot;</span>] <span class="op">=</span> <span class="op">\</span></span>
+<span id="cb210-435"><a href="#cb210-435" aria-hidden="true" tabindex="-1"></a>                loesung.schattenpreise[ressource]</span>
+<span id="cb210-436"><a href="#cb210-436" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb210-437"><a href="#cb210-437" aria-hidden="true" tabindex="-1"></a>    kennzahlen_tabelle <span class="op">=</span> pd.DataFrame({</span>
+<span id="cb210-438"><a href="#cb210-438" aria-hidden="true" tabindex="-1"></a>        <span class="st">&quot;Kennzahl&quot;</span>: <span class="bu">list</span>(kennzahlen),</span>
+<span id="cb210-439"><a href="#cb210-439" aria-hidden="true" tabindex="-1"></a>        <span class="st">&quot;Wert&quot;</span>: [<span class="bu">round</span>(w, <span class="dv">2</span>) <span class="cf">if</span> <span class="bu">isinstance</span>(w, <span class="bu">float</span>) <span class="cf">else</span> w</span>
+<span id="cb210-440"><a href="#cb210-440" aria-hidden="true" tabindex="-1"></a>                 <span class="cf">for</span> w <span class="kw">in</span> kennzahlen.values()],</span>
+<span id="cb210-441"><a href="#cb210-441" aria-hidden="true" tabindex="-1"></a>    })</span>
+<span id="cb210-442"><a href="#cb210-442" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb210-443"><a href="#cb210-443" aria-hidden="true" tabindex="-1"></a>    <span class="cf">with</span> pd.ExcelWriter(pfad, engine<span class="op">=</span><span class="st">&quot;openpyxl&quot;</span>) <span class="im">as</span> mappe:</span>
+<span id="cb210-444"><a href="#cb210-444" aria-hidden="true" tabindex="-1"></a>        plan.<span class="bu">round</span>(<span class="dv">2</span>).to_excel(mappe, sheet_name<span class="op">=</span><span class="st">&quot;Plan&quot;</span>, index<span class="op">=</span><span class="va">False</span>)</span>
+<span id="cb210-445"><a href="#cb210-445" aria-hidden="true" tabindex="-1"></a>        kennzahlen_tabelle.to_excel(mappe, sheet_name<span class="op">=</span><span class="st">&quot;Kennzahlen&quot;</span>, index<span class="op">=</span><span class="va">False</span>)</span>
+<span id="cb210-446"><a href="#cb210-446" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb210-447"><a href="#cb210-447" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb210-448"><a href="#cb210-448" aria-hidden="true" tabindex="-1"></a><span class="cf">if</span> <span class="va">__name__</span> <span class="op">==</span> <span class="st">&quot;__main__&quot;</span>:</span>
+<span id="cb210-449"><a href="#cb210-449" aria-hidden="true" tabindex="-1"></a>    <span class="co"># Die Schreinerei aus Kapitel Einfuehrung - jetzt als Domaenenmodell.</span></span>
+<span id="cb210-450"><a href="#cb210-450" aria-hidden="true" tabindex="-1"></a>    schreinerei <span class="op">=</span> Produktionsproblem(</span>
+<span id="cb210-451"><a href="#cb210-451" aria-hidden="true" tabindex="-1"></a>        produkte<span class="op">=</span>[</span>
+<span id="cb210-452"><a href="#cb210-452" aria-hidden="true" tabindex="-1"></a>            Produkt(name<span class="op">=</span><span class="st">&quot;Tisch&quot;</span>, deckungsbeitrag<span class="op">=</span><span class="fl">240.0</span>,</span>
+<span id="cb210-453"><a href="#cb210-453" aria-hidden="true" tabindex="-1"></a>                    verbrauch<span class="op">=</span>{<span class="st">&quot;Montagestunden&quot;</span>: <span class="fl">3.0</span>, <span class="st">&quot;Plattenmaterial&quot;</span>: <span class="fl">6.0</span>}),</span>
+<span id="cb210-454"><a href="#cb210-454" aria-hidden="true" tabindex="-1"></a>            Produkt(name<span class="op">=</span><span class="st">&quot;Stuhl&quot;</span>, deckungsbeitrag<span class="op">=</span><span class="fl">60.0</span>,</span>
+<span id="cb210-455"><a href="#cb210-455" aria-hidden="true" tabindex="-1"></a>                    verbrauch<span class="op">=</span>{<span class="st">&quot;Montagestunden&quot;</span>: <span class="fl">1.0</span>, <span class="st">&quot;Plattenmaterial&quot;</span>: <span class="fl">1.0</span>}),</span>
+<span id="cb210-456"><a href="#cb210-456" aria-hidden="true" tabindex="-1"></a>        ],</span>
+<span id="cb210-457"><a href="#cb210-457" aria-hidden="true" tabindex="-1"></a>        kapazitaeten<span class="op">=</span>{<span class="st">&quot;Montagestunden&quot;</span>: <span class="fl">150.0</span>, <span class="st">&quot;Plattenmaterial&quot;</span>: <span class="fl">240.0</span>},</span>
+<span id="cb210-458"><a href="#cb210-458" aria-hidden="true" tabindex="-1"></a>    )</span>
+<span id="cb210-459"><a href="#cb210-459" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb210-460"><a href="#cb210-460" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;=&quot;</span> <span class="op">*</span> <span class="dv">78</span>)</span>
+<span id="cb210-461"><a href="#cb210-461" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;  DERSELBE FALL, ZWEI SOLVER, EIN AUSWERTUNGSCODE&quot;</span>)</span>
+<span id="cb210-462"><a href="#cb210-462" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;=&quot;</span> <span class="op">*</span> <span class="dv">78</span>)</span>
+<span id="cb210-463"><a href="#cb210-463" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb210-464"><a href="#cb210-464" aria-hidden="true" tabindex="-1"></a>    <span class="cf">for</span> name, bauer <span class="kw">in</span> [(<span class="st">&quot;OR-Tools GLOP&quot;</span>, loese_mit_glop),</span>
+<span id="cb210-465"><a href="#cb210-465" aria-hidden="true" tabindex="-1"></a>                        (<span class="st">&quot;scipy / HiGHS&quot;</span>, loese_mit_scipy)]:</span>
+<span id="cb210-466"><a href="#cb210-466" aria-hidden="true" tabindex="-1"></a>        loesung <span class="op">=</span> bauer(schreinerei)</span>
+<span id="cb210-467"><a href="#cb210-467" aria-hidden="true" tabindex="-1"></a>        beanstandungen <span class="op">=</span> pruefe_loesung(schreinerei, loesung)</span>
+<span id="cb210-468"><a href="#cb210-468" aria-hidden="true" tabindex="-1"></a>        <span class="bu">print</span>(<span class="ss">f&quot;</span><span class="ch">\n</span><span class="sc">{</span>name<span class="sc">}</span><span class="ss">&quot;</span>)</span>
+<span id="cb210-469"><a href="#cb210-469" aria-hidden="true" tabindex="-1"></a>        <span class="bu">print</span>(<span class="ss">f&quot;  </span><span class="sc">{</span>loesung<span class="sc">.</span>als_bericht()<span class="sc">}</span><span class="ss">&quot;</span>)</span>
+<span id="cb210-470"><a href="#cb210-470" aria-hidden="true" tabindex="-1"></a>        <span class="cf">for</span> produkt, menge <span class="kw">in</span> loesung.werte.items():</span>
+<span id="cb210-471"><a href="#cb210-471" aria-hidden="true" tabindex="-1"></a>            <span class="bu">print</span>(<span class="ss">f&quot;    </span><span class="sc">{</span>produkt<span class="sc">:&lt;10}</span><span class="ss"> </span><span class="sc">{</span>menge<span class="sc">:8.2f}</span><span class="ss">&quot;</span>)</span>
+<span id="cb210-472"><a href="#cb210-472" aria-hidden="true" tabindex="-1"></a>        <span class="bu">print</span>(<span class="ss">f&quot;  Abnahmepruefung: &quot;</span></span>
+<span id="cb210-473"><a href="#cb210-473" aria-hidden="true" tabindex="-1"></a>              <span class="ss">f&quot;</span><span class="sc">{</span><span class="st">&#39;bestanden&#39;</span> <span class="cf">if</span> <span class="kw">not</span> beanstandungen <span class="cf">else</span> beanstandungen<span class="sc">}</span><span class="ss">&quot;</span>)</span>
+<span id="cb210-474"><a href="#cb210-474" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb210-475"><a href="#cb210-475" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;</span><span class="ch">\n</span><span class="st">&quot;</span> <span class="op">+</span> <span class="st">&quot;=&quot;</span> <span class="op">*</span> <span class="dv">78</span>)</span>
+<span id="cb210-476"><a href="#cb210-476" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;  WAS DIE PRUEFUNGEN ABFANGEN&quot;</span>)</span>
+<span id="cb210-477"><a href="#cb210-477" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;=&quot;</span> <span class="op">*</span> <span class="dv">78</span>)</span>
+<span id="cb210-478"><a href="#cb210-478" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb210-479"><a href="#cb210-479" aria-hidden="true" tabindex="-1"></a>    faelle <span class="op">=</span> [</span>
+<span id="cb210-480"><a href="#cb210-480" aria-hidden="true" tabindex="-1"></a>        (<span class="st">&quot;Kapazitaet 0&quot;</span>, <span class="bu">dict</span>(</span>
+<span id="cb210-481"><a href="#cb210-481" aria-hidden="true" tabindex="-1"></a>            produkte<span class="op">=</span>schreinerei.produkte,</span>
+<span id="cb210-482"><a href="#cb210-482" aria-hidden="true" tabindex="-1"></a>            kapazitaeten<span class="op">=</span>{<span class="st">&quot;Montagestunden&quot;</span>: <span class="fl">0.0</span>, <span class="st">&quot;Plattenmaterial&quot;</span>: <span class="fl">240.0</span>})),</span>
+<span id="cb210-483"><a href="#cb210-483" aria-hidden="true" tabindex="-1"></a>        (<span class="st">&quot;Ressource ohne Kapazitaet&quot;</span>, <span class="bu">dict</span>(</span>
+<span id="cb210-484"><a href="#cb210-484" aria-hidden="true" tabindex="-1"></a>            produkte<span class="op">=</span>[Produkt(name<span class="op">=</span><span class="st">&quot;Regal&quot;</span>, deckungsbeitrag<span class="op">=</span><span class="fl">130.0</span>,</span>
+<span id="cb210-485"><a href="#cb210-485" aria-hidden="true" tabindex="-1"></a>                              verbrauch<span class="op">=</span>{<span class="st">&quot;Lackieren&quot;</span>: <span class="fl">2.0</span>})],</span>
+<span id="cb210-486"><a href="#cb210-486" aria-hidden="true" tabindex="-1"></a>            kapazitaeten<span class="op">=</span>{<span class="st">&quot;Montagestunden&quot;</span>: <span class="fl">150.0</span>})),</span>
+<span id="cb210-487"><a href="#cb210-487" aria-hidden="true" tabindex="-1"></a>        (<span class="st">&quot;doppelter Produktname&quot;</span>, <span class="bu">dict</span>(</span>
+<span id="cb210-488"><a href="#cb210-488" aria-hidden="true" tabindex="-1"></a>            produkte<span class="op">=</span>[schreinerei.produkte[<span class="dv">0</span>], schreinerei.produkte[<span class="dv">0</span>]],</span>
+<span id="cb210-489"><a href="#cb210-489" aria-hidden="true" tabindex="-1"></a>            kapazitaeten<span class="op">=</span>schreinerei.kapazitaeten)),</span>
+<span id="cb210-490"><a href="#cb210-490" aria-hidden="true" tabindex="-1"></a>    ]</span>
+<span id="cb210-491"><a href="#cb210-491" aria-hidden="true" tabindex="-1"></a>    <span class="cf">for</span> beschreibung, daten <span class="kw">in</span> faelle:</span>
+<span id="cb210-492"><a href="#cb210-492" aria-hidden="true" tabindex="-1"></a>        <span class="cf">try</span>:</span>
+<span id="cb210-493"><a href="#cb210-493" aria-hidden="true" tabindex="-1"></a>            Produktionsproblem(<span class="op">**</span>daten)</span>
+<span id="cb210-494"><a href="#cb210-494" aria-hidden="true" tabindex="-1"></a>            <span class="bu">print</span>(<span class="ss">f&quot;  </span><span class="sc">{</span>beschreibung<span class="sc">:&lt;28}</span><span class="ss"> NICHT erkannt (!)&quot;</span>)</span>
+<span id="cb210-495"><a href="#cb210-495" aria-hidden="true" tabindex="-1"></a>        <span class="cf">except</span> <span class="pp">Exception</span> <span class="im">as</span> fehler:</span>
+<span id="cb210-496"><a href="#cb210-496" aria-hidden="true" tabindex="-1"></a>            meldung <span class="op">=</span> <span class="bu">str</span>(fehler).splitlines()</span>
+<span id="cb210-497"><a href="#cb210-497" aria-hidden="true" tabindex="-1"></a>            kern <span class="op">=</span> <span class="bu">next</span>((z.strip() <span class="cf">for</span> z <span class="kw">in</span> meldung</span>
+<span id="cb210-498"><a href="#cb210-498" aria-hidden="true" tabindex="-1"></a>                         <span class="cf">if</span> <span class="st">&quot;Value error&quot;</span> <span class="kw">in</span> z <span class="kw">or</span> <span class="st">&quot;greater than&quot;</span> <span class="kw">in</span> z), meldung[<span class="op">-</span><span class="dv">1</span>])</span>
+<span id="cb210-499"><a href="#cb210-499" aria-hidden="true" tabindex="-1"></a>            <span class="bu">print</span>(<span class="ss">f&quot;  </span><span class="sc">{</span>beschreibung<span class="sc">:&lt;28}</span><span class="ss"> abgefangen: </span><span class="sc">{</span>kern[:<span class="dv">44</span>]<span class="sc">}</span><span class="ss">&quot;</span>)</span>
+<span id="cb210-500"><a href="#cb210-500" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb210-501"><a href="#cb210-501" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;</span><span class="ch">\n</span><span class="st">Alle drei scheitern beim EINLESEN - nicht erst beim Loesen und&quot;</span>)</span>
+<span id="cb210-502"><a href="#cb210-502" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;schon gar nicht erst im Bericht. Das ist der ganze Zweck der&quot;</span>)</span>
+<span id="cb210-503"><a href="#cb210-503" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;Domaenenschicht.&quot;</span>)</span>
+<span id="cb210-504"><a href="#cb210-504" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;=&quot;</span> <span class="op">*</span> <span class="dv">78</span>)</span></code></pre></div>
 <p><strong>Erwartete Ausgabe:</strong></p>
 <pre><code>==============================================================================
   DERSELBE FALL, ZWEI SOLVER, EIN AUSWERTUNGSCODE
@@ -25760,7 +27268,7 @@ Domaenenschicht.
 <tr class="odd">
 <td><code>SolverStatus.modellfehler</code></td>
 <td>trennt Modell- von Zeitproblemen</td>
-<td>Genau die Unterscheidung, die <a href="#sec:cpsat-statusfaelle">Abschnitt 7.7</a> als häufigste Verwechslung benennt.</td>
+<td>Genau die Unterscheidung, die <a href="#sec:cpsat-statusfaelle">Abschnitt 7.8</a> als häufigste Verwechslung benennt.</td>
 </tr>
 <tr class="even">
 <td><code>model_validator(mode="after")</code></td>
@@ -25799,7 +27307,7 @@ Domaenenschicht.
 <p><strong>🎯 Merksatz</strong> Ein Fehler, der beim Einlesen auffliegt, kostet Minuten. Derselbe Fehler, der erst im Bericht auffällt, kostet Tage — und derselbe Fehler, der <strong>nie</strong> auffällt, kostet am meisten. Validierung ist deshalb keine Fleißarbeit, sondern die günstigste Stelle im ganzen Ablauf.</p>
 </blockquote>
 <hr />
-<h2 id="sec:praxisfallen-solverwechsel">22.6 Der Solverwechsel in der Praxis</h2>
+<h2 id="sec:praxisfallen-solverwechsel">22.7 Der Solverwechsel in der Praxis</h2>
 <p>Der vorige Abschnitt endet mit einer Behauptung: Ein Solverwechsel betreffe genau <strong>einen</strong> Baustein. Das ist die Art Satz, die in jedem Architekturvortrag vorkommt und die man deshalb nicht glauben sollte, bevor sie jemand vorgeführt hat.</p>
 <p>Also führen wir sie vor — und zwar am unbequemsten Paar, das dieses Buch zu bieten hat: <strong>CP-SAT gegen HiGHS</strong>. Die beiden sind grundverschieden. CP-SAT ist ein Constraint-Programming-Solver, der ausschließlich ganzzahlig rechnet und Restriktionen als Ausdrücke entgegennimmt. HiGHS ist ein klassischer Branch-and-Bound-Löser, der eine Koeffizientenmatrix erwartet. Und sie lassen sich nicht einmal gemeinsam importieren (<a href="#kap-oekosystem">Kapitel 3</a>).</p>
 <p><strong>Die Aufgabe</strong> ist eine kapazitierte Standortplanung: Aus sechs möglichen Lagern sind diejenigen zu eröffnen, mit denen zwölf Kunden am günstigsten beliefert werden. Jeder Kunde wird von genau einem Lager bedient, jedes eröffnete Lager kostet eine Fixgebühr, und die Kapazität reicht je Lager für 174 der insgesamt 387 Paletten — es müssen also mindestens drei Lager öffnen.</p>
@@ -25844,330 +27352,334 @@ Domaenenschicht.
 <blockquote>
 <p><strong>📎 Warum zwei Prozesse?</strong></p>
 <p><code>ortools</code> und <code>highspy</code> bringen beide eine eigene HiGHS-Kopie mit und kollidieren beim gemeinsamen Import (<a href="#kap-oekosystem">Kapitel 3</a>). Das Programm startet sich deshalb für jeden Solver selbst noch einmal als Kindprozess und lässt sich das Ergebnis als <strong>JSON</strong> zurückgeben:</p>
-<div class="sourceCode" id="cb208"><pre class="sourceCode python"><code class="sourceCode python"><span id="cb208-1"><a href="#cb208-1" aria-hidden="true" tabindex="-1"></a><span class="bu">print</span>(MODELLBAUER[sys.argv[<span class="dv">1</span>]](problem).model_dump_json())   <span class="co"># im Kindprozess</span></span>
-<span id="cb208-2"><a href="#cb208-2" aria-hidden="true" tabindex="-1"></a>Loesung.model_validate_json(...)                             <span class="co"># im Hauptprozess</span></span></code></pre></div>
+<div class="sourceCode" id="cb212"><pre class="sourceCode python"><code class="sourceCode python"><span id="cb212-1"><a href="#cb212-1" aria-hidden="true" tabindex="-1"></a><span class="bu">print</span>(MODELLBAUER[sys.argv[<span class="dv">1</span>]](problem).model_dump_json())   <span class="co"># im Kindprozess</span></span>
+<span id="cb212-2"><a href="#cb212-2" aria-hidden="true" tabindex="-1"></a>Loesung.model_validate_json(...)                             <span class="co"># im Hauptprozess</span></span></code></pre></div>
 <p>Das ist der zweite, weniger offensichtliche Ertrag des DTOs: Ein Lösungsobjekt ohne Solverbezug ist nicht nur eine Sprachregelung, sondern ein <strong>Datenformat</strong>. Es überlebt eine Prozessgrenze, passt in eine Warteschlange und lässt sich protokollieren. Ein <code>pywraplp.Solver</code>-Objekt kann das alles nicht.</p>
 </blockquote>
-<div class="sourceCode" id="cb209"><pre class="sourceCode python"><code class="sourceCode python"><span id="cb209-1"><a href="#cb209-1" aria-hidden="true" tabindex="-1"></a><span class="co">#!/usr/bin/env python3</span></span>
-<span id="cb209-2"><a href="#cb209-2" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb209-3"><a href="#cb209-3" aria-hidden="true" tabindex="-1"></a><span class="co"># Solverwechsel_CPSAT_HiGHS.py</span></span>
-<span id="cb209-4"><a href="#cb209-4" aria-hidden="true" tabindex="-1"></a><span class="co">&quot;&quot;&quot;</span></span>
-<span id="cb209-5"><a href="#cb209-5" aria-hidden="true" tabindex="-1"></a><span class="co">Kapitel Praxisfallen: Denselben Fall einmal mit CP-SAT und einmal mit HiGHS rechnen.</span></span>
-<span id="cb209-6"><a href="#cb209-6" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb209-7"><a href="#cb209-7" aria-hidden="true" tabindex="-1"></a><span class="co">Die Trennung aus or_kern.py behauptet, ein Solverwechsel koste genau EINEN</span></span>
-<span id="cb209-8"><a href="#cb209-8" aria-hidden="true" tabindex="-1"></a><span class="co">Baustein. Dieses Programm loest diese Behauptung ein. Aufgabe ist eine</span></span>
-<span id="cb209-9"><a href="#cb209-9" aria-hidden="true" tabindex="-1"></a><span class="co">Standortplanung: Welche Lager oeffnen wir, und wer beliefert welchen Kunden?</span></span>
-<span id="cb209-10"><a href="#cb209-10" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb209-11"><a href="#cb209-11" aria-hidden="true" tabindex="-1"></a><span class="co">    Standortproblem  (Pydantic, geprueft)   &lt;- gemeinsam</span></span>
-<span id="cb209-12"><a href="#cb209-12" aria-hidden="true" tabindex="-1"></a><span class="co">        baue_und_loese_mit_cpsat()          &lt;- der EINE Baustein</span></span>
-<span id="cb209-13"><a href="#cb209-13" aria-hidden="true" tabindex="-1"></a><span class="co">        baue_und_loese_mit_highs()          &lt;- ... in zwei Ausfuehrungen</span></span>
-<span id="cb209-14"><a href="#cb209-14" aria-hidden="true" tabindex="-1"></a><span class="co">    Loesung          (DTO)                  &lt;- gemeinsam</span></span>
-<span id="cb209-15"><a href="#cb209-15" aria-hidden="true" tabindex="-1"></a><span class="co">    pruefe_zuordnung()                      &lt;- gemeinsam</span></span>
-<span id="cb209-16"><a href="#cb209-16" aria-hidden="true" tabindex="-1"></a><span class="co">    berichte()                              &lt;- gemeinsam</span></span>
-<span id="cb209-17"><a href="#cb209-17" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb209-18"><a href="#cb209-18" aria-hidden="true" tabindex="-1"></a><span class="co">Die beiden Modellbauer sind 39 und 52 Zeilen lang - sie sind der gesamte</span></span>
-<span id="cb209-19"><a href="#cb209-19" aria-hidden="true" tabindex="-1"></a><span class="co">solverabhaengige Teil des Programms. Alles andere wird zweimal benutzt und</span></span>
-<span id="cb209-20"><a href="#cb209-20" aria-hidden="true" tabindex="-1"></a><span class="co">einmal geschrieben.</span></span>
-<span id="cb209-21"><a href="#cb209-21" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb209-22"><a href="#cb209-22" aria-hidden="true" tabindex="-1"></a><span class="co">WARUM ZWEI PROZESSE? ortools und highspy bringen beide eine eigene</span></span>
-<span id="cb209-23"><a href="#cb209-23" aria-hidden="true" tabindex="-1"></a><span class="co">HiGHS-Kopie mit und lassen sich auf vielen Systemen nicht gemeinsam</span></span>
-<span id="cb209-24"><a href="#cb209-24" aria-hidden="true" tabindex="-1"></a><span class="co">importieren (Kapitel Oekosystem). Das Hauptprogramm startet deshalb fuer jeden</span></span>
-<span id="cb209-25"><a href="#cb209-25" aria-hidden="true" tabindex="-1"></a><span class="co">Solver einen eigenen Python-Prozess und laesst sich die Loesung als JSON</span></span>
-<span id="cb209-26"><a href="#cb209-26" aria-hidden="true" tabindex="-1"></a><span class="co">zurueckgeben - das DTO ist nicht nur eine Sprachregelung, sondern ein</span></span>
-<span id="cb209-27"><a href="#cb209-27" aria-hidden="true" tabindex="-1"></a><span class="co">Datenformat, das eine Prozessgrenze ueberlebt.</span></span>
-<span id="cb209-28"><a href="#cb209-28" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb209-29"><a href="#cb209-29" aria-hidden="true" tabindex="-1"></a><span class="co">Aufruf:</span></span>
-<span id="cb209-30"><a href="#cb209-30" aria-hidden="true" tabindex="-1"></a><span class="co">    python3 Solverwechsel_CPSAT_HiGHS.py            # beide, mit Vergleich</span></span>
-<span id="cb209-31"><a href="#cb209-31" aria-hidden="true" tabindex="-1"></a><span class="co">    python3 Solverwechsel_CPSAT_HiGHS.py cpsat      # nur der Kindprozess</span></span>
-<span id="cb209-32"><a href="#cb209-32" aria-hidden="true" tabindex="-1"></a><span class="co">    python3 Solverwechsel_CPSAT_HiGHS.py highs</span></span>
-<span id="cb209-33"><a href="#cb209-33" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb209-34"><a href="#cb209-34" aria-hidden="true" tabindex="-1"></a><span class="co">Benoetigt: numpy, pydantic, ortools, highspy (jeweils im eigenen Prozess)</span></span>
-<span id="cb209-35"><a href="#cb209-35" aria-hidden="true" tabindex="-1"></a><span class="co">&quot;&quot;&quot;</span></span>
-<span id="cb209-36"><a href="#cb209-36" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb209-37"><a href="#cb209-37" aria-hidden="true" tabindex="-1"></a><span class="im">from</span> __future__ <span class="im">import</span> annotations</span>
-<span id="cb209-38"><a href="#cb209-38" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb209-39"><a href="#cb209-39" aria-hidden="true" tabindex="-1"></a><span class="im">import</span> subprocess</span>
-<span id="cb209-40"><a href="#cb209-40" aria-hidden="true" tabindex="-1"></a><span class="im">import</span> sys</span>
-<span id="cb209-41"><a href="#cb209-41" aria-hidden="true" tabindex="-1"></a><span class="im">import</span> time</span>
-<span id="cb209-42"><a href="#cb209-42" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb209-43"><a href="#cb209-43" aria-hidden="true" tabindex="-1"></a><span class="im">import</span> numpy <span class="im">as</span> np</span>
-<span id="cb209-44"><a href="#cb209-44" aria-hidden="true" tabindex="-1"></a><span class="im">from</span> pydantic <span class="im">import</span> BaseModel, Field, model_validator</span>
-<span id="cb209-45"><a href="#cb209-45" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb209-46"><a href="#cb209-46" aria-hidden="true" tabindex="-1"></a><span class="im">from</span> or_kern <span class="im">import</span> Loesung, SolverStatus, status_von_cpsat, status_von_highs</span>
-<span id="cb209-47"><a href="#cb209-47" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb209-48"><a href="#cb209-48" aria-hidden="true" tabindex="-1"></a>ZEITLIMIT <span class="op">=</span> <span class="fl">30.0</span></span>
-<span id="cb209-49"><a href="#cb209-49" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb209-50"><a href="#cb209-50" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb209-51"><a href="#cb209-51" aria-hidden="true" tabindex="-1"></a><span class="co"># --- 1. Domaenenmodell: dieselben Fakten fuer beide Solver -------------------</span></span>
-<span id="cb209-52"><a href="#cb209-52" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb209-53"><a href="#cb209-53" aria-hidden="true" tabindex="-1"></a><span class="kw">class</span> Standortproblem(BaseModel):</span>
-<span id="cb209-54"><a href="#cb209-54" aria-hidden="true" tabindex="-1"></a>    <span class="co">&quot;&quot;&quot;Kapazitierte Standortplanung mit Einzelbelieferung.</span></span>
-<span id="cb209-55"><a href="#cb209-55" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb209-56"><a href="#cb209-56" aria-hidden="true" tabindex="-1"></a><span class="co">    Nach dem Muster von Produktionsproblem in or_kern.py: Die Pruefungen</span></span>
-<span id="cb209-57"><a href="#cb209-57" aria-hidden="true" tabindex="-1"></a><span class="co">    stehen im Konstruktor, nicht im Solvercode - sie gelten damit fuer beide</span></span>
-<span id="cb209-58"><a href="#cb209-58" aria-hidden="true" tabindex="-1"></a><span class="co">    Solver, und sie schlagen beim Einlesen zu.</span></span>
-<span id="cb209-59"><a href="#cb209-59" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb209-60"><a href="#cb209-60" aria-hidden="true" tabindex="-1"></a><span class="co">    Alle Kosten sind ganzzahlig (Euro). Das ist keine Bequemlichkeit, sondern</span></span>
-<span id="cb209-61"><a href="#cb209-61" aria-hidden="true" tabindex="-1"></a><span class="co">    Voraussetzung: CP-SAT rechnet ausschliesslich ganzzahlig.</span></span>
-<span id="cb209-62"><a href="#cb209-62" aria-hidden="true" tabindex="-1"></a><span class="co">    &quot;&quot;&quot;</span></span>
-<span id="cb209-63"><a href="#cb209-63" aria-hidden="true" tabindex="-1"></a>    lager: <span class="bu">list</span>[<span class="bu">str</span>] <span class="op">=</span> Field(min_length<span class="op">=</span><span class="dv">1</span>)</span>
-<span id="cb209-64"><a href="#cb209-64" aria-hidden="true" tabindex="-1"></a>    kunden: <span class="bu">list</span>[<span class="bu">str</span>] <span class="op">=</span> Field(min_length<span class="op">=</span><span class="dv">1</span>)</span>
-<span id="cb209-65"><a href="#cb209-65" aria-hidden="true" tabindex="-1"></a>    fixkosten: <span class="bu">list</span>[<span class="bu">int</span>]        <span class="co"># je Lager, faellt bei Eroeffnung an</span></span>
-<span id="cb209-66"><a href="#cb209-66" aria-hidden="true" tabindex="-1"></a>    kapazitaet: <span class="bu">list</span>[<span class="bu">int</span>]       <span class="co"># je Lager, in Paletten</span></span>
-<span id="cb209-67"><a href="#cb209-67" aria-hidden="true" tabindex="-1"></a>    bedarf: <span class="bu">list</span>[<span class="bu">int</span>]           <span class="co"># je Kunde, in Paletten</span></span>
-<span id="cb209-68"><a href="#cb209-68" aria-hidden="true" tabindex="-1"></a>    transport: <span class="bu">list</span>[<span class="bu">list</span>[<span class="bu">int</span>]]  <span class="co"># [Lager][Kunde], Kosten der Belieferung</span></span>
-<span id="cb209-69"><a href="#cb209-69" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb209-70"><a href="#cb209-70" aria-hidden="true" tabindex="-1"></a>    <span class="at">@model_validator</span>(mode<span class="op">=</span><span class="st">&quot;after&quot;</span>)</span>
-<span id="cb209-71"><a href="#cb209-71" aria-hidden="true" tabindex="-1"></a>    <span class="kw">def</span> pruefe_masse(<span class="va">self</span>) <span class="op">-&gt;</span> <span class="st">&quot;Standortproblem&quot;</span>:</span>
-<span id="cb209-72"><a href="#cb209-72" aria-hidden="true" tabindex="-1"></a>        n, m <span class="op">=</span> <span class="bu">len</span>(<span class="va">self</span>.lager), <span class="bu">len</span>(<span class="va">self</span>.kunden)</span>
-<span id="cb209-73"><a href="#cb209-73" aria-hidden="true" tabindex="-1"></a>        <span class="cf">if</span> <span class="bu">len</span>(<span class="va">self</span>.fixkosten) <span class="op">!=</span> n <span class="kw">or</span> <span class="bu">len</span>(<span class="va">self</span>.kapazitaet) <span class="op">!=</span> n:</span>
-<span id="cb209-74"><a href="#cb209-74" aria-hidden="true" tabindex="-1"></a>            <span class="cf">raise</span> <span class="pp">ValueError</span>(<span class="ss">f&quot;fixkosten/kapazitaet muessen </span><span class="sc">{</span>n<span class="sc">}</span><span class="ss"> Eintraege haben&quot;</span>)</span>
-<span id="cb209-75"><a href="#cb209-75" aria-hidden="true" tabindex="-1"></a>        <span class="cf">if</span> <span class="bu">len</span>(<span class="va">self</span>.bedarf) <span class="op">!=</span> m:</span>
-<span id="cb209-76"><a href="#cb209-76" aria-hidden="true" tabindex="-1"></a>            <span class="cf">raise</span> <span class="pp">ValueError</span>(<span class="ss">f&quot;bedarf muss </span><span class="sc">{</span>m<span class="sc">}</span><span class="ss"> Eintraege haben&quot;</span>)</span>
-<span id="cb209-77"><a href="#cb209-77" aria-hidden="true" tabindex="-1"></a>        <span class="cf">if</span> <span class="bu">len</span>(<span class="va">self</span>.transport) <span class="op">!=</span> n <span class="kw">or</span> <span class="bu">any</span>(<span class="bu">len</span>(z) <span class="op">!=</span> m <span class="cf">for</span> z <span class="kw">in</span> <span class="va">self</span>.transport):</span>
-<span id="cb209-78"><a href="#cb209-78" aria-hidden="true" tabindex="-1"></a>            <span class="cf">raise</span> <span class="pp">ValueError</span>(<span class="ss">f&quot;transport muss </span><span class="sc">{</span>n<span class="sc">}</span><span class="ss"> x </span><span class="sc">{</span>m<span class="sc">}</span><span class="ss"> sein&quot;</span>)</span>
-<span id="cb209-79"><a href="#cb209-79" aria-hidden="true" tabindex="-1"></a>        <span class="cf">if</span> <span class="bu">sum</span>(<span class="va">self</span>.kapazitaet) <span class="op">&lt;</span> <span class="bu">sum</span>(<span class="va">self</span>.bedarf):</span>
-<span id="cb209-80"><a href="#cb209-80" aria-hidden="true" tabindex="-1"></a>            <span class="cf">raise</span> <span class="pp">ValueError</span>(<span class="ss">f&quot;Gesamtkapazitaet </span><span class="sc">{</span><span class="bu">sum</span>(<span class="va">self</span>.kapazitaet)<span class="sc">}</span><span class="ss"> deckt den &quot;</span></span>
-<span id="cb209-81"><a href="#cb209-81" aria-hidden="true" tabindex="-1"></a>                             <span class="ss">f&quot;Gesamtbedarf </span><span class="sc">{</span><span class="bu">sum</span>(<span class="va">self</span>.bedarf)<span class="sc">}</span><span class="ss"> nicht&quot;</span>)</span>
-<span id="cb209-82"><a href="#cb209-82" aria-hidden="true" tabindex="-1"></a>        <span class="cf">return</span> <span class="va">self</span></span>
-<span id="cb209-83"><a href="#cb209-83" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb209-84"><a href="#cb209-84" aria-hidden="true" tabindex="-1"></a>    <span class="kw">def</span> schluessel(<span class="va">self</span>, i: <span class="bu">int</span>, j: <span class="bu">int</span>) <span class="op">-&gt;</span> <span class="bu">str</span>:</span>
-<span id="cb209-85"><a href="#cb209-85" aria-hidden="true" tabindex="-1"></a>        <span class="co">&quot;&quot;&quot;Variablenname im Loesung-DTO - beide Modellbauer benutzen ihn.&quot;&quot;&quot;</span></span>
-<span id="cb209-86"><a href="#cb209-86" aria-hidden="true" tabindex="-1"></a>        <span class="cf">return</span> <span class="ss">f&quot;</span><span class="sc">{</span><span class="va">self</span><span class="sc">.</span>lager[i]<span class="sc">}</span><span class="ss">-&gt;</span><span class="sc">{</span><span class="va">self</span><span class="sc">.</span>kunden[j]<span class="sc">}</span><span class="ss">&quot;</span></span>
-<span id="cb209-87"><a href="#cb209-87" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb209-88"><a href="#cb209-88" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb209-89"><a href="#cb209-89" aria-hidden="true" tabindex="-1"></a><span class="kw">def</span> beispielproblem(saat: <span class="bu">int</span> <span class="op">=</span> <span class="dv">11</span>) <span class="op">-&gt;</span> Standortproblem:</span>
-<span id="cb209-90"><a href="#cb209-90" aria-hidden="true" tabindex="-1"></a>    <span class="co">&quot;&quot;&quot;Sechs moegliche Lager, zwoelf Kunden - klein genug fuer beide Solver.&quot;&quot;&quot;</span></span>
-<span id="cb209-91"><a href="#cb209-91" aria-hidden="true" tabindex="-1"></a>    rng <span class="op">=</span> np.random.default_rng(saat)</span>
-<span id="cb209-92"><a href="#cb209-92" aria-hidden="true" tabindex="-1"></a>    lager <span class="op">=</span> [<span class="ss">f&quot;Lager_</span><span class="sc">{</span>k<span class="sc">}</span><span class="ss">&quot;</span> <span class="cf">for</span> k <span class="kw">in</span> <span class="st">&quot;ABCDEF&quot;</span>]</span>
-<span id="cb209-93"><a href="#cb209-93" aria-hidden="true" tabindex="-1"></a>    kunden <span class="op">=</span> [<span class="ss">f&quot;Kunde_</span><span class="sc">{</span>k<span class="sc">:02d}</span><span class="ss">&quot;</span> <span class="cf">for</span> k <span class="kw">in</span> <span class="bu">range</span>(<span class="dv">1</span>, <span class="dv">13</span>)]</span>
-<span id="cb209-94"><a href="#cb209-94" aria-hidden="true" tabindex="-1"></a>    bedarf <span class="op">=</span> rng.integers(<span class="dv">10</span>, <span class="dv">60</span>, <span class="bu">len</span>(kunden))</span>
-<span id="cb209-95"><a href="#cb209-95" aria-hidden="true" tabindex="-1"></a>    <span class="cf">return</span> Standortproblem(</span>
-<span id="cb209-96"><a href="#cb209-96" aria-hidden="true" tabindex="-1"></a>        lager<span class="op">=</span>lager,</span>
-<span id="cb209-97"><a href="#cb209-97" aria-hidden="true" tabindex="-1"></a>        kunden<span class="op">=</span>kunden,</span>
-<span id="cb209-98"><a href="#cb209-98" aria-hidden="true" tabindex="-1"></a>        fixkosten<span class="op">=</span>rng.integers(<span class="dv">3000</span>, <span class="dv">9000</span>, <span class="bu">len</span>(lager)).tolist(),</span>
-<span id="cb209-99"><a href="#cb209-99" aria-hidden="true" tabindex="-1"></a>        kapazitaet<span class="op">=</span>[<span class="bu">int</span>(bedarf.<span class="bu">sum</span>() <span class="op">*</span> <span class="fl">0.45</span>)] <span class="op">*</span> <span class="bu">len</span>(lager),</span>
-<span id="cb209-100"><a href="#cb209-100" aria-hidden="true" tabindex="-1"></a>        bedarf<span class="op">=</span>bedarf.tolist(),</span>
-<span id="cb209-101"><a href="#cb209-101" aria-hidden="true" tabindex="-1"></a>        transport<span class="op">=</span>rng.integers(<span class="dv">200</span>, <span class="dv">1800</span>, (<span class="bu">len</span>(lager), <span class="bu">len</span>(kunden))).tolist(),</span>
-<span id="cb209-102"><a href="#cb209-102" aria-hidden="true" tabindex="-1"></a>    )</span>
-<span id="cb209-103"><a href="#cb209-103" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb209-104"><a href="#cb209-104" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb209-105"><a href="#cb209-105" aria-hidden="true" tabindex="-1"></a><span class="co"># --- 2. Der eine Baustein, der sich aendert: der Modellbauer -----------------</span></span>
-<span id="cb209-106"><a href="#cb209-106" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb209-107"><a href="#cb209-107" aria-hidden="true" tabindex="-1"></a><span class="kw">def</span> baue_und_loese_mit_cpsat(problem: Standortproblem) <span class="op">-&gt;</span> Loesung:</span>
-<span id="cb209-108"><a href="#cb209-108" aria-hidden="true" tabindex="-1"></a>    <span class="co">&quot;&quot;&quot;CP-SAT: Bool-Variablen, ganzzahlige Koeffizienten, Minimize.&quot;&quot;&quot;</span></span>
-<span id="cb209-109"><a href="#cb209-109" aria-hidden="true" tabindex="-1"></a>    <span class="im">from</span> ortools.sat.python <span class="im">import</span> cp_model</span>
-<span id="cb209-110"><a href="#cb209-110" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb209-111"><a href="#cb209-111" aria-hidden="true" tabindex="-1"></a>    n, m <span class="op">=</span> <span class="bu">len</span>(problem.lager), <span class="bu">len</span>(problem.kunden)</span>
-<span id="cb209-112"><a href="#cb209-112" aria-hidden="true" tabindex="-1"></a>    modell <span class="op">=</span> cp_model.CpModel()</span>
-<span id="cb209-113"><a href="#cb209-113" aria-hidden="true" tabindex="-1"></a>    y <span class="op">=</span> [modell.NewBoolVar(<span class="ss">f&quot;offen_</span><span class="sc">{</span>i<span class="sc">}</span><span class="ss">&quot;</span>) <span class="cf">for</span> i <span class="kw">in</span> <span class="bu">range</span>(n)]</span>
-<span id="cb209-114"><a href="#cb209-114" aria-hidden="true" tabindex="-1"></a>    x <span class="op">=</span> {(i, j): modell.NewBoolVar(<span class="ss">f&quot;liefert_</span><span class="sc">{</span>i<span class="sc">}</span><span class="ss">_</span><span class="sc">{</span>j<span class="sc">}</span><span class="ss">&quot;</span>)</span>
-<span id="cb209-115"><a href="#cb209-115" aria-hidden="true" tabindex="-1"></a>         <span class="cf">for</span> i <span class="kw">in</span> <span class="bu">range</span>(n) <span class="cf">for</span> j <span class="kw">in</span> <span class="bu">range</span>(m)}</span>
-<span id="cb209-116"><a href="#cb209-116" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb209-117"><a href="#cb209-117" aria-hidden="true" tabindex="-1"></a>    <span class="cf">for</span> j <span class="kw">in</span> <span class="bu">range</span>(m):                                   <span class="co"># jeder Kunde genau einmal</span></span>
-<span id="cb209-118"><a href="#cb209-118" aria-hidden="true" tabindex="-1"></a>        modell.AddExactlyOne(x[i, j] <span class="cf">for</span> i <span class="kw">in</span> <span class="bu">range</span>(n))</span>
-<span id="cb209-119"><a href="#cb209-119" aria-hidden="true" tabindex="-1"></a>    <span class="cf">for</span> i <span class="kw">in</span> <span class="bu">range</span>(n):</span>
-<span id="cb209-120"><a href="#cb209-120" aria-hidden="true" tabindex="-1"></a>        <span class="cf">for</span> j <span class="kw">in</span> <span class="bu">range</span>(m):                               <span class="co"># nur aus offenen Lagern</span></span>
-<span id="cb209-121"><a href="#cb209-121" aria-hidden="true" tabindex="-1"></a>            modell.AddImplication(x[i, j], y[i])</span>
-<span id="cb209-122"><a href="#cb209-122" aria-hidden="true" tabindex="-1"></a>        modell.Add(<span class="bu">sum</span>(problem.bedarf[j] <span class="op">*</span> x[i, j] <span class="cf">for</span> j <span class="kw">in</span> <span class="bu">range</span>(m))</span>
-<span id="cb209-123"><a href="#cb209-123" aria-hidden="true" tabindex="-1"></a>                   <span class="op">&lt;=</span> problem.kapazitaet[i] <span class="op">*</span> y[i])      <span class="co"># Kapazitaet</span></span>
-<span id="cb209-124"><a href="#cb209-124" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb209-125"><a href="#cb209-125" aria-hidden="true" tabindex="-1"></a>    modell.Minimize(</span>
-<span id="cb209-126"><a href="#cb209-126" aria-hidden="true" tabindex="-1"></a>        <span class="bu">sum</span>(problem.fixkosten[i] <span class="op">*</span> y[i] <span class="cf">for</span> i <span class="kw">in</span> <span class="bu">range</span>(n))</span>
-<span id="cb209-127"><a href="#cb209-127" aria-hidden="true" tabindex="-1"></a>        <span class="op">+</span> <span class="bu">sum</span>(problem.transport[i][j] <span class="op">*</span> x[i, j] <span class="cf">for</span> i <span class="kw">in</span> <span class="bu">range</span>(n) <span class="cf">for</span> j <span class="kw">in</span> <span class="bu">range</span>(m)))</span>
-<span id="cb209-128"><a href="#cb209-128" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb209-129"><a href="#cb209-129" aria-hidden="true" tabindex="-1"></a>    loeser <span class="op">=</span> cp_model.CpSolver()</span>
-<span id="cb209-130"><a href="#cb209-130" aria-hidden="true" tabindex="-1"></a>    loeser.parameters.max_time_in_seconds <span class="op">=</span> ZEITLIMIT</span>
-<span id="cb209-131"><a href="#cb209-131" aria-hidden="true" tabindex="-1"></a>    loeser.parameters.num_workers <span class="op">=</span> <span class="dv">1</span></span>
-<span id="cb209-132"><a href="#cb209-132" aria-hidden="true" tabindex="-1"></a>    loeser.parameters.random_seed <span class="op">=</span> <span class="dv">1</span></span>
-<span id="cb209-133"><a href="#cb209-133" aria-hidden="true" tabindex="-1"></a>    status <span class="op">=</span> status_von_cpsat(loeser.Solve(modell))</span>
-<span id="cb209-134"><a href="#cb209-134" aria-hidden="true" tabindex="-1"></a>    <span class="cf">if</span> <span class="kw">not</span> status.brauchbar:</span>
-<span id="cb209-135"><a href="#cb209-135" aria-hidden="true" tabindex="-1"></a>        <span class="cf">return</span> Loesung(status<span class="op">=</span>status, laufzeit<span class="op">=</span>loeser.WallTime())</span>
-<span id="cb209-136"><a href="#cb209-136" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb209-137"><a href="#cb209-137" aria-hidden="true" tabindex="-1"></a>    <span class="cf">return</span> Loesung(</span>
-<span id="cb209-138"><a href="#cb209-138" aria-hidden="true" tabindex="-1"></a>        status<span class="op">=</span>status,</span>
-<span id="cb209-139"><a href="#cb209-139" aria-hidden="true" tabindex="-1"></a>        werte<span class="op">=</span>{problem.schluessel(i, j): <span class="bu">float</span>(loeser.Value(x[i, j]))</span>
-<span id="cb209-140"><a href="#cb209-140" aria-hidden="true" tabindex="-1"></a>               <span class="cf">for</span> i <span class="kw">in</span> <span class="bu">range</span>(n) <span class="cf">for</span> j <span class="kw">in</span> <span class="bu">range</span>(m)},</span>
-<span id="cb209-141"><a href="#cb209-141" aria-hidden="true" tabindex="-1"></a>        zielwert<span class="op">=</span>loeser.ObjectiveValue(),</span>
-<span id="cb209-142"><a href="#cb209-142" aria-hidden="true" tabindex="-1"></a>        schranke<span class="op">=</span>loeser.BestObjectiveBound(),</span>
-<span id="cb209-143"><a href="#cb209-143" aria-hidden="true" tabindex="-1"></a>        laufzeit<span class="op">=</span>loeser.WallTime())</span>
-<span id="cb209-144"><a href="#cb209-144" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb209-145"><a href="#cb209-145" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb209-146"><a href="#cb209-146" aria-hidden="true" tabindex="-1"></a><span class="kw">def</span> baue_und_loese_mit_highs(problem: Standortproblem) <span class="op">-&gt;</span> Loesung:</span>
-<span id="cb209-147"><a href="#cb209-147" aria-hidden="true" tabindex="-1"></a>    <span class="co">&quot;&quot;&quot;HiGHS: dieselben Restriktionen als Ungleichungszeilen einer Matrix.&quot;&quot;&quot;</span></span>
-<span id="cb209-148"><a href="#cb209-148" aria-hidden="true" tabindex="-1"></a>    <span class="im">import</span> highspy</span>
-<span id="cb209-149"><a href="#cb209-149" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb209-150"><a href="#cb209-150" aria-hidden="true" tabindex="-1"></a>    n, m <span class="op">=</span> <span class="bu">len</span>(problem.lager), <span class="bu">len</span>(problem.kunden)</span>
-<span id="cb209-151"><a href="#cb209-151" aria-hidden="true" tabindex="-1"></a>    anzahl_x <span class="op">=</span> n <span class="op">*</span> m                                     <span class="co"># Spalten 0..n*m-1</span></span>
-<span id="cb209-152"><a href="#cb209-152" aria-hidden="true" tabindex="-1"></a>    spalte_y <span class="op">=</span> <span class="kw">lambda</span> i: anzahl_x <span class="op">+</span> i                    <span class="co"># danach die y_i  # noqa: E731</span></span>
-<span id="cb209-153"><a href="#cb209-153" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb209-154"><a href="#cb209-154" aria-hidden="true" tabindex="-1"></a>    modell <span class="op">=</span> highspy.Highs()</span>
-<span id="cb209-155"><a href="#cb209-155" aria-hidden="true" tabindex="-1"></a>    modell.setOptionValue(<span class="st">&quot;output_flag&quot;</span>, <span class="va">False</span>)</span>
-<span id="cb209-156"><a href="#cb209-156" aria-hidden="true" tabindex="-1"></a>    modell.setOptionValue(<span class="st">&quot;time_limit&quot;</span>, ZEITLIMIT)</span>
-<span id="cb209-157"><a href="#cb209-157" aria-hidden="true" tabindex="-1"></a>    modell.addVars(anzahl_x <span class="op">+</span> n, np.zeros(anzahl_x <span class="op">+</span> n), np.ones(anzahl_x <span class="op">+</span> n))</span>
-<span id="cb209-158"><a href="#cb209-158" aria-hidden="true" tabindex="-1"></a>    <span class="cf">for</span> spalte <span class="kw">in</span> <span class="bu">range</span>(anzahl_x <span class="op">+</span> n):</span>
-<span id="cb209-159"><a href="#cb209-159" aria-hidden="true" tabindex="-1"></a>        modell.changeColIntegrality(spalte, highspy.HighsVarType.kInteger)</span>
-<span id="cb209-160"><a href="#cb209-160" aria-hidden="true" tabindex="-1"></a>    <span class="cf">for</span> i <span class="kw">in</span> <span class="bu">range</span>(n):</span>
-<span id="cb209-161"><a href="#cb209-161" aria-hidden="true" tabindex="-1"></a>        modell.changeColCost(spalte_y(i), <span class="bu">float</span>(problem.fixkosten[i]))</span>
-<span id="cb209-162"><a href="#cb209-162" aria-hidden="true" tabindex="-1"></a>        <span class="cf">for</span> j <span class="kw">in</span> <span class="bu">range</span>(m):</span>
-<span id="cb209-163"><a href="#cb209-163" aria-hidden="true" tabindex="-1"></a>            modell.changeColCost(i <span class="op">*</span> m <span class="op">+</span> j, <span class="bu">float</span>(problem.transport[i][j]))</span>
-<span id="cb209-164"><a href="#cb209-164" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb209-165"><a href="#cb209-165" aria-hidden="true" tabindex="-1"></a>    <span class="cf">for</span> j <span class="kw">in</span> <span class="bu">range</span>(m):                                   <span class="co"># jeder Kunde genau einmal</span></span>
-<span id="cb209-166"><a href="#cb209-166" aria-hidden="true" tabindex="-1"></a>        index <span class="op">=</span> np.array([i <span class="op">*</span> m <span class="op">+</span> j <span class="cf">for</span> i <span class="kw">in</span> <span class="bu">range</span>(n)], dtype<span class="op">=</span>np.int32)</span>
-<span id="cb209-167"><a href="#cb209-167" aria-hidden="true" tabindex="-1"></a>        modell.addRow(<span class="fl">1.0</span>, <span class="fl">1.0</span>, n, index, np.ones(n))</span>
-<span id="cb209-168"><a href="#cb209-168" aria-hidden="true" tabindex="-1"></a>    <span class="cf">for</span> i <span class="kw">in</span> <span class="bu">range</span>(n):</span>
-<span id="cb209-169"><a href="#cb209-169" aria-hidden="true" tabindex="-1"></a>        <span class="cf">for</span> j <span class="kw">in</span> <span class="bu">range</span>(m):                               <span class="co"># x_ij - y_i &lt;= 0</span></span>
-<span id="cb209-170"><a href="#cb209-170" aria-hidden="true" tabindex="-1"></a>            modell.addRow(<span class="op">-</span>highspy.kHighsInf, <span class="fl">0.0</span>, <span class="dv">2</span>,</span>
-<span id="cb209-171"><a href="#cb209-171" aria-hidden="true" tabindex="-1"></a>                          np.array([i <span class="op">*</span> m <span class="op">+</span> j, spalte_y(i)], dtype<span class="op">=</span>np.int32),</span>
-<span id="cb209-172"><a href="#cb209-172" aria-hidden="true" tabindex="-1"></a>                          np.array([<span class="fl">1.0</span>, <span class="op">-</span><span class="fl">1.0</span>]))</span>
-<span id="cb209-173"><a href="#cb209-173" aria-hidden="true" tabindex="-1"></a>        index <span class="op">=</span> np.array([i <span class="op">*</span> m <span class="op">+</span> j <span class="cf">for</span> j <span class="kw">in</span> <span class="bu">range</span>(m)] <span class="op">+</span> [spalte_y(i)],</span>
-<span id="cb209-174"><a href="#cb209-174" aria-hidden="true" tabindex="-1"></a>                         dtype<span class="op">=</span>np.int32)                 <span class="co"># Kapazitaet</span></span>
-<span id="cb209-175"><a href="#cb209-175" aria-hidden="true" tabindex="-1"></a>        werte <span class="op">=</span> np.concatenate([np.array(problem.bedarf, dtype<span class="op">=</span><span class="bu">float</span>),</span>
-<span id="cb209-176"><a href="#cb209-176" aria-hidden="true" tabindex="-1"></a>                                [<span class="op">-</span><span class="bu">float</span>(problem.kapazitaet[i])]])</span>
-<span id="cb209-177"><a href="#cb209-177" aria-hidden="true" tabindex="-1"></a>        modell.addRow(<span class="op">-</span>highspy.kHighsInf, <span class="fl">0.0</span>, m <span class="op">+</span> <span class="dv">1</span>, index, werte)</span>
-<span id="cb209-178"><a href="#cb209-178" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb209-179"><a href="#cb209-179" aria-hidden="true" tabindex="-1"></a>    t0 <span class="op">=</span> time.perf_counter()</span>
-<span id="cb209-180"><a href="#cb209-180" aria-hidden="true" tabindex="-1"></a>    modell.run()</span>
-<span id="cb209-181"><a href="#cb209-181" aria-hidden="true" tabindex="-1"></a>    laufzeit <span class="op">=</span> time.perf_counter() <span class="op">-</span> t0</span>
-<span id="cb209-182"><a href="#cb209-182" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb209-183"><a href="#cb209-183" aria-hidden="true" tabindex="-1"></a>    status <span class="op">=</span> status_von_highs(modell.modelStatusToString(modell.getModelStatus()))</span>
-<span id="cb209-184"><a href="#cb209-184" aria-hidden="true" tabindex="-1"></a>    <span class="cf">if</span> <span class="kw">not</span> status.brauchbar:</span>
-<span id="cb209-185"><a href="#cb209-185" aria-hidden="true" tabindex="-1"></a>        <span class="cf">return</span> Loesung(status<span class="op">=</span>status, laufzeit<span class="op">=</span>laufzeit)</span>
-<span id="cb209-186"><a href="#cb209-186" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb209-187"><a href="#cb209-187" aria-hidden="true" tabindex="-1"></a>    loesungswerte <span class="op">=</span> modell.getSolution().col_value</span>
-<span id="cb209-188"><a href="#cb209-188" aria-hidden="true" tabindex="-1"></a>    info <span class="op">=</span> modell.getInfo()</span>
-<span id="cb209-189"><a href="#cb209-189" aria-hidden="true" tabindex="-1"></a>    <span class="cf">return</span> Loesung(</span>
-<span id="cb209-190"><a href="#cb209-190" aria-hidden="true" tabindex="-1"></a>        status<span class="op">=</span>status,</span>
-<span id="cb209-191"><a href="#cb209-191" aria-hidden="true" tabindex="-1"></a>        werte<span class="op">=</span>{problem.schluessel(i, j): <span class="bu">float</span>(loesungswerte[i <span class="op">*</span> m <span class="op">+</span> j])</span>
-<span id="cb209-192"><a href="#cb209-192" aria-hidden="true" tabindex="-1"></a>               <span class="cf">for</span> i <span class="kw">in</span> <span class="bu">range</span>(n) <span class="cf">for</span> j <span class="kw">in</span> <span class="bu">range</span>(m)},</span>
-<span id="cb209-193"><a href="#cb209-193" aria-hidden="true" tabindex="-1"></a>        zielwert<span class="op">=</span>info.objective_function_value,</span>
-<span id="cb209-194"><a href="#cb209-194" aria-hidden="true" tabindex="-1"></a>        schranke<span class="op">=</span>info.mip_dual_bound,</span>
-<span id="cb209-195"><a href="#cb209-195" aria-hidden="true" tabindex="-1"></a>        laufzeit<span class="op">=</span>laufzeit)</span>
-<span id="cb209-196"><a href="#cb209-196" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb209-197"><a href="#cb209-197" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb209-198"><a href="#cb209-198" aria-hidden="true" tabindex="-1"></a>MODELLBAUER <span class="op">=</span> {<span class="st">&quot;cpsat&quot;</span>: baue_und_loese_mit_cpsat, <span class="st">&quot;highs&quot;</span>: baue_und_loese_mit_highs}</span>
-<span id="cb209-199"><a href="#cb209-199" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb209-200"><a href="#cb209-200" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb209-201"><a href="#cb209-201" aria-hidden="true" tabindex="-1"></a><span class="co"># --- 3. Alles Weitere ist wieder gemeinsam -----------------------------------</span></span>
-<span id="cb209-202"><a href="#cb209-202" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb209-203"><a href="#cb209-203" aria-hidden="true" tabindex="-1"></a><span class="kw">def</span> pruefe_zuordnung(problem: Standortproblem, loesung: Loesung,</span>
-<span id="cb209-204"><a href="#cb209-204" aria-hidden="true" tabindex="-1"></a>                     toleranz: <span class="bu">float</span> <span class="op">=</span> <span class="fl">1e-6</span>) <span class="op">-&gt;</span> <span class="bu">list</span>[<span class="bu">str</span>]:</span>
-<span id="cb209-205"><a href="#cb209-205" aria-hidden="true" tabindex="-1"></a>    <span class="co">&quot;&quot;&quot;Prueft die Loesung gegen die Anforderung - ohne Solver, ohne Modell.&quot;&quot;&quot;</span></span>
-<span id="cb209-206"><a href="#cb209-206" aria-hidden="true" tabindex="-1"></a>    <span class="cf">if</span> <span class="kw">not</span> loesung.status.brauchbar:</span>
-<span id="cb209-207"><a href="#cb209-207" aria-hidden="true" tabindex="-1"></a>        <span class="cf">return</span> [<span class="ss">f&quot;kein verwertbares Ergebnis (</span><span class="sc">{</span>loesung<span class="sc">.</span>status<span class="sc">.</span>value<span class="sc">}</span><span class="ss">)&quot;</span>]</span>
-<span id="cb209-208"><a href="#cb209-208" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb209-209"><a href="#cb209-209" aria-hidden="true" tabindex="-1"></a>    n, m <span class="op">=</span> <span class="bu">len</span>(problem.lager), <span class="bu">len</span>(problem.kunden)</span>
-<span id="cb209-210"><a href="#cb209-210" aria-hidden="true" tabindex="-1"></a>    zuordnung <span class="op">=</span> np.array([[loesung.werte[problem.schluessel(i, j)]</span>
-<span id="cb209-211"><a href="#cb209-211" aria-hidden="true" tabindex="-1"></a>                           <span class="cf">for</span> j <span class="kw">in</span> <span class="bu">range</span>(m)] <span class="cf">for</span> i <span class="kw">in</span> <span class="bu">range</span>(n)])</span>
-<span id="cb209-212"><a href="#cb209-212" aria-hidden="true" tabindex="-1"></a>    beanstandungen: <span class="bu">list</span>[<span class="bu">str</span>] <span class="op">=</span> []</span>
-<span id="cb209-213"><a href="#cb209-213" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb209-214"><a href="#cb209-214" aria-hidden="true" tabindex="-1"></a>    <span class="cf">if</span> (np.<span class="bu">abs</span>(zuordnung <span class="op">-</span> np.<span class="bu">round</span>(zuordnung)) <span class="op">&gt;</span> toleranz).<span class="bu">any</span>():</span>
-<span id="cb209-215"><a href="#cb209-215" aria-hidden="true" tabindex="-1"></a>        beanstandungen.append(<span class="st">&quot;Zuordnungen sind nicht 0/1&quot;</span>)</span>
-<span id="cb209-216"><a href="#cb209-216" aria-hidden="true" tabindex="-1"></a>    zuordnung <span class="op">=</span> np.<span class="bu">round</span>(zuordnung)</span>
-<span id="cb209-217"><a href="#cb209-217" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb209-218"><a href="#cb209-218" aria-hidden="true" tabindex="-1"></a>    <span class="cf">for</span> j, kunde <span class="kw">in</span> <span class="bu">enumerate</span>(problem.kunden):</span>
-<span id="cb209-219"><a href="#cb209-219" aria-hidden="true" tabindex="-1"></a>        <span class="cf">if</span> <span class="bu">abs</span>(zuordnung[:, j].<span class="bu">sum</span>() <span class="op">-</span> <span class="fl">1.0</span>) <span class="op">&gt;</span> toleranz:</span>
-<span id="cb209-220"><a href="#cb209-220" aria-hidden="true" tabindex="-1"></a>            beanstandungen.append(<span class="ss">f&quot;</span><span class="sc">{</span>kunde<span class="sc">}</span><span class="ss"> wird </span><span class="sc">{</span>zuordnung[:, j]<span class="sc">.</span><span class="bu">sum</span>()<span class="sc">:.0f}</span><span class="ss">-mal beliefert&quot;</span>)</span>
-<span id="cb209-221"><a href="#cb209-221" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb209-222"><a href="#cb209-222" aria-hidden="true" tabindex="-1"></a>    beliefert <span class="op">=</span> zuordnung <span class="op">@</span> np.array(problem.bedarf, dtype<span class="op">=</span><span class="bu">float</span>)</span>
-<span id="cb209-223"><a href="#cb209-223" aria-hidden="true" tabindex="-1"></a>    <span class="cf">for</span> i, lagername <span class="kw">in</span> <span class="bu">enumerate</span>(problem.lager):</span>
-<span id="cb209-224"><a href="#cb209-224" aria-hidden="true" tabindex="-1"></a>        <span class="cf">if</span> beliefert[i] <span class="op">&gt;</span> problem.kapazitaet[i] <span class="op">+</span> toleranz:</span>
-<span id="cb209-225"><a href="#cb209-225" aria-hidden="true" tabindex="-1"></a>            beanstandungen.append(<span class="ss">f&quot;</span><span class="sc">{</span>lagername<span class="sc">}</span><span class="ss">: </span><span class="sc">{</span>beliefert[i]<span class="sc">:.0f}</span><span class="ss"> Paletten ueber &quot;</span></span>
-<span id="cb209-226"><a href="#cb209-226" aria-hidden="true" tabindex="-1"></a>                                  <span class="ss">f&quot;Kapazitaet </span><span class="sc">{</span>problem<span class="sc">.</span>kapazitaet[i]<span class="sc">}</span><span class="ss">&quot;</span>)</span>
-<span id="cb209-227"><a href="#cb209-227" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb209-228"><a href="#cb209-228" aria-hidden="true" tabindex="-1"></a>    <span class="cf">if</span> loesung.zielwert <span class="kw">is</span> <span class="kw">not</span> <span class="va">None</span>:</span>
-<span id="cb209-229"><a href="#cb209-229" aria-hidden="true" tabindex="-1"></a>        offen <span class="op">=</span> beliefert <span class="op">&gt;</span> toleranz</span>
-<span id="cb209-230"><a href="#cb209-230" aria-hidden="true" tabindex="-1"></a>        nachgerechnet <span class="op">=</span> (np.array(problem.fixkosten, dtype<span class="op">=</span><span class="bu">float</span>) <span class="op">@</span> offen</span>
-<span id="cb209-231"><a href="#cb209-231" aria-hidden="true" tabindex="-1"></a>                         <span class="op">+</span> (np.array(problem.transport, dtype<span class="op">=</span><span class="bu">float</span>) <span class="op">*</span> zuordnung).<span class="bu">sum</span>())</span>
-<span id="cb209-232"><a href="#cb209-232" aria-hidden="true" tabindex="-1"></a>        <span class="cf">if</span> <span class="bu">abs</span>(nachgerechnet <span class="op">-</span> loesung.zielwert) <span class="op">&gt;</span> <span class="fl">0.5</span>:</span>
-<span id="cb209-233"><a href="#cb209-233" aria-hidden="true" tabindex="-1"></a>            beanstandungen.append(<span class="ss">f&quot;Zielwert </span><span class="sc">{</span>loesung<span class="sc">.</span>zielwert<span class="sc">:,.0f}</span><span class="ss"> passt nicht zur &quot;</span></span>
-<span id="cb209-234"><a href="#cb209-234" aria-hidden="true" tabindex="-1"></a>                                  <span class="ss">f&quot;Zuordnung (nachgerechnet </span><span class="sc">{</span>nachgerechnet<span class="sc">:,.0f}</span><span class="ss">)&quot;</span>)</span>
-<span id="cb209-235"><a href="#cb209-235" aria-hidden="true" tabindex="-1"></a>    <span class="cf">return</span> beanstandungen</span>
-<span id="cb209-236"><a href="#cb209-236" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb209-237"><a href="#cb209-237" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb209-238"><a href="#cb209-238" aria-hidden="true" tabindex="-1"></a><span class="kw">def</span> geoeffnete_lager(problem: Standortproblem, loesung: Loesung) <span class="op">-&gt;</span> <span class="bu">list</span>[<span class="bu">str</span>]:</span>
-<span id="cb209-239"><a href="#cb209-239" aria-hidden="true" tabindex="-1"></a>    m <span class="op">=</span> <span class="bu">len</span>(problem.kunden)</span>
-<span id="cb209-240"><a href="#cb209-240" aria-hidden="true" tabindex="-1"></a>    <span class="cf">return</span> [name <span class="cf">for</span> i, name <span class="kw">in</span> <span class="bu">enumerate</span>(problem.lager)</span>
-<span id="cb209-241"><a href="#cb209-241" aria-hidden="true" tabindex="-1"></a>            <span class="cf">if</span> <span class="bu">any</span>(loesung.werte[problem.schluessel(i, j)] <span class="op">&gt;</span> <span class="fl">0.5</span> <span class="cf">for</span> j <span class="kw">in</span> <span class="bu">range</span>(m))]</span>
-<span id="cb209-242"><a href="#cb209-242" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb209-243"><a href="#cb209-243" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb209-244"><a href="#cb209-244" aria-hidden="true" tabindex="-1"></a><span class="kw">def</span> loese_in_eigenem_prozess(name: <span class="bu">str</span>) <span class="op">-&gt;</span> Loesung:</span>
-<span id="cb209-245"><a href="#cb209-245" aria-hidden="true" tabindex="-1"></a>    <span class="co">&quot;&quot;&quot;Startet dieses Programm noch einmal - mit genau einem Solverimport.&quot;&quot;&quot;</span></span>
-<span id="cb209-246"><a href="#cb209-246" aria-hidden="true" tabindex="-1"></a>    ergebnis <span class="op">=</span> subprocess.run([sys.executable, <span class="va">__file__</span>, name],</span>
-<span id="cb209-247"><a href="#cb209-247" aria-hidden="true" tabindex="-1"></a>                              capture_output<span class="op">=</span><span class="va">True</span>, text<span class="op">=</span><span class="va">True</span>, timeout<span class="op">=</span><span class="dv">300</span>)</span>
-<span id="cb209-248"><a href="#cb209-248" aria-hidden="true" tabindex="-1"></a>    <span class="cf">if</span> ergebnis.returncode <span class="op">!=</span> <span class="dv">0</span>:</span>
-<span id="cb209-249"><a href="#cb209-249" aria-hidden="true" tabindex="-1"></a>        <span class="cf">raise</span> <span class="pp">RuntimeError</span>(ergebnis.stderr.strip().splitlines()[<span class="op">-</span><span class="dv">1</span>])</span>
-<span id="cb209-250"><a href="#cb209-250" aria-hidden="true" tabindex="-1"></a>    <span class="co"># Das DTO als JSON - genau dafuer ist ein Datenobjekt ohne Solverbezug gut.</span></span>
-<span id="cb209-251"><a href="#cb209-251" aria-hidden="true" tabindex="-1"></a>    <span class="cf">return</span> Loesung.model_validate_json(ergebnis.stdout.strip().splitlines()[<span class="op">-</span><span class="dv">1</span>])</span>
-<span id="cb209-252"><a href="#cb209-252" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb209-253"><a href="#cb209-253" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb209-254"><a href="#cb209-254" aria-hidden="true" tabindex="-1"></a><span class="cf">if</span> <span class="va">__name__</span> <span class="op">==</span> <span class="st">&quot;__main__&quot;</span>:</span>
-<span id="cb209-255"><a href="#cb209-255" aria-hidden="true" tabindex="-1"></a>    problem <span class="op">=</span> beispielproblem()</span>
-<span id="cb209-256"><a href="#cb209-256" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb209-257"><a href="#cb209-257" aria-hidden="true" tabindex="-1"></a>    <span class="co"># --- Kindprozess: rechnen und das DTO als JSON ausgeben ---------------</span></span>
-<span id="cb209-258"><a href="#cb209-258" aria-hidden="true" tabindex="-1"></a>    <span class="cf">if</span> <span class="bu">len</span>(sys.argv) <span class="op">&gt;</span> <span class="dv">1</span>:</span>
-<span id="cb209-259"><a href="#cb209-259" aria-hidden="true" tabindex="-1"></a>        <span class="bu">print</span>(MODELLBAUER[sys.argv[<span class="dv">1</span>]](problem).model_dump_json())</span>
-<span id="cb209-260"><a href="#cb209-260" aria-hidden="true" tabindex="-1"></a>        sys.exit(<span class="dv">0</span>)</span>
-<span id="cb209-261"><a href="#cb209-261" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb209-262"><a href="#cb209-262" aria-hidden="true" tabindex="-1"></a>    <span class="co"># --- Hauptprozess: beide Solver anstossen und vergleichen -------------</span></span>
-<span id="cb209-263"><a href="#cb209-263" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;=&quot;</span> <span class="op">*</span> <span class="dv">82</span>)</span>
-<span id="cb209-264"><a href="#cb209-264" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;  DERSELBE FALL, ZWEI SOLVER - UND EIN AUSWERTUNGSCODE&quot;</span>)</span>
-<span id="cb209-265"><a href="#cb209-265" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;=&quot;</span> <span class="op">*</span> <span class="dv">82</span>)</span>
-<span id="cb209-266"><a href="#cb209-266" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;Standortplanung: </span><span class="sc">{</span><span class="bu">len</span>(problem.lager)<span class="sc">}</span><span class="ss"> moegliche Lager, &quot;</span></span>
-<span id="cb209-267"><a href="#cb209-267" aria-hidden="true" tabindex="-1"></a>          <span class="ss">f&quot;</span><span class="sc">{</span><span class="bu">len</span>(problem.kunden)<span class="sc">}</span><span class="ss"> Kunden, </span><span class="sc">{</span><span class="bu">sum</span>(problem.bedarf)<span class="sc">}</span><span class="ss"> Paletten Bedarf.&quot;</span>)</span>
-<span id="cb209-268"><a href="#cb209-268" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;Kapazitaet je Lager: </span><span class="sc">{</span>problem<span class="sc">.</span>kapazitaet[<span class="dv">0</span>]<span class="sc">}</span><span class="ss"> Paletten &quot;</span></span>
-<span id="cb209-269"><a href="#cb209-269" aria-hidden="true" tabindex="-1"></a>          <span class="ss">f&quot;-&gt; mindestens 3 Lager noetig.</span><span class="ch">\n</span><span class="ss">&quot;</span>)</span>
-<span id="cb209-270"><a href="#cb209-270" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb209-271"><a href="#cb209-271" aria-hidden="true" tabindex="-1"></a>    loesungen: <span class="bu">dict</span>[<span class="bu">str</span>, Loesung] <span class="op">=</span> {}</span>
-<span id="cb209-272"><a href="#cb209-272" aria-hidden="true" tabindex="-1"></a>    <span class="cf">for</span> name, beschriftung <span class="kw">in</span> [(<span class="st">&quot;cpsat&quot;</span>, <span class="st">&quot;OR-Tools CP-SAT&quot;</span>),</span>
-<span id="cb209-273"><a href="#cb209-273" aria-hidden="true" tabindex="-1"></a>                               (<span class="st">&quot;highs&quot;</span>, <span class="st">&quot;HiGHS (highspy)&quot;</span>)]:</span>
-<span id="cb209-274"><a href="#cb209-274" aria-hidden="true" tabindex="-1"></a>        loesung <span class="op">=</span> loesungen[name] <span class="op">=</span> loese_in_eigenem_prozess(name)</span>
-<span id="cb209-275"><a href="#cb209-275" aria-hidden="true" tabindex="-1"></a>        beanstandungen <span class="op">=</span> pruefe_zuordnung(problem, loesung)</span>
-<span id="cb209-276"><a href="#cb209-276" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb209-277"><a href="#cb209-277" aria-hidden="true" tabindex="-1"></a>        <span class="bu">print</span>(<span class="ss">f&quot;</span><span class="sc">{</span>beschriftung<span class="sc">}</span><span class="ss">&quot;</span>)</span>
-<span id="cb209-278"><a href="#cb209-278" aria-hidden="true" tabindex="-1"></a>        <span class="bu">print</span>(<span class="ss">f&quot;  </span><span class="sc">{</span>loesung<span class="sc">.</span>als_bericht()<span class="sc">}</span><span class="ss">&quot;</span>)</span>
-<span id="cb209-279"><a href="#cb209-279" aria-hidden="true" tabindex="-1"></a>        <span class="bu">print</span>(<span class="ss">f&quot;  eroeffnete Lager: </span><span class="sc">{</span><span class="st">&#39;, &#39;</span><span class="sc">.</span>join(geoeffnete_lager(problem, loesung))<span class="sc">}</span><span class="ss">&quot;</span>)</span>
-<span id="cb209-280"><a href="#cb209-280" aria-hidden="true" tabindex="-1"></a>        <span class="bu">print</span>(<span class="ss">f&quot;  Abnahmepruefung:  &quot;</span></span>
-<span id="cb209-281"><a href="#cb209-281" aria-hidden="true" tabindex="-1"></a>              <span class="ss">f&quot;</span><span class="sc">{</span><span class="st">&#39;bestanden&#39;</span> <span class="cf">if</span> <span class="kw">not</span> beanstandungen <span class="cf">else</span> beanstandungen<span class="sc">}</span><span class="ss">&quot;</span>)</span>
-<span id="cb209-282"><a href="#cb209-282" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb209-283"><a href="#cb209-283" aria-hidden="true" tabindex="-1"></a>    <span class="co"># --- Was der Vergleich zeigt -----------------------------------------</span></span>
-<span id="cb209-284"><a href="#cb209-284" aria-hidden="true" tabindex="-1"></a>    zielwerte <span class="op">=</span> [loesung.zielwert <span class="cf">for</span> loesung <span class="kw">in</span> loesungen.values()]</span>
-<span id="cb209-285"><a href="#cb209-285" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;-&quot;</span> <span class="op">*</span> <span class="dv">82</span>)</span>
-<span id="cb209-286"><a href="#cb209-286" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;Zielwertdifferenz: </span><span class="sc">{</span><span class="bu">abs</span>(zielwerte[<span class="dv">0</span>] <span class="op">-</span> zielwerte[<span class="dv">1</span>])<span class="sc">:.6f}</span><span class="ss"> EUR&quot;</span>)</span>
-<span id="cb209-287"><a href="#cb209-287" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb209-288"><a href="#cb209-288" aria-hidden="true" tabindex="-1"></a>    gleich_belegt <span class="op">=</span> <span class="bu">all</span>(</span>
-<span id="cb209-289"><a href="#cb209-289" aria-hidden="true" tabindex="-1"></a>        <span class="bu">round</span>(loesungen[<span class="st">&quot;cpsat&quot;</span>].werte[s]) <span class="op">==</span> <span class="bu">round</span>(loesungen[<span class="st">&quot;highs&quot;</span>].werte[s])</span>
-<span id="cb209-290"><a href="#cb209-290" aria-hidden="true" tabindex="-1"></a>        <span class="cf">for</span> s <span class="kw">in</span> loesungen[<span class="st">&quot;cpsat&quot;</span>].werte)</span>
-<span id="cb209-291"><a href="#cb209-291" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;Identische Zuordnung: </span><span class="sc">{</span><span class="st">&#39;ja&#39;</span> <span class="cf">if</span> gleich_belegt <span class="cf">else</span> <span class="st">&#39;nein&#39;</span><span class="sc">}</span><span class="ss">&quot;</span>)</span>
-<span id="cb209-292"><a href="#cb209-292" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb209-293"><a href="#cb209-293" aria-hidden="true" tabindex="-1"></a>    <span class="cf">assert</span> <span class="bu">abs</span>(zielwerte[<span class="dv">0</span>] <span class="op">-</span> zielwerte[<span class="dv">1</span>]) <span class="op">&lt;</span> <span class="fl">0.5</span>, <span class="st">&quot;Die Solver widersprechen sich!&quot;</span></span>
-<span id="cb209-294"><a href="#cb209-294" aria-hidden="true" tabindex="-1"></a>    <span class="cf">assert</span> <span class="bu">all</span>(l.status <span class="kw">is</span> SolverStatus.OPTIMAL <span class="cf">for</span> l <span class="kw">in</span> loesungen.values())</span>
-<span id="cb209-295"><a href="#cb209-295" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb209-296"><a href="#cb209-296" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;</span><span class="ch">\n</span><span class="st">&quot;</span> <span class="op">+</span> <span class="st">&quot;=&quot;</span> <span class="op">*</span> <span class="dv">82</span>)</span>
-<span id="cb209-297"><a href="#cb209-297" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;  WAS DER WECHSEL GEKOSTET HAT&quot;</span>)</span>
-<span id="cb209-298"><a href="#cb209-298" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;=&quot;</span> <span class="op">*</span> <span class="dv">82</span>)</span>
-<span id="cb209-299"><a href="#cb209-299" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;Ausgetauscht wurde EINE Funktion. Domaenenmodell, Abnahmepruefung und&quot;</span>)</span>
-<span id="cb209-300"><a href="#cb209-300" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;Bericht sind woertlich dieselben - sie sehen den Solver nie.&quot;</span>)</span>
-<span id="cb209-301"><a href="#cb209-301" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>()</span>
-<span id="cb209-302"><a href="#cb209-302" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;Nicht umsonst ist der Wechsel trotzdem:&quot;</span>)</span>
-<span id="cb209-303"><a href="#cb209-303" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;  * CP-SAT rechnet ausschliesslich GANZZAHLIG. Alle Kosten sind hier&quot;</span>)</span>
-<span id="cb209-304"><a href="#cb209-304" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;    deshalb int. Wer in Euro und Cent rechnet, skaliert vorher auf Cent -&quot;</span>)</span>
-<span id="cb209-305"><a href="#cb209-305" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;    und muss das im Bericht wieder zuruecknehmen.&quot;</span>)</span>
-<span id="cb209-306"><a href="#cb209-306" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;  * HiGHS braucht die Restriktionen als Matrixzeilen, CP-SAT nimmt sie&quot;</span>)</span>
-<span id="cb209-307"><a href="#cb209-307" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;    als Ausdruecke. Das ist der Grund, warum der HiGHS-Modellbauer&quot;</span>)</span>
-<span id="cb209-308"><a href="#cb209-308" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;    laenger ist, obwohl er dasselbe Modell beschreibt.&quot;</span>)</span>
-<span id="cb209-309"><a href="#cb209-309" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;  * Beide Bibliotheken bringen eine eigene HiGHS-Kopie mit und lassen&quot;</span>)</span>
-<span id="cb209-310"><a href="#cb209-310" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;    sich nicht gemeinsam importieren - daher die zwei Prozesse.&quot;</span>)</span>
-<span id="cb209-311"><a href="#cb209-311" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>()</span>
-<span id="cb209-312"><a href="#cb209-312" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;Der Ertrag: Beide beweisen denselben optimalen Zielwert, und die&quot;</span>)</span>
-<span id="cb209-313"><a href="#cb209-313" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;Entscheidung zwischen ihnen ist eine Frage der Laufzeit geworden -&quot;</span>)</span>
-<span id="cb209-314"><a href="#cb209-314" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;nicht eine Frage, wie viel Code man neu schreiben muss.&quot;</span>)</span>
-<span id="cb209-315"><a href="#cb209-315" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>()</span>
-<span id="cb209-316"><a href="#cb209-316" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;Verglichen wird deshalb der ZIELWERT, nicht der Plan: Gibt es mehrere&quot;</span>)</span>
-<span id="cb209-317"><a href="#cb209-317" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;gleich teure Loesungen, darf jeder Solver eine andere davon liefern.&quot;</span>)</span>
-<span id="cb209-318"><a href="#cb209-318" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;Hier stimmen sie zufaellig ueberein - darauf zu testen waere trotzdem&quot;</span>)</span>
-<span id="cb209-319"><a href="#cb209-319" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;ein unzuverlaessiger Test (siehe JobShop_Intervalle.py).&quot;</span>)</span>
-<span id="cb209-320"><a href="#cb209-320" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;=&quot;</span> <span class="op">*</span> <span class="dv">82</span>)</span></code></pre></div>
+<div class="sourceCode" id="cb213"><pre class="sourceCode python"><code class="sourceCode python"><span id="cb213-1"><a href="#cb213-1" aria-hidden="true" tabindex="-1"></a><span class="co">#!/usr/bin/env python3</span></span>
+<span id="cb213-2"><a href="#cb213-2" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb213-3"><a href="#cb213-3" aria-hidden="true" tabindex="-1"></a><span class="co"># Solverwechsel_CPSAT_HiGHS.py</span></span>
+<span id="cb213-4"><a href="#cb213-4" aria-hidden="true" tabindex="-1"></a><span class="co">&quot;&quot;&quot;</span></span>
+<span id="cb213-5"><a href="#cb213-5" aria-hidden="true" tabindex="-1"></a><span class="co">Kapitel Praxisfallen: Denselben Fall einmal mit CP-SAT und einmal mit HiGHS rechnen.</span></span>
+<span id="cb213-6"><a href="#cb213-6" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb213-7"><a href="#cb213-7" aria-hidden="true" tabindex="-1"></a><span class="co">Die Trennung aus or_kern.py behauptet, ein Solverwechsel koste genau EINEN</span></span>
+<span id="cb213-8"><a href="#cb213-8" aria-hidden="true" tabindex="-1"></a><span class="co">Baustein. Dieses Programm loest diese Behauptung ein. Aufgabe ist eine</span></span>
+<span id="cb213-9"><a href="#cb213-9" aria-hidden="true" tabindex="-1"></a><span class="co">Standortplanung: Welche Lager oeffnen wir, und wer beliefert welchen Kunden?</span></span>
+<span id="cb213-10"><a href="#cb213-10" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb213-11"><a href="#cb213-11" aria-hidden="true" tabindex="-1"></a><span class="co">    Standortproblem  (Pydantic, geprueft)   &lt;- gemeinsam</span></span>
+<span id="cb213-12"><a href="#cb213-12" aria-hidden="true" tabindex="-1"></a><span class="co">        baue_und_loese_mit_cpsat()          &lt;- der EINE Baustein</span></span>
+<span id="cb213-13"><a href="#cb213-13" aria-hidden="true" tabindex="-1"></a><span class="co">        baue_und_loese_mit_highs()          &lt;- ... in zwei Ausfuehrungen</span></span>
+<span id="cb213-14"><a href="#cb213-14" aria-hidden="true" tabindex="-1"></a><span class="co">    Loesung          (DTO)                  &lt;- gemeinsam</span></span>
+<span id="cb213-15"><a href="#cb213-15" aria-hidden="true" tabindex="-1"></a><span class="co">    pruefe_zuordnung()                      &lt;- gemeinsam</span></span>
+<span id="cb213-16"><a href="#cb213-16" aria-hidden="true" tabindex="-1"></a><span class="co">    berichte()                              &lt;- gemeinsam</span></span>
+<span id="cb213-17"><a href="#cb213-17" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb213-18"><a href="#cb213-18" aria-hidden="true" tabindex="-1"></a><span class="co">Die beiden Modellbauer sind 39 und 52 Zeilen lang - sie sind der gesamte</span></span>
+<span id="cb213-19"><a href="#cb213-19" aria-hidden="true" tabindex="-1"></a><span class="co">solverabhaengige Teil des Programms. Alles andere wird zweimal benutzt und</span></span>
+<span id="cb213-20"><a href="#cb213-20" aria-hidden="true" tabindex="-1"></a><span class="co">einmal geschrieben.</span></span>
+<span id="cb213-21"><a href="#cb213-21" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb213-22"><a href="#cb213-22" aria-hidden="true" tabindex="-1"></a><span class="co">WARUM ZWEI PROZESSE? ortools und highspy bringen beide eine eigene</span></span>
+<span id="cb213-23"><a href="#cb213-23" aria-hidden="true" tabindex="-1"></a><span class="co">HiGHS-Kopie mit und lassen sich auf vielen Systemen nicht gemeinsam</span></span>
+<span id="cb213-24"><a href="#cb213-24" aria-hidden="true" tabindex="-1"></a><span class="co">importieren (Kapitel Oekosystem). Das Hauptprogramm startet deshalb fuer jeden</span></span>
+<span id="cb213-25"><a href="#cb213-25" aria-hidden="true" tabindex="-1"></a><span class="co">Solver einen eigenen Python-Prozess und laesst sich die Loesung als JSON</span></span>
+<span id="cb213-26"><a href="#cb213-26" aria-hidden="true" tabindex="-1"></a><span class="co">zurueckgeben - das DTO ist nicht nur eine Sprachregelung, sondern ein</span></span>
+<span id="cb213-27"><a href="#cb213-27" aria-hidden="true" tabindex="-1"></a><span class="co">Datenformat, das eine Prozessgrenze ueberlebt.</span></span>
+<span id="cb213-28"><a href="#cb213-28" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb213-29"><a href="#cb213-29" aria-hidden="true" tabindex="-1"></a><span class="co">Aufruf:</span></span>
+<span id="cb213-30"><a href="#cb213-30" aria-hidden="true" tabindex="-1"></a><span class="co">    python3 Solverwechsel_CPSAT_HiGHS.py            # beide, mit Vergleich</span></span>
+<span id="cb213-31"><a href="#cb213-31" aria-hidden="true" tabindex="-1"></a><span class="co">    python3 Solverwechsel_CPSAT_HiGHS.py cpsat      # nur der Kindprozess</span></span>
+<span id="cb213-32"><a href="#cb213-32" aria-hidden="true" tabindex="-1"></a><span class="co">    python3 Solverwechsel_CPSAT_HiGHS.py highs</span></span>
+<span id="cb213-33"><a href="#cb213-33" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb213-34"><a href="#cb213-34" aria-hidden="true" tabindex="-1"></a><span class="co">Benoetigt: numpy, pydantic, ortools, highspy (jeweils im eigenen Prozess)</span></span>
+<span id="cb213-35"><a href="#cb213-35" aria-hidden="true" tabindex="-1"></a><span class="co">&quot;&quot;&quot;</span></span>
+<span id="cb213-36"><a href="#cb213-36" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb213-37"><a href="#cb213-37" aria-hidden="true" tabindex="-1"></a><span class="im">from</span> __future__ <span class="im">import</span> annotations</span>
+<span id="cb213-38"><a href="#cb213-38" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb213-39"><a href="#cb213-39" aria-hidden="true" tabindex="-1"></a><span class="im">import</span> multiprocessing</span>
+<span id="cb213-40"><a href="#cb213-40" aria-hidden="true" tabindex="-1"></a><span class="im">import</span> time</span>
+<span id="cb213-41"><a href="#cb213-41" aria-hidden="true" tabindex="-1"></a><span class="im">from</span> concurrent.futures <span class="im">import</span> ProcessPoolExecutor</span>
+<span id="cb213-42"><a href="#cb213-42" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb213-43"><a href="#cb213-43" aria-hidden="true" tabindex="-1"></a><span class="im">import</span> numpy <span class="im">as</span> np</span>
+<span id="cb213-44"><a href="#cb213-44" aria-hidden="true" tabindex="-1"></a><span class="im">from</span> pydantic <span class="im">import</span> BaseModel, Field, model_validator</span>
+<span id="cb213-45"><a href="#cb213-45" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb213-46"><a href="#cb213-46" aria-hidden="true" tabindex="-1"></a><span class="im">from</span> or_kern <span class="im">import</span> Loesung, SolverStatus, status_von_cpsat, status_von_highs</span>
+<span id="cb213-47"><a href="#cb213-47" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb213-48"><a href="#cb213-48" aria-hidden="true" tabindex="-1"></a>ZEITLIMIT <span class="op">=</span> <span class="fl">30.0</span></span>
+<span id="cb213-49"><a href="#cb213-49" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb213-50"><a href="#cb213-50" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb213-51"><a href="#cb213-51" aria-hidden="true" tabindex="-1"></a><span class="co"># --- 1. Domaenenmodell: dieselben Fakten fuer beide Solver -------------------</span></span>
+<span id="cb213-52"><a href="#cb213-52" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb213-53"><a href="#cb213-53" aria-hidden="true" tabindex="-1"></a><span class="kw">class</span> Standortproblem(BaseModel):</span>
+<span id="cb213-54"><a href="#cb213-54" aria-hidden="true" tabindex="-1"></a>    <span class="co">&quot;&quot;&quot;Kapazitierte Standortplanung mit Einzelbelieferung.</span></span>
+<span id="cb213-55"><a href="#cb213-55" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb213-56"><a href="#cb213-56" aria-hidden="true" tabindex="-1"></a><span class="co">    Nach dem Muster von Produktionsproblem in or_kern.py: Die Pruefungen</span></span>
+<span id="cb213-57"><a href="#cb213-57" aria-hidden="true" tabindex="-1"></a><span class="co">    stehen im Konstruktor, nicht im Solvercode - sie gelten damit fuer beide</span></span>
+<span id="cb213-58"><a href="#cb213-58" aria-hidden="true" tabindex="-1"></a><span class="co">    Solver, und sie schlagen beim Einlesen zu.</span></span>
+<span id="cb213-59"><a href="#cb213-59" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb213-60"><a href="#cb213-60" aria-hidden="true" tabindex="-1"></a><span class="co">    Alle Kosten sind ganzzahlig (Euro). Das ist keine Bequemlichkeit, sondern</span></span>
+<span id="cb213-61"><a href="#cb213-61" aria-hidden="true" tabindex="-1"></a><span class="co">    Voraussetzung: CP-SAT rechnet ausschliesslich ganzzahlig.</span></span>
+<span id="cb213-62"><a href="#cb213-62" aria-hidden="true" tabindex="-1"></a><span class="co">    &quot;&quot;&quot;</span></span>
+<span id="cb213-63"><a href="#cb213-63" aria-hidden="true" tabindex="-1"></a>    lager: <span class="bu">list</span>[<span class="bu">str</span>] <span class="op">=</span> Field(min_length<span class="op">=</span><span class="dv">1</span>)</span>
+<span id="cb213-64"><a href="#cb213-64" aria-hidden="true" tabindex="-1"></a>    kunden: <span class="bu">list</span>[<span class="bu">str</span>] <span class="op">=</span> Field(min_length<span class="op">=</span><span class="dv">1</span>)</span>
+<span id="cb213-65"><a href="#cb213-65" aria-hidden="true" tabindex="-1"></a>    fixkosten: <span class="bu">list</span>[<span class="bu">int</span>]        <span class="co"># je Lager, faellt bei Eroeffnung an</span></span>
+<span id="cb213-66"><a href="#cb213-66" aria-hidden="true" tabindex="-1"></a>    kapazitaet: <span class="bu">list</span>[<span class="bu">int</span>]       <span class="co"># je Lager, in Paletten</span></span>
+<span id="cb213-67"><a href="#cb213-67" aria-hidden="true" tabindex="-1"></a>    bedarf: <span class="bu">list</span>[<span class="bu">int</span>]           <span class="co"># je Kunde, in Paletten</span></span>
+<span id="cb213-68"><a href="#cb213-68" aria-hidden="true" tabindex="-1"></a>    transport: <span class="bu">list</span>[<span class="bu">list</span>[<span class="bu">int</span>]]  <span class="co"># [Lager][Kunde], Kosten der Belieferung</span></span>
+<span id="cb213-69"><a href="#cb213-69" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb213-70"><a href="#cb213-70" aria-hidden="true" tabindex="-1"></a>    <span class="at">@model_validator</span>(mode<span class="op">=</span><span class="st">&quot;after&quot;</span>)</span>
+<span id="cb213-71"><a href="#cb213-71" aria-hidden="true" tabindex="-1"></a>    <span class="kw">def</span> pruefe_masse(<span class="va">self</span>) <span class="op">-&gt;</span> <span class="st">&quot;Standortproblem&quot;</span>:</span>
+<span id="cb213-72"><a href="#cb213-72" aria-hidden="true" tabindex="-1"></a>        n, m <span class="op">=</span> <span class="bu">len</span>(<span class="va">self</span>.lager), <span class="bu">len</span>(<span class="va">self</span>.kunden)</span>
+<span id="cb213-73"><a href="#cb213-73" aria-hidden="true" tabindex="-1"></a>        <span class="cf">if</span> <span class="bu">len</span>(<span class="va">self</span>.fixkosten) <span class="op">!=</span> n <span class="kw">or</span> <span class="bu">len</span>(<span class="va">self</span>.kapazitaet) <span class="op">!=</span> n:</span>
+<span id="cb213-74"><a href="#cb213-74" aria-hidden="true" tabindex="-1"></a>            <span class="cf">raise</span> <span class="pp">ValueError</span>(<span class="ss">f&quot;fixkosten/kapazitaet muessen </span><span class="sc">{</span>n<span class="sc">}</span><span class="ss"> Eintraege haben&quot;</span>)</span>
+<span id="cb213-75"><a href="#cb213-75" aria-hidden="true" tabindex="-1"></a>        <span class="cf">if</span> <span class="bu">len</span>(<span class="va">self</span>.bedarf) <span class="op">!=</span> m:</span>
+<span id="cb213-76"><a href="#cb213-76" aria-hidden="true" tabindex="-1"></a>            <span class="cf">raise</span> <span class="pp">ValueError</span>(<span class="ss">f&quot;bedarf muss </span><span class="sc">{</span>m<span class="sc">}</span><span class="ss"> Eintraege haben&quot;</span>)</span>
+<span id="cb213-77"><a href="#cb213-77" aria-hidden="true" tabindex="-1"></a>        <span class="cf">if</span> <span class="bu">len</span>(<span class="va">self</span>.transport) <span class="op">!=</span> n <span class="kw">or</span> <span class="bu">any</span>(<span class="bu">len</span>(z) <span class="op">!=</span> m <span class="cf">for</span> z <span class="kw">in</span> <span class="va">self</span>.transport):</span>
+<span id="cb213-78"><a href="#cb213-78" aria-hidden="true" tabindex="-1"></a>            <span class="cf">raise</span> <span class="pp">ValueError</span>(<span class="ss">f&quot;transport muss </span><span class="sc">{</span>n<span class="sc">}</span><span class="ss"> x </span><span class="sc">{</span>m<span class="sc">}</span><span class="ss"> sein&quot;</span>)</span>
+<span id="cb213-79"><a href="#cb213-79" aria-hidden="true" tabindex="-1"></a>        <span class="cf">if</span> <span class="bu">sum</span>(<span class="va">self</span>.kapazitaet) <span class="op">&lt;</span> <span class="bu">sum</span>(<span class="va">self</span>.bedarf):</span>
+<span id="cb213-80"><a href="#cb213-80" aria-hidden="true" tabindex="-1"></a>            <span class="cf">raise</span> <span class="pp">ValueError</span>(<span class="ss">f&quot;Gesamtkapazitaet </span><span class="sc">{</span><span class="bu">sum</span>(<span class="va">self</span>.kapazitaet)<span class="sc">}</span><span class="ss"> deckt den &quot;</span></span>
+<span id="cb213-81"><a href="#cb213-81" aria-hidden="true" tabindex="-1"></a>                             <span class="ss">f&quot;Gesamtbedarf </span><span class="sc">{</span><span class="bu">sum</span>(<span class="va">self</span>.bedarf)<span class="sc">}</span><span class="ss"> nicht&quot;</span>)</span>
+<span id="cb213-82"><a href="#cb213-82" aria-hidden="true" tabindex="-1"></a>        <span class="cf">return</span> <span class="va">self</span></span>
+<span id="cb213-83"><a href="#cb213-83" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb213-84"><a href="#cb213-84" aria-hidden="true" tabindex="-1"></a>    <span class="kw">def</span> schluessel(<span class="va">self</span>, i: <span class="bu">int</span>, j: <span class="bu">int</span>) <span class="op">-&gt;</span> <span class="bu">str</span>:</span>
+<span id="cb213-85"><a href="#cb213-85" aria-hidden="true" tabindex="-1"></a>        <span class="co">&quot;&quot;&quot;Variablenname im Loesung-DTO - beide Modellbauer benutzen ihn.&quot;&quot;&quot;</span></span>
+<span id="cb213-86"><a href="#cb213-86" aria-hidden="true" tabindex="-1"></a>        <span class="cf">return</span> <span class="ss">f&quot;</span><span class="sc">{</span><span class="va">self</span><span class="sc">.</span>lager[i]<span class="sc">}</span><span class="ss">-&gt;</span><span class="sc">{</span><span class="va">self</span><span class="sc">.</span>kunden[j]<span class="sc">}</span><span class="ss">&quot;</span></span>
+<span id="cb213-87"><a href="#cb213-87" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb213-88"><a href="#cb213-88" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb213-89"><a href="#cb213-89" aria-hidden="true" tabindex="-1"></a><span class="kw">def</span> beispielproblem(saat: <span class="bu">int</span> <span class="op">=</span> <span class="dv">11</span>) <span class="op">-&gt;</span> Standortproblem:</span>
+<span id="cb213-90"><a href="#cb213-90" aria-hidden="true" tabindex="-1"></a>    <span class="co">&quot;&quot;&quot;Sechs moegliche Lager, zwoelf Kunden - klein genug fuer beide Solver.&quot;&quot;&quot;</span></span>
+<span id="cb213-91"><a href="#cb213-91" aria-hidden="true" tabindex="-1"></a>    rng <span class="op">=</span> np.random.default_rng(saat)</span>
+<span id="cb213-92"><a href="#cb213-92" aria-hidden="true" tabindex="-1"></a>    lager <span class="op">=</span> [<span class="ss">f&quot;Lager_</span><span class="sc">{</span>k<span class="sc">}</span><span class="ss">&quot;</span> <span class="cf">for</span> k <span class="kw">in</span> <span class="st">&quot;ABCDEF&quot;</span>]</span>
+<span id="cb213-93"><a href="#cb213-93" aria-hidden="true" tabindex="-1"></a>    kunden <span class="op">=</span> [<span class="ss">f&quot;Kunde_</span><span class="sc">{</span>k<span class="sc">:02d}</span><span class="ss">&quot;</span> <span class="cf">for</span> k <span class="kw">in</span> <span class="bu">range</span>(<span class="dv">1</span>, <span class="dv">13</span>)]</span>
+<span id="cb213-94"><a href="#cb213-94" aria-hidden="true" tabindex="-1"></a>    bedarf <span class="op">=</span> rng.integers(<span class="dv">10</span>, <span class="dv">60</span>, <span class="bu">len</span>(kunden))</span>
+<span id="cb213-95"><a href="#cb213-95" aria-hidden="true" tabindex="-1"></a>    <span class="cf">return</span> Standortproblem(</span>
+<span id="cb213-96"><a href="#cb213-96" aria-hidden="true" tabindex="-1"></a>        lager<span class="op">=</span>lager,</span>
+<span id="cb213-97"><a href="#cb213-97" aria-hidden="true" tabindex="-1"></a>        kunden<span class="op">=</span>kunden,</span>
+<span id="cb213-98"><a href="#cb213-98" aria-hidden="true" tabindex="-1"></a>        fixkosten<span class="op">=</span>rng.integers(<span class="dv">3000</span>, <span class="dv">9000</span>, <span class="bu">len</span>(lager)).tolist(),</span>
+<span id="cb213-99"><a href="#cb213-99" aria-hidden="true" tabindex="-1"></a>        kapazitaet<span class="op">=</span>[<span class="bu">int</span>(bedarf.<span class="bu">sum</span>() <span class="op">*</span> <span class="fl">0.45</span>)] <span class="op">*</span> <span class="bu">len</span>(lager),</span>
+<span id="cb213-100"><a href="#cb213-100" aria-hidden="true" tabindex="-1"></a>        bedarf<span class="op">=</span>bedarf.tolist(),</span>
+<span id="cb213-101"><a href="#cb213-101" aria-hidden="true" tabindex="-1"></a>        transport<span class="op">=</span>rng.integers(<span class="dv">200</span>, <span class="dv">1800</span>, (<span class="bu">len</span>(lager), <span class="bu">len</span>(kunden))).tolist(),</span>
+<span id="cb213-102"><a href="#cb213-102" aria-hidden="true" tabindex="-1"></a>    )</span>
+<span id="cb213-103"><a href="#cb213-103" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb213-104"><a href="#cb213-104" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb213-105"><a href="#cb213-105" aria-hidden="true" tabindex="-1"></a><span class="co"># --- 2. Der eine Baustein, der sich aendert: der Modellbauer -----------------</span></span>
+<span id="cb213-106"><a href="#cb213-106" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb213-107"><a href="#cb213-107" aria-hidden="true" tabindex="-1"></a><span class="kw">def</span> baue_und_loese_mit_cpsat(problem: Standortproblem) <span class="op">-&gt;</span> Loesung:</span>
+<span id="cb213-108"><a href="#cb213-108" aria-hidden="true" tabindex="-1"></a>    <span class="co">&quot;&quot;&quot;CP-SAT: Bool-Variablen, ganzzahlige Koeffizienten, Minimize.&quot;&quot;&quot;</span></span>
+<span id="cb213-109"><a href="#cb213-109" aria-hidden="true" tabindex="-1"></a>    <span class="im">from</span> ortools.sat.python <span class="im">import</span> cp_model</span>
+<span id="cb213-110"><a href="#cb213-110" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb213-111"><a href="#cb213-111" aria-hidden="true" tabindex="-1"></a>    n, m <span class="op">=</span> <span class="bu">len</span>(problem.lager), <span class="bu">len</span>(problem.kunden)</span>
+<span id="cb213-112"><a href="#cb213-112" aria-hidden="true" tabindex="-1"></a>    modell <span class="op">=</span> cp_model.CpModel()</span>
+<span id="cb213-113"><a href="#cb213-113" aria-hidden="true" tabindex="-1"></a>    y <span class="op">=</span> [modell.NewBoolVar(<span class="ss">f&quot;offen_</span><span class="sc">{</span>i<span class="sc">}</span><span class="ss">&quot;</span>) <span class="cf">for</span> i <span class="kw">in</span> <span class="bu">range</span>(n)]</span>
+<span id="cb213-114"><a href="#cb213-114" aria-hidden="true" tabindex="-1"></a>    x <span class="op">=</span> {(i, j): modell.NewBoolVar(<span class="ss">f&quot;liefert_</span><span class="sc">{</span>i<span class="sc">}</span><span class="ss">_</span><span class="sc">{</span>j<span class="sc">}</span><span class="ss">&quot;</span>)</span>
+<span id="cb213-115"><a href="#cb213-115" aria-hidden="true" tabindex="-1"></a>         <span class="cf">for</span> i <span class="kw">in</span> <span class="bu">range</span>(n) <span class="cf">for</span> j <span class="kw">in</span> <span class="bu">range</span>(m)}</span>
+<span id="cb213-116"><a href="#cb213-116" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb213-117"><a href="#cb213-117" aria-hidden="true" tabindex="-1"></a>    <span class="cf">for</span> j <span class="kw">in</span> <span class="bu">range</span>(m):                                   <span class="co"># jeder Kunde genau einmal</span></span>
+<span id="cb213-118"><a href="#cb213-118" aria-hidden="true" tabindex="-1"></a>        modell.AddExactlyOne(x[i, j] <span class="cf">for</span> i <span class="kw">in</span> <span class="bu">range</span>(n))</span>
+<span id="cb213-119"><a href="#cb213-119" aria-hidden="true" tabindex="-1"></a>    <span class="cf">for</span> i <span class="kw">in</span> <span class="bu">range</span>(n):</span>
+<span id="cb213-120"><a href="#cb213-120" aria-hidden="true" tabindex="-1"></a>        <span class="cf">for</span> j <span class="kw">in</span> <span class="bu">range</span>(m):                               <span class="co"># nur aus offenen Lagern</span></span>
+<span id="cb213-121"><a href="#cb213-121" aria-hidden="true" tabindex="-1"></a>            modell.AddImplication(x[i, j], y[i])</span>
+<span id="cb213-122"><a href="#cb213-122" aria-hidden="true" tabindex="-1"></a>        modell.Add(<span class="bu">sum</span>(problem.bedarf[j] <span class="op">*</span> x[i, j] <span class="cf">for</span> j <span class="kw">in</span> <span class="bu">range</span>(m))</span>
+<span id="cb213-123"><a href="#cb213-123" aria-hidden="true" tabindex="-1"></a>                   <span class="op">&lt;=</span> problem.kapazitaet[i] <span class="op">*</span> y[i])      <span class="co"># Kapazitaet</span></span>
+<span id="cb213-124"><a href="#cb213-124" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb213-125"><a href="#cb213-125" aria-hidden="true" tabindex="-1"></a>    modell.Minimize(</span>
+<span id="cb213-126"><a href="#cb213-126" aria-hidden="true" tabindex="-1"></a>        <span class="bu">sum</span>(problem.fixkosten[i] <span class="op">*</span> y[i] <span class="cf">for</span> i <span class="kw">in</span> <span class="bu">range</span>(n))</span>
+<span id="cb213-127"><a href="#cb213-127" aria-hidden="true" tabindex="-1"></a>        <span class="op">+</span> <span class="bu">sum</span>(problem.transport[i][j] <span class="op">*</span> x[i, j] <span class="cf">for</span> i <span class="kw">in</span> <span class="bu">range</span>(n) <span class="cf">for</span> j <span class="kw">in</span> <span class="bu">range</span>(m)))</span>
+<span id="cb213-128"><a href="#cb213-128" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb213-129"><a href="#cb213-129" aria-hidden="true" tabindex="-1"></a>    loeser <span class="op">=</span> cp_model.CpSolver()</span>
+<span id="cb213-130"><a href="#cb213-130" aria-hidden="true" tabindex="-1"></a>    loeser.parameters.max_time_in_seconds <span class="op">=</span> ZEITLIMIT</span>
+<span id="cb213-131"><a href="#cb213-131" aria-hidden="true" tabindex="-1"></a>    loeser.parameters.num_workers <span class="op">=</span> <span class="dv">1</span></span>
+<span id="cb213-132"><a href="#cb213-132" aria-hidden="true" tabindex="-1"></a>    loeser.parameters.random_seed <span class="op">=</span> <span class="dv">1</span></span>
+<span id="cb213-133"><a href="#cb213-133" aria-hidden="true" tabindex="-1"></a>    status <span class="op">=</span> status_von_cpsat(loeser.Solve(modell))</span>
+<span id="cb213-134"><a href="#cb213-134" aria-hidden="true" tabindex="-1"></a>    <span class="cf">if</span> <span class="kw">not</span> status.brauchbar:</span>
+<span id="cb213-135"><a href="#cb213-135" aria-hidden="true" tabindex="-1"></a>        <span class="cf">return</span> Loesung(status<span class="op">=</span>status, laufzeit<span class="op">=</span>loeser.WallTime())</span>
+<span id="cb213-136"><a href="#cb213-136" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb213-137"><a href="#cb213-137" aria-hidden="true" tabindex="-1"></a>    <span class="cf">return</span> Loesung(</span>
+<span id="cb213-138"><a href="#cb213-138" aria-hidden="true" tabindex="-1"></a>        status<span class="op">=</span>status,</span>
+<span id="cb213-139"><a href="#cb213-139" aria-hidden="true" tabindex="-1"></a>        werte<span class="op">=</span>{problem.schluessel(i, j): <span class="bu">float</span>(loeser.Value(x[i, j]))</span>
+<span id="cb213-140"><a href="#cb213-140" aria-hidden="true" tabindex="-1"></a>               <span class="cf">for</span> i <span class="kw">in</span> <span class="bu">range</span>(n) <span class="cf">for</span> j <span class="kw">in</span> <span class="bu">range</span>(m)},</span>
+<span id="cb213-141"><a href="#cb213-141" aria-hidden="true" tabindex="-1"></a>        zielwert<span class="op">=</span>loeser.ObjectiveValue(),</span>
+<span id="cb213-142"><a href="#cb213-142" aria-hidden="true" tabindex="-1"></a>        schranke<span class="op">=</span>loeser.BestObjectiveBound(),</span>
+<span id="cb213-143"><a href="#cb213-143" aria-hidden="true" tabindex="-1"></a>        laufzeit<span class="op">=</span>loeser.WallTime())</span>
+<span id="cb213-144"><a href="#cb213-144" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb213-145"><a href="#cb213-145" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb213-146"><a href="#cb213-146" aria-hidden="true" tabindex="-1"></a><span class="kw">def</span> baue_und_loese_mit_highs(problem: Standortproblem) <span class="op">-&gt;</span> Loesung:</span>
+<span id="cb213-147"><a href="#cb213-147" aria-hidden="true" tabindex="-1"></a>    <span class="co">&quot;&quot;&quot;HiGHS: dieselben Restriktionen als Ungleichungszeilen einer Matrix.&quot;&quot;&quot;</span></span>
+<span id="cb213-148"><a href="#cb213-148" aria-hidden="true" tabindex="-1"></a>    <span class="im">import</span> highspy</span>
+<span id="cb213-149"><a href="#cb213-149" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb213-150"><a href="#cb213-150" aria-hidden="true" tabindex="-1"></a>    n, m <span class="op">=</span> <span class="bu">len</span>(problem.lager), <span class="bu">len</span>(problem.kunden)</span>
+<span id="cb213-151"><a href="#cb213-151" aria-hidden="true" tabindex="-1"></a>    anzahl_x <span class="op">=</span> n <span class="op">*</span> m                                     <span class="co"># Spalten 0..n*m-1</span></span>
+<span id="cb213-152"><a href="#cb213-152" aria-hidden="true" tabindex="-1"></a>    spalte_y <span class="op">=</span> <span class="kw">lambda</span> i: anzahl_x <span class="op">+</span> i                    <span class="co"># danach die y_i  # noqa: E731</span></span>
+<span id="cb213-153"><a href="#cb213-153" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb213-154"><a href="#cb213-154" aria-hidden="true" tabindex="-1"></a>    modell <span class="op">=</span> highspy.Highs()</span>
+<span id="cb213-155"><a href="#cb213-155" aria-hidden="true" tabindex="-1"></a>    modell.setOptionValue(<span class="st">&quot;output_flag&quot;</span>, <span class="va">False</span>)</span>
+<span id="cb213-156"><a href="#cb213-156" aria-hidden="true" tabindex="-1"></a>    modell.setOptionValue(<span class="st">&quot;time_limit&quot;</span>, ZEITLIMIT)</span>
+<span id="cb213-157"><a href="#cb213-157" aria-hidden="true" tabindex="-1"></a>    modell.addVars(anzahl_x <span class="op">+</span> n, np.zeros(anzahl_x <span class="op">+</span> n), np.ones(anzahl_x <span class="op">+</span> n))</span>
+<span id="cb213-158"><a href="#cb213-158" aria-hidden="true" tabindex="-1"></a>    <span class="cf">for</span> spalte <span class="kw">in</span> <span class="bu">range</span>(anzahl_x <span class="op">+</span> n):</span>
+<span id="cb213-159"><a href="#cb213-159" aria-hidden="true" tabindex="-1"></a>        modell.changeColIntegrality(spalte, highspy.HighsVarType.kInteger)</span>
+<span id="cb213-160"><a href="#cb213-160" aria-hidden="true" tabindex="-1"></a>    <span class="cf">for</span> i <span class="kw">in</span> <span class="bu">range</span>(n):</span>
+<span id="cb213-161"><a href="#cb213-161" aria-hidden="true" tabindex="-1"></a>        modell.changeColCost(spalte_y(i), <span class="bu">float</span>(problem.fixkosten[i]))</span>
+<span id="cb213-162"><a href="#cb213-162" aria-hidden="true" tabindex="-1"></a>        <span class="cf">for</span> j <span class="kw">in</span> <span class="bu">range</span>(m):</span>
+<span id="cb213-163"><a href="#cb213-163" aria-hidden="true" tabindex="-1"></a>            modell.changeColCost(i <span class="op">*</span> m <span class="op">+</span> j, <span class="bu">float</span>(problem.transport[i][j]))</span>
+<span id="cb213-164"><a href="#cb213-164" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb213-165"><a href="#cb213-165" aria-hidden="true" tabindex="-1"></a>    <span class="cf">for</span> j <span class="kw">in</span> <span class="bu">range</span>(m):                                   <span class="co"># jeder Kunde genau einmal</span></span>
+<span id="cb213-166"><a href="#cb213-166" aria-hidden="true" tabindex="-1"></a>        index <span class="op">=</span> np.array([i <span class="op">*</span> m <span class="op">+</span> j <span class="cf">for</span> i <span class="kw">in</span> <span class="bu">range</span>(n)], dtype<span class="op">=</span>np.int32)</span>
+<span id="cb213-167"><a href="#cb213-167" aria-hidden="true" tabindex="-1"></a>        modell.addRow(<span class="fl">1.0</span>, <span class="fl">1.0</span>, n, index, np.ones(n))</span>
+<span id="cb213-168"><a href="#cb213-168" aria-hidden="true" tabindex="-1"></a>    <span class="cf">for</span> i <span class="kw">in</span> <span class="bu">range</span>(n):</span>
+<span id="cb213-169"><a href="#cb213-169" aria-hidden="true" tabindex="-1"></a>        <span class="cf">for</span> j <span class="kw">in</span> <span class="bu">range</span>(m):                               <span class="co"># x_ij - y_i &lt;= 0</span></span>
+<span id="cb213-170"><a href="#cb213-170" aria-hidden="true" tabindex="-1"></a>            modell.addRow(<span class="op">-</span>highspy.kHighsInf, <span class="fl">0.0</span>, <span class="dv">2</span>,</span>
+<span id="cb213-171"><a href="#cb213-171" aria-hidden="true" tabindex="-1"></a>                          np.array([i <span class="op">*</span> m <span class="op">+</span> j, spalte_y(i)], dtype<span class="op">=</span>np.int32),</span>
+<span id="cb213-172"><a href="#cb213-172" aria-hidden="true" tabindex="-1"></a>                          np.array([<span class="fl">1.0</span>, <span class="op">-</span><span class="fl">1.0</span>]))</span>
+<span id="cb213-173"><a href="#cb213-173" aria-hidden="true" tabindex="-1"></a>        index <span class="op">=</span> np.array([i <span class="op">*</span> m <span class="op">+</span> j <span class="cf">for</span> j <span class="kw">in</span> <span class="bu">range</span>(m)] <span class="op">+</span> [spalte_y(i)],</span>
+<span id="cb213-174"><a href="#cb213-174" aria-hidden="true" tabindex="-1"></a>                         dtype<span class="op">=</span>np.int32)                 <span class="co"># Kapazitaet</span></span>
+<span id="cb213-175"><a href="#cb213-175" aria-hidden="true" tabindex="-1"></a>        werte <span class="op">=</span> np.concatenate([np.array(problem.bedarf, dtype<span class="op">=</span><span class="bu">float</span>),</span>
+<span id="cb213-176"><a href="#cb213-176" aria-hidden="true" tabindex="-1"></a>                                [<span class="op">-</span><span class="bu">float</span>(problem.kapazitaet[i])]])</span>
+<span id="cb213-177"><a href="#cb213-177" aria-hidden="true" tabindex="-1"></a>        modell.addRow(<span class="op">-</span>highspy.kHighsInf, <span class="fl">0.0</span>, m <span class="op">+</span> <span class="dv">1</span>, index, werte)</span>
+<span id="cb213-178"><a href="#cb213-178" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb213-179"><a href="#cb213-179" aria-hidden="true" tabindex="-1"></a>    t0 <span class="op">=</span> time.perf_counter()</span>
+<span id="cb213-180"><a href="#cb213-180" aria-hidden="true" tabindex="-1"></a>    modell.run()</span>
+<span id="cb213-181"><a href="#cb213-181" aria-hidden="true" tabindex="-1"></a>    laufzeit <span class="op">=</span> time.perf_counter() <span class="op">-</span> t0</span>
+<span id="cb213-182"><a href="#cb213-182" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb213-183"><a href="#cb213-183" aria-hidden="true" tabindex="-1"></a>    status <span class="op">=</span> status_von_highs(modell.modelStatusToString(modell.getModelStatus()))</span>
+<span id="cb213-184"><a href="#cb213-184" aria-hidden="true" tabindex="-1"></a>    <span class="cf">if</span> <span class="kw">not</span> status.brauchbar:</span>
+<span id="cb213-185"><a href="#cb213-185" aria-hidden="true" tabindex="-1"></a>        <span class="cf">return</span> Loesung(status<span class="op">=</span>status, laufzeit<span class="op">=</span>laufzeit)</span>
+<span id="cb213-186"><a href="#cb213-186" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb213-187"><a href="#cb213-187" aria-hidden="true" tabindex="-1"></a>    loesungswerte <span class="op">=</span> modell.getSolution().col_value</span>
+<span id="cb213-188"><a href="#cb213-188" aria-hidden="true" tabindex="-1"></a>    info <span class="op">=</span> modell.getInfo()</span>
+<span id="cb213-189"><a href="#cb213-189" aria-hidden="true" tabindex="-1"></a>    <span class="cf">return</span> Loesung(</span>
+<span id="cb213-190"><a href="#cb213-190" aria-hidden="true" tabindex="-1"></a>        status<span class="op">=</span>status,</span>
+<span id="cb213-191"><a href="#cb213-191" aria-hidden="true" tabindex="-1"></a>        werte<span class="op">=</span>{problem.schluessel(i, j): <span class="bu">float</span>(loesungswerte[i <span class="op">*</span> m <span class="op">+</span> j])</span>
+<span id="cb213-192"><a href="#cb213-192" aria-hidden="true" tabindex="-1"></a>               <span class="cf">for</span> i <span class="kw">in</span> <span class="bu">range</span>(n) <span class="cf">for</span> j <span class="kw">in</span> <span class="bu">range</span>(m)},</span>
+<span id="cb213-193"><a href="#cb213-193" aria-hidden="true" tabindex="-1"></a>        zielwert<span class="op">=</span>info.objective_function_value,</span>
+<span id="cb213-194"><a href="#cb213-194" aria-hidden="true" tabindex="-1"></a>        schranke<span class="op">=</span>info.mip_dual_bound,</span>
+<span id="cb213-195"><a href="#cb213-195" aria-hidden="true" tabindex="-1"></a>        laufzeit<span class="op">=</span>laufzeit)</span>
+<span id="cb213-196"><a href="#cb213-196" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb213-197"><a href="#cb213-197" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb213-198"><a href="#cb213-198" aria-hidden="true" tabindex="-1"></a>MODELLBAUER <span class="op">=</span> {<span class="st">&quot;cpsat&quot;</span>: baue_und_loese_mit_cpsat, <span class="st">&quot;highs&quot;</span>: baue_und_loese_mit_highs}</span>
+<span id="cb213-199"><a href="#cb213-199" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb213-200"><a href="#cb213-200" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb213-201"><a href="#cb213-201" aria-hidden="true" tabindex="-1"></a><span class="co"># --- 3. Alles Weitere ist wieder gemeinsam -----------------------------------</span></span>
+<span id="cb213-202"><a href="#cb213-202" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb213-203"><a href="#cb213-203" aria-hidden="true" tabindex="-1"></a><span class="kw">def</span> pruefe_zuordnung(problem: Standortproblem, loesung: Loesung,</span>
+<span id="cb213-204"><a href="#cb213-204" aria-hidden="true" tabindex="-1"></a>                     toleranz: <span class="bu">float</span> <span class="op">=</span> <span class="fl">1e-6</span>) <span class="op">-&gt;</span> <span class="bu">list</span>[<span class="bu">str</span>]:</span>
+<span id="cb213-205"><a href="#cb213-205" aria-hidden="true" tabindex="-1"></a>    <span class="co">&quot;&quot;&quot;Prueft die Loesung gegen die Anforderung - ohne Solver, ohne Modell.&quot;&quot;&quot;</span></span>
+<span id="cb213-206"><a href="#cb213-206" aria-hidden="true" tabindex="-1"></a>    <span class="cf">if</span> <span class="kw">not</span> loesung.status.brauchbar:</span>
+<span id="cb213-207"><a href="#cb213-207" aria-hidden="true" tabindex="-1"></a>        <span class="cf">return</span> [<span class="ss">f&quot;kein verwertbares Ergebnis (</span><span class="sc">{</span>loesung<span class="sc">.</span>status<span class="sc">.</span>value<span class="sc">}</span><span class="ss">)&quot;</span>]</span>
+<span id="cb213-208"><a href="#cb213-208" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb213-209"><a href="#cb213-209" aria-hidden="true" tabindex="-1"></a>    n, m <span class="op">=</span> <span class="bu">len</span>(problem.lager), <span class="bu">len</span>(problem.kunden)</span>
+<span id="cb213-210"><a href="#cb213-210" aria-hidden="true" tabindex="-1"></a>    zuordnung <span class="op">=</span> np.array([[loesung.werte[problem.schluessel(i, j)]</span>
+<span id="cb213-211"><a href="#cb213-211" aria-hidden="true" tabindex="-1"></a>                           <span class="cf">for</span> j <span class="kw">in</span> <span class="bu">range</span>(m)] <span class="cf">for</span> i <span class="kw">in</span> <span class="bu">range</span>(n)])</span>
+<span id="cb213-212"><a href="#cb213-212" aria-hidden="true" tabindex="-1"></a>    beanstandungen: <span class="bu">list</span>[<span class="bu">str</span>] <span class="op">=</span> []</span>
+<span id="cb213-213"><a href="#cb213-213" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb213-214"><a href="#cb213-214" aria-hidden="true" tabindex="-1"></a>    <span class="cf">if</span> (np.<span class="bu">abs</span>(zuordnung <span class="op">-</span> np.<span class="bu">round</span>(zuordnung)) <span class="op">&gt;</span> toleranz).<span class="bu">any</span>():</span>
+<span id="cb213-215"><a href="#cb213-215" aria-hidden="true" tabindex="-1"></a>        beanstandungen.append(<span class="st">&quot;Zuordnungen sind nicht 0/1&quot;</span>)</span>
+<span id="cb213-216"><a href="#cb213-216" aria-hidden="true" tabindex="-1"></a>    zuordnung <span class="op">=</span> np.<span class="bu">round</span>(zuordnung)</span>
+<span id="cb213-217"><a href="#cb213-217" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb213-218"><a href="#cb213-218" aria-hidden="true" tabindex="-1"></a>    <span class="cf">for</span> j, kunde <span class="kw">in</span> <span class="bu">enumerate</span>(problem.kunden):</span>
+<span id="cb213-219"><a href="#cb213-219" aria-hidden="true" tabindex="-1"></a>        <span class="cf">if</span> <span class="bu">abs</span>(zuordnung[:, j].<span class="bu">sum</span>() <span class="op">-</span> <span class="fl">1.0</span>) <span class="op">&gt;</span> toleranz:</span>
+<span id="cb213-220"><a href="#cb213-220" aria-hidden="true" tabindex="-1"></a>            beanstandungen.append(<span class="ss">f&quot;</span><span class="sc">{</span>kunde<span class="sc">}</span><span class="ss"> wird </span><span class="sc">{</span>zuordnung[:, j]<span class="sc">.</span><span class="bu">sum</span>()<span class="sc">:.0f}</span><span class="ss">-mal beliefert&quot;</span>)</span>
+<span id="cb213-221"><a href="#cb213-221" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb213-222"><a href="#cb213-222" aria-hidden="true" tabindex="-1"></a>    beliefert <span class="op">=</span> zuordnung <span class="op">@</span> np.array(problem.bedarf, dtype<span class="op">=</span><span class="bu">float</span>)</span>
+<span id="cb213-223"><a href="#cb213-223" aria-hidden="true" tabindex="-1"></a>    <span class="cf">for</span> i, lagername <span class="kw">in</span> <span class="bu">enumerate</span>(problem.lager):</span>
+<span id="cb213-224"><a href="#cb213-224" aria-hidden="true" tabindex="-1"></a>        <span class="cf">if</span> beliefert[i] <span class="op">&gt;</span> problem.kapazitaet[i] <span class="op">+</span> toleranz:</span>
+<span id="cb213-225"><a href="#cb213-225" aria-hidden="true" tabindex="-1"></a>            beanstandungen.append(<span class="ss">f&quot;</span><span class="sc">{</span>lagername<span class="sc">}</span><span class="ss">: </span><span class="sc">{</span>beliefert[i]<span class="sc">:.0f}</span><span class="ss"> Paletten ueber &quot;</span></span>
+<span id="cb213-226"><a href="#cb213-226" aria-hidden="true" tabindex="-1"></a>                                  <span class="ss">f&quot;Kapazitaet </span><span class="sc">{</span>problem<span class="sc">.</span>kapazitaet[i]<span class="sc">}</span><span class="ss">&quot;</span>)</span>
+<span id="cb213-227"><a href="#cb213-227" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb213-228"><a href="#cb213-228" aria-hidden="true" tabindex="-1"></a>    <span class="cf">if</span> loesung.zielwert <span class="kw">is</span> <span class="kw">not</span> <span class="va">None</span>:</span>
+<span id="cb213-229"><a href="#cb213-229" aria-hidden="true" tabindex="-1"></a>        offen <span class="op">=</span> beliefert <span class="op">&gt;</span> toleranz</span>
+<span id="cb213-230"><a href="#cb213-230" aria-hidden="true" tabindex="-1"></a>        nachgerechnet <span class="op">=</span> (np.array(problem.fixkosten, dtype<span class="op">=</span><span class="bu">float</span>) <span class="op">@</span> offen</span>
+<span id="cb213-231"><a href="#cb213-231" aria-hidden="true" tabindex="-1"></a>                         <span class="op">+</span> (np.array(problem.transport, dtype<span class="op">=</span><span class="bu">float</span>) <span class="op">*</span> zuordnung).<span class="bu">sum</span>())</span>
+<span id="cb213-232"><a href="#cb213-232" aria-hidden="true" tabindex="-1"></a>        <span class="cf">if</span> <span class="bu">abs</span>(nachgerechnet <span class="op">-</span> loesung.zielwert) <span class="op">&gt;</span> <span class="fl">0.5</span>:</span>
+<span id="cb213-233"><a href="#cb213-233" aria-hidden="true" tabindex="-1"></a>            beanstandungen.append(<span class="ss">f&quot;Zielwert </span><span class="sc">{</span>loesung<span class="sc">.</span>zielwert<span class="sc">:,.0f}</span><span class="ss"> passt nicht zur &quot;</span></span>
+<span id="cb213-234"><a href="#cb213-234" aria-hidden="true" tabindex="-1"></a>                                  <span class="ss">f&quot;Zuordnung (nachgerechnet </span><span class="sc">{</span>nachgerechnet<span class="sc">:,.0f}</span><span class="ss">)&quot;</span>)</span>
+<span id="cb213-235"><a href="#cb213-235" aria-hidden="true" tabindex="-1"></a>    <span class="cf">return</span> beanstandungen</span>
+<span id="cb213-236"><a href="#cb213-236" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb213-237"><a href="#cb213-237" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb213-238"><a href="#cb213-238" aria-hidden="true" tabindex="-1"></a><span class="kw">def</span> geoeffnete_lager(problem: Standortproblem, loesung: Loesung) <span class="op">-&gt;</span> <span class="bu">list</span>[<span class="bu">str</span>]:</span>
+<span id="cb213-239"><a href="#cb213-239" aria-hidden="true" tabindex="-1"></a>    m <span class="op">=</span> <span class="bu">len</span>(problem.kunden)</span>
+<span id="cb213-240"><a href="#cb213-240" aria-hidden="true" tabindex="-1"></a>    <span class="cf">return</span> [name <span class="cf">for</span> i, name <span class="kw">in</span> <span class="bu">enumerate</span>(problem.lager)</span>
+<span id="cb213-241"><a href="#cb213-241" aria-hidden="true" tabindex="-1"></a>            <span class="cf">if</span> <span class="bu">any</span>(loesung.werte[problem.schluessel(i, j)] <span class="op">&gt;</span> <span class="fl">0.5</span> <span class="cf">for</span> j <span class="kw">in</span> <span class="bu">range</span>(m))]</span>
+<span id="cb213-242"><a href="#cb213-242" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb213-243"><a href="#cb213-243" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb213-244"><a href="#cb213-244" aria-hidden="true" tabindex="-1"></a><span class="kw">def</span> loese_in_eigenem_prozess(name: <span class="bu">str</span>, problem: Standortproblem) <span class="op">-&gt;</span> Loesung:</span>
+<span id="cb213-245"><a href="#cb213-245" aria-hidden="true" tabindex="-1"></a>    <span class="co">&quot;&quot;&quot;Laesst genau einen Modellbauer in einem frischen Prozess rechnen.</span></span>
+<span id="cb213-246"><a href="#cb213-246" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb213-247"><a href="#cb213-247" aria-hidden="true" tabindex="-1"></a><span class="co">    &#39;spawn&#39; statt des Linux-Standards &#39;fork&#39;: Der Kindprozess startet mit</span></span>
+<span id="cb213-248"><a href="#cb213-248" aria-hidden="true" tabindex="-1"></a><span class="co">    einem leeren Interpreter und importiert nur den Solver, den SEIN</span></span>
+<span id="cb213-249"><a href="#cb213-249" aria-hidden="true" tabindex="-1"></a><span class="co">    Modellbauer braucht. max_tasks_per_child=1 sorgt dafuer, dass der Pool</span></span>
+<span id="cb213-250"><a href="#cb213-250" aria-hidden="true" tabindex="-1"></a><span class="co">    seinen Arbeiter nicht wiederverwendet - sonst saessen beim zweiten Aufruf</span></span>
+<span id="cb213-251"><a href="#cb213-251" aria-hidden="true" tabindex="-1"></a><span class="co">    wieder beide Bibliotheken im selben Prozess.</span></span>
+<span id="cb213-252"><a href="#cb213-252" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb213-253"><a href="#cb213-253" aria-hidden="true" tabindex="-1"></a><span class="co">    Hin und zurueck wandert das Domaenenmodell bzw. das Loesungs-DTO. Beide</span></span>
+<span id="cb213-254"><a href="#cb213-254" aria-hidden="true" tabindex="-1"></a><span class="co">    kennen keinen Solver, sind also serialisierbar - genau dafuer sind sie da.</span></span>
+<span id="cb213-255"><a href="#cb213-255" aria-hidden="true" tabindex="-1"></a><span class="co">    &quot;&quot;&quot;</span></span>
+<span id="cb213-256"><a href="#cb213-256" aria-hidden="true" tabindex="-1"></a>    <span class="cf">with</span> ProcessPoolExecutor(</span>
+<span id="cb213-257"><a href="#cb213-257" aria-hidden="true" tabindex="-1"></a>            max_workers<span class="op">=</span><span class="dv">1</span>,</span>
+<span id="cb213-258"><a href="#cb213-258" aria-hidden="true" tabindex="-1"></a>            mp_context<span class="op">=</span>multiprocessing.get_context(<span class="st">&quot;spawn&quot;</span>),</span>
+<span id="cb213-259"><a href="#cb213-259" aria-hidden="true" tabindex="-1"></a>            max_tasks_per_child<span class="op">=</span><span class="dv">1</span>) <span class="im">as</span> pool:</span>
+<span id="cb213-260"><a href="#cb213-260" aria-hidden="true" tabindex="-1"></a>        <span class="cf">return</span> pool.submit(MODELLBAUER[name], problem).result(timeout<span class="op">=</span><span class="dv">300</span>)</span>
+<span id="cb213-261"><a href="#cb213-261" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb213-262"><a href="#cb213-262" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb213-263"><a href="#cb213-263" aria-hidden="true" tabindex="-1"></a><span class="cf">if</span> <span class="va">__name__</span> <span class="op">==</span> <span class="st">&quot;__main__&quot;</span>:</span>
+<span id="cb213-264"><a href="#cb213-264" aria-hidden="true" tabindex="-1"></a>    problem <span class="op">=</span> beispielproblem()</span>
+<span id="cb213-265"><a href="#cb213-265" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb213-266"><a href="#cb213-266" aria-hidden="true" tabindex="-1"></a>    <span class="co"># --- Beide Solver anstossen und vergleichen ---------------------------</span></span>
+<span id="cb213-267"><a href="#cb213-267" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;=&quot;</span> <span class="op">*</span> <span class="dv">82</span>)</span>
+<span id="cb213-268"><a href="#cb213-268" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;  DERSELBE FALL, ZWEI SOLVER - UND EIN AUSWERTUNGSCODE&quot;</span>)</span>
+<span id="cb213-269"><a href="#cb213-269" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;=&quot;</span> <span class="op">*</span> <span class="dv">82</span>)</span>
+<span id="cb213-270"><a href="#cb213-270" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;Standortplanung: </span><span class="sc">{</span><span class="bu">len</span>(problem.lager)<span class="sc">}</span><span class="ss"> moegliche Lager, &quot;</span></span>
+<span id="cb213-271"><a href="#cb213-271" aria-hidden="true" tabindex="-1"></a>          <span class="ss">f&quot;</span><span class="sc">{</span><span class="bu">len</span>(problem.kunden)<span class="sc">}</span><span class="ss"> Kunden, </span><span class="sc">{</span><span class="bu">sum</span>(problem.bedarf)<span class="sc">}</span><span class="ss"> Paletten Bedarf.&quot;</span>)</span>
+<span id="cb213-272"><a href="#cb213-272" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;Kapazitaet je Lager: </span><span class="sc">{</span>problem<span class="sc">.</span>kapazitaet[<span class="dv">0</span>]<span class="sc">}</span><span class="ss"> Paletten &quot;</span></span>
+<span id="cb213-273"><a href="#cb213-273" aria-hidden="true" tabindex="-1"></a>          <span class="ss">f&quot;-&gt; mindestens 3 Lager noetig.</span><span class="ch">\n</span><span class="ss">&quot;</span>)</span>
+<span id="cb213-274"><a href="#cb213-274" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb213-275"><a href="#cb213-275" aria-hidden="true" tabindex="-1"></a>    loesungen: <span class="bu">dict</span>[<span class="bu">str</span>, Loesung] <span class="op">=</span> {}</span>
+<span id="cb213-276"><a href="#cb213-276" aria-hidden="true" tabindex="-1"></a>    <span class="cf">for</span> name, beschriftung <span class="kw">in</span> [(<span class="st">&quot;cpsat&quot;</span>, <span class="st">&quot;OR-Tools CP-SAT&quot;</span>),</span>
+<span id="cb213-277"><a href="#cb213-277" aria-hidden="true" tabindex="-1"></a>                               (<span class="st">&quot;highs&quot;</span>, <span class="st">&quot;HiGHS (highspy)&quot;</span>)]:</span>
+<span id="cb213-278"><a href="#cb213-278" aria-hidden="true" tabindex="-1"></a>        loesung <span class="op">=</span> loesungen[name] <span class="op">=</span> loese_in_eigenem_prozess(name, problem)</span>
+<span id="cb213-279"><a href="#cb213-279" aria-hidden="true" tabindex="-1"></a>        beanstandungen <span class="op">=</span> pruefe_zuordnung(problem, loesung)</span>
+<span id="cb213-280"><a href="#cb213-280" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb213-281"><a href="#cb213-281" aria-hidden="true" tabindex="-1"></a>        <span class="bu">print</span>(<span class="ss">f&quot;</span><span class="sc">{</span>beschriftung<span class="sc">}</span><span class="ss">&quot;</span>)</span>
+<span id="cb213-282"><a href="#cb213-282" aria-hidden="true" tabindex="-1"></a>        <span class="bu">print</span>(<span class="ss">f&quot;  </span><span class="sc">{</span>loesung<span class="sc">.</span>als_bericht()<span class="sc">}</span><span class="ss">&quot;</span>)</span>
+<span id="cb213-283"><a href="#cb213-283" aria-hidden="true" tabindex="-1"></a>        <span class="bu">print</span>(<span class="ss">f&quot;  eroeffnete Lager: </span><span class="sc">{</span><span class="st">&#39;, &#39;</span><span class="sc">.</span>join(geoeffnete_lager(problem, loesung))<span class="sc">}</span><span class="ss">&quot;</span>)</span>
+<span id="cb213-284"><a href="#cb213-284" aria-hidden="true" tabindex="-1"></a>        <span class="bu">print</span>(<span class="ss">f&quot;  Abnahmepruefung:  &quot;</span></span>
+<span id="cb213-285"><a href="#cb213-285" aria-hidden="true" tabindex="-1"></a>              <span class="ss">f&quot;</span><span class="sc">{</span><span class="st">&#39;bestanden&#39;</span> <span class="cf">if</span> <span class="kw">not</span> beanstandungen <span class="cf">else</span> beanstandungen<span class="sc">}</span><span class="ss">&quot;</span>)</span>
+<span id="cb213-286"><a href="#cb213-286" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb213-287"><a href="#cb213-287" aria-hidden="true" tabindex="-1"></a>    <span class="co"># --- Was der Vergleich zeigt -----------------------------------------</span></span>
+<span id="cb213-288"><a href="#cb213-288" aria-hidden="true" tabindex="-1"></a>    zielwerte <span class="op">=</span> [loesung.zielwert <span class="cf">for</span> loesung <span class="kw">in</span> loesungen.values()]</span>
+<span id="cb213-289"><a href="#cb213-289" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;-&quot;</span> <span class="op">*</span> <span class="dv">82</span>)</span>
+<span id="cb213-290"><a href="#cb213-290" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;Zielwertdifferenz: </span><span class="sc">{</span><span class="bu">abs</span>(zielwerte[<span class="dv">0</span>] <span class="op">-</span> zielwerte[<span class="dv">1</span>])<span class="sc">:.6f}</span><span class="ss"> EUR&quot;</span>)</span>
+<span id="cb213-291"><a href="#cb213-291" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb213-292"><a href="#cb213-292" aria-hidden="true" tabindex="-1"></a>    gleich_belegt <span class="op">=</span> <span class="bu">all</span>(</span>
+<span id="cb213-293"><a href="#cb213-293" aria-hidden="true" tabindex="-1"></a>        <span class="bu">round</span>(loesungen[<span class="st">&quot;cpsat&quot;</span>].werte[s]) <span class="op">==</span> <span class="bu">round</span>(loesungen[<span class="st">&quot;highs&quot;</span>].werte[s])</span>
+<span id="cb213-294"><a href="#cb213-294" aria-hidden="true" tabindex="-1"></a>        <span class="cf">for</span> s <span class="kw">in</span> loesungen[<span class="st">&quot;cpsat&quot;</span>].werte)</span>
+<span id="cb213-295"><a href="#cb213-295" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;Identische Zuordnung: </span><span class="sc">{</span><span class="st">&#39;ja&#39;</span> <span class="cf">if</span> gleich_belegt <span class="cf">else</span> <span class="st">&#39;nein&#39;</span><span class="sc">}</span><span class="ss">&quot;</span>)</span>
+<span id="cb213-296"><a href="#cb213-296" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb213-297"><a href="#cb213-297" aria-hidden="true" tabindex="-1"></a>    <span class="cf">assert</span> <span class="bu">abs</span>(zielwerte[<span class="dv">0</span>] <span class="op">-</span> zielwerte[<span class="dv">1</span>]) <span class="op">&lt;</span> <span class="fl">0.5</span>, <span class="st">&quot;Die Solver widersprechen sich!&quot;</span></span>
+<span id="cb213-298"><a href="#cb213-298" aria-hidden="true" tabindex="-1"></a>    <span class="cf">assert</span> <span class="bu">all</span>(l.status <span class="kw">is</span> SolverStatus.OPTIMAL <span class="cf">for</span> l <span class="kw">in</span> loesungen.values())</span>
+<span id="cb213-299"><a href="#cb213-299" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb213-300"><a href="#cb213-300" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;</span><span class="ch">\n</span><span class="st">&quot;</span> <span class="op">+</span> <span class="st">&quot;=&quot;</span> <span class="op">*</span> <span class="dv">82</span>)</span>
+<span id="cb213-301"><a href="#cb213-301" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;  WAS DER WECHSEL GEKOSTET HAT&quot;</span>)</span>
+<span id="cb213-302"><a href="#cb213-302" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;=&quot;</span> <span class="op">*</span> <span class="dv">82</span>)</span>
+<span id="cb213-303"><a href="#cb213-303" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;Ausgetauscht wurde EINE Funktion. Domaenenmodell, Abnahmepruefung und&quot;</span>)</span>
+<span id="cb213-304"><a href="#cb213-304" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;Bericht sind woertlich dieselben - sie sehen den Solver nie.&quot;</span>)</span>
+<span id="cb213-305"><a href="#cb213-305" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>()</span>
+<span id="cb213-306"><a href="#cb213-306" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;Nicht umsonst ist der Wechsel trotzdem:&quot;</span>)</span>
+<span id="cb213-307"><a href="#cb213-307" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;  * CP-SAT rechnet ausschliesslich GANZZAHLIG. Alle Kosten sind hier&quot;</span>)</span>
+<span id="cb213-308"><a href="#cb213-308" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;    deshalb int. Wer in Euro und Cent rechnet, skaliert vorher auf Cent -&quot;</span>)</span>
+<span id="cb213-309"><a href="#cb213-309" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;    und muss das im Bericht wieder zuruecknehmen.&quot;</span>)</span>
+<span id="cb213-310"><a href="#cb213-310" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;  * HiGHS braucht die Restriktionen als Matrixzeilen, CP-SAT nimmt sie&quot;</span>)</span>
+<span id="cb213-311"><a href="#cb213-311" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;    als Ausdruecke. Das ist der Grund, warum der HiGHS-Modellbauer&quot;</span>)</span>
+<span id="cb213-312"><a href="#cb213-312" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;    laenger ist, obwohl er dasselbe Modell beschreibt.&quot;</span>)</span>
+<span id="cb213-313"><a href="#cb213-313" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;  * Beide Bibliotheken bringen eine eigene HiGHS-Kopie mit und lassen&quot;</span>)</span>
+<span id="cb213-314"><a href="#cb213-314" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;    sich nicht gemeinsam importieren - daher die zwei Prozesse.&quot;</span>)</span>
+<span id="cb213-315"><a href="#cb213-315" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>()</span>
+<span id="cb213-316"><a href="#cb213-316" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;Der Ertrag: Beide beweisen denselben optimalen Zielwert, und die&quot;</span>)</span>
+<span id="cb213-317"><a href="#cb213-317" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;Entscheidung zwischen ihnen ist eine Frage der Laufzeit geworden -&quot;</span>)</span>
+<span id="cb213-318"><a href="#cb213-318" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;nicht eine Frage, wie viel Code man neu schreiben muss.&quot;</span>)</span>
+<span id="cb213-319"><a href="#cb213-319" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>()</span>
+<span id="cb213-320"><a href="#cb213-320" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;Verglichen wird deshalb der ZIELWERT, nicht der Plan: Gibt es mehrere&quot;</span>)</span>
+<span id="cb213-321"><a href="#cb213-321" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;gleich teure Loesungen, darf jeder Solver eine andere davon liefern.&quot;</span>)</span>
+<span id="cb213-322"><a href="#cb213-322" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;Hier stimmen sie zufaellig ueberein - darauf zu testen waere trotzdem&quot;</span>)</span>
+<span id="cb213-323"><a href="#cb213-323" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;ein unzuverlaessiger Test (siehe JobShop_Intervalle.py).&quot;</span>)</span>
+<span id="cb213-324"><a href="#cb213-324" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;=&quot;</span> <span class="op">*</span> <span class="dv">82</span>)</span></code></pre></div>
 <p><strong>Erwartete Ausgabe</strong> (Laufzeiten hardwareabhängig):</p>
 <pre><code>==================================================================================
   DERSELBE FALL, ZWEI SOLVER - UND EIN AUSWERTUNGSCODE
@@ -26226,14 +27738,14 @@ ein unzuverlaessiger Test (siehe JobShop_Intervalle.py).
 <p><strong>🎯 Merksatz</strong> Die Frage „welcher Solver ist der beste?“ ist schlecht gestellt. Die gute Frage lautet: „Wie teuer ist es, den Solver zu wechseln?“ Wer sie mit <em>eine Funktion</em> beantworten kann, muss die erste Frage nie entscheiden — er misst.</p>
 </blockquote>
 <hr />
-<h2 id="sec:praxisfallen-eine-checkliste-vor-dem-produktivgang">22.7 Eine Checkliste vor dem Produktivgang</h2>
+<h2 id="sec:praxisfallen-eine-checkliste-vor-dem-produktivgang">22.8 Eine Checkliste vor dem Produktivgang</h2>
 <p>Arbeiten Sie diese Liste ab, bevor ein OR-System in Betrieb geht:</p>
 <p><strong>Modell</strong> - [ ] Alle Nebenbedingungen sind dokumentiert — mit fachlicher Begründung, nicht nur als Code. - [ ] Für jede harte Bedingung ist geprüft: Muss sie wirklich hart sein? - [ ] Es gibt eine Relaxationsstrategie für den Infeasible-Fall. - [ ] Big-M-Werte sind so klein wie möglich gewählt. - [ ] Die Zielfunktion ist in konsistenten Einheiten formuliert.</p>
 <p><strong>Daten</strong> - [ ] Spaltenreihenfolge und Datentypen werden nach jedem Import geprüft. - [ ] Fehlende Werte und Ausreißer haben eine definierte Behandlung. - [ ] Kovarianzmatrizen werden auf positive Definitheit geprüft. - [ ] Datenstände sind versioniert und reproduzierbar.</p>
 <p><strong>Validierung</strong> - [ ] Das Ergebnis wurde gegen eine unabhängige Rechnung geprüft (Handrechnung, zweiter Solver, Simulation). - [ ] Alle Nebenbedingungen werden nach dem Lösen per <code>assert</code> verifiziert. - [ ] Es gibt einen Vergleich gegen eine naive Referenzstrategie. - [ ] Bei Backtests: Lookahead-Selbsttest bestanden, Zahl der Versuche protokolliert.</p>
 <p><strong>Betrieb</strong> - [ ] Zeitlimit und akzeptierter Gap sind festgelegt und begründet. - [ ] Es gibt eine Fallback-Strategie und Alarmierung. - [ ] Jedes Ergebnis ist mit Snapshot-ID, Modellversion und Solver-Version protokolliert. - [ ] Die Ergebnisse sind erklärbar (Kostenzerlegung, Schattenpreise, Constraint-Trace).</p>
 <hr />
-<h2 id="sec:praxisfallen-weiterfuehrende-literatur-und-roadmap">22.8 Weiterführende Literatur und Roadmap</h2>
+<h2 id="sec:praxisfallen-weiterfuehrende-literatur-und-roadmap">22.9 Weiterführende Literatur und Roadmap</h2>
 <p><strong>Grundlagen und lineare/ganzzahlige Optimierung</strong> * Bertsimas &amp; Tsitsiklis: <em>Introduction to Linear Optimization</em> — Standardwerk zu Simplex, Dualität, Polyedertheorie. * Wolsey: <em>Integer Programming</em> — Branch-and-Cut, Schnittebenen, Formulierungsstärke.</p>
 <p><strong>Konvexe Optimierung</strong> * Boyd &amp; Vandenberghe: <em>Convex Optimization</em> — Pflichtlektüre; frei verfügbar. Die theoretische Basis von CVXPY.</p>
 <p><strong>Constraint Programming und Scheduling</strong> * Google OR-Tools Dokumentation und das CP-SAT-Primer von Laurent Perron.</p>
@@ -26283,21 +27795,22 @@ ein unzuverlaessiger Test (siehe JobShop_Intervalle.py).
 </tbody>
 </table>
 <hr />
-<h2 id="sec:praxisfallen-uebungsaufgaben">22.9 Übungsaufgaben</h2>
+<h2 id="sec:praxisfallen-uebungsaufgaben">22.10 Übungsaufgaben</h2>
 <blockquote>
 <p>Lösungen: <a href="#sec:loesungen-praxisfallen">Abschnitt A.22</a>.</p>
 </blockquote>
 <p><strong>Aufgabe 22.1 ⭐ — Hart oder weich, revisited.</strong> Nennen Sie für ein Vertretungsplanungssystem je zwei Bedingungen, die (a) zwingend hart bleiben müssen, (b) unbedingt weich sein sollten, (c) diskutabel sind. Begründen Sie.</p>
 <p><strong>Aufgabe 22.2 ⭐ — Zeitlimit wählen.</strong> Für welche Szenarien setzen Sie welches Zeitlimit und welchen Gap? (a) Taxi-Disposition in Echtzeit, (b) Wochendienstplan, freitags erstellt, (c) Jahresproduktionsplanung, (d) Portfolio-Rebalancing monatlich.</p>
-<p><strong>Aufgabe 22.3 ⭐⭐ — Relaxation einbauen.</strong> Nehmen Sie Ihr Modell aus Übung 6.7 (Wochendienstplan) und machen Sie es <code>INFEASIBLE</code>-sicher: Schlupfvariablen für unbesetzte Schichten, gestaffelte Strafen. Testen Sie mit einem bewusst überlasteten Szenario.</p>
+<p><strong>Aufgabe 22.3 ⭐⭐ — Relaxation einbauen.</strong> Nehmen Sie Ihr Modell aus der Aufgabe <em>Eigener Dienstplan</em> (<a href="#sec:cpsat-uebungsaufgaben">Abschnitt 7.9</a>) und machen Sie es <code>INFEASIBLE</code>-sicher: Schlupfvariablen für unbesetzte Schichten, gestaffelte Strafen. Testen Sie mit einem bewusst überlasteten Szenario.</p>
 <p><strong>Aufgabe 22.4 ⭐⭐ — Erklärbarkeit implementieren.</strong> Erweitern Sie ein beliebiges Modell aus dem Kurs um einen <code>erklaere(loesung)</code>-Report, der die drei Fragen aus <a href="#sec:praxisfallen-die-fuenf-typischen-praxisfallen">Abschnitt 22.3</a> beantwortet.</p>
-<p><strong>Aufgabe 22.5 ⭐⭐⭐ — Gap gegen Laufzeit.</strong> Nehmen Sie das MILP-Portfolio aus <a href="#kap-milp">Kapitel 6</a> und vergrößern Sie es auf 50 Anlagen. Messen Sie Laufzeit und Zielwert bei Gap-Vorgaben von 10 %, 5 %, 2 %, 1 %, 0,1 % und 0 %. Stellen Sie den Zusammenhang grafisch dar und leiten Sie eine Empfehlung ab.</p>
-<p><strong>Aufgabe 22.6 ⭐⭐⭐ — Post-Mortem schreiben.</strong> Suchen Sie sich einen der im Buch besprochenen Fehler aus (z. B. die Vorzeichenfalle in <a href="#sec:lp-die-vorzeichenfalle-bei-schattenpreisen">Abschnitt 5.7</a>, die ungültige Kovarianzmatrix in <a href="#kap-qp-nlp">Kapitel 11</a>, die Sektor-Positionsindizes in <a href="#kap-markowitz">Kapitel 19</a>, die vermischten Einheiten in <a href="#sec:cvar-implementierung-cvar-portfolio-mit-reibung">Abschnitt 20.6</a> oder die Rebalancing-Termine in <a href="#sec:handelsmaschine-rebalancing-termine-richtig-bestimmen">Abschnitt 21.4</a>) und schreiben Sie ein einseitiges Post-Mortem: Was war der Fehler? Warum fiel er nicht auf? Welche Prüfung hätte ihn gefunden? Welche Regel leiten Sie daraus für eigene Projekte ab?</p>
+<p><strong>Aufgabe 22.5 ⭐⭐ — Den Bericht in die Irre führen.</strong> <code>Constraint_Attribution.py</code> erzeugt seinen Bericht aus gerechneten Zahlen — richtig ist er deshalb noch nicht. (a) Setzen Sie den Deckungsbeitrag von <em>Deckel</em> von 9 € auf 20 €. Wie ändern sich Plan, Rangliste und Bericht? Welche Sätze bleiben wörtlich stehen, obwohl sie jetzt etwas anderes bedeuten? (b) Der Bericht nennt „Liefervertrag Träger” als teuerste Bindung. Formulieren Sie den Satz so um, dass ein Leser erkennt, <strong>worauf</strong> die Aussage beruht. (c) Welche Angabe müsste das Programm zusätzlich ausgeben, damit ein Empfänger die Belastbarkeit selbst einschätzen kann?</p>
+<p><strong>Aufgabe 22.6 ⭐⭐⭐ — Gap gegen Laufzeit.</strong> Nehmen Sie das MILP-Portfolio aus <a href="#kap-milp">Kapitel 6</a> und vergrößern Sie es auf 50 Anlagen. Messen Sie Laufzeit und Zielwert bei Gap-Vorgaben von 10 %, 5 %, 2 %, 1 %, 0,1 % und 0 %. Stellen Sie den Zusammenhang grafisch dar und leiten Sie eine Empfehlung ab.</p>
+<p><strong>Aufgabe 22.7 ⭐⭐⭐ — Post-Mortem schreiben.</strong> Suchen Sie sich einen der im Buch besprochenen Fehler aus (z. B. die Vorzeichenfalle in <a href="#sec:lp-die-vorzeichenfalle-bei-schattenpreisen">Abschnitt 5.7</a>, die ungültige Kovarianzmatrix in <a href="#kap-qp-nlp">Kapitel 11</a>, die Sektor-Positionsindizes in <a href="#kap-markowitz">Kapitel 19</a>, die vermischten Einheiten in <a href="#sec:cvar-implementierung-cvar-portfolio-mit-reibung">Abschnitt 20.6</a> oder die Rebalancing-Termine in <a href="#sec:handelsmaschine-rebalancing-termine-richtig-bestimmen">Abschnitt 21.4</a>) und schreiben Sie ein einseitiges Post-Mortem: Was war der Fehler? Warum fiel er nicht auf? Welche Prüfung hätte ihn gefunden? Welche Regel leiten Sie daraus für eigene Projekte ab?</p>
 <hr />
-<h2 id="sec:praxisfallen-denkfehler">22.10 Finde den Denkfehler</h2>
+<h2 id="sec:praxisfallen-denkfehler">22.11 Finde den Denkfehler</h2>
 <p>Falle 5 — die Laufzeitexplosion — zeigt sich im Betrieb selten als Absturz. Sie zeigt sich als <strong>gar nichts</strong>.</p>
 <blockquote>
-<p><strong>🐛 Finde den Denkfehler 15.1: Das Modell, das seit einem Jahr nicht mehr optimiert</strong></p>
+<p><strong>🐛 Finde den Denkfehler: Das Modell, das seit einem Jahr nicht mehr optimiert</strong></p>
 <p>Ein Standortplanungsmodell geht 2024 in Betrieb. Es läuft jede Nacht, hat drei Sekunden Zeitbudget und liefert zuverlässig die Kosten des Tagesplans. Das Betriebsteam überwacht Abstürze und Laufzeitspitzen — beides tritt nie auf.</p>
 <p>Zwei Jahre später ist das Unternehmen von 15 auf 80 Lager gewachsen. Am Code hat niemand etwas geändert; es gab ja keinen Anlass. Das Protokoll sieht so aus:</p>
 <table>
@@ -26335,186 +27848,186 @@ ein unzuverlaessiger Test (siehe JobShop_Intervalle.py).
 <p><strong>Ihre Aufgabe:</strong> (a) Warum ist die gleichbleibende Laufzeit hier kein Zeichen von Stabilität, sondern das Symptom? (b) Welche drei Größen fehlen im Protokoll? (c) Welche der drei warnt am <strong>frühesten</strong> — und warum ist gerade sie so wertvoll? (d) Das Team bemerkt den Fehler 2026. Wie hoch waren die Mehrkosten, und warum lässt sich das nachträglich nicht mehr genau beziffern?</p>
 <p><em>Auflösung: <a href="#sec:loesungen-praxisfallen">Abschnitt A.22</a>.</em></p>
 </blockquote>
-<div class="sourceCode" id="cb211"><pre class="sourceCode python"><code class="sourceCode python"><span id="cb211-1"><a href="#cb211-1" aria-hidden="true" tabindex="-1"></a><span class="co">#!/usr/bin/env python3</span></span>
-<span id="cb211-2"><a href="#cb211-2" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb211-3"><a href="#cb211-3" aria-hidden="true" tabindex="-1"></a><span class="co"># Betriebsueberwachung.py</span></span>
-<span id="cb211-4"><a href="#cb211-4" aria-hidden="true" tabindex="-1"></a><span class="co">&quot;&quot;&quot;</span></span>
-<span id="cb211-5"><a href="#cb211-5" aria-hidden="true" tabindex="-1"></a><span class="co">Kapitel Praxisfallen: Das Modell, das still aufgehoert hat zu optimieren.</span></span>
-<span id="cb211-6"><a href="#cb211-6" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb211-7"><a href="#cb211-7" aria-hidden="true" tabindex="-1"></a><span class="co">Ein Optimierungsmodell geht in Betrieb und laeuft jede Nacht. Es liefert</span></span>
-<span id="cb211-8"><a href="#cb211-8" aria-hidden="true" tabindex="-1"></a><span class="co">zuverlaessig eine Zahl, die Job-Dauer bleibt konstant, es gibt keine</span></span>
-<span id="cb211-9"><a href="#cb211-9" aria-hidden="true" tabindex="-1"></a><span class="co">Fehlermeldung. Alles sieht gut aus.</span></span>
-<span id="cb211-10"><a href="#cb211-10" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb211-11"><a href="#cb211-11" aria-hidden="true" tabindex="-1"></a><span class="co">Waehrenddessen waechst das Unternehmen. Aus 15 Lagern werden 40, dann 80. Das</span></span>
-<span id="cb211-12"><a href="#cb211-12" aria-hidden="true" tabindex="-1"></a><span class="co">Zeitlimit von drei Sekunden - vor zwei Jahren grosszuegig bemessen - reicht</span></span>
-<span id="cb211-13"><a href="#cb211-13" aria-hidden="true" tabindex="-1"></a><span class="co">irgendwann nicht mehr. Der Solver bricht ab und liefert die beste Loesung, die</span></span>
-<span id="cb211-14"><a href="#cb211-14" aria-hidden="true" tabindex="-1"></a><span class="co">er bis dahin gefunden hat.</span></span>
-<span id="cb211-15"><a href="#cb211-15" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb211-16"><a href="#cb211-16" aria-hidden="true" tabindex="-1"></a><span class="co">Das ist nicht falsch. Es ist sogar richtig so. Aber es ist etwas anderes als</span></span>
-<span id="cb211-17"><a href="#cb211-17" aria-hidden="true" tabindex="-1"></a><span class="co">das, was das Modell einmal geleistet hat - und niemand merkt es, weil im</span></span>
-<span id="cb211-18"><a href="#cb211-18" aria-hidden="true" tabindex="-1"></a><span class="co">Protokoll nur die Kosten stehen.</span></span>
-<span id="cb211-19"><a href="#cb211-19" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb211-20"><a href="#cb211-20" aria-hidden="true" tabindex="-1"></a><span class="co">Dieses Programm zeigt die Verschlechterung und die Ueberwachung, die sie</span></span>
-<span id="cb211-21"><a href="#cb211-21" aria-hidden="true" tabindex="-1"></a><span class="co">sichtbar macht.</span></span>
-<span id="cb211-22"><a href="#cb211-22" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb211-23"><a href="#cb211-23" aria-hidden="true" tabindex="-1"></a><span class="co">WICHTIG: ortools wird hier nicht importiert (Konflikt mit highspy, siehe</span></span>
-<span id="cb211-24"><a href="#cb211-24" aria-hidden="true" tabindex="-1"></a><span class="co">Kapitel Oekosystem).</span></span>
-<span id="cb211-25"><a href="#cb211-25" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb211-26"><a href="#cb211-26" aria-hidden="true" tabindex="-1"></a><span class="co">Benoetigt: numpy, highspy</span></span>
-<span id="cb211-27"><a href="#cb211-27" aria-hidden="true" tabindex="-1"></a><span class="co">&quot;&quot;&quot;</span></span>
-<span id="cb211-28"><a href="#cb211-28" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb211-29"><a href="#cb211-29" aria-hidden="true" tabindex="-1"></a><span class="im">from</span> __future__ <span class="im">import</span> annotations</span>
-<span id="cb211-30"><a href="#cb211-30" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb211-31"><a href="#cb211-31" aria-hidden="true" tabindex="-1"></a><span class="im">import</span> time</span>
-<span id="cb211-32"><a href="#cb211-32" aria-hidden="true" tabindex="-1"></a><span class="im">from</span> dataclasses <span class="im">import</span> dataclass</span>
-<span id="cb211-33"><a href="#cb211-33" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb211-34"><a href="#cb211-34" aria-hidden="true" tabindex="-1"></a><span class="im">import</span> numpy <span class="im">as</span> np</span>
-<span id="cb211-35"><a href="#cb211-35" aria-hidden="true" tabindex="-1"></a><span class="im">import</span> highspy</span>
-<span id="cb211-36"><a href="#cb211-36" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb211-37"><a href="#cb211-37" aria-hidden="true" tabindex="-1"></a>ZEITLIMIT <span class="op">=</span> <span class="fl">3.0</span>                  <span class="co"># das Budget, das der Nachtjob hat</span></span>
-<span id="cb211-38"><a href="#cb211-38" aria-hidden="true" tabindex="-1"></a>GAP_WARNSCHWELLE <span class="op">=</span> <span class="fl">0.02</span>          <span class="co"># ab 2 % Gap wollen wir es wissen</span></span>
-<span id="cb211-39"><a href="#cb211-39" aria-hidden="true" tabindex="-1"></a>ZEITAUSLASTUNG_WARNSCHWELLE <span class="op">=</span> <span class="fl">0.9</span></span>
-<span id="cb211-40"><a href="#cb211-40" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb211-41"><a href="#cb211-41" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb211-42"><a href="#cb211-42" aria-hidden="true" tabindex="-1"></a><span class="at">@dataclass</span></span>
-<span id="cb211-43"><a href="#cb211-43" aria-hidden="true" tabindex="-1"></a><span class="kw">class</span> Laufprotokoll:</span>
-<span id="cb211-44"><a href="#cb211-44" aria-hidden="true" tabindex="-1"></a>    <span class="co">&quot;&quot;&quot;Was nach JEDEM Produktivlauf protokolliert gehoert.</span></span>
-<span id="cb211-45"><a href="#cb211-45" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb211-46"><a href="#cb211-46" aria-hidden="true" tabindex="-1"></a><span class="co">    Die meisten Systeme schreiben nur &#39;kosten&#39;. Genau deshalb faellt eine</span></span>
-<span id="cb211-47"><a href="#cb211-47" aria-hidden="true" tabindex="-1"></a><span class="co">    schleichende Verschlechterung ueber Monate nicht auf.</span></span>
-<span id="cb211-48"><a href="#cb211-48" aria-hidden="true" tabindex="-1"></a><span class="co">    &quot;&quot;&quot;</span></span>
-<span id="cb211-49"><a href="#cb211-49" aria-hidden="true" tabindex="-1"></a>    zeitpunkt: <span class="bu">str</span></span>
-<span id="cb211-50"><a href="#cb211-50" aria-hidden="true" tabindex="-1"></a>    lager: <span class="bu">int</span></span>
-<span id="cb211-51"><a href="#cb211-51" aria-hidden="true" tabindex="-1"></a>    kunden: <span class="bu">int</span></span>
-<span id="cb211-52"><a href="#cb211-52" aria-hidden="true" tabindex="-1"></a>    status: <span class="bu">str</span></span>
-<span id="cb211-53"><a href="#cb211-53" aria-hidden="true" tabindex="-1"></a>    kosten: <span class="bu">float</span></span>
-<span id="cb211-54"><a href="#cb211-54" aria-hidden="true" tabindex="-1"></a>    gap: <span class="bu">float</span></span>
-<span id="cb211-55"><a href="#cb211-55" aria-hidden="true" tabindex="-1"></a>    laufzeit: <span class="bu">float</span></span>
-<span id="cb211-56"><a href="#cb211-56" aria-hidden="true" tabindex="-1"></a>    knoten: <span class="bu">int</span></span>
-<span id="cb211-57"><a href="#cb211-57" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb211-58"><a href="#cb211-58" aria-hidden="true" tabindex="-1"></a>    <span class="at">@property</span></span>
-<span id="cb211-59"><a href="#cb211-59" aria-hidden="true" tabindex="-1"></a>    <span class="kw">def</span> warnungen(<span class="va">self</span>) <span class="op">-&gt;</span> <span class="bu">list</span>[<span class="bu">str</span>]:</span>
-<span id="cb211-60"><a href="#cb211-60" aria-hidden="true" tabindex="-1"></a>        meldungen <span class="op">=</span> []</span>
-<span id="cb211-61"><a href="#cb211-61" aria-hidden="true" tabindex="-1"></a>        <span class="cf">if</span> <span class="va">self</span>.status <span class="op">!=</span> <span class="st">&quot;Optimal&quot;</span>:</span>
-<span id="cb211-62"><a href="#cb211-62" aria-hidden="true" tabindex="-1"></a>            meldungen.append(<span class="ss">f&quot;nicht beweisbar optimal (</span><span class="sc">{</span><span class="va">self</span><span class="sc">.</span>status<span class="sc">}</span><span class="ss">)&quot;</span>)</span>
-<span id="cb211-63"><a href="#cb211-63" aria-hidden="true" tabindex="-1"></a>        <span class="cf">if</span> <span class="va">self</span>.gap <span class="op">&gt;</span> GAP_WARNSCHWELLE:</span>
-<span id="cb211-64"><a href="#cb211-64" aria-hidden="true" tabindex="-1"></a>            meldungen.append(<span class="ss">f&quot;Gap </span><span class="sc">{</span><span class="va">self</span><span class="sc">.</span>gap<span class="sc">:.1%}</span><span class="ss"> ueber Schwelle &quot;</span></span>
-<span id="cb211-65"><a href="#cb211-65" aria-hidden="true" tabindex="-1"></a>                             <span class="ss">f&quot;</span><span class="sc">{</span>GAP_WARNSCHWELLE<span class="sc">:.0%}</span><span class="ss">&quot;</span>)</span>
-<span id="cb211-66"><a href="#cb211-66" aria-hidden="true" tabindex="-1"></a>        <span class="cf">if</span> <span class="va">self</span>.laufzeit <span class="op">&gt;</span> ZEITAUSLASTUNG_WARNSCHWELLE <span class="op">*</span> ZEITLIMIT:</span>
-<span id="cb211-67"><a href="#cb211-67" aria-hidden="true" tabindex="-1"></a>            meldungen.append(<span class="ss">f&quot;Zeitbudget zu </span><span class="sc">{</span><span class="va">self</span><span class="sc">.</span>laufzeit <span class="op">/</span> ZEITLIMIT<span class="sc">:.0%}</span><span class="ss"> &quot;</span></span>
-<span id="cb211-68"><a href="#cb211-68" aria-hidden="true" tabindex="-1"></a>                             <span class="ss">f&quot;ausgeschoepft&quot;</span>)</span>
-<span id="cb211-69"><a href="#cb211-69" aria-hidden="true" tabindex="-1"></a>        <span class="cf">return</span> meldungen</span>
-<span id="cb211-70"><a href="#cb211-70" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb211-71"><a href="#cb211-71" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb211-72"><a href="#cb211-72" aria-hidden="true" tabindex="-1"></a><span class="kw">def</span> plane_netzwerk(n_lager: <span class="bu">int</span>, n_kunden: <span class="bu">int</span>, zeitlimit: <span class="bu">float</span>,</span>
-<span id="cb211-73"><a href="#cb211-73" aria-hidden="true" tabindex="-1"></a>                   saat: <span class="bu">int</span> <span class="op">=</span> <span class="dv">7</span>) <span class="op">-&gt;</span> <span class="bu">tuple</span>[<span class="bu">str</span>, <span class="bu">float</span>, <span class="bu">float</span>, <span class="bu">float</span>, <span class="bu">int</span>]:</span>
-<span id="cb211-74"><a href="#cb211-74" aria-hidden="true" tabindex="-1"></a>    <span class="co">&quot;&quot;&quot;Standortplanung wie in Kapitel MILP, nur mit wachsender Groesse.&quot;&quot;&quot;</span></span>
-<span id="cb211-75"><a href="#cb211-75" aria-hidden="true" tabindex="-1"></a>    rng <span class="op">=</span> np.random.default_rng(saat)</span>
-<span id="cb211-76"><a href="#cb211-76" aria-hidden="true" tabindex="-1"></a>    fixkosten <span class="op">=</span> rng.uniform(<span class="dv">3000</span>, <span class="dv">9000</span>, n_lager)</span>
-<span id="cb211-77"><a href="#cb211-77" aria-hidden="true" tabindex="-1"></a>    transport <span class="op">=</span> rng.uniform(<span class="dv">5</span>, <span class="dv">60</span>, (n_lager, n_kunden))</span>
-<span id="cb211-78"><a href="#cb211-78" aria-hidden="true" tabindex="-1"></a>    bedarf <span class="op">=</span> rng.uniform(<span class="dv">10</span>, <span class="dv">60</span>, n_kunden)</span>
-<span id="cb211-79"><a href="#cb211-79" aria-hidden="true" tabindex="-1"></a>    kapazitaet <span class="op">=</span> np.full(n_lager, bedarf.<span class="bu">sum</span>() <span class="op">*</span> <span class="fl">0.22</span>)</span>
-<span id="cb211-80"><a href="#cb211-80" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb211-81"><a href="#cb211-81" aria-hidden="true" tabindex="-1"></a>    modell <span class="op">=</span> highspy.Highs()</span>
-<span id="cb211-82"><a href="#cb211-82" aria-hidden="true" tabindex="-1"></a>    modell.setOptionValue(<span class="st">&quot;output_flag&quot;</span>, <span class="va">False</span>)</span>
-<span id="cb211-83"><a href="#cb211-83" aria-hidden="true" tabindex="-1"></a>    modell.setOptionValue(<span class="st">&quot;time_limit&quot;</span>, zeitlimit)</span>
-<span id="cb211-84"><a href="#cb211-84" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb211-85"><a href="#cb211-85" aria-hidden="true" tabindex="-1"></a>    anzahl_x <span class="op">=</span> n_lager <span class="op">*</span> n_kunden</span>
-<span id="cb211-86"><a href="#cb211-86" aria-hidden="true" tabindex="-1"></a>    unendlich <span class="op">=</span> highspy.kHighsInf</span>
-<span id="cb211-87"><a href="#cb211-87" aria-hidden="true" tabindex="-1"></a>    modell.addVars(anzahl_x, np.zeros(anzahl_x), np.full(anzahl_x, unendlich))</span>
-<span id="cb211-88"><a href="#cb211-88" aria-hidden="true" tabindex="-1"></a>    modell.addVars(n_lager, np.zeros(n_lager), np.ones(n_lager))</span>
-<span id="cb211-89"><a href="#cb211-89" aria-hidden="true" tabindex="-1"></a>    <span class="cf">for</span> i <span class="kw">in</span> <span class="bu">range</span>(n_lager):</span>
-<span id="cb211-90"><a href="#cb211-90" aria-hidden="true" tabindex="-1"></a>        modell.changeColIntegrality(anzahl_x <span class="op">+</span> i, highspy.HighsVarType.kInteger)</span>
-<span id="cb211-91"><a href="#cb211-91" aria-hidden="true" tabindex="-1"></a>        modell.changeColCost(anzahl_x <span class="op">+</span> i, fixkosten[i])</span>
-<span id="cb211-92"><a href="#cb211-92" aria-hidden="true" tabindex="-1"></a>        <span class="cf">for</span> j <span class="kw">in</span> <span class="bu">range</span>(n_kunden):</span>
-<span id="cb211-93"><a href="#cb211-93" aria-hidden="true" tabindex="-1"></a>            modell.changeColCost(i <span class="op">*</span> n_kunden <span class="op">+</span> j, transport[i, j])</span>
-<span id="cb211-94"><a href="#cb211-94" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb211-95"><a href="#cb211-95" aria-hidden="true" tabindex="-1"></a>    <span class="cf">for</span> j <span class="kw">in</span> <span class="bu">range</span>(n_kunden):</span>
-<span id="cb211-96"><a href="#cb211-96" aria-hidden="true" tabindex="-1"></a>        index <span class="op">=</span> np.array([i <span class="op">*</span> n_kunden <span class="op">+</span> j <span class="cf">for</span> i <span class="kw">in</span> <span class="bu">range</span>(n_lager)], dtype<span class="op">=</span>np.int32)</span>
-<span id="cb211-97"><a href="#cb211-97" aria-hidden="true" tabindex="-1"></a>        modell.addRow(bedarf[j], bedarf[j], <span class="bu">len</span>(index), index, np.ones(<span class="bu">len</span>(index)))</span>
-<span id="cb211-98"><a href="#cb211-98" aria-hidden="true" tabindex="-1"></a>    <span class="cf">for</span> i <span class="kw">in</span> <span class="bu">range</span>(n_lager):</span>
-<span id="cb211-99"><a href="#cb211-99" aria-hidden="true" tabindex="-1"></a>        index <span class="op">=</span> np.array([i <span class="op">*</span> n_kunden <span class="op">+</span> j <span class="cf">for</span> j <span class="kw">in</span> <span class="bu">range</span>(n_kunden)] <span class="op">+</span> [anzahl_x <span class="op">+</span> i],</span>
-<span id="cb211-100"><a href="#cb211-100" aria-hidden="true" tabindex="-1"></a>                         dtype<span class="op">=</span>np.int32)</span>
-<span id="cb211-101"><a href="#cb211-101" aria-hidden="true" tabindex="-1"></a>        werte <span class="op">=</span> np.concatenate([np.ones(n_kunden), [<span class="op">-</span>kapazitaet[i]]])</span>
-<span id="cb211-102"><a href="#cb211-102" aria-hidden="true" tabindex="-1"></a>        modell.addRow(<span class="op">-</span>unendlich, <span class="fl">0.0</span>, <span class="bu">len</span>(index), index, werte)</span>
-<span id="cb211-103"><a href="#cb211-103" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb211-104"><a href="#cb211-104" aria-hidden="true" tabindex="-1"></a>    t0 <span class="op">=</span> time.perf_counter()</span>
-<span id="cb211-105"><a href="#cb211-105" aria-hidden="true" tabindex="-1"></a>    modell.run()</span>
-<span id="cb211-106"><a href="#cb211-106" aria-hidden="true" tabindex="-1"></a>    laufzeit <span class="op">=</span> time.perf_counter() <span class="op">-</span> t0</span>
-<span id="cb211-107"><a href="#cb211-107" aria-hidden="true" tabindex="-1"></a>    info <span class="op">=</span> modell.getInfo()</span>
-<span id="cb211-108"><a href="#cb211-108" aria-hidden="true" tabindex="-1"></a>    <span class="cf">return</span> (modell.modelStatusToString(modell.getModelStatus()),</span>
-<span id="cb211-109"><a href="#cb211-109" aria-hidden="true" tabindex="-1"></a>            info.objective_function_value, info.mip_gap, laufzeit,</span>
-<span id="cb211-110"><a href="#cb211-110" aria-hidden="true" tabindex="-1"></a>            info.mip_node_count)</span>
-<span id="cb211-111"><a href="#cb211-111" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb211-112"><a href="#cb211-112" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb211-113"><a href="#cb211-113" aria-hidden="true" tabindex="-1"></a><span class="cf">if</span> <span class="va">__name__</span> <span class="op">==</span> <span class="st">&quot;__main__&quot;</span>:</span>
-<span id="cb211-114"><a href="#cb211-114" aria-hidden="true" tabindex="-1"></a>    <span class="co"># So ist das Unternehmen ueber zwei Jahre gewachsen.</span></span>
-<span id="cb211-115"><a href="#cb211-115" aria-hidden="true" tabindex="-1"></a>    entwicklung <span class="op">=</span> [(<span class="st">&quot;2024-Q1&quot;</span>, <span class="dv">15</span>, <span class="dv">40</span>), (<span class="st">&quot;2024-Q3&quot;</span>, <span class="dv">25</span>, <span class="dv">70</span>),</span>
-<span id="cb211-116"><a href="#cb211-116" aria-hidden="true" tabindex="-1"></a>                   (<span class="st">&quot;2025-Q1&quot;</span>, <span class="dv">40</span>, <span class="dv">110</span>), (<span class="st">&quot;2025-Q3&quot;</span>, <span class="dv">60</span>, <span class="dv">160</span>),</span>
-<span id="cb211-117"><a href="#cb211-117" aria-hidden="true" tabindex="-1"></a>                   (<span class="st">&quot;2026-Q1&quot;</span>, <span class="dv">80</span>, <span class="dv">220</span>)]</span>
-<span id="cb211-118"><a href="#cb211-118" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb211-119"><a href="#cb211-119" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;=&quot;</span> <span class="op">*</span> <span class="dv">84</span>)</span>
-<span id="cb211-120"><a href="#cb211-120" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;  WAS DAS PROTOKOLL ZEIGT - UND WAS ES ZEIGEN SOLLTE&quot;</span>)</span>
-<span id="cb211-121"><a href="#cb211-121" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;=&quot;</span> <span class="op">*</span> <span class="dv">84</span>)</span>
-<span id="cb211-122"><a href="#cb211-122" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;Derselbe Nachtjob, unveraendert, mit </span><span class="sc">{</span>ZEITLIMIT<span class="sc">:.0f}</span><span class="ss"> Sekunden Zeitlimit.</span><span class="ch">\n</span><span class="ss">&quot;</span>)</span>
-<span id="cb211-123"><a href="#cb211-123" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb211-124"><a href="#cb211-124" aria-hidden="true" tabindex="-1"></a>    protokolle <span class="op">=</span> []</span>
-<span id="cb211-125"><a href="#cb211-125" aria-hidden="true" tabindex="-1"></a>    <span class="cf">for</span> zeitpunkt, lager, kunden <span class="kw">in</span> entwicklung:</span>
-<span id="cb211-126"><a href="#cb211-126" aria-hidden="true" tabindex="-1"></a>        status, kosten, gap, laufzeit, knoten <span class="op">=</span> plane_netzwerk(</span>
-<span id="cb211-127"><a href="#cb211-127" aria-hidden="true" tabindex="-1"></a>            lager, kunden, ZEITLIMIT)</span>
-<span id="cb211-128"><a href="#cb211-128" aria-hidden="true" tabindex="-1"></a>        protokolle.append(Laufprotokoll(zeitpunkt, lager, kunden, status,</span>
-<span id="cb211-129"><a href="#cb211-129" aria-hidden="true" tabindex="-1"></a>                                        kosten, gap, laufzeit, knoten))</span>
-<span id="cb211-130"><a href="#cb211-130" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb211-131"><a href="#cb211-131" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;So sieht das ueblich gefuehrte Protokoll aus:</span><span class="ch">\n</span><span class="st">&quot;</span>)</span>
-<span id="cb211-132"><a href="#cb211-132" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;  </span><span class="sc">{</span><span class="st">&#39;Zeitpunkt&#39;</span><span class="sc">:&lt;10}</span><span class="ss"> </span><span class="sc">{</span><span class="st">&#39;Kosten&#39;</span><span class="sc">:&gt;12}</span><span class="ss">&quot;</span>)</span>
-<span id="cb211-133"><a href="#cb211-133" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;  &quot;</span> <span class="op">+</span> <span class="st">&quot;-&quot;</span> <span class="op">*</span> <span class="dv">24</span>)</span>
-<span id="cb211-134"><a href="#cb211-134" aria-hidden="true" tabindex="-1"></a>    <span class="cf">for</span> p <span class="kw">in</span> protokolle:</span>
-<span id="cb211-135"><a href="#cb211-135" aria-hidden="true" tabindex="-1"></a>        <span class="bu">print</span>(<span class="ss">f&quot;  </span><span class="sc">{</span>p<span class="sc">.</span>zeitpunkt<span class="sc">:&lt;10}</span><span class="ss"> </span><span class="sc">{</span>p<span class="sc">.</span>kosten<span class="sc">:&gt;12,.0f}</span><span class="ss">&quot;</span>)</span>
-<span id="cb211-136"><a href="#cb211-136" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;</span><span class="ch">\n</span><span class="st">  -&gt; Die Kosten steigen. Das Unternehmen waechst ja auch.&quot;</span>)</span>
-<span id="cb211-137"><a href="#cb211-137" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;     Nichts an dieser Tabelle deutet auf ein Problem hin.&quot;</span>)</span>
-<span id="cb211-138"><a href="#cb211-138" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb211-139"><a href="#cb211-139" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;</span><span class="ch">\n</span><span class="st">&quot;</span> <span class="op">+</span> <span class="st">&quot;-&quot;</span> <span class="op">*</span> <span class="dv">84</span>)</span>
-<span id="cb211-140"><a href="#cb211-140" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;So sieht ein vollstaendiges Protokoll aus:</span><span class="ch">\n</span><span class="st">&quot;</span>)</span>
-<span id="cb211-141"><a href="#cb211-141" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;  </span><span class="sc">{</span><span class="st">&#39;Zeitpunkt&#39;</span><span class="sc">:&lt;10}</span><span class="ss"> </span><span class="sc">{</span><span class="st">&#39;Groesse&#39;</span><span class="sc">:&gt;10}</span><span class="ss"> </span><span class="sc">{</span><span class="st">&#39;Status&#39;</span><span class="sc">:&gt;20}</span><span class="ss"> </span><span class="sc">{</span><span class="st">&#39;Kosten&#39;</span><span class="sc">:&gt;11}</span><span class="ss"> &quot;</span></span>
-<span id="cb211-142"><a href="#cb211-142" aria-hidden="true" tabindex="-1"></a>          <span class="ss">f&quot;</span><span class="sc">{</span><span class="st">&#39;Gap&#39;</span><span class="sc">:&gt;8}</span><span class="ss"> </span><span class="sc">{</span><span class="st">&#39;Zeit&#39;</span><span class="sc">:&gt;7}</span><span class="ss">&quot;</span>)</span>
-<span id="cb211-143"><a href="#cb211-143" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;  &quot;</span> <span class="op">+</span> <span class="st">&quot;-&quot;</span> <span class="op">*</span> <span class="dv">80</span>)</span>
-<span id="cb211-144"><a href="#cb211-144" aria-hidden="true" tabindex="-1"></a>    <span class="cf">for</span> p <span class="kw">in</span> protokolle:</span>
-<span id="cb211-145"><a href="#cb211-145" aria-hidden="true" tabindex="-1"></a>        groesse <span class="op">=</span> <span class="ss">f&quot;</span><span class="sc">{</span>p<span class="sc">.</span>lager<span class="sc">}</span><span class="ss">x</span><span class="sc">{</span>p<span class="sc">.</span>kunden<span class="sc">}</span><span class="ss">&quot;</span></span>
-<span id="cb211-146"><a href="#cb211-146" aria-hidden="true" tabindex="-1"></a>        <span class="bu">print</span>(<span class="ss">f&quot;  </span><span class="sc">{</span>p<span class="sc">.</span>zeitpunkt<span class="sc">:&lt;10}</span><span class="ss"> </span><span class="sc">{</span>groesse<span class="sc">:&gt;10}</span><span class="ss"> </span><span class="sc">{</span>p<span class="sc">.</span>status<span class="sc">:&gt;20}</span><span class="ss"> &quot;</span></span>
-<span id="cb211-147"><a href="#cb211-147" aria-hidden="true" tabindex="-1"></a>              <span class="ss">f&quot;</span><span class="sc">{</span>p<span class="sc">.</span>kosten<span class="sc">:&gt;11,.0f}</span><span class="ss"> </span><span class="sc">{</span>p<span class="sc">.</span>gap <span class="op">*</span> <span class="dv">100</span><span class="sc">:7.2f}</span><span class="ss"> % </span><span class="sc">{</span>p<span class="sc">.</span>laufzeit<span class="sc">:6.2f}</span><span class="ss">s&quot;</span>)</span>
-<span id="cb211-148"><a href="#cb211-148" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb211-149"><a href="#cb211-149" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;</span><span class="ch">\n</span><span class="st">&quot;</span> <span class="op">+</span> <span class="st">&quot;-&quot;</span> <span class="op">*</span> <span class="dv">84</span>)</span>
-<span id="cb211-150"><a href="#cb211-150" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;Und so sehen die Warnungen aus, die daraus folgen:</span><span class="ch">\n</span><span class="st">&quot;</span>)</span>
-<span id="cb211-151"><a href="#cb211-151" aria-hidden="true" tabindex="-1"></a>    <span class="cf">for</span> p <span class="kw">in</span> protokolle:</span>
-<span id="cb211-152"><a href="#cb211-152" aria-hidden="true" tabindex="-1"></a>        <span class="cf">if</span> p.warnungen:</span>
-<span id="cb211-153"><a href="#cb211-153" aria-hidden="true" tabindex="-1"></a>            <span class="bu">print</span>(<span class="ss">f&quot;  </span><span class="sc">{</span>p<span class="sc">.</span>zeitpunkt<span class="sc">}</span><span class="ss">:  &quot;</span> <span class="op">+</span> <span class="st">&quot;; &quot;</span>.join(p.warnungen))</span>
-<span id="cb211-154"><a href="#cb211-154" aria-hidden="true" tabindex="-1"></a>        <span class="cf">else</span>:</span>
-<span id="cb211-155"><a href="#cb211-155" aria-hidden="true" tabindex="-1"></a>            <span class="bu">print</span>(<span class="ss">f&quot;  </span><span class="sc">{</span>p<span class="sc">.</span>zeitpunkt<span class="sc">}</span><span class="ss">:  in Ordnung&quot;</span>)</span>
-<span id="cb211-156"><a href="#cb211-156" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb211-157"><a href="#cb211-157" aria-hidden="true" tabindex="-1"></a>    letzte <span class="op">=</span> protokolle[<span class="op">-</span><span class="dv">1</span>]</span>
-<span id="cb211-158"><a href="#cb211-158" aria-hidden="true" tabindex="-1"></a>    erste_warnung <span class="op">=</span> <span class="bu">next</span>(p <span class="cf">for</span> p <span class="kw">in</span> protokolle <span class="cf">if</span> p.warnungen)</span>
-<span id="cb211-159"><a href="#cb211-159" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb211-160"><a href="#cb211-160" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;</span><span class="ch">\n</span><span class="st">&quot;</span> <span class="op">+</span> <span class="st">&quot;=&quot;</span> <span class="op">*</span> <span class="dv">84</span>)</span>
-<span id="cb211-161"><a href="#cb211-161" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;  WAS DA PASSIERT IST&quot;</span>)</span>
-<span id="cb211-162"><a href="#cb211-162" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;=&quot;</span> <span class="op">*</span> <span class="dv">84</span>)</span>
-<span id="cb211-163"><a href="#cb211-163" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;Seit </span><span class="sc">{</span>erste_warnung<span class="sc">.</span>zeitpunkt<span class="sc">}</span><span class="ss"> erreicht der Job das Zeitlimit und liefert&quot;</span>)</span>
-<span id="cb211-164"><a href="#cb211-164" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;nicht mehr das Optimum, sondern die beste bis dahin gefundene Loesung.&quot;</span>)</span>
-<span id="cb211-165"><a href="#cb211-165" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;Im letzten Lauf betraegt der Abstand zum Bestmoeglichen &quot;</span></span>
-<span id="cb211-166"><a href="#cb211-166" aria-hidden="true" tabindex="-1"></a>          <span class="ss">f&quot;</span><span class="sc">{</span>letzte<span class="sc">.</span>gap<span class="sc">:.1%}</span><span class="ss">.&quot;</span>)</span>
-<span id="cb211-167"><a href="#cb211-167" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>()</span>
-<span id="cb211-168"><a href="#cb211-168" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;Der Job ist nicht abgestuerzt. Er hat keine Fehlermeldung erzeugt.&quot;</span>)</span>
-<span id="cb211-169"><a href="#cb211-169" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;Die Laufzeit ist sogar bemerkenswert STABIL geblieben - genau deshalb,&quot;</span>)</span>
-<span id="cb211-170"><a href="#cb211-170" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;weil das Zeitlimit greift. Ein Ueberwachungssystem, das auf Abstuerze&quot;</span>)</span>
-<span id="cb211-171"><a href="#cb211-171" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;und Laufzeitspitzen achtet, sieht hier nichts.&quot;</span>)</span>
-<span id="cb211-172"><a href="#cb211-172" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>()</span>
-<span id="cb211-173"><a href="#cb211-173" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;Drei Zahlen gehoeren deshalb in jedes Protokoll eines Optimierungsjobs:&quot;</span>)</span>
-<span id="cb211-174"><a href="#cb211-174" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;  * der STATUS   - &#39;Optimal&#39; oder etwas anderes?&quot;</span>)</span>
-<span id="cb211-175"><a href="#cb211-175" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;  * der GAP      - wie weit ist die Loesung vom Bestmoeglichen entfernt?&quot;</span>)</span>
-<span id="cb211-176"><a href="#cb211-176" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;  * die LAUFZEIT im Verhaeltnis zum Limit - wie nah am Anschlag?&quot;</span>)</span>
-<span id="cb211-177"><a href="#cb211-177" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>()</span>
-<span id="cb211-178"><a href="#cb211-178" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;Die dritte ist die frueheste Warnung: Sie steigt, lange bevor der Gap&quot;</span>)</span>
-<span id="cb211-179"><a href="#cb211-179" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;sichtbar wird, und gibt Zeit zum Handeln.&quot;</span>)</span>
-<span id="cb211-180"><a href="#cb211-180" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;=&quot;</span> <span class="op">*</span> <span class="dv">84</span>)</span></code></pre></div>
+<div class="sourceCode" id="cb215"><pre class="sourceCode python"><code class="sourceCode python"><span id="cb215-1"><a href="#cb215-1" aria-hidden="true" tabindex="-1"></a><span class="co">#!/usr/bin/env python3</span></span>
+<span id="cb215-2"><a href="#cb215-2" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb215-3"><a href="#cb215-3" aria-hidden="true" tabindex="-1"></a><span class="co"># Betriebsueberwachung.py</span></span>
+<span id="cb215-4"><a href="#cb215-4" aria-hidden="true" tabindex="-1"></a><span class="co">&quot;&quot;&quot;</span></span>
+<span id="cb215-5"><a href="#cb215-5" aria-hidden="true" tabindex="-1"></a><span class="co">Kapitel Praxisfallen: Das Modell, das still aufgehoert hat zu optimieren.</span></span>
+<span id="cb215-6"><a href="#cb215-6" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb215-7"><a href="#cb215-7" aria-hidden="true" tabindex="-1"></a><span class="co">Ein Optimierungsmodell geht in Betrieb und laeuft jede Nacht. Es liefert</span></span>
+<span id="cb215-8"><a href="#cb215-8" aria-hidden="true" tabindex="-1"></a><span class="co">zuverlaessig eine Zahl, die Job-Dauer bleibt konstant, es gibt keine</span></span>
+<span id="cb215-9"><a href="#cb215-9" aria-hidden="true" tabindex="-1"></a><span class="co">Fehlermeldung. Alles sieht gut aus.</span></span>
+<span id="cb215-10"><a href="#cb215-10" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb215-11"><a href="#cb215-11" aria-hidden="true" tabindex="-1"></a><span class="co">Waehrenddessen waechst das Unternehmen. Aus 15 Lagern werden 40, dann 80. Das</span></span>
+<span id="cb215-12"><a href="#cb215-12" aria-hidden="true" tabindex="-1"></a><span class="co">Zeitlimit von drei Sekunden - vor zwei Jahren grosszuegig bemessen - reicht</span></span>
+<span id="cb215-13"><a href="#cb215-13" aria-hidden="true" tabindex="-1"></a><span class="co">irgendwann nicht mehr. Der Solver bricht ab und liefert die beste Loesung, die</span></span>
+<span id="cb215-14"><a href="#cb215-14" aria-hidden="true" tabindex="-1"></a><span class="co">er bis dahin gefunden hat.</span></span>
+<span id="cb215-15"><a href="#cb215-15" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb215-16"><a href="#cb215-16" aria-hidden="true" tabindex="-1"></a><span class="co">Das ist nicht falsch. Es ist sogar richtig so. Aber es ist etwas anderes als</span></span>
+<span id="cb215-17"><a href="#cb215-17" aria-hidden="true" tabindex="-1"></a><span class="co">das, was das Modell einmal geleistet hat - und niemand merkt es, weil im</span></span>
+<span id="cb215-18"><a href="#cb215-18" aria-hidden="true" tabindex="-1"></a><span class="co">Protokoll nur die Kosten stehen.</span></span>
+<span id="cb215-19"><a href="#cb215-19" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb215-20"><a href="#cb215-20" aria-hidden="true" tabindex="-1"></a><span class="co">Dieses Programm zeigt die Verschlechterung und die Ueberwachung, die sie</span></span>
+<span id="cb215-21"><a href="#cb215-21" aria-hidden="true" tabindex="-1"></a><span class="co">sichtbar macht.</span></span>
+<span id="cb215-22"><a href="#cb215-22" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb215-23"><a href="#cb215-23" aria-hidden="true" tabindex="-1"></a><span class="co">WICHTIG: ortools wird hier nicht importiert (Konflikt mit highspy, siehe</span></span>
+<span id="cb215-24"><a href="#cb215-24" aria-hidden="true" tabindex="-1"></a><span class="co">Kapitel Oekosystem).</span></span>
+<span id="cb215-25"><a href="#cb215-25" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb215-26"><a href="#cb215-26" aria-hidden="true" tabindex="-1"></a><span class="co">Benoetigt: numpy, highspy</span></span>
+<span id="cb215-27"><a href="#cb215-27" aria-hidden="true" tabindex="-1"></a><span class="co">&quot;&quot;&quot;</span></span>
+<span id="cb215-28"><a href="#cb215-28" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb215-29"><a href="#cb215-29" aria-hidden="true" tabindex="-1"></a><span class="im">from</span> __future__ <span class="im">import</span> annotations</span>
+<span id="cb215-30"><a href="#cb215-30" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb215-31"><a href="#cb215-31" aria-hidden="true" tabindex="-1"></a><span class="im">import</span> time</span>
+<span id="cb215-32"><a href="#cb215-32" aria-hidden="true" tabindex="-1"></a><span class="im">from</span> dataclasses <span class="im">import</span> dataclass</span>
+<span id="cb215-33"><a href="#cb215-33" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb215-34"><a href="#cb215-34" aria-hidden="true" tabindex="-1"></a><span class="im">import</span> numpy <span class="im">as</span> np</span>
+<span id="cb215-35"><a href="#cb215-35" aria-hidden="true" tabindex="-1"></a><span class="im">import</span> highspy</span>
+<span id="cb215-36"><a href="#cb215-36" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb215-37"><a href="#cb215-37" aria-hidden="true" tabindex="-1"></a>ZEITLIMIT <span class="op">=</span> <span class="fl">3.0</span>                  <span class="co"># das Budget, das der Nachtjob hat</span></span>
+<span id="cb215-38"><a href="#cb215-38" aria-hidden="true" tabindex="-1"></a>GAP_WARNSCHWELLE <span class="op">=</span> <span class="fl">0.02</span>          <span class="co"># ab 2 % Gap wollen wir es wissen</span></span>
+<span id="cb215-39"><a href="#cb215-39" aria-hidden="true" tabindex="-1"></a>ZEITAUSLASTUNG_WARNSCHWELLE <span class="op">=</span> <span class="fl">0.9</span></span>
+<span id="cb215-40"><a href="#cb215-40" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb215-41"><a href="#cb215-41" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb215-42"><a href="#cb215-42" aria-hidden="true" tabindex="-1"></a><span class="at">@dataclass</span></span>
+<span id="cb215-43"><a href="#cb215-43" aria-hidden="true" tabindex="-1"></a><span class="kw">class</span> Laufprotokoll:</span>
+<span id="cb215-44"><a href="#cb215-44" aria-hidden="true" tabindex="-1"></a>    <span class="co">&quot;&quot;&quot;Was nach JEDEM Produktivlauf protokolliert gehoert.</span></span>
+<span id="cb215-45"><a href="#cb215-45" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb215-46"><a href="#cb215-46" aria-hidden="true" tabindex="-1"></a><span class="co">    Die meisten Systeme schreiben nur &#39;kosten&#39;. Genau deshalb faellt eine</span></span>
+<span id="cb215-47"><a href="#cb215-47" aria-hidden="true" tabindex="-1"></a><span class="co">    schleichende Verschlechterung ueber Monate nicht auf.</span></span>
+<span id="cb215-48"><a href="#cb215-48" aria-hidden="true" tabindex="-1"></a><span class="co">    &quot;&quot;&quot;</span></span>
+<span id="cb215-49"><a href="#cb215-49" aria-hidden="true" tabindex="-1"></a>    zeitpunkt: <span class="bu">str</span></span>
+<span id="cb215-50"><a href="#cb215-50" aria-hidden="true" tabindex="-1"></a>    lager: <span class="bu">int</span></span>
+<span id="cb215-51"><a href="#cb215-51" aria-hidden="true" tabindex="-1"></a>    kunden: <span class="bu">int</span></span>
+<span id="cb215-52"><a href="#cb215-52" aria-hidden="true" tabindex="-1"></a>    status: <span class="bu">str</span></span>
+<span id="cb215-53"><a href="#cb215-53" aria-hidden="true" tabindex="-1"></a>    kosten: <span class="bu">float</span></span>
+<span id="cb215-54"><a href="#cb215-54" aria-hidden="true" tabindex="-1"></a>    gap: <span class="bu">float</span></span>
+<span id="cb215-55"><a href="#cb215-55" aria-hidden="true" tabindex="-1"></a>    laufzeit: <span class="bu">float</span></span>
+<span id="cb215-56"><a href="#cb215-56" aria-hidden="true" tabindex="-1"></a>    knoten: <span class="bu">int</span></span>
+<span id="cb215-57"><a href="#cb215-57" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb215-58"><a href="#cb215-58" aria-hidden="true" tabindex="-1"></a>    <span class="at">@property</span></span>
+<span id="cb215-59"><a href="#cb215-59" aria-hidden="true" tabindex="-1"></a>    <span class="kw">def</span> warnungen(<span class="va">self</span>) <span class="op">-&gt;</span> <span class="bu">list</span>[<span class="bu">str</span>]:</span>
+<span id="cb215-60"><a href="#cb215-60" aria-hidden="true" tabindex="-1"></a>        meldungen <span class="op">=</span> []</span>
+<span id="cb215-61"><a href="#cb215-61" aria-hidden="true" tabindex="-1"></a>        <span class="cf">if</span> <span class="va">self</span>.status <span class="op">!=</span> <span class="st">&quot;Optimal&quot;</span>:</span>
+<span id="cb215-62"><a href="#cb215-62" aria-hidden="true" tabindex="-1"></a>            meldungen.append(<span class="ss">f&quot;nicht beweisbar optimal (</span><span class="sc">{</span><span class="va">self</span><span class="sc">.</span>status<span class="sc">}</span><span class="ss">)&quot;</span>)</span>
+<span id="cb215-63"><a href="#cb215-63" aria-hidden="true" tabindex="-1"></a>        <span class="cf">if</span> <span class="va">self</span>.gap <span class="op">&gt;</span> GAP_WARNSCHWELLE:</span>
+<span id="cb215-64"><a href="#cb215-64" aria-hidden="true" tabindex="-1"></a>            meldungen.append(<span class="ss">f&quot;Gap </span><span class="sc">{</span><span class="va">self</span><span class="sc">.</span>gap<span class="sc">:.1%}</span><span class="ss"> ueber Schwelle &quot;</span></span>
+<span id="cb215-65"><a href="#cb215-65" aria-hidden="true" tabindex="-1"></a>                             <span class="ss">f&quot;</span><span class="sc">{</span>GAP_WARNSCHWELLE<span class="sc">:.0%}</span><span class="ss">&quot;</span>)</span>
+<span id="cb215-66"><a href="#cb215-66" aria-hidden="true" tabindex="-1"></a>        <span class="cf">if</span> <span class="va">self</span>.laufzeit <span class="op">&gt;</span> ZEITAUSLASTUNG_WARNSCHWELLE <span class="op">*</span> ZEITLIMIT:</span>
+<span id="cb215-67"><a href="#cb215-67" aria-hidden="true" tabindex="-1"></a>            meldungen.append(<span class="ss">f&quot;Zeitbudget zu </span><span class="sc">{</span><span class="va">self</span><span class="sc">.</span>laufzeit <span class="op">/</span> ZEITLIMIT<span class="sc">:.0%}</span><span class="ss"> &quot;</span></span>
+<span id="cb215-68"><a href="#cb215-68" aria-hidden="true" tabindex="-1"></a>                             <span class="ss">f&quot;ausgeschoepft&quot;</span>)</span>
+<span id="cb215-69"><a href="#cb215-69" aria-hidden="true" tabindex="-1"></a>        <span class="cf">return</span> meldungen</span>
+<span id="cb215-70"><a href="#cb215-70" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb215-71"><a href="#cb215-71" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb215-72"><a href="#cb215-72" aria-hidden="true" tabindex="-1"></a><span class="kw">def</span> plane_netzwerk(n_lager: <span class="bu">int</span>, n_kunden: <span class="bu">int</span>, zeitlimit: <span class="bu">float</span>,</span>
+<span id="cb215-73"><a href="#cb215-73" aria-hidden="true" tabindex="-1"></a>                   saat: <span class="bu">int</span> <span class="op">=</span> <span class="dv">7</span>) <span class="op">-&gt;</span> <span class="bu">tuple</span>[<span class="bu">str</span>, <span class="bu">float</span>, <span class="bu">float</span>, <span class="bu">float</span>, <span class="bu">int</span>]:</span>
+<span id="cb215-74"><a href="#cb215-74" aria-hidden="true" tabindex="-1"></a>    <span class="co">&quot;&quot;&quot;Standortplanung wie in Kapitel MILP, nur mit wachsender Groesse.&quot;&quot;&quot;</span></span>
+<span id="cb215-75"><a href="#cb215-75" aria-hidden="true" tabindex="-1"></a>    rng <span class="op">=</span> np.random.default_rng(saat)</span>
+<span id="cb215-76"><a href="#cb215-76" aria-hidden="true" tabindex="-1"></a>    fixkosten <span class="op">=</span> rng.uniform(<span class="dv">3000</span>, <span class="dv">9000</span>, n_lager)</span>
+<span id="cb215-77"><a href="#cb215-77" aria-hidden="true" tabindex="-1"></a>    transport <span class="op">=</span> rng.uniform(<span class="dv">5</span>, <span class="dv">60</span>, (n_lager, n_kunden))</span>
+<span id="cb215-78"><a href="#cb215-78" aria-hidden="true" tabindex="-1"></a>    bedarf <span class="op">=</span> rng.uniform(<span class="dv">10</span>, <span class="dv">60</span>, n_kunden)</span>
+<span id="cb215-79"><a href="#cb215-79" aria-hidden="true" tabindex="-1"></a>    kapazitaet <span class="op">=</span> np.full(n_lager, bedarf.<span class="bu">sum</span>() <span class="op">*</span> <span class="fl">0.22</span>)</span>
+<span id="cb215-80"><a href="#cb215-80" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb215-81"><a href="#cb215-81" aria-hidden="true" tabindex="-1"></a>    modell <span class="op">=</span> highspy.Highs()</span>
+<span id="cb215-82"><a href="#cb215-82" aria-hidden="true" tabindex="-1"></a>    modell.setOptionValue(<span class="st">&quot;output_flag&quot;</span>, <span class="va">False</span>)</span>
+<span id="cb215-83"><a href="#cb215-83" aria-hidden="true" tabindex="-1"></a>    modell.setOptionValue(<span class="st">&quot;time_limit&quot;</span>, zeitlimit)</span>
+<span id="cb215-84"><a href="#cb215-84" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb215-85"><a href="#cb215-85" aria-hidden="true" tabindex="-1"></a>    anzahl_x <span class="op">=</span> n_lager <span class="op">*</span> n_kunden</span>
+<span id="cb215-86"><a href="#cb215-86" aria-hidden="true" tabindex="-1"></a>    unendlich <span class="op">=</span> highspy.kHighsInf</span>
+<span id="cb215-87"><a href="#cb215-87" aria-hidden="true" tabindex="-1"></a>    modell.addVars(anzahl_x, np.zeros(anzahl_x), np.full(anzahl_x, unendlich))</span>
+<span id="cb215-88"><a href="#cb215-88" aria-hidden="true" tabindex="-1"></a>    modell.addVars(n_lager, np.zeros(n_lager), np.ones(n_lager))</span>
+<span id="cb215-89"><a href="#cb215-89" aria-hidden="true" tabindex="-1"></a>    <span class="cf">for</span> i <span class="kw">in</span> <span class="bu">range</span>(n_lager):</span>
+<span id="cb215-90"><a href="#cb215-90" aria-hidden="true" tabindex="-1"></a>        modell.changeColIntegrality(anzahl_x <span class="op">+</span> i, highspy.HighsVarType.kInteger)</span>
+<span id="cb215-91"><a href="#cb215-91" aria-hidden="true" tabindex="-1"></a>        modell.changeColCost(anzahl_x <span class="op">+</span> i, fixkosten[i])</span>
+<span id="cb215-92"><a href="#cb215-92" aria-hidden="true" tabindex="-1"></a>        <span class="cf">for</span> j <span class="kw">in</span> <span class="bu">range</span>(n_kunden):</span>
+<span id="cb215-93"><a href="#cb215-93" aria-hidden="true" tabindex="-1"></a>            modell.changeColCost(i <span class="op">*</span> n_kunden <span class="op">+</span> j, transport[i, j])</span>
+<span id="cb215-94"><a href="#cb215-94" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb215-95"><a href="#cb215-95" aria-hidden="true" tabindex="-1"></a>    <span class="cf">for</span> j <span class="kw">in</span> <span class="bu">range</span>(n_kunden):</span>
+<span id="cb215-96"><a href="#cb215-96" aria-hidden="true" tabindex="-1"></a>        index <span class="op">=</span> np.array([i <span class="op">*</span> n_kunden <span class="op">+</span> j <span class="cf">for</span> i <span class="kw">in</span> <span class="bu">range</span>(n_lager)], dtype<span class="op">=</span>np.int32)</span>
+<span id="cb215-97"><a href="#cb215-97" aria-hidden="true" tabindex="-1"></a>        modell.addRow(bedarf[j], bedarf[j], <span class="bu">len</span>(index), index, np.ones(<span class="bu">len</span>(index)))</span>
+<span id="cb215-98"><a href="#cb215-98" aria-hidden="true" tabindex="-1"></a>    <span class="cf">for</span> i <span class="kw">in</span> <span class="bu">range</span>(n_lager):</span>
+<span id="cb215-99"><a href="#cb215-99" aria-hidden="true" tabindex="-1"></a>        index <span class="op">=</span> np.array([i <span class="op">*</span> n_kunden <span class="op">+</span> j <span class="cf">for</span> j <span class="kw">in</span> <span class="bu">range</span>(n_kunden)] <span class="op">+</span> [anzahl_x <span class="op">+</span> i],</span>
+<span id="cb215-100"><a href="#cb215-100" aria-hidden="true" tabindex="-1"></a>                         dtype<span class="op">=</span>np.int32)</span>
+<span id="cb215-101"><a href="#cb215-101" aria-hidden="true" tabindex="-1"></a>        werte <span class="op">=</span> np.concatenate([np.ones(n_kunden), [<span class="op">-</span>kapazitaet[i]]])</span>
+<span id="cb215-102"><a href="#cb215-102" aria-hidden="true" tabindex="-1"></a>        modell.addRow(<span class="op">-</span>unendlich, <span class="fl">0.0</span>, <span class="bu">len</span>(index), index, werte)</span>
+<span id="cb215-103"><a href="#cb215-103" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb215-104"><a href="#cb215-104" aria-hidden="true" tabindex="-1"></a>    t0 <span class="op">=</span> time.perf_counter()</span>
+<span id="cb215-105"><a href="#cb215-105" aria-hidden="true" tabindex="-1"></a>    modell.run()</span>
+<span id="cb215-106"><a href="#cb215-106" aria-hidden="true" tabindex="-1"></a>    laufzeit <span class="op">=</span> time.perf_counter() <span class="op">-</span> t0</span>
+<span id="cb215-107"><a href="#cb215-107" aria-hidden="true" tabindex="-1"></a>    info <span class="op">=</span> modell.getInfo()</span>
+<span id="cb215-108"><a href="#cb215-108" aria-hidden="true" tabindex="-1"></a>    <span class="cf">return</span> (modell.modelStatusToString(modell.getModelStatus()),</span>
+<span id="cb215-109"><a href="#cb215-109" aria-hidden="true" tabindex="-1"></a>            info.objective_function_value, info.mip_gap, laufzeit,</span>
+<span id="cb215-110"><a href="#cb215-110" aria-hidden="true" tabindex="-1"></a>            info.mip_node_count)</span>
+<span id="cb215-111"><a href="#cb215-111" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb215-112"><a href="#cb215-112" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb215-113"><a href="#cb215-113" aria-hidden="true" tabindex="-1"></a><span class="cf">if</span> <span class="va">__name__</span> <span class="op">==</span> <span class="st">&quot;__main__&quot;</span>:</span>
+<span id="cb215-114"><a href="#cb215-114" aria-hidden="true" tabindex="-1"></a>    <span class="co"># So ist das Unternehmen ueber zwei Jahre gewachsen.</span></span>
+<span id="cb215-115"><a href="#cb215-115" aria-hidden="true" tabindex="-1"></a>    entwicklung <span class="op">=</span> [(<span class="st">&quot;2024-Q1&quot;</span>, <span class="dv">15</span>, <span class="dv">40</span>), (<span class="st">&quot;2024-Q3&quot;</span>, <span class="dv">25</span>, <span class="dv">70</span>),</span>
+<span id="cb215-116"><a href="#cb215-116" aria-hidden="true" tabindex="-1"></a>                   (<span class="st">&quot;2025-Q1&quot;</span>, <span class="dv">40</span>, <span class="dv">110</span>), (<span class="st">&quot;2025-Q3&quot;</span>, <span class="dv">60</span>, <span class="dv">160</span>),</span>
+<span id="cb215-117"><a href="#cb215-117" aria-hidden="true" tabindex="-1"></a>                   (<span class="st">&quot;2026-Q1&quot;</span>, <span class="dv">80</span>, <span class="dv">220</span>)]</span>
+<span id="cb215-118"><a href="#cb215-118" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb215-119"><a href="#cb215-119" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;=&quot;</span> <span class="op">*</span> <span class="dv">84</span>)</span>
+<span id="cb215-120"><a href="#cb215-120" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;  WAS DAS PROTOKOLL ZEIGT - UND WAS ES ZEIGEN SOLLTE&quot;</span>)</span>
+<span id="cb215-121"><a href="#cb215-121" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;=&quot;</span> <span class="op">*</span> <span class="dv">84</span>)</span>
+<span id="cb215-122"><a href="#cb215-122" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;Derselbe Nachtjob, unveraendert, mit </span><span class="sc">{</span>ZEITLIMIT<span class="sc">:.0f}</span><span class="ss"> Sekunden Zeitlimit.</span><span class="ch">\n</span><span class="ss">&quot;</span>)</span>
+<span id="cb215-123"><a href="#cb215-123" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb215-124"><a href="#cb215-124" aria-hidden="true" tabindex="-1"></a>    protokolle <span class="op">=</span> []</span>
+<span id="cb215-125"><a href="#cb215-125" aria-hidden="true" tabindex="-1"></a>    <span class="cf">for</span> zeitpunkt, lager, kunden <span class="kw">in</span> entwicklung:</span>
+<span id="cb215-126"><a href="#cb215-126" aria-hidden="true" tabindex="-1"></a>        status, kosten, gap, laufzeit, knoten <span class="op">=</span> plane_netzwerk(</span>
+<span id="cb215-127"><a href="#cb215-127" aria-hidden="true" tabindex="-1"></a>            lager, kunden, ZEITLIMIT)</span>
+<span id="cb215-128"><a href="#cb215-128" aria-hidden="true" tabindex="-1"></a>        protokolle.append(Laufprotokoll(zeitpunkt, lager, kunden, status,</span>
+<span id="cb215-129"><a href="#cb215-129" aria-hidden="true" tabindex="-1"></a>                                        kosten, gap, laufzeit, knoten))</span>
+<span id="cb215-130"><a href="#cb215-130" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb215-131"><a href="#cb215-131" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;So sieht das ueblich gefuehrte Protokoll aus:</span><span class="ch">\n</span><span class="st">&quot;</span>)</span>
+<span id="cb215-132"><a href="#cb215-132" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;  </span><span class="sc">{</span><span class="st">&#39;Zeitpunkt&#39;</span><span class="sc">:&lt;10}</span><span class="ss"> </span><span class="sc">{</span><span class="st">&#39;Kosten&#39;</span><span class="sc">:&gt;12}</span><span class="ss">&quot;</span>)</span>
+<span id="cb215-133"><a href="#cb215-133" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;  &quot;</span> <span class="op">+</span> <span class="st">&quot;-&quot;</span> <span class="op">*</span> <span class="dv">24</span>)</span>
+<span id="cb215-134"><a href="#cb215-134" aria-hidden="true" tabindex="-1"></a>    <span class="cf">for</span> p <span class="kw">in</span> protokolle:</span>
+<span id="cb215-135"><a href="#cb215-135" aria-hidden="true" tabindex="-1"></a>        <span class="bu">print</span>(<span class="ss">f&quot;  </span><span class="sc">{</span>p<span class="sc">.</span>zeitpunkt<span class="sc">:&lt;10}</span><span class="ss"> </span><span class="sc">{</span>p<span class="sc">.</span>kosten<span class="sc">:&gt;12,.0f}</span><span class="ss">&quot;</span>)</span>
+<span id="cb215-136"><a href="#cb215-136" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;</span><span class="ch">\n</span><span class="st">  -&gt; Die Kosten steigen. Das Unternehmen waechst ja auch.&quot;</span>)</span>
+<span id="cb215-137"><a href="#cb215-137" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;     Nichts an dieser Tabelle deutet auf ein Problem hin.&quot;</span>)</span>
+<span id="cb215-138"><a href="#cb215-138" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb215-139"><a href="#cb215-139" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;</span><span class="ch">\n</span><span class="st">&quot;</span> <span class="op">+</span> <span class="st">&quot;-&quot;</span> <span class="op">*</span> <span class="dv">84</span>)</span>
+<span id="cb215-140"><a href="#cb215-140" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;So sieht ein vollstaendiges Protokoll aus:</span><span class="ch">\n</span><span class="st">&quot;</span>)</span>
+<span id="cb215-141"><a href="#cb215-141" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;  </span><span class="sc">{</span><span class="st">&#39;Zeitpunkt&#39;</span><span class="sc">:&lt;10}</span><span class="ss"> </span><span class="sc">{</span><span class="st">&#39;Groesse&#39;</span><span class="sc">:&gt;10}</span><span class="ss"> </span><span class="sc">{</span><span class="st">&#39;Status&#39;</span><span class="sc">:&gt;20}</span><span class="ss"> </span><span class="sc">{</span><span class="st">&#39;Kosten&#39;</span><span class="sc">:&gt;11}</span><span class="ss"> &quot;</span></span>
+<span id="cb215-142"><a href="#cb215-142" aria-hidden="true" tabindex="-1"></a>          <span class="ss">f&quot;</span><span class="sc">{</span><span class="st">&#39;Gap&#39;</span><span class="sc">:&gt;8}</span><span class="ss"> </span><span class="sc">{</span><span class="st">&#39;Zeit&#39;</span><span class="sc">:&gt;7}</span><span class="ss">&quot;</span>)</span>
+<span id="cb215-143"><a href="#cb215-143" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;  &quot;</span> <span class="op">+</span> <span class="st">&quot;-&quot;</span> <span class="op">*</span> <span class="dv">80</span>)</span>
+<span id="cb215-144"><a href="#cb215-144" aria-hidden="true" tabindex="-1"></a>    <span class="cf">for</span> p <span class="kw">in</span> protokolle:</span>
+<span id="cb215-145"><a href="#cb215-145" aria-hidden="true" tabindex="-1"></a>        groesse <span class="op">=</span> <span class="ss">f&quot;</span><span class="sc">{</span>p<span class="sc">.</span>lager<span class="sc">}</span><span class="ss">x</span><span class="sc">{</span>p<span class="sc">.</span>kunden<span class="sc">}</span><span class="ss">&quot;</span></span>
+<span id="cb215-146"><a href="#cb215-146" aria-hidden="true" tabindex="-1"></a>        <span class="bu">print</span>(<span class="ss">f&quot;  </span><span class="sc">{</span>p<span class="sc">.</span>zeitpunkt<span class="sc">:&lt;10}</span><span class="ss"> </span><span class="sc">{</span>groesse<span class="sc">:&gt;10}</span><span class="ss"> </span><span class="sc">{</span>p<span class="sc">.</span>status<span class="sc">:&gt;20}</span><span class="ss"> &quot;</span></span>
+<span id="cb215-147"><a href="#cb215-147" aria-hidden="true" tabindex="-1"></a>              <span class="ss">f&quot;</span><span class="sc">{</span>p<span class="sc">.</span>kosten<span class="sc">:&gt;11,.0f}</span><span class="ss"> </span><span class="sc">{</span>p<span class="sc">.</span>gap <span class="op">*</span> <span class="dv">100</span><span class="sc">:7.2f}</span><span class="ss"> % </span><span class="sc">{</span>p<span class="sc">.</span>laufzeit<span class="sc">:6.2f}</span><span class="ss">s&quot;</span>)</span>
+<span id="cb215-148"><a href="#cb215-148" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb215-149"><a href="#cb215-149" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;</span><span class="ch">\n</span><span class="st">&quot;</span> <span class="op">+</span> <span class="st">&quot;-&quot;</span> <span class="op">*</span> <span class="dv">84</span>)</span>
+<span id="cb215-150"><a href="#cb215-150" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;Und so sehen die Warnungen aus, die daraus folgen:</span><span class="ch">\n</span><span class="st">&quot;</span>)</span>
+<span id="cb215-151"><a href="#cb215-151" aria-hidden="true" tabindex="-1"></a>    <span class="cf">for</span> p <span class="kw">in</span> protokolle:</span>
+<span id="cb215-152"><a href="#cb215-152" aria-hidden="true" tabindex="-1"></a>        <span class="cf">if</span> p.warnungen:</span>
+<span id="cb215-153"><a href="#cb215-153" aria-hidden="true" tabindex="-1"></a>            <span class="bu">print</span>(<span class="ss">f&quot;  </span><span class="sc">{</span>p<span class="sc">.</span>zeitpunkt<span class="sc">}</span><span class="ss">:  &quot;</span> <span class="op">+</span> <span class="st">&quot;; &quot;</span>.join(p.warnungen))</span>
+<span id="cb215-154"><a href="#cb215-154" aria-hidden="true" tabindex="-1"></a>        <span class="cf">else</span>:</span>
+<span id="cb215-155"><a href="#cb215-155" aria-hidden="true" tabindex="-1"></a>            <span class="bu">print</span>(<span class="ss">f&quot;  </span><span class="sc">{</span>p<span class="sc">.</span>zeitpunkt<span class="sc">}</span><span class="ss">:  in Ordnung&quot;</span>)</span>
+<span id="cb215-156"><a href="#cb215-156" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb215-157"><a href="#cb215-157" aria-hidden="true" tabindex="-1"></a>    letzte <span class="op">=</span> protokolle[<span class="op">-</span><span class="dv">1</span>]</span>
+<span id="cb215-158"><a href="#cb215-158" aria-hidden="true" tabindex="-1"></a>    erste_warnung <span class="op">=</span> <span class="bu">next</span>(p <span class="cf">for</span> p <span class="kw">in</span> protokolle <span class="cf">if</span> p.warnungen)</span>
+<span id="cb215-159"><a href="#cb215-159" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb215-160"><a href="#cb215-160" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;</span><span class="ch">\n</span><span class="st">&quot;</span> <span class="op">+</span> <span class="st">&quot;=&quot;</span> <span class="op">*</span> <span class="dv">84</span>)</span>
+<span id="cb215-161"><a href="#cb215-161" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;  WAS DA PASSIERT IST&quot;</span>)</span>
+<span id="cb215-162"><a href="#cb215-162" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;=&quot;</span> <span class="op">*</span> <span class="dv">84</span>)</span>
+<span id="cb215-163"><a href="#cb215-163" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;Seit </span><span class="sc">{</span>erste_warnung<span class="sc">.</span>zeitpunkt<span class="sc">}</span><span class="ss"> erreicht der Job das Zeitlimit und liefert&quot;</span>)</span>
+<span id="cb215-164"><a href="#cb215-164" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;nicht mehr das Optimum, sondern die beste bis dahin gefundene Loesung.&quot;</span>)</span>
+<span id="cb215-165"><a href="#cb215-165" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;Im letzten Lauf betraegt der Abstand zum Bestmoeglichen &quot;</span></span>
+<span id="cb215-166"><a href="#cb215-166" aria-hidden="true" tabindex="-1"></a>          <span class="ss">f&quot;</span><span class="sc">{</span>letzte<span class="sc">.</span>gap<span class="sc">:.1%}</span><span class="ss">.&quot;</span>)</span>
+<span id="cb215-167"><a href="#cb215-167" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>()</span>
+<span id="cb215-168"><a href="#cb215-168" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;Der Job ist nicht abgestuerzt. Er hat keine Fehlermeldung erzeugt.&quot;</span>)</span>
+<span id="cb215-169"><a href="#cb215-169" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;Die Laufzeit ist sogar bemerkenswert STABIL geblieben - genau deshalb,&quot;</span>)</span>
+<span id="cb215-170"><a href="#cb215-170" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;weil das Zeitlimit greift. Ein Ueberwachungssystem, das auf Abstuerze&quot;</span>)</span>
+<span id="cb215-171"><a href="#cb215-171" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;und Laufzeitspitzen achtet, sieht hier nichts.&quot;</span>)</span>
+<span id="cb215-172"><a href="#cb215-172" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>()</span>
+<span id="cb215-173"><a href="#cb215-173" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;Drei Zahlen gehoeren deshalb in jedes Protokoll eines Optimierungsjobs:&quot;</span>)</span>
+<span id="cb215-174"><a href="#cb215-174" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;  * der STATUS   - &#39;Optimal&#39; oder etwas anderes?&quot;</span>)</span>
+<span id="cb215-175"><a href="#cb215-175" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;  * der GAP      - wie weit ist die Loesung vom Bestmoeglichen entfernt?&quot;</span>)</span>
+<span id="cb215-176"><a href="#cb215-176" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;  * die LAUFZEIT im Verhaeltnis zum Limit - wie nah am Anschlag?&quot;</span>)</span>
+<span id="cb215-177"><a href="#cb215-177" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>()</span>
+<span id="cb215-178"><a href="#cb215-178" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;Die dritte ist die frueheste Warnung: Sie steigt, lange bevor der Gap&quot;</span>)</span>
+<span id="cb215-179"><a href="#cb215-179" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;sichtbar wird, und gibt Zeit zum Handeln.&quot;</span>)</span>
+<span id="cb215-180"><a href="#cb215-180" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;=&quot;</span> <span class="op">*</span> <span class="dv">84</span>)</span></code></pre></div>
 <p><strong>Erwartete Ausgabe (Zeiten hardwareabhängig):</strong></p>
 <pre><code>====================================================================================
   WAS DAS PROTOKOLL ZEIGT - UND WAS ES ZEIGEN SOLLTE
@@ -26578,16 +28091,16 @@ sichtbar wird, und gibt Zeit zum Handeln.
 <p><strong>🎯 Merksatz</strong> Ein Optimierungsjob, der ein Zeitlimit hat, wird bei wachsenden Daten <strong>nicht langsamer</strong> — er wird <strong>schlechter</strong>. Genau deshalb greift die übliche Betriebsüberwachung nicht: Sie achtet auf Laufzeit und Abstürze, und beides bleibt unauffällig. Protokollieren Sie <strong>Status, Gap und Zeitausschöpfung</strong> bei jedem Lauf, oder Sie erfahren nie, wann Ihr Modell aufgehört hat zu optimieren.</p>
 </blockquote>
 <hr />
-<h2 id="sec:praxisfallen-quiz">22.11 Micro-Quiz</h2>
+<h2 id="sec:praxisfallen-quiz">22.12 Micro-Quiz</h2>
 <blockquote>
-<p><strong>❓ Micro-Quiz 15: Drei Fragen zum Selbstcheck</strong></p>
+<p><strong>❓ Micro-Quiz 22: Drei Fragen zum Selbstcheck</strong></p>
 <p>Genau eine Antwort ist jeweils richtig. Auflösung in <a href="#quiz-loesung-praxisfallen">Anhang A</a>.</p>
 <p><strong>1. Ihr Nachtjob läuft seit Monaten konstant 3,0 Sekunden bei einem Zeitlimit von 3 Sekunden. Was schließen Sie daraus?</strong> (a) Das System ist bemerkenswert stabil. (b) Das Zeitlimit greift jedes Mal. Der Solver bricht ab, statt fertig zu werden — die konstante Laufzeit ist das Symptom, nicht die Beruhigung. (c) Der Rechner ist ausgelastet und sollte aufgerüstet werden.</p>
 <p><strong>2. Eine Prüffunktion soll kontrollieren, ob ein Tourenplan die Fahrzeugkapazitäten einhält. Woher nimmt sie die geladenen Mengen?</strong> (a) Aus der Ladungsdimension des Routing-Modells — dort stehen sie ja bereits. (b) Sie summiert die Bedarfe der Kunden aus dem <strong>ausgegebenen Tourenplan</strong> auf. Alles andere fragt das Modell, ob es sich an sich selbst hält. (c) Aus der Zielfunktion, sofern die Kapazität dort bepreist ist.</p>
 <p><strong>3. Ein Modell meldet <code>INFEASIBLE</code>, nachdem eine neue Regel aufgenommen wurde. Was ist der produktivste erste Schritt?</strong> (a) Das Zeitlimit erhöhen. (b) Die neue Regel wieder entfernen und in Ruhe abwarten. (c) Die harten Regeln hierarchisch lockern — mit teuren Strafkosten statt Verboten —, damit der Solver benennt, <strong>welche</strong> Regel den Widerspruch erzeugt, statt nur zu sagen, dass es einen gibt.</p>
 </blockquote>
 <hr />
-<h2 id="sec:praxisfallen-selbsttest">22.12 Selbsttest</h2>
+<h2 id="sec:praxisfallen-selbsttest">22.13 Selbsttest</h2>
 <blockquote>
 <p>Antworten: <a href="#selbsttest-loesung-praxisfallen">Anhang A</a>.</p>
 </blockquote>
@@ -26597,12 +28110,18 @@ sichtbar wird, und gibt Zeit zum Handeln.
 <li>Warum ist ein MIP-Gap von 2 % in der Praxis meist ausreichend?</li>
 <li>Was ist das Snapshot-Prinzip und wozu dient es?</li>
 <li>Was ist der häufigste Grund, aus dem OR-Projekte scheitern?</li>
+<li>Eine Bedingung bindet, ihr Schattenpreis ist 0. Was heißt das — und was folgt daraus für eine Nachverhandlung?</li>
+<li>Warum kann die Rangfolge nach Schattenpreis eine andere sein als die Rangfolge nach tatsächlichem Nutzen einer Lockerung?</li>
 </ol>
 <hr />
-<h2 id="sec:praxisfallen-zusammenfassung">22.13 Zusammenfassung</h2>
+<h2 id="sec:praxisfallen-zusammenfassung">22.14 Zusammenfassung</h2>
 <ul>
 <li><strong>Infeasibility ist ein Entwurfsproblem, kein Solverproblem.</strong> Wer alles hart formuliert, erhält irgendwann eine Fehlermeldung statt eines Plans.</li>
 <li><strong>Erklärbarkeit entscheidet über Akzeptanz.</strong> Schattenpreise, Kostenzerlegung und Constraint-Traces sind keine Kür.</li>
+<li><strong>Bindend heißt nicht teuer.</strong> Eine Bedingung kann den Plan berühren und trotzdem 0,00 € kosten. Nur die kostenrelevanten lohnen eine Nachverhandlung.</li>
+<li><strong>Der Schattenpreis gilt für die nächste Einheit, nicht für die nächste Schicht.</strong> Hochgerechnet auf einen realistischen Schritt überschätzt er den Nutzen — im Beispiel um das Doppelte. Wer wissen will, was ein Hebel bringt, <strong>misst</strong> die Lockerung, statt zu multiplizieren; die beiden Ranglisten können sich dabei umdrehen.</li>
+<li><strong>Ein Wunsch kann unmöglich statt teuer sein</strong> — und dann ist die richtige Antwort nicht ein Preis, sondern die Liste der Bedingungen, die ihn gemeinsam blockieren.</li>
+<li><strong>Ein generierter Bericht macht ein Modell nicht richtiger, nur schwerer anzuzweifeln.</strong> Er erklärt das Modell, nicht die Wirklichkeit — deshalb gehört dazu, worauf er beruht.</li>
 <li><strong>Optimieren Sie nicht genauer als Ihre Daten.</strong> Ein Gap von 2 % ist bei ±10 % Datenunsicherheit irrelevant.</li>
 <li><strong>Der Optimierer schlägt vor, der Mensch entscheidet</strong> — jedenfalls anfangs.</li>
 <li><strong>Reproduzierbarkeit braucht Snapshots und Versionierung</strong>, nicht guten Willen.</li>
@@ -26616,7 +28135,7 @@ sichtbar wird, und gibt Zeit zum Handeln.
 <blockquote>
 <p><strong>📌 Kapitel auf einen Blick</strong></p>
 <p><strong>Worum geht es?</strong> Um die drei Fragen, die zwischen einem funktionierenden Modell und einem System stehen, auf das sich jemand verlässt: <em>Woher weiß ich, dass es stimmt? Woher weiß ich, dass es schnell genug ist? Wie kommt es zu den Leuten, die es brauchen?</em></p>
-<p><strong>Voraussetzungen:</strong> <a href="#kap-praxisfallen">Kapitel 22</a>, insbesondere <code>or_kern.py</code> aus <a href="#sec:praxisfallen-or-kern">Abschnitt 22.5</a> — dieses Kapitel testet genau dieses Modul.</p>
+<p><strong>Voraussetzungen:</strong> <a href="#kap-praxisfallen">Kapitel 22</a>, insbesondere <code>or_kern.py</code> aus <a href="#sec:praxisfallen-or-kern">Abschnitt 22.6</a> — dieses Kapitel testet genau dieses Modul.</p>
 <p><strong>Danach können Sie:</strong> ein Optimierungsmodell testen, obwohl Sie die richtige Antwort nicht kennen; Ihre eigene Testsuite auf Lücken prüfen; einen Solververgleich aufsetzen, dem man glauben kann; und das Modell als Dienst betreiben, ohne dass die erste große Anfrage ihn blockiert.</p>
 <p><strong>Zeitbedarf:</strong> ca. 5 Stunden.</p>
 <p><strong>Programme:</strong><br />
@@ -26632,22 +28151,22 @@ sichtbar wird, und gibt Zeit zum Handeln.
 <blockquote>
 <p><strong>🚀 In 5 Minuten gelöst: drei Zeilen, die einen echten Fehler fangen</strong></p>
 <p>Die Schreinerei aus <a href="#kap-einfuehrung">Kapitel 1</a>, nur mit etwas knapperen Kapazitäten. Der Solver liefert einen Plan, halbe Tische gibt es nicht — also wird gerundet.</p>
-<div class="sourceCode" id="cb213"><pre class="sourceCode python"><code class="sourceCode python"><span id="cb213-1"><a href="#cb213-1" aria-hidden="true" tabindex="-1"></a><span class="im">import</span> numpy <span class="im">as</span> np</span>
-<span id="cb213-2"><a href="#cb213-2" aria-hidden="true" tabindex="-1"></a><span class="im">from</span> scipy.optimize <span class="im">import</span> linprog</span>
-<span id="cb213-3"><a href="#cb213-3" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb213-4"><a href="#cb213-4" aria-hidden="true" tabindex="-1"></a>verbrauch_je_stueck <span class="op">=</span> np.array([[<span class="fl">3.0</span>, <span class="fl">1.0</span>],    <span class="co"># Montagestunden je Tisch/Stuhl</span></span>
-<span id="cb213-5"><a href="#cb213-5" aria-hidden="true" tabindex="-1"></a>                                [<span class="fl">6.0</span>, <span class="fl">1.0</span>]])   <span class="co"># Plattenmaterial je Tisch/Stuhl</span></span>
-<span id="cb213-6"><a href="#cb213-6" aria-hidden="true" tabindex="-1"></a>kapazitaet <span class="op">=</span> np.array([<span class="fl">140.0</span>, <span class="fl">232.0</span>])</span>
-<span id="cb213-7"><a href="#cb213-7" aria-hidden="true" tabindex="-1"></a>deckungsbeitrag <span class="op">=</span> np.array([<span class="fl">240.0</span>, <span class="fl">60.0</span>])</span>
-<span id="cb213-8"><a href="#cb213-8" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb213-9"><a href="#cb213-9" aria-hidden="true" tabindex="-1"></a>loesung <span class="op">=</span> linprog(<span class="op">-</span>deckungsbeitrag, A_ub<span class="op">=</span>verbrauch_je_stueck, b_ub<span class="op">=</span>kapazitaet,</span>
-<span id="cb213-10"><a href="#cb213-10" aria-hidden="true" tabindex="-1"></a>                  bounds<span class="op">=</span>(<span class="dv">0</span>, <span class="va">None</span>), method<span class="op">=</span><span class="st">&quot;highs&quot;</span>)</span>
-<span id="cb213-11"><a href="#cb213-11" aria-hidden="true" tabindex="-1"></a>plan <span class="op">=</span> np.<span class="bu">round</span>(loesung.x)                     <span class="co"># &quot;Halbe Tische gibt es nicht&quot;</span></span>
-<span id="cb213-12"><a href="#cb213-12" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb213-13"><a href="#cb213-13" aria-hidden="true" tabindex="-1"></a>verbrauch <span class="op">=</span> verbrauch_je_stueck <span class="op">@</span> plan         <span class="co"># DER </span><span class="al">TEST</span></span>
-<span id="cb213-14"><a href="#cb213-14" aria-hidden="true" tabindex="-1"></a><span class="cf">assert</span> (verbrauch <span class="op">&lt;=</span> kapazitaet <span class="op">+</span> <span class="fl">1e-6</span>).<span class="bu">all</span>(), <span class="op">\</span></span>
-<span id="cb213-15"><a href="#cb213-15" aria-hidden="true" tabindex="-1"></a>    <span class="ss">f&quot;Plan </span><span class="sc">{</span>plan<span class="sc">}</span><span class="ss"> braucht </span><span class="sc">{</span>verbrauch<span class="sc">}</span><span class="ss">, verfuegbar sind </span><span class="sc">{</span>kapazitaet<span class="sc">}</span><span class="ss">&quot;</span></span>
-<span id="cb213-16"><a href="#cb213-16" aria-hidden="true" tabindex="-1"></a><span class="bu">print</span>(<span class="st">&quot;Abnahme bestanden:&quot;</span>, plan)</span></code></pre></div>
+<div class="sourceCode" id="cb217"><pre class="sourceCode python"><code class="sourceCode python"><span id="cb217-1"><a href="#cb217-1" aria-hidden="true" tabindex="-1"></a><span class="im">import</span> numpy <span class="im">as</span> np</span>
+<span id="cb217-2"><a href="#cb217-2" aria-hidden="true" tabindex="-1"></a><span class="im">from</span> scipy.optimize <span class="im">import</span> linprog</span>
+<span id="cb217-3"><a href="#cb217-3" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb217-4"><a href="#cb217-4" aria-hidden="true" tabindex="-1"></a>verbrauch_je_stueck <span class="op">=</span> np.array([[<span class="fl">3.0</span>, <span class="fl">1.0</span>],    <span class="co"># Montagestunden je Tisch/Stuhl</span></span>
+<span id="cb217-5"><a href="#cb217-5" aria-hidden="true" tabindex="-1"></a>                                [<span class="fl">6.0</span>, <span class="fl">1.0</span>]])   <span class="co"># Plattenmaterial je Tisch/Stuhl</span></span>
+<span id="cb217-6"><a href="#cb217-6" aria-hidden="true" tabindex="-1"></a>kapazitaet <span class="op">=</span> np.array([<span class="fl">140.0</span>, <span class="fl">232.0</span>])</span>
+<span id="cb217-7"><a href="#cb217-7" aria-hidden="true" tabindex="-1"></a>deckungsbeitrag <span class="op">=</span> np.array([<span class="fl">240.0</span>, <span class="fl">60.0</span>])</span>
+<span id="cb217-8"><a href="#cb217-8" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb217-9"><a href="#cb217-9" aria-hidden="true" tabindex="-1"></a>loesung <span class="op">=</span> linprog(<span class="op">-</span>deckungsbeitrag, A_ub<span class="op">=</span>verbrauch_je_stueck, b_ub<span class="op">=</span>kapazitaet,</span>
+<span id="cb217-10"><a href="#cb217-10" aria-hidden="true" tabindex="-1"></a>                  bounds<span class="op">=</span>(<span class="dv">0</span>, <span class="va">None</span>), method<span class="op">=</span><span class="st">&quot;highs&quot;</span>)</span>
+<span id="cb217-11"><a href="#cb217-11" aria-hidden="true" tabindex="-1"></a>plan <span class="op">=</span> np.<span class="bu">round</span>(loesung.x)                     <span class="co"># &quot;Halbe Tische gibt es nicht&quot;</span></span>
+<span id="cb217-12"><a href="#cb217-12" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb217-13"><a href="#cb217-13" aria-hidden="true" tabindex="-1"></a>verbrauch <span class="op">=</span> verbrauch_je_stueck <span class="op">@</span> plan         <span class="co"># DER </span><span class="al">TEST</span></span>
+<span id="cb217-14"><a href="#cb217-14" aria-hidden="true" tabindex="-1"></a><span class="cf">assert</span> (verbrauch <span class="op">&lt;=</span> kapazitaet <span class="op">+</span> <span class="fl">1e-6</span>).<span class="bu">all</span>(), <span class="op">\</span></span>
+<span id="cb217-15"><a href="#cb217-15" aria-hidden="true" tabindex="-1"></a>    <span class="ss">f&quot;Plan </span><span class="sc">{</span>plan<span class="sc">}</span><span class="ss"> braucht </span><span class="sc">{</span>verbrauch<span class="sc">}</span><span class="ss">, verfuegbar sind </span><span class="sc">{</span>kapazitaet<span class="sc">}</span><span class="ss">&quot;</span></span>
+<span id="cb217-16"><a href="#cb217-16" aria-hidden="true" tabindex="-1"></a><span class="bu">print</span>(<span class="st">&quot;Abnahme bestanden:&quot;</span>, plan)</span></code></pre></div>
 <p><strong>Ausgabe:</strong></p>
 <pre><code>Traceback (most recent call last):
   File &quot;schnellstart.py&quot;, line 14, in &lt;module&gt;
@@ -26674,7 +28193,7 @@ AssertionError: Plan [31. 48.] braucht [141. 234.], verfuegbar sind [140. 232.]<
 <hr />
 <h2 id="sec:testing-warum-schwer">23.3 Warum Optimierungsmodelle schwer zu testen sind</h2>
 <p>Bei einer gewöhnlichen Funktion schreibt man den erwarteten Wert hin:</p>
-<div class="sourceCode" id="cb215"><pre class="sourceCode python"><code class="sourceCode python"><span id="cb215-1"><a href="#cb215-1" aria-hidden="true" tabindex="-1"></a><span class="cf">assert</span> steuer(<span class="dv">50_000</span>) <span class="op">==</span> <span class="fl">12_345.60</span></span></code></pre></div>
+<div class="sourceCode" id="cb219"><pre class="sourceCode python"><code class="sourceCode python"><span id="cb219-1"><a href="#cb219-1" aria-hidden="true" tabindex="-1"></a><span class="cf">assert</span> steuer(<span class="dv">50_000</span>) <span class="op">==</span> <span class="fl">12_345.60</span></span></code></pre></div>
 <p>Bei „der beste Produktionsplan für 400 Aufträge” gibt es niemanden, der die Antwort unabhängig ausrechnen könnte. Gäbe es ihn, bräuchte man den Solver nicht. Damit fällt die naheliegende Testform aus — und mit ihr die Illusion, man könne Optimierungscode wie Geschäftslogik testen.</p>
 <p>Was bleibt, sind vier Ersatzformen:</p>
 <table>
@@ -26721,315 +28240,315 @@ AssertionError: Plan [31. 48.] braucht [141. 234.], verfuegbar sind [140. 232.]<
 </blockquote>
 <hr />
 <h2 id="sec:testing-suite">23.4 Die Testsuite</h2>
-<div class="sourceCode" id="cb216"><pre class="sourceCode python"><code class="sourceCode python"><span id="cb216-1"><a href="#cb216-1" aria-hidden="true" tabindex="-1"></a><span class="co">#!/usr/bin/env python3</span></span>
-<span id="cb216-2"><a href="#cb216-2" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb216-3"><a href="#cb216-3" aria-hidden="true" tabindex="-1"></a><span class="co"># test_or_kern.py</span></span>
-<span id="cb216-4"><a href="#cb216-4" aria-hidden="true" tabindex="-1"></a><span class="co">&quot;&quot;&quot;</span></span>
-<span id="cb216-5"><a href="#cb216-5" aria-hidden="true" tabindex="-1"></a><span class="co">Kapitel Testen: Eine Testsuite fuer ein Optimierungsmodell.</span></span>
-<span id="cb216-6"><a href="#cb216-6" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb216-7"><a href="#cb216-7" aria-hidden="true" tabindex="-1"></a><span class="co">Das Grundproblem beim Testen von Optimierungsmodellen: Man kennt die richtige</span></span>
-<span id="cb216-8"><a href="#cb216-8" aria-hidden="true" tabindex="-1"></a><span class="co">Antwort nicht. Bei einer Funktion `steuer(brutto)` schreibt man den erwarteten</span></span>
-<span id="cb216-9"><a href="#cb216-9" aria-hidden="true" tabindex="-1"></a><span class="co">Wert hin. Bei &quot;der beste Produktionsplan fuer 400 Auftraege&quot; gibt es niemanden,</span></span>
-<span id="cb216-10"><a href="#cb216-10" aria-hidden="true" tabindex="-1"></a><span class="co">der ihn unabhaengig ausrechnen koennte - sonst braeuchte man den Solver nicht.</span></span>
-<span id="cb216-11"><a href="#cb216-11" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb216-12"><a href="#cb216-12" aria-hidden="true" tabindex="-1"></a><span class="co">Deshalb testet man nicht den WERT, sondern vier andere Dinge:</span></span>
-<span id="cb216-13"><a href="#cb216-13" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb216-14"><a href="#cb216-14" aria-hidden="true" tabindex="-1"></a><span class="co">  1. EIGENSCHAFTEN  Die Loesung haelt jede Nebenbedingung ein, und der</span></span>
-<span id="cb216-15"><a href="#cb216-15" aria-hidden="true" tabindex="-1"></a><span class="co">                    ausgewiesene Zielwert passt zu den Mengen.</span></span>
-<span id="cb216-16"><a href="#cb216-16" aria-hidden="true" tabindex="-1"></a><span class="co">  2. INVARIANTEN    Was das Ergebnis NICHT aendern darf: die Reihenfolge der</span></span>
-<span id="cb216-17"><a href="#cb216-17" aria-hidden="true" tabindex="-1"></a><span class="co">                    Produkte, die Waehrungseinheit, ein zusaetzliches Produkt</span></span>
-<span id="cb216-18"><a href="#cb216-18" aria-hidden="true" tabindex="-1"></a><span class="co">                    mit Deckungsbeitrag 0.</span></span>
-<span id="cb216-19"><a href="#cb216-19" aria-hidden="true" tabindex="-1"></a><span class="co">  3. REGRESSION     Eine kleine Instanz mit von Hand nachgerechnetem Optimum.</span></span>
-<span id="cb216-20"><a href="#cb216-20" aria-hidden="true" tabindex="-1"></a><span class="co">  4. FEHLERFAELLE   Unsinnige Eingaben werden abgewiesen, unloesbare Modelle</span></span>
-<span id="cb216-21"><a href="#cb216-21" aria-hidden="true" tabindex="-1"></a><span class="co">                    als unloesbar erkannt - und die Abnahmepruefung schlaegt</span></span>
-<span id="cb216-22"><a href="#cb216-22" aria-hidden="true" tabindex="-1"></a><span class="co">                    tatsaechlich an, wenn man ihr eine kaputte Loesung gibt.</span></span>
-<span id="cb216-23"><a href="#cb216-23" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb216-24"><a href="#cb216-24" aria-hidden="true" tabindex="-1"></a><span class="co">Der vierte Punkt ist der wichtigste und wird am haeufigsten vergessen: Eine</span></span>
-<span id="cb216-25"><a href="#cb216-25" aria-hidden="true" tabindex="-1"></a><span class="co">Pruefung, die noch nie etwas gefunden hat, ist keine Pruefung, sondern eine</span></span>
-<span id="cb216-26"><a href="#cb216-26" aria-hidden="true" tabindex="-1"></a><span class="co">Vermutung. Die Tests unten fuettern `pruefe_loesung()` deshalb absichtlich mit</span></span>
-<span id="cb216-27"><a href="#cb216-27" aria-hidden="true" tabindex="-1"></a><span class="co">falschen Loesungen und verlangen, dass sie anschlaegt.</span></span>
-<span id="cb216-28"><a href="#cb216-28" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb216-29"><a href="#cb216-29" aria-hidden="true" tabindex="-1"></a><span class="co">Aufruf:</span></span>
-<span id="cb216-30"><a href="#cb216-30" aria-hidden="true" tabindex="-1"></a><span class="co">    pytest test_or_kern.py -v</span></span>
-<span id="cb216-31"><a href="#cb216-31" aria-hidden="true" tabindex="-1"></a><span class="co">    python3 test_or_kern.py          # ruft pytest selbst auf</span></span>
-<span id="cb216-32"><a href="#cb216-32" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb216-33"><a href="#cb216-33" aria-hidden="true" tabindex="-1"></a><span class="co">Benoetigt: pytest, numpy, pydantic, ortools, scipy (ueber or_kern)</span></span>
-<span id="cb216-34"><a href="#cb216-34" aria-hidden="true" tabindex="-1"></a><span class="co">&quot;&quot;&quot;</span></span>
-<span id="cb216-35"><a href="#cb216-35" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb216-36"><a href="#cb216-36" aria-hidden="true" tabindex="-1"></a><span class="im">from</span> __future__ <span class="im">import</span> annotations</span>
-<span id="cb216-37"><a href="#cb216-37" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb216-38"><a href="#cb216-38" aria-hidden="true" tabindex="-1"></a><span class="im">import</span> pytest</span>
-<span id="cb216-39"><a href="#cb216-39" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb216-40"><a href="#cb216-40" aria-hidden="true" tabindex="-1"></a><span class="im">from</span> or_kern <span class="im">import</span> (Loesung, Produkt, Produktionsproblem, SolverStatus,</span>
-<span id="cb216-41"><a href="#cb216-41" aria-hidden="true" tabindex="-1"></a>                     loese_mit_glop, loese_mit_scipy, pruefe_loesung,</span>
-<span id="cb216-42"><a href="#cb216-42" aria-hidden="true" tabindex="-1"></a>                     status_von_scipy)</span>
-<span id="cb216-43"><a href="#cb216-43" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb216-44"><a href="#cb216-44" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb216-45"><a href="#cb216-45" aria-hidden="true" tabindex="-1"></a><span class="co"># --- Die Instanz, gegen die getestet wird ----------------------------------</span></span>
-<span id="cb216-46"><a href="#cb216-46" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb216-47"><a href="#cb216-47" aria-hidden="true" tabindex="-1"></a><span class="kw">def</span> schreinerei() <span class="op">-&gt;</span> Produktionsproblem:</span>
-<span id="cb216-48"><a href="#cb216-48" aria-hidden="true" tabindex="-1"></a>    <span class="co">&quot;&quot;&quot;Der Fall aus Kapitel Einfuehrung - klein genug fuer die Handrechnung.</span></span>
-<span id="cb216-49"><a href="#cb216-49" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb216-50"><a href="#cb216-50" aria-hidden="true" tabindex="-1"></a><span class="co">    Optimum: 30 Tische, 60 Stuehle, Deckungsbeitrag 10.800 EUR.</span></span>
-<span id="cb216-51"><a href="#cb216-51" aria-hidden="true" tabindex="-1"></a><span class="co">    Beide Ressourcen sind voll ausgelastet (3*30 + 1*60 = 150,</span></span>
-<span id="cb216-52"><a href="#cb216-52" aria-hidden="true" tabindex="-1"></a><span class="co">    6*30 + 1*60 = 240).</span></span>
-<span id="cb216-53"><a href="#cb216-53" aria-hidden="true" tabindex="-1"></a><span class="co">    &quot;&quot;&quot;</span></span>
-<span id="cb216-54"><a href="#cb216-54" aria-hidden="true" tabindex="-1"></a>    <span class="cf">return</span> Produktionsproblem(</span>
-<span id="cb216-55"><a href="#cb216-55" aria-hidden="true" tabindex="-1"></a>        produkte<span class="op">=</span>[</span>
-<span id="cb216-56"><a href="#cb216-56" aria-hidden="true" tabindex="-1"></a>            Produkt(name<span class="op">=</span><span class="st">&quot;Tisch&quot;</span>, deckungsbeitrag<span class="op">=</span><span class="fl">240.0</span>,</span>
-<span id="cb216-57"><a href="#cb216-57" aria-hidden="true" tabindex="-1"></a>                    verbrauch<span class="op">=</span>{<span class="st">&quot;Montagestunden&quot;</span>: <span class="fl">3.0</span>, <span class="st">&quot;Plattenmaterial&quot;</span>: <span class="fl">6.0</span>}),</span>
-<span id="cb216-58"><a href="#cb216-58" aria-hidden="true" tabindex="-1"></a>            Produkt(name<span class="op">=</span><span class="st">&quot;Stuhl&quot;</span>, deckungsbeitrag<span class="op">=</span><span class="fl">60.0</span>,</span>
-<span id="cb216-59"><a href="#cb216-59" aria-hidden="true" tabindex="-1"></a>                    verbrauch<span class="op">=</span>{<span class="st">&quot;Montagestunden&quot;</span>: <span class="fl">1.0</span>, <span class="st">&quot;Plattenmaterial&quot;</span>: <span class="fl">1.0</span>}),</span>
-<span id="cb216-60"><a href="#cb216-60" aria-hidden="true" tabindex="-1"></a>        ],</span>
-<span id="cb216-61"><a href="#cb216-61" aria-hidden="true" tabindex="-1"></a>        kapazitaeten<span class="op">=</span>{<span class="st">&quot;Montagestunden&quot;</span>: <span class="fl">150.0</span>, <span class="st">&quot;Plattenmaterial&quot;</span>: <span class="fl">240.0</span>},</span>
-<span id="cb216-62"><a href="#cb216-62" aria-hidden="true" tabindex="-1"></a>    )</span>
-<span id="cb216-63"><a href="#cb216-63" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb216-64"><a href="#cb216-64" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb216-65"><a href="#cb216-65" aria-hidden="true" tabindex="-1"></a><span class="co"># Beide Modellbauer durchlaufen JEDEN Test. Ein Test, der nur mit einem Solver</span></span>
-<span id="cb216-66"><a href="#cb216-66" aria-hidden="true" tabindex="-1"></a><span class="co"># laeuft, prueft die Bibliothek mit - nicht das Modell.</span></span>
-<span id="cb216-67"><a href="#cb216-67" aria-hidden="true" tabindex="-1"></a>MODELLBAUER <span class="op">=</span> [loese_mit_glop, loese_mit_scipy]</span>
-<span id="cb216-68"><a href="#cb216-68" aria-hidden="true" tabindex="-1"></a>NAMEN <span class="op">=</span> [<span class="st">&quot;glop&quot;</span>, <span class="st">&quot;scipy&quot;</span>]</span>
-<span id="cb216-69"><a href="#cb216-69" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb216-70"><a href="#cb216-70" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb216-71"><a href="#cb216-71" aria-hidden="true" tabindex="-1"></a><span class="at">@pytest.fixture</span>(params<span class="op">=</span>MODELLBAUER, ids<span class="op">=</span>NAMEN)</span>
-<span id="cb216-72"><a href="#cb216-72" aria-hidden="true" tabindex="-1"></a><span class="kw">def</span> bauer(request):</span>
-<span id="cb216-73"><a href="#cb216-73" aria-hidden="true" tabindex="-1"></a>    <span class="cf">return</span> request.param</span>
-<span id="cb216-74"><a href="#cb216-74" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb216-75"><a href="#cb216-75" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb216-76"><a href="#cb216-76" aria-hidden="true" tabindex="-1"></a><span class="co"># --- 1. Eigenschaften ------------------------------------------------------</span></span>
-<span id="cb216-77"><a href="#cb216-77" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb216-78"><a href="#cb216-78" aria-hidden="true" tabindex="-1"></a><span class="kw">def</span> test_loesung_haelt_alle_nebenbedingungen_ein(bauer):</span>
-<span id="cb216-79"><a href="#cb216-79" aria-hidden="true" tabindex="-1"></a>    <span class="co">&quot;&quot;&quot;Die Abnahmepruefung darf nichts zu beanstanden haben.&quot;&quot;&quot;</span></span>
-<span id="cb216-80"><a href="#cb216-80" aria-hidden="true" tabindex="-1"></a>    problem <span class="op">=</span> schreinerei()</span>
-<span id="cb216-81"><a href="#cb216-81" aria-hidden="true" tabindex="-1"></a>    loesung <span class="op">=</span> bauer(problem)</span>
-<span id="cb216-82"><a href="#cb216-82" aria-hidden="true" tabindex="-1"></a>    <span class="cf">assert</span> loesung.status <span class="kw">is</span> SolverStatus.OPTIMAL</span>
-<span id="cb216-83"><a href="#cb216-83" aria-hidden="true" tabindex="-1"></a>    <span class="cf">assert</span> pruefe_loesung(problem, loesung) <span class="op">==</span> []</span>
-<span id="cb216-84"><a href="#cb216-84" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb216-85"><a href="#cb216-85" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb216-86"><a href="#cb216-86" aria-hidden="true" tabindex="-1"></a><span class="kw">def</span> test_zielwert_passt_zu_den_mengen(bauer):</span>
-<span id="cb216-87"><a href="#cb216-87" aria-hidden="true" tabindex="-1"></a>    <span class="co">&quot;&quot;&quot;Der ausgewiesene Zielwert wird unabhaengig nachgerechnet.</span></span>
-<span id="cb216-88"><a href="#cb216-88" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb216-89"><a href="#cb216-89" aria-hidden="true" tabindex="-1"></a><span class="co">    Klingt trivial, ist es nicht: Wer die Zielfunktion im Modell anders</span></span>
-<span id="cb216-90"><a href="#cb216-90" aria-hidden="true" tabindex="-1"></a><span class="co">    zusammensetzt als im Bericht (etwa Gebuehren einmal abgezogen, einmal</span></span>
-<span id="cb216-91"><a href="#cb216-91" aria-hidden="true" tabindex="-1"></a><span class="co">    nicht), merkt es sonst nie.</span></span>
-<span id="cb216-92"><a href="#cb216-92" aria-hidden="true" tabindex="-1"></a><span class="co">    &quot;&quot;&quot;</span></span>
-<span id="cb216-93"><a href="#cb216-93" aria-hidden="true" tabindex="-1"></a>    problem <span class="op">=</span> schreinerei()</span>
-<span id="cb216-94"><a href="#cb216-94" aria-hidden="true" tabindex="-1"></a>    loesung <span class="op">=</span> bauer(problem)</span>
-<span id="cb216-95"><a href="#cb216-95" aria-hidden="true" tabindex="-1"></a>    nachgerechnet <span class="op">=</span> <span class="bu">sum</span>(p.deckungsbeitrag <span class="op">*</span> loesung.werte[p.name]</span>
-<span id="cb216-96"><a href="#cb216-96" aria-hidden="true" tabindex="-1"></a>                        <span class="cf">for</span> p <span class="kw">in</span> problem.produkte)</span>
-<span id="cb216-97"><a href="#cb216-97" aria-hidden="true" tabindex="-1"></a>    <span class="cf">assert</span> loesung.zielwert <span class="op">==</span> pytest.approx(nachgerechnet, <span class="bu">abs</span><span class="op">=</span><span class="fl">1e-6</span>)</span>
-<span id="cb216-98"><a href="#cb216-98" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb216-99"><a href="#cb216-99" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb216-100"><a href="#cb216-100" aria-hidden="true" tabindex="-1"></a><span class="kw">def</span> test_beide_solver_liefern_dasselbe():</span>
-<span id="cb216-101"><a href="#cb216-101" aria-hidden="true" tabindex="-1"></a>    <span class="co">&quot;&quot;&quot;Der Kern der Architektur aus Kapitel Praxisfallen, als Test.&quot;&quot;&quot;</span></span>
-<span id="cb216-102"><a href="#cb216-102" aria-hidden="true" tabindex="-1"></a>    problem <span class="op">=</span> schreinerei()</span>
-<span id="cb216-103"><a href="#cb216-103" aria-hidden="true" tabindex="-1"></a>    glop, scipy_ <span class="op">=</span> loese_mit_glop(problem), loese_mit_scipy(problem)</span>
-<span id="cb216-104"><a href="#cb216-104" aria-hidden="true" tabindex="-1"></a>    <span class="cf">assert</span> glop.zielwert <span class="op">==</span> pytest.approx(scipy_.zielwert, <span class="bu">abs</span><span class="op">=</span><span class="fl">1e-6</span>)</span>
-<span id="cb216-105"><a href="#cb216-105" aria-hidden="true" tabindex="-1"></a>    <span class="cf">for</span> ressource <span class="kw">in</span> problem.ressourcen:</span>
-<span id="cb216-106"><a href="#cb216-106" aria-hidden="true" tabindex="-1"></a>        <span class="cf">assert</span> glop.schattenpreise[ressource] <span class="op">==</span> pytest.approx(</span>
-<span id="cb216-107"><a href="#cb216-107" aria-hidden="true" tabindex="-1"></a>            scipy_.schattenpreise[ressource], <span class="bu">abs</span><span class="op">=</span><span class="fl">1e-6</span>)</span>
-<span id="cb216-108"><a href="#cb216-108" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb216-109"><a href="#cb216-109" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb216-110"><a href="#cb216-110" aria-hidden="true" tabindex="-1"></a><span class="co"># --- 2. Invarianten --------------------------------------------------------</span></span>
-<span id="cb216-111"><a href="#cb216-111" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb216-112"><a href="#cb216-112" aria-hidden="true" tabindex="-1"></a><span class="kw">def</span> test_produktreihenfolge_aendert_nichts(bauer):</span>
-<span id="cb216-113"><a href="#cb216-113" aria-hidden="true" tabindex="-1"></a>    <span class="co">&quot;&quot;&quot;Dieselben Daten in anderer Zeilenreihenfolge - gleiches Ergebnis.</span></span>
-<span id="cb216-114"><a href="#cb216-114" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb216-115"><a href="#cb216-115" aria-hidden="true" tabindex="-1"></a><span class="co">    Das faengt die Spaltenvertauschungsfalle aus Kapitel Finanzdaten ab: ein</span></span>
-<span id="cb216-116"><a href="#cb216-116" aria-hidden="true" tabindex="-1"></a><span class="co">    Modell, das Positionen statt Namen benutzt, faellt hier durch.</span></span>
-<span id="cb216-117"><a href="#cb216-117" aria-hidden="true" tabindex="-1"></a><span class="co">    &quot;&quot;&quot;</span></span>
-<span id="cb216-118"><a href="#cb216-118" aria-hidden="true" tabindex="-1"></a>    problem <span class="op">=</span> schreinerei()</span>
-<span id="cb216-119"><a href="#cb216-119" aria-hidden="true" tabindex="-1"></a>    gedreht <span class="op">=</span> Produktionsproblem(produkte<span class="op">=</span><span class="bu">list</span>(<span class="bu">reversed</span>(problem.produkte)),</span>
-<span id="cb216-120"><a href="#cb216-120" aria-hidden="true" tabindex="-1"></a>                                 kapazitaeten<span class="op">=</span>problem.kapazitaeten)</span>
-<span id="cb216-121"><a href="#cb216-121" aria-hidden="true" tabindex="-1"></a>    <span class="cf">assert</span> bauer(problem).zielwert <span class="op">==</span> pytest.approx(bauer(gedreht).zielwert)</span>
-<span id="cb216-122"><a href="#cb216-122" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb216-123"><a href="#cb216-123" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb216-124"><a href="#cb216-124" aria-hidden="true" tabindex="-1"></a><span class="kw">def</span> test_waehrungseinheit_skaliert_linear(bauer):</span>
-<span id="cb216-125"><a href="#cb216-125" aria-hidden="true" tabindex="-1"></a>    <span class="co">&quot;&quot;&quot;Deckungsbeitraege in Cent statt Euro: Zielwert mal 100, Mengen gleich.</span></span>
-<span id="cb216-126"><a href="#cb216-126" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb216-127"><a href="#cb216-127" aria-hidden="true" tabindex="-1"></a><span class="co">    Der Test prueft nicht die Mathematik - die ist offensichtlich -, sondern</span></span>
-<span id="cb216-128"><a href="#cb216-128" aria-hidden="true" tabindex="-1"></a><span class="co">    die NUMERIK. Wer schlecht skalierte Modelle baut (Kapitel Fundament),</span></span>
-<span id="cb216-129"><a href="#cb216-129" aria-hidden="true" tabindex="-1"></a><span class="co">    bekommt hier Abweichungen weit ueber der Toleranz.</span></span>
-<span id="cb216-130"><a href="#cb216-130" aria-hidden="true" tabindex="-1"></a><span class="co">    &quot;&quot;&quot;</span></span>
-<span id="cb216-131"><a href="#cb216-131" aria-hidden="true" tabindex="-1"></a>    problem <span class="op">=</span> schreinerei()</span>
-<span id="cb216-132"><a href="#cb216-132" aria-hidden="true" tabindex="-1"></a>    in_cent <span class="op">=</span> Produktionsproblem(</span>
-<span id="cb216-133"><a href="#cb216-133" aria-hidden="true" tabindex="-1"></a>        produkte<span class="op">=</span>[Produkt(name<span class="op">=</span>p.name, deckungsbeitrag<span class="op">=</span>p.deckungsbeitrag <span class="op">*</span> <span class="dv">100</span>,</span>
-<span id="cb216-134"><a href="#cb216-134" aria-hidden="true" tabindex="-1"></a>                          verbrauch<span class="op">=</span>p.verbrauch) <span class="cf">for</span> p <span class="kw">in</span> problem.produkte],</span>
-<span id="cb216-135"><a href="#cb216-135" aria-hidden="true" tabindex="-1"></a>        kapazitaeten<span class="op">=</span>problem.kapazitaeten)</span>
-<span id="cb216-136"><a href="#cb216-136" aria-hidden="true" tabindex="-1"></a>    basis, skaliert <span class="op">=</span> bauer(problem), bauer(in_cent)</span>
-<span id="cb216-137"><a href="#cb216-137" aria-hidden="true" tabindex="-1"></a>    <span class="cf">assert</span> skaliert.zielwert <span class="op">==</span> pytest.approx(basis.zielwert <span class="op">*</span> <span class="dv">100</span>, rel<span class="op">=</span><span class="fl">1e-9</span>)</span>
-<span id="cb216-138"><a href="#cb216-138" aria-hidden="true" tabindex="-1"></a>    <span class="cf">for</span> p <span class="kw">in</span> problem.produkte:</span>
-<span id="cb216-139"><a href="#cb216-139" aria-hidden="true" tabindex="-1"></a>        <span class="cf">assert</span> skaliert.werte[p.name] <span class="op">==</span> pytest.approx(basis.werte[p.name],</span>
-<span id="cb216-140"><a href="#cb216-140" aria-hidden="true" tabindex="-1"></a>                                                       <span class="bu">abs</span><span class="op">=</span><span class="fl">1e-6</span>)</span>
-<span id="cb216-141"><a href="#cb216-141" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb216-142"><a href="#cb216-142" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb216-143"><a href="#cb216-143" aria-hidden="true" tabindex="-1"></a><span class="kw">def</span> test_produkt_ohne_deckungsbeitrag_aendert_das_optimum_nicht(bauer):</span>
-<span id="cb216-144"><a href="#cb216-144" aria-hidden="true" tabindex="-1"></a>    <span class="co">&quot;&quot;&quot;Ein Produkt, das nichts einbringt, darf den Zielwert nicht heben.&quot;&quot;&quot;</span></span>
-<span id="cb216-145"><a href="#cb216-145" aria-hidden="true" tabindex="-1"></a>    problem <span class="op">=</span> schreinerei()</span>
-<span id="cb216-146"><a href="#cb216-146" aria-hidden="true" tabindex="-1"></a>    mit_nullprodukt <span class="op">=</span> Produktionsproblem(</span>
-<span id="cb216-147"><a href="#cb216-147" aria-hidden="true" tabindex="-1"></a>        produkte<span class="op">=</span>problem.produkte <span class="op">+</span> [</span>
-<span id="cb216-148"><a href="#cb216-148" aria-hidden="true" tabindex="-1"></a>            Produkt(name<span class="op">=</span><span class="st">&quot;Muster&quot;</span>, deckungsbeitrag<span class="op">=</span><span class="fl">0.0</span>,</span>
-<span id="cb216-149"><a href="#cb216-149" aria-hidden="true" tabindex="-1"></a>                    verbrauch<span class="op">=</span>{<span class="st">&quot;Montagestunden&quot;</span>: <span class="fl">1.0</span>, <span class="st">&quot;Plattenmaterial&quot;</span>: <span class="fl">1.0</span>})],</span>
-<span id="cb216-150"><a href="#cb216-150" aria-hidden="true" tabindex="-1"></a>        kapazitaeten<span class="op">=</span>problem.kapazitaeten)</span>
-<span id="cb216-151"><a href="#cb216-151" aria-hidden="true" tabindex="-1"></a>    <span class="cf">assert</span> bauer(mit_nullprodukt).zielwert <span class="op">&lt;=</span> bauer(problem).zielwert <span class="op">+</span> <span class="fl">1e-6</span></span>
-<span id="cb216-152"><a href="#cb216-152" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb216-153"><a href="#cb216-153" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb216-154"><a href="#cb216-154" aria-hidden="true" tabindex="-1"></a><span class="co"># --- 3. Regression ---------------------------------------------------------</span></span>
-<span id="cb216-155"><a href="#cb216-155" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb216-156"><a href="#cb216-156" aria-hidden="true" tabindex="-1"></a><span class="kw">def</span> test_bekanntes_optimum(bauer):</span>
-<span id="cb216-157"><a href="#cb216-157" aria-hidden="true" tabindex="-1"></a>    <span class="co">&quot;&quot;&quot;Von Hand nachgerechnet (Kapitel Einfuehrung, Handrechnung).</span></span>
-<span id="cb216-158"><a href="#cb216-158" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb216-159"><a href="#cb216-159" aria-hidden="true" tabindex="-1"></a><span class="co">    Das ist der einzige Test, der einen ZAHLENWERT festschreibt - und er darf</span></span>
-<span id="cb216-160"><a href="#cb216-160" aria-hidden="true" tabindex="-1"></a><span class="co">    es, weil dieser Wert von Hand belegt ist. Fuer grosse Instanzen gibt es</span></span>
-<span id="cb216-161"><a href="#cb216-161" aria-hidden="true" tabindex="-1"></a><span class="co">    diesen Test nicht; dort tragen die Eigenschaften und Invarianten.</span></span>
-<span id="cb216-162"><a href="#cb216-162" aria-hidden="true" tabindex="-1"></a><span class="co">    &quot;&quot;&quot;</span></span>
-<span id="cb216-163"><a href="#cb216-163" aria-hidden="true" tabindex="-1"></a>    loesung <span class="op">=</span> bauer(schreinerei())</span>
-<span id="cb216-164"><a href="#cb216-164" aria-hidden="true" tabindex="-1"></a>    <span class="cf">assert</span> loesung.zielwert <span class="op">==</span> pytest.approx(<span class="fl">10_800.0</span>, <span class="bu">abs</span><span class="op">=</span><span class="fl">1e-6</span>)</span>
-<span id="cb216-165"><a href="#cb216-165" aria-hidden="true" tabindex="-1"></a>    <span class="cf">assert</span> loesung.werte[<span class="st">&quot;Tisch&quot;</span>] <span class="op">==</span> pytest.approx(<span class="fl">30.0</span>, <span class="bu">abs</span><span class="op">=</span><span class="fl">1e-6</span>)</span>
-<span id="cb216-166"><a href="#cb216-166" aria-hidden="true" tabindex="-1"></a>    <span class="cf">assert</span> loesung.werte[<span class="st">&quot;Stuhl&quot;</span>] <span class="op">==</span> pytest.approx(<span class="fl">60.0</span>, <span class="bu">abs</span><span class="op">=</span><span class="fl">1e-6</span>)</span>
-<span id="cb216-167"><a href="#cb216-167" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb216-168"><a href="#cb216-168" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb216-169"><a href="#cb216-169" aria-hidden="true" tabindex="-1"></a><span class="kw">def</span> test_schattenpreise_bekannt(bauer):</span>
-<span id="cb216-170"><a href="#cb216-170" aria-hidden="true" tabindex="-1"></a>    <span class="co">&quot;&quot;&quot;40 EUR je Montagestunde, 20 EUR je Einheit Plattenmaterial.&quot;&quot;&quot;</span></span>
-<span id="cb216-171"><a href="#cb216-171" aria-hidden="true" tabindex="-1"></a>    loesung <span class="op">=</span> bauer(schreinerei())</span>
-<span id="cb216-172"><a href="#cb216-172" aria-hidden="true" tabindex="-1"></a>    <span class="cf">assert</span> loesung.schattenpreise[<span class="st">&quot;Montagestunden&quot;</span>] <span class="op">==</span> pytest.approx(<span class="fl">40.0</span>, <span class="bu">abs</span><span class="op">=</span><span class="fl">1e-6</span>)</span>
-<span id="cb216-173"><a href="#cb216-173" aria-hidden="true" tabindex="-1"></a>    <span class="cf">assert</span> loesung.schattenpreise[<span class="st">&quot;Plattenmaterial&quot;</span>] <span class="op">==</span> pytest.approx(<span class="fl">20.0</span>, <span class="bu">abs</span><span class="op">=</span><span class="fl">1e-6</span>)</span>
-<span id="cb216-174"><a href="#cb216-174" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb216-175"><a href="#cb216-175" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb216-176"><a href="#cb216-176" aria-hidden="true" tabindex="-1"></a><span class="co"># --- 4. Fehlerfaelle: schlaegt die Pruefung ueberhaupt an? -----------------</span></span>
-<span id="cb216-177"><a href="#cb216-177" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb216-178"><a href="#cb216-178" aria-hidden="true" tabindex="-1"></a><span class="kw">def</span> test_pruefung_findet_kapazitaetsverletzung():</span>
-<span id="cb216-179"><a href="#cb216-179" aria-hidden="true" tabindex="-1"></a>    <span class="co">&quot;&quot;&quot;Eine Loesung, die zu viel verbraucht, MUSS beanstandet werden.&quot;&quot;&quot;</span></span>
-<span id="cb216-180"><a href="#cb216-180" aria-hidden="true" tabindex="-1"></a>    problem <span class="op">=</span> schreinerei()</span>
-<span id="cb216-181"><a href="#cb216-181" aria-hidden="true" tabindex="-1"></a>    kaputt <span class="op">=</span> Loesung(status<span class="op">=</span>SolverStatus.OPTIMAL,</span>
-<span id="cb216-182"><a href="#cb216-182" aria-hidden="true" tabindex="-1"></a>                     werte<span class="op">=</span>{<span class="st">&quot;Tisch&quot;</span>: <span class="fl">50.0</span>, <span class="st">&quot;Stuhl&quot;</span>: <span class="fl">60.0</span>},   <span class="co"># 3*50+60 = 210 &gt; 150</span></span>
-<span id="cb216-183"><a href="#cb216-183" aria-hidden="true" tabindex="-1"></a>                     zielwert<span class="op">=</span><span class="dv">50</span> <span class="op">*</span> <span class="fl">240.0</span> <span class="op">+</span> <span class="dv">60</span> <span class="op">*</span> <span class="fl">60.0</span>)</span>
-<span id="cb216-184"><a href="#cb216-184" aria-hidden="true" tabindex="-1"></a>    beanstandungen <span class="op">=</span> pruefe_loesung(problem, kaputt)</span>
-<span id="cb216-185"><a href="#cb216-185" aria-hidden="true" tabindex="-1"></a>    <span class="cf">assert</span> <span class="bu">any</span>(<span class="st">&quot;Montagestunden&quot;</span> <span class="kw">in</span> b <span class="cf">for</span> b <span class="kw">in</span> beanstandungen)</span>
-<span id="cb216-186"><a href="#cb216-186" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb216-187"><a href="#cb216-187" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb216-188"><a href="#cb216-188" aria-hidden="true" tabindex="-1"></a><span class="kw">def</span> test_pruefung_findet_falschen_zielwert():</span>
-<span id="cb216-189"><a href="#cb216-189" aria-hidden="true" tabindex="-1"></a>    <span class="co">&quot;&quot;&quot;Mengen und Zielwert passen nicht zusammen - der haeufigste stille Fehler.&quot;&quot;&quot;</span></span>
-<span id="cb216-190"><a href="#cb216-190" aria-hidden="true" tabindex="-1"></a>    problem <span class="op">=</span> schreinerei()</span>
-<span id="cb216-191"><a href="#cb216-191" aria-hidden="true" tabindex="-1"></a>    kaputt <span class="op">=</span> Loesung(status<span class="op">=</span>SolverStatus.OPTIMAL,</span>
-<span id="cb216-192"><a href="#cb216-192" aria-hidden="true" tabindex="-1"></a>                     werte<span class="op">=</span>{<span class="st">&quot;Tisch&quot;</span>: <span class="fl">30.0</span>, <span class="st">&quot;Stuhl&quot;</span>: <span class="fl">60.0</span>},</span>
-<span id="cb216-193"><a href="#cb216-193" aria-hidden="true" tabindex="-1"></a>                     zielwert<span class="op">=</span><span class="fl">99_999.0</span>)</span>
-<span id="cb216-194"><a href="#cb216-194" aria-hidden="true" tabindex="-1"></a>    <span class="cf">assert</span> <span class="bu">any</span>(<span class="st">&quot;Zielwert&quot;</span> <span class="kw">in</span> b <span class="cf">for</span> b <span class="kw">in</span> pruefe_loesung(problem, kaputt))</span>
-<span id="cb216-195"><a href="#cb216-195" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb216-196"><a href="#cb216-196" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb216-197"><a href="#cb216-197" aria-hidden="true" tabindex="-1"></a><span class="kw">def</span> test_pruefung_findet_negative_mengen():</span>
-<span id="cb216-198"><a href="#cb216-198" aria-hidden="true" tabindex="-1"></a>    problem <span class="op">=</span> schreinerei()</span>
-<span id="cb216-199"><a href="#cb216-199" aria-hidden="true" tabindex="-1"></a>    kaputt <span class="op">=</span> Loesung(status<span class="op">=</span>SolverStatus.OPTIMAL,</span>
-<span id="cb216-200"><a href="#cb216-200" aria-hidden="true" tabindex="-1"></a>                     werte<span class="op">=</span>{<span class="st">&quot;Tisch&quot;</span>: <span class="op">-</span><span class="fl">5.0</span>, <span class="st">&quot;Stuhl&quot;</span>: <span class="fl">60.0</span>},</span>
-<span id="cb216-201"><a href="#cb216-201" aria-hidden="true" tabindex="-1"></a>                     zielwert<span class="op">=-</span><span class="dv">5</span> <span class="op">*</span> <span class="fl">240.0</span> <span class="op">+</span> <span class="dv">60</span> <span class="op">*</span> <span class="fl">60.0</span>)</span>
-<span id="cb216-202"><a href="#cb216-202" aria-hidden="true" tabindex="-1"></a>    <span class="cf">assert</span> <span class="bu">any</span>(<span class="st">&quot;negativ&quot;</span> <span class="kw">in</span> b <span class="cf">for</span> b <span class="kw">in</span> pruefe_loesung(problem, kaputt))</span>
-<span id="cb216-203"><a href="#cb216-203" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb216-204"><a href="#cb216-204" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb216-205"><a href="#cb216-205" aria-hidden="true" tabindex="-1"></a><span class="kw">def</span> test_pruefung_findet_gebrochene_ganzzahligkeit():</span>
-<span id="cb216-206"><a href="#cb216-206" aria-hidden="true" tabindex="-1"></a>    <span class="co">&quot;&quot;&quot;Die Falle aus Kapitel MILP: 0,99999998 ist nicht 1.&quot;&quot;&quot;</span></span>
-<span id="cb216-207"><a href="#cb216-207" aria-hidden="true" tabindex="-1"></a>    problem <span class="op">=</span> schreinerei()</span>
-<span id="cb216-208"><a href="#cb216-208" aria-hidden="true" tabindex="-1"></a>    fast_ganz <span class="op">=</span> Loesung(status<span class="op">=</span>SolverStatus.OPTIMAL,</span>
-<span id="cb216-209"><a href="#cb216-209" aria-hidden="true" tabindex="-1"></a>                        werte<span class="op">=</span>{<span class="st">&quot;Tisch&quot;</span>: <span class="fl">29.4</span>, <span class="st">&quot;Stuhl&quot;</span>: <span class="fl">61.8</span>},</span>
-<span id="cb216-210"><a href="#cb216-210" aria-hidden="true" tabindex="-1"></a>                        zielwert<span class="op">=</span><span class="fl">29.4</span> <span class="op">*</span> <span class="fl">240.0</span> <span class="op">+</span> <span class="fl">61.8</span> <span class="op">*</span> <span class="fl">60.0</span>)</span>
-<span id="cb216-211"><a href="#cb216-211" aria-hidden="true" tabindex="-1"></a>    beanstandungen <span class="op">=</span> pruefe_loesung(problem, fast_ganz, ganzzahlig<span class="op">=</span>[<span class="st">&quot;Tisch&quot;</span>])</span>
-<span id="cb216-212"><a href="#cb216-212" aria-hidden="true" tabindex="-1"></a>    <span class="cf">assert</span> <span class="bu">any</span>(<span class="st">&quot;ganzzahlig&quot;</span> <span class="kw">in</span> b <span class="cf">for</span> b <span class="kw">in</span> beanstandungen)</span>
-<span id="cb216-213"><a href="#cb216-213" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb216-214"><a href="#cb216-214" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb216-215"><a href="#cb216-215" aria-hidden="true" tabindex="-1"></a><span class="kw">def</span> test_pruefung_verweigert_unbrauchbaren_status():</span>
-<span id="cb216-216"><a href="#cb216-216" aria-hidden="true" tabindex="-1"></a>    <span class="co">&quot;&quot;&quot;Ohne verwertbares Ergebnis wird gar nicht erst gerechnet.&quot;&quot;&quot;</span></span>
-<span id="cb216-217"><a href="#cb216-217" aria-hidden="true" tabindex="-1"></a>    problem <span class="op">=</span> schreinerei()</span>
-<span id="cb216-218"><a href="#cb216-218" aria-hidden="true" tabindex="-1"></a>    ohne <span class="op">=</span> Loesung(status<span class="op">=</span>SolverStatus.UNZULAESSIG)</span>
-<span id="cb216-219"><a href="#cb216-219" aria-hidden="true" tabindex="-1"></a>    beanstandungen <span class="op">=</span> pruefe_loesung(problem, ohne)</span>
-<span id="cb216-220"><a href="#cb216-220" aria-hidden="true" tabindex="-1"></a>    <span class="cf">assert</span> <span class="bu">len</span>(beanstandungen) <span class="op">==</span> <span class="dv">1</span> <span class="kw">and</span> <span class="st">&quot;unzulaessig&quot;</span> <span class="kw">in</span> beanstandungen[<span class="dv">0</span>]</span>
-<span id="cb216-221"><a href="#cb216-221" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb216-222"><a href="#cb216-222" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb216-223"><a href="#cb216-223" aria-hidden="true" tabindex="-1"></a><span class="at">@pytest.mark.parametrize</span>(<span class="st">&quot;daten, stichwort&quot;</span>, [</span>
-<span id="cb216-224"><a href="#cb216-224" aria-hidden="true" tabindex="-1"></a>    (<span class="bu">dict</span>(produkte<span class="op">=</span>[Produkt(name<span class="op">=</span><span class="st">&quot;Tisch&quot;</span>, deckungsbeitrag<span class="op">=</span><span class="fl">240.0</span>,</span>
-<span id="cb216-225"><a href="#cb216-225" aria-hidden="true" tabindex="-1"></a>                            verbrauch<span class="op">=</span>{<span class="st">&quot;Montagestunden&quot;</span>: <span class="fl">3.0</span>})],</span>
-<span id="cb216-226"><a href="#cb216-226" aria-hidden="true" tabindex="-1"></a>          kapazitaeten<span class="op">=</span>{<span class="st">&quot;Montagestunden&quot;</span>: <span class="fl">0.0</span>}), <span class="st">&quot;greater than&quot;</span>),</span>
-<span id="cb216-227"><a href="#cb216-227" aria-hidden="true" tabindex="-1"></a>    (<span class="bu">dict</span>(produkte<span class="op">=</span>[Produkt(name<span class="op">=</span><span class="st">&quot;Regal&quot;</span>, deckungsbeitrag<span class="op">=</span><span class="fl">130.0</span>,</span>
-<span id="cb216-228"><a href="#cb216-228" aria-hidden="true" tabindex="-1"></a>                            verbrauch<span class="op">=</span>{<span class="st">&quot;Lackieren&quot;</span>: <span class="fl">2.0</span>})],</span>
-<span id="cb216-229"><a href="#cb216-229" aria-hidden="true" tabindex="-1"></a>          kapazitaeten<span class="op">=</span>{<span class="st">&quot;Montagestunden&quot;</span>: <span class="fl">150.0</span>}), <span class="st">&quot;Kapazitaetsangabe&quot;</span>),</span>
-<span id="cb216-230"><a href="#cb216-230" aria-hidden="true" tabindex="-1"></a>    (<span class="bu">dict</span>(produkte<span class="op">=</span>[], kapazitaeten<span class="op">=</span>{<span class="st">&quot;Montagestunden&quot;</span>: <span class="fl">150.0</span>}), <span class="st">&quot;at least 1&quot;</span>),</span>
-<span id="cb216-231"><a href="#cb216-231" aria-hidden="true" tabindex="-1"></a>])</span>
-<span id="cb216-232"><a href="#cb216-232" aria-hidden="true" tabindex="-1"></a><span class="kw">def</span> test_unsinnige_eingaben_werden_beim_einlesen_abgewiesen(daten, stichwort):</span>
-<span id="cb216-233"><a href="#cb216-233" aria-hidden="true" tabindex="-1"></a>    <span class="co">&quot;&quot;&quot;Drei Fehler, die NICHT erst beim Loesen auffallen duerfen.&quot;&quot;&quot;</span></span>
-<span id="cb216-234"><a href="#cb216-234" aria-hidden="true" tabindex="-1"></a>    <span class="cf">with</span> pytest.raises(<span class="pp">Exception</span>) <span class="im">as</span> fehler:</span>
-<span id="cb216-235"><a href="#cb216-235" aria-hidden="true" tabindex="-1"></a>        Produktionsproblem(<span class="op">**</span>daten)</span>
-<span id="cb216-236"><a href="#cb216-236" aria-hidden="true" tabindex="-1"></a>    <span class="cf">assert</span> stichwort <span class="kw">in</span> <span class="bu">str</span>(fehler.value)</span>
-<span id="cb216-237"><a href="#cb216-237" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb216-238"><a href="#cb216-238" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb216-239"><a href="#cb216-239" aria-hidden="true" tabindex="-1"></a><span class="kw">def</span> test_doppelter_produktname_wird_abgewiesen():</span>
-<span id="cb216-240"><a href="#cb216-240" aria-hidden="true" tabindex="-1"></a>    produkt <span class="op">=</span> Produkt(name<span class="op">=</span><span class="st">&quot;Tisch&quot;</span>, deckungsbeitrag<span class="op">=</span><span class="fl">240.0</span>,</span>
-<span id="cb216-241"><a href="#cb216-241" aria-hidden="true" tabindex="-1"></a>                      verbrauch<span class="op">=</span>{<span class="st">&quot;Montagestunden&quot;</span>: <span class="fl">3.0</span>})</span>
-<span id="cb216-242"><a href="#cb216-242" aria-hidden="true" tabindex="-1"></a>    <span class="cf">with</span> pytest.raises(<span class="pp">Exception</span>) <span class="im">as</span> fehler:</span>
-<span id="cb216-243"><a href="#cb216-243" aria-hidden="true" tabindex="-1"></a>        Produktionsproblem(produkte<span class="op">=</span>[produkt, produkt],</span>
-<span id="cb216-244"><a href="#cb216-244" aria-hidden="true" tabindex="-1"></a>                           kapazitaeten<span class="op">=</span>{<span class="st">&quot;Montagestunden&quot;</span>: <span class="fl">150.0</span>})</span>
-<span id="cb216-245"><a href="#cb216-245" aria-hidden="true" tabindex="-1"></a>    <span class="cf">assert</span> <span class="st">&quot;mehrfach&quot;</span> <span class="kw">in</span> <span class="bu">str</span>(fehler.value)</span>
-<span id="cb216-246"><a href="#cb216-246" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb216-247"><a href="#cb216-247" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb216-248"><a href="#cb216-248" aria-hidden="true" tabindex="-1"></a><span class="at">@pytest.mark.parametrize</span>(<span class="st">&quot;rohstatus, erwartet&quot;</span>, [</span>
-<span id="cb216-249"><a href="#cb216-249" aria-hidden="true" tabindex="-1"></a>    (<span class="dv">0</span>, SolverStatus.OPTIMAL),</span>
-<span id="cb216-250"><a href="#cb216-250" aria-hidden="true" tabindex="-1"></a>    (<span class="dv">1</span>, SolverStatus.ZEITLIMIT),</span>
-<span id="cb216-251"><a href="#cb216-251" aria-hidden="true" tabindex="-1"></a>    (<span class="dv">2</span>, SolverStatus.UNZULAESSIG),</span>
-<span id="cb216-252"><a href="#cb216-252" aria-hidden="true" tabindex="-1"></a>    (<span class="dv">3</span>, SolverStatus.UNBESCHRAENKT),</span>
-<span id="cb216-253"><a href="#cb216-253" aria-hidden="true" tabindex="-1"></a>    (<span class="dv">4</span>, SolverStatus.FEHLERHAFT),</span>
-<span id="cb216-254"><a href="#cb216-254" aria-hidden="true" tabindex="-1"></a>    (<span class="dv">99</span>, SolverStatus.UNBEKANNT),</span>
-<span id="cb216-255"><a href="#cb216-255" aria-hidden="true" tabindex="-1"></a>])</span>
-<span id="cb216-256"><a href="#cb216-256" aria-hidden="true" tabindex="-1"></a><span class="kw">def</span> test_statusuebersetzung_scipy(rohstatus, erwartet):</span>
-<span id="cb216-257"><a href="#cb216-257" aria-hidden="true" tabindex="-1"></a>    <span class="co">&quot;&quot;&quot;Die Uebersetzertabelle selbst - inklusive des unbekannten Falls.&quot;&quot;&quot;</span></span>
-<span id="cb216-258"><a href="#cb216-258" aria-hidden="true" tabindex="-1"></a>    <span class="kw">class</span> Ergebnis:</span>
-<span id="cb216-259"><a href="#cb216-259" aria-hidden="true" tabindex="-1"></a>        status <span class="op">=</span> rohstatus</span>
-<span id="cb216-260"><a href="#cb216-260" aria-hidden="true" tabindex="-1"></a>    <span class="cf">assert</span> status_von_scipy(Ergebnis()) <span class="kw">is</span> erwartet</span>
-<span id="cb216-261"><a href="#cb216-261" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb216-262"><a href="#cb216-262" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb216-263"><a href="#cb216-263" aria-hidden="true" tabindex="-1"></a><span class="kw">def</span> test_status_eigenschaften_sind_konsistent():</span>
-<span id="cb216-264"><a href="#cb216-264" aria-hidden="true" tabindex="-1"></a>    <span class="co">&quot;&quot;&quot;brauchbar und modellfehler duerfen sich nie ueberschneiden.&quot;&quot;&quot;</span></span>
-<span id="cb216-265"><a href="#cb216-265" aria-hidden="true" tabindex="-1"></a>    <span class="cf">for</span> status <span class="kw">in</span> SolverStatus:</span>
-<span id="cb216-266"><a href="#cb216-266" aria-hidden="true" tabindex="-1"></a>        <span class="cf">assert</span> <span class="kw">not</span> (status.brauchbar <span class="kw">and</span> status.modellfehler)</span>
-<span id="cb216-267"><a href="#cb216-267" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb216-268"><a href="#cb216-268" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb216-269"><a href="#cb216-269" aria-hidden="true" tabindex="-1"></a><span class="co"># Die beiden folgenden Tests gab es zuerst nicht. Sie sind entstanden, weil</span></span>
-<span id="cb216-270"><a href="#cb216-270" aria-hidden="true" tabindex="-1"></a><span class="co"># Mutationstest.py zwei eingebaute Fehler UEBERLEBEN liess - siehe den</span></span>
-<span id="cb216-271"><a href="#cb216-271" aria-hidden="true" tabindex="-1"></a><span class="co"># Abschnitt &quot;Wer testet die Tests?&quot;.</span></span>
-<span id="cb216-272"><a href="#cb216-272" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb216-273"><a href="#cb216-273" aria-hidden="true" tabindex="-1"></a><span class="kw">def</span> test_nur_optimal_und_zulaessig_gelten_als_brauchbar():</span>
-<span id="cb216-274"><a href="#cb216-274" aria-hidden="true" tabindex="-1"></a>    <span class="co">&quot;&quot;&quot;ZEITLIMIT ist NICHT brauchbar - der Solver hat nichts gefunden.</span></span>
-<span id="cb216-275"><a href="#cb216-275" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb216-276"><a href="#cb216-276" aria-hidden="true" tabindex="-1"></a><span class="co">    Der Unterschied entscheidet, ob ein Nachtjob einen Plan ausliefert oder</span></span>
-<span id="cb216-277"><a href="#cb216-277" aria-hidden="true" tabindex="-1"></a><span class="co">    Alarm schlaegt. Ein aufgeweichtes &#39;brauchbar&#39; faellt sonst nirgends auf.</span></span>
-<span id="cb216-278"><a href="#cb216-278" aria-hidden="true" tabindex="-1"></a><span class="co">    &quot;&quot;&quot;</span></span>
-<span id="cb216-279"><a href="#cb216-279" aria-hidden="true" tabindex="-1"></a>    <span class="cf">assert</span> SolverStatus.OPTIMAL.brauchbar</span>
-<span id="cb216-280"><a href="#cb216-280" aria-hidden="true" tabindex="-1"></a>    <span class="cf">assert</span> SolverStatus.ZULAESSIG.brauchbar</span>
-<span id="cb216-281"><a href="#cb216-281" aria-hidden="true" tabindex="-1"></a>    <span class="cf">for</span> status <span class="kw">in</span> (SolverStatus.ZEITLIMIT, SolverStatus.UNZULAESSIG,</span>
-<span id="cb216-282"><a href="#cb216-282" aria-hidden="true" tabindex="-1"></a>                   SolverStatus.UNBESCHRAENKT, SolverStatus.FEHLERHAFT,</span>
-<span id="cb216-283"><a href="#cb216-283" aria-hidden="true" tabindex="-1"></a>                   SolverStatus.UNBEKANNT):</span>
-<span id="cb216-284"><a href="#cb216-284" aria-hidden="true" tabindex="-1"></a>        <span class="cf">assert</span> <span class="kw">not</span> status.brauchbar, <span class="ss">f&quot;</span><span class="sc">{</span>status<span class="sc">.</span>value<span class="sc">}</span><span class="ss"> darf nicht brauchbar sein&quot;</span></span>
-<span id="cb216-285"><a href="#cb216-285" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb216-286"><a href="#cb216-286" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb216-287"><a href="#cb216-287" aria-hidden="true" tabindex="-1"></a><span class="kw">def</span> test_ressourcenreihenfolge_haengt_nicht_an_der_eingabe():</span>
-<span id="cb216-288"><a href="#cb216-288" aria-hidden="true" tabindex="-1"></a>    <span class="co">&quot;&quot;&quot;Zwei Mappings mit gleichem Inhalt, andere Einfuegereihenfolge.</span></span>
-<span id="cb216-289"><a href="#cb216-289" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb216-290"><a href="#cb216-290" aria-hidden="true" tabindex="-1"></a><span class="co">    Die Verbrauchsmatrix muss zeilenweise identisch sein. Ohne diese</span></span>
-<span id="cb216-291"><a href="#cb216-291" aria-hidden="true" tabindex="-1"></a><span class="co">    Zusicherung passt die Matrix irgendwann nicht mehr zum</span></span>
-<span id="cb216-292"><a href="#cb216-292" aria-hidden="true" tabindex="-1"></a><span class="co">    Kapazitaetsvektor - die Vertauschungsfalle aus Kapitel Finanzdaten,</span></span>
-<span id="cb216-293"><a href="#cb216-293" aria-hidden="true" tabindex="-1"></a><span class="co">    nur eine Ebene tiefer.</span></span>
-<span id="cb216-294"><a href="#cb216-294" aria-hidden="true" tabindex="-1"></a><span class="co">    &quot;&quot;&quot;</span></span>
-<span id="cb216-295"><a href="#cb216-295" aria-hidden="true" tabindex="-1"></a>    produkte <span class="op">=</span> schreinerei().produkte</span>
-<span id="cb216-296"><a href="#cb216-296" aria-hidden="true" tabindex="-1"></a>    vorwaerts <span class="op">=</span> Produktionsproblem(</span>
-<span id="cb216-297"><a href="#cb216-297" aria-hidden="true" tabindex="-1"></a>        produkte<span class="op">=</span>produkte,</span>
-<span id="cb216-298"><a href="#cb216-298" aria-hidden="true" tabindex="-1"></a>        kapazitaeten<span class="op">=</span>{<span class="st">&quot;Montagestunden&quot;</span>: <span class="fl">150.0</span>, <span class="st">&quot;Plattenmaterial&quot;</span>: <span class="fl">240.0</span>})</span>
-<span id="cb216-299"><a href="#cb216-299" aria-hidden="true" tabindex="-1"></a>    rueckwaerts <span class="op">=</span> Produktionsproblem(</span>
-<span id="cb216-300"><a href="#cb216-300" aria-hidden="true" tabindex="-1"></a>        produkte<span class="op">=</span>produkte,</span>
-<span id="cb216-301"><a href="#cb216-301" aria-hidden="true" tabindex="-1"></a>        kapazitaeten<span class="op">=</span>{<span class="st">&quot;Plattenmaterial&quot;</span>: <span class="fl">240.0</span>, <span class="st">&quot;Montagestunden&quot;</span>: <span class="fl">150.0</span>})</span>
-<span id="cb216-302"><a href="#cb216-302" aria-hidden="true" tabindex="-1"></a>    <span class="cf">assert</span> vorwaerts.ressourcen <span class="op">==</span> rueckwaerts.ressourcen</span>
-<span id="cb216-303"><a href="#cb216-303" aria-hidden="true" tabindex="-1"></a>    <span class="cf">assert</span> (vorwaerts.verbrauchsmatrix() <span class="op">==</span> rueckwaerts.verbrauchsmatrix()).<span class="bu">all</span>()</span>
-<span id="cb216-304"><a href="#cb216-304" aria-hidden="true" tabindex="-1"></a>    <span class="cf">assert</span> (vorwaerts.kapazitaetsvektor() <span class="op">==</span> rueckwaerts.kapazitaetsvektor()).<span class="bu">all</span>()</span>
-<span id="cb216-305"><a href="#cb216-305" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb216-306"><a href="#cb216-306" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb216-307"><a href="#cb216-307" aria-hidden="true" tabindex="-1"></a><span class="cf">if</span> <span class="va">__name__</span> <span class="op">==</span> <span class="st">&quot;__main__&quot;</span>:</span>
-<span id="cb216-308"><a href="#cb216-308" aria-hidden="true" tabindex="-1"></a>    <span class="im">import</span> sys</span>
-<span id="cb216-309"><a href="#cb216-309" aria-hidden="true" tabindex="-1"></a>    sys.exit(pytest.main([<span class="va">__file__</span>, <span class="st">&quot;-v&quot;</span>, <span class="st">&quot;--tb=short&quot;</span>, <span class="st">&quot;-p&quot;</span>, <span class="st">&quot;no:cacheprovider&quot;</span>]))</span></code></pre></div>
+<div class="sourceCode" id="cb220"><pre class="sourceCode python"><code class="sourceCode python"><span id="cb220-1"><a href="#cb220-1" aria-hidden="true" tabindex="-1"></a><span class="co">#!/usr/bin/env python3</span></span>
+<span id="cb220-2"><a href="#cb220-2" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb220-3"><a href="#cb220-3" aria-hidden="true" tabindex="-1"></a><span class="co"># test_or_kern.py</span></span>
+<span id="cb220-4"><a href="#cb220-4" aria-hidden="true" tabindex="-1"></a><span class="co">&quot;&quot;&quot;</span></span>
+<span id="cb220-5"><a href="#cb220-5" aria-hidden="true" tabindex="-1"></a><span class="co">Kapitel Testen: Eine Testsuite fuer ein Optimierungsmodell.</span></span>
+<span id="cb220-6"><a href="#cb220-6" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb220-7"><a href="#cb220-7" aria-hidden="true" tabindex="-1"></a><span class="co">Das Grundproblem beim Testen von Optimierungsmodellen: Man kennt die richtige</span></span>
+<span id="cb220-8"><a href="#cb220-8" aria-hidden="true" tabindex="-1"></a><span class="co">Antwort nicht. Bei einer Funktion `steuer(brutto)` schreibt man den erwarteten</span></span>
+<span id="cb220-9"><a href="#cb220-9" aria-hidden="true" tabindex="-1"></a><span class="co">Wert hin. Bei &quot;der beste Produktionsplan fuer 400 Auftraege&quot; gibt es niemanden,</span></span>
+<span id="cb220-10"><a href="#cb220-10" aria-hidden="true" tabindex="-1"></a><span class="co">der ihn unabhaengig ausrechnen koennte - sonst braeuchte man den Solver nicht.</span></span>
+<span id="cb220-11"><a href="#cb220-11" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb220-12"><a href="#cb220-12" aria-hidden="true" tabindex="-1"></a><span class="co">Deshalb testet man nicht den WERT, sondern vier andere Dinge:</span></span>
+<span id="cb220-13"><a href="#cb220-13" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb220-14"><a href="#cb220-14" aria-hidden="true" tabindex="-1"></a><span class="co">  1. EIGENSCHAFTEN  Die Loesung haelt jede Nebenbedingung ein, und der</span></span>
+<span id="cb220-15"><a href="#cb220-15" aria-hidden="true" tabindex="-1"></a><span class="co">                    ausgewiesene Zielwert passt zu den Mengen.</span></span>
+<span id="cb220-16"><a href="#cb220-16" aria-hidden="true" tabindex="-1"></a><span class="co">  2. INVARIANTEN    Was das Ergebnis NICHT aendern darf: die Reihenfolge der</span></span>
+<span id="cb220-17"><a href="#cb220-17" aria-hidden="true" tabindex="-1"></a><span class="co">                    Produkte, die Waehrungseinheit, ein zusaetzliches Produkt</span></span>
+<span id="cb220-18"><a href="#cb220-18" aria-hidden="true" tabindex="-1"></a><span class="co">                    mit Deckungsbeitrag 0.</span></span>
+<span id="cb220-19"><a href="#cb220-19" aria-hidden="true" tabindex="-1"></a><span class="co">  3. REGRESSION     Eine kleine Instanz mit von Hand nachgerechnetem Optimum.</span></span>
+<span id="cb220-20"><a href="#cb220-20" aria-hidden="true" tabindex="-1"></a><span class="co">  4. FEHLERFAELLE   Unsinnige Eingaben werden abgewiesen, unloesbare Modelle</span></span>
+<span id="cb220-21"><a href="#cb220-21" aria-hidden="true" tabindex="-1"></a><span class="co">                    als unloesbar erkannt - und die Abnahmepruefung schlaegt</span></span>
+<span id="cb220-22"><a href="#cb220-22" aria-hidden="true" tabindex="-1"></a><span class="co">                    tatsaechlich an, wenn man ihr eine kaputte Loesung gibt.</span></span>
+<span id="cb220-23"><a href="#cb220-23" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb220-24"><a href="#cb220-24" aria-hidden="true" tabindex="-1"></a><span class="co">Der vierte Punkt ist der wichtigste und wird am haeufigsten vergessen: Eine</span></span>
+<span id="cb220-25"><a href="#cb220-25" aria-hidden="true" tabindex="-1"></a><span class="co">Pruefung, die noch nie etwas gefunden hat, ist keine Pruefung, sondern eine</span></span>
+<span id="cb220-26"><a href="#cb220-26" aria-hidden="true" tabindex="-1"></a><span class="co">Vermutung. Die Tests unten fuettern `pruefe_loesung()` deshalb absichtlich mit</span></span>
+<span id="cb220-27"><a href="#cb220-27" aria-hidden="true" tabindex="-1"></a><span class="co">falschen Loesungen und verlangen, dass sie anschlaegt.</span></span>
+<span id="cb220-28"><a href="#cb220-28" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb220-29"><a href="#cb220-29" aria-hidden="true" tabindex="-1"></a><span class="co">Aufruf:</span></span>
+<span id="cb220-30"><a href="#cb220-30" aria-hidden="true" tabindex="-1"></a><span class="co">    pytest test_or_kern.py -v</span></span>
+<span id="cb220-31"><a href="#cb220-31" aria-hidden="true" tabindex="-1"></a><span class="co">    python3 test_or_kern.py          # ruft pytest selbst auf</span></span>
+<span id="cb220-32"><a href="#cb220-32" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb220-33"><a href="#cb220-33" aria-hidden="true" tabindex="-1"></a><span class="co">Benoetigt: pytest, numpy, pydantic, ortools, scipy (ueber or_kern)</span></span>
+<span id="cb220-34"><a href="#cb220-34" aria-hidden="true" tabindex="-1"></a><span class="co">&quot;&quot;&quot;</span></span>
+<span id="cb220-35"><a href="#cb220-35" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb220-36"><a href="#cb220-36" aria-hidden="true" tabindex="-1"></a><span class="im">from</span> __future__ <span class="im">import</span> annotations</span>
+<span id="cb220-37"><a href="#cb220-37" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb220-38"><a href="#cb220-38" aria-hidden="true" tabindex="-1"></a><span class="im">import</span> pytest</span>
+<span id="cb220-39"><a href="#cb220-39" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb220-40"><a href="#cb220-40" aria-hidden="true" tabindex="-1"></a><span class="im">from</span> or_kern <span class="im">import</span> (Loesung, Produkt, Produktionsproblem, SolverStatus,</span>
+<span id="cb220-41"><a href="#cb220-41" aria-hidden="true" tabindex="-1"></a>                     loese_mit_glop, loese_mit_scipy, pruefe_loesung,</span>
+<span id="cb220-42"><a href="#cb220-42" aria-hidden="true" tabindex="-1"></a>                     status_von_scipy)</span>
+<span id="cb220-43"><a href="#cb220-43" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb220-44"><a href="#cb220-44" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb220-45"><a href="#cb220-45" aria-hidden="true" tabindex="-1"></a><span class="co"># --- Die Instanz, gegen die getestet wird ----------------------------------</span></span>
+<span id="cb220-46"><a href="#cb220-46" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb220-47"><a href="#cb220-47" aria-hidden="true" tabindex="-1"></a><span class="kw">def</span> schreinerei() <span class="op">-&gt;</span> Produktionsproblem:</span>
+<span id="cb220-48"><a href="#cb220-48" aria-hidden="true" tabindex="-1"></a>    <span class="co">&quot;&quot;&quot;Der Fall aus Kapitel Einfuehrung - klein genug fuer die Handrechnung.</span></span>
+<span id="cb220-49"><a href="#cb220-49" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb220-50"><a href="#cb220-50" aria-hidden="true" tabindex="-1"></a><span class="co">    Optimum: 30 Tische, 60 Stuehle, Deckungsbeitrag 10.800 EUR.</span></span>
+<span id="cb220-51"><a href="#cb220-51" aria-hidden="true" tabindex="-1"></a><span class="co">    Beide Ressourcen sind voll ausgelastet (3*30 + 1*60 = 150,</span></span>
+<span id="cb220-52"><a href="#cb220-52" aria-hidden="true" tabindex="-1"></a><span class="co">    6*30 + 1*60 = 240).</span></span>
+<span id="cb220-53"><a href="#cb220-53" aria-hidden="true" tabindex="-1"></a><span class="co">    &quot;&quot;&quot;</span></span>
+<span id="cb220-54"><a href="#cb220-54" aria-hidden="true" tabindex="-1"></a>    <span class="cf">return</span> Produktionsproblem(</span>
+<span id="cb220-55"><a href="#cb220-55" aria-hidden="true" tabindex="-1"></a>        produkte<span class="op">=</span>[</span>
+<span id="cb220-56"><a href="#cb220-56" aria-hidden="true" tabindex="-1"></a>            Produkt(name<span class="op">=</span><span class="st">&quot;Tisch&quot;</span>, deckungsbeitrag<span class="op">=</span><span class="fl">240.0</span>,</span>
+<span id="cb220-57"><a href="#cb220-57" aria-hidden="true" tabindex="-1"></a>                    verbrauch<span class="op">=</span>{<span class="st">&quot;Montagestunden&quot;</span>: <span class="fl">3.0</span>, <span class="st">&quot;Plattenmaterial&quot;</span>: <span class="fl">6.0</span>}),</span>
+<span id="cb220-58"><a href="#cb220-58" aria-hidden="true" tabindex="-1"></a>            Produkt(name<span class="op">=</span><span class="st">&quot;Stuhl&quot;</span>, deckungsbeitrag<span class="op">=</span><span class="fl">60.0</span>,</span>
+<span id="cb220-59"><a href="#cb220-59" aria-hidden="true" tabindex="-1"></a>                    verbrauch<span class="op">=</span>{<span class="st">&quot;Montagestunden&quot;</span>: <span class="fl">1.0</span>, <span class="st">&quot;Plattenmaterial&quot;</span>: <span class="fl">1.0</span>}),</span>
+<span id="cb220-60"><a href="#cb220-60" aria-hidden="true" tabindex="-1"></a>        ],</span>
+<span id="cb220-61"><a href="#cb220-61" aria-hidden="true" tabindex="-1"></a>        kapazitaeten<span class="op">=</span>{<span class="st">&quot;Montagestunden&quot;</span>: <span class="fl">150.0</span>, <span class="st">&quot;Plattenmaterial&quot;</span>: <span class="fl">240.0</span>},</span>
+<span id="cb220-62"><a href="#cb220-62" aria-hidden="true" tabindex="-1"></a>    )</span>
+<span id="cb220-63"><a href="#cb220-63" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb220-64"><a href="#cb220-64" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb220-65"><a href="#cb220-65" aria-hidden="true" tabindex="-1"></a><span class="co"># Beide Modellbauer durchlaufen JEDEN Test. Ein Test, der nur mit einem Solver</span></span>
+<span id="cb220-66"><a href="#cb220-66" aria-hidden="true" tabindex="-1"></a><span class="co"># laeuft, prueft die Bibliothek mit - nicht das Modell.</span></span>
+<span id="cb220-67"><a href="#cb220-67" aria-hidden="true" tabindex="-1"></a>MODELLBAUER <span class="op">=</span> [loese_mit_glop, loese_mit_scipy]</span>
+<span id="cb220-68"><a href="#cb220-68" aria-hidden="true" tabindex="-1"></a>NAMEN <span class="op">=</span> [<span class="st">&quot;glop&quot;</span>, <span class="st">&quot;scipy&quot;</span>]</span>
+<span id="cb220-69"><a href="#cb220-69" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb220-70"><a href="#cb220-70" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb220-71"><a href="#cb220-71" aria-hidden="true" tabindex="-1"></a><span class="at">@pytest.fixture</span>(params<span class="op">=</span>MODELLBAUER, ids<span class="op">=</span>NAMEN)</span>
+<span id="cb220-72"><a href="#cb220-72" aria-hidden="true" tabindex="-1"></a><span class="kw">def</span> bauer(request):</span>
+<span id="cb220-73"><a href="#cb220-73" aria-hidden="true" tabindex="-1"></a>    <span class="cf">return</span> request.param</span>
+<span id="cb220-74"><a href="#cb220-74" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb220-75"><a href="#cb220-75" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb220-76"><a href="#cb220-76" aria-hidden="true" tabindex="-1"></a><span class="co"># --- 1. Eigenschaften ------------------------------------------------------</span></span>
+<span id="cb220-77"><a href="#cb220-77" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb220-78"><a href="#cb220-78" aria-hidden="true" tabindex="-1"></a><span class="kw">def</span> test_loesung_haelt_alle_nebenbedingungen_ein(bauer):</span>
+<span id="cb220-79"><a href="#cb220-79" aria-hidden="true" tabindex="-1"></a>    <span class="co">&quot;&quot;&quot;Die Abnahmepruefung darf nichts zu beanstanden haben.&quot;&quot;&quot;</span></span>
+<span id="cb220-80"><a href="#cb220-80" aria-hidden="true" tabindex="-1"></a>    problem <span class="op">=</span> schreinerei()</span>
+<span id="cb220-81"><a href="#cb220-81" aria-hidden="true" tabindex="-1"></a>    loesung <span class="op">=</span> bauer(problem)</span>
+<span id="cb220-82"><a href="#cb220-82" aria-hidden="true" tabindex="-1"></a>    <span class="cf">assert</span> loesung.status <span class="kw">is</span> SolverStatus.OPTIMAL</span>
+<span id="cb220-83"><a href="#cb220-83" aria-hidden="true" tabindex="-1"></a>    <span class="cf">assert</span> pruefe_loesung(problem, loesung) <span class="op">==</span> []</span>
+<span id="cb220-84"><a href="#cb220-84" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb220-85"><a href="#cb220-85" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb220-86"><a href="#cb220-86" aria-hidden="true" tabindex="-1"></a><span class="kw">def</span> test_zielwert_passt_zu_den_mengen(bauer):</span>
+<span id="cb220-87"><a href="#cb220-87" aria-hidden="true" tabindex="-1"></a>    <span class="co">&quot;&quot;&quot;Der ausgewiesene Zielwert wird unabhaengig nachgerechnet.</span></span>
+<span id="cb220-88"><a href="#cb220-88" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb220-89"><a href="#cb220-89" aria-hidden="true" tabindex="-1"></a><span class="co">    Klingt trivial, ist es nicht: Wer die Zielfunktion im Modell anders</span></span>
+<span id="cb220-90"><a href="#cb220-90" aria-hidden="true" tabindex="-1"></a><span class="co">    zusammensetzt als im Bericht (etwa Gebuehren einmal abgezogen, einmal</span></span>
+<span id="cb220-91"><a href="#cb220-91" aria-hidden="true" tabindex="-1"></a><span class="co">    nicht), merkt es sonst nie.</span></span>
+<span id="cb220-92"><a href="#cb220-92" aria-hidden="true" tabindex="-1"></a><span class="co">    &quot;&quot;&quot;</span></span>
+<span id="cb220-93"><a href="#cb220-93" aria-hidden="true" tabindex="-1"></a>    problem <span class="op">=</span> schreinerei()</span>
+<span id="cb220-94"><a href="#cb220-94" aria-hidden="true" tabindex="-1"></a>    loesung <span class="op">=</span> bauer(problem)</span>
+<span id="cb220-95"><a href="#cb220-95" aria-hidden="true" tabindex="-1"></a>    nachgerechnet <span class="op">=</span> <span class="bu">sum</span>(p.deckungsbeitrag <span class="op">*</span> loesung.werte[p.name]</span>
+<span id="cb220-96"><a href="#cb220-96" aria-hidden="true" tabindex="-1"></a>                        <span class="cf">for</span> p <span class="kw">in</span> problem.produkte)</span>
+<span id="cb220-97"><a href="#cb220-97" aria-hidden="true" tabindex="-1"></a>    <span class="cf">assert</span> loesung.zielwert <span class="op">==</span> pytest.approx(nachgerechnet, <span class="bu">abs</span><span class="op">=</span><span class="fl">1e-6</span>)</span>
+<span id="cb220-98"><a href="#cb220-98" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb220-99"><a href="#cb220-99" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb220-100"><a href="#cb220-100" aria-hidden="true" tabindex="-1"></a><span class="kw">def</span> test_beide_solver_liefern_dasselbe():</span>
+<span id="cb220-101"><a href="#cb220-101" aria-hidden="true" tabindex="-1"></a>    <span class="co">&quot;&quot;&quot;Der Kern der Architektur aus Kapitel Praxisfallen, als Test.&quot;&quot;&quot;</span></span>
+<span id="cb220-102"><a href="#cb220-102" aria-hidden="true" tabindex="-1"></a>    problem <span class="op">=</span> schreinerei()</span>
+<span id="cb220-103"><a href="#cb220-103" aria-hidden="true" tabindex="-1"></a>    glop, scipy_ <span class="op">=</span> loese_mit_glop(problem), loese_mit_scipy(problem)</span>
+<span id="cb220-104"><a href="#cb220-104" aria-hidden="true" tabindex="-1"></a>    <span class="cf">assert</span> glop.zielwert <span class="op">==</span> pytest.approx(scipy_.zielwert, <span class="bu">abs</span><span class="op">=</span><span class="fl">1e-6</span>)</span>
+<span id="cb220-105"><a href="#cb220-105" aria-hidden="true" tabindex="-1"></a>    <span class="cf">for</span> ressource <span class="kw">in</span> problem.ressourcen:</span>
+<span id="cb220-106"><a href="#cb220-106" aria-hidden="true" tabindex="-1"></a>        <span class="cf">assert</span> glop.schattenpreise[ressource] <span class="op">==</span> pytest.approx(</span>
+<span id="cb220-107"><a href="#cb220-107" aria-hidden="true" tabindex="-1"></a>            scipy_.schattenpreise[ressource], <span class="bu">abs</span><span class="op">=</span><span class="fl">1e-6</span>)</span>
+<span id="cb220-108"><a href="#cb220-108" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb220-109"><a href="#cb220-109" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb220-110"><a href="#cb220-110" aria-hidden="true" tabindex="-1"></a><span class="co"># --- 2. Invarianten --------------------------------------------------------</span></span>
+<span id="cb220-111"><a href="#cb220-111" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb220-112"><a href="#cb220-112" aria-hidden="true" tabindex="-1"></a><span class="kw">def</span> test_produktreihenfolge_aendert_nichts(bauer):</span>
+<span id="cb220-113"><a href="#cb220-113" aria-hidden="true" tabindex="-1"></a>    <span class="co">&quot;&quot;&quot;Dieselben Daten in anderer Zeilenreihenfolge - gleiches Ergebnis.</span></span>
+<span id="cb220-114"><a href="#cb220-114" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb220-115"><a href="#cb220-115" aria-hidden="true" tabindex="-1"></a><span class="co">    Das faengt die Spaltenvertauschungsfalle aus Kapitel Finanzdaten ab: ein</span></span>
+<span id="cb220-116"><a href="#cb220-116" aria-hidden="true" tabindex="-1"></a><span class="co">    Modell, das Positionen statt Namen benutzt, faellt hier durch.</span></span>
+<span id="cb220-117"><a href="#cb220-117" aria-hidden="true" tabindex="-1"></a><span class="co">    &quot;&quot;&quot;</span></span>
+<span id="cb220-118"><a href="#cb220-118" aria-hidden="true" tabindex="-1"></a>    problem <span class="op">=</span> schreinerei()</span>
+<span id="cb220-119"><a href="#cb220-119" aria-hidden="true" tabindex="-1"></a>    gedreht <span class="op">=</span> Produktionsproblem(produkte<span class="op">=</span><span class="bu">list</span>(<span class="bu">reversed</span>(problem.produkte)),</span>
+<span id="cb220-120"><a href="#cb220-120" aria-hidden="true" tabindex="-1"></a>                                 kapazitaeten<span class="op">=</span>problem.kapazitaeten)</span>
+<span id="cb220-121"><a href="#cb220-121" aria-hidden="true" tabindex="-1"></a>    <span class="cf">assert</span> bauer(problem).zielwert <span class="op">==</span> pytest.approx(bauer(gedreht).zielwert)</span>
+<span id="cb220-122"><a href="#cb220-122" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb220-123"><a href="#cb220-123" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb220-124"><a href="#cb220-124" aria-hidden="true" tabindex="-1"></a><span class="kw">def</span> test_waehrungseinheit_skaliert_linear(bauer):</span>
+<span id="cb220-125"><a href="#cb220-125" aria-hidden="true" tabindex="-1"></a>    <span class="co">&quot;&quot;&quot;Deckungsbeitraege in Cent statt Euro: Zielwert mal 100, Mengen gleich.</span></span>
+<span id="cb220-126"><a href="#cb220-126" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb220-127"><a href="#cb220-127" aria-hidden="true" tabindex="-1"></a><span class="co">    Der Test prueft nicht die Mathematik - die ist offensichtlich -, sondern</span></span>
+<span id="cb220-128"><a href="#cb220-128" aria-hidden="true" tabindex="-1"></a><span class="co">    die NUMERIK. Wer schlecht skalierte Modelle baut (Kapitel Fundament),</span></span>
+<span id="cb220-129"><a href="#cb220-129" aria-hidden="true" tabindex="-1"></a><span class="co">    bekommt hier Abweichungen weit ueber der Toleranz.</span></span>
+<span id="cb220-130"><a href="#cb220-130" aria-hidden="true" tabindex="-1"></a><span class="co">    &quot;&quot;&quot;</span></span>
+<span id="cb220-131"><a href="#cb220-131" aria-hidden="true" tabindex="-1"></a>    problem <span class="op">=</span> schreinerei()</span>
+<span id="cb220-132"><a href="#cb220-132" aria-hidden="true" tabindex="-1"></a>    in_cent <span class="op">=</span> Produktionsproblem(</span>
+<span id="cb220-133"><a href="#cb220-133" aria-hidden="true" tabindex="-1"></a>        produkte<span class="op">=</span>[Produkt(name<span class="op">=</span>p.name, deckungsbeitrag<span class="op">=</span>p.deckungsbeitrag <span class="op">*</span> <span class="dv">100</span>,</span>
+<span id="cb220-134"><a href="#cb220-134" aria-hidden="true" tabindex="-1"></a>                          verbrauch<span class="op">=</span>p.verbrauch) <span class="cf">for</span> p <span class="kw">in</span> problem.produkte],</span>
+<span id="cb220-135"><a href="#cb220-135" aria-hidden="true" tabindex="-1"></a>        kapazitaeten<span class="op">=</span>problem.kapazitaeten)</span>
+<span id="cb220-136"><a href="#cb220-136" aria-hidden="true" tabindex="-1"></a>    basis, skaliert <span class="op">=</span> bauer(problem), bauer(in_cent)</span>
+<span id="cb220-137"><a href="#cb220-137" aria-hidden="true" tabindex="-1"></a>    <span class="cf">assert</span> skaliert.zielwert <span class="op">==</span> pytest.approx(basis.zielwert <span class="op">*</span> <span class="dv">100</span>, rel<span class="op">=</span><span class="fl">1e-9</span>)</span>
+<span id="cb220-138"><a href="#cb220-138" aria-hidden="true" tabindex="-1"></a>    <span class="cf">for</span> p <span class="kw">in</span> problem.produkte:</span>
+<span id="cb220-139"><a href="#cb220-139" aria-hidden="true" tabindex="-1"></a>        <span class="cf">assert</span> skaliert.werte[p.name] <span class="op">==</span> pytest.approx(basis.werte[p.name],</span>
+<span id="cb220-140"><a href="#cb220-140" aria-hidden="true" tabindex="-1"></a>                                                       <span class="bu">abs</span><span class="op">=</span><span class="fl">1e-6</span>)</span>
+<span id="cb220-141"><a href="#cb220-141" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb220-142"><a href="#cb220-142" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb220-143"><a href="#cb220-143" aria-hidden="true" tabindex="-1"></a><span class="kw">def</span> test_produkt_ohne_deckungsbeitrag_aendert_das_optimum_nicht(bauer):</span>
+<span id="cb220-144"><a href="#cb220-144" aria-hidden="true" tabindex="-1"></a>    <span class="co">&quot;&quot;&quot;Ein Produkt, das nichts einbringt, darf den Zielwert nicht heben.&quot;&quot;&quot;</span></span>
+<span id="cb220-145"><a href="#cb220-145" aria-hidden="true" tabindex="-1"></a>    problem <span class="op">=</span> schreinerei()</span>
+<span id="cb220-146"><a href="#cb220-146" aria-hidden="true" tabindex="-1"></a>    mit_nullprodukt <span class="op">=</span> Produktionsproblem(</span>
+<span id="cb220-147"><a href="#cb220-147" aria-hidden="true" tabindex="-1"></a>        produkte<span class="op">=</span>problem.produkte <span class="op">+</span> [</span>
+<span id="cb220-148"><a href="#cb220-148" aria-hidden="true" tabindex="-1"></a>            Produkt(name<span class="op">=</span><span class="st">&quot;Muster&quot;</span>, deckungsbeitrag<span class="op">=</span><span class="fl">0.0</span>,</span>
+<span id="cb220-149"><a href="#cb220-149" aria-hidden="true" tabindex="-1"></a>                    verbrauch<span class="op">=</span>{<span class="st">&quot;Montagestunden&quot;</span>: <span class="fl">1.0</span>, <span class="st">&quot;Plattenmaterial&quot;</span>: <span class="fl">1.0</span>})],</span>
+<span id="cb220-150"><a href="#cb220-150" aria-hidden="true" tabindex="-1"></a>        kapazitaeten<span class="op">=</span>problem.kapazitaeten)</span>
+<span id="cb220-151"><a href="#cb220-151" aria-hidden="true" tabindex="-1"></a>    <span class="cf">assert</span> bauer(mit_nullprodukt).zielwert <span class="op">&lt;=</span> bauer(problem).zielwert <span class="op">+</span> <span class="fl">1e-6</span></span>
+<span id="cb220-152"><a href="#cb220-152" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb220-153"><a href="#cb220-153" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb220-154"><a href="#cb220-154" aria-hidden="true" tabindex="-1"></a><span class="co"># --- 3. Regression ---------------------------------------------------------</span></span>
+<span id="cb220-155"><a href="#cb220-155" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb220-156"><a href="#cb220-156" aria-hidden="true" tabindex="-1"></a><span class="kw">def</span> test_bekanntes_optimum(bauer):</span>
+<span id="cb220-157"><a href="#cb220-157" aria-hidden="true" tabindex="-1"></a>    <span class="co">&quot;&quot;&quot;Von Hand nachgerechnet (Kapitel Einfuehrung, Handrechnung).</span></span>
+<span id="cb220-158"><a href="#cb220-158" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb220-159"><a href="#cb220-159" aria-hidden="true" tabindex="-1"></a><span class="co">    Das ist der einzige Test, der einen ZAHLENWERT festschreibt - und er darf</span></span>
+<span id="cb220-160"><a href="#cb220-160" aria-hidden="true" tabindex="-1"></a><span class="co">    es, weil dieser Wert von Hand belegt ist. Fuer grosse Instanzen gibt es</span></span>
+<span id="cb220-161"><a href="#cb220-161" aria-hidden="true" tabindex="-1"></a><span class="co">    diesen Test nicht; dort tragen die Eigenschaften und Invarianten.</span></span>
+<span id="cb220-162"><a href="#cb220-162" aria-hidden="true" tabindex="-1"></a><span class="co">    &quot;&quot;&quot;</span></span>
+<span id="cb220-163"><a href="#cb220-163" aria-hidden="true" tabindex="-1"></a>    loesung <span class="op">=</span> bauer(schreinerei())</span>
+<span id="cb220-164"><a href="#cb220-164" aria-hidden="true" tabindex="-1"></a>    <span class="cf">assert</span> loesung.zielwert <span class="op">==</span> pytest.approx(<span class="fl">10_800.0</span>, <span class="bu">abs</span><span class="op">=</span><span class="fl">1e-6</span>)</span>
+<span id="cb220-165"><a href="#cb220-165" aria-hidden="true" tabindex="-1"></a>    <span class="cf">assert</span> loesung.werte[<span class="st">&quot;Tisch&quot;</span>] <span class="op">==</span> pytest.approx(<span class="fl">30.0</span>, <span class="bu">abs</span><span class="op">=</span><span class="fl">1e-6</span>)</span>
+<span id="cb220-166"><a href="#cb220-166" aria-hidden="true" tabindex="-1"></a>    <span class="cf">assert</span> loesung.werte[<span class="st">&quot;Stuhl&quot;</span>] <span class="op">==</span> pytest.approx(<span class="fl">60.0</span>, <span class="bu">abs</span><span class="op">=</span><span class="fl">1e-6</span>)</span>
+<span id="cb220-167"><a href="#cb220-167" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb220-168"><a href="#cb220-168" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb220-169"><a href="#cb220-169" aria-hidden="true" tabindex="-1"></a><span class="kw">def</span> test_schattenpreise_bekannt(bauer):</span>
+<span id="cb220-170"><a href="#cb220-170" aria-hidden="true" tabindex="-1"></a>    <span class="co">&quot;&quot;&quot;40 EUR je Montagestunde, 20 EUR je Einheit Plattenmaterial.&quot;&quot;&quot;</span></span>
+<span id="cb220-171"><a href="#cb220-171" aria-hidden="true" tabindex="-1"></a>    loesung <span class="op">=</span> bauer(schreinerei())</span>
+<span id="cb220-172"><a href="#cb220-172" aria-hidden="true" tabindex="-1"></a>    <span class="cf">assert</span> loesung.schattenpreise[<span class="st">&quot;Montagestunden&quot;</span>] <span class="op">==</span> pytest.approx(<span class="fl">40.0</span>, <span class="bu">abs</span><span class="op">=</span><span class="fl">1e-6</span>)</span>
+<span id="cb220-173"><a href="#cb220-173" aria-hidden="true" tabindex="-1"></a>    <span class="cf">assert</span> loesung.schattenpreise[<span class="st">&quot;Plattenmaterial&quot;</span>] <span class="op">==</span> pytest.approx(<span class="fl">20.0</span>, <span class="bu">abs</span><span class="op">=</span><span class="fl">1e-6</span>)</span>
+<span id="cb220-174"><a href="#cb220-174" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb220-175"><a href="#cb220-175" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb220-176"><a href="#cb220-176" aria-hidden="true" tabindex="-1"></a><span class="co"># --- 4. Fehlerfaelle: schlaegt die Pruefung ueberhaupt an? -----------------</span></span>
+<span id="cb220-177"><a href="#cb220-177" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb220-178"><a href="#cb220-178" aria-hidden="true" tabindex="-1"></a><span class="kw">def</span> test_pruefung_findet_kapazitaetsverletzung():</span>
+<span id="cb220-179"><a href="#cb220-179" aria-hidden="true" tabindex="-1"></a>    <span class="co">&quot;&quot;&quot;Eine Loesung, die zu viel verbraucht, MUSS beanstandet werden.&quot;&quot;&quot;</span></span>
+<span id="cb220-180"><a href="#cb220-180" aria-hidden="true" tabindex="-1"></a>    problem <span class="op">=</span> schreinerei()</span>
+<span id="cb220-181"><a href="#cb220-181" aria-hidden="true" tabindex="-1"></a>    kaputt <span class="op">=</span> Loesung(status<span class="op">=</span>SolverStatus.OPTIMAL,</span>
+<span id="cb220-182"><a href="#cb220-182" aria-hidden="true" tabindex="-1"></a>                     werte<span class="op">=</span>{<span class="st">&quot;Tisch&quot;</span>: <span class="fl">50.0</span>, <span class="st">&quot;Stuhl&quot;</span>: <span class="fl">60.0</span>},   <span class="co"># 3*50+60 = 210 &gt; 150</span></span>
+<span id="cb220-183"><a href="#cb220-183" aria-hidden="true" tabindex="-1"></a>                     zielwert<span class="op">=</span><span class="dv">50</span> <span class="op">*</span> <span class="fl">240.0</span> <span class="op">+</span> <span class="dv">60</span> <span class="op">*</span> <span class="fl">60.0</span>)</span>
+<span id="cb220-184"><a href="#cb220-184" aria-hidden="true" tabindex="-1"></a>    beanstandungen <span class="op">=</span> pruefe_loesung(problem, kaputt)</span>
+<span id="cb220-185"><a href="#cb220-185" aria-hidden="true" tabindex="-1"></a>    <span class="cf">assert</span> <span class="bu">any</span>(<span class="st">&quot;Montagestunden&quot;</span> <span class="kw">in</span> b <span class="cf">for</span> b <span class="kw">in</span> beanstandungen)</span>
+<span id="cb220-186"><a href="#cb220-186" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb220-187"><a href="#cb220-187" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb220-188"><a href="#cb220-188" aria-hidden="true" tabindex="-1"></a><span class="kw">def</span> test_pruefung_findet_falschen_zielwert():</span>
+<span id="cb220-189"><a href="#cb220-189" aria-hidden="true" tabindex="-1"></a>    <span class="co">&quot;&quot;&quot;Mengen und Zielwert passen nicht zusammen - der haeufigste stille Fehler.&quot;&quot;&quot;</span></span>
+<span id="cb220-190"><a href="#cb220-190" aria-hidden="true" tabindex="-1"></a>    problem <span class="op">=</span> schreinerei()</span>
+<span id="cb220-191"><a href="#cb220-191" aria-hidden="true" tabindex="-1"></a>    kaputt <span class="op">=</span> Loesung(status<span class="op">=</span>SolverStatus.OPTIMAL,</span>
+<span id="cb220-192"><a href="#cb220-192" aria-hidden="true" tabindex="-1"></a>                     werte<span class="op">=</span>{<span class="st">&quot;Tisch&quot;</span>: <span class="fl">30.0</span>, <span class="st">&quot;Stuhl&quot;</span>: <span class="fl">60.0</span>},</span>
+<span id="cb220-193"><a href="#cb220-193" aria-hidden="true" tabindex="-1"></a>                     zielwert<span class="op">=</span><span class="fl">99_999.0</span>)</span>
+<span id="cb220-194"><a href="#cb220-194" aria-hidden="true" tabindex="-1"></a>    <span class="cf">assert</span> <span class="bu">any</span>(<span class="st">&quot;Zielwert&quot;</span> <span class="kw">in</span> b <span class="cf">for</span> b <span class="kw">in</span> pruefe_loesung(problem, kaputt))</span>
+<span id="cb220-195"><a href="#cb220-195" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb220-196"><a href="#cb220-196" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb220-197"><a href="#cb220-197" aria-hidden="true" tabindex="-1"></a><span class="kw">def</span> test_pruefung_findet_negative_mengen():</span>
+<span id="cb220-198"><a href="#cb220-198" aria-hidden="true" tabindex="-1"></a>    problem <span class="op">=</span> schreinerei()</span>
+<span id="cb220-199"><a href="#cb220-199" aria-hidden="true" tabindex="-1"></a>    kaputt <span class="op">=</span> Loesung(status<span class="op">=</span>SolverStatus.OPTIMAL,</span>
+<span id="cb220-200"><a href="#cb220-200" aria-hidden="true" tabindex="-1"></a>                     werte<span class="op">=</span>{<span class="st">&quot;Tisch&quot;</span>: <span class="op">-</span><span class="fl">5.0</span>, <span class="st">&quot;Stuhl&quot;</span>: <span class="fl">60.0</span>},</span>
+<span id="cb220-201"><a href="#cb220-201" aria-hidden="true" tabindex="-1"></a>                     zielwert<span class="op">=-</span><span class="dv">5</span> <span class="op">*</span> <span class="fl">240.0</span> <span class="op">+</span> <span class="dv">60</span> <span class="op">*</span> <span class="fl">60.0</span>)</span>
+<span id="cb220-202"><a href="#cb220-202" aria-hidden="true" tabindex="-1"></a>    <span class="cf">assert</span> <span class="bu">any</span>(<span class="st">&quot;negativ&quot;</span> <span class="kw">in</span> b <span class="cf">for</span> b <span class="kw">in</span> pruefe_loesung(problem, kaputt))</span>
+<span id="cb220-203"><a href="#cb220-203" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb220-204"><a href="#cb220-204" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb220-205"><a href="#cb220-205" aria-hidden="true" tabindex="-1"></a><span class="kw">def</span> test_pruefung_findet_gebrochene_ganzzahligkeit():</span>
+<span id="cb220-206"><a href="#cb220-206" aria-hidden="true" tabindex="-1"></a>    <span class="co">&quot;&quot;&quot;Die Falle aus Kapitel MILP: 0,99999998 ist nicht 1.&quot;&quot;&quot;</span></span>
+<span id="cb220-207"><a href="#cb220-207" aria-hidden="true" tabindex="-1"></a>    problem <span class="op">=</span> schreinerei()</span>
+<span id="cb220-208"><a href="#cb220-208" aria-hidden="true" tabindex="-1"></a>    fast_ganz <span class="op">=</span> Loesung(status<span class="op">=</span>SolverStatus.OPTIMAL,</span>
+<span id="cb220-209"><a href="#cb220-209" aria-hidden="true" tabindex="-1"></a>                        werte<span class="op">=</span>{<span class="st">&quot;Tisch&quot;</span>: <span class="fl">29.4</span>, <span class="st">&quot;Stuhl&quot;</span>: <span class="fl">61.8</span>},</span>
+<span id="cb220-210"><a href="#cb220-210" aria-hidden="true" tabindex="-1"></a>                        zielwert<span class="op">=</span><span class="fl">29.4</span> <span class="op">*</span> <span class="fl">240.0</span> <span class="op">+</span> <span class="fl">61.8</span> <span class="op">*</span> <span class="fl">60.0</span>)</span>
+<span id="cb220-211"><a href="#cb220-211" aria-hidden="true" tabindex="-1"></a>    beanstandungen <span class="op">=</span> pruefe_loesung(problem, fast_ganz, ganzzahlig<span class="op">=</span>[<span class="st">&quot;Tisch&quot;</span>])</span>
+<span id="cb220-212"><a href="#cb220-212" aria-hidden="true" tabindex="-1"></a>    <span class="cf">assert</span> <span class="bu">any</span>(<span class="st">&quot;ganzzahlig&quot;</span> <span class="kw">in</span> b <span class="cf">for</span> b <span class="kw">in</span> beanstandungen)</span>
+<span id="cb220-213"><a href="#cb220-213" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb220-214"><a href="#cb220-214" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb220-215"><a href="#cb220-215" aria-hidden="true" tabindex="-1"></a><span class="kw">def</span> test_pruefung_verweigert_unbrauchbaren_status():</span>
+<span id="cb220-216"><a href="#cb220-216" aria-hidden="true" tabindex="-1"></a>    <span class="co">&quot;&quot;&quot;Ohne verwertbares Ergebnis wird gar nicht erst gerechnet.&quot;&quot;&quot;</span></span>
+<span id="cb220-217"><a href="#cb220-217" aria-hidden="true" tabindex="-1"></a>    problem <span class="op">=</span> schreinerei()</span>
+<span id="cb220-218"><a href="#cb220-218" aria-hidden="true" tabindex="-1"></a>    ohne <span class="op">=</span> Loesung(status<span class="op">=</span>SolverStatus.UNZULAESSIG)</span>
+<span id="cb220-219"><a href="#cb220-219" aria-hidden="true" tabindex="-1"></a>    beanstandungen <span class="op">=</span> pruefe_loesung(problem, ohne)</span>
+<span id="cb220-220"><a href="#cb220-220" aria-hidden="true" tabindex="-1"></a>    <span class="cf">assert</span> <span class="bu">len</span>(beanstandungen) <span class="op">==</span> <span class="dv">1</span> <span class="kw">and</span> <span class="st">&quot;unzulaessig&quot;</span> <span class="kw">in</span> beanstandungen[<span class="dv">0</span>]</span>
+<span id="cb220-221"><a href="#cb220-221" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb220-222"><a href="#cb220-222" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb220-223"><a href="#cb220-223" aria-hidden="true" tabindex="-1"></a><span class="at">@pytest.mark.parametrize</span>(<span class="st">&quot;daten, stichwort&quot;</span>, [</span>
+<span id="cb220-224"><a href="#cb220-224" aria-hidden="true" tabindex="-1"></a>    (<span class="bu">dict</span>(produkte<span class="op">=</span>[Produkt(name<span class="op">=</span><span class="st">&quot;Tisch&quot;</span>, deckungsbeitrag<span class="op">=</span><span class="fl">240.0</span>,</span>
+<span id="cb220-225"><a href="#cb220-225" aria-hidden="true" tabindex="-1"></a>                            verbrauch<span class="op">=</span>{<span class="st">&quot;Montagestunden&quot;</span>: <span class="fl">3.0</span>})],</span>
+<span id="cb220-226"><a href="#cb220-226" aria-hidden="true" tabindex="-1"></a>          kapazitaeten<span class="op">=</span>{<span class="st">&quot;Montagestunden&quot;</span>: <span class="fl">0.0</span>}), <span class="st">&quot;greater than&quot;</span>),</span>
+<span id="cb220-227"><a href="#cb220-227" aria-hidden="true" tabindex="-1"></a>    (<span class="bu">dict</span>(produkte<span class="op">=</span>[Produkt(name<span class="op">=</span><span class="st">&quot;Regal&quot;</span>, deckungsbeitrag<span class="op">=</span><span class="fl">130.0</span>,</span>
+<span id="cb220-228"><a href="#cb220-228" aria-hidden="true" tabindex="-1"></a>                            verbrauch<span class="op">=</span>{<span class="st">&quot;Lackieren&quot;</span>: <span class="fl">2.0</span>})],</span>
+<span id="cb220-229"><a href="#cb220-229" aria-hidden="true" tabindex="-1"></a>          kapazitaeten<span class="op">=</span>{<span class="st">&quot;Montagestunden&quot;</span>: <span class="fl">150.0</span>}), <span class="st">&quot;Kapazitaetsangabe&quot;</span>),</span>
+<span id="cb220-230"><a href="#cb220-230" aria-hidden="true" tabindex="-1"></a>    (<span class="bu">dict</span>(produkte<span class="op">=</span>[], kapazitaeten<span class="op">=</span>{<span class="st">&quot;Montagestunden&quot;</span>: <span class="fl">150.0</span>}), <span class="st">&quot;at least 1&quot;</span>),</span>
+<span id="cb220-231"><a href="#cb220-231" aria-hidden="true" tabindex="-1"></a>])</span>
+<span id="cb220-232"><a href="#cb220-232" aria-hidden="true" tabindex="-1"></a><span class="kw">def</span> test_unsinnige_eingaben_werden_beim_einlesen_abgewiesen(daten, stichwort):</span>
+<span id="cb220-233"><a href="#cb220-233" aria-hidden="true" tabindex="-1"></a>    <span class="co">&quot;&quot;&quot;Drei Fehler, die NICHT erst beim Loesen auffallen duerfen.&quot;&quot;&quot;</span></span>
+<span id="cb220-234"><a href="#cb220-234" aria-hidden="true" tabindex="-1"></a>    <span class="cf">with</span> pytest.raises(<span class="pp">Exception</span>) <span class="im">as</span> fehler:</span>
+<span id="cb220-235"><a href="#cb220-235" aria-hidden="true" tabindex="-1"></a>        Produktionsproblem(<span class="op">**</span>daten)</span>
+<span id="cb220-236"><a href="#cb220-236" aria-hidden="true" tabindex="-1"></a>    <span class="cf">assert</span> stichwort <span class="kw">in</span> <span class="bu">str</span>(fehler.value)</span>
+<span id="cb220-237"><a href="#cb220-237" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb220-238"><a href="#cb220-238" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb220-239"><a href="#cb220-239" aria-hidden="true" tabindex="-1"></a><span class="kw">def</span> test_doppelter_produktname_wird_abgewiesen():</span>
+<span id="cb220-240"><a href="#cb220-240" aria-hidden="true" tabindex="-1"></a>    produkt <span class="op">=</span> Produkt(name<span class="op">=</span><span class="st">&quot;Tisch&quot;</span>, deckungsbeitrag<span class="op">=</span><span class="fl">240.0</span>,</span>
+<span id="cb220-241"><a href="#cb220-241" aria-hidden="true" tabindex="-1"></a>                      verbrauch<span class="op">=</span>{<span class="st">&quot;Montagestunden&quot;</span>: <span class="fl">3.0</span>})</span>
+<span id="cb220-242"><a href="#cb220-242" aria-hidden="true" tabindex="-1"></a>    <span class="cf">with</span> pytest.raises(<span class="pp">Exception</span>) <span class="im">as</span> fehler:</span>
+<span id="cb220-243"><a href="#cb220-243" aria-hidden="true" tabindex="-1"></a>        Produktionsproblem(produkte<span class="op">=</span>[produkt, produkt],</span>
+<span id="cb220-244"><a href="#cb220-244" aria-hidden="true" tabindex="-1"></a>                           kapazitaeten<span class="op">=</span>{<span class="st">&quot;Montagestunden&quot;</span>: <span class="fl">150.0</span>})</span>
+<span id="cb220-245"><a href="#cb220-245" aria-hidden="true" tabindex="-1"></a>    <span class="cf">assert</span> <span class="st">&quot;mehrfach&quot;</span> <span class="kw">in</span> <span class="bu">str</span>(fehler.value)</span>
+<span id="cb220-246"><a href="#cb220-246" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb220-247"><a href="#cb220-247" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb220-248"><a href="#cb220-248" aria-hidden="true" tabindex="-1"></a><span class="at">@pytest.mark.parametrize</span>(<span class="st">&quot;rohstatus, erwartet&quot;</span>, [</span>
+<span id="cb220-249"><a href="#cb220-249" aria-hidden="true" tabindex="-1"></a>    (<span class="dv">0</span>, SolverStatus.OPTIMAL),</span>
+<span id="cb220-250"><a href="#cb220-250" aria-hidden="true" tabindex="-1"></a>    (<span class="dv">1</span>, SolverStatus.ZEITLIMIT),</span>
+<span id="cb220-251"><a href="#cb220-251" aria-hidden="true" tabindex="-1"></a>    (<span class="dv">2</span>, SolverStatus.UNZULAESSIG),</span>
+<span id="cb220-252"><a href="#cb220-252" aria-hidden="true" tabindex="-1"></a>    (<span class="dv">3</span>, SolverStatus.UNBESCHRAENKT),</span>
+<span id="cb220-253"><a href="#cb220-253" aria-hidden="true" tabindex="-1"></a>    (<span class="dv">4</span>, SolverStatus.FEHLERHAFT),</span>
+<span id="cb220-254"><a href="#cb220-254" aria-hidden="true" tabindex="-1"></a>    (<span class="dv">99</span>, SolverStatus.UNBEKANNT),</span>
+<span id="cb220-255"><a href="#cb220-255" aria-hidden="true" tabindex="-1"></a>])</span>
+<span id="cb220-256"><a href="#cb220-256" aria-hidden="true" tabindex="-1"></a><span class="kw">def</span> test_statusuebersetzung_scipy(rohstatus, erwartet):</span>
+<span id="cb220-257"><a href="#cb220-257" aria-hidden="true" tabindex="-1"></a>    <span class="co">&quot;&quot;&quot;Die Uebersetzertabelle selbst - inklusive des unbekannten Falls.&quot;&quot;&quot;</span></span>
+<span id="cb220-258"><a href="#cb220-258" aria-hidden="true" tabindex="-1"></a>    <span class="kw">class</span> Ergebnis:</span>
+<span id="cb220-259"><a href="#cb220-259" aria-hidden="true" tabindex="-1"></a>        status <span class="op">=</span> rohstatus</span>
+<span id="cb220-260"><a href="#cb220-260" aria-hidden="true" tabindex="-1"></a>    <span class="cf">assert</span> status_von_scipy(Ergebnis()) <span class="kw">is</span> erwartet</span>
+<span id="cb220-261"><a href="#cb220-261" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb220-262"><a href="#cb220-262" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb220-263"><a href="#cb220-263" aria-hidden="true" tabindex="-1"></a><span class="kw">def</span> test_status_eigenschaften_sind_konsistent():</span>
+<span id="cb220-264"><a href="#cb220-264" aria-hidden="true" tabindex="-1"></a>    <span class="co">&quot;&quot;&quot;brauchbar und modellfehler duerfen sich nie ueberschneiden.&quot;&quot;&quot;</span></span>
+<span id="cb220-265"><a href="#cb220-265" aria-hidden="true" tabindex="-1"></a>    <span class="cf">for</span> status <span class="kw">in</span> SolverStatus:</span>
+<span id="cb220-266"><a href="#cb220-266" aria-hidden="true" tabindex="-1"></a>        <span class="cf">assert</span> <span class="kw">not</span> (status.brauchbar <span class="kw">and</span> status.modellfehler)</span>
+<span id="cb220-267"><a href="#cb220-267" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb220-268"><a href="#cb220-268" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb220-269"><a href="#cb220-269" aria-hidden="true" tabindex="-1"></a><span class="co"># Die beiden folgenden Tests gab es zuerst nicht. Sie sind entstanden, weil</span></span>
+<span id="cb220-270"><a href="#cb220-270" aria-hidden="true" tabindex="-1"></a><span class="co"># Mutationstest.py zwei eingebaute Fehler UEBERLEBEN liess - siehe den</span></span>
+<span id="cb220-271"><a href="#cb220-271" aria-hidden="true" tabindex="-1"></a><span class="co"># Abschnitt &quot;Wer testet die Tests?&quot;.</span></span>
+<span id="cb220-272"><a href="#cb220-272" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb220-273"><a href="#cb220-273" aria-hidden="true" tabindex="-1"></a><span class="kw">def</span> test_nur_optimal_und_zulaessig_gelten_als_brauchbar():</span>
+<span id="cb220-274"><a href="#cb220-274" aria-hidden="true" tabindex="-1"></a>    <span class="co">&quot;&quot;&quot;ZEITLIMIT ist NICHT brauchbar - der Solver hat nichts gefunden.</span></span>
+<span id="cb220-275"><a href="#cb220-275" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb220-276"><a href="#cb220-276" aria-hidden="true" tabindex="-1"></a><span class="co">    Der Unterschied entscheidet, ob ein Nachtjob einen Plan ausliefert oder</span></span>
+<span id="cb220-277"><a href="#cb220-277" aria-hidden="true" tabindex="-1"></a><span class="co">    Alarm schlaegt. Ein aufgeweichtes &#39;brauchbar&#39; faellt sonst nirgends auf.</span></span>
+<span id="cb220-278"><a href="#cb220-278" aria-hidden="true" tabindex="-1"></a><span class="co">    &quot;&quot;&quot;</span></span>
+<span id="cb220-279"><a href="#cb220-279" aria-hidden="true" tabindex="-1"></a>    <span class="cf">assert</span> SolverStatus.OPTIMAL.brauchbar</span>
+<span id="cb220-280"><a href="#cb220-280" aria-hidden="true" tabindex="-1"></a>    <span class="cf">assert</span> SolverStatus.ZULAESSIG.brauchbar</span>
+<span id="cb220-281"><a href="#cb220-281" aria-hidden="true" tabindex="-1"></a>    <span class="cf">for</span> status <span class="kw">in</span> (SolverStatus.ZEITLIMIT, SolverStatus.UNZULAESSIG,</span>
+<span id="cb220-282"><a href="#cb220-282" aria-hidden="true" tabindex="-1"></a>                   SolverStatus.UNBESCHRAENKT, SolverStatus.FEHLERHAFT,</span>
+<span id="cb220-283"><a href="#cb220-283" aria-hidden="true" tabindex="-1"></a>                   SolverStatus.UNBEKANNT):</span>
+<span id="cb220-284"><a href="#cb220-284" aria-hidden="true" tabindex="-1"></a>        <span class="cf">assert</span> <span class="kw">not</span> status.brauchbar, <span class="ss">f&quot;</span><span class="sc">{</span>status<span class="sc">.</span>value<span class="sc">}</span><span class="ss"> darf nicht brauchbar sein&quot;</span></span>
+<span id="cb220-285"><a href="#cb220-285" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb220-286"><a href="#cb220-286" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb220-287"><a href="#cb220-287" aria-hidden="true" tabindex="-1"></a><span class="kw">def</span> test_ressourcenreihenfolge_haengt_nicht_an_der_eingabe():</span>
+<span id="cb220-288"><a href="#cb220-288" aria-hidden="true" tabindex="-1"></a>    <span class="co">&quot;&quot;&quot;Zwei Mappings mit gleichem Inhalt, andere Einfuegereihenfolge.</span></span>
+<span id="cb220-289"><a href="#cb220-289" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb220-290"><a href="#cb220-290" aria-hidden="true" tabindex="-1"></a><span class="co">    Die Verbrauchsmatrix muss zeilenweise identisch sein. Ohne diese</span></span>
+<span id="cb220-291"><a href="#cb220-291" aria-hidden="true" tabindex="-1"></a><span class="co">    Zusicherung passt die Matrix irgendwann nicht mehr zum</span></span>
+<span id="cb220-292"><a href="#cb220-292" aria-hidden="true" tabindex="-1"></a><span class="co">    Kapazitaetsvektor - die Vertauschungsfalle aus Kapitel Finanzdaten,</span></span>
+<span id="cb220-293"><a href="#cb220-293" aria-hidden="true" tabindex="-1"></a><span class="co">    nur eine Ebene tiefer.</span></span>
+<span id="cb220-294"><a href="#cb220-294" aria-hidden="true" tabindex="-1"></a><span class="co">    &quot;&quot;&quot;</span></span>
+<span id="cb220-295"><a href="#cb220-295" aria-hidden="true" tabindex="-1"></a>    produkte <span class="op">=</span> schreinerei().produkte</span>
+<span id="cb220-296"><a href="#cb220-296" aria-hidden="true" tabindex="-1"></a>    vorwaerts <span class="op">=</span> Produktionsproblem(</span>
+<span id="cb220-297"><a href="#cb220-297" aria-hidden="true" tabindex="-1"></a>        produkte<span class="op">=</span>produkte,</span>
+<span id="cb220-298"><a href="#cb220-298" aria-hidden="true" tabindex="-1"></a>        kapazitaeten<span class="op">=</span>{<span class="st">&quot;Montagestunden&quot;</span>: <span class="fl">150.0</span>, <span class="st">&quot;Plattenmaterial&quot;</span>: <span class="fl">240.0</span>})</span>
+<span id="cb220-299"><a href="#cb220-299" aria-hidden="true" tabindex="-1"></a>    rueckwaerts <span class="op">=</span> Produktionsproblem(</span>
+<span id="cb220-300"><a href="#cb220-300" aria-hidden="true" tabindex="-1"></a>        produkte<span class="op">=</span>produkte,</span>
+<span id="cb220-301"><a href="#cb220-301" aria-hidden="true" tabindex="-1"></a>        kapazitaeten<span class="op">=</span>{<span class="st">&quot;Plattenmaterial&quot;</span>: <span class="fl">240.0</span>, <span class="st">&quot;Montagestunden&quot;</span>: <span class="fl">150.0</span>})</span>
+<span id="cb220-302"><a href="#cb220-302" aria-hidden="true" tabindex="-1"></a>    <span class="cf">assert</span> vorwaerts.ressourcen <span class="op">==</span> rueckwaerts.ressourcen</span>
+<span id="cb220-303"><a href="#cb220-303" aria-hidden="true" tabindex="-1"></a>    <span class="cf">assert</span> (vorwaerts.verbrauchsmatrix() <span class="op">==</span> rueckwaerts.verbrauchsmatrix()).<span class="bu">all</span>()</span>
+<span id="cb220-304"><a href="#cb220-304" aria-hidden="true" tabindex="-1"></a>    <span class="cf">assert</span> (vorwaerts.kapazitaetsvektor() <span class="op">==</span> rueckwaerts.kapazitaetsvektor()).<span class="bu">all</span>()</span>
+<span id="cb220-305"><a href="#cb220-305" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb220-306"><a href="#cb220-306" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb220-307"><a href="#cb220-307" aria-hidden="true" tabindex="-1"></a><span class="cf">if</span> <span class="va">__name__</span> <span class="op">==</span> <span class="st">&quot;__main__&quot;</span>:</span>
+<span id="cb220-308"><a href="#cb220-308" aria-hidden="true" tabindex="-1"></a>    <span class="im">import</span> sys</span>
+<span id="cb220-309"><a href="#cb220-309" aria-hidden="true" tabindex="-1"></a>    sys.exit(pytest.main([<span class="va">__file__</span>, <span class="st">&quot;-v&quot;</span>, <span class="st">&quot;--tb=short&quot;</span>, <span class="st">&quot;-p&quot;</span>, <span class="st">&quot;no:cacheprovider&quot;</span>]))</span></code></pre></div>
 <blockquote>
 <p><strong>💻 Code-Durchgang</strong></p>
 <table>
@@ -27106,185 +28625,185 @@ AssertionError: Plan [31. 48.] braucht [141. 234.], verfuegbar sind [140. 232.]<
 </tr>
 </tbody>
 </table>
-<div class="sourceCode" id="cb218"><pre class="sourceCode python"><code class="sourceCode python"><span id="cb218-1"><a href="#cb218-1" aria-hidden="true" tabindex="-1"></a><span class="co">#!/usr/bin/env python3</span></span>
-<span id="cb218-2"><a href="#cb218-2" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb218-3"><a href="#cb218-3" aria-hidden="true" tabindex="-1"></a><span class="co"># Mutationstest.py</span></span>
-<span id="cb218-4"><a href="#cb218-4" aria-hidden="true" tabindex="-1"></a><span class="co">&quot;&quot;&quot;</span></span>
-<span id="cb218-5"><a href="#cb218-5" aria-hidden="true" tabindex="-1"></a><span class="co">Kapitel Testen: Wer testet die Tests?</span></span>
-<span id="cb218-6"><a href="#cb218-6" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb218-7"><a href="#cb218-7" aria-hidden="true" tabindex="-1"></a><span class="co">`test_or_kern.py` besteht aus 31 Tests, und alle sind gruen. Das ist noch kein</span></span>
-<span id="cb218-8"><a href="#cb218-8" aria-hidden="true" tabindex="-1"></a><span class="co">Ergebnis. Eine Testsuite, die nie rot war, ist keine Pruefung, sondern eine</span></span>
-<span id="cb218-9"><a href="#cb218-9" aria-hidden="true" tabindex="-1"></a><span class="co">Vermutung - sie koennte aus lauter `assert True` bestehen und saehe genauso aus.</span></span>
-<span id="cb218-10"><a href="#cb218-10" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb218-11"><a href="#cb218-11" aria-hidden="true" tabindex="-1"></a><span class="co">Dieses Programm prueft die Pruefung. Es baut nacheinander KLEINE, gezielte</span></span>
-<span id="cb218-12"><a href="#cb218-12" aria-hidden="true" tabindex="-1"></a><span class="co">Fehler in `or_kern.py` ein - jeder einzelne ist ein Fehler, den man beim</span></span>
-<span id="cb218-13"><a href="#cb218-13" aria-hidden="true" tabindex="-1"></a><span class="co">Programmieren tatsaechlich macht - und laesst die Testsuite darauf los. Fuer</span></span>
-<span id="cb218-14"><a href="#cb218-14" aria-hidden="true" tabindex="-1"></a><span class="co">jede Mutation gibt es genau zwei moegliche Ausgaenge:</span></span>
-<span id="cb218-15"><a href="#cb218-15" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb218-16"><a href="#cb218-16" aria-hidden="true" tabindex="-1"></a><span class="co">    GETOETET    Mindestens ein Test wird rot. Die Suite haette diesen Fehler</span></span>
-<span id="cb218-17"><a href="#cb218-17" aria-hidden="true" tabindex="-1"></a><span class="co">                in der Praxis gefunden.</span></span>
-<span id="cb218-18"><a href="#cb218-18" aria-hidden="true" tabindex="-1"></a><span class="co">    UEBERLEBT   Alle Tests bleiben gruen. Die Suite haette diesen Fehler</span></span>
-<span id="cb218-19"><a href="#cb218-19" aria-hidden="true" tabindex="-1"></a><span class="co">                DURCHGEHEN LASSEN - hier fehlt ein Test.</span></span>
-<span id="cb218-20"><a href="#cb218-20" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb218-21"><a href="#cb218-21" aria-hidden="true" tabindex="-1"></a><span class="co">Ueberlebende Mutationen sind das eigentliche Ergebnis: Sie zeigen die Luecken,</span></span>
-<span id="cb218-22"><a href="#cb218-22" aria-hidden="true" tabindex="-1"></a><span class="co">und zwar ohne dass man sie erraten muss.</span></span>
-<span id="cb218-23"><a href="#cb218-23" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb218-24"><a href="#cb218-24" aria-hidden="true" tabindex="-1"></a><span class="co">Das Verfahren heisst Mutationstest und ist alt; neu ist nur, wie gut es zu</span></span>
-<span id="cb218-25"><a href="#cb218-25" aria-hidden="true" tabindex="-1"></a><span class="co">Optimierungsmodellen passt. Dort kann man den Zielwert meist nicht gegen einen</span></span>
-<span id="cb218-26"><a href="#cb218-26" aria-hidden="true" tabindex="-1"></a><span class="co">bekannten Sollwert pruefen - also weiss man ohne so ein Experiment nicht, ob</span></span>
-<span id="cb218-27"><a href="#cb218-27" aria-hidden="true" tabindex="-1"></a><span class="co">die Ersatzpruefungen (Eigenschaften, Invarianten) ueberhaupt greifen.</span></span>
-<span id="cb218-28"><a href="#cb218-28" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb218-29"><a href="#cb218-29" aria-hidden="true" tabindex="-1"></a><span class="co">WICHTIG: Es wird nichts veraendert. Jede Mutation laeuft in einem eigenen</span></span>
-<span id="cb218-30"><a href="#cb218-30" aria-hidden="true" tabindex="-1"></a><span class="co">temporaeren Verzeichnis mit einer Kopie von or_kern.py.</span></span>
-<span id="cb218-31"><a href="#cb218-31" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb218-32"><a href="#cb218-32" aria-hidden="true" tabindex="-1"></a><span class="co">Benoetigt: pytest; im selben Verzeichnis or_kern.py und test_or_kern.py</span></span>
-<span id="cb218-33"><a href="#cb218-33" aria-hidden="true" tabindex="-1"></a><span class="co">&quot;&quot;&quot;</span></span>
-<span id="cb218-34"><a href="#cb218-34" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb218-35"><a href="#cb218-35" aria-hidden="true" tabindex="-1"></a><span class="im">from</span> __future__ <span class="im">import</span> annotations</span>
-<span id="cb218-36"><a href="#cb218-36" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb218-37"><a href="#cb218-37" aria-hidden="true" tabindex="-1"></a><span class="im">import</span> os</span>
-<span id="cb218-38"><a href="#cb218-38" aria-hidden="true" tabindex="-1"></a><span class="im">import</span> shutil</span>
-<span id="cb218-39"><a href="#cb218-39" aria-hidden="true" tabindex="-1"></a><span class="im">import</span> subprocess</span>
-<span id="cb218-40"><a href="#cb218-40" aria-hidden="true" tabindex="-1"></a><span class="im">import</span> sys</span>
-<span id="cb218-41"><a href="#cb218-41" aria-hidden="true" tabindex="-1"></a><span class="im">import</span> tempfile</span>
-<span id="cb218-42"><a href="#cb218-42" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb218-43"><a href="#cb218-43" aria-hidden="true" tabindex="-1"></a><span class="co"># (Name, gesuchter Text, Ersatz) - jede Zeile ein realistischer Fehler.</span></span>
-<span id="cb218-44"><a href="#cb218-44" aria-hidden="true" tabindex="-1"></a>MUTATIONEN <span class="op">=</span> [</span>
-<span id="cb218-45"><a href="#cb218-45" aria-hidden="true" tabindex="-1"></a>    (<span class="st">&quot;Nebenbedingung umgedreht (&lt;= wird &gt;=)&quot;</span>,</span>
-<span id="cb218-46"><a href="#cb218-46" aria-hidden="true" tabindex="-1"></a>     <span class="st">&quot;&lt;= problem.kapazitaeten[ressource], name=ressource)&quot;</span>,</span>
-<span id="cb218-47"><a href="#cb218-47" aria-hidden="true" tabindex="-1"></a>     <span class="st">&quot;&gt;= problem.kapazitaeten[ressource], name=ressource)&quot;</span>),</span>
-<span id="cb218-48"><a href="#cb218-48" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb218-49"><a href="#cb218-49" aria-hidden="true" tabindex="-1"></a>    (<span class="st">&quot;Maximierung wird Minimierung&quot;</span>,</span>
-<span id="cb218-50"><a href="#cb218-50" aria-hidden="true" tabindex="-1"></a>     <span class="st">&quot;solver.Maximize(sum(menge[p.name] * p.deckungsbeitrag&quot;</span>,</span>
-<span id="cb218-51"><a href="#cb218-51" aria-hidden="true" tabindex="-1"></a>     <span class="st">&quot;solver.Minimize(sum(menge[p.name] * p.deckungsbeitrag&quot;</span>),</span>
-<span id="cb218-52"><a href="#cb218-52" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb218-53"><a href="#cb218-53" aria-hidden="true" tabindex="-1"></a>    (<span class="st">&quot;Vorzeichen der Dualwerte vergessen&quot;</span>,</span>
-<span id="cb218-54"><a href="#cb218-54" aria-hidden="true" tabindex="-1"></a>     <span class="st">&quot;schattenpreise={r: float(-m) for r, m in&quot;</span>,</span>
-<span id="cb218-55"><a href="#cb218-55" aria-hidden="true" tabindex="-1"></a>     <span class="st">&quot;schattenpreise={r: float(m) for r, m in&quot;</span>),</span>
-<span id="cb218-56"><a href="#cb218-56" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb218-57"><a href="#cb218-57" aria-hidden="true" tabindex="-1"></a>    (<span class="st">&quot;Abnahmepruefung aufgeweicht (Toleranz 1e-6 -&gt; 1.0)&quot;</span>,</span>
-<span id="cb218-58"><a href="#cb218-58" aria-hidden="true" tabindex="-1"></a>     <span class="st">&quot;toleranz: float = 1e-6) -&gt; list[str]:&quot;</span>,</span>
-<span id="cb218-59"><a href="#cb218-59" aria-hidden="true" tabindex="-1"></a>     <span class="st">&quot;toleranz: float = 1.0) -&gt; list[str]:&quot;</span>),</span>
-<span id="cb218-60"><a href="#cb218-60" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb218-61"><a href="#cb218-61" aria-hidden="true" tabindex="-1"></a>    (<span class="st">&quot;Kapazitaetspruefung uebersprungen&quot;</span>,</span>
-<span id="cb218-62"><a href="#cb218-62" aria-hidden="true" tabindex="-1"></a>     <span class="st">&quot;if ist &gt; grenze + toleranz:&quot;</span>,</span>
-<span id="cb218-63"><a href="#cb218-63" aria-hidden="true" tabindex="-1"></a>     <span class="st">&quot;if False:&quot;</span>),</span>
-<span id="cb218-64"><a href="#cb218-64" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb218-65"><a href="#cb218-65" aria-hidden="true" tabindex="-1"></a>    (<span class="st">&quot;Pruefung auf doppelte Produktnamen entfernt&quot;</span>,</span>
-<span id="cb218-66"><a href="#cb218-66" aria-hidden="true" tabindex="-1"></a>     <span class="st">&quot;if len(set(namen)) != len(namen):&quot;</span>,</span>
-<span id="cb218-67"><a href="#cb218-67" aria-hidden="true" tabindex="-1"></a>     <span class="st">&quot;if False:&quot;</span>),</span>
-<span id="cb218-68"><a href="#cb218-68" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb218-69"><a href="#cb218-69" aria-hidden="true" tabindex="-1"></a>    (<span class="st">&quot;Ganzzahligkeitspruefung entfernt&quot;</span>,</span>
-<span id="cb218-70"><a href="#cb218-70" aria-hidden="true" tabindex="-1"></a>     <span class="st">&quot;if abs(wert - round(wert)) &gt; toleranz:&quot;</span>,</span>
-<span id="cb218-71"><a href="#cb218-71" aria-hidden="true" tabindex="-1"></a>     <span class="st">&quot;if False:&quot;</span>),</span>
-<span id="cb218-72"><a href="#cb218-72" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb218-73"><a href="#cb218-73" aria-hidden="true" tabindex="-1"></a>    (<span class="st">&quot;Zielwertabgleich entfernt&quot;</span>,</span>
-<span id="cb218-74"><a href="#cb218-74" aria-hidden="true" tabindex="-1"></a>     <span class="st">&quot;if abs(nachgerechnet - loesung.zielwert) &gt; toleranz * max(1.0, abs(nachgerechnet)):&quot;</span>,</span>
-<span id="cb218-75"><a href="#cb218-75" aria-hidden="true" tabindex="-1"></a>     <span class="st">&quot;if False:&quot;</span>),</span>
-<span id="cb218-76"><a href="#cb218-76" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb218-77"><a href="#cb218-77" aria-hidden="true" tabindex="-1"></a>    (<span class="st">&quot;ZEITLIMIT gilt faelschlich als brauchbar&quot;</span>,</span>
-<span id="cb218-78"><a href="#cb218-78" aria-hidden="true" tabindex="-1"></a>     <span class="st">&quot;return self in (SolverStatus.OPTIMAL, SolverStatus.ZULAESSIG)&quot;</span>,</span>
-<span id="cb218-79"><a href="#cb218-79" aria-hidden="true" tabindex="-1"></a>     <span class="st">&quot;return self in (SolverStatus.OPTIMAL, SolverStatus.ZULAESSIG,</span><span class="ch">\n</span><span class="st">&quot;</span></span>
-<span id="cb218-80"><a href="#cb218-80" aria-hidden="true" tabindex="-1"></a>     <span class="st">&quot;                        SolverStatus.ZEITLIMIT)&quot;</span>),</span>
-<span id="cb218-81"><a href="#cb218-81" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb218-82"><a href="#cb218-82" aria-hidden="true" tabindex="-1"></a>    (<span class="st">&quot;Ressourcenreihenfolge nicht mehr stabil&quot;</span>,</span>
-<span id="cb218-83"><a href="#cb218-83" aria-hidden="true" tabindex="-1"></a>     <span class="st">&quot;return sorted(self.kapazitaeten)&quot;</span>,</span>
-<span id="cb218-84"><a href="#cb218-84" aria-hidden="true" tabindex="-1"></a>     <span class="st">&quot;return list(self.kapazitaeten)&quot;</span>),</span>
-<span id="cb218-85"><a href="#cb218-85" aria-hidden="true" tabindex="-1"></a>]</span>
-<span id="cb218-86"><a href="#cb218-86" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb218-87"><a href="#cb218-87" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb218-88"><a href="#cb218-88" aria-hidden="true" tabindex="-1"></a><span class="kw">def</span> fuehre_suite_aus(verzeichnis: <span class="bu">str</span>) <span class="op">-&gt;</span> <span class="bu">tuple</span>[<span class="bu">int</span>, <span class="bu">int</span>, <span class="bu">str</span>]:</span>
-<span id="cb218-89"><a href="#cb218-89" aria-hidden="true" tabindex="-1"></a>    <span class="co">&quot;&quot;&quot;Laesst pytest im Verzeichnis laufen; liefert (bestanden, fehlgeschlagen).&quot;&quot;&quot;</span></span>
-<span id="cb218-90"><a href="#cb218-90" aria-hidden="true" tabindex="-1"></a>    ergebnis <span class="op">=</span> subprocess.run(</span>
-<span id="cb218-91"><a href="#cb218-91" aria-hidden="true" tabindex="-1"></a>        [sys.executable, <span class="st">&quot;-m&quot;</span>, <span class="st">&quot;pytest&quot;</span>, <span class="st">&quot;test_or_kern.py&quot;</span>, <span class="st">&quot;-q&quot;</span>,</span>
-<span id="cb218-92"><a href="#cb218-92" aria-hidden="true" tabindex="-1"></a>         <span class="st">&quot;--tb=no&quot;</span>, <span class="st">&quot;-p&quot;</span>, <span class="st">&quot;no:cacheprovider&quot;</span>],</span>
-<span id="cb218-93"><a href="#cb218-93" aria-hidden="true" tabindex="-1"></a>        cwd<span class="op">=</span>verzeichnis, capture_output<span class="op">=</span><span class="va">True</span>, text<span class="op">=</span><span class="va">True</span>, timeout<span class="op">=</span><span class="dv">600</span>)</span>
-<span id="cb218-94"><a href="#cb218-94" aria-hidden="true" tabindex="-1"></a>    letzte <span class="op">=</span> [z <span class="cf">for</span> z <span class="kw">in</span> ergebnis.stdout.strip().splitlines() <span class="cf">if</span> z.strip()]</span>
-<span id="cb218-95"><a href="#cb218-95" aria-hidden="true" tabindex="-1"></a>    zeile <span class="op">=</span> letzte[<span class="op">-</span><span class="dv">1</span>] <span class="cf">if</span> letzte <span class="cf">else</span> <span class="st">&quot;&quot;</span></span>
-<span id="cb218-96"><a href="#cb218-96" aria-hidden="true" tabindex="-1"></a>    bestanden <span class="op">=</span> fehlgeschlagen <span class="op">=</span> <span class="dv">0</span></span>
-<span id="cb218-97"><a href="#cb218-97" aria-hidden="true" tabindex="-1"></a>    <span class="cf">for</span> teil <span class="kw">in</span> zeile.replace(<span class="st">&quot;=&quot;</span>, <span class="st">&quot; &quot;</span>).split(<span class="st">&quot;,&quot;</span>):</span>
-<span id="cb218-98"><a href="#cb218-98" aria-hidden="true" tabindex="-1"></a>        <span class="cf">for</span> wort <span class="kw">in</span> teil.split():</span>
-<span id="cb218-99"><a href="#cb218-99" aria-hidden="true" tabindex="-1"></a>            <span class="cf">if</span> wort.isdigit():</span>
-<span id="cb218-100"><a href="#cb218-100" aria-hidden="true" tabindex="-1"></a>                zahl <span class="op">=</span> <span class="bu">int</span>(wort)</span>
-<span id="cb218-101"><a href="#cb218-101" aria-hidden="true" tabindex="-1"></a>            <span class="cf">elif</span> wort.startswith(<span class="st">&quot;passed&quot;</span>):</span>
-<span id="cb218-102"><a href="#cb218-102" aria-hidden="true" tabindex="-1"></a>                bestanden <span class="op">=</span> zahl</span>
-<span id="cb218-103"><a href="#cb218-103" aria-hidden="true" tabindex="-1"></a>            <span class="cf">elif</span> wort.startswith(<span class="st">&quot;failed&quot;</span>) <span class="kw">or</span> wort.startswith(<span class="st">&quot;error&quot;</span>):</span>
-<span id="cb218-104"><a href="#cb218-104" aria-hidden="true" tabindex="-1"></a>                fehlgeschlagen <span class="op">+=</span> zahl</span>
-<span id="cb218-105"><a href="#cb218-105" aria-hidden="true" tabindex="-1"></a>    <span class="cf">return</span> bestanden, fehlgeschlagen, zeile</span>
-<span id="cb218-106"><a href="#cb218-106" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb218-107"><a href="#cb218-107" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb218-108"><a href="#cb218-108" aria-hidden="true" tabindex="-1"></a><span class="kw">def</span> mutiere_und_pruefe(quelle: <span class="bu">str</span>, ziel: <span class="bu">str</span>, suche: <span class="bu">str</span>,</span>
-<span id="cb218-109"><a href="#cb218-109" aria-hidden="true" tabindex="-1"></a>                       ersatz: <span class="bu">str</span>) <span class="op">-&gt;</span> <span class="bu">tuple</span>[<span class="bu">int</span>, <span class="bu">int</span>, <span class="bu">str</span>] <span class="op">|</span> <span class="va">None</span>:</span>
-<span id="cb218-110"><a href="#cb218-110" aria-hidden="true" tabindex="-1"></a>    <span class="co">&quot;&quot;&quot;Legt eine mutierte Kopie an und laesst die Suite darauf laufen.&quot;&quot;&quot;</span></span>
-<span id="cb218-111"><a href="#cb218-111" aria-hidden="true" tabindex="-1"></a>    <span class="cf">with</span> tempfile.TemporaryDirectory() <span class="im">as</span> verzeichnis:</span>
-<span id="cb218-112"><a href="#cb218-112" aria-hidden="true" tabindex="-1"></a>        text <span class="op">=</span> <span class="bu">open</span>(quelle, encoding<span class="op">=</span><span class="st">&quot;utf-8&quot;</span>).read()</span>
-<span id="cb218-113"><a href="#cb218-113" aria-hidden="true" tabindex="-1"></a>        <span class="cf">if</span> text.count(suche) <span class="op">!=</span> <span class="dv">1</span>:</span>
-<span id="cb218-114"><a href="#cb218-114" aria-hidden="true" tabindex="-1"></a>            <span class="cf">return</span> <span class="va">None</span>                      <span class="co"># Muster passt nicht (mehr)</span></span>
-<span id="cb218-115"><a href="#cb218-115" aria-hidden="true" tabindex="-1"></a>        <span class="bu">open</span>(os.path.join(verzeichnis, <span class="st">&quot;or_kern.py&quot;</span>), <span class="st">&quot;w&quot;</span>,</span>
-<span id="cb218-116"><a href="#cb218-116" aria-hidden="true" tabindex="-1"></a>             encoding<span class="op">=</span><span class="st">&quot;utf-8&quot;</span>).write(text.replace(suche, ersatz))</span>
-<span id="cb218-117"><a href="#cb218-117" aria-hidden="true" tabindex="-1"></a>        shutil.copy(ziel, verzeichnis)</span>
-<span id="cb218-118"><a href="#cb218-118" aria-hidden="true" tabindex="-1"></a>        <span class="cf">return</span> fuehre_suite_aus(verzeichnis)</span>
-<span id="cb218-119"><a href="#cb218-119" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb218-120"><a href="#cb218-120" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb218-121"><a href="#cb218-121" aria-hidden="true" tabindex="-1"></a><span class="cf">if</span> <span class="va">__name__</span> <span class="op">==</span> <span class="st">&quot;__main__&quot;</span>:</span>
-<span id="cb218-122"><a href="#cb218-122" aria-hidden="true" tabindex="-1"></a>    hier <span class="op">=</span> os.path.dirname(os.path.abspath(<span class="va">__file__</span>))</span>
-<span id="cb218-123"><a href="#cb218-123" aria-hidden="true" tabindex="-1"></a>    quelle <span class="op">=</span> os.path.join(hier, <span class="st">&quot;or_kern.py&quot;</span>)</span>
-<span id="cb218-124"><a href="#cb218-124" aria-hidden="true" tabindex="-1"></a>    suite <span class="op">=</span> os.path.join(hier, <span class="st">&quot;test_or_kern.py&quot;</span>)</span>
-<span id="cb218-125"><a href="#cb218-125" aria-hidden="true" tabindex="-1"></a>    <span class="cf">for</span> pfad <span class="kw">in</span> (quelle, suite):</span>
-<span id="cb218-126"><a href="#cb218-126" aria-hidden="true" tabindex="-1"></a>        <span class="cf">if</span> <span class="kw">not</span> os.path.exists(pfad):</span>
-<span id="cb218-127"><a href="#cb218-127" aria-hidden="true" tabindex="-1"></a>            <span class="cf">raise</span> <span class="pp">SystemExit</span>(<span class="ss">f&quot;Nicht gefunden: </span><span class="sc">{</span>pfad<span class="sc">}</span><span class="ch">\n</span><span class="ss">&quot;</span></span>
-<span id="cb218-128"><a href="#cb218-128" aria-hidden="true" tabindex="-1"></a>                             <span class="ss">f&quot;Beide Dateien muessen im selben Verzeichnis liegen.&quot;</span>)</span>
-<span id="cb218-129"><a href="#cb218-129" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb218-130"><a href="#cb218-130" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;=&quot;</span> <span class="op">*</span> <span class="dv">84</span>)</span>
-<span id="cb218-131"><a href="#cb218-131" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;  MUTATIONSTEST: WUERDE DIE SUITE DIESE FEHLER FINDEN?&quot;</span>)</span>
-<span id="cb218-132"><a href="#cb218-132" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;=&quot;</span> <span class="op">*</span> <span class="dv">84</span>)</span>
-<span id="cb218-133"><a href="#cb218-133" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb218-134"><a href="#cb218-134" aria-hidden="true" tabindex="-1"></a>    <span class="cf">with</span> tempfile.TemporaryDirectory() <span class="im">as</span> v:</span>
-<span id="cb218-135"><a href="#cb218-135" aria-hidden="true" tabindex="-1"></a>        shutil.copy(quelle, v)</span>
-<span id="cb218-136"><a href="#cb218-136" aria-hidden="true" tabindex="-1"></a>        shutil.copy(suite, v)</span>
-<span id="cb218-137"><a href="#cb218-137" aria-hidden="true" tabindex="-1"></a>        bestanden, fehlgeschlagen, _ <span class="op">=</span> fuehre_suite_aus(v)</span>
-<span id="cb218-138"><a href="#cb218-138" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;Ausgangslage: </span><span class="sc">{</span>bestanden<span class="sc">}</span><span class="ss"> Tests, </span><span class="sc">{</span>fehlgeschlagen<span class="sc">}</span><span class="ss"> rot.</span><span class="ch">\n</span><span class="ss">&quot;</span>)</span>
-<span id="cb218-139"><a href="#cb218-139" aria-hidden="true" tabindex="-1"></a>    <span class="cf">if</span> fehlgeschlagen:</span>
-<span id="cb218-140"><a href="#cb218-140" aria-hidden="true" tabindex="-1"></a>        <span class="cf">raise</span> <span class="pp">SystemExit</span>(<span class="st">&quot;Die Suite ist schon ohne Mutation rot - erst das reparieren.&quot;</span>)</span>
-<span id="cb218-141"><a href="#cb218-141" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb218-142"><a href="#cb218-142" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;</span><span class="sc">{</span><span class="st">&#39;eingebauter Fehler&#39;</span><span class="sc">:&lt;48}</span><span class="ss"> </span><span class="sc">{</span><span class="st">&#39;rote Tests&#39;</span><span class="sc">:&gt;11}</span><span class="ss"> </span><span class="sc">{</span><span class="st">&#39;Urteil&#39;</span><span class="sc">:&gt;12}</span><span class="ss">&quot;</span>)</span>
-<span id="cb218-143"><a href="#cb218-143" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;-&quot;</span> <span class="op">*</span> <span class="dv">84</span>)</span>
-<span id="cb218-144"><a href="#cb218-144" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb218-145"><a href="#cb218-145" aria-hidden="true" tabindex="-1"></a>    getoetet, ueberlebt <span class="op">=</span> [], []</span>
-<span id="cb218-146"><a href="#cb218-146" aria-hidden="true" tabindex="-1"></a>    <span class="cf">for</span> name, suche, ersatz <span class="kw">in</span> MUTATIONEN:</span>
-<span id="cb218-147"><a href="#cb218-147" aria-hidden="true" tabindex="-1"></a>        ergebnis <span class="op">=</span> mutiere_und_pruefe(quelle, suite, suche, ersatz)</span>
-<span id="cb218-148"><a href="#cb218-148" aria-hidden="true" tabindex="-1"></a>        <span class="cf">if</span> ergebnis <span class="kw">is</span> <span class="va">None</span>:</span>
-<span id="cb218-149"><a href="#cb218-149" aria-hidden="true" tabindex="-1"></a>            <span class="bu">print</span>(<span class="ss">f&quot;</span><span class="sc">{</span>name<span class="sc">:&lt;48}</span><span class="ss"> </span><span class="sc">{</span><span class="st">&#39;-&#39;</span><span class="sc">:&gt;11}</span><span class="ss"> </span><span class="sc">{</span><span class="st">&#39;nicht anwendbar&#39;</span><span class="sc">:&gt;12}</span><span class="ss">&quot;</span>)</span>
-<span id="cb218-150"><a href="#cb218-150" aria-hidden="true" tabindex="-1"></a>            <span class="cf">continue</span></span>
-<span id="cb218-151"><a href="#cb218-151" aria-hidden="true" tabindex="-1"></a>        _, rot, _ <span class="op">=</span> ergebnis</span>
-<span id="cb218-152"><a href="#cb218-152" aria-hidden="true" tabindex="-1"></a>        urteil <span class="op">=</span> <span class="st">&quot;GETOETET&quot;</span> <span class="cf">if</span> rot <span class="cf">else</span> <span class="st">&quot;UEBERLEBT&quot;</span></span>
-<span id="cb218-153"><a href="#cb218-153" aria-hidden="true" tabindex="-1"></a>        (getoetet <span class="cf">if</span> rot <span class="cf">else</span> ueberlebt).append(name)</span>
-<span id="cb218-154"><a href="#cb218-154" aria-hidden="true" tabindex="-1"></a>        <span class="bu">print</span>(<span class="ss">f&quot;</span><span class="sc">{</span>name<span class="sc">:&lt;48}</span><span class="ss"> </span><span class="sc">{</span>rot<span class="sc">:&gt;11}</span><span class="ss"> </span><span class="sc">{</span>urteil<span class="sc">:&gt;12}</span><span class="ss">&quot;</span>)</span>
-<span id="cb218-155"><a href="#cb218-155" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb218-156"><a href="#cb218-156" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;-&quot;</span> <span class="op">*</span> <span class="dv">84</span>)</span>
-<span id="cb218-157"><a href="#cb218-157" aria-hidden="true" tabindex="-1"></a>    quote <span class="op">=</span> <span class="bu">len</span>(getoetet) <span class="op">/</span> <span class="bu">max</span>(<span class="dv">1</span>, <span class="bu">len</span>(getoetet) <span class="op">+</span> <span class="bu">len</span>(ueberlebt)) <span class="op">*</span> <span class="dv">100</span></span>
-<span id="cb218-158"><a href="#cb218-158" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;Getoetet: </span><span class="sc">{</span><span class="bu">len</span>(getoetet)<span class="sc">}</span><span class="ss"> von </span><span class="sc">{</span><span class="bu">len</span>(getoetet) <span class="op">+</span> <span class="bu">len</span>(ueberlebt)<span class="sc">}</span><span class="ss"> &quot;</span></span>
-<span id="cb218-159"><a href="#cb218-159" aria-hidden="true" tabindex="-1"></a>          <span class="ss">f&quot;(</span><span class="sc">{</span>quote<span class="sc">:.0f}</span><span class="ss"> %)&quot;</span>)</span>
-<span id="cb218-160"><a href="#cb218-160" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb218-161"><a href="#cb218-161" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;</span><span class="ch">\n</span><span class="st">&quot;</span> <span class="op">+</span> <span class="st">&quot;=&quot;</span> <span class="op">*</span> <span class="dv">84</span>)</span>
-<span id="cb218-162"><a href="#cb218-162" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;  WAS DAS ERGEBNIS BEDEUTET&quot;</span>)</span>
-<span id="cb218-163"><a href="#cb218-163" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;=&quot;</span> <span class="op">*</span> <span class="dv">84</span>)</span>
-<span id="cb218-164"><a href="#cb218-164" aria-hidden="true" tabindex="-1"></a>    <span class="cf">if</span> ueberlebt:</span>
-<span id="cb218-165"><a href="#cb218-165" aria-hidden="true" tabindex="-1"></a>        <span class="bu">print</span>(<span class="st">&quot;Diese Fehler haette die Suite DURCHGEHEN LASSEN:</span><span class="ch">\n</span><span class="st">&quot;</span>)</span>
-<span id="cb218-166"><a href="#cb218-166" aria-hidden="true" tabindex="-1"></a>        <span class="cf">for</span> name <span class="kw">in</span> ueberlebt:</span>
-<span id="cb218-167"><a href="#cb218-167" aria-hidden="true" tabindex="-1"></a>            <span class="bu">print</span>(<span class="ss">f&quot;  * </span><span class="sc">{</span>name<span class="sc">}</span><span class="ss">&quot;</span>)</span>
-<span id="cb218-168"><a href="#cb218-168" aria-hidden="true" tabindex="-1"></a>        <span class="bu">print</span>(<span class="st">&quot;</span><span class="ch">\n</span><span class="st">Jeder ueberlebende Eintrag ist eine Testluecke - und zwar eine&quot;</span>)</span>
-<span id="cb218-169"><a href="#cb218-169" aria-hidden="true" tabindex="-1"></a>        <span class="bu">print</span>(<span class="st">&quot;gefundene, keine vermutete. Das ist der ganze Zweck des Verfahrens:&quot;</span>)</span>
-<span id="cb218-170"><a href="#cb218-170" aria-hidden="true" tabindex="-1"></a>        <span class="bu">print</span>(<span class="st">&quot;Es sagt einem, welchen Test man als naechstes schreiben sollte,&quot;</span>)</span>
-<span id="cb218-171"><a href="#cb218-171" aria-hidden="true" tabindex="-1"></a>        <span class="bu">print</span>(<span class="st">&quot;statt dass man raten muss.&quot;</span>)</span>
-<span id="cb218-172"><a href="#cb218-172" aria-hidden="true" tabindex="-1"></a>    <span class="cf">else</span>:</span>
-<span id="cb218-173"><a href="#cb218-173" aria-hidden="true" tabindex="-1"></a>        <span class="bu">print</span>(<span class="st">&quot;Alle eingebauten Fehler wurden gefunden. Das heisst nicht, dass die&quot;</span>)</span>
-<span id="cb218-174"><a href="#cb218-174" aria-hidden="true" tabindex="-1"></a>        <span class="bu">print</span>(<span class="st">&quot;Suite vollstaendig ist - nur, dass sie diese zehn Fehler faengt.&quot;</span>)</span>
-<span id="cb218-175"><a href="#cb218-175" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>()</span>
-<span id="cb218-176"><a href="#cb218-176" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;Die Quote selbst ist keine Kennzahl fuer ein Dashboard. Zehn von Hand&quot;</span>)</span>
-<span id="cb218-177"><a href="#cb218-177" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;gewaehlte Mutationen sind keine Stichprobe aus der Menge aller&quot;</span>)</span>
-<span id="cb218-178"><a href="#cb218-178" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;moeglichen Fehler. Was zaehlt, ist die LISTE der Ueberlebenden.&quot;</span>)</span>
-<span id="cb218-179"><a href="#cb218-179" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;=&quot;</span> <span class="op">*</span> <span class="dv">84</span>)</span></code></pre></div>
+<div class="sourceCode" id="cb222"><pre class="sourceCode python"><code class="sourceCode python"><span id="cb222-1"><a href="#cb222-1" aria-hidden="true" tabindex="-1"></a><span class="co">#!/usr/bin/env python3</span></span>
+<span id="cb222-2"><a href="#cb222-2" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb222-3"><a href="#cb222-3" aria-hidden="true" tabindex="-1"></a><span class="co"># Mutationstest.py</span></span>
+<span id="cb222-4"><a href="#cb222-4" aria-hidden="true" tabindex="-1"></a><span class="co">&quot;&quot;&quot;</span></span>
+<span id="cb222-5"><a href="#cb222-5" aria-hidden="true" tabindex="-1"></a><span class="co">Kapitel Testen: Wer testet die Tests?</span></span>
+<span id="cb222-6"><a href="#cb222-6" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb222-7"><a href="#cb222-7" aria-hidden="true" tabindex="-1"></a><span class="co">`test_or_kern.py` besteht aus 31 Tests, und alle sind gruen. Das ist noch kein</span></span>
+<span id="cb222-8"><a href="#cb222-8" aria-hidden="true" tabindex="-1"></a><span class="co">Ergebnis. Eine Testsuite, die nie rot war, ist keine Pruefung, sondern eine</span></span>
+<span id="cb222-9"><a href="#cb222-9" aria-hidden="true" tabindex="-1"></a><span class="co">Vermutung - sie koennte aus lauter `assert True` bestehen und saehe genauso aus.</span></span>
+<span id="cb222-10"><a href="#cb222-10" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb222-11"><a href="#cb222-11" aria-hidden="true" tabindex="-1"></a><span class="co">Dieses Programm prueft die Pruefung. Es baut nacheinander KLEINE, gezielte</span></span>
+<span id="cb222-12"><a href="#cb222-12" aria-hidden="true" tabindex="-1"></a><span class="co">Fehler in `or_kern.py` ein - jeder einzelne ist ein Fehler, den man beim</span></span>
+<span id="cb222-13"><a href="#cb222-13" aria-hidden="true" tabindex="-1"></a><span class="co">Programmieren tatsaechlich macht - und laesst die Testsuite darauf los. Fuer</span></span>
+<span id="cb222-14"><a href="#cb222-14" aria-hidden="true" tabindex="-1"></a><span class="co">jede Mutation gibt es genau zwei moegliche Ausgaenge:</span></span>
+<span id="cb222-15"><a href="#cb222-15" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb222-16"><a href="#cb222-16" aria-hidden="true" tabindex="-1"></a><span class="co">    GETOETET    Mindestens ein Test wird rot. Die Suite haette diesen Fehler</span></span>
+<span id="cb222-17"><a href="#cb222-17" aria-hidden="true" tabindex="-1"></a><span class="co">                in der Praxis gefunden.</span></span>
+<span id="cb222-18"><a href="#cb222-18" aria-hidden="true" tabindex="-1"></a><span class="co">    UEBERLEBT   Alle Tests bleiben gruen. Die Suite haette diesen Fehler</span></span>
+<span id="cb222-19"><a href="#cb222-19" aria-hidden="true" tabindex="-1"></a><span class="co">                DURCHGEHEN LASSEN - hier fehlt ein Test.</span></span>
+<span id="cb222-20"><a href="#cb222-20" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb222-21"><a href="#cb222-21" aria-hidden="true" tabindex="-1"></a><span class="co">Ueberlebende Mutationen sind das eigentliche Ergebnis: Sie zeigen die Luecken,</span></span>
+<span id="cb222-22"><a href="#cb222-22" aria-hidden="true" tabindex="-1"></a><span class="co">und zwar ohne dass man sie erraten muss.</span></span>
+<span id="cb222-23"><a href="#cb222-23" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb222-24"><a href="#cb222-24" aria-hidden="true" tabindex="-1"></a><span class="co">Das Verfahren heisst Mutationstest und ist alt; neu ist nur, wie gut es zu</span></span>
+<span id="cb222-25"><a href="#cb222-25" aria-hidden="true" tabindex="-1"></a><span class="co">Optimierungsmodellen passt. Dort kann man den Zielwert meist nicht gegen einen</span></span>
+<span id="cb222-26"><a href="#cb222-26" aria-hidden="true" tabindex="-1"></a><span class="co">bekannten Sollwert pruefen - also weiss man ohne so ein Experiment nicht, ob</span></span>
+<span id="cb222-27"><a href="#cb222-27" aria-hidden="true" tabindex="-1"></a><span class="co">die Ersatzpruefungen (Eigenschaften, Invarianten) ueberhaupt greifen.</span></span>
+<span id="cb222-28"><a href="#cb222-28" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb222-29"><a href="#cb222-29" aria-hidden="true" tabindex="-1"></a><span class="co">WICHTIG: Es wird nichts veraendert. Jede Mutation laeuft in einem eigenen</span></span>
+<span id="cb222-30"><a href="#cb222-30" aria-hidden="true" tabindex="-1"></a><span class="co">temporaeren Verzeichnis mit einer Kopie von or_kern.py.</span></span>
+<span id="cb222-31"><a href="#cb222-31" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb222-32"><a href="#cb222-32" aria-hidden="true" tabindex="-1"></a><span class="co">Benoetigt: pytest; im selben Verzeichnis or_kern.py und test_or_kern.py</span></span>
+<span id="cb222-33"><a href="#cb222-33" aria-hidden="true" tabindex="-1"></a><span class="co">&quot;&quot;&quot;</span></span>
+<span id="cb222-34"><a href="#cb222-34" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb222-35"><a href="#cb222-35" aria-hidden="true" tabindex="-1"></a><span class="im">from</span> __future__ <span class="im">import</span> annotations</span>
+<span id="cb222-36"><a href="#cb222-36" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb222-37"><a href="#cb222-37" aria-hidden="true" tabindex="-1"></a><span class="im">import</span> os</span>
+<span id="cb222-38"><a href="#cb222-38" aria-hidden="true" tabindex="-1"></a><span class="im">import</span> shutil</span>
+<span id="cb222-39"><a href="#cb222-39" aria-hidden="true" tabindex="-1"></a><span class="im">import</span> subprocess</span>
+<span id="cb222-40"><a href="#cb222-40" aria-hidden="true" tabindex="-1"></a><span class="im">import</span> sys</span>
+<span id="cb222-41"><a href="#cb222-41" aria-hidden="true" tabindex="-1"></a><span class="im">import</span> tempfile</span>
+<span id="cb222-42"><a href="#cb222-42" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb222-43"><a href="#cb222-43" aria-hidden="true" tabindex="-1"></a><span class="co"># (Name, gesuchter Text, Ersatz) - jede Zeile ein realistischer Fehler.</span></span>
+<span id="cb222-44"><a href="#cb222-44" aria-hidden="true" tabindex="-1"></a>MUTATIONEN <span class="op">=</span> [</span>
+<span id="cb222-45"><a href="#cb222-45" aria-hidden="true" tabindex="-1"></a>    (<span class="st">&quot;Nebenbedingung umgedreht (&lt;= wird &gt;=)&quot;</span>,</span>
+<span id="cb222-46"><a href="#cb222-46" aria-hidden="true" tabindex="-1"></a>     <span class="st">&quot;&lt;= problem.kapazitaeten[ressource], name=ressource)&quot;</span>,</span>
+<span id="cb222-47"><a href="#cb222-47" aria-hidden="true" tabindex="-1"></a>     <span class="st">&quot;&gt;= problem.kapazitaeten[ressource], name=ressource)&quot;</span>),</span>
+<span id="cb222-48"><a href="#cb222-48" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb222-49"><a href="#cb222-49" aria-hidden="true" tabindex="-1"></a>    (<span class="st">&quot;Maximierung wird Minimierung&quot;</span>,</span>
+<span id="cb222-50"><a href="#cb222-50" aria-hidden="true" tabindex="-1"></a>     <span class="st">&quot;solver.Maximize(sum(menge[p.name] * p.deckungsbeitrag&quot;</span>,</span>
+<span id="cb222-51"><a href="#cb222-51" aria-hidden="true" tabindex="-1"></a>     <span class="st">&quot;solver.Minimize(sum(menge[p.name] * p.deckungsbeitrag&quot;</span>),</span>
+<span id="cb222-52"><a href="#cb222-52" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb222-53"><a href="#cb222-53" aria-hidden="true" tabindex="-1"></a>    (<span class="st">&quot;Vorzeichen der Dualwerte vergessen&quot;</span>,</span>
+<span id="cb222-54"><a href="#cb222-54" aria-hidden="true" tabindex="-1"></a>     <span class="st">&quot;schattenpreise={r: float(-m) for r, m in&quot;</span>,</span>
+<span id="cb222-55"><a href="#cb222-55" aria-hidden="true" tabindex="-1"></a>     <span class="st">&quot;schattenpreise={r: float(m) for r, m in&quot;</span>),</span>
+<span id="cb222-56"><a href="#cb222-56" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb222-57"><a href="#cb222-57" aria-hidden="true" tabindex="-1"></a>    (<span class="st">&quot;Abnahmepruefung aufgeweicht (Toleranz 1e-6 -&gt; 1.0)&quot;</span>,</span>
+<span id="cb222-58"><a href="#cb222-58" aria-hidden="true" tabindex="-1"></a>     <span class="st">&quot;toleranz: float = 1e-6) -&gt; list[str]:&quot;</span>,</span>
+<span id="cb222-59"><a href="#cb222-59" aria-hidden="true" tabindex="-1"></a>     <span class="st">&quot;toleranz: float = 1.0) -&gt; list[str]:&quot;</span>),</span>
+<span id="cb222-60"><a href="#cb222-60" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb222-61"><a href="#cb222-61" aria-hidden="true" tabindex="-1"></a>    (<span class="st">&quot;Kapazitaetspruefung uebersprungen&quot;</span>,</span>
+<span id="cb222-62"><a href="#cb222-62" aria-hidden="true" tabindex="-1"></a>     <span class="st">&quot;if ist &gt; grenze + toleranz:&quot;</span>,</span>
+<span id="cb222-63"><a href="#cb222-63" aria-hidden="true" tabindex="-1"></a>     <span class="st">&quot;if False:&quot;</span>),</span>
+<span id="cb222-64"><a href="#cb222-64" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb222-65"><a href="#cb222-65" aria-hidden="true" tabindex="-1"></a>    (<span class="st">&quot;Pruefung auf doppelte Produktnamen entfernt&quot;</span>,</span>
+<span id="cb222-66"><a href="#cb222-66" aria-hidden="true" tabindex="-1"></a>     <span class="st">&quot;if len(set(namen)) != len(namen):&quot;</span>,</span>
+<span id="cb222-67"><a href="#cb222-67" aria-hidden="true" tabindex="-1"></a>     <span class="st">&quot;if False:&quot;</span>),</span>
+<span id="cb222-68"><a href="#cb222-68" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb222-69"><a href="#cb222-69" aria-hidden="true" tabindex="-1"></a>    (<span class="st">&quot;Ganzzahligkeitspruefung entfernt&quot;</span>,</span>
+<span id="cb222-70"><a href="#cb222-70" aria-hidden="true" tabindex="-1"></a>     <span class="st">&quot;if abs(wert - round(wert)) &gt; toleranz:&quot;</span>,</span>
+<span id="cb222-71"><a href="#cb222-71" aria-hidden="true" tabindex="-1"></a>     <span class="st">&quot;if False:&quot;</span>),</span>
+<span id="cb222-72"><a href="#cb222-72" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb222-73"><a href="#cb222-73" aria-hidden="true" tabindex="-1"></a>    (<span class="st">&quot;Zielwertabgleich entfernt&quot;</span>,</span>
+<span id="cb222-74"><a href="#cb222-74" aria-hidden="true" tabindex="-1"></a>     <span class="st">&quot;if abs(nachgerechnet - loesung.zielwert) &gt; toleranz * max(1.0, abs(nachgerechnet)):&quot;</span>,</span>
+<span id="cb222-75"><a href="#cb222-75" aria-hidden="true" tabindex="-1"></a>     <span class="st">&quot;if False:&quot;</span>),</span>
+<span id="cb222-76"><a href="#cb222-76" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb222-77"><a href="#cb222-77" aria-hidden="true" tabindex="-1"></a>    (<span class="st">&quot;ZEITLIMIT gilt faelschlich als brauchbar&quot;</span>,</span>
+<span id="cb222-78"><a href="#cb222-78" aria-hidden="true" tabindex="-1"></a>     <span class="st">&quot;return self in (SolverStatus.OPTIMAL, SolverStatus.ZULAESSIG)&quot;</span>,</span>
+<span id="cb222-79"><a href="#cb222-79" aria-hidden="true" tabindex="-1"></a>     <span class="st">&quot;return self in (SolverStatus.OPTIMAL, SolverStatus.ZULAESSIG,</span><span class="ch">\n</span><span class="st">&quot;</span></span>
+<span id="cb222-80"><a href="#cb222-80" aria-hidden="true" tabindex="-1"></a>     <span class="st">&quot;                        SolverStatus.ZEITLIMIT)&quot;</span>),</span>
+<span id="cb222-81"><a href="#cb222-81" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb222-82"><a href="#cb222-82" aria-hidden="true" tabindex="-1"></a>    (<span class="st">&quot;Ressourcenreihenfolge nicht mehr stabil&quot;</span>,</span>
+<span id="cb222-83"><a href="#cb222-83" aria-hidden="true" tabindex="-1"></a>     <span class="st">&quot;return sorted(self.kapazitaeten)&quot;</span>,</span>
+<span id="cb222-84"><a href="#cb222-84" aria-hidden="true" tabindex="-1"></a>     <span class="st">&quot;return list(self.kapazitaeten)&quot;</span>),</span>
+<span id="cb222-85"><a href="#cb222-85" aria-hidden="true" tabindex="-1"></a>]</span>
+<span id="cb222-86"><a href="#cb222-86" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb222-87"><a href="#cb222-87" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb222-88"><a href="#cb222-88" aria-hidden="true" tabindex="-1"></a><span class="kw">def</span> fuehre_suite_aus(verzeichnis: <span class="bu">str</span>) <span class="op">-&gt;</span> <span class="bu">tuple</span>[<span class="bu">int</span>, <span class="bu">int</span>, <span class="bu">str</span>]:</span>
+<span id="cb222-89"><a href="#cb222-89" aria-hidden="true" tabindex="-1"></a>    <span class="co">&quot;&quot;&quot;Laesst pytest im Verzeichnis laufen; liefert (bestanden, fehlgeschlagen).&quot;&quot;&quot;</span></span>
+<span id="cb222-90"><a href="#cb222-90" aria-hidden="true" tabindex="-1"></a>    ergebnis <span class="op">=</span> subprocess.run(</span>
+<span id="cb222-91"><a href="#cb222-91" aria-hidden="true" tabindex="-1"></a>        [sys.executable, <span class="st">&quot;-m&quot;</span>, <span class="st">&quot;pytest&quot;</span>, <span class="st">&quot;test_or_kern.py&quot;</span>, <span class="st">&quot;-q&quot;</span>,</span>
+<span id="cb222-92"><a href="#cb222-92" aria-hidden="true" tabindex="-1"></a>         <span class="st">&quot;--tb=no&quot;</span>, <span class="st">&quot;-p&quot;</span>, <span class="st">&quot;no:cacheprovider&quot;</span>],</span>
+<span id="cb222-93"><a href="#cb222-93" aria-hidden="true" tabindex="-1"></a>        cwd<span class="op">=</span>verzeichnis, capture_output<span class="op">=</span><span class="va">True</span>, text<span class="op">=</span><span class="va">True</span>, timeout<span class="op">=</span><span class="dv">600</span>)</span>
+<span id="cb222-94"><a href="#cb222-94" aria-hidden="true" tabindex="-1"></a>    letzte <span class="op">=</span> [z <span class="cf">for</span> z <span class="kw">in</span> ergebnis.stdout.strip().splitlines() <span class="cf">if</span> z.strip()]</span>
+<span id="cb222-95"><a href="#cb222-95" aria-hidden="true" tabindex="-1"></a>    zeile <span class="op">=</span> letzte[<span class="op">-</span><span class="dv">1</span>] <span class="cf">if</span> letzte <span class="cf">else</span> <span class="st">&quot;&quot;</span></span>
+<span id="cb222-96"><a href="#cb222-96" aria-hidden="true" tabindex="-1"></a>    bestanden <span class="op">=</span> fehlgeschlagen <span class="op">=</span> <span class="dv">0</span></span>
+<span id="cb222-97"><a href="#cb222-97" aria-hidden="true" tabindex="-1"></a>    <span class="cf">for</span> teil <span class="kw">in</span> zeile.replace(<span class="st">&quot;=&quot;</span>, <span class="st">&quot; &quot;</span>).split(<span class="st">&quot;,&quot;</span>):</span>
+<span id="cb222-98"><a href="#cb222-98" aria-hidden="true" tabindex="-1"></a>        <span class="cf">for</span> wort <span class="kw">in</span> teil.split():</span>
+<span id="cb222-99"><a href="#cb222-99" aria-hidden="true" tabindex="-1"></a>            <span class="cf">if</span> wort.isdigit():</span>
+<span id="cb222-100"><a href="#cb222-100" aria-hidden="true" tabindex="-1"></a>                zahl <span class="op">=</span> <span class="bu">int</span>(wort)</span>
+<span id="cb222-101"><a href="#cb222-101" aria-hidden="true" tabindex="-1"></a>            <span class="cf">elif</span> wort.startswith(<span class="st">&quot;passed&quot;</span>):</span>
+<span id="cb222-102"><a href="#cb222-102" aria-hidden="true" tabindex="-1"></a>                bestanden <span class="op">=</span> zahl</span>
+<span id="cb222-103"><a href="#cb222-103" aria-hidden="true" tabindex="-1"></a>            <span class="cf">elif</span> wort.startswith(<span class="st">&quot;failed&quot;</span>) <span class="kw">or</span> wort.startswith(<span class="st">&quot;error&quot;</span>):</span>
+<span id="cb222-104"><a href="#cb222-104" aria-hidden="true" tabindex="-1"></a>                fehlgeschlagen <span class="op">+=</span> zahl</span>
+<span id="cb222-105"><a href="#cb222-105" aria-hidden="true" tabindex="-1"></a>    <span class="cf">return</span> bestanden, fehlgeschlagen, zeile</span>
+<span id="cb222-106"><a href="#cb222-106" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb222-107"><a href="#cb222-107" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb222-108"><a href="#cb222-108" aria-hidden="true" tabindex="-1"></a><span class="kw">def</span> mutiere_und_pruefe(quelle: <span class="bu">str</span>, ziel: <span class="bu">str</span>, suche: <span class="bu">str</span>,</span>
+<span id="cb222-109"><a href="#cb222-109" aria-hidden="true" tabindex="-1"></a>                       ersatz: <span class="bu">str</span>) <span class="op">-&gt;</span> <span class="bu">tuple</span>[<span class="bu">int</span>, <span class="bu">int</span>, <span class="bu">str</span>] <span class="op">|</span> <span class="va">None</span>:</span>
+<span id="cb222-110"><a href="#cb222-110" aria-hidden="true" tabindex="-1"></a>    <span class="co">&quot;&quot;&quot;Legt eine mutierte Kopie an und laesst die Suite darauf laufen.&quot;&quot;&quot;</span></span>
+<span id="cb222-111"><a href="#cb222-111" aria-hidden="true" tabindex="-1"></a>    <span class="cf">with</span> tempfile.TemporaryDirectory() <span class="im">as</span> verzeichnis:</span>
+<span id="cb222-112"><a href="#cb222-112" aria-hidden="true" tabindex="-1"></a>        text <span class="op">=</span> <span class="bu">open</span>(quelle, encoding<span class="op">=</span><span class="st">&quot;utf-8&quot;</span>).read()</span>
+<span id="cb222-113"><a href="#cb222-113" aria-hidden="true" tabindex="-1"></a>        <span class="cf">if</span> text.count(suche) <span class="op">!=</span> <span class="dv">1</span>:</span>
+<span id="cb222-114"><a href="#cb222-114" aria-hidden="true" tabindex="-1"></a>            <span class="cf">return</span> <span class="va">None</span>                      <span class="co"># Muster passt nicht (mehr)</span></span>
+<span id="cb222-115"><a href="#cb222-115" aria-hidden="true" tabindex="-1"></a>        <span class="bu">open</span>(os.path.join(verzeichnis, <span class="st">&quot;or_kern.py&quot;</span>), <span class="st">&quot;w&quot;</span>,</span>
+<span id="cb222-116"><a href="#cb222-116" aria-hidden="true" tabindex="-1"></a>             encoding<span class="op">=</span><span class="st">&quot;utf-8&quot;</span>).write(text.replace(suche, ersatz))</span>
+<span id="cb222-117"><a href="#cb222-117" aria-hidden="true" tabindex="-1"></a>        shutil.copy(ziel, verzeichnis)</span>
+<span id="cb222-118"><a href="#cb222-118" aria-hidden="true" tabindex="-1"></a>        <span class="cf">return</span> fuehre_suite_aus(verzeichnis)</span>
+<span id="cb222-119"><a href="#cb222-119" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb222-120"><a href="#cb222-120" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb222-121"><a href="#cb222-121" aria-hidden="true" tabindex="-1"></a><span class="cf">if</span> <span class="va">__name__</span> <span class="op">==</span> <span class="st">&quot;__main__&quot;</span>:</span>
+<span id="cb222-122"><a href="#cb222-122" aria-hidden="true" tabindex="-1"></a>    hier <span class="op">=</span> os.path.dirname(os.path.abspath(<span class="va">__file__</span>))</span>
+<span id="cb222-123"><a href="#cb222-123" aria-hidden="true" tabindex="-1"></a>    quelle <span class="op">=</span> os.path.join(hier, <span class="st">&quot;or_kern.py&quot;</span>)</span>
+<span id="cb222-124"><a href="#cb222-124" aria-hidden="true" tabindex="-1"></a>    suite <span class="op">=</span> os.path.join(hier, <span class="st">&quot;test_or_kern.py&quot;</span>)</span>
+<span id="cb222-125"><a href="#cb222-125" aria-hidden="true" tabindex="-1"></a>    <span class="cf">for</span> pfad <span class="kw">in</span> (quelle, suite):</span>
+<span id="cb222-126"><a href="#cb222-126" aria-hidden="true" tabindex="-1"></a>        <span class="cf">if</span> <span class="kw">not</span> os.path.exists(pfad):</span>
+<span id="cb222-127"><a href="#cb222-127" aria-hidden="true" tabindex="-1"></a>            <span class="cf">raise</span> <span class="pp">SystemExit</span>(<span class="ss">f&quot;Nicht gefunden: </span><span class="sc">{</span>pfad<span class="sc">}</span><span class="ch">\n</span><span class="ss">&quot;</span></span>
+<span id="cb222-128"><a href="#cb222-128" aria-hidden="true" tabindex="-1"></a>                             <span class="ss">f&quot;Beide Dateien muessen im selben Verzeichnis liegen.&quot;</span>)</span>
+<span id="cb222-129"><a href="#cb222-129" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb222-130"><a href="#cb222-130" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;=&quot;</span> <span class="op">*</span> <span class="dv">84</span>)</span>
+<span id="cb222-131"><a href="#cb222-131" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;  MUTATIONSTEST: WUERDE DIE SUITE DIESE FEHLER FINDEN?&quot;</span>)</span>
+<span id="cb222-132"><a href="#cb222-132" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;=&quot;</span> <span class="op">*</span> <span class="dv">84</span>)</span>
+<span id="cb222-133"><a href="#cb222-133" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb222-134"><a href="#cb222-134" aria-hidden="true" tabindex="-1"></a>    <span class="cf">with</span> tempfile.TemporaryDirectory() <span class="im">as</span> v:</span>
+<span id="cb222-135"><a href="#cb222-135" aria-hidden="true" tabindex="-1"></a>        shutil.copy(quelle, v)</span>
+<span id="cb222-136"><a href="#cb222-136" aria-hidden="true" tabindex="-1"></a>        shutil.copy(suite, v)</span>
+<span id="cb222-137"><a href="#cb222-137" aria-hidden="true" tabindex="-1"></a>        bestanden, fehlgeschlagen, _ <span class="op">=</span> fuehre_suite_aus(v)</span>
+<span id="cb222-138"><a href="#cb222-138" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;Ausgangslage: </span><span class="sc">{</span>bestanden<span class="sc">}</span><span class="ss"> Tests, </span><span class="sc">{</span>fehlgeschlagen<span class="sc">}</span><span class="ss"> rot.</span><span class="ch">\n</span><span class="ss">&quot;</span>)</span>
+<span id="cb222-139"><a href="#cb222-139" aria-hidden="true" tabindex="-1"></a>    <span class="cf">if</span> fehlgeschlagen:</span>
+<span id="cb222-140"><a href="#cb222-140" aria-hidden="true" tabindex="-1"></a>        <span class="cf">raise</span> <span class="pp">SystemExit</span>(<span class="st">&quot;Die Suite ist schon ohne Mutation rot - erst das reparieren.&quot;</span>)</span>
+<span id="cb222-141"><a href="#cb222-141" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb222-142"><a href="#cb222-142" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;</span><span class="sc">{</span><span class="st">&#39;eingebauter Fehler&#39;</span><span class="sc">:&lt;48}</span><span class="ss"> </span><span class="sc">{</span><span class="st">&#39;rote Tests&#39;</span><span class="sc">:&gt;11}</span><span class="ss"> </span><span class="sc">{</span><span class="st">&#39;Urteil&#39;</span><span class="sc">:&gt;12}</span><span class="ss">&quot;</span>)</span>
+<span id="cb222-143"><a href="#cb222-143" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;-&quot;</span> <span class="op">*</span> <span class="dv">84</span>)</span>
+<span id="cb222-144"><a href="#cb222-144" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb222-145"><a href="#cb222-145" aria-hidden="true" tabindex="-1"></a>    getoetet, ueberlebt <span class="op">=</span> [], []</span>
+<span id="cb222-146"><a href="#cb222-146" aria-hidden="true" tabindex="-1"></a>    <span class="cf">for</span> name, suche, ersatz <span class="kw">in</span> MUTATIONEN:</span>
+<span id="cb222-147"><a href="#cb222-147" aria-hidden="true" tabindex="-1"></a>        ergebnis <span class="op">=</span> mutiere_und_pruefe(quelle, suite, suche, ersatz)</span>
+<span id="cb222-148"><a href="#cb222-148" aria-hidden="true" tabindex="-1"></a>        <span class="cf">if</span> ergebnis <span class="kw">is</span> <span class="va">None</span>:</span>
+<span id="cb222-149"><a href="#cb222-149" aria-hidden="true" tabindex="-1"></a>            <span class="bu">print</span>(<span class="ss">f&quot;</span><span class="sc">{</span>name<span class="sc">:&lt;48}</span><span class="ss"> </span><span class="sc">{</span><span class="st">&#39;-&#39;</span><span class="sc">:&gt;11}</span><span class="ss"> </span><span class="sc">{</span><span class="st">&#39;nicht anwendbar&#39;</span><span class="sc">:&gt;12}</span><span class="ss">&quot;</span>)</span>
+<span id="cb222-150"><a href="#cb222-150" aria-hidden="true" tabindex="-1"></a>            <span class="cf">continue</span></span>
+<span id="cb222-151"><a href="#cb222-151" aria-hidden="true" tabindex="-1"></a>        _, rot, _ <span class="op">=</span> ergebnis</span>
+<span id="cb222-152"><a href="#cb222-152" aria-hidden="true" tabindex="-1"></a>        urteil <span class="op">=</span> <span class="st">&quot;GETOETET&quot;</span> <span class="cf">if</span> rot <span class="cf">else</span> <span class="st">&quot;UEBERLEBT&quot;</span></span>
+<span id="cb222-153"><a href="#cb222-153" aria-hidden="true" tabindex="-1"></a>        (getoetet <span class="cf">if</span> rot <span class="cf">else</span> ueberlebt).append(name)</span>
+<span id="cb222-154"><a href="#cb222-154" aria-hidden="true" tabindex="-1"></a>        <span class="bu">print</span>(<span class="ss">f&quot;</span><span class="sc">{</span>name<span class="sc">:&lt;48}</span><span class="ss"> </span><span class="sc">{</span>rot<span class="sc">:&gt;11}</span><span class="ss"> </span><span class="sc">{</span>urteil<span class="sc">:&gt;12}</span><span class="ss">&quot;</span>)</span>
+<span id="cb222-155"><a href="#cb222-155" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb222-156"><a href="#cb222-156" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;-&quot;</span> <span class="op">*</span> <span class="dv">84</span>)</span>
+<span id="cb222-157"><a href="#cb222-157" aria-hidden="true" tabindex="-1"></a>    quote <span class="op">=</span> <span class="bu">len</span>(getoetet) <span class="op">/</span> <span class="bu">max</span>(<span class="dv">1</span>, <span class="bu">len</span>(getoetet) <span class="op">+</span> <span class="bu">len</span>(ueberlebt)) <span class="op">*</span> <span class="dv">100</span></span>
+<span id="cb222-158"><a href="#cb222-158" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;Getoetet: </span><span class="sc">{</span><span class="bu">len</span>(getoetet)<span class="sc">}</span><span class="ss"> von </span><span class="sc">{</span><span class="bu">len</span>(getoetet) <span class="op">+</span> <span class="bu">len</span>(ueberlebt)<span class="sc">}</span><span class="ss"> &quot;</span></span>
+<span id="cb222-159"><a href="#cb222-159" aria-hidden="true" tabindex="-1"></a>          <span class="ss">f&quot;(</span><span class="sc">{</span>quote<span class="sc">:.0f}</span><span class="ss"> %)&quot;</span>)</span>
+<span id="cb222-160"><a href="#cb222-160" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb222-161"><a href="#cb222-161" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;</span><span class="ch">\n</span><span class="st">&quot;</span> <span class="op">+</span> <span class="st">&quot;=&quot;</span> <span class="op">*</span> <span class="dv">84</span>)</span>
+<span id="cb222-162"><a href="#cb222-162" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;  WAS DAS ERGEBNIS BEDEUTET&quot;</span>)</span>
+<span id="cb222-163"><a href="#cb222-163" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;=&quot;</span> <span class="op">*</span> <span class="dv">84</span>)</span>
+<span id="cb222-164"><a href="#cb222-164" aria-hidden="true" tabindex="-1"></a>    <span class="cf">if</span> ueberlebt:</span>
+<span id="cb222-165"><a href="#cb222-165" aria-hidden="true" tabindex="-1"></a>        <span class="bu">print</span>(<span class="st">&quot;Diese Fehler haette die Suite DURCHGEHEN LASSEN:</span><span class="ch">\n</span><span class="st">&quot;</span>)</span>
+<span id="cb222-166"><a href="#cb222-166" aria-hidden="true" tabindex="-1"></a>        <span class="cf">for</span> name <span class="kw">in</span> ueberlebt:</span>
+<span id="cb222-167"><a href="#cb222-167" aria-hidden="true" tabindex="-1"></a>            <span class="bu">print</span>(<span class="ss">f&quot;  * </span><span class="sc">{</span>name<span class="sc">}</span><span class="ss">&quot;</span>)</span>
+<span id="cb222-168"><a href="#cb222-168" aria-hidden="true" tabindex="-1"></a>        <span class="bu">print</span>(<span class="st">&quot;</span><span class="ch">\n</span><span class="st">Jeder ueberlebende Eintrag ist eine Testluecke - und zwar eine&quot;</span>)</span>
+<span id="cb222-169"><a href="#cb222-169" aria-hidden="true" tabindex="-1"></a>        <span class="bu">print</span>(<span class="st">&quot;gefundene, keine vermutete. Das ist der ganze Zweck des Verfahrens:&quot;</span>)</span>
+<span id="cb222-170"><a href="#cb222-170" aria-hidden="true" tabindex="-1"></a>        <span class="bu">print</span>(<span class="st">&quot;Es sagt einem, welchen Test man als naechstes schreiben sollte,&quot;</span>)</span>
+<span id="cb222-171"><a href="#cb222-171" aria-hidden="true" tabindex="-1"></a>        <span class="bu">print</span>(<span class="st">&quot;statt dass man raten muss.&quot;</span>)</span>
+<span id="cb222-172"><a href="#cb222-172" aria-hidden="true" tabindex="-1"></a>    <span class="cf">else</span>:</span>
+<span id="cb222-173"><a href="#cb222-173" aria-hidden="true" tabindex="-1"></a>        <span class="bu">print</span>(<span class="st">&quot;Alle eingebauten Fehler wurden gefunden. Das heisst nicht, dass die&quot;</span>)</span>
+<span id="cb222-174"><a href="#cb222-174" aria-hidden="true" tabindex="-1"></a>        <span class="bu">print</span>(<span class="st">&quot;Suite vollstaendig ist - nur, dass sie diese zehn Fehler faengt.&quot;</span>)</span>
+<span id="cb222-175"><a href="#cb222-175" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>()</span>
+<span id="cb222-176"><a href="#cb222-176" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;Die Quote selbst ist keine Kennzahl fuer ein Dashboard. Zehn von Hand&quot;</span>)</span>
+<span id="cb222-177"><a href="#cb222-177" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;gewaehlte Mutationen sind keine Stichprobe aus der Menge aller&quot;</span>)</span>
+<span id="cb222-178"><a href="#cb222-178" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;moeglichen Fehler. Was zaehlt, ist die LISTE der Ueberlebenden.&quot;</span>)</span>
+<span id="cb222-179"><a href="#cb222-179" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;=&quot;</span> <span class="op">*</span> <span class="dv">84</span>)</span></code></pre></div>
 <h3 id="der-erste-lauf-fand-zwei-lücken">Der erste Lauf fand zwei Lücken</h3>
 <p>Die Suite hatte zunächst 31 Tests. Der Mutationstest sagte dazu:</p>
 <pre><code>Nebenbedingung umgedreht (&lt;= wird &gt;=)                          7     GETOETET
@@ -27339,208 +28858,219 @@ moeglichen Fehler. Was zaehlt, ist die LISTE der Ueberlebenden.
 <hr />
 <h2 id="sec:testing-benchmark">23.6 Ein Vergleich, dem man glauben kann</h2>
 <p>Solververgleiche stehen in jedem Blog, und die meisten sind wertlos. Nicht, weil falsch gemessen wurde, sondern weil zu wenig dazugesagt wird.</p>
-<div class="sourceCode" id="cb221"><pre class="sourceCode python"><code class="sourceCode python"><span id="cb221-1"><a href="#cb221-1" aria-hidden="true" tabindex="-1"></a><span class="co">#!/usr/bin/env python3</span></span>
-<span id="cb221-2"><a href="#cb221-2" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb221-3"><a href="#cb221-3" aria-hidden="true" tabindex="-1"></a><span class="co"># Benchmark_Skalierung.py</span></span>
-<span id="cb221-4"><a href="#cb221-4" aria-hidden="true" tabindex="-1"></a><span class="co">&quot;&quot;&quot;</span></span>
-<span id="cb221-5"><a href="#cb221-5" aria-hidden="true" tabindex="-1"></a><span class="co">Kapitel Testen: Ein Vergleich, dem man glauben kann.</span></span>
-<span id="cb221-6"><a href="#cb221-6" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb221-7"><a href="#cb221-7" aria-hidden="true" tabindex="-1"></a><span class="co">Solververgleiche stehen in jedem Blog, und die meisten sind wertlos - nicht</span></span>
-<span id="cb221-8"><a href="#cb221-8" aria-hidden="true" tabindex="-1"></a><span class="co">weil falsch gemessen wurde, sondern weil zu wenig dazugesagt wird. Dieses</span></span>
-<span id="cb221-9"><a href="#cb221-9" aria-hidden="true" tabindex="-1"></a><span class="co">Programm misst dasselbe Transportproblem in drei Groessen mit vier</span></span>
-<span id="cb221-10"><a href="#cb221-10" aria-hidden="true" tabindex="-1"></a><span class="co">Bibliotheken und haelt sich dabei an fuenf Regeln, die den Unterschied machen:</span></span>
-<span id="cb221-11"><a href="#cb221-11" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb221-12"><a href="#cb221-12" aria-hidden="true" tabindex="-1"></a><span class="co">  1. EIGENER PROZESS je Bibliothek. Nicht nur wegen des Importkonflikts</span></span>
-<span id="cb221-13"><a href="#cb221-13" aria-hidden="true" tabindex="-1"></a><span class="co">     zwischen ortools und highspy (Kapitel Oekosystem) - auch, damit der</span></span>
-<span id="cb221-14"><a href="#cb221-14" aria-hidden="true" tabindex="-1"></a><span class="co">     Speicherverbrauch der einen nicht in der Messung der anderen auftaucht.</span></span>
-<span id="cb221-15"><a href="#cb221-15" aria-hidden="true" tabindex="-1"></a><span class="co">  2. AUFBAU UND LOESEN GETRENNT messen. Bei grossen Instanzen ist der Aufbau</span></span>
-<span id="cb221-16"><a href="#cb221-16" aria-hidden="true" tabindex="-1"></a><span class="co">     des Modells in Python regelmaessig teurer als das Loesen. Wer nur die</span></span>
-<span id="cb221-17"><a href="#cb221-17" aria-hidden="true" tabindex="-1"></a><span class="co">     Gesamtzeit misst, optimiert am Ende die falsche Haelfte.</span></span>
-<span id="cb221-18"><a href="#cb221-18" aria-hidden="true" tabindex="-1"></a><span class="co">  3. ZIELWERTE GEGENEINANDER PRUEFEN. Eine Bibliothek, die schneller ist und</span></span>
-<span id="cb221-19"><a href="#cb221-19" aria-hidden="true" tabindex="-1"></a><span class="co">     etwas anderes ausrechnet, hat den Vergleich nicht gewonnen. Diese Pruefung</span></span>
-<span id="cb221-20"><a href="#cb221-20" aria-hidden="true" tabindex="-1"></a><span class="co">     ist der wichtigste Teil des Programms.</span></span>
-<span id="cb221-21"><a href="#cb221-21" aria-hidden="true" tabindex="-1"></a><span class="co">  4. SPEICHER MITMESSEN. Bei 10.000 Variablen entscheidet oft er und nicht die</span></span>
-<span id="cb221-22"><a href="#cb221-22" aria-hidden="true" tabindex="-1"></a><span class="co">     Zeit darueber, was auf einer Maschine noch laeuft.</span></span>
-<span id="cb221-23"><a href="#cb221-23" aria-hidden="true" tabindex="-1"></a><span class="co">  5. DIESELBE INSTANZ fuer alle. Feste Saat, kein Neuwuerfeln zwischendurch.</span></span>
-<span id="cb221-24"><a href="#cb221-24" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb221-25"><a href="#cb221-25" aria-hidden="true" tabindex="-1"></a><span class="co">Und die Einschraenkung, die dazugehoert: Gemessen wird EIN Problemtyp in EINER</span></span>
-<span id="cb221-26"><a href="#cb221-26" aria-hidden="true" tabindex="-1"></a><span class="co">Formulierung auf EINER Maschine. Das Ergebnis ist keine Rangliste der Solver,</span></span>
-<span id="cb221-27"><a href="#cb221-27" aria-hidden="true" tabindex="-1"></a><span class="co">sondern eine Entscheidungshilfe fuer genau diesen Fall. Wer es verallgemeinert,</span></span>
-<span id="cb221-28"><a href="#cb221-28" aria-hidden="true" tabindex="-1"></a><span class="co">macht denselben Fehler wie jemand, der aus einem Backtest auf die Zukunft</span></span>
-<span id="cb221-29"><a href="#cb221-29" aria-hidden="true" tabindex="-1"></a><span class="co">schliesst (Kapitel Handelsmaschine).</span></span>
-<span id="cb221-30"><a href="#cb221-30" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb221-31"><a href="#cb221-31" aria-hidden="true" tabindex="-1"></a><span class="co">Benoetigt: numpy; in den Kindprozessen scipy, highspy, ortools, cvxpy</span></span>
-<span id="cb221-32"><a href="#cb221-32" aria-hidden="true" tabindex="-1"></a><span class="co">&quot;&quot;&quot;</span></span>
-<span id="cb221-33"><a href="#cb221-33" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb221-34"><a href="#cb221-34" aria-hidden="true" tabindex="-1"></a><span class="im">from</span> __future__ <span class="im">import</span> annotations</span>
-<span id="cb221-35"><a href="#cb221-35" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb221-36"><a href="#cb221-36" aria-hidden="true" tabindex="-1"></a><span class="im">import</span> json</span>
-<span id="cb221-37"><a href="#cb221-37" aria-hidden="true" tabindex="-1"></a><span class="im">import</span> subprocess</span>
-<span id="cb221-38"><a href="#cb221-38" aria-hidden="true" tabindex="-1"></a><span class="im">import</span> sys</span>
-<span id="cb221-39"><a href="#cb221-39" aria-hidden="true" tabindex="-1"></a><span class="im">import</span> textwrap</span>
-<span id="cb221-40"><a href="#cb221-40" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb221-41"><a href="#cb221-41" aria-hidden="true" tabindex="-1"></a>GROESSEN <span class="op">=</span> [(<span class="dv">10</span>, <span class="dv">10</span>), (<span class="dv">32</span>, <span class="dv">32</span>), (<span class="dv">100</span>, <span class="dv">100</span>)]   <span class="co"># (Lager, Kunden) -&gt; 100 / 1.024 / 10.000 Variablen</span></span>
-<span id="cb221-42"><a href="#cb221-42" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb221-43"><a href="#cb221-43" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb221-44"><a href="#cb221-44" aria-hidden="true" tabindex="-1"></a><span class="co"># Jeder Eintrag ist ein eigenstaendiges Programm: Instanz aufbauen, loesen,</span></span>
-<span id="cb221-45"><a href="#cb221-45" aria-hidden="true" tabindex="-1"></a><span class="co"># Ergebnis als JSON ausgeben. Die Instanz wird in jedem Kindprozess aus</span></span>
-<span id="cb221-46"><a href="#cb221-46" aria-hidden="true" tabindex="-1"></a><span class="co"># derselben Saat neu erzeugt - so reist nichts ueber die Prozessgrenze,</span></span>
-<span id="cb221-47"><a href="#cb221-47" aria-hidden="true" tabindex="-1"></a><span class="co"># was das Ergebnis verfaelschen koennte.</span></span>
-<span id="cb221-48"><a href="#cb221-48" aria-hidden="true" tabindex="-1"></a>VORSPANN <span class="op">=</span> <span class="st">&quot;&quot;&quot;</span></span>
-<span id="cb221-49"><a href="#cb221-49" aria-hidden="true" tabindex="-1"></a><span class="st">import json, time, resource</span></span>
-<span id="cb221-50"><a href="#cb221-50" aria-hidden="true" tabindex="-1"></a><span class="st">import numpy as np</span></span>
-<span id="cb221-51"><a href="#cb221-51" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb221-52"><a href="#cb221-52" aria-hidden="true" tabindex="-1"></a><span class="st">def instanz(m, n):</span></span>
-<span id="cb221-53"><a href="#cb221-53" aria-hidden="true" tabindex="-1"></a><span class="st">    rng = np.random.default_rng(20)</span></span>
-<span id="cb221-54"><a href="#cb221-54" aria-hidden="true" tabindex="-1"></a><span class="st">    kosten = rng.integers(5, 95, (m, n)).astype(float)</span></span>
-<span id="cb221-55"><a href="#cb221-55" aria-hidden="true" tabindex="-1"></a><span class="st">    angebot = rng.integers(50, 150, m).astype(float)</span></span>
-<span id="cb221-56"><a href="#cb221-56" aria-hidden="true" tabindex="-1"></a><span class="st">    bedarf = angebot.sum() * rng.dirichlet(np.ones(n))</span></span>
-<span id="cb221-57"><a href="#cb221-57" aria-hidden="true" tabindex="-1"></a><span class="st">    return kosten, angebot, bedarf</span></span>
-<span id="cb221-58"><a href="#cb221-58" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb221-59"><a href="#cb221-59" aria-hidden="true" tabindex="-1"></a><span class="st">def speicher_mb():</span></span>
-<span id="cb221-60"><a href="#cb221-60" aria-hidden="true" tabindex="-1"></a><span class="st">    # ru_maxrss ist unter Linux in Kilobyte</span></span>
-<span id="cb221-61"><a href="#cb221-61" aria-hidden="true" tabindex="-1"></a><span class="st">    return resource.getrusage(resource.RUSAGE_SELF).ru_maxrss / 1024</span></span>
-<span id="cb221-62"><a href="#cb221-62" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb221-63"><a href="#cb221-63" aria-hidden="true" tabindex="-1"></a><span class="st">M, N = </span><span class="sc">{m}</span><span class="st">, </span><span class="sc">{n}</span></span>
-<span id="cb221-64"><a href="#cb221-64" aria-hidden="true" tabindex="-1"></a><span class="st">kosten, angebot, bedarf = instanz(M, N)</span></span>
-<span id="cb221-65"><a href="#cb221-65" aria-hidden="true" tabindex="-1"></a><span class="st">&quot;&quot;&quot;</span></span>
-<span id="cb221-66"><a href="#cb221-66" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb221-67"><a href="#cb221-67" aria-hidden="true" tabindex="-1"></a>ANSAETZE <span class="op">=</span> {</span>
-<span id="cb221-68"><a href="#cb221-68" aria-hidden="true" tabindex="-1"></a>    <span class="st">&quot;scipy.linprog&quot;</span>: <span class="st">&quot;&quot;&quot;</span></span>
-<span id="cb221-69"><a href="#cb221-69" aria-hidden="true" tabindex="-1"></a><span class="st">        from scipy.optimize import linprog</span></span>
-<span id="cb221-70"><a href="#cb221-70" aria-hidden="true" tabindex="-1"></a><span class="st">        t0 = time.perf_counter()</span></span>
-<span id="cb221-71"><a href="#cb221-71" aria-hidden="true" tabindex="-1"></a><span class="st">        c = kosten.reshape(-1)</span></span>
-<span id="cb221-72"><a href="#cb221-72" aria-hidden="true" tabindex="-1"></a><span class="st">        A_ub = np.zeros((M, M * N)); A_eq = np.zeros((N, M * N))</span></span>
-<span id="cb221-73"><a href="#cb221-73" aria-hidden="true" tabindex="-1"></a><span class="st">        for i in range(M):</span></span>
-<span id="cb221-74"><a href="#cb221-74" aria-hidden="true" tabindex="-1"></a><span class="st">            A_ub[i, i * N:(i + 1) * N] = 1.0</span></span>
-<span id="cb221-75"><a href="#cb221-75" aria-hidden="true" tabindex="-1"></a><span class="st">        for j in range(N):</span></span>
-<span id="cb221-76"><a href="#cb221-76" aria-hidden="true" tabindex="-1"></a><span class="st">            A_eq[j, j::N] = 1.0</span></span>
-<span id="cb221-77"><a href="#cb221-77" aria-hidden="true" tabindex="-1"></a><span class="st">        aufbau = time.perf_counter() - t0</span></span>
-<span id="cb221-78"><a href="#cb221-78" aria-hidden="true" tabindex="-1"></a><span class="st">        t0 = time.perf_counter()</span></span>
-<span id="cb221-79"><a href="#cb221-79" aria-hidden="true" tabindex="-1"></a><span class="st">        r = linprog(c=c, A_ub=A_ub, b_ub=angebot, A_eq=A_eq, b_eq=bedarf,</span></span>
-<span id="cb221-80"><a href="#cb221-80" aria-hidden="true" tabindex="-1"></a><span class="st">                    bounds=(0, None), method=&quot;highs&quot;)</span></span>
-<span id="cb221-81"><a href="#cb221-81" aria-hidden="true" tabindex="-1"></a><span class="st">        loesen = time.perf_counter() - t0</span></span>
-<span id="cb221-82"><a href="#cb221-82" aria-hidden="true" tabindex="-1"></a><span class="st">        ausgabe = (float(r.fun), aufbau, loesen, speicher_mb())</span></span>
-<span id="cb221-83"><a href="#cb221-83" aria-hidden="true" tabindex="-1"></a><span class="st">    &quot;&quot;&quot;</span>,</span>
-<span id="cb221-84"><a href="#cb221-84" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb221-85"><a href="#cb221-85" aria-hidden="true" tabindex="-1"></a>    <span class="st">&quot;highspy&quot;</span>: <span class="st">&quot;&quot;&quot;</span></span>
-<span id="cb221-86"><a href="#cb221-86" aria-hidden="true" tabindex="-1"></a><span class="st">        import highspy</span></span>
-<span id="cb221-87"><a href="#cb221-87" aria-hidden="true" tabindex="-1"></a><span class="st">        t0 = time.perf_counter()</span></span>
-<span id="cb221-88"><a href="#cb221-88" aria-hidden="true" tabindex="-1"></a><span class="st">        h = highspy.Highs(); h.setOptionValue(&quot;output_flag&quot;, False)</span></span>
-<span id="cb221-89"><a href="#cb221-89" aria-hidden="true" tabindex="-1"></a><span class="st">        h.addVars(M * N, np.zeros(M * N), np.full(M * N, highspy.kHighsInf))</span></span>
-<span id="cb221-90"><a href="#cb221-90" aria-hidden="true" tabindex="-1"></a><span class="st">        for k in range(M * N):</span></span>
-<span id="cb221-91"><a href="#cb221-91" aria-hidden="true" tabindex="-1"></a><span class="st">            h.changeColCost(k, float(kosten.reshape(-1)[k]))</span></span>
-<span id="cb221-92"><a href="#cb221-92" aria-hidden="true" tabindex="-1"></a><span class="st">        for i in range(M):</span></span>
-<span id="cb221-93"><a href="#cb221-93" aria-hidden="true" tabindex="-1"></a><span class="st">            idx = np.arange(i * N, (i + 1) * N, dtype=np.int32)</span></span>
-<span id="cb221-94"><a href="#cb221-94" aria-hidden="true" tabindex="-1"></a><span class="st">            h.addRow(-highspy.kHighsInf, float(angebot[i]), N, idx, np.ones(N))</span></span>
-<span id="cb221-95"><a href="#cb221-95" aria-hidden="true" tabindex="-1"></a><span class="st">        for j in range(N):</span></span>
-<span id="cb221-96"><a href="#cb221-96" aria-hidden="true" tabindex="-1"></a><span class="st">            idx = np.arange(j, M * N, N, dtype=np.int32)</span></span>
-<span id="cb221-97"><a href="#cb221-97" aria-hidden="true" tabindex="-1"></a><span class="st">            h.addRow(float(bedarf[j]), float(bedarf[j]), M, idx, np.ones(M))</span></span>
-<span id="cb221-98"><a href="#cb221-98" aria-hidden="true" tabindex="-1"></a><span class="st">        aufbau = time.perf_counter() - t0</span></span>
-<span id="cb221-99"><a href="#cb221-99" aria-hidden="true" tabindex="-1"></a><span class="st">        t0 = time.perf_counter(); h.run(); loesen = time.perf_counter() - t0</span></span>
-<span id="cb221-100"><a href="#cb221-100" aria-hidden="true" tabindex="-1"></a><span class="st">        ausgabe = (h.getInfo().objective_function_value, aufbau, loesen, speicher_mb())</span></span>
-<span id="cb221-101"><a href="#cb221-101" aria-hidden="true" tabindex="-1"></a><span class="st">    &quot;&quot;&quot;</span>,</span>
-<span id="cb221-102"><a href="#cb221-102" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb221-103"><a href="#cb221-103" aria-hidden="true" tabindex="-1"></a>    <span class="st">&quot;ortools/GLOP&quot;</span>: <span class="st">&quot;&quot;&quot;</span></span>
-<span id="cb221-104"><a href="#cb221-104" aria-hidden="true" tabindex="-1"></a><span class="st">        from ortools.linear_solver import pywraplp</span></span>
-<span id="cb221-105"><a href="#cb221-105" aria-hidden="true" tabindex="-1"></a><span class="st">        t0 = time.perf_counter()</span></span>
-<span id="cb221-106"><a href="#cb221-106" aria-hidden="true" tabindex="-1"></a><span class="st">        s = pywraplp.Solver.CreateSolver(&quot;GLOP&quot;)</span></span>
-<span id="cb221-107"><a href="#cb221-107" aria-hidden="true" tabindex="-1"></a><span class="st">        x = [[s.NumVar(0, s.infinity(), f&quot;x</span><span class="sc">{i}</span><span class="st">_</span><span class="sc">{j}</span><span class="st">&quot;) for j in range(N)]</span></span>
-<span id="cb221-108"><a href="#cb221-108" aria-hidden="true" tabindex="-1"></a><span class="st">             for i in range(M)]</span></span>
-<span id="cb221-109"><a href="#cb221-109" aria-hidden="true" tabindex="-1"></a><span class="st">        for i in range(M):</span></span>
-<span id="cb221-110"><a href="#cb221-110" aria-hidden="true" tabindex="-1"></a><span class="st">            s.Add(sum(x[i]) &lt;= float(angebot[i]))</span></span>
-<span id="cb221-111"><a href="#cb221-111" aria-hidden="true" tabindex="-1"></a><span class="st">        for j in range(N):</span></span>
-<span id="cb221-112"><a href="#cb221-112" aria-hidden="true" tabindex="-1"></a><span class="st">            s.Add(sum(x[i][j] for i in range(M)) == float(bedarf[j]))</span></span>
-<span id="cb221-113"><a href="#cb221-113" aria-hidden="true" tabindex="-1"></a><span class="st">        s.Minimize(sum(float(kosten[i, j]) * x[i][j]</span></span>
-<span id="cb221-114"><a href="#cb221-114" aria-hidden="true" tabindex="-1"></a><span class="st">                       for i in range(M) for j in range(N)))</span></span>
-<span id="cb221-115"><a href="#cb221-115" aria-hidden="true" tabindex="-1"></a><span class="st">        aufbau = time.perf_counter() - t0</span></span>
-<span id="cb221-116"><a href="#cb221-116" aria-hidden="true" tabindex="-1"></a><span class="st">        t0 = time.perf_counter(); s.Solve(); loesen = time.perf_counter() - t0</span></span>
-<span id="cb221-117"><a href="#cb221-117" aria-hidden="true" tabindex="-1"></a><span class="st">        ausgabe = (s.Objective().Value(), aufbau, loesen, speicher_mb())</span></span>
-<span id="cb221-118"><a href="#cb221-118" aria-hidden="true" tabindex="-1"></a><span class="st">    &quot;&quot;&quot;</span>,</span>
-<span id="cb221-119"><a href="#cb221-119" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb221-120"><a href="#cb221-120" aria-hidden="true" tabindex="-1"></a>    <span class="st">&quot;cvxpy&quot;</span>: <span class="st">&quot;&quot;&quot;</span></span>
-<span id="cb221-121"><a href="#cb221-121" aria-hidden="true" tabindex="-1"></a><span class="st">        import cvxpy as cp</span></span>
-<span id="cb221-122"><a href="#cb221-122" aria-hidden="true" tabindex="-1"></a><span class="st">        t0 = time.perf_counter()</span></span>
-<span id="cb221-123"><a href="#cb221-123" aria-hidden="true" tabindex="-1"></a><span class="st">        x = cp.Variable((M, N), nonneg=True)</span></span>
-<span id="cb221-124"><a href="#cb221-124" aria-hidden="true" tabindex="-1"></a><span class="st">        problem = cp.Problem(cp.Minimize(cp.sum(cp.multiply(kosten, x))),</span></span>
-<span id="cb221-125"><a href="#cb221-125" aria-hidden="true" tabindex="-1"></a><span class="st">                             [cp.sum(x, axis=1) &lt;= angebot,</span></span>
-<span id="cb221-126"><a href="#cb221-126" aria-hidden="true" tabindex="-1"></a><span class="st">                              cp.sum(x, axis=0) == bedarf])</span></span>
-<span id="cb221-127"><a href="#cb221-127" aria-hidden="true" tabindex="-1"></a><span class="st">        aufbau = time.perf_counter() - t0</span></span>
-<span id="cb221-128"><a href="#cb221-128" aria-hidden="true" tabindex="-1"></a><span class="st">        t0 = time.perf_counter(); problem.solve(); loesen = time.perf_counter() - t0</span></span>
-<span id="cb221-129"><a href="#cb221-129" aria-hidden="true" tabindex="-1"></a><span class="st">        ausgabe = (float(problem.value), aufbau, loesen, speicher_mb())</span></span>
-<span id="cb221-130"><a href="#cb221-130" aria-hidden="true" tabindex="-1"></a><span class="st">    &quot;&quot;&quot;</span>,</span>
-<span id="cb221-131"><a href="#cb221-131" aria-hidden="true" tabindex="-1"></a>}</span>
-<span id="cb221-132"><a href="#cb221-132" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb221-133"><a href="#cb221-133" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb221-134"><a href="#cb221-134" aria-hidden="true" tabindex="-1"></a><span class="kw">def</span> messe(name: <span class="bu">str</span>, quelltext: <span class="bu">str</span>, m: <span class="bu">int</span>, n: <span class="bu">int</span>):</span>
-<span id="cb221-135"><a href="#cb221-135" aria-hidden="true" tabindex="-1"></a>    <span class="co">&quot;&quot;&quot;Fuehrt einen Ansatz in einem eigenen Prozess aus.&quot;&quot;&quot;</span></span>
-<span id="cb221-136"><a href="#cb221-136" aria-hidden="true" tabindex="-1"></a>    programm <span class="op">=</span> (VORSPANN.<span class="bu">format</span>(m<span class="op">=</span>m, n<span class="op">=</span>n) <span class="op">+</span> textwrap.dedent(quelltext)</span>
-<span id="cb221-137"><a href="#cb221-137" aria-hidden="true" tabindex="-1"></a>                <span class="op">+</span> <span class="st">&quot;</span><span class="ch">\n</span><span class="st">print(json.dumps(ausgabe))</span><span class="ch">\n</span><span class="st">&quot;</span>)</span>
-<span id="cb221-138"><a href="#cb221-138" aria-hidden="true" tabindex="-1"></a>    ergebnis <span class="op">=</span> subprocess.run([sys.executable, <span class="st">&quot;-c&quot;</span>, programm],</span>
-<span id="cb221-139"><a href="#cb221-139" aria-hidden="true" tabindex="-1"></a>                              capture_output<span class="op">=</span><span class="va">True</span>, text<span class="op">=</span><span class="va">True</span>, timeout<span class="op">=</span><span class="dv">600</span>)</span>
-<span id="cb221-140"><a href="#cb221-140" aria-hidden="true" tabindex="-1"></a>    <span class="cf">if</span> ergebnis.returncode <span class="op">!=</span> <span class="dv">0</span>:</span>
-<span id="cb221-141"><a href="#cb221-141" aria-hidden="true" tabindex="-1"></a>        <span class="cf">return</span> <span class="va">None</span>, ergebnis.stderr.strip().splitlines()[<span class="op">-</span><span class="dv">1</span>][:<span class="dv">60</span>]</span>
-<span id="cb221-142"><a href="#cb221-142" aria-hidden="true" tabindex="-1"></a>    <span class="cf">return</span> json.loads(ergebnis.stdout.strip().splitlines()[<span class="op">-</span><span class="dv">1</span>]), <span class="va">None</span></span>
-<span id="cb221-143"><a href="#cb221-143" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb221-144"><a href="#cb221-144" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb221-145"><a href="#cb221-145" aria-hidden="true" tabindex="-1"></a><span class="cf">if</span> <span class="va">__name__</span> <span class="op">==</span> <span class="st">&quot;__main__&quot;</span>:</span>
-<span id="cb221-146"><a href="#cb221-146" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;=&quot;</span> <span class="op">*</span> <span class="dv">92</span>)</span>
-<span id="cb221-147"><a href="#cb221-147" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;  SKALIERUNGSVERGLEICH: TRANSPORTPROBLEM, VIER BIBLIOTHEKEN&quot;</span>)</span>
-<span id="cb221-148"><a href="#cb221-148" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;=&quot;</span> <span class="op">*</span> <span class="dv">92</span>)</span>
-<span id="cb221-149"><a href="#cb221-149" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;Jede Zeile ein eigener Prozess. Zeiten und Speicher sind &quot;</span></span>
-<span id="cb221-150"><a href="#cb221-150" aria-hidden="true" tabindex="-1"></a>          <span class="st">&quot;hardwareabhaengig,&quot;</span>)</span>
-<span id="cb221-151"><a href="#cb221-151" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;die Zielwerte und ihr Verhaeltnis zueinander nicht.</span><span class="ch">\n</span><span class="st">&quot;</span>)</span>
-<span id="cb221-152"><a href="#cb221-152" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb221-153"><a href="#cb221-153" aria-hidden="true" tabindex="-1"></a>    <span class="cf">for</span> m, n <span class="kw">in</span> GROESSEN:</span>
-<span id="cb221-154"><a href="#cb221-154" aria-hidden="true" tabindex="-1"></a>        kopf <span class="op">=</span> <span class="ss">f&quot;--- </span><span class="sc">{</span>m<span class="sc">}</span><span class="ss"> Lager x </span><span class="sc">{</span>n<span class="sc">}</span><span class="ss"> Kunden = </span><span class="sc">{</span>m <span class="op">*</span> n<span class="sc">:,}</span><span class="ss"> Variablen &quot;</span></span>
-<span id="cb221-155"><a href="#cb221-155" aria-hidden="true" tabindex="-1"></a>        <span class="bu">print</span>(kopf <span class="op">+</span> <span class="st">&quot;-&quot;</span> <span class="op">*</span> <span class="bu">max</span>(<span class="dv">3</span>, <span class="dv">92</span> <span class="op">-</span> <span class="bu">len</span>(kopf)))</span>
-<span id="cb221-156"><a href="#cb221-156" aria-hidden="true" tabindex="-1"></a>        <span class="bu">print</span>(<span class="ss">f&quot;  </span><span class="sc">{</span><span class="st">&#39;Bibliothek&#39;</span><span class="sc">:&lt;16}</span><span class="ss"> </span><span class="sc">{</span><span class="st">&#39;Zielwert&#39;</span><span class="sc">:&gt;14}</span><span class="ss"> </span><span class="sc">{</span><span class="st">&#39;Aufbau&#39;</span><span class="sc">:&gt;9}</span><span class="ss"> &quot;</span></span>
-<span id="cb221-157"><a href="#cb221-157" aria-hidden="true" tabindex="-1"></a>              <span class="ss">f&quot;</span><span class="sc">{</span><span class="st">&#39;Loesen&#39;</span><span class="sc">:&gt;9}</span><span class="ss"> </span><span class="sc">{</span><span class="st">&#39;Anteil&#39;</span><span class="sc">:&gt;8}</span><span class="ss"> </span><span class="sc">{</span><span class="st">&#39;Speicher&#39;</span><span class="sc">:&gt;10}</span><span class="ss">&quot;</span>)</span>
-<span id="cb221-158"><a href="#cb221-158" aria-hidden="true" tabindex="-1"></a>        <span class="bu">print</span>(<span class="st">&quot;  &quot;</span> <span class="op">+</span> <span class="st">&quot;-&quot;</span> <span class="op">*</span> <span class="dv">72</span>)</span>
-<span id="cb221-159"><a href="#cb221-159" aria-hidden="true" tabindex="-1"></a>        zielwerte <span class="op">=</span> {}</span>
-<span id="cb221-160"><a href="#cb221-160" aria-hidden="true" tabindex="-1"></a>        <span class="cf">for</span> name, quelltext <span class="kw">in</span> ANSAETZE.items():</span>
-<span id="cb221-161"><a href="#cb221-161" aria-hidden="true" tabindex="-1"></a>            werte, fehler <span class="op">=</span> messe(name, quelltext, m, n)</span>
-<span id="cb221-162"><a href="#cb221-162" aria-hidden="true" tabindex="-1"></a>            <span class="cf">if</span> werte <span class="kw">is</span> <span class="va">None</span>:</span>
-<span id="cb221-163"><a href="#cb221-163" aria-hidden="true" tabindex="-1"></a>                <span class="bu">print</span>(<span class="ss">f&quot;  </span><span class="sc">{</span>name<span class="sc">:&lt;16}</span><span class="ss"> nicht verfuegbar: </span><span class="sc">{</span>fehler<span class="sc">}</span><span class="ss">&quot;</span>)</span>
-<span id="cb221-164"><a href="#cb221-164" aria-hidden="true" tabindex="-1"></a>                <span class="cf">continue</span></span>
-<span id="cb221-165"><a href="#cb221-165" aria-hidden="true" tabindex="-1"></a>            ziel, aufbau, loesen, speicher <span class="op">=</span> werte</span>
-<span id="cb221-166"><a href="#cb221-166" aria-hidden="true" tabindex="-1"></a>            zielwerte[name] <span class="op">=</span> ziel</span>
-<span id="cb221-167"><a href="#cb221-167" aria-hidden="true" tabindex="-1"></a>            anteil <span class="op">=</span> aufbau <span class="op">/</span> (aufbau <span class="op">+</span> loesen) <span class="op">*</span> <span class="dv">100</span></span>
-<span id="cb221-168"><a href="#cb221-168" aria-hidden="true" tabindex="-1"></a>            <span class="bu">print</span>(<span class="ss">f&quot;  </span><span class="sc">{</span>name<span class="sc">:&lt;16}</span><span class="ss"> </span><span class="sc">{</span>ziel<span class="sc">:&gt;14,.2f}</span><span class="ss"> </span><span class="sc">{</span>aufbau<span class="sc">:&gt;8.3f}</span><span class="ss">s &quot;</span></span>
-<span id="cb221-169"><a href="#cb221-169" aria-hidden="true" tabindex="-1"></a>                  <span class="ss">f&quot;</span><span class="sc">{</span>loesen<span class="sc">:&gt;8.3f}</span><span class="ss">s </span><span class="sc">{</span>anteil<span class="sc">:&gt;7.0f}</span><span class="ss">% </span><span class="sc">{</span>speicher<span class="sc">:&gt;9.0f}</span><span class="ss"> MB&quot;</span>)</span>
-<span id="cb221-170"><a href="#cb221-170" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb221-171"><a href="#cb221-171" aria-hidden="true" tabindex="-1"></a>        <span class="co"># Die wichtigste Zeile: Rechnen alle dasselbe aus?</span></span>
-<span id="cb221-172"><a href="#cb221-172" aria-hidden="true" tabindex="-1"></a>        spanne <span class="op">=</span> <span class="bu">max</span>(zielwerte.values()) <span class="op">-</span> <span class="bu">min</span>(zielwerte.values())</span>
-<span id="cb221-173"><a href="#cb221-173" aria-hidden="true" tabindex="-1"></a>        bezug <span class="op">=</span> <span class="bu">max</span>(<span class="bu">abs</span>(v) <span class="cf">for</span> v <span class="kw">in</span> zielwerte.values())</span>
-<span id="cb221-174"><a href="#cb221-174" aria-hidden="true" tabindex="-1"></a>        <span class="bu">print</span>(<span class="ss">f&quot;  </span><span class="sc">{</span><span class="st">&#39;&#39;</span><span class="sc">:16}</span><span class="ss"> Spannweite der Zielwerte: </span><span class="sc">{</span>spanne<span class="sc">:.2e}</span><span class="ss"> &quot;</span></span>
-<span id="cb221-175"><a href="#cb221-175" aria-hidden="true" tabindex="-1"></a>              <span class="ss">f&quot;(relativ </span><span class="sc">{</span>spanne <span class="op">/</span> bezug<span class="sc">:.1e}</span><span class="ss">)&quot;</span>)</span>
-<span id="cb221-176"><a href="#cb221-176" aria-hidden="true" tabindex="-1"></a>        <span class="cf">if</span> spanne <span class="op">/</span> bezug <span class="op">&gt;</span> <span class="fl">1e-6</span>:</span>
-<span id="cb221-177"><a href="#cb221-177" aria-hidden="true" tabindex="-1"></a>            <span class="bu">print</span>(<span class="st">&quot;  ACHTUNG: Die Bibliotheken widersprechen sich - &quot;</span></span>
-<span id="cb221-178"><a href="#cb221-178" aria-hidden="true" tabindex="-1"></a>                  <span class="st">&quot;der Zeitvergleich ist wertlos.&quot;</span>)</span>
-<span id="cb221-179"><a href="#cb221-179" aria-hidden="true" tabindex="-1"></a>        <span class="bu">print</span>()</span>
-<span id="cb221-180"><a href="#cb221-180" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb221-181"><a href="#cb221-181" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;=&quot;</span> <span class="op">*</span> <span class="dv">92</span>)</span>
-<span id="cb221-182"><a href="#cb221-182" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;  WAS MAN AUS SO EINER TABELLE ABLESEN DARF - UND WAS NICHT&quot;</span>)</span>
-<span id="cb221-183"><a href="#cb221-183" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;=&quot;</span> <span class="op">*</span> <span class="dv">92</span>)</span>
-<span id="cb221-184"><a href="#cb221-184" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;DARF man ablesen:&quot;</span>)</span>
-<span id="cb221-185"><a href="#cb221-185" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;  * Die Spalte &#39;Anteil&#39; - wie viel der Zeit in den AUFBAU geht statt&quot;</span>)</span>
-<span id="cb221-186"><a href="#cb221-186" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;    ins Loesen. Wenn dort 80 </span><span class="sc">% s</span><span class="st">tehen, ist ein schnellerer Solver die&quot;</span>)</span>
-<span id="cb221-187"><a href="#cb221-187" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;    falsche Antwort; dann gehoert das Modell vektorisiert aufgebaut&quot;</span>)</span>
-<span id="cb221-188"><a href="#cb221-188" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;    (Kapitel Oekosystem).&quot;</span>)</span>
-<span id="cb221-189"><a href="#cb221-189" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;  * Die Groessenordnung des Speicherbedarfs. Sie entscheidet, was auf&quot;</span>)</span>
-<span id="cb221-190"><a href="#cb221-190" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;    einer bestimmten Maschine ueberhaupt laeuft.&quot;</span>)</span>
-<span id="cb221-191"><a href="#cb221-191" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;  * Wie sich beides mit der Groesse ENTWICKELT. Der Trend ist&quot;</span>)</span>
-<span id="cb221-192"><a href="#cb221-192" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;    uebertragbarer als der Absolutwert.&quot;</span>)</span>
-<span id="cb221-193"><a href="#cb221-193" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>()</span>
-<span id="cb221-194"><a href="#cb221-194" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;NICHT ablesen darf man:&quot;</span>)</span>
-<span id="cb221-195"><a href="#cb221-195" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;  * &#39;Bibliothek X ist schneller als Y.&#39; Gemessen wurde EIN&quot;</span>)</span>
-<span id="cb221-196"><a href="#cb221-196" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;    Problemtyp in EINER Formulierung. Ein MILP, ein QP oder eine&quot;</span>)</span>
-<span id="cb221-197"><a href="#cb221-197" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;    andere Modellierung desselben Problems koennen die Reihenfolge&quot;</span>)</span>
-<span id="cb221-198"><a href="#cb221-198" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;    umdrehen.&quot;</span>)</span>
-<span id="cb221-199"><a href="#cb221-199" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;  * Etwas ueber Ihre Maschine. Diese Zahlen stammen von einer&quot;</span>)</span>
-<span id="cb221-200"><a href="#cb221-200" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;    anderen. Der Sinn des Programms ist, dass Sie es auf Ihrer&quot;</span>)</span>
-<span id="cb221-201"><a href="#cb221-201" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;    laufen lassen.&quot;</span>)</span>
-<span id="cb221-202"><a href="#cb221-202" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;=&quot;</span> <span class="op">*</span> <span class="dv">92</span>)</span></code></pre></div>
+<div class="sourceCode" id="cb225"><pre class="sourceCode python"><code class="sourceCode python"><span id="cb225-1"><a href="#cb225-1" aria-hidden="true" tabindex="-1"></a><span class="co">#!/usr/bin/env python3</span></span>
+<span id="cb225-2"><a href="#cb225-2" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb225-3"><a href="#cb225-3" aria-hidden="true" tabindex="-1"></a><span class="co"># Benchmark_Skalierung.py</span></span>
+<span id="cb225-4"><a href="#cb225-4" aria-hidden="true" tabindex="-1"></a><span class="co">&quot;&quot;&quot;</span></span>
+<span id="cb225-5"><a href="#cb225-5" aria-hidden="true" tabindex="-1"></a><span class="co">Kapitel Testen: Ein Vergleich, dem man glauben kann.</span></span>
+<span id="cb225-6"><a href="#cb225-6" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb225-7"><a href="#cb225-7" aria-hidden="true" tabindex="-1"></a><span class="co">Solververgleiche stehen in jedem Blog, und die meisten sind wertlos - nicht</span></span>
+<span id="cb225-8"><a href="#cb225-8" aria-hidden="true" tabindex="-1"></a><span class="co">weil falsch gemessen wurde, sondern weil zu wenig dazugesagt wird. Dieses</span></span>
+<span id="cb225-9"><a href="#cb225-9" aria-hidden="true" tabindex="-1"></a><span class="co">Programm misst dasselbe Transportproblem in drei Groessen mit vier</span></span>
+<span id="cb225-10"><a href="#cb225-10" aria-hidden="true" tabindex="-1"></a><span class="co">Bibliotheken und haelt sich dabei an fuenf Regeln, die den Unterschied machen:</span></span>
+<span id="cb225-11"><a href="#cb225-11" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb225-12"><a href="#cb225-12" aria-hidden="true" tabindex="-1"></a><span class="co">  1. EIGENER PROZESS je Bibliothek. Nicht nur wegen des Importkonflikts</span></span>
+<span id="cb225-13"><a href="#cb225-13" aria-hidden="true" tabindex="-1"></a><span class="co">     zwischen ortools und highspy (Kapitel Oekosystem) - auch, damit der</span></span>
+<span id="cb225-14"><a href="#cb225-14" aria-hidden="true" tabindex="-1"></a><span class="co">     Speicherverbrauch der einen nicht in der Messung der anderen auftaucht.</span></span>
+<span id="cb225-15"><a href="#cb225-15" aria-hidden="true" tabindex="-1"></a><span class="co">  2. AUFBAU UND LOESEN GETRENNT messen. Bei grossen Instanzen ist der Aufbau</span></span>
+<span id="cb225-16"><a href="#cb225-16" aria-hidden="true" tabindex="-1"></a><span class="co">     des Modells in Python regelmaessig teurer als das Loesen. Wer nur die</span></span>
+<span id="cb225-17"><a href="#cb225-17" aria-hidden="true" tabindex="-1"></a><span class="co">     Gesamtzeit misst, optimiert am Ende die falsche Haelfte.</span></span>
+<span id="cb225-18"><a href="#cb225-18" aria-hidden="true" tabindex="-1"></a><span class="co">  3. ZIELWERTE GEGENEINANDER PRUEFEN. Eine Bibliothek, die schneller ist und</span></span>
+<span id="cb225-19"><a href="#cb225-19" aria-hidden="true" tabindex="-1"></a><span class="co">     etwas anderes ausrechnet, hat den Vergleich nicht gewonnen. Diese Pruefung</span></span>
+<span id="cb225-20"><a href="#cb225-20" aria-hidden="true" tabindex="-1"></a><span class="co">     ist der wichtigste Teil des Programms.</span></span>
+<span id="cb225-21"><a href="#cb225-21" aria-hidden="true" tabindex="-1"></a><span class="co">  4. SPEICHER MITMESSEN. Bei 10.000 Variablen entscheidet oft er und nicht die</span></span>
+<span id="cb225-22"><a href="#cb225-22" aria-hidden="true" tabindex="-1"></a><span class="co">     Zeit darueber, was auf einer Maschine noch laeuft.</span></span>
+<span id="cb225-23"><a href="#cb225-23" aria-hidden="true" tabindex="-1"></a><span class="co">  5. DIESELBE INSTANZ fuer alle. Feste Saat, kein Neuwuerfeln zwischendurch.</span></span>
+<span id="cb225-24"><a href="#cb225-24" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb225-25"><a href="#cb225-25" aria-hidden="true" tabindex="-1"></a><span class="co">Und die Einschraenkung, die dazugehoert: Gemessen wird EIN Problemtyp in EINER</span></span>
+<span id="cb225-26"><a href="#cb225-26" aria-hidden="true" tabindex="-1"></a><span class="co">Formulierung auf EINER Maschine. Das Ergebnis ist keine Rangliste der Solver,</span></span>
+<span id="cb225-27"><a href="#cb225-27" aria-hidden="true" tabindex="-1"></a><span class="co">sondern eine Entscheidungshilfe fuer genau diesen Fall. Wer es verallgemeinert,</span></span>
+<span id="cb225-28"><a href="#cb225-28" aria-hidden="true" tabindex="-1"></a><span class="co">macht denselben Fehler wie jemand, der aus einem Backtest auf die Zukunft</span></span>
+<span id="cb225-29"><a href="#cb225-29" aria-hidden="true" tabindex="-1"></a><span class="co">schliesst (Kapitel Handelsmaschine).</span></span>
+<span id="cb225-30"><a href="#cb225-30" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb225-31"><a href="#cb225-31" aria-hidden="true" tabindex="-1"></a><span class="co">Benoetigt: numpy; in den Kindprozessen scipy, highspy, ortools, cvxpy</span></span>
+<span id="cb225-32"><a href="#cb225-32" aria-hidden="true" tabindex="-1"></a><span class="co">&quot;&quot;&quot;</span></span>
+<span id="cb225-33"><a href="#cb225-33" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb225-34"><a href="#cb225-34" aria-hidden="true" tabindex="-1"></a><span class="im">from</span> __future__ <span class="im">import</span> annotations</span>
+<span id="cb225-35"><a href="#cb225-35" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb225-36"><a href="#cb225-36" aria-hidden="true" tabindex="-1"></a><span class="im">import</span> multiprocessing</span>
+<span id="cb225-37"><a href="#cb225-37" aria-hidden="true" tabindex="-1"></a><span class="im">import</span> resource</span>
+<span id="cb225-38"><a href="#cb225-38" aria-hidden="true" tabindex="-1"></a><span class="im">import</span> time</span>
+<span id="cb225-39"><a href="#cb225-39" aria-hidden="true" tabindex="-1"></a><span class="im">from</span> concurrent.futures <span class="im">import</span> ProcessPoolExecutor</span>
+<span id="cb225-40"><a href="#cb225-40" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb225-41"><a href="#cb225-41" aria-hidden="true" tabindex="-1"></a><span class="im">import</span> numpy <span class="im">as</span> np</span>
+<span id="cb225-42"><a href="#cb225-42" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb225-43"><a href="#cb225-43" aria-hidden="true" tabindex="-1"></a>GROESSEN <span class="op">=</span> [(<span class="dv">10</span>, <span class="dv">10</span>), (<span class="dv">32</span>, <span class="dv">32</span>), (<span class="dv">100</span>, <span class="dv">100</span>)]   <span class="co"># (Lager, Kunden) -&gt; 100 / 1.024 / 10.000 Variablen</span></span>
+<span id="cb225-44"><a href="#cb225-44" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb225-45"><a href="#cb225-45" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb225-46"><a href="#cb225-46" aria-hidden="true" tabindex="-1"></a><span class="co"># Instanz und Speichermessung stehen als gewoehnliche Funktionen hier - nicht</span></span>
+<span id="cb225-47"><a href="#cb225-47" aria-hidden="true" tabindex="-1"></a><span class="co"># in einem String, den ein Kindprozess ausfuehrt. Jede Messfunktion baut die</span></span>
+<span id="cb225-48"><a href="#cb225-48" aria-hidden="true" tabindex="-1"></a><span class="co"># Instanz aus derselben Saat neu auf, damit ueber die Prozessgrenze nichts</span></span>
+<span id="cb225-49"><a href="#cb225-49" aria-hidden="true" tabindex="-1"></a><span class="co"># reist, was das Ergebnis verfaelschen koennte.</span></span>
+<span id="cb225-50"><a href="#cb225-50" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb225-51"><a href="#cb225-51" aria-hidden="true" tabindex="-1"></a><span class="kw">def</span> instanz(m: <span class="bu">int</span>, n: <span class="bu">int</span>):</span>
+<span id="cb225-52"><a href="#cb225-52" aria-hidden="true" tabindex="-1"></a>    rng <span class="op">=</span> np.random.default_rng(<span class="dv">20</span>)</span>
+<span id="cb225-53"><a href="#cb225-53" aria-hidden="true" tabindex="-1"></a>    kosten <span class="op">=</span> rng.integers(<span class="dv">5</span>, <span class="dv">95</span>, (m, n)).astype(<span class="bu">float</span>)</span>
+<span id="cb225-54"><a href="#cb225-54" aria-hidden="true" tabindex="-1"></a>    angebot <span class="op">=</span> rng.integers(<span class="dv">50</span>, <span class="dv">150</span>, m).astype(<span class="bu">float</span>)</span>
+<span id="cb225-55"><a href="#cb225-55" aria-hidden="true" tabindex="-1"></a>    bedarf <span class="op">=</span> angebot.<span class="bu">sum</span>() <span class="op">*</span> rng.dirichlet(np.ones(n))</span>
+<span id="cb225-56"><a href="#cb225-56" aria-hidden="true" tabindex="-1"></a>    <span class="cf">return</span> kosten, angebot, bedarf</span>
+<span id="cb225-57"><a href="#cb225-57" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb225-58"><a href="#cb225-58" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb225-59"><a href="#cb225-59" aria-hidden="true" tabindex="-1"></a><span class="kw">def</span> speicher_mb() <span class="op">-&gt;</span> <span class="bu">float</span>:</span>
+<span id="cb225-60"><a href="#cb225-60" aria-hidden="true" tabindex="-1"></a>    <span class="co"># ru_maxrss ist unter Linux in Kilobyte. Gemessen wird der Kindprozess -</span></span>
+<span id="cb225-61"><a href="#cb225-61" aria-hidden="true" tabindex="-1"></a>    <span class="co"># deshalb muss jede Messung einen eigenen bekommen.</span></span>
+<span id="cb225-62"><a href="#cb225-62" aria-hidden="true" tabindex="-1"></a>    <span class="cf">return</span> resource.getrusage(resource.RUSAGE_SELF).ru_maxrss <span class="op">/</span> <span class="dv">1024</span></span>
+<span id="cb225-63"><a href="#cb225-63" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb225-64"><a href="#cb225-64" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb225-65"><a href="#cb225-65" aria-hidden="true" tabindex="-1"></a><span class="kw">def</span> messe_scipy(m: <span class="bu">int</span>, n: <span class="bu">int</span>):</span>
+<span id="cb225-66"><a href="#cb225-66" aria-hidden="true" tabindex="-1"></a>    <span class="im">from</span> scipy.optimize <span class="im">import</span> linprog</span>
+<span id="cb225-67"><a href="#cb225-67" aria-hidden="true" tabindex="-1"></a>    kosten, angebot, bedarf <span class="op">=</span> instanz(m, n)</span>
+<span id="cb225-68"><a href="#cb225-68" aria-hidden="true" tabindex="-1"></a>    t0 <span class="op">=</span> time.perf_counter()</span>
+<span id="cb225-69"><a href="#cb225-69" aria-hidden="true" tabindex="-1"></a>    c <span class="op">=</span> kosten.reshape(<span class="op">-</span><span class="dv">1</span>)</span>
+<span id="cb225-70"><a href="#cb225-70" aria-hidden="true" tabindex="-1"></a>    A_ub <span class="op">=</span> np.zeros((m, m <span class="op">*</span> n))<span class="op">;</span> A_eq <span class="op">=</span> np.zeros((n, m <span class="op">*</span> n))</span>
+<span id="cb225-71"><a href="#cb225-71" aria-hidden="true" tabindex="-1"></a>    <span class="cf">for</span> i <span class="kw">in</span> <span class="bu">range</span>(m):</span>
+<span id="cb225-72"><a href="#cb225-72" aria-hidden="true" tabindex="-1"></a>        A_ub[i, i <span class="op">*</span> n:(i <span class="op">+</span> <span class="dv">1</span>) <span class="op">*</span> n] <span class="op">=</span> <span class="fl">1.0</span></span>
+<span id="cb225-73"><a href="#cb225-73" aria-hidden="true" tabindex="-1"></a>    <span class="cf">for</span> j <span class="kw">in</span> <span class="bu">range</span>(n):</span>
+<span id="cb225-74"><a href="#cb225-74" aria-hidden="true" tabindex="-1"></a>        A_eq[j, j::n] <span class="op">=</span> <span class="fl">1.0</span></span>
+<span id="cb225-75"><a href="#cb225-75" aria-hidden="true" tabindex="-1"></a>    aufbau <span class="op">=</span> time.perf_counter() <span class="op">-</span> t0</span>
+<span id="cb225-76"><a href="#cb225-76" aria-hidden="true" tabindex="-1"></a>    t0 <span class="op">=</span> time.perf_counter()</span>
+<span id="cb225-77"><a href="#cb225-77" aria-hidden="true" tabindex="-1"></a>    r <span class="op">=</span> linprog(c<span class="op">=</span>c, A_ub<span class="op">=</span>A_ub, b_ub<span class="op">=</span>angebot, A_eq<span class="op">=</span>A_eq, b_eq<span class="op">=</span>bedarf,</span>
+<span id="cb225-78"><a href="#cb225-78" aria-hidden="true" tabindex="-1"></a>                bounds<span class="op">=</span>(<span class="dv">0</span>, <span class="va">None</span>), method<span class="op">=</span><span class="st">&quot;highs&quot;</span>)</span>
+<span id="cb225-79"><a href="#cb225-79" aria-hidden="true" tabindex="-1"></a>    loesen <span class="op">=</span> time.perf_counter() <span class="op">-</span> t0</span>
+<span id="cb225-80"><a href="#cb225-80" aria-hidden="true" tabindex="-1"></a>    <span class="cf">return</span> <span class="bu">float</span>(r.fun), aufbau, loesen, speicher_mb()</span>
+<span id="cb225-81"><a href="#cb225-81" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb225-82"><a href="#cb225-82" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb225-83"><a href="#cb225-83" aria-hidden="true" tabindex="-1"></a><span class="kw">def</span> messe_highspy(m: <span class="bu">int</span>, n: <span class="bu">int</span>):</span>
+<span id="cb225-84"><a href="#cb225-84" aria-hidden="true" tabindex="-1"></a>    <span class="im">import</span> highspy</span>
+<span id="cb225-85"><a href="#cb225-85" aria-hidden="true" tabindex="-1"></a>    kosten, angebot, bedarf <span class="op">=</span> instanz(m, n)</span>
+<span id="cb225-86"><a href="#cb225-86" aria-hidden="true" tabindex="-1"></a>    t0 <span class="op">=</span> time.perf_counter()</span>
+<span id="cb225-87"><a href="#cb225-87" aria-hidden="true" tabindex="-1"></a>    h <span class="op">=</span> highspy.Highs()<span class="op">;</span> h.setOptionValue(<span class="st">&quot;output_flag&quot;</span>, <span class="va">False</span>)</span>
+<span id="cb225-88"><a href="#cb225-88" aria-hidden="true" tabindex="-1"></a>    h.addVars(m <span class="op">*</span> n, np.zeros(m <span class="op">*</span> n), np.full(m <span class="op">*</span> n, highspy.kHighsInf))</span>
+<span id="cb225-89"><a href="#cb225-89" aria-hidden="true" tabindex="-1"></a>    <span class="cf">for</span> k <span class="kw">in</span> <span class="bu">range</span>(m <span class="op">*</span> n):</span>
+<span id="cb225-90"><a href="#cb225-90" aria-hidden="true" tabindex="-1"></a>        h.changeColCost(k, <span class="bu">float</span>(kosten.reshape(<span class="op">-</span><span class="dv">1</span>)[k]))</span>
+<span id="cb225-91"><a href="#cb225-91" aria-hidden="true" tabindex="-1"></a>    <span class="cf">for</span> i <span class="kw">in</span> <span class="bu">range</span>(m):</span>
+<span id="cb225-92"><a href="#cb225-92" aria-hidden="true" tabindex="-1"></a>        idx <span class="op">=</span> np.arange(i <span class="op">*</span> n, (i <span class="op">+</span> <span class="dv">1</span>) <span class="op">*</span> n, dtype<span class="op">=</span>np.int32)</span>
+<span id="cb225-93"><a href="#cb225-93" aria-hidden="true" tabindex="-1"></a>        h.addRow(<span class="op">-</span>highspy.kHighsInf, <span class="bu">float</span>(angebot[i]), n, idx, np.ones(n))</span>
+<span id="cb225-94"><a href="#cb225-94" aria-hidden="true" tabindex="-1"></a>    <span class="cf">for</span> j <span class="kw">in</span> <span class="bu">range</span>(n):</span>
+<span id="cb225-95"><a href="#cb225-95" aria-hidden="true" tabindex="-1"></a>        idx <span class="op">=</span> np.arange(j, m <span class="op">*</span> n, n, dtype<span class="op">=</span>np.int32)</span>
+<span id="cb225-96"><a href="#cb225-96" aria-hidden="true" tabindex="-1"></a>        h.addRow(<span class="bu">float</span>(bedarf[j]), <span class="bu">float</span>(bedarf[j]), m, idx, np.ones(m))</span>
+<span id="cb225-97"><a href="#cb225-97" aria-hidden="true" tabindex="-1"></a>    aufbau <span class="op">=</span> time.perf_counter() <span class="op">-</span> t0</span>
+<span id="cb225-98"><a href="#cb225-98" aria-hidden="true" tabindex="-1"></a>    t0 <span class="op">=</span> time.perf_counter()<span class="op">;</span> h.run()<span class="op">;</span> loesen <span class="op">=</span> time.perf_counter() <span class="op">-</span> t0</span>
+<span id="cb225-99"><a href="#cb225-99" aria-hidden="true" tabindex="-1"></a>    <span class="cf">return</span> h.getInfo().objective_function_value, aufbau, loesen, speicher_mb()</span>
+<span id="cb225-100"><a href="#cb225-100" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb225-101"><a href="#cb225-101" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb225-102"><a href="#cb225-102" aria-hidden="true" tabindex="-1"></a><span class="kw">def</span> messe_ortools(m: <span class="bu">int</span>, n: <span class="bu">int</span>):</span>
+<span id="cb225-103"><a href="#cb225-103" aria-hidden="true" tabindex="-1"></a>    <span class="im">from</span> ortools.linear_solver <span class="im">import</span> pywraplp</span>
+<span id="cb225-104"><a href="#cb225-104" aria-hidden="true" tabindex="-1"></a>    kosten, angebot, bedarf <span class="op">=</span> instanz(m, n)</span>
+<span id="cb225-105"><a href="#cb225-105" aria-hidden="true" tabindex="-1"></a>    t0 <span class="op">=</span> time.perf_counter()</span>
+<span id="cb225-106"><a href="#cb225-106" aria-hidden="true" tabindex="-1"></a>    s <span class="op">=</span> pywraplp.Solver.CreateSolver(<span class="st">&quot;GLOP&quot;</span>)</span>
+<span id="cb225-107"><a href="#cb225-107" aria-hidden="true" tabindex="-1"></a>    x <span class="op">=</span> [[s.NumVar(<span class="dv">0</span>, s.infinity(), <span class="ss">f&quot;x</span><span class="sc">{</span>i<span class="sc">}</span><span class="ss">_</span><span class="sc">{</span>j<span class="sc">}</span><span class="ss">&quot;</span>) <span class="cf">for</span> j <span class="kw">in</span> <span class="bu">range</span>(n)]</span>
+<span id="cb225-108"><a href="#cb225-108" aria-hidden="true" tabindex="-1"></a>         <span class="cf">for</span> i <span class="kw">in</span> <span class="bu">range</span>(m)]</span>
+<span id="cb225-109"><a href="#cb225-109" aria-hidden="true" tabindex="-1"></a>    <span class="cf">for</span> i <span class="kw">in</span> <span class="bu">range</span>(m):</span>
+<span id="cb225-110"><a href="#cb225-110" aria-hidden="true" tabindex="-1"></a>        s.Add(<span class="bu">sum</span>(x[i]) <span class="op">&lt;=</span> <span class="bu">float</span>(angebot[i]))</span>
+<span id="cb225-111"><a href="#cb225-111" aria-hidden="true" tabindex="-1"></a>    <span class="cf">for</span> j <span class="kw">in</span> <span class="bu">range</span>(n):</span>
+<span id="cb225-112"><a href="#cb225-112" aria-hidden="true" tabindex="-1"></a>        s.Add(<span class="bu">sum</span>(x[i][j] <span class="cf">for</span> i <span class="kw">in</span> <span class="bu">range</span>(m)) <span class="op">==</span> <span class="bu">float</span>(bedarf[j]))</span>
+<span id="cb225-113"><a href="#cb225-113" aria-hidden="true" tabindex="-1"></a>    s.Minimize(<span class="bu">sum</span>(<span class="bu">float</span>(kosten[i, j]) <span class="op">*</span> x[i][j]</span>
+<span id="cb225-114"><a href="#cb225-114" aria-hidden="true" tabindex="-1"></a>                   <span class="cf">for</span> i <span class="kw">in</span> <span class="bu">range</span>(m) <span class="cf">for</span> j <span class="kw">in</span> <span class="bu">range</span>(n)))</span>
+<span id="cb225-115"><a href="#cb225-115" aria-hidden="true" tabindex="-1"></a>    aufbau <span class="op">=</span> time.perf_counter() <span class="op">-</span> t0</span>
+<span id="cb225-116"><a href="#cb225-116" aria-hidden="true" tabindex="-1"></a>    t0 <span class="op">=</span> time.perf_counter()<span class="op">;</span> s.Solve()<span class="op">;</span> loesen <span class="op">=</span> time.perf_counter() <span class="op">-</span> t0</span>
+<span id="cb225-117"><a href="#cb225-117" aria-hidden="true" tabindex="-1"></a>    <span class="cf">return</span> s.Objective().Value(), aufbau, loesen, speicher_mb()</span>
+<span id="cb225-118"><a href="#cb225-118" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb225-119"><a href="#cb225-119" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb225-120"><a href="#cb225-120" aria-hidden="true" tabindex="-1"></a><span class="kw">def</span> messe_cvxpy(m: <span class="bu">int</span>, n: <span class="bu">int</span>):</span>
+<span id="cb225-121"><a href="#cb225-121" aria-hidden="true" tabindex="-1"></a>    <span class="im">import</span> cvxpy <span class="im">as</span> cp</span>
+<span id="cb225-122"><a href="#cb225-122" aria-hidden="true" tabindex="-1"></a>    kosten, angebot, bedarf <span class="op">=</span> instanz(m, n)</span>
+<span id="cb225-123"><a href="#cb225-123" aria-hidden="true" tabindex="-1"></a>    t0 <span class="op">=</span> time.perf_counter()</span>
+<span id="cb225-124"><a href="#cb225-124" aria-hidden="true" tabindex="-1"></a>    x <span class="op">=</span> cp.Variable((m, n), nonneg<span class="op">=</span><span class="va">True</span>)</span>
+<span id="cb225-125"><a href="#cb225-125" aria-hidden="true" tabindex="-1"></a>    problem <span class="op">=</span> cp.Problem(cp.Minimize(cp.<span class="bu">sum</span>(cp.multiply(kosten, x))),</span>
+<span id="cb225-126"><a href="#cb225-126" aria-hidden="true" tabindex="-1"></a>                         [cp.<span class="bu">sum</span>(x, axis<span class="op">=</span><span class="dv">1</span>) <span class="op">&lt;=</span> angebot,</span>
+<span id="cb225-127"><a href="#cb225-127" aria-hidden="true" tabindex="-1"></a>                          cp.<span class="bu">sum</span>(x, axis<span class="op">=</span><span class="dv">0</span>) <span class="op">==</span> bedarf])</span>
+<span id="cb225-128"><a href="#cb225-128" aria-hidden="true" tabindex="-1"></a>    aufbau <span class="op">=</span> time.perf_counter() <span class="op">-</span> t0</span>
+<span id="cb225-129"><a href="#cb225-129" aria-hidden="true" tabindex="-1"></a>    t0 <span class="op">=</span> time.perf_counter()<span class="op">;</span> problem.solve()<span class="op">;</span> loesen <span class="op">=</span> time.perf_counter() <span class="op">-</span> t0</span>
+<span id="cb225-130"><a href="#cb225-130" aria-hidden="true" tabindex="-1"></a>    <span class="cf">return</span> <span class="bu">float</span>(problem.value), aufbau, loesen, speicher_mb()</span>
+<span id="cb225-131"><a href="#cb225-131" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb225-132"><a href="#cb225-132" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb225-133"><a href="#cb225-133" aria-hidden="true" tabindex="-1"></a>ANSAETZE <span class="op">=</span> {<span class="st">&quot;scipy.linprog&quot;</span>: messe_scipy, <span class="st">&quot;highspy&quot;</span>: messe_highspy,</span>
+<span id="cb225-134"><a href="#cb225-134" aria-hidden="true" tabindex="-1"></a>            <span class="st">&quot;ortools/GLOP&quot;</span>: messe_ortools, <span class="st">&quot;cvxpy&quot;</span>: messe_cvxpy}</span>
+<span id="cb225-135"><a href="#cb225-135" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb225-136"><a href="#cb225-136" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb225-137"><a href="#cb225-137" aria-hidden="true" tabindex="-1"></a><span class="kw">def</span> messe(funktion, m: <span class="bu">int</span>, n: <span class="bu">int</span>):</span>
+<span id="cb225-138"><a href="#cb225-138" aria-hidden="true" tabindex="-1"></a>    <span class="co">&quot;&quot;&quot;Fuehrt eine Messfunktion in einem FRISCHEN Prozess aus.</span></span>
+<span id="cb225-139"><a href="#cb225-139" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb225-140"><a href="#cb225-140" aria-hidden="true" tabindex="-1"></a><span class="co">    &#39;spawn&#39; und max_tasks_per_child=1 zusammen garantieren, was Regel 1</span></span>
+<span id="cb225-141"><a href="#cb225-141" aria-hidden="true" tabindex="-1"></a><span class="co">    verlangt: Jede Messung sieht einen leeren Interpreter. Ohne das</span></span>
+<span id="cb225-142"><a href="#cb225-142" aria-hidden="true" tabindex="-1"></a><span class="co">    zweite wuerde der Pool seinen Arbeiter wiederverwenden - dann waere</span></span>
+<span id="cb225-143"><a href="#cb225-143" aria-hidden="true" tabindex="-1"></a><span class="co">    der Speicherwert der zweiten Bibliothek um die erste zu hoch, und</span></span>
+<span id="cb225-144"><a href="#cb225-144" aria-hidden="true" tabindex="-1"></a><span class="co">    ortools und highspy saessen im selben Prozess.</span></span>
+<span id="cb225-145"><a href="#cb225-145" aria-hidden="true" tabindex="-1"></a><span class="co">    &quot;&quot;&quot;</span></span>
+<span id="cb225-146"><a href="#cb225-146" aria-hidden="true" tabindex="-1"></a>    <span class="cf">with</span> ProcessPoolExecutor(</span>
+<span id="cb225-147"><a href="#cb225-147" aria-hidden="true" tabindex="-1"></a>            max_workers<span class="op">=</span><span class="dv">1</span>,</span>
+<span id="cb225-148"><a href="#cb225-148" aria-hidden="true" tabindex="-1"></a>            mp_context<span class="op">=</span>multiprocessing.get_context(<span class="st">&quot;spawn&quot;</span>),</span>
+<span id="cb225-149"><a href="#cb225-149" aria-hidden="true" tabindex="-1"></a>            max_tasks_per_child<span class="op">=</span><span class="dv">1</span>) <span class="im">as</span> pool:</span>
+<span id="cb225-150"><a href="#cb225-150" aria-hidden="true" tabindex="-1"></a>        <span class="cf">try</span>:</span>
+<span id="cb225-151"><a href="#cb225-151" aria-hidden="true" tabindex="-1"></a>            <span class="cf">return</span> pool.submit(funktion, m, n).result(timeout<span class="op">=</span><span class="dv">600</span>), <span class="va">None</span></span>
+<span id="cb225-152"><a href="#cb225-152" aria-hidden="true" tabindex="-1"></a>        <span class="cf">except</span> <span class="pp">Exception</span> <span class="im">as</span> fehler:</span>
+<span id="cb225-153"><a href="#cb225-153" aria-hidden="true" tabindex="-1"></a>            <span class="cf">return</span> <span class="va">None</span>, <span class="bu">str</span>(fehler).strip().splitlines()[<span class="op">-</span><span class="dv">1</span>][:<span class="dv">60</span>]</span>
+<span id="cb225-154"><a href="#cb225-154" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb225-155"><a href="#cb225-155" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb225-156"><a href="#cb225-156" aria-hidden="true" tabindex="-1"></a><span class="cf">if</span> <span class="va">__name__</span> <span class="op">==</span> <span class="st">&quot;__main__&quot;</span>:</span>
+<span id="cb225-157"><a href="#cb225-157" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;=&quot;</span> <span class="op">*</span> <span class="dv">92</span>)</span>
+<span id="cb225-158"><a href="#cb225-158" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;  SKALIERUNGSVERGLEICH: TRANSPORTPROBLEM, VIER BIBLIOTHEKEN&quot;</span>)</span>
+<span id="cb225-159"><a href="#cb225-159" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;=&quot;</span> <span class="op">*</span> <span class="dv">92</span>)</span>
+<span id="cb225-160"><a href="#cb225-160" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;Jede Zeile ein eigener Prozess. Zeiten und Speicher sind &quot;</span></span>
+<span id="cb225-161"><a href="#cb225-161" aria-hidden="true" tabindex="-1"></a>          <span class="st">&quot;hardwareabhaengig,&quot;</span>)</span>
+<span id="cb225-162"><a href="#cb225-162" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;die Zielwerte und ihr Verhaeltnis zueinander nicht.</span><span class="ch">\n</span><span class="st">&quot;</span>)</span>
+<span id="cb225-163"><a href="#cb225-163" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb225-164"><a href="#cb225-164" aria-hidden="true" tabindex="-1"></a>    <span class="cf">for</span> m, n <span class="kw">in</span> GROESSEN:</span>
+<span id="cb225-165"><a href="#cb225-165" aria-hidden="true" tabindex="-1"></a>        kopf <span class="op">=</span> <span class="ss">f&quot;--- </span><span class="sc">{</span>m<span class="sc">}</span><span class="ss"> Lager x </span><span class="sc">{</span>n<span class="sc">}</span><span class="ss"> Kunden = </span><span class="sc">{</span>m <span class="op">*</span> n<span class="sc">:,}</span><span class="ss"> Variablen &quot;</span></span>
+<span id="cb225-166"><a href="#cb225-166" aria-hidden="true" tabindex="-1"></a>        <span class="bu">print</span>(kopf <span class="op">+</span> <span class="st">&quot;-&quot;</span> <span class="op">*</span> <span class="bu">max</span>(<span class="dv">3</span>, <span class="dv">92</span> <span class="op">-</span> <span class="bu">len</span>(kopf)))</span>
+<span id="cb225-167"><a href="#cb225-167" aria-hidden="true" tabindex="-1"></a>        <span class="bu">print</span>(<span class="ss">f&quot;  </span><span class="sc">{</span><span class="st">&#39;Bibliothek&#39;</span><span class="sc">:&lt;16}</span><span class="ss"> </span><span class="sc">{</span><span class="st">&#39;Zielwert&#39;</span><span class="sc">:&gt;14}</span><span class="ss"> </span><span class="sc">{</span><span class="st">&#39;Aufbau&#39;</span><span class="sc">:&gt;9}</span><span class="ss"> &quot;</span></span>
+<span id="cb225-168"><a href="#cb225-168" aria-hidden="true" tabindex="-1"></a>              <span class="ss">f&quot;</span><span class="sc">{</span><span class="st">&#39;Loesen&#39;</span><span class="sc">:&gt;9}</span><span class="ss"> </span><span class="sc">{</span><span class="st">&#39;Anteil&#39;</span><span class="sc">:&gt;8}</span><span class="ss"> </span><span class="sc">{</span><span class="st">&#39;Speicher&#39;</span><span class="sc">:&gt;10}</span><span class="ss">&quot;</span>)</span>
+<span id="cb225-169"><a href="#cb225-169" aria-hidden="true" tabindex="-1"></a>        <span class="bu">print</span>(<span class="st">&quot;  &quot;</span> <span class="op">+</span> <span class="st">&quot;-&quot;</span> <span class="op">*</span> <span class="dv">72</span>)</span>
+<span id="cb225-170"><a href="#cb225-170" aria-hidden="true" tabindex="-1"></a>        zielwerte <span class="op">=</span> {}</span>
+<span id="cb225-171"><a href="#cb225-171" aria-hidden="true" tabindex="-1"></a>        <span class="cf">for</span> name, funktion <span class="kw">in</span> ANSAETZE.items():</span>
+<span id="cb225-172"><a href="#cb225-172" aria-hidden="true" tabindex="-1"></a>            werte, fehler <span class="op">=</span> messe(funktion, m, n)</span>
+<span id="cb225-173"><a href="#cb225-173" aria-hidden="true" tabindex="-1"></a>            <span class="cf">if</span> werte <span class="kw">is</span> <span class="va">None</span>:</span>
+<span id="cb225-174"><a href="#cb225-174" aria-hidden="true" tabindex="-1"></a>                <span class="bu">print</span>(<span class="ss">f&quot;  </span><span class="sc">{</span>name<span class="sc">:&lt;16}</span><span class="ss"> nicht verfuegbar: </span><span class="sc">{</span>fehler<span class="sc">}</span><span class="ss">&quot;</span>)</span>
+<span id="cb225-175"><a href="#cb225-175" aria-hidden="true" tabindex="-1"></a>                <span class="cf">continue</span></span>
+<span id="cb225-176"><a href="#cb225-176" aria-hidden="true" tabindex="-1"></a>            ziel, aufbau, loesen, speicher <span class="op">=</span> werte</span>
+<span id="cb225-177"><a href="#cb225-177" aria-hidden="true" tabindex="-1"></a>            zielwerte[name] <span class="op">=</span> ziel</span>
+<span id="cb225-178"><a href="#cb225-178" aria-hidden="true" tabindex="-1"></a>            anteil <span class="op">=</span> aufbau <span class="op">/</span> (aufbau <span class="op">+</span> loesen) <span class="op">*</span> <span class="dv">100</span></span>
+<span id="cb225-179"><a href="#cb225-179" aria-hidden="true" tabindex="-1"></a>            <span class="bu">print</span>(<span class="ss">f&quot;  </span><span class="sc">{</span>name<span class="sc">:&lt;16}</span><span class="ss"> </span><span class="sc">{</span>ziel<span class="sc">:&gt;14,.2f}</span><span class="ss"> </span><span class="sc">{</span>aufbau<span class="sc">:&gt;8.3f}</span><span class="ss">s &quot;</span></span>
+<span id="cb225-180"><a href="#cb225-180" aria-hidden="true" tabindex="-1"></a>                  <span class="ss">f&quot;</span><span class="sc">{</span>loesen<span class="sc">:&gt;8.3f}</span><span class="ss">s </span><span class="sc">{</span>anteil<span class="sc">:&gt;7.0f}</span><span class="ss">% </span><span class="sc">{</span>speicher<span class="sc">:&gt;9.0f}</span><span class="ss"> MB&quot;</span>)</span>
+<span id="cb225-181"><a href="#cb225-181" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb225-182"><a href="#cb225-182" aria-hidden="true" tabindex="-1"></a>        <span class="co"># Die wichtigste Zeile: Rechnen alle dasselbe aus?</span></span>
+<span id="cb225-183"><a href="#cb225-183" aria-hidden="true" tabindex="-1"></a>        spanne <span class="op">=</span> <span class="bu">max</span>(zielwerte.values()) <span class="op">-</span> <span class="bu">min</span>(zielwerte.values())</span>
+<span id="cb225-184"><a href="#cb225-184" aria-hidden="true" tabindex="-1"></a>        bezug <span class="op">=</span> <span class="bu">max</span>(<span class="bu">abs</span>(v) <span class="cf">for</span> v <span class="kw">in</span> zielwerte.values())</span>
+<span id="cb225-185"><a href="#cb225-185" aria-hidden="true" tabindex="-1"></a>        <span class="bu">print</span>(<span class="ss">f&quot;  </span><span class="sc">{</span><span class="st">&#39;&#39;</span><span class="sc">:16}</span><span class="ss"> Spannweite der Zielwerte: </span><span class="sc">{</span>spanne<span class="sc">:.2e}</span><span class="ss"> &quot;</span></span>
+<span id="cb225-186"><a href="#cb225-186" aria-hidden="true" tabindex="-1"></a>              <span class="ss">f&quot;(relativ </span><span class="sc">{</span>spanne <span class="op">/</span> bezug<span class="sc">:.1e}</span><span class="ss">)&quot;</span>)</span>
+<span id="cb225-187"><a href="#cb225-187" aria-hidden="true" tabindex="-1"></a>        <span class="cf">if</span> spanne <span class="op">/</span> bezug <span class="op">&gt;</span> <span class="fl">1e-6</span>:</span>
+<span id="cb225-188"><a href="#cb225-188" aria-hidden="true" tabindex="-1"></a>            <span class="bu">print</span>(<span class="st">&quot;  ACHTUNG: Die Bibliotheken widersprechen sich - &quot;</span></span>
+<span id="cb225-189"><a href="#cb225-189" aria-hidden="true" tabindex="-1"></a>                  <span class="st">&quot;der Zeitvergleich ist wertlos.&quot;</span>)</span>
+<span id="cb225-190"><a href="#cb225-190" aria-hidden="true" tabindex="-1"></a>        <span class="bu">print</span>()</span>
+<span id="cb225-191"><a href="#cb225-191" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb225-192"><a href="#cb225-192" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;=&quot;</span> <span class="op">*</span> <span class="dv">92</span>)</span>
+<span id="cb225-193"><a href="#cb225-193" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;  WAS MAN AUS SO EINER TABELLE ABLESEN DARF - UND WAS NICHT&quot;</span>)</span>
+<span id="cb225-194"><a href="#cb225-194" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;=&quot;</span> <span class="op">*</span> <span class="dv">92</span>)</span>
+<span id="cb225-195"><a href="#cb225-195" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;DARF man ablesen:&quot;</span>)</span>
+<span id="cb225-196"><a href="#cb225-196" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;  * Die Spalte &#39;Anteil&#39; - wie viel der Zeit in den AUFBAU geht statt&quot;</span>)</span>
+<span id="cb225-197"><a href="#cb225-197" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;    ins Loesen. Wenn dort 80 </span><span class="sc">% s</span><span class="st">tehen, ist ein schnellerer Solver die&quot;</span>)</span>
+<span id="cb225-198"><a href="#cb225-198" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;    falsche Antwort; dann gehoert das Modell vektorisiert aufgebaut&quot;</span>)</span>
+<span id="cb225-199"><a href="#cb225-199" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;    (Kapitel Oekosystem).&quot;</span>)</span>
+<span id="cb225-200"><a href="#cb225-200" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;  * Die Groessenordnung des Speicherbedarfs. Sie entscheidet, was auf&quot;</span>)</span>
+<span id="cb225-201"><a href="#cb225-201" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;    einer bestimmten Maschine ueberhaupt laeuft.&quot;</span>)</span>
+<span id="cb225-202"><a href="#cb225-202" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;  * Wie sich beides mit der Groesse ENTWICKELT. Der Trend ist&quot;</span>)</span>
+<span id="cb225-203"><a href="#cb225-203" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;    uebertragbarer als der Absolutwert.&quot;</span>)</span>
+<span id="cb225-204"><a href="#cb225-204" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>()</span>
+<span id="cb225-205"><a href="#cb225-205" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;NICHT ablesen darf man:&quot;</span>)</span>
+<span id="cb225-206"><a href="#cb225-206" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;  * &#39;Bibliothek X ist schneller als Y.&#39; Gemessen wurde EIN&quot;</span>)</span>
+<span id="cb225-207"><a href="#cb225-207" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;    Problemtyp in EINER Formulierung. Ein MILP, ein QP oder eine&quot;</span>)</span>
+<span id="cb225-208"><a href="#cb225-208" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;    andere Modellierung desselben Problems koennen die Reihenfolge&quot;</span>)</span>
+<span id="cb225-209"><a href="#cb225-209" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;    umdrehen.&quot;</span>)</span>
+<span id="cb225-210"><a href="#cb225-210" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;  * Etwas ueber Ihre Maschine. Diese Zahlen stammen von einer&quot;</span>)</span>
+<span id="cb225-211"><a href="#cb225-211" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;    anderen. Der Sinn des Programms ist, dass Sie es auf Ihrer&quot;</span>)</span>
+<span id="cb225-212"><a href="#cb225-212" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;    laufen lassen.&quot;</span>)</span>
+<span id="cb225-213"><a href="#cb225-213" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;=&quot;</span> <span class="op">*</span> <span class="dv">92</span>)</span></code></pre></div>
 <p><strong>Erwartete Ausgabe</strong> (Zeiten und Speicher hardwareabhängig, die Zielwerte nicht):</p>
 <pre><code>============================================================================================
   SKALIERUNGSVERGLEICH: TRANSPORTPROBLEM, VIER BIBLIOTHEKEN
@@ -27551,28 +29081,28 @@ die Zielwerte und ihr Verhaeltnis zueinander nicht.
 --- 10 Lager x 10 Kunden = 100 Variablen ---------------------------------------------------
   Bibliothek             Zielwert    Aufbau    Loesen   Anteil   Speicher
   ------------------------------------------------------------------------
-  scipy.linprog         13,509.48    0.000s    0.004s       1%        78 MB
-  highspy               13,509.48    0.001s    0.002s      34%        41 MB
-  ortools/GLOP          13,509.48    0.002s    0.001s      80%        54 MB
+  scipy.linprog         13,509.48    0.000s    0.004s       1%        79 MB
+  highspy               13,509.48    0.001s    0.002s      36%        44 MB
+  ortools/GLOP          13,509.48    0.003s    0.001s      80%        56 MB
   cvxpy                 13,509.48    0.001s    0.009s       9%       229 MB
                    Spannweite der Zielwerte: 1.33e-06 (relativ 9.8e-11)
 
 --- 32 Lager x 32 Kunden = 1,024 Variablen -------------------------------------------------
   Bibliothek             Zielwert    Aufbau    Loesen   Anteil   Speicher
   ------------------------------------------------------------------------
-  scipy.linprog         35,744.25    0.000s    0.009s       4%        80 MB
-  highspy               35,744.25    0.004s    0.005s      47%        42 MB
-  ortools/GLOP          35,744.25    0.015s    0.002s      85%        55 MB
-  cvxpy                 35,744.25    0.001s    0.016s       5%       230 MB
+  scipy.linprog         35,744.25    0.000s    0.009s       3%        81 MB
+  highspy               35,744.25    0.004s    0.005s      44%        45 MB
+  ortools/GLOP          35,744.25    0.014s    0.002s      85%        58 MB
+  cvxpy                 35,744.25    0.001s    0.017s       5%       231 MB
                    Spannweite der Zielwerte: 9.54e-05 (relativ 2.7e-09)
 
 --- 100 Lager x 100 Kunden = 10,000 Variablen ----------------------------------------------
   Bibliothek             Zielwert    Aufbau    Loesen   Anteil   Speicher
   ------------------------------------------------------------------------
-  scipy.linprog         72,220.34    0.002s    0.070s       3%       120 MB
-  highspy               72,220.34    0.029s    0.034s      45%        47 MB
-  ortools/GLOP          72,220.34    0.123s    0.036s      77%        66 MB
-  cvxpy                 72,220.34    0.001s    0.103s       1%       242 MB
+  scipy.linprog         72,220.34    0.004s    0.072s       5%       122 MB
+  highspy               72,220.34    0.026s    0.032s      45%        50 MB
+  ortools/GLOP          72,220.34    0.141s    0.043s      77%        68 MB
+  cvxpy                 72,220.34    0.001s    0.108s       1%       242 MB
                    Spannweite der Zielwerte: 3.65e-04 (relativ 5.0e-09)
 
 ============================================================================================
@@ -27667,321 +29197,321 @@ NICHT ablesen darf man:
 </tr>
 </tbody>
 </table>
-<div class="sourceCode" id="cb223"><pre class="sourceCode python"><code class="sourceCode python"><span id="cb223-1"><a href="#cb223-1" aria-hidden="true" tabindex="-1"></a><span class="co">#!/usr/bin/env python3</span></span>
-<span id="cb223-2"><a href="#cb223-2" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb223-3"><a href="#cb223-3" aria-hidden="true" tabindex="-1"></a><span class="co"># Optimierungsdienst.py</span></span>
-<span id="cb223-4"><a href="#cb223-4" aria-hidden="true" tabindex="-1"></a><span class="co">&quot;&quot;&quot;</span></span>
-<span id="cb223-5"><a href="#cb223-5" aria-hidden="true" tabindex="-1"></a><span class="co">Kapitel Testen: Das Modell als Dienst - und warum es kein normaler Endpunkt ist.</span></span>
-<span id="cb223-6"><a href="#cb223-6" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb223-7"><a href="#cb223-7" aria-hidden="true" tabindex="-1"></a><span class="co">Ein Optimierungsmodell hinter eine HTTP-Schnittstelle zu haengen sieht nach</span></span>
-<span id="cb223-8"><a href="#cb223-8" aria-hidden="true" tabindex="-1"></a><span class="co">einer Fingeruebung aus. Es gibt aber einen Unterschied, der alles bestimmt:</span></span>
-<span id="cb223-9"><a href="#cb223-9" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb223-10"><a href="#cb223-10" aria-hidden="true" tabindex="-1"></a><span class="co">    Eine gewoehnliche Anfrage dauert Millisekunden.</span></span>
-<span id="cb223-11"><a href="#cb223-11" aria-hidden="true" tabindex="-1"></a><span class="co">    Eine Optimierung dauert Sekunden bis Minuten - und manchmal laenger,</span></span>
-<span id="cb223-12"><a href="#cb223-12" aria-hidden="true" tabindex="-1"></a><span class="co">    als jemand warten will.</span></span>
-<span id="cb223-13"><a href="#cb223-13" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb223-14"><a href="#cb223-14" aria-hidden="true" tabindex="-1"></a><span class="co">Damit scheidet die naheliegende Bauform aus. Wer den Solver direkt im</span></span>
-<span id="cb223-15"><a href="#cb223-15" aria-hidden="true" tabindex="-1"></a><span class="co">Request-Handler aufruft, baut einen Dienst, der bei der ersten grossen Instanz</span></span>
-<span id="cb223-16"><a href="#cb223-16" aria-hidden="true" tabindex="-1"></a><span class="co">in einen Timeout des Reverse Proxy laeuft, und bei zehn gleichzeitigen Anfragen</span></span>
-<span id="cb223-17"><a href="#cb223-17" aria-hidden="true" tabindex="-1"></a><span class="co">alle Arbeiter blockiert.</span></span>
-<span id="cb223-18"><a href="#cb223-18" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb223-19"><a href="#cb223-19" aria-hidden="true" tabindex="-1"></a><span class="co">Die tragfaehige Bauform ist deshalb ZWEISTUFIG:</span></span>
-<span id="cb223-20"><a href="#cb223-20" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb223-21"><a href="#cb223-21" aria-hidden="true" tabindex="-1"></a><span class="co">    POST /plaene         nimmt den Auftrag an, prueft ihn, gibt sofort</span></span>
-<span id="cb223-22"><a href="#cb223-22" aria-hidden="true" tabindex="-1"></a><span class="co">                         202 Accepted und eine Auftragsnummer zurueck</span></span>
-<span id="cb223-23"><a href="#cb223-23" aria-hidden="true" tabindex="-1"></a><span class="co">    GET  /plaene/{id}    sagt, wie weit es ist - und liefert am Ende die</span></span>
-<span id="cb223-24"><a href="#cb223-24" aria-hidden="true" tabindex="-1"></a><span class="co">                         Loesung samt Status und Gap</span></span>
-<span id="cb223-25"><a href="#cb223-25" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb223-26"><a href="#cb223-26" aria-hidden="true" tabindex="-1"></a><span class="co">Drei Dinge, die dabei leicht untergehen und hier bewusst sichtbar sind:</span></span>
-<span id="cb223-27"><a href="#cb223-27" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb223-28"><a href="#cb223-28" aria-hidden="true" tabindex="-1"></a><span class="co">  1. Das Domaenenmodell aus or_kern.py ist zugleich das API-Schema. Eine</span></span>
-<span id="cb223-29"><a href="#cb223-29" aria-hidden="true" tabindex="-1"></a><span class="co">     unsinnige Anfrage wird von FastAPI mit 422 abgewiesen, bevor irgendein</span></span>
-<span id="cb223-30"><a href="#cb223-30" aria-hidden="true" tabindex="-1"></a><span class="co">     Solver startet - dieselbe Pruefung wie beim Excel-Import.</span></span>
-<span id="cb223-31"><a href="#cb223-31" aria-hidden="true" tabindex="-1"></a><span class="co">  2. Die Antwort enthaelt STATUS und GAP, nicht nur Zahlen. Ein Aufrufer, der</span></span>
-<span id="cb223-32"><a href="#cb223-32" aria-hidden="true" tabindex="-1"></a><span class="co">     nur die Mengen bekommt, kann nicht unterscheiden, ob er ein bewiesenes</span></span>
-<span id="cb223-33"><a href="#cb223-33" aria-hidden="true" tabindex="-1"></a><span class="co">     Optimum oder einen Zeitlimit-Abbruch in der Hand haelt.</span></span>
-<span id="cb223-34"><a href="#cb223-34" aria-hidden="true" tabindex="-1"></a><span class="co">  3. Jeder Auftrag hat ein ZEITLIMIT. Ohne das belegt eine einzige unguenstige</span></span>
-<span id="cb223-35"><a href="#cb223-35" aria-hidden="true" tabindex="-1"></a><span class="co">     Instanz einen Arbeiter auf unbestimmte Zeit.</span></span>
-<span id="cb223-36"><a href="#cb223-36" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb223-37"><a href="#cb223-37" aria-hidden="true" tabindex="-1"></a><span class="co">Dieses Programm laeuft ohne Server: Der Selbsttest unten benutzt den</span></span>
-<span id="cb223-38"><a href="#cb223-38" aria-hidden="true" tabindex="-1"></a><span class="co">TestClient von FastAPI und spricht die Anwendung direkt an. Fuer den echten</span></span>
-<span id="cb223-39"><a href="#cb223-39" aria-hidden="true" tabindex="-1"></a><span class="co">Betrieb steht am Ende, was sich aendert.</span></span>
-<span id="cb223-40"><a href="#cb223-40" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb223-41"><a href="#cb223-41" aria-hidden="true" tabindex="-1"></a><span class="co">Aufruf:</span></span>
-<span id="cb223-42"><a href="#cb223-42" aria-hidden="true" tabindex="-1"></a><span class="co">    python3 Optimierungsdienst.py          # Selbsttest, kein Server noetig</span></span>
-<span id="cb223-43"><a href="#cb223-43" aria-hidden="true" tabindex="-1"></a><span class="co">    uvicorn Optimierungsdienst:app         # echter Server auf Port 8000</span></span>
-<span id="cb223-44"><a href="#cb223-44" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb223-45"><a href="#cb223-45" aria-hidden="true" tabindex="-1"></a><span class="co">Benoetigt: fastapi, httpx (fuer den Selbsttest), pydantic, ortools (ueber or_kern)</span></span>
-<span id="cb223-46"><a href="#cb223-46" aria-hidden="true" tabindex="-1"></a><span class="co">&quot;&quot;&quot;</span></span>
-<span id="cb223-47"><a href="#cb223-47" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb223-48"><a href="#cb223-48" aria-hidden="true" tabindex="-1"></a><span class="im">from</span> __future__ <span class="im">import</span> annotations</span>
-<span id="cb223-49"><a href="#cb223-49" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb223-50"><a href="#cb223-50" aria-hidden="true" tabindex="-1"></a><span class="im">import</span> time</span>
-<span id="cb223-51"><a href="#cb223-51" aria-hidden="true" tabindex="-1"></a><span class="im">import</span> uuid</span>
-<span id="cb223-52"><a href="#cb223-52" aria-hidden="true" tabindex="-1"></a><span class="im">from</span> concurrent.futures <span class="im">import</span> ThreadPoolExecutor</span>
-<span id="cb223-53"><a href="#cb223-53" aria-hidden="true" tabindex="-1"></a><span class="im">from</span> enum <span class="im">import</span> Enum</span>
-<span id="cb223-54"><a href="#cb223-54" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb223-55"><a href="#cb223-55" aria-hidden="true" tabindex="-1"></a><span class="im">from</span> fastapi <span class="im">import</span> FastAPI, HTTPException</span>
-<span id="cb223-56"><a href="#cb223-56" aria-hidden="true" tabindex="-1"></a><span class="im">from</span> pydantic <span class="im">import</span> BaseModel, Field</span>
-<span id="cb223-57"><a href="#cb223-57" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb223-58"><a href="#cb223-58" aria-hidden="true" tabindex="-1"></a><span class="im">from</span> or_kern <span class="im">import</span> (Loesung, Produktionsproblem, loese_mit_glop,</span>
-<span id="cb223-59"><a href="#cb223-59" aria-hidden="true" tabindex="-1"></a>                     pruefe_loesung)</span>
-<span id="cb223-60"><a href="#cb223-60" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb223-61"><a href="#cb223-61" aria-hidden="true" tabindex="-1"></a>ZEITLIMIT_SEKUNDEN <span class="op">=</span> <span class="fl">30.0</span></span>
-<span id="cb223-62"><a href="#cb223-62" aria-hidden="true" tabindex="-1"></a>ARBEITER <span class="op">=</span> <span class="dv">2</span></span>
-<span id="cb223-63"><a href="#cb223-63" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb223-64"><a href="#cb223-64" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb223-65"><a href="#cb223-65" aria-hidden="true" tabindex="-1"></a><span class="kw">class</span> Auftragsstand(<span class="bu">str</span>, Enum):</span>
-<span id="cb223-66"><a href="#cb223-66" aria-hidden="true" tabindex="-1"></a>    WARTET <span class="op">=</span> <span class="st">&quot;wartet&quot;</span></span>
-<span id="cb223-67"><a href="#cb223-67" aria-hidden="true" tabindex="-1"></a>    LAEUFT <span class="op">=</span> <span class="st">&quot;laeuft&quot;</span></span>
-<span id="cb223-68"><a href="#cb223-68" aria-hidden="true" tabindex="-1"></a>    FERTIG <span class="op">=</span> <span class="st">&quot;fertig&quot;</span></span>
-<span id="cb223-69"><a href="#cb223-69" aria-hidden="true" tabindex="-1"></a>    GESCHEITERT <span class="op">=</span> <span class="st">&quot;gescheitert&quot;</span></span>
-<span id="cb223-70"><a href="#cb223-70" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb223-71"><a href="#cb223-71" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb223-72"><a href="#cb223-72" aria-hidden="true" tabindex="-1"></a><span class="kw">class</span> Auftragsantwort(BaseModel):</span>
-<span id="cb223-73"><a href="#cb223-73" aria-hidden="true" tabindex="-1"></a>    <span class="co">&quot;&quot;&quot;Was der Aufrufer beim Abholen bekommt.</span></span>
-<span id="cb223-74"><a href="#cb223-74" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb223-75"><a href="#cb223-75" aria-hidden="true" tabindex="-1"></a><span class="co">    Bewusst NICHT nur die Mengen: &#39;stand&#39; und die Felder aus &#39;loesung&#39;</span></span>
-<span id="cb223-76"><a href="#cb223-76" aria-hidden="true" tabindex="-1"></a><span class="co">    (Status, Gap) sind der Unterschied zwischen einer Zahl und einer</span></span>
-<span id="cb223-77"><a href="#cb223-77" aria-hidden="true" tabindex="-1"></a><span class="co">    belastbaren Auskunft.</span></span>
-<span id="cb223-78"><a href="#cb223-78" aria-hidden="true" tabindex="-1"></a><span class="co">    &quot;&quot;&quot;</span></span>
-<span id="cb223-79"><a href="#cb223-79" aria-hidden="true" tabindex="-1"></a>    <span class="bu">id</span>: <span class="bu">str</span></span>
-<span id="cb223-80"><a href="#cb223-80" aria-hidden="true" tabindex="-1"></a>    stand: Auftragsstand</span>
-<span id="cb223-81"><a href="#cb223-81" aria-hidden="true" tabindex="-1"></a>    eingegangen: <span class="bu">float</span></span>
-<span id="cb223-82"><a href="#cb223-82" aria-hidden="true" tabindex="-1"></a>    laufzeit: <span class="bu">float</span> <span class="op">|</span> <span class="va">None</span> <span class="op">=</span> <span class="va">None</span></span>
-<span id="cb223-83"><a href="#cb223-83" aria-hidden="true" tabindex="-1"></a>    loesung: Loesung <span class="op">|</span> <span class="va">None</span> <span class="op">=</span> <span class="va">None</span></span>
-<span id="cb223-84"><a href="#cb223-84" aria-hidden="true" tabindex="-1"></a>    beanstandungen: <span class="bu">list</span>[<span class="bu">str</span>] <span class="op">=</span> Field(default_factory<span class="op">=</span><span class="bu">list</span>)</span>
-<span id="cb223-85"><a href="#cb223-85" aria-hidden="true" tabindex="-1"></a>    fehler: <span class="bu">str</span> <span class="op">|</span> <span class="va">None</span> <span class="op">=</span> <span class="va">None</span></span>
-<span id="cb223-86"><a href="#cb223-86" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb223-87"><a href="#cb223-87" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb223-88"><a href="#cb223-88" aria-hidden="true" tabindex="-1"></a>app <span class="op">=</span> FastAPI(title<span class="op">=</span><span class="st">&quot;Optimierungsdienst&quot;</span>,</span>
-<span id="cb223-89"><a href="#cb223-89" aria-hidden="true" tabindex="-1"></a>              summary<span class="op">=</span><span class="st">&quot;Produktionsplanung als Auftrag, nicht als Abfrage&quot;</span>)</span>
-<span id="cb223-90"><a href="#cb223-90" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb223-91"><a href="#cb223-91" aria-hidden="true" tabindex="-1"></a><span class="co"># Fuer das Buchbeispiel: Auftragsbuch im Speicher, Arbeiter im selben Prozess.</span></span>
-<span id="cb223-92"><a href="#cb223-92" aria-hidden="true" tabindex="-1"></a><span class="co"># Was daran im echten Betrieb nicht reicht, steht unten.</span></span>
-<span id="cb223-93"><a href="#cb223-93" aria-hidden="true" tabindex="-1"></a>AUFTRAEGE: <span class="bu">dict</span>[<span class="bu">str</span>, Auftragsantwort] <span class="op">=</span> {}</span>
-<span id="cb223-94"><a href="#cb223-94" aria-hidden="true" tabindex="-1"></a>POOL <span class="op">=</span> ThreadPoolExecutor(max_workers<span class="op">=</span>ARBEITER)</span>
-<span id="cb223-95"><a href="#cb223-95" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb223-96"><a href="#cb223-96" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb223-97"><a href="#cb223-97" aria-hidden="true" tabindex="-1"></a><span class="kw">def</span> rechne(auftrags_id: <span class="bu">str</span>, problem: Produktionsproblem) <span class="op">-&gt;</span> <span class="va">None</span>:</span>
-<span id="cb223-98"><a href="#cb223-98" aria-hidden="true" tabindex="-1"></a>    <span class="co">&quot;&quot;&quot;Laeuft im Arbeiterthread - nie im Request-Handler.&quot;&quot;&quot;</span></span>
-<span id="cb223-99"><a href="#cb223-99" aria-hidden="true" tabindex="-1"></a>    antwort <span class="op">=</span> AUFTRAEGE[auftrags_id]</span>
-<span id="cb223-100"><a href="#cb223-100" aria-hidden="true" tabindex="-1"></a>    antwort.stand <span class="op">=</span> Auftragsstand.LAEUFT</span>
-<span id="cb223-101"><a href="#cb223-101" aria-hidden="true" tabindex="-1"></a>    start <span class="op">=</span> time.perf_counter()</span>
-<span id="cb223-102"><a href="#cb223-102" aria-hidden="true" tabindex="-1"></a>    <span class="cf">try</span>:</span>
-<span id="cb223-103"><a href="#cb223-103" aria-hidden="true" tabindex="-1"></a>        loesung <span class="op">=</span> loese_mit_glop(problem)</span>
-<span id="cb223-104"><a href="#cb223-104" aria-hidden="true" tabindex="-1"></a>        antwort.loesung <span class="op">=</span> loesung</span>
-<span id="cb223-105"><a href="#cb223-105" aria-hidden="true" tabindex="-1"></a>        <span class="co"># Dieselbe Abnahmepruefung wie ueberall sonst. Ein Dienst, der sie</span></span>
-<span id="cb223-106"><a href="#cb223-106" aria-hidden="true" tabindex="-1"></a>        <span class="co"># weglaesst, liefert Fehler schneller aus als ein Mensch sie faende.</span></span>
-<span id="cb223-107"><a href="#cb223-107" aria-hidden="true" tabindex="-1"></a>        antwort.beanstandungen <span class="op">=</span> pruefe_loesung(problem, loesung)</span>
-<span id="cb223-108"><a href="#cb223-108" aria-hidden="true" tabindex="-1"></a>        antwort.stand <span class="op">=</span> (Auftragsstand.FERTIG <span class="cf">if</span> loesung.status.brauchbar</span>
-<span id="cb223-109"><a href="#cb223-109" aria-hidden="true" tabindex="-1"></a>                         <span class="kw">and</span> <span class="kw">not</span> antwort.beanstandungen</span>
-<span id="cb223-110"><a href="#cb223-110" aria-hidden="true" tabindex="-1"></a>                         <span class="cf">else</span> Auftragsstand.GESCHEITERT)</span>
-<span id="cb223-111"><a href="#cb223-111" aria-hidden="true" tabindex="-1"></a>        <span class="cf">if</span> <span class="kw">not</span> loesung.status.brauchbar:</span>
-<span id="cb223-112"><a href="#cb223-112" aria-hidden="true" tabindex="-1"></a>            antwort.fehler <span class="op">=</span> <span class="ss">f&quot;Solverstatus: </span><span class="sc">{</span>loesung<span class="sc">.</span>status<span class="sc">.</span>value<span class="sc">}</span><span class="ss">&quot;</span></span>
-<span id="cb223-113"><a href="#cb223-113" aria-hidden="true" tabindex="-1"></a>        <span class="cf">elif</span> antwort.beanstandungen:</span>
-<span id="cb223-114"><a href="#cb223-114" aria-hidden="true" tabindex="-1"></a>            antwort.fehler <span class="op">=</span> <span class="st">&quot;Abnahmepruefung fehlgeschlagen&quot;</span></span>
-<span id="cb223-115"><a href="#cb223-115" aria-hidden="true" tabindex="-1"></a>    <span class="cf">except</span> <span class="pp">Exception</span> <span class="im">as</span> fehler:                      <span class="co"># noqa: BLE001</span></span>
-<span id="cb223-116"><a href="#cb223-116" aria-hidden="true" tabindex="-1"></a>        antwort.stand <span class="op">=</span> Auftragsstand.GESCHEITERT</span>
-<span id="cb223-117"><a href="#cb223-117" aria-hidden="true" tabindex="-1"></a>        antwort.fehler <span class="op">=</span> <span class="ss">f&quot;</span><span class="sc">{</span><span class="bu">type</span>(fehler)<span class="sc">.</span><span class="va">__name__</span><span class="sc">}</span><span class="ss">: </span><span class="sc">{</span>fehler<span class="sc">}</span><span class="ss">&quot;</span></span>
-<span id="cb223-118"><a href="#cb223-118" aria-hidden="true" tabindex="-1"></a>    <span class="cf">finally</span>:</span>
-<span id="cb223-119"><a href="#cb223-119" aria-hidden="true" tabindex="-1"></a>        antwort.laufzeit <span class="op">=</span> time.perf_counter() <span class="op">-</span> start</span>
-<span id="cb223-120"><a href="#cb223-120" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb223-121"><a href="#cb223-121" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb223-122"><a href="#cb223-122" aria-hidden="true" tabindex="-1"></a><span class="at">@app.post</span>(<span class="st">&quot;/plaene&quot;</span>, status_code<span class="op">=</span><span class="dv">202</span>, response_model<span class="op">=</span>Auftragsantwort)</span>
-<span id="cb223-123"><a href="#cb223-123" aria-hidden="true" tabindex="-1"></a><span class="kw">def</span> auftrag_annehmen(problem: Produktionsproblem) <span class="op">-&gt;</span> Auftragsantwort:</span>
-<span id="cb223-124"><a href="#cb223-124" aria-hidden="true" tabindex="-1"></a>    <span class="co">&quot;&quot;&quot;Nimmt an, prueft, gibt sofort zurueck.</span></span>
-<span id="cb223-125"><a href="#cb223-125" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb223-126"><a href="#cb223-126" aria-hidden="true" tabindex="-1"></a><span class="co">    Der Typ &#39;Produktionsproblem&#39; im Parameter ist der ganze Trick: FastAPI</span></span>
-<span id="cb223-127"><a href="#cb223-127" aria-hidden="true" tabindex="-1"></a><span class="co">    validiert die Anfrage damit gegen das Domaenenmodell und antwortet bei</span></span>
-<span id="cb223-128"><a href="#cb223-128" aria-hidden="true" tabindex="-1"></a><span class="co">    Unsinn mit 422, ohne dass hier eine Zeile Pruefcode steht.</span></span>
-<span id="cb223-129"><a href="#cb223-129" aria-hidden="true" tabindex="-1"></a><span class="co">    &quot;&quot;&quot;</span></span>
-<span id="cb223-130"><a href="#cb223-130" aria-hidden="true" tabindex="-1"></a>    auftrags_id <span class="op">=</span> <span class="bu">str</span>(uuid.uuid4())</span>
-<span id="cb223-131"><a href="#cb223-131" aria-hidden="true" tabindex="-1"></a>    AUFTRAEGE[auftrags_id] <span class="op">=</span> Auftragsantwort(</span>
-<span id="cb223-132"><a href="#cb223-132" aria-hidden="true" tabindex="-1"></a>        <span class="bu">id</span><span class="op">=</span>auftrags_id, stand<span class="op">=</span>Auftragsstand.WARTET, eingegangen<span class="op">=</span>time.time())</span>
-<span id="cb223-133"><a href="#cb223-133" aria-hidden="true" tabindex="-1"></a>    POOL.submit(rechne, auftrags_id, problem)</span>
-<span id="cb223-134"><a href="#cb223-134" aria-hidden="true" tabindex="-1"></a>    <span class="cf">return</span> AUFTRAEGE[auftrags_id]</span>
-<span id="cb223-135"><a href="#cb223-135" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb223-136"><a href="#cb223-136" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb223-137"><a href="#cb223-137" aria-hidden="true" tabindex="-1"></a><span class="at">@app.get</span>(<span class="st">&quot;/plaene/</span><span class="sc">{auftrags_id}</span><span class="st">&quot;</span>, response_model<span class="op">=</span>Auftragsantwort)</span>
-<span id="cb223-138"><a href="#cb223-138" aria-hidden="true" tabindex="-1"></a><span class="kw">def</span> auftrag_abholen(auftrags_id: <span class="bu">str</span>) <span class="op">-&gt;</span> Auftragsantwort:</span>
-<span id="cb223-139"><a href="#cb223-139" aria-hidden="true" tabindex="-1"></a>    <span class="cf">if</span> auftrags_id <span class="kw">not</span> <span class="kw">in</span> AUFTRAEGE:</span>
-<span id="cb223-140"><a href="#cb223-140" aria-hidden="true" tabindex="-1"></a>        <span class="cf">raise</span> HTTPException(status_code<span class="op">=</span><span class="dv">404</span>, detail<span class="op">=</span><span class="st">&quot;Unbekannter Auftrag&quot;</span>)</span>
-<span id="cb223-141"><a href="#cb223-141" aria-hidden="true" tabindex="-1"></a>    <span class="cf">return</span> AUFTRAEGE[auftrags_id]</span>
-<span id="cb223-142"><a href="#cb223-142" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb223-143"><a href="#cb223-143" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb223-144"><a href="#cb223-144" aria-hidden="true" tabindex="-1"></a><span class="at">@app.get</span>(<span class="st">&quot;/gesundheit&quot;</span>)</span>
-<span id="cb223-145"><a href="#cb223-145" aria-hidden="true" tabindex="-1"></a><span class="kw">def</span> gesundheit() <span class="op">-&gt;</span> <span class="bu">dict</span>[<span class="bu">str</span>, <span class="bu">object</span>]:</span>
-<span id="cb223-146"><a href="#cb223-146" aria-hidden="true" tabindex="-1"></a>    <span class="co">&quot;&quot;&quot;Was ein Ueberwachungssystem abfragt - siehe Betriebsueberwachung.py.&quot;&quot;&quot;</span></span>
-<span id="cb223-147"><a href="#cb223-147" aria-hidden="true" tabindex="-1"></a>    offen <span class="op">=</span> <span class="bu">sum</span>(<span class="dv">1</span> <span class="cf">for</span> a <span class="kw">in</span> AUFTRAEGE.values()</span>
-<span id="cb223-148"><a href="#cb223-148" aria-hidden="true" tabindex="-1"></a>                <span class="cf">if</span> a.stand <span class="kw">in</span> (Auftragsstand.WARTET, Auftragsstand.LAEUFT))</span>
-<span id="cb223-149"><a href="#cb223-149" aria-hidden="true" tabindex="-1"></a>    <span class="cf">return</span> {<span class="st">&quot;zustand&quot;</span>: <span class="st">&quot;bereit&quot;</span>, <span class="st">&quot;auftraege_gesamt&quot;</span>: <span class="bu">len</span>(AUFTRAEGE),</span>
-<span id="cb223-150"><a href="#cb223-150" aria-hidden="true" tabindex="-1"></a>            <span class="st">&quot;offen&quot;</span>: offen, <span class="st">&quot;arbeiter&quot;</span>: ARBEITER}</span>
-<span id="cb223-151"><a href="#cb223-151" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb223-152"><a href="#cb223-152" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb223-153"><a href="#cb223-153" aria-hidden="true" tabindex="-1"></a><span class="co"># --- Selbsttest ohne Server -------------------------------------------------</span></span>
-<span id="cb223-154"><a href="#cb223-154" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb223-155"><a href="#cb223-155" aria-hidden="true" tabindex="-1"></a>SCHREINEREI <span class="op">=</span> {</span>
-<span id="cb223-156"><a href="#cb223-156" aria-hidden="true" tabindex="-1"></a>    <span class="st">&quot;produkte&quot;</span>: [</span>
-<span id="cb223-157"><a href="#cb223-157" aria-hidden="true" tabindex="-1"></a>        {<span class="st">&quot;name&quot;</span>: <span class="st">&quot;Tisch&quot;</span>, <span class="st">&quot;deckungsbeitrag&quot;</span>: <span class="fl">240.0</span>,</span>
-<span id="cb223-158"><a href="#cb223-158" aria-hidden="true" tabindex="-1"></a>         <span class="st">&quot;verbrauch&quot;</span>: {<span class="st">&quot;Montagestunden&quot;</span>: <span class="fl">3.0</span>, <span class="st">&quot;Plattenmaterial&quot;</span>: <span class="fl">6.0</span>}},</span>
-<span id="cb223-159"><a href="#cb223-159" aria-hidden="true" tabindex="-1"></a>        {<span class="st">&quot;name&quot;</span>: <span class="st">&quot;Stuhl&quot;</span>, <span class="st">&quot;deckungsbeitrag&quot;</span>: <span class="fl">60.0</span>,</span>
-<span id="cb223-160"><a href="#cb223-160" aria-hidden="true" tabindex="-1"></a>         <span class="st">&quot;verbrauch&quot;</span>: {<span class="st">&quot;Montagestunden&quot;</span>: <span class="fl">1.0</span>, <span class="st">&quot;Plattenmaterial&quot;</span>: <span class="fl">1.0</span>}},</span>
-<span id="cb223-161"><a href="#cb223-161" aria-hidden="true" tabindex="-1"></a>    ],</span>
-<span id="cb223-162"><a href="#cb223-162" aria-hidden="true" tabindex="-1"></a>    <span class="st">&quot;kapazitaeten&quot;</span>: {<span class="st">&quot;Montagestunden&quot;</span>: <span class="fl">150.0</span>, <span class="st">&quot;Plattenmaterial&quot;</span>: <span class="fl">240.0</span>},</span>
-<span id="cb223-163"><a href="#cb223-163" aria-hidden="true" tabindex="-1"></a>}</span>
-<span id="cb223-164"><a href="#cb223-164" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb223-165"><a href="#cb223-165" aria-hidden="true" tabindex="-1"></a>DOCKERFILE <span class="op">=</span> <span class="st">&quot;&quot;&quot;</span><span class="ch">\</span></span>
-<span id="cb223-166"><a href="#cb223-166" aria-hidden="true" tabindex="-1"></a><span class="st">FROM python:3.12-slim</span></span>
-<span id="cb223-167"><a href="#cb223-167" aria-hidden="true" tabindex="-1"></a><span class="st">WORKDIR /app</span></span>
-<span id="cb223-168"><a href="#cb223-168" aria-hidden="true" tabindex="-1"></a><span class="st">COPY requirements.txt .</span></span>
-<span id="cb223-169"><a href="#cb223-169" aria-hidden="true" tabindex="-1"></a><span class="st">RUN pip install --no-cache-dir -r requirements.txt</span></span>
-<span id="cb223-170"><a href="#cb223-170" aria-hidden="true" tabindex="-1"></a><span class="st">COPY or_kern.py Optimierungsdienst.py .</span></span>
-<span id="cb223-171"><a href="#cb223-171" aria-hidden="true" tabindex="-1"></a><span class="st"># Ein Arbeiter je CPU-Kern - der Solver rechnet selbst schon parallel,</span></span>
-<span id="cb223-172"><a href="#cb223-172" aria-hidden="true" tabindex="-1"></a><span class="st"># mehr Prozesse machen ihn nicht schneller, sondern langsamer.</span></span>
-<span id="cb223-173"><a href="#cb223-173" aria-hidden="true" tabindex="-1"></a><span class="st">CMD [&quot;uvicorn&quot;, &quot;Optimierungsdienst:app&quot;, &quot;--host&quot;, &quot;0.0.0.0&quot;, &quot;--port&quot;, &quot;8000&quot;]</span></span>
-<span id="cb223-174"><a href="#cb223-174" aria-hidden="true" tabindex="-1"></a><span class="st">&quot;&quot;&quot;</span></span>
-<span id="cb223-175"><a href="#cb223-175" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb223-176"><a href="#cb223-176" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb223-177"><a href="#cb223-177" aria-hidden="true" tabindex="-1"></a><span class="kw">def</span> warte_auf_ergebnis(klient, auftrags_id: <span class="bu">str</span>, grenze: <span class="bu">float</span> <span class="op">=</span> <span class="fl">30.0</span>) <span class="op">-&gt;</span> <span class="bu">dict</span>:</span>
-<span id="cb223-178"><a href="#cb223-178" aria-hidden="true" tabindex="-1"></a>    ende <span class="op">=</span> time.time() <span class="op">+</span> grenze</span>
-<span id="cb223-179"><a href="#cb223-179" aria-hidden="true" tabindex="-1"></a>    <span class="cf">while</span> time.time() <span class="op">&lt;</span> ende:</span>
-<span id="cb223-180"><a href="#cb223-180" aria-hidden="true" tabindex="-1"></a>        antwort <span class="op">=</span> klient.get(<span class="ss">f&quot;/plaene/</span><span class="sc">{</span>auftrags_id<span class="sc">}</span><span class="ss">&quot;</span>).json()</span>
-<span id="cb223-181"><a href="#cb223-181" aria-hidden="true" tabindex="-1"></a>        <span class="cf">if</span> antwort[<span class="st">&quot;stand&quot;</span>] <span class="kw">in</span> (<span class="st">&quot;fertig&quot;</span>, <span class="st">&quot;gescheitert&quot;</span>):</span>
-<span id="cb223-182"><a href="#cb223-182" aria-hidden="true" tabindex="-1"></a>            <span class="cf">return</span> antwort</span>
-<span id="cb223-183"><a href="#cb223-183" aria-hidden="true" tabindex="-1"></a>        time.sleep(<span class="fl">0.02</span>)</span>
-<span id="cb223-184"><a href="#cb223-184" aria-hidden="true" tabindex="-1"></a>    <span class="cf">raise</span> <span class="pp">TimeoutError</span>(<span class="st">&quot;Auftrag wurde nicht fertig&quot;</span>)</span>
-<span id="cb223-185"><a href="#cb223-185" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb223-186"><a href="#cb223-186" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb223-187"><a href="#cb223-187" aria-hidden="true" tabindex="-1"></a><span class="cf">if</span> <span class="va">__name__</span> <span class="op">==</span> <span class="st">&quot;__main__&quot;</span>:</span>
-<span id="cb223-188"><a href="#cb223-188" aria-hidden="true" tabindex="-1"></a>    <span class="im">from</span> fastapi.testclient <span class="im">import</span> TestClient</span>
-<span id="cb223-189"><a href="#cb223-189" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb223-190"><a href="#cb223-190" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;=&quot;</span> <span class="op">*</span> <span class="dv">80</span>)</span>
-<span id="cb223-191"><a href="#cb223-191" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;  DAS MODELL ALS DIENST&quot;</span>)</span>
-<span id="cb223-192"><a href="#cb223-192" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;=&quot;</span> <span class="op">*</span> <span class="dv">80</span>)</span>
-<span id="cb223-193"><a href="#cb223-193" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb223-194"><a href="#cb223-194" aria-hidden="true" tabindex="-1"></a>    <span class="cf">with</span> TestClient(app) <span class="im">as</span> klient:</span>
-<span id="cb223-195"><a href="#cb223-195" aria-hidden="true" tabindex="-1"></a>        <span class="co"># 1. Gueltiger Auftrag</span></span>
-<span id="cb223-196"><a href="#cb223-196" aria-hidden="true" tabindex="-1"></a>        <span class="bu">print</span>(<span class="st">&quot;</span><span class="ch">\n</span><span class="st">1. Auftrag einreichen&quot;</span>)</span>
-<span id="cb223-197"><a href="#cb223-197" aria-hidden="true" tabindex="-1"></a>        angenommen <span class="op">=</span> klient.post(<span class="st">&quot;/plaene&quot;</span>, json<span class="op">=</span>SCHREINEREI)</span>
-<span id="cb223-198"><a href="#cb223-198" aria-hidden="true" tabindex="-1"></a>        auftrags_id <span class="op">=</span> angenommen.json()[<span class="st">&quot;id&quot;</span>]</span>
-<span id="cb223-199"><a href="#cb223-199" aria-hidden="true" tabindex="-1"></a>        <span class="bu">print</span>(<span class="ss">f&quot;   POST /plaene            -&gt; </span><span class="sc">{</span>angenommen<span class="sc">.</span>status_code<span class="sc">}</span><span class="ss"> &quot;</span></span>
-<span id="cb223-200"><a href="#cb223-200" aria-hidden="true" tabindex="-1"></a>              <span class="ss">f&quot;</span><span class="sc">{</span><span class="st">&#39;Accepted&#39;</span> <span class="cf">if</span> angenommen<span class="sc">.</span>status_code <span class="op">==</span> <span class="dv">202</span> <span class="cf">else</span> <span class="st">&#39;&#39;</span><span class="sc">}</span><span class="ss">&quot;</span>)</span>
-<span id="cb223-201"><a href="#cb223-201" aria-hidden="true" tabindex="-1"></a>        <span class="bu">print</span>(<span class="ss">f&quot;   Auftragsnummer          -&gt; UUID, </span><span class="sc">{</span><span class="bu">len</span>(auftrags_id)<span class="sc">}</span><span class="ss"> Zeichen&quot;</span>)</span>
-<span id="cb223-202"><a href="#cb223-202" aria-hidden="true" tabindex="-1"></a>        <span class="co"># Der entscheidende Punkt, und er ist pruefbar: Die Antwort ist da,</span></span>
-<span id="cb223-203"><a href="#cb223-203" aria-hidden="true" tabindex="-1"></a>        <span class="co"># BEVOR es eine Loesung gibt. Genau dafuer ist 202 gedacht.</span></span>
-<span id="cb223-204"><a href="#cb223-204" aria-hidden="true" tabindex="-1"></a>        <span class="bu">print</span>(<span class="ss">f&quot;   Loesung schon dabei?    -&gt; &quot;</span></span>
-<span id="cb223-205"><a href="#cb223-205" aria-hidden="true" tabindex="-1"></a>              <span class="ss">f&quot;</span><span class="sc">{</span><span class="st">&#39;ja&#39;</span> <span class="cf">if</span> angenommen<span class="sc">.</span>json()[<span class="st">&#39;loesung&#39;</span>] <span class="cf">else</span> <span class="st">&#39;nein - genau so soll es sein&#39;</span><span class="sc">}</span><span class="ss">&quot;</span>)</span>
-<span id="cb223-206"><a href="#cb223-206" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb223-207"><a href="#cb223-207" aria-hidden="true" tabindex="-1"></a>        fertig <span class="op">=</span> warte_auf_ergebnis(klient, auftrags_id)</span>
-<span id="cb223-208"><a href="#cb223-208" aria-hidden="true" tabindex="-1"></a>        loesung <span class="op">=</span> fertig[<span class="st">&quot;loesung&quot;</span>]</span>
-<span id="cb223-209"><a href="#cb223-209" aria-hidden="true" tabindex="-1"></a>        <span class="bu">print</span>(<span class="st">&quot;</span><span class="ch">\n</span><span class="st">2. Ergebnis abholen&quot;</span>)</span>
-<span id="cb223-210"><a href="#cb223-210" aria-hidden="true" tabindex="-1"></a>        <span class="bu">print</span>(<span class="ss">f&quot;   Stand                   -&gt; </span><span class="sc">{</span>fertig[<span class="st">&#39;stand&#39;</span>]<span class="sc">}</span><span class="ss">&quot;</span>)</span>
-<span id="cb223-211"><a href="#cb223-211" aria-hidden="true" tabindex="-1"></a>        <span class="bu">print</span>(<span class="ss">f&quot;   Solverstatus            -&gt; </span><span class="sc">{</span>loesung[<span class="st">&#39;status&#39;</span>]<span class="sc">}</span><span class="ss">&quot;</span>)</span>
-<span id="cb223-212"><a href="#cb223-212" aria-hidden="true" tabindex="-1"></a>        <span class="bu">print</span>(<span class="ss">f&quot;   Zielwert                -&gt; </span><span class="sc">{</span>loesung[<span class="st">&#39;zielwert&#39;</span>]<span class="sc">:,.2f}</span><span class="ss"> EUR&quot;</span>)</span>
-<span id="cb223-213"><a href="#cb223-213" aria-hidden="true" tabindex="-1"></a>        <span class="bu">print</span>(<span class="ss">f&quot;   Mengen                  -&gt; &quot;</span> <span class="op">+</span> <span class="st">&quot;, &quot;</span>.join(</span>
-<span id="cb223-214"><a href="#cb223-214" aria-hidden="true" tabindex="-1"></a>            <span class="ss">f&quot;</span><span class="sc">{</span>name<span class="sc">}</span><span class="ss"> </span><span class="sc">{</span>wert<span class="sc">:.0f}</span><span class="ss">&quot;</span> <span class="cf">for</span> name, wert <span class="kw">in</span> loesung[<span class="st">&quot;werte&quot;</span>].items()))</span>
-<span id="cb223-215"><a href="#cb223-215" aria-hidden="true" tabindex="-1"></a>        <span class="bu">print</span>(<span class="ss">f&quot;   Schattenpreise          -&gt; &quot;</span> <span class="op">+</span> <span class="st">&quot;, &quot;</span>.join(</span>
-<span id="cb223-216"><a href="#cb223-216" aria-hidden="true" tabindex="-1"></a>            <span class="ss">f&quot;</span><span class="sc">{</span>name<span class="sc">}</span><span class="ss"> </span><span class="sc">{</span>wert<span class="sc">:.0f}</span><span class="ss">&quot;</span> <span class="cf">for</span> name, wert <span class="kw">in</span> loesung[<span class="st">&quot;schattenpreise&quot;</span>].items()))</span>
-<span id="cb223-217"><a href="#cb223-217" aria-hidden="true" tabindex="-1"></a>        <span class="bu">print</span>(<span class="ss">f&quot;   Abnahmepruefung         -&gt; &quot;</span></span>
-<span id="cb223-218"><a href="#cb223-218" aria-hidden="true" tabindex="-1"></a>              <span class="ss">f&quot;</span><span class="sc">{</span><span class="st">&#39;bestanden&#39;</span> <span class="cf">if</span> <span class="kw">not</span> fertig[<span class="st">&#39;beanstandungen&#39;</span>] <span class="cf">else</span> fertig[<span class="st">&#39;beanstandungen&#39;</span>]<span class="sc">}</span><span class="ss">&quot;</span>)</span>
-<span id="cb223-219"><a href="#cb223-219" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb223-220"><a href="#cb223-220" aria-hidden="true" tabindex="-1"></a>        <span class="co"># 2. Unsinnige Anfrage - muss abgewiesen werden, BEVOR gerechnet wird</span></span>
-<span id="cb223-221"><a href="#cb223-221" aria-hidden="true" tabindex="-1"></a>        <span class="bu">print</span>(<span class="st">&quot;</span><span class="ch">\n</span><span class="st">3. Unsinnige Anfragen (der Solver startet gar nicht erst)&quot;</span>)</span>
-<span id="cb223-222"><a href="#cb223-222" aria-hidden="true" tabindex="-1"></a>        <span class="cf">for</span> beschreibung, aenderung <span class="kw">in</span> [</span>
-<span id="cb223-223"><a href="#cb223-223" aria-hidden="true" tabindex="-1"></a>                (<span class="st">&quot;Kapazitaet 0&quot;</span>, {<span class="st">&quot;kapazitaeten&quot;</span>: {<span class="st">&quot;Montagestunden&quot;</span>: <span class="fl">0.0</span>}}),</span>
-<span id="cb223-224"><a href="#cb223-224" aria-hidden="true" tabindex="-1"></a>                (<span class="st">&quot;keine Produkte&quot;</span>, {<span class="st">&quot;produkte&quot;</span>: []}),</span>
-<span id="cb223-225"><a href="#cb223-225" aria-hidden="true" tabindex="-1"></a>                (<span class="st">&quot;Ressource ohne Kapazitaet&quot;</span>,</span>
-<span id="cb223-226"><a href="#cb223-226" aria-hidden="true" tabindex="-1"></a>                 {<span class="st">&quot;produkte&quot;</span>: [{<span class="st">&quot;name&quot;</span>: <span class="st">&quot;Regal&quot;</span>, <span class="st">&quot;deckungsbeitrag&quot;</span>: <span class="fl">130.0</span>,</span>
-<span id="cb223-227"><a href="#cb223-227" aria-hidden="true" tabindex="-1"></a>                                <span class="st">&quot;verbrauch&quot;</span>: {<span class="st">&quot;Lackieren&quot;</span>: <span class="fl">2.0</span>}}]})]:</span>
-<span id="cb223-228"><a href="#cb223-228" aria-hidden="true" tabindex="-1"></a>            anfrage <span class="op">=</span> {<span class="op">**</span>SCHREINEREI, <span class="op">**</span>aenderung}</span>
-<span id="cb223-229"><a href="#cb223-229" aria-hidden="true" tabindex="-1"></a>            antwort <span class="op">=</span> klient.post(<span class="st">&quot;/plaene&quot;</span>, json<span class="op">=</span>anfrage)</span>
-<span id="cb223-230"><a href="#cb223-230" aria-hidden="true" tabindex="-1"></a>            <span class="bu">print</span>(<span class="ss">f&quot;   </span><span class="sc">{</span>beschreibung<span class="sc">:&lt;24}</span><span class="ss"> -&gt; </span><span class="sc">{</span>antwort<span class="sc">.</span>status_code<span class="sc">}</span><span class="ss"> &quot;</span></span>
-<span id="cb223-231"><a href="#cb223-231" aria-hidden="true" tabindex="-1"></a>                  <span class="ss">f&quot;</span><span class="sc">{</span><span class="st">&#39;Unprocessable Content&#39;</span> <span class="cf">if</span> antwort<span class="sc">.</span>status_code <span class="op">==</span> <span class="dv">422</span> <span class="cf">else</span> <span class="st">&#39;&#39;</span><span class="sc">}</span><span class="ss">&quot;</span>)</span>
-<span id="cb223-232"><a href="#cb223-232" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb223-233"><a href="#cb223-233" aria-hidden="true" tabindex="-1"></a>        <span class="bu">print</span>(<span class="st">&quot;</span><span class="ch">\n</span><span class="st">4. Unbekannter Auftrag&quot;</span>)</span>
-<span id="cb223-234"><a href="#cb223-234" aria-hidden="true" tabindex="-1"></a>        <span class="bu">print</span>(<span class="ss">f&quot;   GET /plaene/gibtsnicht  -&gt; &quot;</span></span>
-<span id="cb223-235"><a href="#cb223-235" aria-hidden="true" tabindex="-1"></a>              <span class="ss">f&quot;</span><span class="sc">{</span>klient<span class="sc">.</span>get(<span class="st">&#39;/plaene/gibtsnicht&#39;</span>)<span class="sc">.</span>status_code<span class="sc">}</span><span class="ss"> Not Found&quot;</span>)</span>
-<span id="cb223-236"><a href="#cb223-236" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb223-237"><a href="#cb223-237" aria-hidden="true" tabindex="-1"></a>        <span class="bu">print</span>(<span class="st">&quot;</span><span class="ch">\n</span><span class="st">5. Gesundheitsabfrage&quot;</span>)</span>
-<span id="cb223-238"><a href="#cb223-238" aria-hidden="true" tabindex="-1"></a>        <span class="bu">print</span>(<span class="ss">f&quot;   GET /gesundheit         -&gt; </span><span class="sc">{</span>klient<span class="sc">.</span>get(<span class="st">&#39;/gesundheit&#39;</span>)<span class="sc">.</span>json()<span class="sc">}</span><span class="ss">&quot;</span>)</span>
-<span id="cb223-239"><a href="#cb223-239" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb223-240"><a href="#cb223-240" aria-hidden="true" tabindex="-1"></a>    <span class="co"># --- Warum ein Thread je Auftrag genuegt -----------------------------</span></span>
-<span id="cb223-241"><a href="#cb223-241" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;</span><span class="ch">\n</span><span class="st">&quot;</span> <span class="op">+</span> <span class="st">&quot;-&quot;</span> <span class="op">*</span> <span class="dv">80</span>)</span>
-<span id="cb223-242"><a href="#cb223-242" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;6. Warum Threads hier reichen (und wann nicht)</span><span class="ch">\n</span><span class="st">&quot;</span>)</span>
-<span id="cb223-243"><a href="#cb223-243" aria-hidden="true" tabindex="-1"></a>    <span class="im">from</span> concurrent.futures <span class="im">import</span> ThreadPoolExecutor <span class="im">as</span> Pool</span>
-<span id="cb223-244"><a href="#cb223-244" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb223-245"><a href="#cb223-245" aria-hidden="true" tabindex="-1"></a>    <span class="co"># Wichtig: eine Rechnung mit ECHTER Last. Ein Modell, das in zehn</span></span>
-<span id="cb223-246"><a href="#cb223-246" aria-hidden="true" tabindex="-1"></a>    <span class="co"># Millisekunden fertig ist, misst nur den Aufwand fuers Threadstarten -</span></span>
-<span id="cb223-247"><a href="#cb223-247" aria-hidden="true" tabindex="-1"></a>    <span class="co"># der erste Entwurf dieser Messung ist genau daran gescheitert und zeigte</span></span>
-<span id="cb223-248"><a href="#cb223-248" aria-hidden="true" tabindex="-1"></a>    <span class="co"># eine Verlangsamung, wo in Wirklichkeit eine Beschleunigung steht.</span></span>
-<span id="cb223-249"><a href="#cb223-249" aria-hidden="true" tabindex="-1"></a>    <span class="kw">def</span> eine_rechnung() <span class="op">-&gt;</span> <span class="va">None</span>:</span>
-<span id="cb223-250"><a href="#cb223-250" aria-hidden="true" tabindex="-1"></a>        <span class="im">import</span> numpy <span class="im">as</span> np</span>
-<span id="cb223-251"><a href="#cb223-251" aria-hidden="true" tabindex="-1"></a>        <span class="im">from</span> ortools.linear_solver <span class="im">import</span> pywraplp</span>
-<span id="cb223-252"><a href="#cb223-252" aria-hidden="true" tabindex="-1"></a>        rng <span class="op">=</span> np.random.default_rng(<span class="dv">3</span>)</span>
-<span id="cb223-253"><a href="#cb223-253" aria-hidden="true" tabindex="-1"></a>        n <span class="op">=</span> <span class="dv">260</span></span>
-<span id="cb223-254"><a href="#cb223-254" aria-hidden="true" tabindex="-1"></a>        solver <span class="op">=</span> pywraplp.Solver.CreateSolver(<span class="st">&quot;SCIP&quot;</span>)</span>
-<span id="cb223-255"><a href="#cb223-255" aria-hidden="true" tabindex="-1"></a>        x <span class="op">=</span> [solver.IntVar(<span class="dv">0</span>, <span class="dv">1</span>, <span class="ss">f&quot;x</span><span class="sc">{</span>i<span class="sc">}</span><span class="ss">&quot;</span>) <span class="cf">for</span> i <span class="kw">in</span> <span class="bu">range</span>(n)]</span>
-<span id="cb223-256"><a href="#cb223-256" aria-hidden="true" tabindex="-1"></a>        gewicht <span class="op">=</span> rng.integers(<span class="dv">10</span>, <span class="dv">60</span>, n)</span>
-<span id="cb223-257"><a href="#cb223-257" aria-hidden="true" tabindex="-1"></a>        wert <span class="op">=</span> rng.integers(<span class="dv">10</span>, <span class="dv">60</span>, n)</span>
-<span id="cb223-258"><a href="#cb223-258" aria-hidden="true" tabindex="-1"></a>        solver.Add(<span class="bu">sum</span>(<span class="bu">int</span>(gewicht[i]) <span class="op">*</span> x[i] <span class="cf">for</span> i <span class="kw">in</span> <span class="bu">range</span>(n))</span>
-<span id="cb223-259"><a href="#cb223-259" aria-hidden="true" tabindex="-1"></a>                   <span class="op">&lt;=</span> <span class="bu">int</span>(gewicht.<span class="bu">sum</span>() <span class="op">*</span> <span class="fl">0.5</span>))</span>
-<span id="cb223-260"><a href="#cb223-260" aria-hidden="true" tabindex="-1"></a>        <span class="cf">for</span> _ <span class="kw">in</span> <span class="bu">range</span>(<span class="dv">30</span>):</span>
-<span id="cb223-261"><a href="#cb223-261" aria-hidden="true" tabindex="-1"></a>            auswahl <span class="op">=</span> rng.choice(n, <span class="dv">40</span>, replace<span class="op">=</span><span class="va">False</span>)</span>
-<span id="cb223-262"><a href="#cb223-262" aria-hidden="true" tabindex="-1"></a>            solver.Add(<span class="bu">sum</span>(x[<span class="bu">int</span>(i)] <span class="cf">for</span> i <span class="kw">in</span> auswahl) <span class="op">&lt;=</span> <span class="dv">12</span>)</span>
-<span id="cb223-263"><a href="#cb223-263" aria-hidden="true" tabindex="-1"></a>        solver.Maximize(<span class="bu">sum</span>(<span class="bu">int</span>(wert[i]) <span class="op">*</span> x[i] <span class="cf">for</span> i <span class="kw">in</span> <span class="bu">range</span>(n)))</span>
-<span id="cb223-264"><a href="#cb223-264" aria-hidden="true" tabindex="-1"></a>        solver.Solve()</span>
-<span id="cb223-265"><a href="#cb223-265" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb223-266"><a href="#cb223-266" aria-hidden="true" tabindex="-1"></a>    t0 <span class="op">=</span> time.perf_counter()</span>
-<span id="cb223-267"><a href="#cb223-267" aria-hidden="true" tabindex="-1"></a>    <span class="cf">for</span> _ <span class="kw">in</span> <span class="bu">range</span>(<span class="dv">4</span>):</span>
-<span id="cb223-268"><a href="#cb223-268" aria-hidden="true" tabindex="-1"></a>        eine_rechnung()</span>
-<span id="cb223-269"><a href="#cb223-269" aria-hidden="true" tabindex="-1"></a>    seriell <span class="op">=</span> time.perf_counter() <span class="op">-</span> t0</span>
-<span id="cb223-270"><a href="#cb223-270" aria-hidden="true" tabindex="-1"></a>    t0 <span class="op">=</span> time.perf_counter()</span>
-<span id="cb223-271"><a href="#cb223-271" aria-hidden="true" tabindex="-1"></a>    <span class="cf">with</span> Pool(max_workers<span class="op">=</span><span class="dv">4</span>) <span class="im">as</span> p:</span>
-<span id="cb223-272"><a href="#cb223-272" aria-hidden="true" tabindex="-1"></a>        <span class="bu">list</span>(p.<span class="bu">map</span>(<span class="kw">lambda</span> _: eine_rechnung(), <span class="bu">range</span>(<span class="dv">4</span>)))</span>
-<span id="cb223-273"><a href="#cb223-273" aria-hidden="true" tabindex="-1"></a>    parallel <span class="op">=</span> time.perf_counter() <span class="op">-</span> t0</span>
-<span id="cb223-274"><a href="#cb223-274" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb223-275"><a href="#cb223-275" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;   vier Rechnungen nacheinander -&gt; </span><span class="sc">{</span>seriell<span class="sc">:6.2f}</span><span class="ss"> s&quot;</span>)</span>
-<span id="cb223-276"><a href="#cb223-276" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;   vier Rechnungen in Threads   -&gt; </span><span class="sc">{</span>parallel<span class="sc">:6.2f}</span><span class="ss"> s &quot;</span></span>
-<span id="cb223-277"><a href="#cb223-277" aria-hidden="true" tabindex="-1"></a>          <span class="ss">f&quot;(Faktor </span><span class="sc">{</span>seriell <span class="op">/</span> parallel<span class="sc">:.1f}</span><span class="ss">)&quot;</span>)</span>
-<span id="cb223-278"><a href="#cb223-278" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>()</span>
-<span id="cb223-279"><a href="#cb223-279" aria-hidden="true" tabindex="-1"></a>    <span class="cf">if</span> parallel <span class="op">&lt;</span> seriell <span class="op">*</span> <span class="fl">0.75</span>:</span>
-<span id="cb223-280"><a href="#cb223-280" aria-hidden="true" tabindex="-1"></a>        <span class="bu">print</span>(<span class="st">&quot;   Die Laeufe ueberlappen sich. ortools rechnet in C++ und gibt&quot;</span>)</span>
-<span id="cb223-281"><a href="#cb223-281" aria-hidden="true" tabindex="-1"></a>        <span class="bu">print</span>(<span class="st">&quot;   den GIL waehrend Solve() frei - deshalb genuegt hier ein&quot;</span>)</span>
-<span id="cb223-282"><a href="#cb223-282" aria-hidden="true" tabindex="-1"></a>        <span class="bu">print</span>(<span class="st">&quot;   Threadpool, es braucht keine eigenen Prozesse.&quot;</span>)</span>
-<span id="cb223-283"><a href="#cb223-283" aria-hidden="true" tabindex="-1"></a>    <span class="cf">else</span>:</span>
-<span id="cb223-284"><a href="#cb223-284" aria-hidden="true" tabindex="-1"></a>        <span class="bu">print</span>(<span class="st">&quot;   Keine Ueberlappung - hier waeren Prozesse noetig.&quot;</span>)</span>
-<span id="cb223-285"><a href="#cb223-285" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>()</span>
-<span id="cb223-286"><a href="#cb223-286" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;   ACHTUNG, das gilt nicht allgemein: Eine in reinem Python&quot;</span>)</span>
-<span id="cb223-287"><a href="#cb223-287" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;   geschriebene Heuristik (Kapitel Metaheuristiken) haelt den GIL&quot;</span>)</span>
-<span id="cb223-288"><a href="#cb223-288" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;   die ganze Zeit. Fuer sie braucht derselbe Dienst einen&quot;</span>)</span>
-<span id="cb223-289"><a href="#cb223-289" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;   ProcessPoolExecutor statt eines Threadpools.&quot;</span>)</span>
-<span id="cb223-290"><a href="#cb223-290" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb223-291"><a href="#cb223-291" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;</span><span class="ch">\n</span><span class="st">&quot;</span> <span class="op">+</span> <span class="st">&quot;=&quot;</span> <span class="op">*</span> <span class="dv">80</span>)</span>
-<span id="cb223-292"><a href="#cb223-292" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;  WAS SICH IM ECHTEN BETRIEB AENDERT&quot;</span>)</span>
-<span id="cb223-293"><a href="#cb223-293" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;=&quot;</span> <span class="op">*</span> <span class="dv">80</span>)</span>
-<span id="cb223-294"><a href="#cb223-294" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;Dieses Beispiel haelt das Auftragsbuch im Speicher und rechnet in&quot;</span>)</span>
-<span id="cb223-295"><a href="#cb223-295" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;Threads desselben Prozesses. Das reicht zum Zeigen und fuer einen&quot;</span>)</span>
-<span id="cb223-296"><a href="#cb223-296" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;einzelnen Rechner - nicht darueber hinaus:&quot;</span>)</span>
-<span id="cb223-297"><a href="#cb223-297" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>()</span>
-<span id="cb223-298"><a href="#cb223-298" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;  * NEUSTART LOESCHT ALLES. Auftragsbuch in eine Datenbank oder eine&quot;</span>)</span>
-<span id="cb223-299"><a href="#cb223-299" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;    Warteschlange (Redis, RabbitMQ), nicht in ein dict.&quot;</span>)</span>
-<span id="cb223-300"><a href="#cb223-300" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;  * ZWEI INSTANZEN KENNEN EINANDER NICHT. Sobald der Dienst mehr als&quot;</span>)</span>
-<span id="cb223-301"><a href="#cb223-301" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;    einmal laeuft, muss die Warteschlange ausserhalb liegen -&quot;</span>)</span>
-<span id="cb223-302"><a href="#cb223-302" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;    typischerweise Celery mit Redis als Vermittler.&quot;</span>)</span>
-<span id="cb223-303"><a href="#cb223-303" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;  * DIE WAHL THREADS/PROZESSE HAENGT AM SOLVER - siehe die Messung&quot;</span>)</span>
-<span id="cb223-304"><a href="#cb223-304" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;    unter Punkt 6. Sie gehoert gemessen, nicht angenommen.&quot;</span>)</span>
-<span id="cb223-305"><a href="#cb223-305" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;  * OHNE ZEITLIMIT KEIN DIENST. Jede Instanz bekommt eines, und der&quot;</span>)</span>
-<span id="cb223-306"><a href="#cb223-306" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;    Aufrufer erfaehrt im Status, ob es gegriffen hat.&quot;</span>)</span>
-<span id="cb223-307"><a href="#cb223-307" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>()</span>
-<span id="cb223-308"><a href="#cb223-308" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;Das zugehoerige Dockerfile ist kurz genug, um es ganz zu zeigen:&quot;</span>)</span>
-<span id="cb223-309"><a href="#cb223-309" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>()</span>
-<span id="cb223-310"><a href="#cb223-310" aria-hidden="true" tabindex="-1"></a>    <span class="cf">for</span> zeile <span class="kw">in</span> DOCKERFILE.splitlines():</span>
-<span id="cb223-311"><a href="#cb223-311" aria-hidden="true" tabindex="-1"></a>        <span class="bu">print</span>(<span class="ss">f&quot;    </span><span class="sc">{</span>zeile<span class="sc">}</span><span class="ss">&quot;</span>)</span>
-<span id="cb223-312"><a href="#cb223-312" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>()</span>
-<span id="cb223-313"><a href="#cb223-313" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;(Es wird hier nicht gebaut - das Buch setzt keine laufende&quot;</span>)</span>
-<span id="cb223-314"><a href="#cb223-314" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot; Docker-Installation voraus.)&quot;</span>)</span>
-<span id="cb223-315"><a href="#cb223-315" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;=&quot;</span> <span class="op">*</span> <span class="dv">80</span>)</span></code></pre></div>
+<div class="sourceCode" id="cb227"><pre class="sourceCode python"><code class="sourceCode python"><span id="cb227-1"><a href="#cb227-1" aria-hidden="true" tabindex="-1"></a><span class="co">#!/usr/bin/env python3</span></span>
+<span id="cb227-2"><a href="#cb227-2" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb227-3"><a href="#cb227-3" aria-hidden="true" tabindex="-1"></a><span class="co"># Optimierungsdienst.py</span></span>
+<span id="cb227-4"><a href="#cb227-4" aria-hidden="true" tabindex="-1"></a><span class="co">&quot;&quot;&quot;</span></span>
+<span id="cb227-5"><a href="#cb227-5" aria-hidden="true" tabindex="-1"></a><span class="co">Kapitel Testen: Das Modell als Dienst - und warum es kein normaler Endpunkt ist.</span></span>
+<span id="cb227-6"><a href="#cb227-6" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb227-7"><a href="#cb227-7" aria-hidden="true" tabindex="-1"></a><span class="co">Ein Optimierungsmodell hinter eine HTTP-Schnittstelle zu haengen sieht nach</span></span>
+<span id="cb227-8"><a href="#cb227-8" aria-hidden="true" tabindex="-1"></a><span class="co">einer Fingeruebung aus. Es gibt aber einen Unterschied, der alles bestimmt:</span></span>
+<span id="cb227-9"><a href="#cb227-9" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb227-10"><a href="#cb227-10" aria-hidden="true" tabindex="-1"></a><span class="co">    Eine gewoehnliche Anfrage dauert Millisekunden.</span></span>
+<span id="cb227-11"><a href="#cb227-11" aria-hidden="true" tabindex="-1"></a><span class="co">    Eine Optimierung dauert Sekunden bis Minuten - und manchmal laenger,</span></span>
+<span id="cb227-12"><a href="#cb227-12" aria-hidden="true" tabindex="-1"></a><span class="co">    als jemand warten will.</span></span>
+<span id="cb227-13"><a href="#cb227-13" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb227-14"><a href="#cb227-14" aria-hidden="true" tabindex="-1"></a><span class="co">Damit scheidet die naheliegende Bauform aus. Wer den Solver direkt im</span></span>
+<span id="cb227-15"><a href="#cb227-15" aria-hidden="true" tabindex="-1"></a><span class="co">Request-Handler aufruft, baut einen Dienst, der bei der ersten grossen Instanz</span></span>
+<span id="cb227-16"><a href="#cb227-16" aria-hidden="true" tabindex="-1"></a><span class="co">in einen Timeout des Reverse Proxy laeuft, und bei zehn gleichzeitigen Anfragen</span></span>
+<span id="cb227-17"><a href="#cb227-17" aria-hidden="true" tabindex="-1"></a><span class="co">alle Arbeiter blockiert.</span></span>
+<span id="cb227-18"><a href="#cb227-18" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb227-19"><a href="#cb227-19" aria-hidden="true" tabindex="-1"></a><span class="co">Die tragfaehige Bauform ist deshalb ZWEISTUFIG:</span></span>
+<span id="cb227-20"><a href="#cb227-20" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb227-21"><a href="#cb227-21" aria-hidden="true" tabindex="-1"></a><span class="co">    POST /plaene         nimmt den Auftrag an, prueft ihn, gibt sofort</span></span>
+<span id="cb227-22"><a href="#cb227-22" aria-hidden="true" tabindex="-1"></a><span class="co">                         202 Accepted und eine Auftragsnummer zurueck</span></span>
+<span id="cb227-23"><a href="#cb227-23" aria-hidden="true" tabindex="-1"></a><span class="co">    GET  /plaene/{id}    sagt, wie weit es ist - und liefert am Ende die</span></span>
+<span id="cb227-24"><a href="#cb227-24" aria-hidden="true" tabindex="-1"></a><span class="co">                         Loesung samt Status und Gap</span></span>
+<span id="cb227-25"><a href="#cb227-25" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb227-26"><a href="#cb227-26" aria-hidden="true" tabindex="-1"></a><span class="co">Drei Dinge, die dabei leicht untergehen und hier bewusst sichtbar sind:</span></span>
+<span id="cb227-27"><a href="#cb227-27" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb227-28"><a href="#cb227-28" aria-hidden="true" tabindex="-1"></a><span class="co">  1. Das Domaenenmodell aus or_kern.py ist zugleich das API-Schema. Eine</span></span>
+<span id="cb227-29"><a href="#cb227-29" aria-hidden="true" tabindex="-1"></a><span class="co">     unsinnige Anfrage wird von FastAPI mit 422 abgewiesen, bevor irgendein</span></span>
+<span id="cb227-30"><a href="#cb227-30" aria-hidden="true" tabindex="-1"></a><span class="co">     Solver startet - dieselbe Pruefung wie beim Excel-Import.</span></span>
+<span id="cb227-31"><a href="#cb227-31" aria-hidden="true" tabindex="-1"></a><span class="co">  2. Die Antwort enthaelt STATUS und GAP, nicht nur Zahlen. Ein Aufrufer, der</span></span>
+<span id="cb227-32"><a href="#cb227-32" aria-hidden="true" tabindex="-1"></a><span class="co">     nur die Mengen bekommt, kann nicht unterscheiden, ob er ein bewiesenes</span></span>
+<span id="cb227-33"><a href="#cb227-33" aria-hidden="true" tabindex="-1"></a><span class="co">     Optimum oder einen Zeitlimit-Abbruch in der Hand haelt.</span></span>
+<span id="cb227-34"><a href="#cb227-34" aria-hidden="true" tabindex="-1"></a><span class="co">  3. Jeder Auftrag hat ein ZEITLIMIT. Ohne das belegt eine einzige unguenstige</span></span>
+<span id="cb227-35"><a href="#cb227-35" aria-hidden="true" tabindex="-1"></a><span class="co">     Instanz einen Arbeiter auf unbestimmte Zeit.</span></span>
+<span id="cb227-36"><a href="#cb227-36" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb227-37"><a href="#cb227-37" aria-hidden="true" tabindex="-1"></a><span class="co">Dieses Programm laeuft ohne Server: Der Selbsttest unten benutzt den</span></span>
+<span id="cb227-38"><a href="#cb227-38" aria-hidden="true" tabindex="-1"></a><span class="co">TestClient von FastAPI und spricht die Anwendung direkt an. Fuer den echten</span></span>
+<span id="cb227-39"><a href="#cb227-39" aria-hidden="true" tabindex="-1"></a><span class="co">Betrieb steht am Ende, was sich aendert.</span></span>
+<span id="cb227-40"><a href="#cb227-40" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb227-41"><a href="#cb227-41" aria-hidden="true" tabindex="-1"></a><span class="co">Aufruf:</span></span>
+<span id="cb227-42"><a href="#cb227-42" aria-hidden="true" tabindex="-1"></a><span class="co">    python3 Optimierungsdienst.py          # Selbsttest, kein Server noetig</span></span>
+<span id="cb227-43"><a href="#cb227-43" aria-hidden="true" tabindex="-1"></a><span class="co">    uvicorn Optimierungsdienst:app         # echter Server auf Port 8000</span></span>
+<span id="cb227-44"><a href="#cb227-44" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb227-45"><a href="#cb227-45" aria-hidden="true" tabindex="-1"></a><span class="co">Benoetigt: fastapi, httpx (fuer den Selbsttest), pydantic, ortools (ueber or_kern)</span></span>
+<span id="cb227-46"><a href="#cb227-46" aria-hidden="true" tabindex="-1"></a><span class="co">&quot;&quot;&quot;</span></span>
+<span id="cb227-47"><a href="#cb227-47" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb227-48"><a href="#cb227-48" aria-hidden="true" tabindex="-1"></a><span class="im">from</span> __future__ <span class="im">import</span> annotations</span>
+<span id="cb227-49"><a href="#cb227-49" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb227-50"><a href="#cb227-50" aria-hidden="true" tabindex="-1"></a><span class="im">import</span> time</span>
+<span id="cb227-51"><a href="#cb227-51" aria-hidden="true" tabindex="-1"></a><span class="im">import</span> uuid</span>
+<span id="cb227-52"><a href="#cb227-52" aria-hidden="true" tabindex="-1"></a><span class="im">from</span> concurrent.futures <span class="im">import</span> ThreadPoolExecutor</span>
+<span id="cb227-53"><a href="#cb227-53" aria-hidden="true" tabindex="-1"></a><span class="im">from</span> enum <span class="im">import</span> Enum</span>
+<span id="cb227-54"><a href="#cb227-54" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb227-55"><a href="#cb227-55" aria-hidden="true" tabindex="-1"></a><span class="im">from</span> fastapi <span class="im">import</span> FastAPI, HTTPException</span>
+<span id="cb227-56"><a href="#cb227-56" aria-hidden="true" tabindex="-1"></a><span class="im">from</span> pydantic <span class="im">import</span> BaseModel, Field</span>
+<span id="cb227-57"><a href="#cb227-57" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb227-58"><a href="#cb227-58" aria-hidden="true" tabindex="-1"></a><span class="im">from</span> or_kern <span class="im">import</span> (Loesung, Produktionsproblem, loese_mit_glop,</span>
+<span id="cb227-59"><a href="#cb227-59" aria-hidden="true" tabindex="-1"></a>                     pruefe_loesung)</span>
+<span id="cb227-60"><a href="#cb227-60" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb227-61"><a href="#cb227-61" aria-hidden="true" tabindex="-1"></a>ZEITLIMIT_SEKUNDEN <span class="op">=</span> <span class="fl">30.0</span></span>
+<span id="cb227-62"><a href="#cb227-62" aria-hidden="true" tabindex="-1"></a>ARBEITER <span class="op">=</span> <span class="dv">2</span></span>
+<span id="cb227-63"><a href="#cb227-63" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb227-64"><a href="#cb227-64" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb227-65"><a href="#cb227-65" aria-hidden="true" tabindex="-1"></a><span class="kw">class</span> Auftragsstand(<span class="bu">str</span>, Enum):</span>
+<span id="cb227-66"><a href="#cb227-66" aria-hidden="true" tabindex="-1"></a>    WARTET <span class="op">=</span> <span class="st">&quot;wartet&quot;</span></span>
+<span id="cb227-67"><a href="#cb227-67" aria-hidden="true" tabindex="-1"></a>    LAEUFT <span class="op">=</span> <span class="st">&quot;laeuft&quot;</span></span>
+<span id="cb227-68"><a href="#cb227-68" aria-hidden="true" tabindex="-1"></a>    FERTIG <span class="op">=</span> <span class="st">&quot;fertig&quot;</span></span>
+<span id="cb227-69"><a href="#cb227-69" aria-hidden="true" tabindex="-1"></a>    GESCHEITERT <span class="op">=</span> <span class="st">&quot;gescheitert&quot;</span></span>
+<span id="cb227-70"><a href="#cb227-70" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb227-71"><a href="#cb227-71" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb227-72"><a href="#cb227-72" aria-hidden="true" tabindex="-1"></a><span class="kw">class</span> Auftragsantwort(BaseModel):</span>
+<span id="cb227-73"><a href="#cb227-73" aria-hidden="true" tabindex="-1"></a>    <span class="co">&quot;&quot;&quot;Was der Aufrufer beim Abholen bekommt.</span></span>
+<span id="cb227-74"><a href="#cb227-74" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb227-75"><a href="#cb227-75" aria-hidden="true" tabindex="-1"></a><span class="co">    Bewusst NICHT nur die Mengen: &#39;stand&#39; und die Felder aus &#39;loesung&#39;</span></span>
+<span id="cb227-76"><a href="#cb227-76" aria-hidden="true" tabindex="-1"></a><span class="co">    (Status, Gap) sind der Unterschied zwischen einer Zahl und einer</span></span>
+<span id="cb227-77"><a href="#cb227-77" aria-hidden="true" tabindex="-1"></a><span class="co">    belastbaren Auskunft.</span></span>
+<span id="cb227-78"><a href="#cb227-78" aria-hidden="true" tabindex="-1"></a><span class="co">    &quot;&quot;&quot;</span></span>
+<span id="cb227-79"><a href="#cb227-79" aria-hidden="true" tabindex="-1"></a>    <span class="bu">id</span>: <span class="bu">str</span></span>
+<span id="cb227-80"><a href="#cb227-80" aria-hidden="true" tabindex="-1"></a>    stand: Auftragsstand</span>
+<span id="cb227-81"><a href="#cb227-81" aria-hidden="true" tabindex="-1"></a>    eingegangen: <span class="bu">float</span></span>
+<span id="cb227-82"><a href="#cb227-82" aria-hidden="true" tabindex="-1"></a>    laufzeit: <span class="bu">float</span> <span class="op">|</span> <span class="va">None</span> <span class="op">=</span> <span class="va">None</span></span>
+<span id="cb227-83"><a href="#cb227-83" aria-hidden="true" tabindex="-1"></a>    loesung: Loesung <span class="op">|</span> <span class="va">None</span> <span class="op">=</span> <span class="va">None</span></span>
+<span id="cb227-84"><a href="#cb227-84" aria-hidden="true" tabindex="-1"></a>    beanstandungen: <span class="bu">list</span>[<span class="bu">str</span>] <span class="op">=</span> Field(default_factory<span class="op">=</span><span class="bu">list</span>)</span>
+<span id="cb227-85"><a href="#cb227-85" aria-hidden="true" tabindex="-1"></a>    fehler: <span class="bu">str</span> <span class="op">|</span> <span class="va">None</span> <span class="op">=</span> <span class="va">None</span></span>
+<span id="cb227-86"><a href="#cb227-86" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb227-87"><a href="#cb227-87" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb227-88"><a href="#cb227-88" aria-hidden="true" tabindex="-1"></a>app <span class="op">=</span> FastAPI(title<span class="op">=</span><span class="st">&quot;Optimierungsdienst&quot;</span>,</span>
+<span id="cb227-89"><a href="#cb227-89" aria-hidden="true" tabindex="-1"></a>              summary<span class="op">=</span><span class="st">&quot;Produktionsplanung als Auftrag, nicht als Abfrage&quot;</span>)</span>
+<span id="cb227-90"><a href="#cb227-90" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb227-91"><a href="#cb227-91" aria-hidden="true" tabindex="-1"></a><span class="co"># Fuer das Buchbeispiel: Auftragsbuch im Speicher, Arbeiter im selben Prozess.</span></span>
+<span id="cb227-92"><a href="#cb227-92" aria-hidden="true" tabindex="-1"></a><span class="co"># Was daran im echten Betrieb nicht reicht, steht unten.</span></span>
+<span id="cb227-93"><a href="#cb227-93" aria-hidden="true" tabindex="-1"></a>AUFTRAEGE: <span class="bu">dict</span>[<span class="bu">str</span>, Auftragsantwort] <span class="op">=</span> {}</span>
+<span id="cb227-94"><a href="#cb227-94" aria-hidden="true" tabindex="-1"></a>POOL <span class="op">=</span> ThreadPoolExecutor(max_workers<span class="op">=</span>ARBEITER)</span>
+<span id="cb227-95"><a href="#cb227-95" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb227-96"><a href="#cb227-96" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb227-97"><a href="#cb227-97" aria-hidden="true" tabindex="-1"></a><span class="kw">def</span> rechne(auftrags_id: <span class="bu">str</span>, problem: Produktionsproblem) <span class="op">-&gt;</span> <span class="va">None</span>:</span>
+<span id="cb227-98"><a href="#cb227-98" aria-hidden="true" tabindex="-1"></a>    <span class="co">&quot;&quot;&quot;Laeuft im Arbeiterthread - nie im Request-Handler.&quot;&quot;&quot;</span></span>
+<span id="cb227-99"><a href="#cb227-99" aria-hidden="true" tabindex="-1"></a>    antwort <span class="op">=</span> AUFTRAEGE[auftrags_id]</span>
+<span id="cb227-100"><a href="#cb227-100" aria-hidden="true" tabindex="-1"></a>    antwort.stand <span class="op">=</span> Auftragsstand.LAEUFT</span>
+<span id="cb227-101"><a href="#cb227-101" aria-hidden="true" tabindex="-1"></a>    start <span class="op">=</span> time.perf_counter()</span>
+<span id="cb227-102"><a href="#cb227-102" aria-hidden="true" tabindex="-1"></a>    <span class="cf">try</span>:</span>
+<span id="cb227-103"><a href="#cb227-103" aria-hidden="true" tabindex="-1"></a>        loesung <span class="op">=</span> loese_mit_glop(problem)</span>
+<span id="cb227-104"><a href="#cb227-104" aria-hidden="true" tabindex="-1"></a>        antwort.loesung <span class="op">=</span> loesung</span>
+<span id="cb227-105"><a href="#cb227-105" aria-hidden="true" tabindex="-1"></a>        <span class="co"># Dieselbe Abnahmepruefung wie ueberall sonst. Ein Dienst, der sie</span></span>
+<span id="cb227-106"><a href="#cb227-106" aria-hidden="true" tabindex="-1"></a>        <span class="co"># weglaesst, liefert Fehler schneller aus als ein Mensch sie faende.</span></span>
+<span id="cb227-107"><a href="#cb227-107" aria-hidden="true" tabindex="-1"></a>        antwort.beanstandungen <span class="op">=</span> pruefe_loesung(problem, loesung)</span>
+<span id="cb227-108"><a href="#cb227-108" aria-hidden="true" tabindex="-1"></a>        antwort.stand <span class="op">=</span> (Auftragsstand.FERTIG <span class="cf">if</span> loesung.status.brauchbar</span>
+<span id="cb227-109"><a href="#cb227-109" aria-hidden="true" tabindex="-1"></a>                         <span class="kw">and</span> <span class="kw">not</span> antwort.beanstandungen</span>
+<span id="cb227-110"><a href="#cb227-110" aria-hidden="true" tabindex="-1"></a>                         <span class="cf">else</span> Auftragsstand.GESCHEITERT)</span>
+<span id="cb227-111"><a href="#cb227-111" aria-hidden="true" tabindex="-1"></a>        <span class="cf">if</span> <span class="kw">not</span> loesung.status.brauchbar:</span>
+<span id="cb227-112"><a href="#cb227-112" aria-hidden="true" tabindex="-1"></a>            antwort.fehler <span class="op">=</span> <span class="ss">f&quot;Solverstatus: </span><span class="sc">{</span>loesung<span class="sc">.</span>status<span class="sc">.</span>value<span class="sc">}</span><span class="ss">&quot;</span></span>
+<span id="cb227-113"><a href="#cb227-113" aria-hidden="true" tabindex="-1"></a>        <span class="cf">elif</span> antwort.beanstandungen:</span>
+<span id="cb227-114"><a href="#cb227-114" aria-hidden="true" tabindex="-1"></a>            antwort.fehler <span class="op">=</span> <span class="st">&quot;Abnahmepruefung fehlgeschlagen&quot;</span></span>
+<span id="cb227-115"><a href="#cb227-115" aria-hidden="true" tabindex="-1"></a>    <span class="cf">except</span> <span class="pp">Exception</span> <span class="im">as</span> fehler:                      <span class="co"># noqa: BLE001</span></span>
+<span id="cb227-116"><a href="#cb227-116" aria-hidden="true" tabindex="-1"></a>        antwort.stand <span class="op">=</span> Auftragsstand.GESCHEITERT</span>
+<span id="cb227-117"><a href="#cb227-117" aria-hidden="true" tabindex="-1"></a>        antwort.fehler <span class="op">=</span> <span class="ss">f&quot;</span><span class="sc">{</span><span class="bu">type</span>(fehler)<span class="sc">.</span><span class="va">__name__</span><span class="sc">}</span><span class="ss">: </span><span class="sc">{</span>fehler<span class="sc">}</span><span class="ss">&quot;</span></span>
+<span id="cb227-118"><a href="#cb227-118" aria-hidden="true" tabindex="-1"></a>    <span class="cf">finally</span>:</span>
+<span id="cb227-119"><a href="#cb227-119" aria-hidden="true" tabindex="-1"></a>        antwort.laufzeit <span class="op">=</span> time.perf_counter() <span class="op">-</span> start</span>
+<span id="cb227-120"><a href="#cb227-120" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb227-121"><a href="#cb227-121" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb227-122"><a href="#cb227-122" aria-hidden="true" tabindex="-1"></a><span class="at">@app.post</span>(<span class="st">&quot;/plaene&quot;</span>, status_code<span class="op">=</span><span class="dv">202</span>, response_model<span class="op">=</span>Auftragsantwort)</span>
+<span id="cb227-123"><a href="#cb227-123" aria-hidden="true" tabindex="-1"></a><span class="kw">def</span> auftrag_annehmen(problem: Produktionsproblem) <span class="op">-&gt;</span> Auftragsantwort:</span>
+<span id="cb227-124"><a href="#cb227-124" aria-hidden="true" tabindex="-1"></a>    <span class="co">&quot;&quot;&quot;Nimmt an, prueft, gibt sofort zurueck.</span></span>
+<span id="cb227-125"><a href="#cb227-125" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb227-126"><a href="#cb227-126" aria-hidden="true" tabindex="-1"></a><span class="co">    Der Typ &#39;Produktionsproblem&#39; im Parameter ist der ganze Trick: FastAPI</span></span>
+<span id="cb227-127"><a href="#cb227-127" aria-hidden="true" tabindex="-1"></a><span class="co">    validiert die Anfrage damit gegen das Domaenenmodell und antwortet bei</span></span>
+<span id="cb227-128"><a href="#cb227-128" aria-hidden="true" tabindex="-1"></a><span class="co">    Unsinn mit 422, ohne dass hier eine Zeile Pruefcode steht.</span></span>
+<span id="cb227-129"><a href="#cb227-129" aria-hidden="true" tabindex="-1"></a><span class="co">    &quot;&quot;&quot;</span></span>
+<span id="cb227-130"><a href="#cb227-130" aria-hidden="true" tabindex="-1"></a>    auftrags_id <span class="op">=</span> <span class="bu">str</span>(uuid.uuid4())</span>
+<span id="cb227-131"><a href="#cb227-131" aria-hidden="true" tabindex="-1"></a>    AUFTRAEGE[auftrags_id] <span class="op">=</span> Auftragsantwort(</span>
+<span id="cb227-132"><a href="#cb227-132" aria-hidden="true" tabindex="-1"></a>        <span class="bu">id</span><span class="op">=</span>auftrags_id, stand<span class="op">=</span>Auftragsstand.WARTET, eingegangen<span class="op">=</span>time.time())</span>
+<span id="cb227-133"><a href="#cb227-133" aria-hidden="true" tabindex="-1"></a>    POOL.submit(rechne, auftrags_id, problem)</span>
+<span id="cb227-134"><a href="#cb227-134" aria-hidden="true" tabindex="-1"></a>    <span class="cf">return</span> AUFTRAEGE[auftrags_id]</span>
+<span id="cb227-135"><a href="#cb227-135" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb227-136"><a href="#cb227-136" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb227-137"><a href="#cb227-137" aria-hidden="true" tabindex="-1"></a><span class="at">@app.get</span>(<span class="st">&quot;/plaene/</span><span class="sc">{auftrags_id}</span><span class="st">&quot;</span>, response_model<span class="op">=</span>Auftragsantwort)</span>
+<span id="cb227-138"><a href="#cb227-138" aria-hidden="true" tabindex="-1"></a><span class="kw">def</span> auftrag_abholen(auftrags_id: <span class="bu">str</span>) <span class="op">-&gt;</span> Auftragsantwort:</span>
+<span id="cb227-139"><a href="#cb227-139" aria-hidden="true" tabindex="-1"></a>    <span class="cf">if</span> auftrags_id <span class="kw">not</span> <span class="kw">in</span> AUFTRAEGE:</span>
+<span id="cb227-140"><a href="#cb227-140" aria-hidden="true" tabindex="-1"></a>        <span class="cf">raise</span> HTTPException(status_code<span class="op">=</span><span class="dv">404</span>, detail<span class="op">=</span><span class="st">&quot;Unbekannter Auftrag&quot;</span>)</span>
+<span id="cb227-141"><a href="#cb227-141" aria-hidden="true" tabindex="-1"></a>    <span class="cf">return</span> AUFTRAEGE[auftrags_id]</span>
+<span id="cb227-142"><a href="#cb227-142" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb227-143"><a href="#cb227-143" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb227-144"><a href="#cb227-144" aria-hidden="true" tabindex="-1"></a><span class="at">@app.get</span>(<span class="st">&quot;/gesundheit&quot;</span>)</span>
+<span id="cb227-145"><a href="#cb227-145" aria-hidden="true" tabindex="-1"></a><span class="kw">def</span> gesundheit() <span class="op">-&gt;</span> <span class="bu">dict</span>[<span class="bu">str</span>, <span class="bu">object</span>]:</span>
+<span id="cb227-146"><a href="#cb227-146" aria-hidden="true" tabindex="-1"></a>    <span class="co">&quot;&quot;&quot;Was ein Ueberwachungssystem abfragt - siehe Betriebsueberwachung.py.&quot;&quot;&quot;</span></span>
+<span id="cb227-147"><a href="#cb227-147" aria-hidden="true" tabindex="-1"></a>    offen <span class="op">=</span> <span class="bu">sum</span>(<span class="dv">1</span> <span class="cf">for</span> a <span class="kw">in</span> AUFTRAEGE.values()</span>
+<span id="cb227-148"><a href="#cb227-148" aria-hidden="true" tabindex="-1"></a>                <span class="cf">if</span> a.stand <span class="kw">in</span> (Auftragsstand.WARTET, Auftragsstand.LAEUFT))</span>
+<span id="cb227-149"><a href="#cb227-149" aria-hidden="true" tabindex="-1"></a>    <span class="cf">return</span> {<span class="st">&quot;zustand&quot;</span>: <span class="st">&quot;bereit&quot;</span>, <span class="st">&quot;auftraege_gesamt&quot;</span>: <span class="bu">len</span>(AUFTRAEGE),</span>
+<span id="cb227-150"><a href="#cb227-150" aria-hidden="true" tabindex="-1"></a>            <span class="st">&quot;offen&quot;</span>: offen, <span class="st">&quot;arbeiter&quot;</span>: ARBEITER}</span>
+<span id="cb227-151"><a href="#cb227-151" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb227-152"><a href="#cb227-152" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb227-153"><a href="#cb227-153" aria-hidden="true" tabindex="-1"></a><span class="co"># --- Selbsttest ohne Server -------------------------------------------------</span></span>
+<span id="cb227-154"><a href="#cb227-154" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb227-155"><a href="#cb227-155" aria-hidden="true" tabindex="-1"></a>SCHREINEREI <span class="op">=</span> {</span>
+<span id="cb227-156"><a href="#cb227-156" aria-hidden="true" tabindex="-1"></a>    <span class="st">&quot;produkte&quot;</span>: [</span>
+<span id="cb227-157"><a href="#cb227-157" aria-hidden="true" tabindex="-1"></a>        {<span class="st">&quot;name&quot;</span>: <span class="st">&quot;Tisch&quot;</span>, <span class="st">&quot;deckungsbeitrag&quot;</span>: <span class="fl">240.0</span>,</span>
+<span id="cb227-158"><a href="#cb227-158" aria-hidden="true" tabindex="-1"></a>         <span class="st">&quot;verbrauch&quot;</span>: {<span class="st">&quot;Montagestunden&quot;</span>: <span class="fl">3.0</span>, <span class="st">&quot;Plattenmaterial&quot;</span>: <span class="fl">6.0</span>}},</span>
+<span id="cb227-159"><a href="#cb227-159" aria-hidden="true" tabindex="-1"></a>        {<span class="st">&quot;name&quot;</span>: <span class="st">&quot;Stuhl&quot;</span>, <span class="st">&quot;deckungsbeitrag&quot;</span>: <span class="fl">60.0</span>,</span>
+<span id="cb227-160"><a href="#cb227-160" aria-hidden="true" tabindex="-1"></a>         <span class="st">&quot;verbrauch&quot;</span>: {<span class="st">&quot;Montagestunden&quot;</span>: <span class="fl">1.0</span>, <span class="st">&quot;Plattenmaterial&quot;</span>: <span class="fl">1.0</span>}},</span>
+<span id="cb227-161"><a href="#cb227-161" aria-hidden="true" tabindex="-1"></a>    ],</span>
+<span id="cb227-162"><a href="#cb227-162" aria-hidden="true" tabindex="-1"></a>    <span class="st">&quot;kapazitaeten&quot;</span>: {<span class="st">&quot;Montagestunden&quot;</span>: <span class="fl">150.0</span>, <span class="st">&quot;Plattenmaterial&quot;</span>: <span class="fl">240.0</span>},</span>
+<span id="cb227-163"><a href="#cb227-163" aria-hidden="true" tabindex="-1"></a>}</span>
+<span id="cb227-164"><a href="#cb227-164" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb227-165"><a href="#cb227-165" aria-hidden="true" tabindex="-1"></a>DOCKERFILE <span class="op">=</span> <span class="st">&quot;&quot;&quot;</span><span class="ch">\</span></span>
+<span id="cb227-166"><a href="#cb227-166" aria-hidden="true" tabindex="-1"></a><span class="st">FROM python:3.12-slim</span></span>
+<span id="cb227-167"><a href="#cb227-167" aria-hidden="true" tabindex="-1"></a><span class="st">WORKDIR /app</span></span>
+<span id="cb227-168"><a href="#cb227-168" aria-hidden="true" tabindex="-1"></a><span class="st">COPY requirements.txt .</span></span>
+<span id="cb227-169"><a href="#cb227-169" aria-hidden="true" tabindex="-1"></a><span class="st">RUN pip install --no-cache-dir -r requirements.txt</span></span>
+<span id="cb227-170"><a href="#cb227-170" aria-hidden="true" tabindex="-1"></a><span class="st">COPY or_kern.py Optimierungsdienst.py .</span></span>
+<span id="cb227-171"><a href="#cb227-171" aria-hidden="true" tabindex="-1"></a><span class="st"># Ein Arbeiter je CPU-Kern - der Solver rechnet selbst schon parallel,</span></span>
+<span id="cb227-172"><a href="#cb227-172" aria-hidden="true" tabindex="-1"></a><span class="st"># mehr Prozesse machen ihn nicht schneller, sondern langsamer.</span></span>
+<span id="cb227-173"><a href="#cb227-173" aria-hidden="true" tabindex="-1"></a><span class="st">CMD [&quot;uvicorn&quot;, &quot;Optimierungsdienst:app&quot;, &quot;--host&quot;, &quot;0.0.0.0&quot;, &quot;--port&quot;, &quot;8000&quot;]</span></span>
+<span id="cb227-174"><a href="#cb227-174" aria-hidden="true" tabindex="-1"></a><span class="st">&quot;&quot;&quot;</span></span>
+<span id="cb227-175"><a href="#cb227-175" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb227-176"><a href="#cb227-176" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb227-177"><a href="#cb227-177" aria-hidden="true" tabindex="-1"></a><span class="kw">def</span> warte_auf_ergebnis(klient, auftrags_id: <span class="bu">str</span>, grenze: <span class="bu">float</span> <span class="op">=</span> <span class="fl">30.0</span>) <span class="op">-&gt;</span> <span class="bu">dict</span>:</span>
+<span id="cb227-178"><a href="#cb227-178" aria-hidden="true" tabindex="-1"></a>    ende <span class="op">=</span> time.time() <span class="op">+</span> grenze</span>
+<span id="cb227-179"><a href="#cb227-179" aria-hidden="true" tabindex="-1"></a>    <span class="cf">while</span> time.time() <span class="op">&lt;</span> ende:</span>
+<span id="cb227-180"><a href="#cb227-180" aria-hidden="true" tabindex="-1"></a>        antwort <span class="op">=</span> klient.get(<span class="ss">f&quot;/plaene/</span><span class="sc">{</span>auftrags_id<span class="sc">}</span><span class="ss">&quot;</span>).json()</span>
+<span id="cb227-181"><a href="#cb227-181" aria-hidden="true" tabindex="-1"></a>        <span class="cf">if</span> antwort[<span class="st">&quot;stand&quot;</span>] <span class="kw">in</span> (<span class="st">&quot;fertig&quot;</span>, <span class="st">&quot;gescheitert&quot;</span>):</span>
+<span id="cb227-182"><a href="#cb227-182" aria-hidden="true" tabindex="-1"></a>            <span class="cf">return</span> antwort</span>
+<span id="cb227-183"><a href="#cb227-183" aria-hidden="true" tabindex="-1"></a>        time.sleep(<span class="fl">0.02</span>)</span>
+<span id="cb227-184"><a href="#cb227-184" aria-hidden="true" tabindex="-1"></a>    <span class="cf">raise</span> <span class="pp">TimeoutError</span>(<span class="st">&quot;Auftrag wurde nicht fertig&quot;</span>)</span>
+<span id="cb227-185"><a href="#cb227-185" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb227-186"><a href="#cb227-186" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb227-187"><a href="#cb227-187" aria-hidden="true" tabindex="-1"></a><span class="cf">if</span> <span class="va">__name__</span> <span class="op">==</span> <span class="st">&quot;__main__&quot;</span>:</span>
+<span id="cb227-188"><a href="#cb227-188" aria-hidden="true" tabindex="-1"></a>    <span class="im">from</span> fastapi.testclient <span class="im">import</span> TestClient</span>
+<span id="cb227-189"><a href="#cb227-189" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb227-190"><a href="#cb227-190" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;=&quot;</span> <span class="op">*</span> <span class="dv">80</span>)</span>
+<span id="cb227-191"><a href="#cb227-191" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;  DAS MODELL ALS DIENST&quot;</span>)</span>
+<span id="cb227-192"><a href="#cb227-192" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;=&quot;</span> <span class="op">*</span> <span class="dv">80</span>)</span>
+<span id="cb227-193"><a href="#cb227-193" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb227-194"><a href="#cb227-194" aria-hidden="true" tabindex="-1"></a>    <span class="cf">with</span> TestClient(app) <span class="im">as</span> klient:</span>
+<span id="cb227-195"><a href="#cb227-195" aria-hidden="true" tabindex="-1"></a>        <span class="co"># 1. Gueltiger Auftrag</span></span>
+<span id="cb227-196"><a href="#cb227-196" aria-hidden="true" tabindex="-1"></a>        <span class="bu">print</span>(<span class="st">&quot;</span><span class="ch">\n</span><span class="st">1. Auftrag einreichen&quot;</span>)</span>
+<span id="cb227-197"><a href="#cb227-197" aria-hidden="true" tabindex="-1"></a>        angenommen <span class="op">=</span> klient.post(<span class="st">&quot;/plaene&quot;</span>, json<span class="op">=</span>SCHREINEREI)</span>
+<span id="cb227-198"><a href="#cb227-198" aria-hidden="true" tabindex="-1"></a>        auftrags_id <span class="op">=</span> angenommen.json()[<span class="st">&quot;id&quot;</span>]</span>
+<span id="cb227-199"><a href="#cb227-199" aria-hidden="true" tabindex="-1"></a>        <span class="bu">print</span>(<span class="ss">f&quot;   POST /plaene            -&gt; </span><span class="sc">{</span>angenommen<span class="sc">.</span>status_code<span class="sc">}</span><span class="ss"> &quot;</span></span>
+<span id="cb227-200"><a href="#cb227-200" aria-hidden="true" tabindex="-1"></a>              <span class="ss">f&quot;</span><span class="sc">{</span><span class="st">&#39;Accepted&#39;</span> <span class="cf">if</span> angenommen<span class="sc">.</span>status_code <span class="op">==</span> <span class="dv">202</span> <span class="cf">else</span> <span class="st">&#39;&#39;</span><span class="sc">}</span><span class="ss">&quot;</span>)</span>
+<span id="cb227-201"><a href="#cb227-201" aria-hidden="true" tabindex="-1"></a>        <span class="bu">print</span>(<span class="ss">f&quot;   Auftragsnummer          -&gt; UUID, </span><span class="sc">{</span><span class="bu">len</span>(auftrags_id)<span class="sc">}</span><span class="ss"> Zeichen&quot;</span>)</span>
+<span id="cb227-202"><a href="#cb227-202" aria-hidden="true" tabindex="-1"></a>        <span class="co"># Der entscheidende Punkt, und er ist pruefbar: Die Antwort ist da,</span></span>
+<span id="cb227-203"><a href="#cb227-203" aria-hidden="true" tabindex="-1"></a>        <span class="co"># BEVOR es eine Loesung gibt. Genau dafuer ist 202 gedacht.</span></span>
+<span id="cb227-204"><a href="#cb227-204" aria-hidden="true" tabindex="-1"></a>        <span class="bu">print</span>(<span class="ss">f&quot;   Loesung schon dabei?    -&gt; &quot;</span></span>
+<span id="cb227-205"><a href="#cb227-205" aria-hidden="true" tabindex="-1"></a>              <span class="ss">f&quot;</span><span class="sc">{</span><span class="st">&#39;ja&#39;</span> <span class="cf">if</span> angenommen<span class="sc">.</span>json()[<span class="st">&#39;loesung&#39;</span>] <span class="cf">else</span> <span class="st">&#39;nein - genau so soll es sein&#39;</span><span class="sc">}</span><span class="ss">&quot;</span>)</span>
+<span id="cb227-206"><a href="#cb227-206" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb227-207"><a href="#cb227-207" aria-hidden="true" tabindex="-1"></a>        fertig <span class="op">=</span> warte_auf_ergebnis(klient, auftrags_id)</span>
+<span id="cb227-208"><a href="#cb227-208" aria-hidden="true" tabindex="-1"></a>        loesung <span class="op">=</span> fertig[<span class="st">&quot;loesung&quot;</span>]</span>
+<span id="cb227-209"><a href="#cb227-209" aria-hidden="true" tabindex="-1"></a>        <span class="bu">print</span>(<span class="st">&quot;</span><span class="ch">\n</span><span class="st">2. Ergebnis abholen&quot;</span>)</span>
+<span id="cb227-210"><a href="#cb227-210" aria-hidden="true" tabindex="-1"></a>        <span class="bu">print</span>(<span class="ss">f&quot;   Stand                   -&gt; </span><span class="sc">{</span>fertig[<span class="st">&#39;stand&#39;</span>]<span class="sc">}</span><span class="ss">&quot;</span>)</span>
+<span id="cb227-211"><a href="#cb227-211" aria-hidden="true" tabindex="-1"></a>        <span class="bu">print</span>(<span class="ss">f&quot;   Solverstatus            -&gt; </span><span class="sc">{</span>loesung[<span class="st">&#39;status&#39;</span>]<span class="sc">}</span><span class="ss">&quot;</span>)</span>
+<span id="cb227-212"><a href="#cb227-212" aria-hidden="true" tabindex="-1"></a>        <span class="bu">print</span>(<span class="ss">f&quot;   Zielwert                -&gt; </span><span class="sc">{</span>loesung[<span class="st">&#39;zielwert&#39;</span>]<span class="sc">:,.2f}</span><span class="ss"> EUR&quot;</span>)</span>
+<span id="cb227-213"><a href="#cb227-213" aria-hidden="true" tabindex="-1"></a>        <span class="bu">print</span>(<span class="ss">f&quot;   Mengen                  -&gt; &quot;</span> <span class="op">+</span> <span class="st">&quot;, &quot;</span>.join(</span>
+<span id="cb227-214"><a href="#cb227-214" aria-hidden="true" tabindex="-1"></a>            <span class="ss">f&quot;</span><span class="sc">{</span>name<span class="sc">}</span><span class="ss"> </span><span class="sc">{</span>wert<span class="sc">:.0f}</span><span class="ss">&quot;</span> <span class="cf">for</span> name, wert <span class="kw">in</span> loesung[<span class="st">&quot;werte&quot;</span>].items()))</span>
+<span id="cb227-215"><a href="#cb227-215" aria-hidden="true" tabindex="-1"></a>        <span class="bu">print</span>(<span class="ss">f&quot;   Schattenpreise          -&gt; &quot;</span> <span class="op">+</span> <span class="st">&quot;, &quot;</span>.join(</span>
+<span id="cb227-216"><a href="#cb227-216" aria-hidden="true" tabindex="-1"></a>            <span class="ss">f&quot;</span><span class="sc">{</span>name<span class="sc">}</span><span class="ss"> </span><span class="sc">{</span>wert<span class="sc">:.0f}</span><span class="ss">&quot;</span> <span class="cf">for</span> name, wert <span class="kw">in</span> loesung[<span class="st">&quot;schattenpreise&quot;</span>].items()))</span>
+<span id="cb227-217"><a href="#cb227-217" aria-hidden="true" tabindex="-1"></a>        <span class="bu">print</span>(<span class="ss">f&quot;   Abnahmepruefung         -&gt; &quot;</span></span>
+<span id="cb227-218"><a href="#cb227-218" aria-hidden="true" tabindex="-1"></a>              <span class="ss">f&quot;</span><span class="sc">{</span><span class="st">&#39;bestanden&#39;</span> <span class="cf">if</span> <span class="kw">not</span> fertig[<span class="st">&#39;beanstandungen&#39;</span>] <span class="cf">else</span> fertig[<span class="st">&#39;beanstandungen&#39;</span>]<span class="sc">}</span><span class="ss">&quot;</span>)</span>
+<span id="cb227-219"><a href="#cb227-219" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb227-220"><a href="#cb227-220" aria-hidden="true" tabindex="-1"></a>        <span class="co"># 2. Unsinnige Anfrage - muss abgewiesen werden, BEVOR gerechnet wird</span></span>
+<span id="cb227-221"><a href="#cb227-221" aria-hidden="true" tabindex="-1"></a>        <span class="bu">print</span>(<span class="st">&quot;</span><span class="ch">\n</span><span class="st">3. Unsinnige Anfragen (der Solver startet gar nicht erst)&quot;</span>)</span>
+<span id="cb227-222"><a href="#cb227-222" aria-hidden="true" tabindex="-1"></a>        <span class="cf">for</span> beschreibung, aenderung <span class="kw">in</span> [</span>
+<span id="cb227-223"><a href="#cb227-223" aria-hidden="true" tabindex="-1"></a>                (<span class="st">&quot;Kapazitaet 0&quot;</span>, {<span class="st">&quot;kapazitaeten&quot;</span>: {<span class="st">&quot;Montagestunden&quot;</span>: <span class="fl">0.0</span>}}),</span>
+<span id="cb227-224"><a href="#cb227-224" aria-hidden="true" tabindex="-1"></a>                (<span class="st">&quot;keine Produkte&quot;</span>, {<span class="st">&quot;produkte&quot;</span>: []}),</span>
+<span id="cb227-225"><a href="#cb227-225" aria-hidden="true" tabindex="-1"></a>                (<span class="st">&quot;Ressource ohne Kapazitaet&quot;</span>,</span>
+<span id="cb227-226"><a href="#cb227-226" aria-hidden="true" tabindex="-1"></a>                 {<span class="st">&quot;produkte&quot;</span>: [{<span class="st">&quot;name&quot;</span>: <span class="st">&quot;Regal&quot;</span>, <span class="st">&quot;deckungsbeitrag&quot;</span>: <span class="fl">130.0</span>,</span>
+<span id="cb227-227"><a href="#cb227-227" aria-hidden="true" tabindex="-1"></a>                                <span class="st">&quot;verbrauch&quot;</span>: {<span class="st">&quot;Lackieren&quot;</span>: <span class="fl">2.0</span>}}]})]:</span>
+<span id="cb227-228"><a href="#cb227-228" aria-hidden="true" tabindex="-1"></a>            anfrage <span class="op">=</span> {<span class="op">**</span>SCHREINEREI, <span class="op">**</span>aenderung}</span>
+<span id="cb227-229"><a href="#cb227-229" aria-hidden="true" tabindex="-1"></a>            antwort <span class="op">=</span> klient.post(<span class="st">&quot;/plaene&quot;</span>, json<span class="op">=</span>anfrage)</span>
+<span id="cb227-230"><a href="#cb227-230" aria-hidden="true" tabindex="-1"></a>            <span class="bu">print</span>(<span class="ss">f&quot;   </span><span class="sc">{</span>beschreibung<span class="sc">:&lt;24}</span><span class="ss"> -&gt; </span><span class="sc">{</span>antwort<span class="sc">.</span>status_code<span class="sc">}</span><span class="ss"> &quot;</span></span>
+<span id="cb227-231"><a href="#cb227-231" aria-hidden="true" tabindex="-1"></a>                  <span class="ss">f&quot;</span><span class="sc">{</span><span class="st">&#39;Unprocessable Content&#39;</span> <span class="cf">if</span> antwort<span class="sc">.</span>status_code <span class="op">==</span> <span class="dv">422</span> <span class="cf">else</span> <span class="st">&#39;&#39;</span><span class="sc">}</span><span class="ss">&quot;</span>)</span>
+<span id="cb227-232"><a href="#cb227-232" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb227-233"><a href="#cb227-233" aria-hidden="true" tabindex="-1"></a>        <span class="bu">print</span>(<span class="st">&quot;</span><span class="ch">\n</span><span class="st">4. Unbekannter Auftrag&quot;</span>)</span>
+<span id="cb227-234"><a href="#cb227-234" aria-hidden="true" tabindex="-1"></a>        <span class="bu">print</span>(<span class="ss">f&quot;   GET /plaene/gibtsnicht  -&gt; &quot;</span></span>
+<span id="cb227-235"><a href="#cb227-235" aria-hidden="true" tabindex="-1"></a>              <span class="ss">f&quot;</span><span class="sc">{</span>klient<span class="sc">.</span>get(<span class="st">&#39;/plaene/gibtsnicht&#39;</span>)<span class="sc">.</span>status_code<span class="sc">}</span><span class="ss"> Not Found&quot;</span>)</span>
+<span id="cb227-236"><a href="#cb227-236" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb227-237"><a href="#cb227-237" aria-hidden="true" tabindex="-1"></a>        <span class="bu">print</span>(<span class="st">&quot;</span><span class="ch">\n</span><span class="st">5. Gesundheitsabfrage&quot;</span>)</span>
+<span id="cb227-238"><a href="#cb227-238" aria-hidden="true" tabindex="-1"></a>        <span class="bu">print</span>(<span class="ss">f&quot;   GET /gesundheit         -&gt; </span><span class="sc">{</span>klient<span class="sc">.</span>get(<span class="st">&#39;/gesundheit&#39;</span>)<span class="sc">.</span>json()<span class="sc">}</span><span class="ss">&quot;</span>)</span>
+<span id="cb227-239"><a href="#cb227-239" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb227-240"><a href="#cb227-240" aria-hidden="true" tabindex="-1"></a>    <span class="co"># --- Warum ein Thread je Auftrag genuegt -----------------------------</span></span>
+<span id="cb227-241"><a href="#cb227-241" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;</span><span class="ch">\n</span><span class="st">&quot;</span> <span class="op">+</span> <span class="st">&quot;-&quot;</span> <span class="op">*</span> <span class="dv">80</span>)</span>
+<span id="cb227-242"><a href="#cb227-242" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;6. Warum Threads hier reichen (und wann nicht)</span><span class="ch">\n</span><span class="st">&quot;</span>)</span>
+<span id="cb227-243"><a href="#cb227-243" aria-hidden="true" tabindex="-1"></a>    <span class="im">from</span> concurrent.futures <span class="im">import</span> ThreadPoolExecutor <span class="im">as</span> Pool</span>
+<span id="cb227-244"><a href="#cb227-244" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb227-245"><a href="#cb227-245" aria-hidden="true" tabindex="-1"></a>    <span class="co"># Wichtig: eine Rechnung mit ECHTER Last. Ein Modell, das in zehn</span></span>
+<span id="cb227-246"><a href="#cb227-246" aria-hidden="true" tabindex="-1"></a>    <span class="co"># Millisekunden fertig ist, misst nur den Aufwand fuers Threadstarten -</span></span>
+<span id="cb227-247"><a href="#cb227-247" aria-hidden="true" tabindex="-1"></a>    <span class="co"># der erste Entwurf dieser Messung ist genau daran gescheitert und zeigte</span></span>
+<span id="cb227-248"><a href="#cb227-248" aria-hidden="true" tabindex="-1"></a>    <span class="co"># eine Verlangsamung, wo in Wirklichkeit eine Beschleunigung steht.</span></span>
+<span id="cb227-249"><a href="#cb227-249" aria-hidden="true" tabindex="-1"></a>    <span class="kw">def</span> eine_rechnung() <span class="op">-&gt;</span> <span class="va">None</span>:</span>
+<span id="cb227-250"><a href="#cb227-250" aria-hidden="true" tabindex="-1"></a>        <span class="im">import</span> numpy <span class="im">as</span> np</span>
+<span id="cb227-251"><a href="#cb227-251" aria-hidden="true" tabindex="-1"></a>        <span class="im">from</span> ortools.linear_solver <span class="im">import</span> pywraplp</span>
+<span id="cb227-252"><a href="#cb227-252" aria-hidden="true" tabindex="-1"></a>        rng <span class="op">=</span> np.random.default_rng(<span class="dv">3</span>)</span>
+<span id="cb227-253"><a href="#cb227-253" aria-hidden="true" tabindex="-1"></a>        n <span class="op">=</span> <span class="dv">260</span></span>
+<span id="cb227-254"><a href="#cb227-254" aria-hidden="true" tabindex="-1"></a>        solver <span class="op">=</span> pywraplp.Solver.CreateSolver(<span class="st">&quot;SCIP&quot;</span>)</span>
+<span id="cb227-255"><a href="#cb227-255" aria-hidden="true" tabindex="-1"></a>        x <span class="op">=</span> [solver.IntVar(<span class="dv">0</span>, <span class="dv">1</span>, <span class="ss">f&quot;x</span><span class="sc">{</span>i<span class="sc">}</span><span class="ss">&quot;</span>) <span class="cf">for</span> i <span class="kw">in</span> <span class="bu">range</span>(n)]</span>
+<span id="cb227-256"><a href="#cb227-256" aria-hidden="true" tabindex="-1"></a>        gewicht <span class="op">=</span> rng.integers(<span class="dv">10</span>, <span class="dv">60</span>, n)</span>
+<span id="cb227-257"><a href="#cb227-257" aria-hidden="true" tabindex="-1"></a>        wert <span class="op">=</span> rng.integers(<span class="dv">10</span>, <span class="dv">60</span>, n)</span>
+<span id="cb227-258"><a href="#cb227-258" aria-hidden="true" tabindex="-1"></a>        solver.Add(<span class="bu">sum</span>(<span class="bu">int</span>(gewicht[i]) <span class="op">*</span> x[i] <span class="cf">for</span> i <span class="kw">in</span> <span class="bu">range</span>(n))</span>
+<span id="cb227-259"><a href="#cb227-259" aria-hidden="true" tabindex="-1"></a>                   <span class="op">&lt;=</span> <span class="bu">int</span>(gewicht.<span class="bu">sum</span>() <span class="op">*</span> <span class="fl">0.5</span>))</span>
+<span id="cb227-260"><a href="#cb227-260" aria-hidden="true" tabindex="-1"></a>        <span class="cf">for</span> _ <span class="kw">in</span> <span class="bu">range</span>(<span class="dv">30</span>):</span>
+<span id="cb227-261"><a href="#cb227-261" aria-hidden="true" tabindex="-1"></a>            auswahl <span class="op">=</span> rng.choice(n, <span class="dv">40</span>, replace<span class="op">=</span><span class="va">False</span>)</span>
+<span id="cb227-262"><a href="#cb227-262" aria-hidden="true" tabindex="-1"></a>            solver.Add(<span class="bu">sum</span>(x[<span class="bu">int</span>(i)] <span class="cf">for</span> i <span class="kw">in</span> auswahl) <span class="op">&lt;=</span> <span class="dv">12</span>)</span>
+<span id="cb227-263"><a href="#cb227-263" aria-hidden="true" tabindex="-1"></a>        solver.Maximize(<span class="bu">sum</span>(<span class="bu">int</span>(wert[i]) <span class="op">*</span> x[i] <span class="cf">for</span> i <span class="kw">in</span> <span class="bu">range</span>(n)))</span>
+<span id="cb227-264"><a href="#cb227-264" aria-hidden="true" tabindex="-1"></a>        solver.Solve()</span>
+<span id="cb227-265"><a href="#cb227-265" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb227-266"><a href="#cb227-266" aria-hidden="true" tabindex="-1"></a>    t0 <span class="op">=</span> time.perf_counter()</span>
+<span id="cb227-267"><a href="#cb227-267" aria-hidden="true" tabindex="-1"></a>    <span class="cf">for</span> _ <span class="kw">in</span> <span class="bu">range</span>(<span class="dv">4</span>):</span>
+<span id="cb227-268"><a href="#cb227-268" aria-hidden="true" tabindex="-1"></a>        eine_rechnung()</span>
+<span id="cb227-269"><a href="#cb227-269" aria-hidden="true" tabindex="-1"></a>    seriell <span class="op">=</span> time.perf_counter() <span class="op">-</span> t0</span>
+<span id="cb227-270"><a href="#cb227-270" aria-hidden="true" tabindex="-1"></a>    t0 <span class="op">=</span> time.perf_counter()</span>
+<span id="cb227-271"><a href="#cb227-271" aria-hidden="true" tabindex="-1"></a>    <span class="cf">with</span> Pool(max_workers<span class="op">=</span><span class="dv">4</span>) <span class="im">as</span> p:</span>
+<span id="cb227-272"><a href="#cb227-272" aria-hidden="true" tabindex="-1"></a>        <span class="bu">list</span>(p.<span class="bu">map</span>(<span class="kw">lambda</span> _: eine_rechnung(), <span class="bu">range</span>(<span class="dv">4</span>)))</span>
+<span id="cb227-273"><a href="#cb227-273" aria-hidden="true" tabindex="-1"></a>    parallel <span class="op">=</span> time.perf_counter() <span class="op">-</span> t0</span>
+<span id="cb227-274"><a href="#cb227-274" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb227-275"><a href="#cb227-275" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;   vier Rechnungen nacheinander -&gt; </span><span class="sc">{</span>seriell<span class="sc">:6.2f}</span><span class="ss"> s&quot;</span>)</span>
+<span id="cb227-276"><a href="#cb227-276" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;   vier Rechnungen in Threads   -&gt; </span><span class="sc">{</span>parallel<span class="sc">:6.2f}</span><span class="ss"> s &quot;</span></span>
+<span id="cb227-277"><a href="#cb227-277" aria-hidden="true" tabindex="-1"></a>          <span class="ss">f&quot;(Faktor </span><span class="sc">{</span>seriell <span class="op">/</span> parallel<span class="sc">:.1f}</span><span class="ss">)&quot;</span>)</span>
+<span id="cb227-278"><a href="#cb227-278" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>()</span>
+<span id="cb227-279"><a href="#cb227-279" aria-hidden="true" tabindex="-1"></a>    <span class="cf">if</span> parallel <span class="op">&lt;</span> seriell <span class="op">*</span> <span class="fl">0.75</span>:</span>
+<span id="cb227-280"><a href="#cb227-280" aria-hidden="true" tabindex="-1"></a>        <span class="bu">print</span>(<span class="st">&quot;   Die Laeufe ueberlappen sich. ortools rechnet in C++ und gibt&quot;</span>)</span>
+<span id="cb227-281"><a href="#cb227-281" aria-hidden="true" tabindex="-1"></a>        <span class="bu">print</span>(<span class="st">&quot;   den GIL waehrend Solve() frei - deshalb genuegt hier ein&quot;</span>)</span>
+<span id="cb227-282"><a href="#cb227-282" aria-hidden="true" tabindex="-1"></a>        <span class="bu">print</span>(<span class="st">&quot;   Threadpool, es braucht keine eigenen Prozesse.&quot;</span>)</span>
+<span id="cb227-283"><a href="#cb227-283" aria-hidden="true" tabindex="-1"></a>    <span class="cf">else</span>:</span>
+<span id="cb227-284"><a href="#cb227-284" aria-hidden="true" tabindex="-1"></a>        <span class="bu">print</span>(<span class="st">&quot;   Keine Ueberlappung - hier waeren Prozesse noetig.&quot;</span>)</span>
+<span id="cb227-285"><a href="#cb227-285" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>()</span>
+<span id="cb227-286"><a href="#cb227-286" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;   ACHTUNG, das gilt nicht allgemein: Eine in reinem Python&quot;</span>)</span>
+<span id="cb227-287"><a href="#cb227-287" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;   geschriebene Heuristik (Kapitel Metaheuristiken) haelt den GIL&quot;</span>)</span>
+<span id="cb227-288"><a href="#cb227-288" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;   die ganze Zeit. Fuer sie braucht derselbe Dienst einen&quot;</span>)</span>
+<span id="cb227-289"><a href="#cb227-289" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;   ProcessPoolExecutor statt eines Threadpools.&quot;</span>)</span>
+<span id="cb227-290"><a href="#cb227-290" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb227-291"><a href="#cb227-291" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;</span><span class="ch">\n</span><span class="st">&quot;</span> <span class="op">+</span> <span class="st">&quot;=&quot;</span> <span class="op">*</span> <span class="dv">80</span>)</span>
+<span id="cb227-292"><a href="#cb227-292" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;  WAS SICH IM ECHTEN BETRIEB AENDERT&quot;</span>)</span>
+<span id="cb227-293"><a href="#cb227-293" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;=&quot;</span> <span class="op">*</span> <span class="dv">80</span>)</span>
+<span id="cb227-294"><a href="#cb227-294" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;Dieses Beispiel haelt das Auftragsbuch im Speicher und rechnet in&quot;</span>)</span>
+<span id="cb227-295"><a href="#cb227-295" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;Threads desselben Prozesses. Das reicht zum Zeigen und fuer einen&quot;</span>)</span>
+<span id="cb227-296"><a href="#cb227-296" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;einzelnen Rechner - nicht darueber hinaus:&quot;</span>)</span>
+<span id="cb227-297"><a href="#cb227-297" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>()</span>
+<span id="cb227-298"><a href="#cb227-298" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;  * NEUSTART LOESCHT ALLES. Auftragsbuch in eine Datenbank oder eine&quot;</span>)</span>
+<span id="cb227-299"><a href="#cb227-299" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;    Warteschlange (Redis, RabbitMQ), nicht in ein dict.&quot;</span>)</span>
+<span id="cb227-300"><a href="#cb227-300" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;  * ZWEI INSTANZEN KENNEN EINANDER NICHT. Sobald der Dienst mehr als&quot;</span>)</span>
+<span id="cb227-301"><a href="#cb227-301" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;    einmal laeuft, muss die Warteschlange ausserhalb liegen -&quot;</span>)</span>
+<span id="cb227-302"><a href="#cb227-302" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;    typischerweise Celery mit Redis als Vermittler.&quot;</span>)</span>
+<span id="cb227-303"><a href="#cb227-303" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;  * DIE WAHL THREADS/PROZESSE HAENGT AM SOLVER - siehe die Messung&quot;</span>)</span>
+<span id="cb227-304"><a href="#cb227-304" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;    unter Punkt 6. Sie gehoert gemessen, nicht angenommen.&quot;</span>)</span>
+<span id="cb227-305"><a href="#cb227-305" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;  * OHNE ZEITLIMIT KEIN DIENST. Jede Instanz bekommt eines, und der&quot;</span>)</span>
+<span id="cb227-306"><a href="#cb227-306" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;    Aufrufer erfaehrt im Status, ob es gegriffen hat.&quot;</span>)</span>
+<span id="cb227-307"><a href="#cb227-307" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>()</span>
+<span id="cb227-308"><a href="#cb227-308" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;Das zugehoerige Dockerfile ist kurz genug, um es ganz zu zeigen:&quot;</span>)</span>
+<span id="cb227-309"><a href="#cb227-309" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>()</span>
+<span id="cb227-310"><a href="#cb227-310" aria-hidden="true" tabindex="-1"></a>    <span class="cf">for</span> zeile <span class="kw">in</span> DOCKERFILE.splitlines():</span>
+<span id="cb227-311"><a href="#cb227-311" aria-hidden="true" tabindex="-1"></a>        <span class="bu">print</span>(<span class="ss">f&quot;    </span><span class="sc">{</span>zeile<span class="sc">}</span><span class="ss">&quot;</span>)</span>
+<span id="cb227-312"><a href="#cb227-312" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>()</span>
+<span id="cb227-313"><a href="#cb227-313" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;(Es wird hier nicht gebaut - das Buch setzt keine laufende&quot;</span>)</span>
+<span id="cb227-314"><a href="#cb227-314" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot; Docker-Installation voraus.)&quot;</span>)</span>
+<span id="cb227-315"><a href="#cb227-315" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;=&quot;</span> <span class="op">*</span> <span class="dv">80</span>)</span></code></pre></div>
 <p><strong>Erwartete Ausgabe</strong> (Laufzeiten hardwareabhängig):</p>
 <pre><code>================================================================================
   DAS MODELL ALS DIENST
@@ -28060,7 +29590,7 @@ Das zugehoerige Dockerfile ist kurz genug, um es ganz zu zeigen:
 <blockquote>
 <p><strong>💻 Code-Durchgang: drei Entscheidungen</strong></p>
 <p><strong>1. Das Domänenmodell ist das API-Schema.</strong> Der Parameter heißt <code>problem: Produktionsproblem</code> — mehr steht nicht da. FastAPI validiert die Anfrage damit gegen dieselben Pydantic-Regeln wie der Excel-Import aus <a href="#kap-einfuehrung">Kapitel 1</a> und antwortet bei Unsinn mit <code>422</code>, <strong>bevor</strong> ein Solver startet. Die drei abgewiesenen Anfragen im Selbsttest sind genau die drei Fälle, die <code>or_kern.py</code> schon beim Einlesen abfängt.</p>
-<p><strong>2. Die Antwort enthält Status und Gap, nicht nur Zahlen.</strong> Ein Aufrufer, der nur die Mengen bekommt, kann nicht unterscheiden, ob er ein bewiesenes Optimum oder einen Zeitlimit-Abbruch in der Hand hält. Das <code>Loesung</code>-Objekt geht deshalb vollständig durch die Schnittstelle — dasselbe DTO, das in <a href="#sec:praxisfallen-solverwechsel">Abschnitt 22.6</a> schon eine Prozessgrenze überlebt hat.</p>
+<p><strong>2. Die Antwort enthält Status und Gap, nicht nur Zahlen.</strong> Ein Aufrufer, der nur die Mengen bekommt, kann nicht unterscheiden, ob er ein bewiesenes Optimum oder einen Zeitlimit-Abbruch in der Hand hält. Das <code>Loesung</code>-Objekt geht deshalb vollständig durch die Schnittstelle — dasselbe DTO, das in <a href="#sec:praxisfallen-solverwechsel">Abschnitt 22.7</a> schon eine Prozessgrenze überlebt hat.</p>
 <p><strong>3. Die Abnahmeprüfung läuft auch hier.</strong> <code>pruefe_loesung()</code> steht im Arbeiter, nicht nur im Skript. Ein Dienst ohne sie liefert Fehler schneller aus, als ein Mensch sie finden könnte.</p>
 </blockquote>
 <h3 id="threads-oder-prozesse-eine-messung-keine-meinung">Threads oder Prozesse? Eine Messung, keine Meinung</h3>
@@ -28153,6 +29683,104 @@ Das zugehoerige Dockerfile ist kurz genug, um es ganz zu zeigen:
 <li>Ein <strong>Optimierungsdienst</strong> ist zweistufig: annehmen und prüfen sofort, rechnen im Hintergrund, Ergebnis mit Status und Gap abholen. Die Frage Threads oder Prozesse gehört gemessen — bei C++-Solvern genügen Threads, bei Python-Heuristiken nicht.</li>
 </ul>
 <hr />
+<h1 id="synthese-teil-v-vom-rechnenden-modell-zum-benutzten-system">Synthese Teil V — Vom rechnenden Modell zum benutzten System</h1>
+<p>Zwei Kapitel, ein Übergang: Das Modell rechnet — und muss jetzt jemand anderem übergeben werden. Was dabei schiefgeht, hat selten mit Mathematik zu tun.</p>
+<h2 id="was-schiefgeht-und-was-dagegen-hilft">Was schiefgeht, und was dagegen hilft</h2>
+<table>
+<colgroup>
+<col style="width: 33%" />
+<col style="width: 33%" />
+<col style="width: 33%" />
+</colgroup>
+<thead>
+<tr class="header">
+<th>Was in Produktion passiert</th>
+<th>Gegenmittel</th>
+<th>Wo</th>
+</tr>
+</thead>
+<tbody>
+<tr class="odd">
+<td><code>INFEASIBLE</code> um 3 Uhr nachts, niemand weiß warum</td>
+<td>Relaxation mit gestaffelten Strafkosten (B18); Deletion Filter für die Diagnose</td>
+<td><a href="#kap-praxisfallen">Kapitel 22</a>, <a href="#anhang-fehlerdiagnose">Anhang C</a></td>
+</tr>
+<tr class="even">
+<td>Der Disponent lehnt den Plan ab, weil er ihn nicht versteht</td>
+<td>Constraint-Trace für die einzelne Zuweisung; Kostenzurechnung für den ganzen Plan</td>
+<td><a href="#kap-praxisfallen">Kapitel 22</a>, <a href="#sec:praxisfallen-attribution">Abschnitt 22.4</a></td>
+</tr>
+<tr class="odd">
+<td>Der Solver läuft ins Zeitlimit und keiner merkt es</td>
+<td>Status, Gap und Zeitausschöpfung protokollieren — konstante Laufzeit ist ein Warnsignal</td>
+<td><a href="#kap-praxisfallen">Kapitel 22</a></td>
+</tr>
+<tr class="even">
+<td>Ein Test wird grundlos mal rot, mal grün</td>
+<td>auf Zielwert und Regeln prüfen, nicht auf die Gestalt der Lösung; <code>num_workers = 1</code> <strong>und</strong> Seed</td>
+<td><a href="#sec:cpsat-parallele-suche">Abschnitt 7.7</a>, <a href="#kap-testing">Kapitel 23</a></td>
+</tr>
+<tr class="odd">
+<td>Ein Ergebnis lässt sich später nicht mehr nachvollziehen</td>
+<td>Snapshot-Prinzip: unveränderlicher Datenstand mit ID je Lauf</td>
+<td><a href="#kap-praxisfallen">Kapitel 22</a></td>
+</tr>
+<tr class="even">
+<td>Das Modell prüft sich selbst</td>
+<td>Abnahmeprüfung als eigener Baustein, ohne Solver und ohne Modellvariable</td>
+<td><a href="#sec:praxisfallen-or-kern">Abschnitt 22.6</a></td>
+</tr>
+</tbody>
+</table>
+<h2 id="was-dieser-teil-gemessen-hat-3">Was dieser Teil gemessen hat</h2>
+<table>
+<colgroup>
+<col style="width: 33%" />
+<col style="width: 33%" />
+<col style="width: 33%" />
+</colgroup>
+<thead>
+<tr class="header">
+<th>Behauptung</th>
+<th>Gemessen</th>
+<th>Wo</th>
+</tr>
+</thead>
+<tbody>
+<tr class="odd">
+<td>„Der Solver nennt schon den Grund für <code>INFEASIBLE</code>.”</td>
+<td>Er nennt gar nichts. Der Deletion Filter findet einen kleinsten Konflikt — dieses Modell enthält <strong>neun</strong> verschiedene, und welchen man sieht, steuert die Prüfreihenfolge</td>
+<td><a href="#anhang-fehlerdiagnose">Anhang C</a></td>
+</tr>
+<tr class="even">
+<td>„Bindende Bedingungen sind die teuren.”</td>
+<td>Von fünf bindenden Bedingungen kostet eine <strong>0,00 €</strong></td>
+<td><a href="#sec:praxisfallen-attribution">Abschnitt 22.4</a></td>
+</tr>
+<tr class="odd">
+<td>„Der Schattenpreis sagt, was der Hebel bringt.”</td>
+<td>Hochgerechnet 120 €, gemessen <strong>60 €</strong> — er gilt nur bis +15 Stunden. Die Ranglisten nach Preis und nach Wirkung drehen sich um</td>
+<td><a href="#sec:praxisfallen-attribution">Abschnitt 22.4</a></td>
+</tr>
+<tr class="even">
+<td>„Mehr Arbeiter sind proportional schneller.”</td>
+<td><strong>12,3-fach</strong> bei acht Arbeitern — überlinear, weil verschiedene Strategien statt derselben Suche laufen</td>
+<td><a href="#sec:cpsat-parallele-suche">Abschnitt 7.7</a></td>
+</tr>
+</tbody>
+</table>
+<h2 id="drei-fehler-die-dieser-teil-verhindert-3">Drei Fehler, die dieser Teil verhindert</h2>
+<ol type="1">
+<li><strong>Alles hart formulieren.</strong> Wer keine Regel brechen lässt, bekommt irgendwann eine Fehlermeldung statt eines Plans — und zwar nachts, im Batchlauf.</li>
+<li><strong>Genauer optimieren als die Daten sind.</strong> Ein Gap von 2 % ist bei ±10 % Datenunsicherheit bedeutungslos. Die Rechenzeit dafür ist verschenkt.</li>
+<li><strong>Einen Bericht für einen Beweis halten.</strong> Ein generierter Text erklärt das <strong>Modell</strong>, nicht die <strong>Wirklichkeit</strong>. Ist eine Eingabe falsch geschätzt, ist er überzeugend <strong>und</strong> falsch — die gefährlichste Kombination.</li>
+</ol>
+<h2 id="wenn-sie-nur-eines-mitnehmen-4">Wenn Sie nur eines mitnehmen</h2>
+<blockquote>
+<p><strong>🎯</strong> Ein Modell, das nur auf Ihrem Rechner und nur mit Ihren Daten läuft, ist ein Prototyp — kein System. Der Unterschied besteht aus drei Dingen, die alle nichts mit dem Solver zu tun haben: einer Abnahmeprüfung, einer Erklärung und einem Protokoll.</p>
+</blockquote>
+<p><strong>Danach:</strong> die Projektwerkstatt. Elf Aufträge, jeder mit Datenquellen, Modellskizze, Abnahmekriterien und Stolperfallen — zugeschnitten auf 10 bis 25 Stunden bis zu einem vorzeigbaren Ergebnis.</p>
+<hr />
 <h1 id="projektwerkstatt-elf-eigene-anwendungen">Projektwerkstatt — elf eigene Anwendungen</h1>
 <blockquote>
 <p><strong>📌 Auf einen Blick</strong></p>
@@ -28398,21 +30026,21 @@ Das zugehoerige Dockerfile ist kurz genug, um es ganz zu zeigen:
 <p><strong>1.3 — Kombinatorik.</strong> (a) <span class="math inline">12! = 479\,001\,600</span>. (b) <span class="math inline">479\,001\,600 / 5\cdot10^6 \approx 95{,}8</span> Sekunden <span class="math inline">\approx 1{,}6</span> Minuten. (c) <span class="math inline">13! = 6\,227\,020\,800</span>; das sind <span class="math inline">1245</span> s <span class="math inline">\approx 20{,}8</span> Minuten — <strong>Faktor 13</strong>. Jeder weitere Auftrag multipliziert die Zeit mit der neuen Anzahl. (d) Eine Stunde <span class="math inline">= 3600</span> s <span class="math inline">\to 1{,}8\cdot10^{10}</span> Prüfungen. <span class="math inline">13! = 6{,}2\cdot10^9</span> ✓, <span class="math inline">14! = 8{,}7\cdot10^{10}</span> ✗. Also <strong>13 Aufträge</strong>.</p>
 <p><strong>1.4 — Modell lesen.</strong> (a) Variablen <span class="math inline">x_1, x_2 \ge 0</span>; Parameter <span class="math inline">(3,5)</span> und die Kapazitäten <span class="math inline">(4,12,18)</span>; Zielfunktion <span class="math inline">\max 3x_1+5x_2</span>; vier Nebenbedingungen inkl. Nichtnegativität. (b) <span class="math inline">(2,6)</span>: <span class="math inline">2\le4</span> ✓, <span class="math inline">12\le12</span> ✓, <span class="math inline">6+12=18\le18</span> ✓ → zulässig, <span class="math inline">Z=36</span>. <span class="math inline">(4,3)</span>: <span class="math inline">4\le4</span> ✓, <span class="math inline">6\le12</span> ✓, <span class="math inline">12+6=18\le18</span> ✓ → zulässig, <span class="math inline">Z=27</span>. (c) Beste ganzzahlige Lösung ist <span class="math inline">(2,6)</span> mit <span class="math inline">Z=36</span> — sie ist hier bereits ganzzahlig, weil die Ecke des Polyeders zufällig auf Gitterpunkten liegt.</p>
 <p><strong>1.5 — Bäckerei.</strong></p>
-<div class="sourceCode" id="cb225"><pre class="sourceCode python"><code class="sourceCode python"><span id="cb225-1"><a href="#cb225-1" aria-hidden="true" tabindex="-1"></a><span class="im">from</span> ortools.sat.python <span class="im">import</span> cp_model</span>
-<span id="cb225-2"><a href="#cb225-2" aria-hidden="true" tabindex="-1"></a>m <span class="op">=</span> cp_model.CpModel()</span>
-<span id="cb225-3"><a href="#cb225-3" aria-hidden="true" tabindex="-1"></a>x1 <span class="op">=</span> m.NewIntVar(<span class="dv">0</span>, <span class="dv">1000</span>, <span class="st">&quot;Brote&quot;</span>)</span>
-<span id="cb225-4"><a href="#cb225-4" aria-hidden="true" tabindex="-1"></a>x2 <span class="op">=</span> m.NewIntVar(<span class="dv">0</span>, <span class="dv">1000</span>, <span class="st">&quot;Broetchen_10er&quot;</span>)</span>
-<span id="cb225-5"><a href="#cb225-5" aria-hidden="true" tabindex="-1"></a>m.Add(<span class="dv">5</span> <span class="op">*</span> x1 <span class="op">+</span> <span class="dv">6</span> <span class="op">*</span> x2 <span class="op">&lt;=</span> <span class="dv">900</span>)        <span class="co"># Mehl in 100-g-Einheiten (0,5 kg -&gt; 5)</span></span>
-<span id="cb225-6"><a href="#cb225-6" aria-hidden="true" tabindex="-1"></a>m.Add(<span class="dv">4</span> <span class="op">*</span> x1 <span class="op">+</span> <span class="dv">3</span> <span class="op">*</span> x2 <span class="op">&lt;=</span> <span class="dv">600</span>)        <span class="co"># Ofenminuten</span></span>
-<span id="cb225-7"><a href="#cb225-7" aria-hidden="true" tabindex="-1"></a>m.Add(x1 <span class="op">&gt;=</span> <span class="dv">40</span>)                       <span class="co"># Vertrag</span></span>
-<span id="cb225-8"><a href="#cb225-8" aria-hidden="true" tabindex="-1"></a>m.Maximize(<span class="dv">250</span> <span class="op">*</span> x1 <span class="op">+</span> <span class="dv">300</span> <span class="op">*</span> x2)       <span class="co"># Deckungsbeitrag in Cent</span></span>
-<span id="cb225-9"><a href="#cb225-9" aria-hidden="true" tabindex="-1"></a>s <span class="op">=</span> cp_model.CpSolver()<span class="op">;</span> s.Solve(m)</span></code></pre></div>
+<div class="sourceCode" id="cb229"><pre class="sourceCode python"><code class="sourceCode python"><span id="cb229-1"><a href="#cb229-1" aria-hidden="true" tabindex="-1"></a><span class="im">from</span> ortools.sat.python <span class="im">import</span> cp_model</span>
+<span id="cb229-2"><a href="#cb229-2" aria-hidden="true" tabindex="-1"></a>m <span class="op">=</span> cp_model.CpModel()</span>
+<span id="cb229-3"><a href="#cb229-3" aria-hidden="true" tabindex="-1"></a>x1 <span class="op">=</span> m.NewIntVar(<span class="dv">0</span>, <span class="dv">1000</span>, <span class="st">&quot;Brote&quot;</span>)</span>
+<span id="cb229-4"><a href="#cb229-4" aria-hidden="true" tabindex="-1"></a>x2 <span class="op">=</span> m.NewIntVar(<span class="dv">0</span>, <span class="dv">1000</span>, <span class="st">&quot;Broetchen_10er&quot;</span>)</span>
+<span id="cb229-5"><a href="#cb229-5" aria-hidden="true" tabindex="-1"></a>m.Add(<span class="dv">5</span> <span class="op">*</span> x1 <span class="op">+</span> <span class="dv">6</span> <span class="op">*</span> x2 <span class="op">&lt;=</span> <span class="dv">900</span>)        <span class="co"># Mehl in 100-g-Einheiten (0,5 kg -&gt; 5)</span></span>
+<span id="cb229-6"><a href="#cb229-6" aria-hidden="true" tabindex="-1"></a>m.Add(<span class="dv">4</span> <span class="op">*</span> x1 <span class="op">+</span> <span class="dv">3</span> <span class="op">*</span> x2 <span class="op">&lt;=</span> <span class="dv">600</span>)        <span class="co"># Ofenminuten</span></span>
+<span id="cb229-7"><a href="#cb229-7" aria-hidden="true" tabindex="-1"></a>m.Add(x1 <span class="op">&gt;=</span> <span class="dv">40</span>)                       <span class="co"># Vertrag</span></span>
+<span id="cb229-8"><a href="#cb229-8" aria-hidden="true" tabindex="-1"></a>m.Maximize(<span class="dv">250</span> <span class="op">*</span> x1 <span class="op">+</span> <span class="dv">300</span> <span class="op">*</span> x2)       <span class="co"># Deckungsbeitrag in Cent</span></span>
+<span id="cb229-9"><a href="#cb229-9" aria-hidden="true" tabindex="-1"></a>s <span class="op">=</span> cp_model.CpSolver()<span class="op">;</span> s.Solve(m)</span></code></pre></div>
 <p><strong>Ergebnis:</strong> <span class="math inline">x_1 = 96</span> Brote, <span class="math inline">x_2 = 70</span> Zehnerpackungen, Deckungsbeitrag <strong>450,00 €</strong>.</p>
 <p>Probe: Mehl <span class="math inline">0{,}5\cdot96 + 0{,}6\cdot70 = 48 + 42 = 90</span> kg ✓ (voll ausgelastet); Ofen <span class="math inline">4\cdot96 + 3\cdot70 = 384+210 = 594 \le 600</span> ✓; Vertrag <span class="math inline">96 \ge 40</span> ✓; <span class="math inline">Z = 2{,}5\cdot96 + 3\cdot70 = 240 + 210 = 450</span> ✓.</p>
 <p><strong>Zwei lehrreiche Beobachtungen:</strong> 1. Die <strong>Vertragsbedingung <span class="math inline">x_1 \ge 40</span> ist nicht bindend</strong> — der Solver backt freiwillig 96 Brote. Wer aus der Aufgabenstellung schließt, die Mindestmenge werde „gerade so“ erfüllt, liegt falsch. 2. Das <strong>kontinuierliche</strong> Optimum <span class="math inline">(40;\ 116{,}67)</span> liefert <strong>denselben</strong> Zielwert 450. Das Problem hat also mehrere optimale Lösungen — die Zielfunktion verläuft parallel zur Mehlrestriktion (<span class="math inline">2{,}5/0{,}5 = 5 = 3{,}0/0{,}6</span>). Prüfen Sie das nach: Genau deshalb ist hier auch die ganzzahlige Lösung ohne Verlust erreichbar.</p>
 <p><strong>1.6 — Sensitivität durch Ausprobieren.</strong> Schleife über <code>RAM_GESAMT in range(54, 73, 2)</code>, jeweils Modell neu lösen. (a) Ab 62 GB steigt der Gewinn nicht mehr — dann bindet die <strong>vCPU</strong>-Grenze, RAM ist nicht mehr der Engpass. (b) Der Zuwachs je GB ist der <strong>Schattenpreis</strong> (<a href="#kap-lp">Kapitel 5</a>). Solange RAM bindet, liegt er bei 31,25 €/GB; danach fällt er auf 0.</p>
 <p><strong>1.7 — Eigenes Problem.</strong> Individuell. Prüfkriterien: Sind die Variablen wirklich <em>entscheidbar</em> (nicht bereits festgelegt)? Hat die Zielfunktion eine <strong>Einheit</strong>? Ist jede harte Bedingung wirklich unverhandelbar?</p>
-<h3 id="finde-den-denkfehler-1.1-die-schreinerei-verdoppelt-ihren-gewinn">Finde den Denkfehler 1.1 — Die Schreinerei verdoppelt ihren Gewinn</h3>
+<h3 id="finde-den-denkfehler-die-schreinerei-verdoppelt-ihren-gewinn">Finde den Denkfehler — Die Schreinerei verdoppelt ihren Gewinn</h3>
 <ol type="a">
 <li><p><strong>Nachrechnen.</strong> Der Plan lautet 40 Tische und 150 Stühle: <span class="math inline">40 \cdot 3 + 150 \cdot 1 = \mathbf{270}</span> Montagestunden bei 150 verfügbaren, und <span class="math inline">40 \cdot 6 + 150 \cdot 1 = \mathbf{390}</span> m² Material bei 240 verfügbaren. Beide Vorräte sind fast doppelt überzogen — der Plan ist in der Werkstatt nicht ausführbar.</p></li>
 <li><p><strong>Der Fehler.</strong> Die Nebenbedingungen stehen <strong>innerhalb</strong> der Produktschleife. Dadurch entsteht je Produkt eine eigene Kapazitätsgrenze („der Tisch allein darf 150 Stunden verbrauchen“, „der Stuhl allein darf 150 Stunden verbrauchen“) statt einer <strong>gemeinsamen</strong> Grenze über alle Produkte hinweg. Die Ressource wird so für jedes Produkt neu verteilt — im Modell existiert sie mehrfach.</p></li>
@@ -28421,14 +30049,14 @@ Das zugehoerige Dockerfile ist kurz genug, um es ganz zu zeigen:
 <ol start="3" type="a">
 <li><strong>Korrektur.</strong> Die Summe über alle Produkte gehört <em>in</em> die Bedingung, die Schleife läuft über die <strong>Ressourcen</strong>, nicht über die Produkte:</li>
 </ol>
-<div class="sourceCode" id="cb226"><pre class="sourceCode python"><code class="sourceCode python"><span id="cb226-1"><a href="#cb226-1" aria-hidden="true" tabindex="-1"></a><span class="cf">for</span> r, index <span class="kw">in</span> [(<span class="st">&quot;Montagestunden&quot;</span>, <span class="dv">1</span>), (<span class="st">&quot;Plattenmaterial&quot;</span>, <span class="dv">2</span>)]:</span>
-<span id="cb226-2"><a href="#cb226-2" aria-hidden="true" tabindex="-1"></a>    s.Add(<span class="bu">sum</span>(x[p] <span class="op">*</span> produkt[p][index] <span class="cf">for</span> p <span class="kw">in</span> produkt) <span class="op">&lt;=</span> vorrat[r])</span></code></pre></div>
+<div class="sourceCode" id="cb230"><pre class="sourceCode python"><code class="sourceCode python"><span id="cb230-1"><a href="#cb230-1" aria-hidden="true" tabindex="-1"></a><span class="cf">for</span> r, index <span class="kw">in</span> [(<span class="st">&quot;Montagestunden&quot;</span>, <span class="dv">1</span>), (<span class="st">&quot;Plattenmaterial&quot;</span>, <span class="dv">2</span>)]:</span>
+<span id="cb230-2"><a href="#cb230-2" aria-hidden="true" tabindex="-1"></a>    s.Add(<span class="bu">sum</span>(x[p] <span class="op">*</span> produkt[p][index] <span class="cf">for</span> p <span class="kw">in</span> produkt) <span class="op">&lt;=</span> vorrat[r])</span></code></pre></div>
 <ol start="4" type="a">
 <li><strong>Automatische Absicherung.</strong> Nach jedem Lösen den tatsächlichen Verbrauch gegen den Vorrat prüfen — mit kleiner Toleranz, weil Solver mit endlicher Genauigkeit rechnen (siehe <a href="#kap-oekosystem">Kapitel 3</a>):</li>
 </ol>
-<div class="sourceCode" id="cb227"><pre class="sourceCode python"><code class="sourceCode python"><span id="cb227-1"><a href="#cb227-1" aria-hidden="true" tabindex="-1"></a><span class="cf">for</span> r, index <span class="kw">in</span> [(<span class="st">&quot;Montagestunden&quot;</span>, <span class="dv">1</span>), (<span class="st">&quot;Plattenmaterial&quot;</span>, <span class="dv">2</span>)]:</span>
-<span id="cb227-2"><a href="#cb227-2" aria-hidden="true" tabindex="-1"></a>    verbrauch <span class="op">=</span> <span class="bu">sum</span>(x[p].solution_value() <span class="op">*</span> produkt[p][index] <span class="cf">for</span> p <span class="kw">in</span> produkt)</span>
-<span id="cb227-3"><a href="#cb227-3" aria-hidden="true" tabindex="-1"></a>    <span class="cf">assert</span> verbrauch <span class="op">&lt;=</span> vorrat[r] <span class="op">+</span> <span class="fl">1e-6</span>, <span class="ss">f&quot;</span><span class="sc">{</span>r<span class="sc">}</span><span class="ss"> ueberzogen: </span><span class="sc">{</span>verbrauch<span class="sc">}</span><span class="ss"> &gt; </span><span class="sc">{</span>vorrat[r]<span class="sc">}</span><span class="ss">&quot;</span></span></code></pre></div>
+<div class="sourceCode" id="cb231"><pre class="sourceCode python"><code class="sourceCode python"><span id="cb231-1"><a href="#cb231-1" aria-hidden="true" tabindex="-1"></a><span class="cf">for</span> r, index <span class="kw">in</span> [(<span class="st">&quot;Montagestunden&quot;</span>, <span class="dv">1</span>), (<span class="st">&quot;Plattenmaterial&quot;</span>, <span class="dv">2</span>)]:</span>
+<span id="cb231-2"><a href="#cb231-2" aria-hidden="true" tabindex="-1"></a>    verbrauch <span class="op">=</span> <span class="bu">sum</span>(x[p].solution_value() <span class="op">*</span> produkt[p][index] <span class="cf">for</span> p <span class="kw">in</span> produkt)</span>
+<span id="cb231-3"><a href="#cb231-3" aria-hidden="true" tabindex="-1"></a>    <span class="cf">assert</span> verbrauch <span class="op">&lt;=</span> vorrat[r] <span class="op">+</span> <span class="fl">1e-6</span>, <span class="ss">f&quot;</span><span class="sc">{</span>r<span class="sc">}</span><span class="ss"> ueberzogen: </span><span class="sc">{</span>verbrauch<span class="sc">}</span><span class="ss"> &gt; </span><span class="sc">{</span>vorrat[r]<span class="sc">}</span><span class="ss">&quot;</span></span></code></pre></div>
 <p>Diese vier Zeilen sind das wichtigste Werkzeug des Kapitels: Sie prüfen die <strong>Lösung gegen die Wirklichkeit</strong>, nicht gegen das Modell. Ein Modellierungsfehler kann sich vor dem Solver verstecken, vor dieser Prüfung nicht.</p>
 <h3 id="quiz-loesung-einfuehrung">Micro-Quiz</h3>
 <p><strong>1 — (c) präskriptiv.</strong> Die Frage lautet „was tun“, und es gibt eine Restriktion (das Restbudget). Dass man für die Bewertung eine Prognose braucht, macht die Frage nicht prädiktiv — die Prognose ist hier <strong>Eingabeparameter</strong>, nicht Ergebnis.</p>
@@ -28451,11 +30079,11 @@ Das zugehoerige Dockerfile ist kurz genug, um es ganz zu zeigen:
 <p><strong>2.5 — Positive Semidefinitheit.</strong> <span class="math inline">\mathbf{P}_1</span>: Eigenwerte <span class="math inline">\approx (3{,}8;\ 9{,}2)</span> → PSD ✓, Korrelation <span class="math inline">1/\sqrt{4\cdot9} = 0{,}167</span> ✓. <span class="math inline">\mathbf{P}_2</span>: Eigenwerte <span class="math inline">\approx (-0{,}6;\ 13{,}6)</span> → <strong>nicht PSD</strong>; implizierte Korrelation <span class="math inline">7/\sqrt{36} = 1{,}167 &gt; 1</span> — unmöglich. <span class="math inline">\mathbf{P}_3</span>: Eigenwerte <span class="math inline">(0{,}5;\ 0{,}5;\ 2{,}0)</span> → PSD ✓.</p>
 <p><strong>2.6 — Bäckerei visualisieren.</strong> Ecken: <span class="math inline">(40,0)</span>, <span class="math inline">(150,0)</span>, <span class="math inline">(40,116{,}67)</span> und der Schnittpunkt von Mehl- und Ofengrenze. Beste Ecke ist <span class="math inline">(40;\ 116{,}67)</span> mit <span class="math inline">Z = 450</span> (im kontinuierlichen Fall).</p>
 <p><strong>2.7 — Eigenwert-Clipping.</strong></p>
-<div class="sourceCode" id="cb228"><pre class="sourceCode python"><code class="sourceCode python"><span id="cb228-1"><a href="#cb228-1" aria-hidden="true" tabindex="-1"></a><span class="kw">def</span> repariere(P):</span>
-<span id="cb228-2"><a href="#cb228-2" aria-hidden="true" tabindex="-1"></a>    lam, V <span class="op">=</span> np.linalg.eigh(P)</span>
-<span id="cb228-3"><a href="#cb228-3" aria-hidden="true" tabindex="-1"></a>    <span class="cf">return</span> V <span class="op">@</span> np.diag(np.maximum(lam, <span class="fl">0.0</span>)) <span class="op">@</span> V.T</span></code></pre></div>
+<div class="sourceCode" id="cb232"><pre class="sourceCode python"><code class="sourceCode python"><span id="cb232-1"><a href="#cb232-1" aria-hidden="true" tabindex="-1"></a><span class="kw">def</span> repariere(P):</span>
+<span id="cb232-2"><a href="#cb232-2" aria-hidden="true" tabindex="-1"></a>    lam, V <span class="op">=</span> np.linalg.eigh(P)</span>
+<span id="cb232-3"><a href="#cb232-3" aria-hidden="true" tabindex="-1"></a>    <span class="cf">return</span> V <span class="op">@</span> np.diag(np.maximum(lam, <span class="fl">0.0</span>)) <span class="op">@</span> V.T</span></code></pre></div>
 <p>Für <span class="math inline">\mathbf{P}_2</span> ergibt sich eine PSD-Matrix mit Korrelation exakt <span class="math inline">1{,}0</span> — das Verfahren zieht die unmögliche Korrelation auf den nächstgelegenen zulässigen Wert. Für Kovarianzmatrizen setzt man in der Praxis auf einen kleinen positiven Wert statt auf 0 (<code>np.maximum(lam, 1e-10)</code>), damit die Matrix invertierbar bleibt.</p>
-<h3 id="finde-den-denkfehler-2.1-die-unauffällige-transposition">Finde den Denkfehler 2.1 — Die unauffällige Transposition</h3>
+<h3 id="finde-den-denkfehler-die-unauffällige-transposition">Finde den Denkfehler — Die unauffällige Transposition</h3>
 <ol type="a">
 <li><p><strong>Warum nichts auffällt.</strong> <span class="math inline">\mathbf{A}</span> ist quadratisch, also passen die Dimensionen auch transponiert. NumPy prüft Formen, nicht Bedeutungen; der Solver bekommt ein vollkommen zulässiges LP vorgelegt und löst es korrekt — nur eben ein <strong>anderes</strong>. Eine Transposition ist genau dann gefährlich, wenn sie folgenlos <em>aussieht</em>: Wäre die Matrix <span class="math inline">2 \times 3</span> gewesen, hätte NumPy sofort einen Dimensionsfehler geworfen.</p></li>
 <li><p><strong>Der Plan an den echten Restriktionen.</strong> Mit <span class="math inline">\mathbf{A} = \begin{pmatrix} 1 &amp; 2 \\ 3 &amp; 1\end{pmatrix}</span> und <span class="math inline">\mathbf{x} = (5{,}6;\ 0{,}8)</span>:</p></li>
@@ -28463,11 +30091,11 @@ Das zugehoerige Dockerfile ist kurz genug, um es ganz zu zeigen:
 <p><span class="math display">\mathbf{A}\mathbf{x} = \begin{pmatrix} 1\cdot5{,}6 + 2\cdot0{,}8 \\ 3\cdot5{,}6 + 1\cdot0{,}8\end{pmatrix} = \begin{pmatrix} 7{,}2 \\ 17{,}6 \end{pmatrix} \quad\text{gegen}\quad \mathbf{b} = \begin{pmatrix} 8 \\ 12\end{pmatrix}</span></p>
 <p>Die zweite Ressource ist um <strong>47 % überzogen</strong> (17,6 statt 12). Der Plan ist in der Werkstatt nicht ausführbar.</p>
 <ol start="3" type="a">
-<li><p><strong>Warum „zu klein“ schlimmer ist als „zu groß“.</strong> Ein unerwartet <em>hoher</em> Zielwert weckt Misstrauen — man rechnet nach (siehe Denkfehler 1.1). Ein leicht <em>niedrigerer</em> Wert wirkt dagegen wie ein normales, etwas enttäuschendes Ergebnis: Niemand prüft nach, warum die Optimierung „nur“ 20,80 € statt der erhofften 22 € bringt. Fehler, die sich als Bescheidenheit tarnen, überleben am längsten.</p></li>
+<li><p><strong>Warum „zu klein“ schlimmer ist als „zu groß“.</strong> Ein unerwartet <em>hoher</em> Zielwert weckt Misstrauen — man rechnet nach (siehe <a href="#sec:einfuehrung-denkfehler">Abschnitt 1.10</a>). Ein leicht <em>niedrigerer</em> Wert wirkt dagegen wie ein normales, etwas enttäuschendes Ergebnis: Niemand prüft nach, warum die Optimierung „nur“ 20,80 € statt der erhofften 22 € bringt. Fehler, die sich als Bescheidenheit tarnen, überleben am längsten.</p></li>
 <li><p><strong>Zwei Zeilen, die es aufgedeckt hätten.</strong> Erstens beim Einlesen die Form gegen die Bedeutung prüfen, zweitens nach dem Lösen den Verbrauch gegen den Vorrat:</p></li>
 </ol>
-<div class="sourceCode" id="cb229"><pre class="sourceCode python"><code class="sourceCode python"><span id="cb229-1"><a href="#cb229-1" aria-hidden="true" tabindex="-1"></a><span class="cf">assert</span> A.shape <span class="op">==</span> (<span class="bu">len</span>(b), <span class="bu">len</span>(c)), <span class="st">&quot;A: Zeilen = Ressourcen, Spalten = Variablen&quot;</span></span>
-<span id="cb229-2"><a href="#cb229-2" aria-hidden="true" tabindex="-1"></a><span class="cf">assert</span> np.<span class="bu">all</span>(A <span class="op">@</span> r.x <span class="op">&lt;=</span> b <span class="op">+</span> <span class="fl">1e-9</span>), <span class="ss">f&quot;Plan verletzt Restriktionen: </span><span class="sc">{</span>A <span class="op">@</span> r<span class="sc">.</span>x<span class="sc">}</span><span class="ss"> &gt; </span><span class="sc">{</span>b<span class="sc">}</span><span class="ss">&quot;</span></span></code></pre></div>
+<div class="sourceCode" id="cb233"><pre class="sourceCode python"><code class="sourceCode python"><span id="cb233-1"><a href="#cb233-1" aria-hidden="true" tabindex="-1"></a><span class="cf">assert</span> A.shape <span class="op">==</span> (<span class="bu">len</span>(b), <span class="bu">len</span>(c)), <span class="st">&quot;A: Zeilen = Ressourcen, Spalten = Variablen&quot;</span></span>
+<span id="cb233-2"><a href="#cb233-2" aria-hidden="true" tabindex="-1"></a><span class="cf">assert</span> np.<span class="bu">all</span>(A <span class="op">@</span> r.x <span class="op">&lt;=</span> b <span class="op">+</span> <span class="fl">1e-9</span>), <span class="ss">f&quot;Plan verletzt Restriktionen: </span><span class="sc">{</span>A <span class="op">@</span> r<span class="sc">.</span>x<span class="sc">}</span><span class="ss"> &gt; </span><span class="sc">{</span>b<span class="sc">}</span><span class="ss">&quot;</span></span></code></pre></div>
 <p>Die erste Zeile hilft nur bei rechteckigem <span class="math inline">\mathbf{A}</span> — die zweite <strong>immer</strong>. Sie ist die wichtigste Zeile in jedem Optimierungsskript: Sie prüft die Lösung nicht gegen das Modell, sondern gegen die Wirklichkeit, die das Modell abbilden sollte.</p>
 <p>Vorbeugend hilft außerdem, Matrizen nie positionsweise abzutippen, sondern über benannte Spalten aus einer Tabelle zu erzeugen — genau das tut <code>Excel_Bruecke.py</code> aus <a href="#kap-einfuehrung">Kapitel 1</a>.</p>
 <h3 id="quiz-loesung-fundament">Micro-Quiz</h3>
@@ -28490,7 +30118,7 @@ Das zugehoerige Dockerfile ist kurz genug, um es ganz zu zeigen:
 <p><strong>3.4 — Konvexitätsprüfung.</strong> <span class="math inline">\min x^3</span> wirft <code>DCPError: Problem does not follow DCP rules</code>, weil <span class="math inline">x^3</span> auf <span class="math inline">[-2,2]</span> weder konvex noch konkav ist. <span class="math inline">\min x^2</span> läuft und liefert <span class="math inline">x=0</span>. Der Unterschied: CVXPY akzeptiert nur Ausdrücke, deren Konvexität es <strong>beweisen</strong> kann — dafür garantiert es das globale Optimum.</p>
 <p><strong>3.5 — Laufzeitvergleich.</strong> Erwartetes Muster: <code>linprog</code> und <code>highspy</code> liegen bei kleinen Modellen gleichauf (Overhead dominiert); ab etwa <span class="math inline">n \gtrsim 500</span> zieht <code>highspy</code> davon, weil der Modellaufbau effizienter ist. CVXPY hat den größten festen Aufwand (Ausdrucksbaum-Kompilierung), der bei wiederholten Läufen mit <code>cp.Parameter</code> teilweise entfällt.</p>
 <p><strong>3.6 — Eigene Entscheidungshilfe.</strong> Ergänzungen: Bei kommerzieller Lizenz Gurobi/CPLEX über Pyomo oder CVXPY empfehlen; bei Lesbarkeitsanforderung Pyomo (algebraische Notation, Trennung von Daten und Modell).</p>
-<h3 id="finde-den-denkfehler-3.1-der-solver-der-angeblich-dreimal-schneller-ist">Finde den Denkfehler 3.1 — Der Solver, der angeblich dreimal schneller ist</h3>
+<h3 id="finde-den-denkfehler-der-solver-der-angeblich-dreimal-schneller-ist">Finde den Denkfehler — Der Solver, der angeblich dreimal schneller ist</h3>
 <ol type="a">
 <li><strong>Was da alles mitgemessen wird.</strong> Die Stoppuhr läuft ab der ersten Zeile, also mindestens über drei Dinge, die mit Lösegeschwindigkeit nichts zu tun haben:</li>
 </ol>
@@ -28503,24 +30131,24 @@ Das zugehoerige Dockerfile ist kurz genug, um es ganz zu zeigen:
 <li><p><strong>Warum das bei 60 Wiederholungen kippt.</strong> Import und Kompilierung fallen <strong>einmal</strong> an, das Lösen <strong>sechzigmal</strong>. Genau dafür hat CVXPY <code>cp.Parameter</code>: Man baut das Problem einmal, tauscht nur die Daten und löst erneut, ohne neu zu kompilieren. Gemessen wurde also ausgerechnet der Teil, der in der Zielanwendung fast nicht mehr vorkommt — die Entscheidung beruht auf der unwichtigsten Zahl.</p></li>
 <li><p><strong>Eine Messung, die trägt.</strong> Drei Regeln:</p></li>
 </ol>
-<div class="sourceCode" id="cb230"><pre class="sourceCode python"><code class="sourceCode python"><span id="cb230-1"><a href="#cb230-1" aria-hidden="true" tabindex="-1"></a><span class="co"># 1. Importe VOR die Messung</span></span>
-<span id="cb230-2"><a href="#cb230-2" aria-hidden="true" tabindex="-1"></a><span class="im">import</span> cvxpy <span class="im">as</span> cp</span>
-<span id="cb230-3"><a href="#cb230-3" aria-hidden="true" tabindex="-1"></a><span class="im">from</span> scipy.optimize <span class="im">import</span> linprog</span>
-<span id="cb230-4"><a href="#cb230-4" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb230-5"><a href="#cb230-5" aria-hidden="true" tabindex="-1"></a><span class="co"># 2. Aufwaermlauf: einmal alles durchlaufen lassen, Ergebnis verwerfen</span></span>
-<span id="cb230-6"><a href="#cb230-6" aria-hidden="true" tabindex="-1"></a>loese_klein()</span>
-<span id="cb230-7"><a href="#cb230-7" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb230-8"><a href="#cb230-8" aria-hidden="true" tabindex="-1"></a><span class="co"># 3. Aufbau und Loesen GETRENNT messen, ueber mehrere Wiederholungen</span></span>
-<span id="cb230-9"><a href="#cb230-9" aria-hidden="true" tabindex="-1"></a>t0 <span class="op">=</span> time.perf_counter()</span>
-<span id="cb230-10"><a href="#cb230-10" aria-hidden="true" tabindex="-1"></a>problem <span class="op">=</span> cp.Problem(cp.Minimize(kosten <span class="op">@</span> x), [A <span class="op">@</span> x <span class="op">==</span> b])   <span class="co"># Aufbau</span></span>
-<span id="cb230-11"><a href="#cb230-11" aria-hidden="true" tabindex="-1"></a>t_aufbau <span class="op">=</span> time.perf_counter() <span class="op">-</span> t0</span>
-<span id="cb230-12"><a href="#cb230-12" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb230-13"><a href="#cb230-13" aria-hidden="true" tabindex="-1"></a>zeiten <span class="op">=</span> []</span>
-<span id="cb230-14"><a href="#cb230-14" aria-hidden="true" tabindex="-1"></a><span class="cf">for</span> _ <span class="kw">in</span> <span class="bu">range</span>(<span class="dv">10</span>):</span>
-<span id="cb230-15"><a href="#cb230-15" aria-hidden="true" tabindex="-1"></a>    t0 <span class="op">=</span> time.perf_counter()</span>
-<span id="cb230-16"><a href="#cb230-16" aria-hidden="true" tabindex="-1"></a>    problem.solve()</span>
-<span id="cb230-17"><a href="#cb230-17" aria-hidden="true" tabindex="-1"></a>    zeiten.append(time.perf_counter() <span class="op">-</span> t0)</span>
-<span id="cb230-18"><a href="#cb230-18" aria-hidden="true" tabindex="-1"></a><span class="bu">print</span>(<span class="ss">f&quot;Aufbau </span><span class="sc">{</span>t_aufbau<span class="sc">:.3f}</span><span class="ss">s, Loesen Median </span><span class="sc">{</span>statistics<span class="sc">.</span>median(zeiten)<span class="sc">:.3f}</span><span class="ss">s&quot;</span>)</span></code></pre></div>
+<div class="sourceCode" id="cb234"><pre class="sourceCode python"><code class="sourceCode python"><span id="cb234-1"><a href="#cb234-1" aria-hidden="true" tabindex="-1"></a><span class="co"># 1. Importe VOR die Messung</span></span>
+<span id="cb234-2"><a href="#cb234-2" aria-hidden="true" tabindex="-1"></a><span class="im">import</span> cvxpy <span class="im">as</span> cp</span>
+<span id="cb234-3"><a href="#cb234-3" aria-hidden="true" tabindex="-1"></a><span class="im">from</span> scipy.optimize <span class="im">import</span> linprog</span>
+<span id="cb234-4"><a href="#cb234-4" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb234-5"><a href="#cb234-5" aria-hidden="true" tabindex="-1"></a><span class="co"># 2. Aufwaermlauf: einmal alles durchlaufen lassen, Ergebnis verwerfen</span></span>
+<span id="cb234-6"><a href="#cb234-6" aria-hidden="true" tabindex="-1"></a>loese_klein()</span>
+<span id="cb234-7"><a href="#cb234-7" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb234-8"><a href="#cb234-8" aria-hidden="true" tabindex="-1"></a><span class="co"># 3. Aufbau und Loesen GETRENNT messen, ueber mehrere Wiederholungen</span></span>
+<span id="cb234-9"><a href="#cb234-9" aria-hidden="true" tabindex="-1"></a>t0 <span class="op">=</span> time.perf_counter()</span>
+<span id="cb234-10"><a href="#cb234-10" aria-hidden="true" tabindex="-1"></a>problem <span class="op">=</span> cp.Problem(cp.Minimize(kosten <span class="op">@</span> x), [A <span class="op">@</span> x <span class="op">==</span> b])   <span class="co"># Aufbau</span></span>
+<span id="cb234-11"><a href="#cb234-11" aria-hidden="true" tabindex="-1"></a>t_aufbau <span class="op">=</span> time.perf_counter() <span class="op">-</span> t0</span>
+<span id="cb234-12"><a href="#cb234-12" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb234-13"><a href="#cb234-13" aria-hidden="true" tabindex="-1"></a>zeiten <span class="op">=</span> []</span>
+<span id="cb234-14"><a href="#cb234-14" aria-hidden="true" tabindex="-1"></a><span class="cf">for</span> _ <span class="kw">in</span> <span class="bu">range</span>(<span class="dv">10</span>):</span>
+<span id="cb234-15"><a href="#cb234-15" aria-hidden="true" tabindex="-1"></a>    t0 <span class="op">=</span> time.perf_counter()</span>
+<span id="cb234-16"><a href="#cb234-16" aria-hidden="true" tabindex="-1"></a>    problem.solve()</span>
+<span id="cb234-17"><a href="#cb234-17" aria-hidden="true" tabindex="-1"></a>    zeiten.append(time.perf_counter() <span class="op">-</span> t0)</span>
+<span id="cb234-18"><a href="#cb234-18" aria-hidden="true" tabindex="-1"></a><span class="bu">print</span>(<span class="ss">f&quot;Aufbau </span><span class="sc">{</span>t_aufbau<span class="sc">:.3f}</span><span class="ss">s, Loesen Median </span><span class="sc">{</span>statistics<span class="sc">.</span>median(zeiten)<span class="sc">:.3f}</span><span class="ss">s&quot;</span>)</span></code></pre></div>
 <p>Und die vierte, wichtigste Regel: <strong>die Größe messen, die später auch läuft.</strong> Ein Vergleich bei 200 Variablen sagt nichts über das Verhalten bei 200 000 — die Kurven schneiden sich oft. Genau diese Trennung führt <code>Vektorisierte_Modellgenerierung.py</code> vor, und <a href="#kap-praxisfallen">Kapitel 22</a> baut daraus eine vollständige Benchmark-Pipeline.</p>
 <h3 id="quiz-loesung-oekosystem">Micro-Quiz</h3>
 <p><strong>1 — (b) CP-SAT.</strong> Es geht um diskrete Zuweisung mit logischen Regeln („nicht gleichzeitig“) — CP-SATs Kerngebiet, und Regeln dieser Art formuliert man dort direkt statt über Big-M-Umwege. (a) scheidet aus, weil CVXPY keine sinnvolle Ganzzahligkeit in dieser Größenordnung bietet; (c) findet bei einem diskreten Problem bestenfalls ein lokales Optimum und hat keinerlei Handhabe für „entweder–oder“-Regeln.</p>
@@ -28536,19 +30164,20 @@ Das zugehoerige Dockerfile ist kurz genug, um es ganz zu zeigen:
 </ol>
 <hr />
 <h2 id="sec:loesungen-modellierung">A.4 Lösungen zu Kapitel „Vom Management-Wunsch zum Modell“</h2>
-<p><strong>Die fehlende Lesart.</strong> Eine dritte Lesart: <strong>„Der Umsatzanteil der Stammkunden darf nicht unter 30 % fallen.”</strong> Sie zielt weder auf einzelne Aufträge noch auf einzelne Kunden, sondern auf das Gesamtbild. Sie beschreibt einen Betrieb, dem die <em>Struktur</em> seines Geschäfts wichtig ist — etwa weil Stammkunden verlässlicher zahlen oder weil eine zu große Abhängigkeit von Neukunden als Risiko gilt. Sie lässt zu, dass ein einzelner Stammkunde in einem Quartal leer ausgeht, solange die Summe stimmt.</p>
+<p><strong>4.1 — Die fehlende Lesart.</strong> Eine dritte Lesart: <strong>„Der Umsatzanteil der Stammkunden darf nicht unter 30 % fallen.”</strong> Sie zielt weder auf einzelne Aufträge noch auf einzelne Kunden, sondern auf das Gesamtbild. Sie beschreibt einen Betrieb, dem die <em>Struktur</em> seines Geschäfts wichtig ist — etwa weil Stammkunden verlässlicher zahlen oder weil eine zu große Abhängigkeit von Neukunden als Risiko gilt. Sie lässt zu, dass ein einzelner Stammkunde in einem Quartal leer ausgeht, solange die Summe stimmt.</p>
 <p>Der Punkt der Aufgabe: Alle drei Lesarten sind vertretbar, und keine ist aus dem Satz ableitbar. Die Wahl trifft man — im Zweifel unbewusst.</p>
-<p><strong>Frage 5 anwenden.</strong> Wird die <em>durchschnittliche</em> Wartezeit minimiert, lohnt es sich, viele leichte Fälle schnell abzuarbeiten und die aufwendigen nach hinten zu schieben: Ein Fall mit vier Stunden Wartezeit zählt genauso viel wie vier Fälle mit einer Stunde. Der optimale Plan behandelt also bevorzugt Bagatellen und lässt schwere Fälle warten — medizinisch das Gegenteil des Gewollten.</p>
+<p><strong>4.2 — Frage 5 anwenden.</strong> Wird die <em>durchschnittliche</em> Wartezeit minimiert, lohnt es sich, viele leichte Fälle schnell abzuarbeiten und die aufwendigen nach hinten zu schieben: Ein Fall mit vier Stunden Wartezeit zählt genauso viel wie vier Fälle mit einer Stunde. Der optimale Plan behandelt also bevorzugt Bagatellen und lässt schwere Fälle warten — medizinisch das Gegenteil des Gewollten.</p>
 <p>Das ist genau der Ertrag von Frage 5: Der Plan lässt sich <em>ablehnen</em>, und aus der Ablehnung folgt die richtige Zielgröße — etwa die maximale Wartezeit je Dringlichkeitsstufe, oder die Einhaltung von Zielzeiten je Triage-Kategorie.</p>
-<p><strong>Der Kompromiss dazwischen.</strong> Je Stammkunde eine Nebenbedingung: Die Summe der zugeteilten Stunden dieses Kunden muss mindestens die Hälfte seiner angefragten Stunden betragen.</p>
-<div class="sourceCode" id="cb231"><pre class="sourceCode python"><code class="sourceCode python"><span id="cb231-1"><a href="#cb231-1" aria-hidden="true" tabindex="-1"></a><span class="cf">for</span> kunde <span class="kw">in</span> STAMMKUNDEN:</span>
-<span id="cb231-2"><a href="#cb231-2" aria-hidden="true" tabindex="-1"></a>    stunden_kunde <span class="op">=</span> [a[<span class="dv">3</span>] <span class="cf">if</span> a[<span class="dv">1</span>] <span class="op">==</span> kunde <span class="cf">else</span> <span class="dv">0</span> <span class="cf">for</span> a <span class="kw">in</span> AUFTRAEGE]</span>
-<span id="cb231-3"><a href="#cb231-3" aria-hidden="true" tabindex="-1"></a>    je_kunde_ub.append([<span class="op">-</span>s <span class="cf">for</span> s <span class="kw">in</span> stunden_kunde])</span>
-<span id="cb231-4"><a href="#cb231-4" aria-hidden="true" tabindex="-1"></a>    je_kunde_b.append(<span class="op">-</span><span class="fl">0.5</span> <span class="op">*</span> <span class="bu">sum</span>(stunden_kunde))</span></code></pre></div>
+<p><strong>4.3 — Der Kompromiss dazwischen.</strong> Je Stammkunde eine Nebenbedingung: Die Summe der zugeteilten Stunden dieses Kunden muss mindestens die Hälfte seiner angefragten Stunden betragen.</p>
+<div class="sourceCode" id="cb235"><pre class="sourceCode python"><code class="sourceCode python"><span id="cb235-1"><a href="#cb235-1" aria-hidden="true" tabindex="-1"></a><span class="cf">for</span> kunde <span class="kw">in</span> STAMMKUNDEN:</span>
+<span id="cb235-2"><a href="#cb235-2" aria-hidden="true" tabindex="-1"></a>    stunden_kunde <span class="op">=</span> [a[<span class="dv">3</span>] <span class="cf">if</span> a[<span class="dv">1</span>] <span class="op">==</span> kunde <span class="cf">else</span> <span class="dv">0</span> <span class="cf">for</span> a <span class="kw">in</span> AUFTRAEGE]</span>
+<span id="cb235-3"><a href="#cb235-3" aria-hidden="true" tabindex="-1"></a>    je_kunde_ub.append([<span class="op">-</span>s <span class="cf">for</span> s <span class="kw">in</span> stunden_kunde])</span>
+<span id="cb235-4"><a href="#cb235-4" aria-hidden="true" tabindex="-1"></a>    je_kunde_b.append(<span class="op">-</span><span class="fl">0.5</span> <span class="op">*</span> <span class="bu">sum</span>(stunden_kunde))</span></code></pre></div>
 <p>Erwartung: Das Ergebnis liegt zwischen Lesart A und B — die Regel bindet stärker als „ein Auftrag genügt”, aber schwächer als „alle Aufträge”. Der Lehrpunkt ist nicht die Zahl, sondern dass sich zwischen zwei Lesarten beliebig fein abstufen lässt, sobald man sie einmal als Ungleichung geschrieben hat.</p>
-<p><strong>Zwei Ziele gleichzeitig.</strong> Bei <span class="math inline">\lambda = 0</span> ergibt sich der DB-Plan (78 500 € DB), bei großem <span class="math inline">\lambda</span> der Umsatzplan (66 000 € DB). Dazwischen kippt es an genau einer Stelle — und zwar <strong>sprunghaft</strong>, nicht allmählich: Weil die Entscheidungsvariablen binär sind, gibt es nur endlich viele Pläne, und der Wechsel erfolgt, sobald ein anderer Plan den höheren gewichteten Wert hat.</p>
+<p><strong>4.4 — Zwei Ziele gleichzeitig.</strong> Bei <span class="math inline">\lambda = 0</span> ergibt sich der DB-Plan (78 500 € DB), bei großem <span class="math inline">\lambda</span> der Umsatzplan (66 000 € DB). Dazwischen kippt es an genau einer Stelle — und zwar <strong>sprunghaft</strong>, nicht allmählich: Weil die Entscheidungsvariablen binär sind, gibt es nur endlich viele Pläne, und der Wechsel erfolgt, sobald ein anderer Plan den höheren gewichteten Wert hat.</p>
 <p>Der Kippwert sagt dem Betrieb etwas Konkretes: <em>„Erst wenn Ihnen ein Euro Umsatz mehr wert ist als λ Euro Deckungsbeitrag, ändert sich Ihr Plan.”</em> Das ist eine Frage, die ein Kaufmann beantworten kann — anders als „welche Gewichtung hätten Sie gern?“.</p>
-<p><strong>Die Anforderung schreiben.</strong> Eine tragfähige Anforderung enthält mindestens:</p>
+<p><strong>4.5 — Übersetzen, wo es nicht eindeutig ist.</strong> (a) Drei Lesarten von „gleichmäßig ausgelastet”: <strong>(1) Spannweite minimieren</strong> — <span class="math inline">\max_i a_i - \min_i a_i</span>. Bestraft Ausreißer nach beiden Seiten; ein einzelner Untätiger ist genauso schlimm wie ein Überlasteter. <strong>(2) Den Schlechtestgestellten verbessern</strong> — <span class="math inline">\max_i a_i</span> minimieren (B11). Interessiert sich nicht dafür, wie ungleich die übrigen liegen, solange die Spitze sinkt. <strong>(3) Abweichung vom Mittel minimieren</strong> — <span class="math inline">\sum_i |a_i - \bar a|</span> (B10). Verteilt die Last am gleichmäßigsten, kann aber die Spitze höher lassen als (2). Wo es sichtbar wird: Bei fünf Monteuren mit 8, 8, 8, 8 und 16 Stunden senkt (2) die 16 zuerst; bei 4, 8, 8, 8, 12 tut (1) am meisten gegen die Spreizung, während (2) kaum etwas findet. Und wenn ein Monteur aus guten Gründen nur halbtags da ist, bestrafen (1) und (3) genau das — (2) nicht. (b) Hart: <span class="math inline">w_k \le 3</span> für jeden Kunden <span class="math inline">k</span>. Weich: <span class="math inline">w_k \le 3 + s_k</span> mit <span class="math inline">s_k \ge 0</span> und Strafkosten <span class="math inline">c \cdot s_k</span> in der Zielfunktion (B8, B18). Die Frage an den Betrieb ist die dritte der vier: <em>Was passiert, wenn es einmal nicht geht?</em> Führt die Antwort zu „dann müssen wir eben” — weich. Führt sie zu „das darf nicht passieren, dann rufen wir an und verschieben” — dann ist auch das ein Prozess, und die Bedingung bleibt weich, nur mit sehr hohen Strafkosten. Wirklich hart ist sie nur, wenn ein Verstoß rechtlich unmöglich ist. (c) Individuell. Prüfkriterium: Wird eine Wendung gefunden, die <strong>zwei</strong> vertretbare Modelle zulässt — und wird benannt, wer die Wahl treffen muss? Die häufigsten Kandidaten in echten Anforderungen sind „in der Regel”, „zeitnah”, „vergleichbar” und jede Zahl ohne Bezugszeitraum.</p>
+<p><strong>4.6 — Die Anforderung schreiben.</strong> Eine tragfähige Anforderung enthält mindestens:</p>
 <ul>
 <li><strong>Entscheidung:</strong> Für jede Anfrage im Planungszeitraum: annehmen oder ablehnen.</li>
 <li><strong>Ziel:</strong> Deckungsbeitrag maximieren (Umsatz minus Material).</li>
@@ -28611,14 +30240,14 @@ Das zugehoerige Dockerfile ist kurz genug, um es ganz zu zeigen:
 </ol>
 <hr />
 <h2 id="sec:loesungen-lp">A.5 Lösungen zu Kapitel „Lineare Programmierung — Simplex, Dualität und Schattenpreise“</h2>
-<p><strong>4.1 — Schlupf deuten.</strong> (a) Ressourcen 1 und 3 (Schlupf 0). (b) Ja: Überall ist <span class="math inline">s_i \cdot y_i = 0</span>. (c) In Ressource 3 — der höchste Schattenpreis (9,8) bedeutet den größten Grenznutzen.</p>
-<p><strong>4.2 — Vorzeichen.</strong> Er hat die Zielfunktion für <code>linprog</code> negiert und die Dualwerte nicht zurückgedreht. Der korrekte Schattenpreis ist <strong>+45 €</strong>.</p>
-<p><strong>4.3 — Simplex von Hand.</strong> Starttableau mit <span class="math inline">s_1, s_2</span> in der Basis. Erste Iteration: Pivotspalte <span class="math inline">x_1</span> (<span class="math inline">-5</span>), Quotienten <span class="math inline">24/6 = 4</span> und <span class="math inline">6/1 = 6</span> → Pivotzeile 1. Nach dem Tausch: <span class="math inline">x_1 = 4</span>, <span class="math inline">Z = 20</span>. Zweite Iteration: Pivotspalte <span class="math inline">x_2</span>, Pivotzeile 2 → <span class="math inline">x_1 = 3</span>, <span class="math inline">x_2 = 1{,}5</span>, <span class="math inline">Z = 21</span>. <strong>Optimum:</strong> <span class="math inline">\mathbf{x}^* = (3;\ 1{,}5)</span>, <span class="math inline">Z^* = 21</span>, Schattenpreise <span class="math inline">y^* = (0{,}75;\ 0{,}50)</span>.</p>
-<p><strong>4.4 — Duales Problem.</strong> <span class="math inline">\min 24y_1 + 6y_2</span> u. d. N. <span class="math inline">6y_1 + y_2 \ge 5</span>, <span class="math inline">4y_1 + 2y_2 \ge 4</span>, <span class="math inline">y \ge 0</span>. Lösung <span class="math inline">y^* = (0{,}75;\ 0{,}50)</span>. Probe der Restriktionen: <span class="math inline">6\cdot0{,}75 + 0{,}5 = 5</span> ✓ (mit Gleichheit, weil <span class="math inline">x_1 &gt; 0</span>), <span class="math inline">4\cdot0{,}75 + 2\cdot0{,}5 = 4</span> ✓ (ebenfalls Gleichheit, weil <span class="math inline">x_2 &gt; 0</span>). Zielwert <span class="math inline">24\cdot0{,}75 + 6\cdot0{,}5 = 18 + 3 = 21 = Z^*</span> ✓ — starker Dualitätssatz bestätigt.</p>
-<p><strong>4.5 — Unbeschränktheit.</strong> Der Solver wirft „Problem ist unbeschränkt“. Geometrisch: Der zulässige Bereich <span class="math inline">\{x_1 - x_2 \le 5,\ x \ge 0\}</span> ist nach oben offen — man kann <span class="math inline">x_1</span> und <span class="math inline">x_2</span> gemeinsam beliebig wachsen lassen (z. B. <span class="math inline">x_1 = x_2 = t</span> für <span class="math inline">t \to \infty</span>), ohne eine Bedingung zu verletzen, und <span class="math inline">Z = 2t</span> wächst mit. In der Praxis fehlt fast immer eine Kapazitätsgrenze.</p>
-<p><strong>4.6 — Gültigkeitsbereich.</strong> (a) Bei ca. 66,7 Stunden Prüfkapazität wird die <strong>Lackierzeit</strong> zum Engpass; der Schattenpreis der Prüfung fällt dann. (b) Zukaufen lohnt bis zu dem Punkt, an dem der Schattenpreis unter 18 €/h fällt. (c) Der Gewinnverlauf ist <strong>stückweise linear und konkav</strong>: Jedes Teilstück hat die Steigung des jeweils gültigen Schattenpreises, und die Steigungen werden immer flacher — jede zusätzliche Einheit bringt weniger, weil andere Engpässe nachrücken.</p>
-<p><strong>4.7 — Phase 1.</strong> Ansatz: Für jede Zeile mit <span class="math inline">b_i &lt; 0</span> (nach Umformung zu <span class="math inline">\ge</span>) eine künstliche Variable <span class="math inline">a_i \ge 0</span> einführen, Hilfszielfunktion <span class="math inline">\min \sum a_i</span> lösen. Ist das Minimum 0, existiert eine zulässige Basislösung, und man startet Phase 2 mit dem erreichten Tableau. Ist es <span class="math inline">&gt; 0</span>, ist das Problem unzulässig. Für das Beispiel: Optimum <span class="math inline">(12;\ 0)</span>, <span class="math inline">Z = 36</span>.</p>
-<h3 id="finde-den-denkfehler-4.1-die-380-000-euro-maschine">Finde den Denkfehler 4.1 — Die 380 000-Euro-Maschine</h3>
+<p><strong>5.1 — Schlupf deuten.</strong> (a) Ressourcen 1 und 3 (Schlupf 0). (b) Ja: Überall ist <span class="math inline">s_i \cdot y_i = 0</span>. (c) In Ressource 3 — der höchste Schattenpreis (9,8) bedeutet den größten Grenznutzen.</p>
+<p><strong>5.2 — Vorzeichen.</strong> Er hat die Zielfunktion für <code>linprog</code> negiert und die Dualwerte nicht zurückgedreht. Der korrekte Schattenpreis ist <strong>+45 €</strong>.</p>
+<p><strong>5.3 — Simplex von Hand.</strong> Starttableau mit <span class="math inline">s_1, s_2</span> in der Basis. Erste Iteration: Pivotspalte <span class="math inline">x_1</span> (<span class="math inline">-5</span>), Quotienten <span class="math inline">24/6 = 4</span> und <span class="math inline">6/1 = 6</span> → Pivotzeile 1. Nach dem Tausch: <span class="math inline">x_1 = 4</span>, <span class="math inline">Z = 20</span>. Zweite Iteration: Pivotspalte <span class="math inline">x_2</span>, Pivotzeile 2 → <span class="math inline">x_1 = 3</span>, <span class="math inline">x_2 = 1{,}5</span>, <span class="math inline">Z = 21</span>. <strong>Optimum:</strong> <span class="math inline">\mathbf{x}^* = (3;\ 1{,}5)</span>, <span class="math inline">Z^* = 21</span>, Schattenpreise <span class="math inline">y^* = (0{,}75;\ 0{,}50)</span>.</p>
+<p><strong>5.4 — Duales Problem.</strong> <span class="math inline">\min 24y_1 + 6y_2</span> u. d. N. <span class="math inline">6y_1 + y_2 \ge 5</span>, <span class="math inline">4y_1 + 2y_2 \ge 4</span>, <span class="math inline">y \ge 0</span>. Lösung <span class="math inline">y^* = (0{,}75;\ 0{,}50)</span>. Probe der Restriktionen: <span class="math inline">6\cdot0{,}75 + 0{,}5 = 5</span> ✓ (mit Gleichheit, weil <span class="math inline">x_1 &gt; 0</span>), <span class="math inline">4\cdot0{,}75 + 2\cdot0{,}5 = 4</span> ✓ (ebenfalls Gleichheit, weil <span class="math inline">x_2 &gt; 0</span>). Zielwert <span class="math inline">24\cdot0{,}75 + 6\cdot0{,}5 = 18 + 3 = 21 = Z^*</span> ✓ — starker Dualitätssatz bestätigt.</p>
+<p><strong>5.5 — Unbeschränktheit.</strong> Der Solver wirft „Problem ist unbeschränkt“. Geometrisch: Der zulässige Bereich <span class="math inline">\{x_1 - x_2 \le 5,\ x \ge 0\}</span> ist nach oben offen — man kann <span class="math inline">x_1</span> und <span class="math inline">x_2</span> gemeinsam beliebig wachsen lassen (z. B. <span class="math inline">x_1 = x_2 = t</span> für <span class="math inline">t \to \infty</span>), ohne eine Bedingung zu verletzen, und <span class="math inline">Z = 2t</span> wächst mit. In der Praxis fehlt fast immer eine Kapazitätsgrenze.</p>
+<p><strong>5.6 — Gültigkeitsbereich.</strong> (a) Bei ca. 66,7 Stunden Prüfkapazität wird die <strong>Lackierzeit</strong> zum Engpass; der Schattenpreis der Prüfung fällt dann. (b) Zukaufen lohnt bis zu dem Punkt, an dem der Schattenpreis unter 18 €/h fällt. (c) Der Gewinnverlauf ist <strong>stückweise linear und konkav</strong>: Jedes Teilstück hat die Steigung des jeweils gültigen Schattenpreises, und die Steigungen werden immer flacher — jede zusätzliche Einheit bringt weniger, weil andere Engpässe nachrücken.</p>
+<p><strong>5.7 — Phase 1.</strong> Ansatz: Für jede Zeile mit <span class="math inline">b_i &lt; 0</span> (nach Umformung zu <span class="math inline">\ge</span>) eine künstliche Variable <span class="math inline">a_i \ge 0</span> einführen, Hilfszielfunktion <span class="math inline">\min \sum a_i</span> lösen. Ist das Minimum 0, existiert eine zulässige Basislösung, und man startet Phase 2 mit dem erreichten Tableau. Ist es <span class="math inline">&gt; 0</span>, ist das Problem unzulässig. Für das Beispiel: Optimum <span class="math inline">(12;\ 0)</span>, <span class="math inline">Z = 36</span>.</p>
+<h3 id="finde-den-denkfehler-die-380-000-euro-maschine">Finde den Denkfehler — Die 380 000-Euro-Maschine</h3>
 <ol type="a">
 <li><p><strong>Eine Ableitung gilt lokal.</strong> <span class="math inline">y_i = \partial Z^*/\partial b_i</span> beschreibt die Steigung der Zielfunktion <strong>am aktuellen Punkt</strong>. Sie sagt: „Die <em>nächste</em> Stunde ist 50 € wert“ — nicht: „jede der nächsten 2 000 Stunden ist 50 € wert“. Der Werksleiter behandelt eine Ableitung wie eine Konstante und multipliziert sie mit einer großen Zahl. Genau daran scheitert die Rechnung.</p></li>
 <li><p><strong>Der wahre Verlauf ist stückweise linear und knickt ab.</strong> Solange der Lackierofen der Engpass bleibt, gilt tatsächlich 50 €/h. Irgendwann ist aber genug Ofenzeit da — dann bindet eine <strong>andere</strong> Ressource, und weitere Ofenstunden bringen nichts mehr. Am Beispiel aus dem Kapitelanfang (Zusatzstunden <span class="math inline">h</span> am Lackierofen):</p></li>
@@ -28689,10 +30318,10 @@ Das zugehoerige Dockerfile ist kurz genug, um es ganz zu zeigen:
 <li><p><strong>Zwei fehlende Prüfungen.</strong> Erstens der <strong>Entartungstest</strong>: Sind mehr Nebenbedingungen aktiv als Variablen vorhanden, ist der Wert 50 € nur einer von vielen möglichen und hätte gar nicht als Einzelwert berichtet werden dürfen (siehe <code>Toleranzen_und_Entartung.py</code>). Zweitens der <strong>Gültigkeitsbereich</strong>: Bis zu welcher Kapazitätserhöhung bleibt dieser Schattenpreis überhaupt bestehen? Ohne diese Spanne ist die Zahl nicht interpretierbar.</p></li>
 <li><p><strong>Nicht extrapolieren — nachrechnen.</strong> Der zusätzliche Nutzen ergibt sich aus einem zweiten Solverlauf, nicht aus einer Multiplikation:</p></li>
 </ol>
-<div class="sourceCode" id="cb232"><pre class="sourceCode python"><code class="sourceCode python"><span id="cb232-1"><a href="#cb232-1" aria-hidden="true" tabindex="-1"></a>z_basis <span class="op">=</span> <span class="op">-</span>linprog(c, A_ub<span class="op">=</span>A, b_ub<span class="op">=</span>b, bounds<span class="op">=</span>(<span class="dv">0</span>, <span class="va">None</span>)).fun</span>
-<span id="cb232-2"><a href="#cb232-2" aria-hidden="true" tabindex="-1"></a>b_neu <span class="op">=</span> b.copy()<span class="op">;</span> b_neu[<span class="dv">0</span>] <span class="op">+=</span> <span class="dv">2000</span>                 <span class="co"># zweiter Lackierofen</span></span>
-<span id="cb232-3"><a href="#cb232-3" aria-hidden="true" tabindex="-1"></a>z_neu <span class="op">=</span> <span class="op">-</span>linprog(c, A_ub<span class="op">=</span>A, b_ub<span class="op">=</span>b_neu, bounds<span class="op">=</span>(<span class="dv">0</span>, <span class="va">None</span>)).fun</span>
-<span id="cb232-4"><a href="#cb232-4" aria-hidden="true" tabindex="-1"></a><span class="bu">print</span>(<span class="ss">f&quot;Tatsaechlicher Zusatznutzen: </span><span class="sc">{</span>z_neu <span class="op">-</span> z_basis<span class="sc">:,.0f}</span><span class="ss"> EUR&quot;</span>)   <span class="co"># 3.000 EUR</span></span></code></pre></div>
+<div class="sourceCode" id="cb236"><pre class="sourceCode python"><code class="sourceCode python"><span id="cb236-1"><a href="#cb236-1" aria-hidden="true" tabindex="-1"></a>z_basis <span class="op">=</span> <span class="op">-</span>linprog(c, A_ub<span class="op">=</span>A, b_ub<span class="op">=</span>b, bounds<span class="op">=</span>(<span class="dv">0</span>, <span class="va">None</span>)).fun</span>
+<span id="cb236-2"><a href="#cb236-2" aria-hidden="true" tabindex="-1"></a>b_neu <span class="op">=</span> b.copy()<span class="op">;</span> b_neu[<span class="dv">0</span>] <span class="op">+=</span> <span class="dv">2000</span>                 <span class="co"># zweiter Lackierofen</span></span>
+<span id="cb236-3"><a href="#cb236-3" aria-hidden="true" tabindex="-1"></a>z_neu <span class="op">=</span> <span class="op">-</span>linprog(c, A_ub<span class="op">=</span>A, b_ub<span class="op">=</span>b_neu, bounds<span class="op">=</span>(<span class="dv">0</span>, <span class="va">None</span>)).fun</span>
+<span id="cb236-4"><a href="#cb236-4" aria-hidden="true" tabindex="-1"></a><span class="bu">print</span>(<span class="ss">f&quot;Tatsaechlicher Zusatznutzen: </span><span class="sc">{</span>z_neu <span class="op">-</span> z_basis<span class="sc">:,.0f}</span><span class="ss"> EUR&quot;</span>)   <span class="co"># 3.000 EUR</span></span></code></pre></div>
 <p>Das ist die allgemeine Regel für jede Sensitivitätsaussage über mehr als eine Grenzeinheit: <strong>Der Schattenpreis zeigt die Richtung, die Neuberechnung liefert den Betrag.</strong> Bei einer Investitionsentscheidung kostet ein zusätzlicher Solverlauf Millisekunden — und hier hätte er 380 000 € gespart.</p>
 <h3 id="quiz-loesung-lp">Micro-Quiz</h3>
 <p><strong>1 — (b).</strong> Genau der Satz vom komplementären Schlupf: <span class="math inline">s_i \cdot y_i = 0</span>. Ist Schlupf vorhanden, muss der Dualwert null sein. (a) hat die Aussage in ihr Gegenteil verkehrt; (c) verwechselt Schlupf mit Auslastung — <span class="math inline">s_i = 12</span> heißt gerade, dass 12 Einheiten <em>übrig</em> sind.</p>
@@ -28708,14 +30337,14 @@ Das zugehoerige Dockerfile ist kurz genug, um es ganz zu zeigen:
 </ol>
 <hr />
 <h2 id="sec:loesungen-milp">A.6 Lösungen zu Kapitel „Gemischt-ganzzahlige Optimierung — Diskrete Entscheidungen und Branch-and-Bound“</h2>
-<p><strong>5.1 — Runden widerlegen.</strong> Beispiel: <span class="math inline">\max x_1 + x_2</span> u. d. N. <span class="math inline">10x_1 + 10x_2 \le 15</span>, ganzzahlig. LP-Optimum <span class="math inline">Z = 1{,}5</span>; Abrunden ergibt <span class="math inline">(0,0)</span> mit <span class="math inline">Z = 0</span> — <strong>100 % Verlust</strong>. Das ganzzahlige Optimum ist <span class="math inline">(1,0)</span> mit <span class="math inline">Z = 1</span>. Prinzip: kleine Zahlen plus knappe Kapazität.</p>
-<p><strong>5.2 — Big-M wählen.</strong> <span class="math inline">M = 250</span> (die bekannte Kapazität). Bei <span class="math inline">M = 10^6</span> bleibt das Modell korrekt, aber die LP-Relaxation wird extrem schwach: <span class="math inline">y_j</span> darf schon bei <span class="math inline">x_j/10^6</span> liegen, die Schranke ist praktisch wertlos, und Branch-and-Bound muss weit mehr Knoten durchsuchen.</p>
-<p><strong>5.3 — Regeln übersetzen.</strong> (a) <span class="math inline">y_A + y_B \le 1</span>. (b) <span class="math inline">\sum_{j=1}^4 y_j \ge 2</span>. (c) <span class="math inline">y_1 + y_2 - 1 \le y_{\text{Lager}}</span>. (d) <span class="math inline">500\,y \le x \le 2000\,y</span> mit <span class="math inline">y \in \{0,1\}</span>. (e) <span class="math inline">\sum_{j=1}^3 y_j = 1</span>.</p>
-<p><strong>5.4 — Branch-and-Bound.</strong> LP-Relaxation der Wurzel: nach Nutzen/Gewicht sortieren (<span class="math inline">8/5=1{,}6</span>; <span class="math inline">11/7=1{,}57</span>; <span class="math inline">6/4=1{,}5</span>; <span class="math inline">4/3=1{,}33</span>). Gierig füllen: <span class="math inline">x_1=1</span> (Rest 9), <span class="math inline">x_2=1</span> (Rest 2), <span class="math inline">x_3 = 0{,}5</span> → <span class="math inline">Z_{LP} = 8+11+3 = 22</span>. Verzweigen über <span class="math inline">x_3</span>. Ast <span class="math inline">x_3=0</span>: <span class="math inline">x_1=1,x_2=1,x_4=2/3</span> → <span class="math inline">Z = 21{,}67</span>; weiter verzweigen → beste ganzzahlige Lösung <span class="math inline">(1,1,0,0)</span> mit <span class="math inline">Z=19</span>. Ast <span class="math inline">x_3=1</span>: <span class="math inline">x_1=1</span>, <span class="math inline">x_3=1</span>, Rest 5 → <span class="math inline">x_2=5/7</span> → <span class="math inline">Z = 21{,}86</span>; verzweigen führt auf <span class="math inline">(1,0,1,1)</span> mit <span class="math inline">Z = 18</span> und <span class="math inline">(0,1,1,0)</span> mit <span class="math inline">Z=17</span>. <strong>Optimum: <span class="math inline">(1,1,0,0)</span>, <span class="math inline">Z = 19</span>.</strong></p>
-<p><strong>5.5 — Kardinalität variieren.</strong> (a) Ab <span class="math inline">K = 3</span> steigt der Ertrag nicht mehr wesentlich, weil bereits drei Positionen à 40 000 € das Budget von 100 000 € abdecken können. (b) Rechenzeit steigt zunächst (mehr Kombinationen), fällt bei großem <span class="math inline">K</span> wieder (Restriktion bindet nicht mehr). (c) Der faire Preis ist die Differenz der Netto-Erträge zwischen <span class="math inline">K=3</span> und <span class="math inline">K=4</span> — bei den gegebenen Daten nahe null, weil die Obergrenze von 40 000 € bereits bindet.</p>
-<p><strong>5.6 — Big-M-Effekt.</strong> Erwartetes Muster: Knotenzahl und Laufzeit steigen deutlich mit <span class="math inline">M</span>. Bei <span class="math inline">M = 10^9</span> ist die Relaxation so schwach, dass der Solver kaum noch prunen kann.</p>
-<p><strong>5.7 — Standortplanung.</strong> Modell wie in Projekt P4. Prüfen Sie: Gesamtkapazität der eröffneten Lager <span class="math inline">\ge</span> Gesamtbedarf (140); bei Kapazität 80 je Lager sind mindestens <span class="math inline">\lceil 140/80 \rceil = 2</span> Lager nötig.</p>
-<h3 id="finde-den-denkfehler-5.1-elf-lager-die-keine-fixkosten-kosten">Finde den Denkfehler 5.1 — Elf Lager, die keine Fixkosten kosten</h3>
+<p><strong>6.1 — Runden widerlegen.</strong> Beispiel: <span class="math inline">\max x_1 + x_2</span> u. d. N. <span class="math inline">10x_1 + 10x_2 \le 15</span>, ganzzahlig. LP-Optimum <span class="math inline">Z = 1{,}5</span>; Abrunden ergibt <span class="math inline">(0,0)</span> mit <span class="math inline">Z = 0</span> — <strong>100 % Verlust</strong>. Das ganzzahlige Optimum ist <span class="math inline">(1,0)</span> mit <span class="math inline">Z = 1</span>. Prinzip: kleine Zahlen plus knappe Kapazität.</p>
+<p><strong>6.2 — Big-M wählen.</strong> <span class="math inline">M = 250</span> (die bekannte Kapazität). Bei <span class="math inline">M = 10^6</span> bleibt das Modell korrekt, aber die LP-Relaxation wird extrem schwach: <span class="math inline">y_j</span> darf schon bei <span class="math inline">x_j/10^6</span> liegen, die Schranke ist praktisch wertlos, und Branch-and-Bound muss weit mehr Knoten durchsuchen.</p>
+<p><strong>6.3 — Regeln übersetzen.</strong> (a) <span class="math inline">y_A + y_B \le 1</span>. (b) <span class="math inline">\sum_{j=1}^4 y_j \ge 2</span>. (c) <span class="math inline">y_1 + y_2 - 1 \le y_{\text{Lager}}</span>. (d) <span class="math inline">500\,y \le x \le 2000\,y</span> mit <span class="math inline">y \in \{0,1\}</span>. (e) <span class="math inline">\sum_{j=1}^3 y_j = 1</span>.</p>
+<p><strong>6.4 — Branch-and-Bound.</strong> LP-Relaxation der Wurzel: nach Nutzen/Gewicht sortieren (<span class="math inline">8/5=1{,}6</span>; <span class="math inline">11/7=1{,}57</span>; <span class="math inline">6/4=1{,}5</span>; <span class="math inline">4/3=1{,}33</span>). Gierig füllen: <span class="math inline">x_1=1</span> (Rest 9), <span class="math inline">x_2=1</span> (Rest 2), <span class="math inline">x_3 = 0{,}5</span> → <span class="math inline">Z_{LP} = 8+11+3 = 22</span>. Verzweigen über <span class="math inline">x_3</span>. Ast <span class="math inline">x_3=0</span>: <span class="math inline">x_1=1,x_2=1,x_4=2/3</span> → <span class="math inline">Z = 21{,}67</span>; weiter verzweigen → beste ganzzahlige Lösung <span class="math inline">(1,1,0,0)</span> mit <span class="math inline">Z=19</span>. Ast <span class="math inline">x_3=1</span>: <span class="math inline">x_1=1</span>, <span class="math inline">x_3=1</span>, Rest 5 → <span class="math inline">x_2=5/7</span> → <span class="math inline">Z = 21{,}86</span>; verzweigen führt auf <span class="math inline">(1,0,1,1)</span> mit <span class="math inline">Z = 18</span> und <span class="math inline">(0,1,1,0)</span> mit <span class="math inline">Z=17</span>. <strong>Optimum: <span class="math inline">(1,1,0,0)</span>, <span class="math inline">Z = 19</span>.</strong></p>
+<p><strong>6.5 — Kardinalität variieren.</strong> (a) Ab <span class="math inline">K = 3</span> steigt der Ertrag nicht mehr wesentlich, weil bereits drei Positionen à 40 000 € das Budget von 100 000 € abdecken können. (b) Rechenzeit steigt zunächst (mehr Kombinationen), fällt bei großem <span class="math inline">K</span> wieder (Restriktion bindet nicht mehr). (c) Der faire Preis ist die Differenz der Netto-Erträge zwischen <span class="math inline">K=3</span> und <span class="math inline">K=4</span> — bei den gegebenen Daten nahe null, weil die Obergrenze von 40 000 € bereits bindet.</p>
+<p><strong>6.6 — Big-M-Effekt.</strong> Erwartetes Muster: Knotenzahl und Laufzeit steigen deutlich mit <span class="math inline">M</span>. Bei <span class="math inline">M = 10^9</span> ist die Relaxation so schwach, dass der Solver kaum noch prunen kann.</p>
+<p><strong>6.7 — Standortplanung.</strong> Modell wie in Projekt P4. Prüfen Sie: Gesamtkapazität der eröffneten Lager <span class="math inline">\ge</span> Gesamtbedarf (140); bei Kapazität 80 je Lager sind mindestens <span class="math inline">\lceil 140/80 \rceil = 2</span> Lager nötig.</p>
+<h3 id="finde-den-denkfehler-elf-lager-die-keine-fixkosten-kosten">Finde den Denkfehler — Elf Lager, die keine Fixkosten kosten</h3>
 <ol type="a">
 <li><p><strong>Warum die Zahl kleiner ist.</strong> Ein größeres <span class="math inline">M</span> <strong>lockert</strong> die Nebenbedingung <span class="math inline">\sum_j x_{ij} \le M y_i</span>. Der zulässige Bereich des Modells wird also größer, und in einem größeren Bereich kann das Minimum nur kleiner oder gleich bleiben. Bei einem <em>korrekt</em> formulierten Modell dürfte das aber gar nicht auffallen: Solange <span class="math inline">y_i</span> wirklich binär ist, ist <span class="math inline">M \cdot 1 = M</span> ohnehin größer als jede mögliche Liefermenge — die Lockerung wäre wirkungslos. Dass sich der Zielwert überhaupt ändert, ist deshalb schon der Beweis, dass <span class="math inline">y_i</span> <strong>nicht</strong> wirklich binär ist.</p></li>
 <li><p><strong>Die Binärvariablen.</strong> Sie stehen bei rund <span class="math inline">4 \cdot 10^{-8}</span> — nicht bei 0 und nicht bei 1. Die Ganzzahltoleranz von HiGHS (wie der meisten Solver) beträgt <span class="math inline">10^{-6}</span>. Alles, was näher als das an einer ganzen Zahl liegt, gilt als ganzzahlig. <span class="math inline">4 \cdot 10^{-8}</span> ist damit für den Solver eine saubere <strong>0</strong>: „Lager geschlossen“.</p></li>
@@ -28730,17 +30359,17 @@ Das zugehoerige Dockerfile ist kurz genug, um es ganz zu zeigen:
 <ol start="4" type="a">
 <li><strong>Die Prüfung.</strong> Drei Tests, zusammen keine zwanzig Zeilen, die in jedes MILP-Auswertungsskript gehören:</li>
 </ol>
-<div class="sourceCode" id="cb233"><pre class="sourceCode python"><code class="sourceCode python"><span id="cb233-1"><a href="#cb233-1" aria-hidden="true" tabindex="-1"></a><span class="co"># 1. Sind die Binaervariablen wirklich binaer?</span></span>
-<span id="cb233-2"><a href="#cb233-2" aria-hidden="true" tabindex="-1"></a><span class="cf">assert</span> np.<span class="bu">abs</span>(y <span class="op">-</span> np.<span class="bu">round</span>(y)).<span class="bu">max</span>() <span class="op">&lt;=</span> <span class="fl">1e-6</span>, <span class="st">&quot;y ist nicht ganzzahlig&quot;</span></span>
-<span id="cb233-3"><a href="#cb233-3" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb233-4"><a href="#cb233-4" aria-hidden="true" tabindex="-1"></a><span class="co"># 2. Widerspricht sich die Loesung selbst?</span></span>
-<span id="cb233-5"><a href="#cb233-5" aria-hidden="true" tabindex="-1"></a>liefert <span class="op">=</span> x.<span class="bu">sum</span>(axis<span class="op">=</span><span class="dv">1</span>) <span class="op">&gt;</span> <span class="fl">1e-6</span></span>
-<span id="cb233-6"><a href="#cb233-6" aria-hidden="true" tabindex="-1"></a><span class="cf">assert</span> <span class="kw">not</span> (liefert <span class="op">&amp;</span> (y <span class="op">&lt;</span> <span class="fl">0.5</span>)).<span class="bu">any</span>(), <span class="st">&quot;Lager liefert, gilt aber als geschlossen&quot;</span></span>
-<span id="cb233-7"><a href="#cb233-7" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb233-8"><a href="#cb233-8" aria-hidden="true" tabindex="-1"></a><span class="co"># 3. Stimmt der Zielwert mit den Kosten der Loesung ueberein?</span></span>
-<span id="cb233-9"><a href="#cb233-9" aria-hidden="true" tabindex="-1"></a>echte_kosten <span class="op">=</span> FIXKOSTEN[liefert].<span class="bu">sum</span>() <span class="op">+</span> (TRANSPORT <span class="op">*</span> x).<span class="bu">sum</span>()</span>
-<span id="cb233-10"><a href="#cb233-10" aria-hidden="true" tabindex="-1"></a><span class="cf">assert</span> <span class="bu">abs</span>(echte_kosten <span class="op">-</span> zielwert) <span class="op">&lt;</span> <span class="fl">1e-4</span> <span class="op">*</span> echte_kosten, <span class="op">\</span></span>
-<span id="cb233-11"><a href="#cb233-11" aria-hidden="true" tabindex="-1"></a>    <span class="ss">f&quot;Zielwert </span><span class="sc">{</span>zielwert<span class="sc">}</span><span class="ss"> passt nicht zu den echten Kosten </span><span class="sc">{</span>echte_kosten<span class="sc">}</span><span class="ss">&quot;</span></span></code></pre></div>
+<div class="sourceCode" id="cb237"><pre class="sourceCode python"><code class="sourceCode python"><span id="cb237-1"><a href="#cb237-1" aria-hidden="true" tabindex="-1"></a><span class="co"># 1. Sind die Binaervariablen wirklich binaer?</span></span>
+<span id="cb237-2"><a href="#cb237-2" aria-hidden="true" tabindex="-1"></a><span class="cf">assert</span> np.<span class="bu">abs</span>(y <span class="op">-</span> np.<span class="bu">round</span>(y)).<span class="bu">max</span>() <span class="op">&lt;=</span> <span class="fl">1e-6</span>, <span class="st">&quot;y ist nicht ganzzahlig&quot;</span></span>
+<span id="cb237-3"><a href="#cb237-3" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb237-4"><a href="#cb237-4" aria-hidden="true" tabindex="-1"></a><span class="co"># 2. Widerspricht sich die Loesung selbst?</span></span>
+<span id="cb237-5"><a href="#cb237-5" aria-hidden="true" tabindex="-1"></a>liefert <span class="op">=</span> x.<span class="bu">sum</span>(axis<span class="op">=</span><span class="dv">1</span>) <span class="op">&gt;</span> <span class="fl">1e-6</span></span>
+<span id="cb237-6"><a href="#cb237-6" aria-hidden="true" tabindex="-1"></a><span class="cf">assert</span> <span class="kw">not</span> (liefert <span class="op">&amp;</span> (y <span class="op">&lt;</span> <span class="fl">0.5</span>)).<span class="bu">any</span>(), <span class="st">&quot;Lager liefert, gilt aber als geschlossen&quot;</span></span>
+<span id="cb237-7"><a href="#cb237-7" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb237-8"><a href="#cb237-8" aria-hidden="true" tabindex="-1"></a><span class="co"># 3. Stimmt der Zielwert mit den Kosten der Loesung ueberein?</span></span>
+<span id="cb237-9"><a href="#cb237-9" aria-hidden="true" tabindex="-1"></a>echte_kosten <span class="op">=</span> FIXKOSTEN[liefert].<span class="bu">sum</span>() <span class="op">+</span> (TRANSPORT <span class="op">*</span> x).<span class="bu">sum</span>()</span>
+<span id="cb237-10"><a href="#cb237-10" aria-hidden="true" tabindex="-1"></a><span class="cf">assert</span> <span class="bu">abs</span>(echte_kosten <span class="op">-</span> zielwert) <span class="op">&lt;</span> <span class="fl">1e-4</span> <span class="op">*</span> echte_kosten, <span class="op">\</span></span>
+<span id="cb237-11"><a href="#cb237-11" aria-hidden="true" tabindex="-1"></a>    <span class="ss">f&quot;Zielwert </span><span class="sc">{</span>zielwert<span class="sc">}</span><span class="ss"> passt nicht zu den echten Kosten </span><span class="sc">{</span>echte_kosten<span class="sc">}</span><span class="ss">&quot;</span></span></code></pre></div>
 <p>Test 3 ist der wichtigste. Er vergleicht nicht Modell mit Modell, sondern <strong>Modell mit Wirklichkeit</strong> — er rechnet die Kosten aus der ausgegebenen Lösung neu aus, ganz ohne Solver. Damit fängt er nicht nur den Big-M-Fehler, sondern jeden Fehler, bei dem die Zielfunktion etwas anderes bilanziert als der Plan tatsächlich kostet.</p>
 <p><strong>Vorbeugend</strong> gilt weiter die Regel aus dem Kapitel: <span class="math inline">M</span> so klein wie möglich, hergeleitet aus einer echten Kapazität. Hier wäre das schlicht die Lagerkapazität — mehr kann ein Lager ohnehin nicht ausliefern.</p>
 <h3 id="quiz-loesung-milp">Micro-Quiz</h3>
@@ -28757,24 +30386,47 @@ Das zugehoerige Dockerfile ist kurz genug, um es ganz zu zeigen:
 </ol>
 <hr />
 <h2 id="sec:loesungen-cpsat">A.7 Lösungen zu Kapitel „Constraint Programming mit CP-SAT — Logik, Scheduling und Zuweisung“</h2>
-<p><strong>6.1 — Propagation.</strong> Aus <span class="math inline">x_1 + x_2 = 8</span> und <span class="math inline">x_1 &lt; x_2</span> folgt <span class="math inline">x_1 &lt; 4</span>, also <span class="math inline">x_1 \in \{2,3\}</span> (denn <span class="math inline">x_2 = 8-x_1 \le 6</span> verlangt <span class="math inline">x_1 \ge 2</span>) und entsprechend <span class="math inline">x_2 \in \{5,6\}</span>. Aus 36 Kombinationen werden 2 zulässige.</p>
-<p><strong>6.2 — Hart oder weich.</strong> (a) hart. (b) weich, mittlere Strafe (~50). (c) hart. (d) weich, mittlere Strafe (~80, weil geteilte Dienste stark belasten). (e) hart, falls gesetzlich; sonst weich mit sehr hoher Strafe (~1000).</p>
-<p><strong>6.3 — Regeln ergänzen.</strong> (a) <code>for s in (2,3): modell.Add(x["Frau_Albrecht", s] == 0)</code> (b) Hilfsvariablen <code>arbeitet_bauer</code>, <code>arbeitet_koch</code> per <code>AddMaxEquality</code> an die Zuweisungssummen koppeln, dann <code>modell.Add(arbeitet_bauer + arbeitet_koch &lt;= 1)</code>. (c) Belohnung = negative Strafe: <code>strafterme.append(-30 * folge_var)</code>, wobei <code>folge_var</code> per <code>AddBoolAnd</code>/<code>OnlyEnforceIf</code> an <span class="math inline">x_{p,0} \wedge x_{p,1}</span> gekoppelt wird.</p>
-<p><strong>6.4 — Infeasibility.</strong> Mit <code>MAX_VERTRETUNGEN = 0</code> meldet der Solver <code>INFEASIBLE</code>. Nach Einbau der Schlupfvariablen lässt der Solver <strong>alle vier</strong> Stunden ausfallen (4 × 10 000 = 40 000 Strafpunkte) — es geht nicht anders. Interessanter wird es bei <code>MAX_VERTRETUNGEN = 1</code>: Dann fällt genau die Stunde aus, für die am wenigsten qualifiziertes Personal zur Verfügung steht.</p>
-<p><strong>6.5 — Sudoku.</strong></p>
-<div class="sourceCode" id="cb234"><pre class="sourceCode python"><code class="sourceCode python"><span id="cb234-1"><a href="#cb234-1" aria-hidden="true" tabindex="-1"></a>x <span class="op">=</span> [[m.NewIntVar(<span class="dv">1</span>, <span class="dv">9</span>, <span class="ss">f&quot;x</span><span class="sc">{</span>i<span class="sc">}{</span>j<span class="sc">}</span><span class="ss">&quot;</span>) <span class="cf">for</span> j <span class="kw">in</span> <span class="bu">range</span>(<span class="dv">9</span>)] <span class="cf">for</span> i <span class="kw">in</span> <span class="bu">range</span>(<span class="dv">9</span>)]</span>
-<span id="cb234-2"><a href="#cb234-2" aria-hidden="true" tabindex="-1"></a><span class="cf">for</span> i <span class="kw">in</span> <span class="bu">range</span>(<span class="dv">9</span>): m.AddAllDifferent(x[i])                       <span class="co"># Zeilen</span></span>
-<span id="cb234-3"><a href="#cb234-3" aria-hidden="true" tabindex="-1"></a><span class="cf">for</span> j <span class="kw">in</span> <span class="bu">range</span>(<span class="dv">9</span>): m.AddAllDifferent([x[i][j] <span class="cf">for</span> i <span class="kw">in</span> <span class="bu">range</span>(<span class="dv">9</span>)]) <span class="co"># Spalten</span></span>
-<span id="cb234-4"><a href="#cb234-4" aria-hidden="true" tabindex="-1"></a><span class="cf">for</span> bi <span class="kw">in</span> <span class="bu">range</span>(<span class="dv">3</span>):</span>
-<span id="cb234-5"><a href="#cb234-5" aria-hidden="true" tabindex="-1"></a>    <span class="cf">for</span> bj <span class="kw">in</span> <span class="bu">range</span>(<span class="dv">3</span>):</span>
-<span id="cb234-6"><a href="#cb234-6" aria-hidden="true" tabindex="-1"></a>        m.AddAllDifferent([x[<span class="dv">3</span><span class="op">*</span>bi<span class="op">+</span>i][<span class="dv">3</span><span class="op">*</span>bj<span class="op">+</span>j] <span class="cf">for</span> i <span class="kw">in</span> <span class="bu">range</span>(<span class="dv">3</span>) <span class="cf">for</span> j <span class="kw">in</span> <span class="bu">range</span>(<span class="dv">3</span>)])</span>
-<span id="cb234-7"><a href="#cb234-7" aria-hidden="true" tabindex="-1"></a><span class="cf">for</span> i <span class="kw">in</span> <span class="bu">range</span>(<span class="dv">9</span>):</span>
-<span id="cb234-8"><a href="#cb234-8" aria-hidden="true" tabindex="-1"></a>    <span class="cf">for</span> j <span class="kw">in</span> <span class="bu">range</span>(<span class="dv">9</span>):</span>
-<span id="cb234-9"><a href="#cb234-9" aria-hidden="true" tabindex="-1"></a>        <span class="cf">if</span> vorgabe[i][j]: m.Add(x[i][j] <span class="op">==</span> vorgabe[i][j])</span></code></pre></div>
+<p><strong>7.1 — Propagation.</strong> Aus <span class="math inline">x_1 + x_2 = 8</span> und <span class="math inline">x_1 &lt; x_2</span> folgt <span class="math inline">x_1 &lt; 4</span>, also <span class="math inline">x_1 \in \{2,3\}</span> (denn <span class="math inline">x_2 = 8-x_1 \le 6</span> verlangt <span class="math inline">x_1 \ge 2</span>) und entsprechend <span class="math inline">x_2 \in \{5,6\}</span>. Aus 36 Kombinationen werden 2 zulässige.</p>
+<p><strong>7.2 — Hart oder weich.</strong> (a) hart. (b) weich, mittlere Strafe (~50). (c) hart. (d) weich, mittlere Strafe (~80, weil geteilte Dienste stark belasten). (e) hart, falls gesetzlich; sonst weich mit sehr hoher Strafe (~1000).</p>
+<p><strong>7.3 — Regeln ergänzen.</strong> (a) <code>for s in (2,3): modell.Add(x["Frau_Albrecht", s] == 0)</code> (b) Hilfsvariablen <code>arbeitet_bauer</code>, <code>arbeitet_koch</code> per <code>AddMaxEquality</code> an die Zuweisungssummen koppeln, dann <code>modell.Add(arbeitet_bauer + arbeitet_koch &lt;= 1)</code>. (c) Belohnung = negative Strafe: <code>strafterme.append(-30 * folge_var)</code>, wobei <code>folge_var</code> per <code>AddBoolAnd</code>/<code>OnlyEnforceIf</code> an <span class="math inline">x_{p,0} \wedge x_{p,1}</span> gekoppelt wird.</p>
+<p><strong>7.4 — Infeasibility.</strong> Mit <code>MAX_VERTRETUNGEN = 0</code> meldet der Solver <code>INFEASIBLE</code>. Nach Einbau der Schlupfvariablen lässt der Solver <strong>alle vier</strong> Stunden ausfallen (4 × 10 000 = 40 000 Strafpunkte) — es geht nicht anders. Interessanter wird es bei <code>MAX_VERTRETUNGEN = 1</code>: Dann fällt genau die Stunde aus, für die am wenigsten qualifiziertes Personal zur Verfügung steht.</p>
+<p><strong>7.5 — Sudoku.</strong></p>
+<div class="sourceCode" id="cb238"><pre class="sourceCode python"><code class="sourceCode python"><span id="cb238-1"><a href="#cb238-1" aria-hidden="true" tabindex="-1"></a>x <span class="op">=</span> [[m.NewIntVar(<span class="dv">1</span>, <span class="dv">9</span>, <span class="ss">f&quot;x</span><span class="sc">{</span>i<span class="sc">}{</span>j<span class="sc">}</span><span class="ss">&quot;</span>) <span class="cf">for</span> j <span class="kw">in</span> <span class="bu">range</span>(<span class="dv">9</span>)] <span class="cf">for</span> i <span class="kw">in</span> <span class="bu">range</span>(<span class="dv">9</span>)]</span>
+<span id="cb238-2"><a href="#cb238-2" aria-hidden="true" tabindex="-1"></a><span class="cf">for</span> i <span class="kw">in</span> <span class="bu">range</span>(<span class="dv">9</span>): m.AddAllDifferent(x[i])                       <span class="co"># Zeilen</span></span>
+<span id="cb238-3"><a href="#cb238-3" aria-hidden="true" tabindex="-1"></a><span class="cf">for</span> j <span class="kw">in</span> <span class="bu">range</span>(<span class="dv">9</span>): m.AddAllDifferent([x[i][j] <span class="cf">for</span> i <span class="kw">in</span> <span class="bu">range</span>(<span class="dv">9</span>)]) <span class="co"># Spalten</span></span>
+<span id="cb238-4"><a href="#cb238-4" aria-hidden="true" tabindex="-1"></a><span class="cf">for</span> bi <span class="kw">in</span> <span class="bu">range</span>(<span class="dv">3</span>):</span>
+<span id="cb238-5"><a href="#cb238-5" aria-hidden="true" tabindex="-1"></a>    <span class="cf">for</span> bj <span class="kw">in</span> <span class="bu">range</span>(<span class="dv">3</span>):</span>
+<span id="cb238-6"><a href="#cb238-6" aria-hidden="true" tabindex="-1"></a>        m.AddAllDifferent([x[<span class="dv">3</span><span class="op">*</span>bi<span class="op">+</span>i][<span class="dv">3</span><span class="op">*</span>bj<span class="op">+</span>j] <span class="cf">for</span> i <span class="kw">in</span> <span class="bu">range</span>(<span class="dv">3</span>) <span class="cf">for</span> j <span class="kw">in</span> <span class="bu">range</span>(<span class="dv">3</span>)])</span>
+<span id="cb238-7"><a href="#cb238-7" aria-hidden="true" tabindex="-1"></a><span class="cf">for</span> i <span class="kw">in</span> <span class="bu">range</span>(<span class="dv">9</span>):</span>
+<span id="cb238-8"><a href="#cb238-8" aria-hidden="true" tabindex="-1"></a>    <span class="cf">for</span> j <span class="kw">in</span> <span class="bu">range</span>(<span class="dv">9</span>):</span>
+<span id="cb238-9"><a href="#cb238-9" aria-hidden="true" tabindex="-1"></a>        <span class="cf">if</span> vorgabe[i][j]: m.Add(x[i][j] <span class="op">==</span> vorgabe[i][j])</span></code></pre></div>
 <p><strong>Etwa 10 Zeilen Modellcode</strong> — und der Solver löst jedes Sudoku in Millisekunden. Das ist die Stärke globaler Constraints.</p>
-<p><strong>6.6 — Job-Shop erweitern.</strong> (a) Rüstzeiten: <code>AddNoOverlap</code> durch paarweise Disjunktionen mit Übergangszeit ersetzen, oder <code>AddCircuit</code> je Maschine mit Übergangsmatrix. (b) Verspätung: <code>tardiness = MaxEquality(0, ende - faellig)</code>, in die Zielfunktion. (c) <code>AddCumulative(intervalle, [1]*n, 2)</code> statt <code>AddNoOverlap</code> für die Doppelmaschine.</p>
-<p><strong>6.7 — Wochendienstplan.</strong> Siehe Projekt P2. Kernpunkte: Nachtschicht-Folgeregel über <code>AddImplication</code>; „höchstens 5 Tage in Folge“ über gleitende Fenster (<code>sum(x[p,t..t+5]) &lt;= 5</code>).</p>
-<h3 id="finde-den-denkfehler-6.1-die-betriebsvereinbarung-die-niemanden-interessiert">Finde den Denkfehler 6.1 — Die Betriebsvereinbarung, die niemanden interessiert</h3>
+<p><strong>7.6 — Die Grenze der Parallelität finden.</strong> (a) Der Gewinn flacht ab und kehrt sich um. Auf einem Rechner mit 24 Kernen gemessen (Faktor gegenüber einem Arbeiter): 8 Arbeiter <strong>10,2</strong>, 16 Arbeiter <strong>12,3</strong>, 24 Arbeiter <strong>9,0</strong>. Wer alle Kerne belegt, ist langsamer als mit zwei Dritteln — dem Betriebssystem, dem Speicherbus und den Suchsträngen untereinander bleibt zu wenig Luft. Die Faustregel „so viele Arbeiter wie Kerne” ist also falsch; die richtige Zahl ist eine Messung, keine Einstellung. (b) <strong>Fünf verschiedene Pläne aus fünf Seeds</strong> — bei <code>num_workers = 1</code> und identischem Zielwert 183. Das ist die andere Hälfte der Antwort: Der Seed <em>wirkt</em>, aber nur auf den einzelnen Suchstrang. Es sichert also <strong>keiner der beiden Parameter allein</strong> die Reproduzierbarkeit:</p>
+<table>
+<thead>
+<tr class="header">
+<th></th>
+<th>Seed fest</th>
+<th>Seed variabel</th>
+</tr>
+</thead>
+<tbody>
+<tr class="odd">
+<td><strong>1 Arbeiter</strong></td>
+<td>reproduzierbar</td>
+<td>5 Pläne aus 5 Läufen</td>
+</tr>
+<tr class="even">
+<td><strong>mehrere Arbeiter</strong></td>
+<td>3 Pläne aus 4 Läufen</td>
+<td>erst recht nicht</td>
+</tr>
+</tbody>
+</table>
+<p>Nur die Kombination trägt. (c) Bei <strong>15 Aufträgen</strong> (60 s Zeitlimit): Ein Arbeiter läuft ins Limit und meldet <code>FEASIBLE</code> mit Makespan 200; acht Arbeiter melden <code>OPTIMAL</code> mit <strong>demselben</strong> Makespan 200 nach 26,4 s. Bei 13 Aufträgen sind es 11,2 s gegen 2,8 s, bei 14 schon 21,4 s gegen 3,7 s. Bemerkenswert ist, dass beide denselben Wert finden — der Unterschied liegt nicht in der Lösung, sondern im <strong>Beweis</strong>, dass es keine bessere gibt. Genau diese Arbeit teilen sich die parallelen Stränge auf.</p>
+<p><strong>7.7 — Job-Shop erweitern.</strong> (a) Rüstzeiten: <code>AddNoOverlap</code> durch paarweise Disjunktionen mit Übergangszeit ersetzen, oder <code>AddCircuit</code> je Maschine mit Übergangsmatrix. (b) Verspätung: <code>tardiness = MaxEquality(0, ende - faellig)</code>, in die Zielfunktion. (c) <code>AddCumulative(intervalle, [1]*n, 2)</code> statt <code>AddNoOverlap</code> für die Doppelmaschine.</p>
+<p><strong>7.8 — Wochendienstplan.</strong> Siehe Projekt P2. Kernpunkte: Nachtschicht-Folgeregel über <code>AddImplication</code>; „höchstens 5 Tage in Folge“ über gleitende Fenster (<code>sum(x[p,t..t+5]) &lt;= 5</code>).</p>
+<h3 id="finde-den-denkfehler-die-betriebsvereinbarung-die-niemanden-interessiert">Finde den Denkfehler — Die Betriebsvereinbarung, die niemanden interessiert</h3>
 <ol type="a">
 <li><p><strong>Warum die Regel verletzt wird.</strong> Weil sie einen <strong>Preis</strong> hat. Eine weiche Nebenbedingung verbietet nichts — sie verteuert. Der Solver vergleicht in jedem Schritt, was ihn eine Verletzung kostet und was sie ihm einbringt. Bei einem Gewicht von 1 gegen 10 lohnt sich eine Drei-Tage-Serie, sobald sie auch nur ein Zehntel eines Wunsches rettet. Der Solver hat genau das getan, was im Modell steht — er hat nur nicht getan, was gemeint war.</p></li>
 <li><p><strong>Was <span class="math inline">(1, 10)</span> wörtlich bedeutet.</strong> Nicht „Wunschfrei ist wichtiger“, sondern:</p></li>
@@ -28851,12 +30503,14 @@ Das zugehoerige Dockerfile ist kurz genug, um es ganz zu zeigen:
 <li>Eine Variable mit Start, Dauer und Ende; sie garantiert automatisch <code>start + dauer == ende</code>.</li>
 <li>Weil jede zusätzliche harte Bedingung das Risiko von <code>INFEASIBLE</code> erhöht — und eine Fehlermeldung dem Anwender nicht hilft.</li>
 <li>Weil Anwender die Frage „Warum ich?“ stellen. Ohne Antwort wird das System umgangen.</li>
+<li>Weil der Seed nur festlegt, wie ein <strong>einzelner</strong> Suchstrang würfelt — nicht, welcher von mehreren parallelen zuerst fertig wird. Das entscheidet die Ausführungsreihenfolge, also die Uhr. Abhilfe: zusätzlich <code>num_workers = 1</code>. Gemessen: schon zwei Arbeiter liefern bei identischem Seed drei verschiedene Pläne zum selben Zielwert.</li>
+<li>Weil CP-SAT nicht dieselbe Suche vervielfacht, sondern <strong>verschiedene Strategien</strong> nebeneinander laufen lässt (LP-gestützt, andere Verzweigungsregeln, lokale Suche), die einander ihre Schranken mitteilen. Ein zusätzlicher Arbeiter ist deshalb nicht ein weiterer Kern für dieselbe Arbeit, sondern ein anderes Verfahren — und wenn eines davon früh eine gute Schranke findet, profitieren alle.</li>
 </ol>
 <hr />
 <h2 id="sec:loesungen-graphen">A.8 Lösungen zu Kapitel „Graphen, Flüsse und Touren — Min-Cost-Flow, Matching und VRP“</h2>
-<p><strong>7.1 — Flusserhaltung.</strong> <span class="math inline">b_i = (15+3) - (12+8) = -2</span> → <strong>Senke</strong> (Nettobedarf 2).</p>
-<p><strong>7.2 — Unlösbarkeit.</strong> Die Summe aller Flusserhaltungsgleichungen ergibt <span class="math inline">\sum_i b_i = 0</span> (jede Kante taucht einmal mit <span class="math inline">+1</span> und einmal mit <span class="math inline">-1</span> auf). Ist die Summe ungleich null, widersprechen sich die Gleichungen. Bei Angebotsüberschuss führt man einen künstlichen <strong>Dummy-Senkenknoten</strong> mit dem Restbedarf und Kosten 0 ein.</p>
-<p><strong>7.3 — Transportproblem.</strong> (a) Angebot <span class="math inline">30+25+45 = 100</span>, Bedarf <span class="math inline">25+30+20+25 = 100</span> ✓ (b) Optimale Kosten: <strong>790</strong>. Transportplan:</p>
+<p><strong>8.1 — Flusserhaltung.</strong> <span class="math inline">b_i = (15+3) - (12+8) = -2</span> → <strong>Senke</strong> (Nettobedarf 2).</p>
+<p><strong>8.2 — Unlösbarkeit.</strong> Die Summe aller Flusserhaltungsgleichungen ergibt <span class="math inline">\sum_i b_i = 0</span> (jede Kante taucht einmal mit <span class="math inline">+1</span> und einmal mit <span class="math inline">-1</span> auf). Ist die Summe ungleich null, widersprechen sich die Gleichungen. Bei Angebotsüberschuss führt man einen künstlichen <strong>Dummy-Senkenknoten</strong> mit dem Restbedarf und Kosten 0 ein.</p>
+<p><strong>8.3 — Transportproblem.</strong> (a) Angebot <span class="math inline">30+25+45 = 100</span>, Bedarf <span class="math inline">25+30+20+25 = 100</span> ✓ (b) Optimale Kosten: <strong>790</strong>. Transportplan:</p>
 <table>
 <thead>
 <tr class="header">
@@ -28904,11 +30558,11 @@ Das zugehoerige Dockerfile ist kurz genug, um es ganz zu zeigen:
 </tbody>
 </table>
 <p>Beachten Sie, dass Werk 3 seine günstigste Verbindung (L4 zu 5) voll ausschöpft und W2 ausschließlich L1 beliefert (9), obwohl L4 mit 7 billiger wäre — dort ist der Bedarf bereits von W3 gedeckt. (c) Die Lösung ist ganzzahlig, obwohl nicht gefordert — die Transportmatrix ist <strong>total unimodular</strong>, alle Ecken sind ganzzahlig.</p>
-<p><strong>7.4 — Zuordnung mit Verboten.</strong> Kosten auf einen sehr hohen Wert setzen (<code>kosten[2][2] = 1e6</code>) oder mit <code>np.inf</code> arbeiten (bei <code>linear_sum_assignment</code> erlaubt). Die Lösung weicht auf die zweitbeste Zuordnung für Carla aus; die Gesamtkosten steigen um die Differenz.</p>
-<p><strong>7.5 — Engpass finden.</strong> Die Dualwerte der Kapazitätsschranken (<code>res.upper.marginals</code> bei <code>linprog</code>) zeigen es direkt; alternativ jede Kapazität einzeln um 1 erhöhen und neu rechnen. Im Beispiel ist die Kante <code>Werk_A → Umschlag</code> der Engpass (voll ausgelastet, günstigster Weg).</p>
-<p><strong>7.6 — VRP variieren.</strong> (a) Mit 3 Fahrzeugen werden die Touren länger, die Gesamtfahrzeit steigt leicht, die Auslastung deutlich. (b) Unlösbar, sobald <span class="math inline">\text{Kapazität} \times \text{Fahrzeuge} &lt; \text{Gesamtbedarf}</span> (hier: bei 3 Fahrzeugen à 10 sind 30 &lt; 37 → unlösbar) <strong>oder</strong> wenn Zeitfenster nicht mehr eingehalten werden können. (c) 1 s liefert meist eine brauchbare, 30 s eine spürbar bessere Lösung — die Metaheuristik verbessert kontinuierlich. (d) Doppelte Servicezeit kann Zeitfenster verletzen → möglicherweise unlösbar.</p>
-<p><strong>7.7 — TSP mit MTZ.</strong> Erwartetes Ergebnis: Bei 8 Städten löst das MILP in Sekunden. Ab etwa 12–15 Städten wird die schwache MTZ-Relaxation zum Problem, und die Laufzeit steigt stark — während OR-Tools weiterhin in Sekundenbruchteilen sehr gute Touren liefert.</p>
-<h3 id="finde-den-denkfehler-7.1-die-vergessene-dimension">Finde den Denkfehler 7.1 — Die vergessene Dimension</h3>
+<p><strong>8.4 — Zuordnung mit Verboten.</strong> Kosten auf einen sehr hohen Wert setzen (<code>kosten[2][2] = 1e6</code>) oder mit <code>np.inf</code> arbeiten (bei <code>linear_sum_assignment</code> erlaubt). Die Lösung weicht auf die zweitbeste Zuordnung für Carla aus; die Gesamtkosten steigen um die Differenz.</p>
+<p><strong>8.5 — Engpass finden.</strong> Die Dualwerte der Kapazitätsschranken (<code>res.upper.marginals</code> bei <code>linprog</code>) zeigen es direkt; alternativ jede Kapazität einzeln um 1 erhöhen und neu rechnen. Im Beispiel ist die Kante <code>Werk_A → Umschlag</code> der Engpass (voll ausgelastet, günstigster Weg).</p>
+<p><strong>8.6 — VRP variieren.</strong> (a) Mit 3 Fahrzeugen werden die Touren länger, die Gesamtfahrzeit steigt leicht, die Auslastung deutlich. (b) Unlösbar, sobald <span class="math inline">\text{Kapazität} \times \text{Fahrzeuge} &lt; \text{Gesamtbedarf}</span> (hier: bei 3 Fahrzeugen à 10 sind 30 &lt; 37 → unlösbar) <strong>oder</strong> wenn Zeitfenster nicht mehr eingehalten werden können. (c) 1 s liefert meist eine brauchbare, 30 s eine spürbar bessere Lösung — die Metaheuristik verbessert kontinuierlich. (d) Doppelte Servicezeit kann Zeitfenster verletzen → möglicherweise unlösbar.</p>
+<p><strong>8.7 — TSP mit MTZ.</strong> Erwartetes Ergebnis: Bei 8 Städten löst das MILP in Sekunden. Ab etwa 12–15 Städten wird die schwache MTZ-Relaxation zum Problem, und die Laufzeit steigt stark — während OR-Tools weiterhin in Sekundenbruchteilen sehr gute Touren liefert.</p>
+<h3 id="finde-den-denkfehler-die-vergessene-dimension">Finde den Denkfehler — Die vergessene Dimension</h3>
 <ol type="a">
 <li><strong>Was die Fahrzeuge tun.</strong> Fahrzeuge 1, 2 und 3 fahren <strong>gar nicht</strong> — sie stehen mit null Stopps im Depot. Fahrzeug 4 bedient alle 16 Kunden und lädt dabei <strong>37 Paletten</strong> bei einer Kapazität von 10. Es ist um 270 % überladen. Physikalisch ist dieser Plan nicht ausführbar; im Modell ist er die beste Lösung.</li>
 </ol>
@@ -28924,18 +30578,18 @@ Das zugehoerige Dockerfile ist kurz genug, um es ganz zu zeigen:
 <ol start="4" type="a">
 <li><strong>Die Prüfung — und warum sie unabhängig sein muss.</strong></li>
 </ol>
-<div class="sourceCode" id="cb235"><pre class="sourceCode python"><code class="sourceCode python"><span id="cb235-1"><a href="#cb235-1" aria-hidden="true" tabindex="-1"></a><span class="cf">for</span> fahrzeug, (ladung, kapazitaet) <span class="kw">in</span> <span class="bu">enumerate</span>(<span class="bu">zip</span>(ladungen, KAPAZITAETEN)):</span>
-<span id="cb235-2"><a href="#cb235-2" aria-hidden="true" tabindex="-1"></a>    <span class="cf">assert</span> ladung <span class="op">&lt;=</span> kapazitaet, <span class="op">\</span></span>
-<span id="cb235-3"><a href="#cb235-3" aria-hidden="true" tabindex="-1"></a>        <span class="ss">f&quot;Fahrzeug </span><span class="sc">{</span>fahrzeug <span class="op">+</span> <span class="dv">1</span><span class="sc">}</span><span class="ss">: </span><span class="sc">{</span>ladung<span class="sc">}</span><span class="ss"> Paletten bei Kapazitaet </span><span class="sc">{</span>kapazitaet<span class="sc">}</span><span class="ss">&quot;</span></span></code></pre></div>
+<div class="sourceCode" id="cb239"><pre class="sourceCode python"><code class="sourceCode python"><span id="cb239-1"><a href="#cb239-1" aria-hidden="true" tabindex="-1"></a><span class="cf">for</span> fahrzeug, (ladung, kapazitaet) <span class="kw">in</span> <span class="bu">enumerate</span>(<span class="bu">zip</span>(ladungen, KAPAZITAETEN)):</span>
+<span id="cb239-2"><a href="#cb239-2" aria-hidden="true" tabindex="-1"></a>    <span class="cf">assert</span> ladung <span class="op">&lt;=</span> kapazitaet, <span class="op">\</span></span>
+<span id="cb239-3"><a href="#cb239-3" aria-hidden="true" tabindex="-1"></a>        <span class="ss">f&quot;Fahrzeug </span><span class="sc">{</span>fahrzeug <span class="op">+</span> <span class="dv">1</span><span class="sc">}</span><span class="ss">: </span><span class="sc">{</span>ladung<span class="sc">}</span><span class="ss"> Paletten bei Kapazitaet </span><span class="sc">{</span>kapazitaet<span class="sc">}</span><span class="ss">&quot;</span></span></code></pre></div>
 <p>Dabei wird <code>ladung</code> <strong>aus der ausgegebenen Tour</strong> aufsummiert — also aus der Liste der angefahrenen Kunden und deren Bedarfen. Entscheidend ist, was man dafür <em>nicht</em> benutzt:</p>
-<div class="sourceCode" id="cb236"><pre class="sourceCode python"><code class="sourceCode python"><span id="cb236-1"><a href="#cb236-1" aria-hidden="true" tabindex="-1"></a><span class="co"># FALSCH als Pruefung:</span></span>
-<span id="cb236-2"><a href="#cb236-2" aria-hidden="true" tabindex="-1"></a>ladung <span class="op">=</span> loesung.Value(routing.GetDimensionOrDie(<span class="st">&quot;Ladung&quot;</span>).CumulVar(index))</span></code></pre></div>
+<div class="sourceCode" id="cb240"><pre class="sourceCode python"><code class="sourceCode python"><span id="cb240-1"><a href="#cb240-1" aria-hidden="true" tabindex="-1"></a><span class="co"># FALSCH als Pruefung:</span></span>
+<span id="cb240-2"><a href="#cb240-2" aria-hidden="true" tabindex="-1"></a>ladung <span class="op">=</span> loesung.Value(routing.GetDimensionOrDie(<span class="st">&quot;Ladung&quot;</span>).CumulVar(index))</span></code></pre></div>
 <p>Diese Zeile fragt das Modell, ob das Modell sich an sich selbst hält. Existiert die Dimension „Ladung“ gar nicht, stürzt sie ab — und existiert sie, kann sie per Konstruktion nie verletzt sein. Sie prüft also entweder nichts oder gar nichts.</p>
-<p><strong>Die allgemeine Regel:</strong> Eine Prüfung, die dieselben Bausteine verwendet wie das Modell, prüft das Modell gegen sich selbst. Nützlich ist nur eine Prüfung, die von der <strong>ausgegebenen Lösung</strong> ausgeht und die Anforderungen der Wirklichkeit unabhängig nachrechnet — genau wie die Kostengegenrechnung in <a href="#kapitel-5">Denkfehler 5.1</a> und die Verbrauchsprüfung in <a href="#kapitel-1">Denkfehler 1.1</a>.</p>
+<p><strong>Die allgemeine Regel:</strong> Eine Prüfung, die dieselben Bausteine verwendet wie das Modell, prüft das Modell gegen sich selbst. Nützlich ist nur eine Prüfung, die von der <strong>ausgegebenen Lösung</strong> ausgeht und die Anforderungen der Wirklichkeit unabhängig nachrechnet — genau wie die Kostengegenrechnung in <a href="#sec:milp-denkfehler">Abschnitt 6.10</a> und die Verbrauchsprüfung in <a href="#sec:einfuehrung-denkfehler">Abschnitt 1.10</a>.</p>
 <h3 id="quiz-loesung-graphen">Micro-Quiz</h3>
 <p><strong>1 — (b) totale Unimodularität.</strong> Jede quadratische Teilmatrix hat Determinante <span class="math inline">0</span>, <span class="math inline">+1</span> oder <span class="math inline">-1</span>; bei ganzzahliger rechter Seite sind deshalb alle Ecken des zulässigen Bereichs ganzzahlig. Da das LP-Optimum nach dem Fundamentalsatz in einer Ecke liegt, ist es automatisch 0/1-wertig. (a) unterschätzt das: Es ist kein Zufall, sondern eine Struktureigenschaft, die für <strong>jede</strong> Kostenmatrix gilt. (c) ist falsch — <code>linprog</code> rundet nichts.</p>
 <p><strong>2 — (b) die Struktur geht verloren.</strong> „Höchstens 4 von 12“ ist eine Kardinalitätsregel; ihre Zeile passt nicht in das Schema, das die totale Unimodularität sichert. Die Relaxation kann dann Brüche liefern (etwa vier Monteure zu je 0,75 Überstunden), und man braucht Binärvariablen und Branch-and-Bound. (a) ist die gefährliche Fehlannahme: Die Eigenschaft ist <strong>zerbrechlich</strong>, eine einzige zusätzliche Zeile genügt. (c) verwechselt „schwerer zu lösen“ mit „unlösbar“.</p>
-<p><strong>3 — (b) fehlende Dimension.</strong> Ohne begrenzende Dimension ist jede zusätzliche Tour reine Zusatzstrecke — ein Optimierer legt dann folgerichtig alles auf ein Fahrzeug. Genau dieses Bild zeigt Denkfehler 7.1. (a) wäre zu prüfen, wenn die Lösung <em>schlecht</em> aussähe, nicht wenn sie verdächtig gut ist. (c) ist zwar eine sinnvolle Datenprüfung, erklärt aber nicht, warum drei Fahrzeuge unbenutzt bleiben.</p>
+<p><strong>3 — (b) fehlende Dimension.</strong> Ohne begrenzende Dimension ist jede zusätzliche Tour reine Zusatzstrecke — ein Optimierer legt dann folgerichtig alles auf ein Fahrzeug. Genau dieses Bild zeigt <a href="#sec:graphen-denkfehler">Abschnitt 8.7</a>. (a) wäre zu prüfen, wenn die Lösung <em>schlecht</em> aussähe, nicht wenn sie verdächtig gut ist. (c) ist zwar eine sinnvolle Datenprüfung, erklärt aber nicht, warum drei Fahrzeuge unbenutzt bleiben.</p>
 <h3 id="selbsttest-loesung-graphen">Selbsttest</h3>
 <ol type="1">
 <li>Abfluss minus Zufluss = Knotensaldo; entspricht der Kirchhoffschen Knotenregel.</li>
@@ -28946,11 +30600,11 @@ Das zugehoerige Dockerfile ist kurz genug, um es ganz zu zeigen:
 </ol>
 <hr />
 <h2 id="sec:loesungen-metaheuristiken">A.9 Lösungen zu Kapitel „Metaheuristiken — wenn der exakte Solver aussteigt“</h2>
-<p><strong>Die Kurzsichtigkeit von Hand.</strong> Ab <em>Schwarz</em> wählt die Faustregel: Schwarz → Dunkelrot (26) → Rot (5) → … und muss dann in die helle Gruppe: Rot → Weiß (50) → Elfenbein (2) → Beige (2). Summe <strong>85 Minuten</strong> — also noch einen Deut schlechter als die 84 ab Weiß. Der Grund ist derselbe: Die Regel erwischt den Gruppenwechsel an der teuersten Stelle. Bemerkenswert ist aber, dass der <em>Startpunkt</em> kaum etwas ändert. Das ist typisch: Eine kurzsichtige Regel scheitert nicht am Anfang, sondern an der Reihenfolge, in der sie ihre Möglichkeiten verbraucht.</p>
-<p><strong>Zuggröße und Temperatur.</strong> Gesucht ist <span class="math inline">T</span> mit <span class="math inline">e^{-70/T} = e^{-1}</span>, also <strong><span class="math inline">T = 70</span></strong>. Die getesteten Temperaturen liegen zwischen 0,5 und 8 — allesamt <strong>eine Größenordnung darunter</strong>. Bei <span class="math inline">T_0 = 8</span> hat eine mediane Verschlechterung die Annahmewahrscheinlichkeit <span class="math inline">e^{-70/8} \approx 0{,}00016</span>. Genau das ist der Punkt der Warnung im Kapitel: Die verbreitete Regel „20 bis 50 % Annahmequote“ würde hier <span class="math inline">T_0 \approx 50</span> verlangen, und bei dieser Temperatur ist die Suche ein reiner Zufallslauf.</p>
-<p><strong>Die teure Bewertung.</strong> Statt <code>delta_verschieben</code> die Reihenfolge tatsächlich umbauen und <code>gesamtruestzeit()</code> neu rechnen. Bei <span class="math inline">n = 200</span> kostet das rund 200 Matrixzugriffe statt sechs. Erwartung: Die Zugzahl je Sekunde bricht um etwa zwei Größenordnungen ein. Bei gleichem <strong>Zeitbudget</strong> kommt die Suche entsprechend weniger weit; bei gleichem <strong>Zugbudget</strong> ist das Ergebnis identisch (die Bewertung ist ja korrekt, nur langsam). Genau diese Unterscheidung ist der Lehrpunkt: Die Implementierung ändert nicht das Verfahren, sondern nur, wie viel davon in das Zeitbudget passt.</p>
-<p><strong>Der Umschlagpunkt genauer.</strong> Sinnvolle Zwischengrößen sind 250, 300, 350 und 400. Zu erwarten ist ein <strong>verwaschener</strong> Übergang, kein scharfer Punkt: Der exakte Solver verschlechtert sich nicht sprunghaft, sondern sein Gap wächst, und irgendwann liegt seine beste gefundene Lösung über der heuristischen. Wo genau das passiert, hängt zusätzlich vom Zeitlimit ab — mit 300 Sekunden statt 30 verschiebt sich der Punkt nach oben. Die belastbare Aussage ist deshalb nie „ab <span class="math inline">n = 380</span>“, sondern immer „ab <span class="math inline">n \approx 380</span> <strong>bei diesem Zeitbudget</strong>“.</p>
-<p><strong>Zerstören nach Maß.</strong> Die kostenbasierte Zerstörung entfernt gezielt dort, wo etwas zu holen ist, und findet deshalb pro Runde mehr. Sie hat aber zwei Nachteile: Sie muss die Übergangskosten jedes Mal sortieren, und die entfernten Aufträge liegen über den ganzen Plan verstreut — das Teilproblem für CP-SAT ist damit schwieriger als ein zusammenhängendes Fenster gleicher Größe, weil auch alle Einfügestellen offen sind.</p>
+<p><strong>9.1 — Die Kurzsichtigkeit von Hand.</strong> Ab <em>Schwarz</em> wählt die Faustregel: Schwarz → Dunkelrot (26) → Rot (5) → … und muss dann in die helle Gruppe: Rot → Weiß (50) → Elfenbein (2) → Beige (2). Summe <strong>85 Minuten</strong> — also noch einen Deut schlechter als die 84 ab Weiß. Der Grund ist derselbe: Die Regel erwischt den Gruppenwechsel an der teuersten Stelle. Bemerkenswert ist aber, dass der <em>Startpunkt</em> kaum etwas ändert. Das ist typisch: Eine kurzsichtige Regel scheitert nicht am Anfang, sondern an der Reihenfolge, in der sie ihre Möglichkeiten verbraucht.</p>
+<p><strong>9.2 — Zuggröße und Temperatur.</strong> Gesucht ist <span class="math inline">T</span> mit <span class="math inline">e^{-70/T} = e^{-1}</span>, also <strong><span class="math inline">T = 70</span></strong>. Die getesteten Temperaturen liegen zwischen 0,5 und 8 — allesamt <strong>eine Größenordnung darunter</strong>. Bei <span class="math inline">T_0 = 8</span> hat eine mediane Verschlechterung die Annahmewahrscheinlichkeit <span class="math inline">e^{-70/8} \approx 0{,}00016</span>. Genau das ist der Punkt der Warnung im Kapitel: Die verbreitete Regel „20 bis 50 % Annahmequote“ würde hier <span class="math inline">T_0 \approx 50</span> verlangen, und bei dieser Temperatur ist die Suche ein reiner Zufallslauf.</p>
+<p><strong>9.3 — Die teure Bewertung.</strong> Statt <code>delta_verschieben</code> die Reihenfolge tatsächlich umbauen und <code>gesamtruestzeit()</code> neu rechnen. Bei <span class="math inline">n = 200</span> kostet das rund 200 Matrixzugriffe statt sechs. Erwartung: Die Zugzahl je Sekunde bricht um etwa zwei Größenordnungen ein. Bei gleichem <strong>Zeitbudget</strong> kommt die Suche entsprechend weniger weit; bei gleichem <strong>Zugbudget</strong> ist das Ergebnis identisch (die Bewertung ist ja korrekt, nur langsam). Genau diese Unterscheidung ist der Lehrpunkt: Die Implementierung ändert nicht das Verfahren, sondern nur, wie viel davon in das Zeitbudget passt.</p>
+<p><strong>9.4 — Der Umschlagpunkt genauer.</strong> Sinnvolle Zwischengrößen sind 250, 300, 350 und 400. Zu erwarten ist ein <strong>verwaschener</strong> Übergang, kein scharfer Punkt: Der exakte Solver verschlechtert sich nicht sprunghaft, sondern sein Gap wächst, und irgendwann liegt seine beste gefundene Lösung über der heuristischen. Wo genau das passiert, hängt zusätzlich vom Zeitlimit ab — mit 300 Sekunden statt 30 verschiebt sich der Punkt nach oben. Die belastbare Aussage ist deshalb nie „ab <span class="math inline">n = 380</span>“, sondern immer „ab <span class="math inline">n \approx 380</span> <strong>bei diesem Zeitbudget</strong>“.</p>
+<p><strong>9.5 — Zerstören nach Maß.</strong> Die kostenbasierte Zerstörung entfernt gezielt dort, wo etwas zu holen ist, und findet deshalb pro Runde mehr. Sie hat aber zwei Nachteile: Sie muss die Übergangskosten jedes Mal sortieren, und die entfernten Aufträge liegen über den ganzen Plan verstreut — das Teilproblem für CP-SAT ist damit schwieriger als ein zusammenhängendes Fenster gleicher Größe, weil auch alle Einfügestellen offen sind.</p>
 <p>Die Aufgabe ist bewusst so gestellt, dass die Antwort <strong>gemessen</strong> werden muss. Wer nur die Ergebniswerte vergleicht, kann Strategie und Rundenzahl nicht trennen. Die saubere Auswertung protokolliert beides: Verbesserungen <strong>je Runde</strong> (Güte der Strategie) und Runden <strong>je Sekunde</strong> (ihr Preis).</p>
 <h3 id="denkfehler-loesung-metaheuristiken">Finde den Denkfehler — „Unsere Heuristik ist 6 % besser“</h3>
 <p><strong>Es fehlt die Schranke.</strong></p>
@@ -28974,20 +30628,20 @@ Das zugehoerige Dockerfile ist kurz genug, um es ganz zu zeigen:
 </ol>
 <hr />
 <h2 id="sec:loesungen-dekomposition">A.10 Lösungen zu Kapitel „Spaltengenerierung“</h2>
-<p><strong>Das Abbruchkriterium.</strong> Die Eins ist der Zielfunktionskoeffizient eines Musters: Jedes geschnittene Muster verbraucht <strong>genau eine</strong> Mutterrolle, und die Zielfunktion lautet <span class="math inline">\min \sum_p x_p</span>. Die reduzierten Kosten einer neuen Spalte sind <span class="math inline">c_p - \pi^\top a_p = 1 - \sum_i \pi_i a_{ip}</span>; sie sind negativ — die Spalte lohnt sich also —, wenn <span class="math inline">\sum_i \pi_i a_{ip} &gt; 1</span>.</p>
+<p><strong>10.1 — Das Abbruchkriterium.</strong> Die Eins ist der Zielfunktionskoeffizient eines Musters: Jedes geschnittene Muster verbraucht <strong>genau eine</strong> Mutterrolle, und die Zielfunktion lautet <span class="math inline">\min \sum_p x_p</span>. Die reduzierten Kosten einer neuen Spalte sind <span class="math inline">c_p - \pi^\top a_p = 1 - \sum_i \pi_i a_{ip}</span>; sie sind negativ — die Spalte lohnt sich also —, wenn <span class="math inline">\sum_i \pi_i a_{ip} &gt; 1</span>.</p>
 <p>Wäre die Zielfunktion eine andere — etwa „minimiere den Verschnitt in Millimetern” —, stünde dort statt der Eins der Verschnitt des Musters. Die Eins ist also kein Zauberwert, sondern schlicht die Kosten der Spalte.</p>
-<p><strong>Die Startbasis.</strong> Ein Muster, das nur eine einzige Breite enthält, ist immer zulässig: <span class="math inline">\lfloor W / b_i \rfloor</span> Stücke der Breite <span class="math inline">i</span> passen in jede Rolle. Mit diesen <span class="math inline">n</span> Mustern lässt sich <strong>jeder</strong> Bedarf decken — notfalls sehr verschwenderisch, aber zulässig.</p>
+<p><strong>10.2 — Die Startbasis.</strong> Ein Muster, das nur eine einzige Breite enthält, ist immer zulässig: <span class="math inline">\lfloor W / b_i \rfloor</span> Stücke der Breite <span class="math inline">i</span> passen in jede Rolle. Mit diesen <span class="math inline">n</span> Mustern lässt sich <strong>jeder</strong> Bedarf decken — notfalls sehr verschwenderisch, aber zulässig.</p>
 <p>Eine leere Startmenge wäre ein Problem, weil das Master-LP dann unzulässig ist: Es gibt keine Spalten, mit denen sich die Bedarfszeilen erfüllen ließen. Ohne zulässige Lösung gibt es keine Dualwerte, und ohne Dualwerte kann das Pricing nicht arbeiten. Die Schleife käme nie in Gang.</p>
 <p>(In der Literatur behilft man sich alternativ mit künstlichen Variablen und sehr hohen Strafkosten — dieselbe Idee wie die Big-M-Phase des Simplex aus <a href="#kap-lp">Kapitel 5</a>.)</p>
-<p><strong>Die Kennzahl prüfen.</strong> Zu erwarten ist ein deutlicher, monotoner Zusammenhang: Je mehr Stücke auf eine Rolle passen, desto kleiner die Ersparnis. Bei zwei Stücken je Rolle entscheidet jede Paarung, und die Faustregel verschenkt regelmäßig ganze Rollen; ab acht bis zehn Stücken ist sie praktisch immer optimal.</p>
+<p><strong>10.3 — Die Kennzahl prüfen.</strong> Zu erwarten ist ein deutlicher, monotoner Zusammenhang: Je mehr Stücke auf eine Rolle passen, desto kleiner die Ersparnis. Bei zwei Stücken je Rolle entscheidet jede Paarung, und die Faustregel verschenkt regelmäßig ganze Rollen; ab acht bis zehn Stücken ist sie praktisch immer optimal.</p>
 <p>Der Grund ist ein Verhältnis: Der Verschnitt einer Rolle ist höchstens so groß wie das kleinste nicht mehr passende Stück. Sind die Stücke klein gegen die Rolle, ist auch dieser Rest klein — und der Gesamtverschnitt nähert sich der theoretischen Untergrenze <span class="math inline">\lceil \sum_i b_i d_i / W \rceil</span>, die jede Methode erreichen muss.</p>
-<p><strong>Dienstplanung.</strong> Eine „Spalte” ist ein <strong>vollständiger zulässiger Wochenplan einer Person</strong>: an welchen Tagen sie welche Schicht übernimmt.</p>
+<p><strong>10.4 — Dienstplanung.</strong> Eine „Spalte” ist ein <strong>vollständiger zulässiger Wochenplan einer Person</strong>: an welchen Tagen sie welche Schicht übernimmt.</p>
 <ul>
 <li><strong>Ins Master gehört</strong>, was Personen miteinander koppelt: Jede Schicht muss besetzt sein (<span class="math inline">\sum_p a_{sp} x_p \ge</span> Bedarf je Schicht <span class="math inline">s</span>), und jede Person bekommt genau einen Plan.</li>
 <li><strong>Ins Teilproblem gehört</strong>, was innerhalb einer Person gilt: Höchstarbeitszeit, Ruhezeiten, Qualifikation, keine zwei Schichten am selben Tag, höchstens zwei Wochenenden im Monat.</li>
 </ul>
 <p>Das ist der eigentliche Gewinn der Zerlegung: Die komplizierten arbeitsrechtlichen Regeln stehen im Teilproblem und werden dort <strong>einmal je Person</strong> geprüft, statt das Master zu überfrachten. Das Teilproblem ist meist ein kürzester Weg über ein Zeit-Zustands-Netz (<a href="#kap-graphen">Kapitel 8</a>) statt eines Rucksacks.</p>
-<p><strong>Branch-and-Price.</strong> Das Problem: Verzweigt man auf einer Mustervariablen (<span class="math inline">x_p \le 3</span> gegen <span class="math inline">x_p \ge 4</span>), so ist diese Bedingung im <strong>Pricing</strong> nicht darstellbar. Das Teilproblem erzeugt Muster, es kennt keine Verzweigungsentscheidungen über einzelne Spalten — es könnte im nächsten Schritt genau das ausgeschlossene Muster wieder erzeugen.</p>
+<p><strong>10.5 — Branch-and-Price.</strong> Das Problem: Verzweigt man auf einer Mustervariablen (<span class="math inline">x_p \le 3</span> gegen <span class="math inline">x_p \ge 4</span>), so ist diese Bedingung im <strong>Pricing</strong> nicht darstellbar. Das Teilproblem erzeugt Muster, es kennt keine Verzweigungsentscheidungen über einzelne Spalten — es könnte im nächsten Schritt genau das ausgeschlossene Muster wieder erzeugen.</p>
 <p>Branch-and-Price löst das, indem es auf <strong>Originalgrößen</strong> verzweigt statt auf Spalten: etwa „in wie vielen Rollen kommen Breite <span class="math inline">i</span> und Breite <span class="math inline">j</span> gemeinsam vor?” Solche Bedingungen lassen sich ins Pricing-Teilproblem einbauen, weil sie über die Struktur eines Musters sprechen und nicht über seine Identität.</p>
 <p>Für das Kapitel genügt der einfachere Weg: das ganzzahlige Master über die erzeugten Spalten. Es ist nicht garantiert optimal, liegt in der Praxis aber fast immer auf oder dicht bei der Schranke — hier exakt darauf (73 gegen 72,92).</p>
 <h3 id="denkfehler-loesung-dekomposition">Finde den Denkfehler — „Die LP-Lösung sagt 72,92 — also runden wir auf“</h3>
@@ -29035,13 +30689,13 @@ Das zugehoerige Dockerfile ist kurz genug, um es ganz zu zeigen:
 </ol>
 <hr />
 <h2 id="sec:loesungen-qp-nlp">A.11 Lösungen zu Kapitel „Quadratische und nichtlineare Optimierung — KKT, Lagrange, Konvexität“</h2>
-<p><strong>8.1 — Konvexität einordnen.</strong> PSD (alle <span class="math inline">\ge 0</span>) → <strong>konvex</strong>, aber <strong>nicht streng</strong> konvex; die Lösung ist <strong>nicht notwendig eindeutig</strong>. Der Eigenwert 0 bedeutet eine <strong>flache Richtung</strong>: Entlang des zugehörigen Eigenvektors ändert sich der quadratische Term nicht — es gibt eine Rinne statt eines Punktes.</p>
-<p><strong>8.2 — Komplementärer Schlupf.</strong> Ja, verträglich: <span class="math inline">\lambda_i w_i = 0</span> gilt für alle <span class="math inline">i</span> (<span class="math inline">w_2 = 0</span> mit <span class="math inline">\lambda_2 &gt; 0</span>; die anderen mit <span class="math inline">\lambda = 0</span>). <span class="math inline">\lambda_2 = 0{,}03</span> bedeutet: Würde man Titel 2 zwingen, ein kleines positives Gewicht zu tragen, verschlechterte sich der Zielwert um 0,03 je Einheit — die Nichtnegativitätsschranke ist dort <strong>bindend</strong>.</p>
-<p><strong>8.3 — KKT von Hand.</strong> <span class="math inline">\mathcal{L} = x_1^2 + x_2^2 + \lambda(4 - x_1 - x_2)</span>. Stationarität: <span class="math inline">2x_1 = \lambda</span>, <span class="math inline">2x_2 = \lambda</span> → <span class="math inline">x_1 = x_2</span>. Bindend (<span class="math inline">\lambda &gt; 0</span>): <span class="math inline">x_1 + x_2 = 4</span> → <span class="math inline">x_1 = x_2 = 2</span>, <span class="math inline">\lambda = 4</span>. Prüfung: <span class="math inline">\lambda = 4 &gt; 0</span> ✓, <span class="math inline">f = 8</span>. <strong>Interpretation:</strong> Würde die Forderung auf <span class="math inline">\ge 4{,}1</span> steigen, stiege <span class="math inline">f</span> um etwa <span class="math inline">4 \cdot 0{,}1 = 0{,}4</span>. Probe: <span class="math inline">2\cdot(2{,}05)^2 = 8{,}405</span> ✓.</p>
-<p><strong>8.4 — Unmögliche Korrelationsmatrix.</strong> Eigenwerte <span class="math inline">\approx (-0{,}62;\ 1{,}0;\ 2{,}62)</span> → <strong>nicht PSD</strong>, also unmöglich. Anschaulich: Wenn A stark <strong>positiv</strong> mit B korreliert und B stark positiv mit C, kann A nicht gleichzeitig stark <strong>negativ</strong> mit C korrelieren — Korrelation ist eingeschränkt transitiv. Formal: <span class="math inline">\rho_{AC} \ge \rho_{AB}\rho_{BC} - \sqrt{(1-\rho_{AB}^2)(1-\rho_{BC}^2)} = 0{,}81 - 0{,}19 = 0{,}62</span>; verlangt waren <span class="math inline">-0{,}9</span>.</p>
-<p><strong>8.5 — Gewichtung untersuchen.</strong> Erwartetes Muster: Größeres <span class="math inline">\alpha</span> → mehr Rendite, mehr Konzentration im Titel mit höchstem <span class="math inline">\mu</span>. Größeres <span class="math inline">\beta</span> → gleichmäßigere Gewichte, Entropie steigt Richtung <span class="math inline">\ln 4 = 1{,}386</span>. Ab etwa <span class="math inline">\beta \approx 0{,}1</span> dominiert die Entropie und man nähert sich der Gleichgewichtung. <strong>Empfehlung an einen Ausschuss:</strong> Nicht mit <span class="math inline">\beta</span> argumentieren, sondern mit der resultierenden <strong>Maximalposition</strong> — „mit dieser Einstellung liegt keine Position über 40 %“ ist verständlich, „<span class="math inline">\beta = 0{,}015</span>“ nicht.</p>
-<p><strong>8.6 — Nicht-Konvexität demonstrieren.</strong> Mit der bewusst fehlerhaft konstruierten Matrix finden 20 Startpunkte typischerweise mehrere verschiedene Optima; die „Portfoliovarianz“ <span class="math inline">w^\top\Sigma w</span> kann bei geeigneten Gewichten negativ werden (der zugehörige Eigenvektor liegt allerdings teilweise außerhalb des zulässigen Bereichs <span class="math inline">w \ge 0{,}001</span>, <span class="math inline">\sum w = 1</span> — deshalb fällt der Fehler bei naiver Prüfung nicht auf).</p>
-<h3 id="finde-den-denkfehler-8.1-die-kovarianzmatrix-aus-dem-controlling">Finde den Denkfehler 8.1 — Die Kovarianzmatrix aus dem Controlling</h3>
+<p><strong>11.1 — Konvexität einordnen.</strong> PSD (alle <span class="math inline">\ge 0</span>) → <strong>konvex</strong>, aber <strong>nicht streng</strong> konvex; die Lösung ist <strong>nicht notwendig eindeutig</strong>. Der Eigenwert 0 bedeutet eine <strong>flache Richtung</strong>: Entlang des zugehörigen Eigenvektors ändert sich der quadratische Term nicht — es gibt eine Rinne statt eines Punktes.</p>
+<p><strong>11.2 — Komplementärer Schlupf.</strong> Ja, verträglich: <span class="math inline">\lambda_i w_i = 0</span> gilt für alle <span class="math inline">i</span> (<span class="math inline">w_2 = 0</span> mit <span class="math inline">\lambda_2 &gt; 0</span>; die anderen mit <span class="math inline">\lambda = 0</span>). <span class="math inline">\lambda_2 = 0{,}03</span> bedeutet: Würde man Titel 2 zwingen, ein kleines positives Gewicht zu tragen, verschlechterte sich der Zielwert um 0,03 je Einheit — die Nichtnegativitätsschranke ist dort <strong>bindend</strong>.</p>
+<p><strong>11.3 — KKT von Hand.</strong> <span class="math inline">\mathcal{L} = x_1^2 + x_2^2 + \lambda(4 - x_1 - x_2)</span>. Stationarität: <span class="math inline">2x_1 = \lambda</span>, <span class="math inline">2x_2 = \lambda</span> → <span class="math inline">x_1 = x_2</span>. Bindend (<span class="math inline">\lambda &gt; 0</span>): <span class="math inline">x_1 + x_2 = 4</span> → <span class="math inline">x_1 = x_2 = 2</span>, <span class="math inline">\lambda = 4</span>. Prüfung: <span class="math inline">\lambda = 4 &gt; 0</span> ✓, <span class="math inline">f = 8</span>. <strong>Interpretation:</strong> Würde die Forderung auf <span class="math inline">\ge 4{,}1</span> steigen, stiege <span class="math inline">f</span> um etwa <span class="math inline">4 \cdot 0{,}1 = 0{,}4</span>. Probe: <span class="math inline">2\cdot(2{,}05)^2 = 8{,}405</span> ✓.</p>
+<p><strong>11.4 — Unmögliche Korrelationsmatrix.</strong> Eigenwerte <span class="math inline">\approx (-0{,}62;\ 1{,}0;\ 2{,}62)</span> → <strong>nicht PSD</strong>, also unmöglich. Anschaulich: Wenn A stark <strong>positiv</strong> mit B korreliert und B stark positiv mit C, kann A nicht gleichzeitig stark <strong>negativ</strong> mit C korrelieren — Korrelation ist eingeschränkt transitiv. Formal: <span class="math inline">\rho_{AC} \ge \rho_{AB}\rho_{BC} - \sqrt{(1-\rho_{AB}^2)(1-\rho_{BC}^2)} = 0{,}81 - 0{,}19 = 0{,}62</span>; verlangt waren <span class="math inline">-0{,}9</span>.</p>
+<p><strong>11.5 — Gewichtung untersuchen.</strong> Erwartetes Muster: Größeres <span class="math inline">\alpha</span> → mehr Rendite, mehr Konzentration im Titel mit höchstem <span class="math inline">\mu</span>. Größeres <span class="math inline">\beta</span> → gleichmäßigere Gewichte, Entropie steigt Richtung <span class="math inline">\ln 4 = 1{,}386</span>. Ab etwa <span class="math inline">\beta \approx 0{,}1</span> dominiert die Entropie und man nähert sich der Gleichgewichtung. <strong>Empfehlung an einen Ausschuss:</strong> Nicht mit <span class="math inline">\beta</span> argumentieren, sondern mit der resultierenden <strong>Maximalposition</strong> — „mit dieser Einstellung liegt keine Position über 40 %“ ist verständlich, „<span class="math inline">\beta = 0{,}015</span>“ nicht.</p>
+<p><strong>11.6 — Nicht-Konvexität demonstrieren.</strong> Mit der bewusst fehlerhaft konstruierten Matrix finden 20 Startpunkte typischerweise mehrere verschiedene Optima; die „Portfoliovarianz“ <span class="math inline">w^\top\Sigma w</span> kann bei geeigneten Gewichten negativ werden (der zugehörige Eigenvektor liegt allerdings teilweise außerhalb des zulässigen Bereichs <span class="math inline">w \ge 0{,}001</span>, <span class="math inline">\sum w = 1</span> — deshalb fällt der Fehler bei naiver Prüfung nicht auf).</p>
+<h3 id="finde-den-denkfehler-die-kovarianzmatrix-aus-dem-controlling">Finde den Denkfehler — Die Kovarianzmatrix aus dem Controlling</h3>
 <ol type="a">
 <li><strong>Ohne zu rechnen.</strong> Stellen Sie sich die drei Anlagen als drei Personen vor, die nebeneinander gehen. A und B gehen fast im Gleichschritt (<span class="math inline">0{,}9</span>). B und C gehen fast im Gleichschritt (<span class="math inline">0{,}9</span>). Können A und C dann in <em>entgegengesetzte</em> Richtungen laufen? Nein — wenn A B folgt und B C folgt, muss A ungefähr auch C folgen. Korrelation ist zwar nicht transitiv im strengen Sinne, aber sie ist <strong>eingeschränkt</strong>: Zwei starke Bindungen zwingen die dritte in einen engen Bereich.</li>
 </ol>
@@ -29055,9 +30709,9 @@ Das zugehoerige Dockerfile ist kurz genug, um es ganz zu zeigen:
 <li><strong>Die Eigenwerte</strong> von <span class="math inline">\mathbf{R}</span> lauten <span class="math inline">(-0{,}8;\ 1{,}9;\ 1{,}9)</span>. Ein <strong>negativer</strong> Eigenwert bedeutet: Die Matrix ist nicht positiv semidefinit. Es gibt eine Richtung im Gewichtsraum — hier ungefähr <span class="math inline">(0{,}58;\ -0{,}58;\ 0{,}58)</span>, der Eigenvektor zu <span class="math inline">-0{,}8</span> —, entlang derer die quadratische Form <strong>negativ</strong> wird. Genau diese Richtung hat <code>scipy</code> gefunden: Das Ergebnis <span class="math inline">(1{,}5;\ -2{,}0;\ 1{,}5)</span> ist ein Vielfaches davon.</li>
 </ol>
 <p>Der Test dafür ist eine Zeile und gehört vor jede Risikorechnung:</p>
-<div class="sourceCode" id="cb237"><pre class="sourceCode python"><code class="sourceCode python"><span id="cb237-1"><a href="#cb237-1" aria-hidden="true" tabindex="-1"></a>eigenwerte <span class="op">=</span> np.linalg.eigvalsh(S)</span>
-<span id="cb237-2"><a href="#cb237-2" aria-hidden="true" tabindex="-1"></a><span class="cf">assert</span> eigenwerte.<span class="bu">min</span>() <span class="op">&gt;=</span> <span class="op">-</span><span class="fl">1e-10</span>, <span class="op">\</span></span>
-<span id="cb237-3"><a href="#cb237-3" aria-hidden="true" tabindex="-1"></a>    <span class="ss">f&quot;Kovarianzmatrix nicht positiv semidefinit: kleinster Eigenwert </span><span class="sc">{</span>eigenwerte<span class="sc">.</span><span class="bu">min</span>()<span class="sc">:.3f}</span><span class="ss">&quot;</span></span></code></pre></div>
+<div class="sourceCode" id="cb241"><pre class="sourceCode python"><code class="sourceCode python"><span id="cb241-1"><a href="#cb241-1" aria-hidden="true" tabindex="-1"></a>eigenwerte <span class="op">=</span> np.linalg.eigvalsh(S)</span>
+<span id="cb241-2"><a href="#cb241-2" aria-hidden="true" tabindex="-1"></a><span class="cf">assert</span> eigenwerte.<span class="bu">min</span>() <span class="op">&gt;=</span> <span class="op">-</span><span class="fl">1e-10</span>, <span class="op">\</span></span>
+<span id="cb241-3"><a href="#cb241-3" aria-hidden="true" tabindex="-1"></a>    <span class="ss">f&quot;Kovarianzmatrix nicht positiv semidefinit: kleinster Eigenwert </span><span class="sc">{</span>eigenwerte<span class="sc">.</span><span class="bu">min</span>()<span class="sc">:.3f}</span><span class="ss">&quot;</span></span></code></pre></div>
 <ol start="3" type="a">
 <li><strong>Warum das kein Rechenfehler ist.</strong> <code>scipy</code> hat exakt die Aufgabe gelöst, die man ihm gestellt hat: „minimiere <span class="math inline">\mathbf{w}^\top\mathbf{S}\mathbf{w}</span>“. Dass dieser Ausdruck bei nicht positiv semidefinitem <span class="math inline">\mathbf{S}</span> beliebig negativ werden kann, ist eine Eigenschaft der <strong>Eingabe</strong>, nicht des Verfahrens. <code>success: True</code> heißt hier — wie in <a href="#sec:qp-nlp-nichtkonvex">Abschnitt 11.6</a> — nur: „Ich bin an einer Stelle angekommen, an der es nicht weiter bergab geht.“ Dass es überhaupt bis <span class="math inline">-0{,}254</span> bergab ging, lag allein an den Schranken <span class="math inline">\pm 2</span>; ohne sie liefe das Verfahren gegen <span class="math inline">-\infty</span>.</li>
 </ol>
@@ -29075,7 +30729,7 @@ Das zugehoerige Dockerfile ist kurz genug, um es ganz zu zeigen:
 <p><strong>Der Merksatz dazu:</strong> Eine Kovarianzmatrix ist kein Behälter für einzeln geschätzte Zahlen, sondern ein geometrisches Objekt. Nicht jede Kombination von Korrelationen existiert.</p>
 </blockquote>
 <h3 id="quiz-loesung-qp-nlp">Micro-Quiz</h3>
-<p><strong>1 — (b).</strong> Der <code>DCPError</code> ist eine inhaltliche Aussage: Für diese Formulierung kann es keine Optimalitätsgarantie geben. Auf <code>scipy</code> auszuweichen (a) beseitigt die Meldung, nicht die Ursache — man bekommt dann ein lokales Ergebnis ohne Garantie und ohne Warnung, wie Denkfehler 8.1 zeigt. Toleranzen (c) haben mit Konvexität nichts zu tun. Richtig ist, zwischen zwei bewussten Wegen zu wählen: konvex umformulieren, oder lokal rechnen <strong>und</strong> das im Bericht kenntlich machen.</p>
+<p><strong>1 — (b).</strong> Der <code>DCPError</code> ist eine inhaltliche Aussage: Für diese Formulierung kann es keine Optimalitätsgarantie geben. Auf <code>scipy</code> auszuweichen (a) beseitigt die Meldung, nicht die Ursache — man bekommt dann ein lokales Ergebnis ohne Garantie und ohne Warnung, wie <a href="#sec:qp-nlp-denkfehler">Abschnitt 11.8</a> zeigt. Toleranzen (c) haben mit Konvexität nichts zu tun. Richtig ist, zwischen zwei bewussten Wegen zu wählen: konvex umformulieren, oder lokal rechnen <strong>und</strong> das im Bericht kenntlich machen.</p>
 <p><strong>2 — (b) ein lokales Minimum.</strong> <code>success: True</code> beschreibt die Konvergenz des Verfahrens, nicht die Qualität des Ergebnisses. Bei Mengenrabatten ist die Zielfunktion nicht konvex, also kann es mehrere lokale Minima geben — im Kapitelbeispiel fünf, mit 8 % Spanne. (a) wäre nur bei einem konvexen Problem richtig. (c) ist zu pessimistisch: Ein lokales Minimum ist es sehr wohl, die Zulässigkeit wird von SLSQP eingehalten.</p>
 <p><strong>3 — (c) Schattenpreis.</strong> <span class="math inline">\lambda^*</span> ist die Ableitung des optimalen Zielwerts nach der rechten Seite der Nebenbedingung — dieselbe Bedeutung wie der Dualwert im LP (<a href="#kap-lp">Kapitel 5</a>), nur für allgemeine, auch krumme Nebenbedingungen. (a) und (b) verwechseln den Multiplikator mit einer Verletzungszahl beziehungsweise mit dem Schlupf; der Schlupf ist bei einer bindenden Bedingung gerade <strong>null</strong> (komplementärer Schlupf).</p>
 <h3 id="selbsttest-loesung-qp-nlp">Selbsttest</h3>
@@ -29088,17 +30742,17 @@ Das zugehoerige Dockerfile ist kurz genug, um es ganz zu zeigen:
 </ol>
 <hr />
 <h2 id="sec:loesungen-unsicherheit">A.12 Lösungen zu Kapitel „Optimierung unter Unsicherheit — Monte-Carlo, Stochastik, Robustheit“</h2>
-<p><strong>9.1 — Fluch des Durchschnitts.</strong> Weil sich Verzögerungen <strong>fortpflanzen</strong> und die Verteilung rechtsschief ist: Ein Gewerk, das früher fertig wird, beschleunigt selten den Gesamtablauf (der nächste Schritt ist noch nicht bereit), ein verspätetes verzögert alles. Weitere Beispiele: Wartezeiten in Warteschlangen (nichtlinear in der Auslastung), Projektkosten mit Nachträgen.</p>
-<p><strong>9.2 — Ansatz wählen.</strong> (a) robust (Ausfall ist existenziell, Wahrscheinlichkeiten unzuverlässig). (b) stochastisch (Verteilung bekannt). (c) robust bzw. Extremwertstatistik (seltene Ereignisse, katastrophale Folgen). (d) stochastisch (Szenarien mit Wahrscheinlichkeiten liegen vor). (e) Chance Constraint — die Zusage ist bereits als Quote formuliert („an 99 % aller Wintertage“). Robust wäre hier zu teuer (es gibt immer einen kälteren Tag), der Erwartungswert zu schwach (er sagt nichts über die Zusage).</p>
-<p><strong>9.3 — Zweistufig rechnen.</strong> (a) Mit Spot = 60: Ableitung bei <span class="math inline">x \in (100,250)</span>: <span class="math inline">40 - 60\cdot0{,}5 + 5\cdot0{,}5 = 40-30+2{,}5 = +12{,}5 &gt; 0</span> → Kapazität <strong>senken</strong>. Bei <span class="math inline">x &lt; 100</span>: <span class="math inline">40 - 60 = -20 &lt; 0</span> → erhöhen. Optimum daher <span class="math inline">x^* = 100</span>. (b) Billige Nachbesserung macht Vorhalten unattraktiv. (c) Bei <span class="math inline">x = 225</span> optimal müsste die Ableitung dort das Vorzeichen wechseln — das ist bei diskreten Szenarien nur zufällig der Fall; der Mittelwert ist nur bei symmetrischen Kosten und stetiger Verteilung optimal.</p>
-<p><strong>9.4 — EVPI interpretieren.</strong> Selbst eine <strong>perfekte</strong> Prognose wäre nur 8 400 € pro Jahr wert. Eine Lösung für 15 000 € kann sich also <strong>niemals</strong> rechnen — unabhängig von ihrer Güte. Argument: „Der theoretische Maximalnutzen liegt unter dem Preis.“</p>
-<p><strong>9.5 — Monte-Carlo erweitern.</strong> (a) Servicelevel 95 %: Kapazität = 95 %-Quantil des Bedarfs (ca. 485). Die Zusatzkosten gegenüber dem Kostenoptimum (180) betragen ein Vielfaches — Servicelevel ist teuer, und genau diese Zahl braucht die Geschäftsleitung für die Entscheidung. (b) <code>cvar = kosten[kosten &gt;= np.quantile(kosten, 0.95)].mean()</code>. (c) Erwartetes Bild: Bei kleiner Kapazität ist die Kostenverteilung stark rechtsschief (seltene, teure Notzukäufe); bei großer Kapazität schmal und nach rechts verschoben.</p>
-<p><strong>9.6 — Den Preis der Zusage selbst bestimmen.</strong> (a) Die Kosten je Prozentpunkt steigen weiter steil an; der Mix verschiebt sich dabei fast nur noch zugunsten des Gaskraftwerks, weil Biomasse längst an ihrer Ausbaugrenze liegt. Wind und Sonne bleiben bei einem kleinen Rest — sie senken über ihre Gegenläufigkeit die Norm, tragen zur gesicherten Leistung aber kaum bei. (b) Der Unterschied ist <strong>nicht</strong> numerisch, sondern inhaltlich. Bei 200 MW Biomasse liefert selbst der <strong>Vollausbau</strong> in der Kältewelle nur rund 440 MW — 7,5 % der Szenarien sind schlicht nicht bedienbar, egal wie viel Geld man ausgibt. Das Szenariomodell sieht diese Fälle in den Daten und meldet korrekt <code>infeasible</code>, sobald die Zusage über 92 % steigt. Das analytische Modell kennt sie nicht: Für eine Normalverteilung ist jede Zusage unter 100 % erfüllbar, wenn man nur genug Streuung wegkauft. Es meldet <code>optimal</code> — und der Plan hält gemessen 87,4 %. Glauben sollte man dem Szenariomodell: Ein <code>infeasible</code> ist hier die <strong>richtige</strong> Antwort. Es sagt, dass die Zusage nicht am Budget scheitert, sondern am Kraftwerkspark, und dass nicht mehr Geld hilft, sondern nur eine andere Anlage oder eine kleinere Zusage. (c) Sinngemäß: „99,99 % kosten nicht 5 % mehr als 99 %, sondern ein Vielfaches — der letzte Prozentpunkt ist bereits 4,5-mal so teuer wie der erste. Sagen Sie mir, was ein Ausfalltag das Unternehmen kostet, dann rechne ich aus, welche Quote sich lohnt. Und die Zusage gilt nur für die Wetterlagen, die wir modelliert haben — die Kältewelle gehört hinein.“</p>
-<p><strong>9.7 — Budgeted Uncertainty.</strong></p>
-<div class="sourceCode" id="cb238"><pre class="sourceCode python"><code class="sourceCode python"><span id="cb238-1"><a href="#cb238-1" aria-hidden="true" tabindex="-1"></a>abzug <span class="op">=</span> cp.sum_largest(cp.multiply(UNSICHERHEIT, w), Gamma)</span>
-<span id="cb238-2"><a href="#cb238-2" aria-hidden="true" tabindex="-1"></a>ziel <span class="op">=</span> cp.Maximize(MU_SCHAETZUNG <span class="op">@</span> w <span class="op">-</span> abzug <span class="op">-</span> <span class="fl">0.5</span><span class="op">*</span>LAMBDA<span class="op">*</span>cp.quad_form(w, SIGMA))</span></code></pre></div>
+<p><strong>12.1 — Fluch des Durchschnitts.</strong> Weil sich Verzögerungen <strong>fortpflanzen</strong> und die Verteilung rechtsschief ist: Ein Gewerk, das früher fertig wird, beschleunigt selten den Gesamtablauf (der nächste Schritt ist noch nicht bereit), ein verspätetes verzögert alles. Weitere Beispiele: Wartezeiten in Warteschlangen (nichtlinear in der Auslastung), Projektkosten mit Nachträgen.</p>
+<p><strong>12.2 — Ansatz wählen.</strong> (a) robust (Ausfall ist existenziell, Wahrscheinlichkeiten unzuverlässig). (b) stochastisch (Verteilung bekannt). (c) robust bzw. Extremwertstatistik (seltene Ereignisse, katastrophale Folgen). (d) stochastisch (Szenarien mit Wahrscheinlichkeiten liegen vor). (e) Chance Constraint — die Zusage ist bereits als Quote formuliert („an 99 % aller Wintertage“). Robust wäre hier zu teuer (es gibt immer einen kälteren Tag), der Erwartungswert zu schwach (er sagt nichts über die Zusage).</p>
+<p><strong>12.3 — Zweistufig rechnen.</strong> (a) Mit Spot = 60: Ableitung bei <span class="math inline">x \in (100,250)</span>: <span class="math inline">40 - 60\cdot0{,}5 + 5\cdot0{,}5 = 40-30+2{,}5 = +12{,}5 &gt; 0</span> → Kapazität <strong>senken</strong>. Bei <span class="math inline">x &lt; 100</span>: <span class="math inline">40 - 60 = -20 &lt; 0</span> → erhöhen. Optimum daher <span class="math inline">x^* = 100</span>. (b) Billige Nachbesserung macht Vorhalten unattraktiv. (c) Bei <span class="math inline">x = 225</span> optimal müsste die Ableitung dort das Vorzeichen wechseln — das ist bei diskreten Szenarien nur zufällig der Fall; der Mittelwert ist nur bei symmetrischen Kosten und stetiger Verteilung optimal.</p>
+<p><strong>12.4 — EVPI interpretieren.</strong> Selbst eine <strong>perfekte</strong> Prognose wäre nur 8 400 € pro Jahr wert. Eine Lösung für 15 000 € kann sich also <strong>niemals</strong> rechnen — unabhängig von ihrer Güte. Argument: „Der theoretische Maximalnutzen liegt unter dem Preis.“</p>
+<p><strong>12.5 — Monte-Carlo erweitern.</strong> (a) Servicelevel 95 %: Kapazität = 95 %-Quantil des Bedarfs (ca. 485). Die Zusatzkosten gegenüber dem Kostenoptimum (180) betragen ein Vielfaches — Servicelevel ist teuer, und genau diese Zahl braucht die Geschäftsleitung für die Entscheidung. (b) <code>cvar = kosten[kosten &gt;= np.quantile(kosten, 0.95)].mean()</code>. (c) Erwartetes Bild: Bei kleiner Kapazität ist die Kostenverteilung stark rechtsschief (seltene, teure Notzukäufe); bei großer Kapazität schmal und nach rechts verschoben.</p>
+<p><strong>12.6 — Den Preis der Zusage selbst bestimmen.</strong> (a) Die Kosten je Prozentpunkt steigen weiter steil an; der Mix verschiebt sich dabei fast nur noch zugunsten des Gaskraftwerks, weil Biomasse längst an ihrer Ausbaugrenze liegt. Wind und Sonne bleiben bei einem kleinen Rest — sie senken über ihre Gegenläufigkeit die Norm, tragen zur gesicherten Leistung aber kaum bei. (b) Der Unterschied ist <strong>nicht</strong> numerisch, sondern inhaltlich. Bei 200 MW Biomasse liefert selbst der <strong>Vollausbau</strong> in der Kältewelle nur rund 440 MW — 7,5 % der Szenarien sind schlicht nicht bedienbar, egal wie viel Geld man ausgibt. Das Szenariomodell sieht diese Fälle in den Daten und meldet korrekt <code>infeasible</code>, sobald die Zusage über 92 % steigt. Das analytische Modell kennt sie nicht: Für eine Normalverteilung ist jede Zusage unter 100 % erfüllbar, wenn man nur genug Streuung wegkauft. Es meldet <code>optimal</code> — und der Plan hält gemessen 87,4 %. Glauben sollte man dem Szenariomodell: Ein <code>infeasible</code> ist hier die <strong>richtige</strong> Antwort. Es sagt, dass die Zusage nicht am Budget scheitert, sondern am Kraftwerkspark, und dass nicht mehr Geld hilft, sondern nur eine andere Anlage oder eine kleinere Zusage. (c) Sinngemäß: „99,99 % kosten nicht 5 % mehr als 99 %, sondern ein Vielfaches — der letzte Prozentpunkt ist bereits 4,5-mal so teuer wie der erste. Sagen Sie mir, was ein Ausfalltag das Unternehmen kostet, dann rechne ich aus, welche Quote sich lohnt. Und die Zusage gilt nur für die Wetterlagen, die wir modelliert haben — die Kältewelle gehört hinein.“</p>
+<p><strong>12.7 — Budgeted Uncertainty.</strong></p>
+<div class="sourceCode" id="cb242"><pre class="sourceCode python"><code class="sourceCode python"><span id="cb242-1"><a href="#cb242-1" aria-hidden="true" tabindex="-1"></a>abzug <span class="op">=</span> cp.sum_largest(cp.multiply(UNSICHERHEIT, w), Gamma)</span>
+<span id="cb242-2"><a href="#cb242-2" aria-hidden="true" tabindex="-1"></a>ziel <span class="op">=</span> cp.Maximize(MU_SCHAETZUNG <span class="op">@</span> w <span class="op">-</span> abzug <span class="op">-</span> <span class="fl">0.5</span><span class="op">*</span>LAMBDA<span class="op">*</span>cp.quad_form(w, SIGMA))</span></code></pre></div>
 <p><span class="math inline">\Gamma = 0</span> entspricht dem nominalen Fall, <span class="math inline">\Gamma = n</span> dem vollen Worst Case. Dazwischen steuert <span class="math inline">\Gamma</span> die Vorsicht stufenlos — der praktisch nützlichste Bereich liegt meist bei <span class="math inline">\Gamma \approx \sqrt{n}</span>.</p>
-<h3 id="finde-den-denkfehler-9.1-warum-jedes-projekt-zu-spät-fertig-wird">Finde den Denkfehler 9.1 — Warum jedes Projekt zu spät fertig wird</h3>
+<h3 id="finde-den-denkfehler-warum-jedes-projekt-zu-spät-fertig-wird">Finde den Denkfehler — Warum jedes Projekt zu spät fertig wird</h3>
 <ol type="a">
 <li><strong>Warum 14,38 statt 11,34 Tage.</strong> Der Projektleiter hat den Mittelwert der <strong>Einzeldauer</strong> berechnet und ihn für den Mittelwert der <strong>Projektdauer</strong> gehalten. Das sind zwei verschiedene Größen:</li>
 </ol>
@@ -29127,13 +30781,13 @@ F(11{,}33) = 1 - \frac{(18-11{,}33)^2}{(18-6)(18-10)} = 1 - \frac{44{,}4}{96} =
 <ol start="4" type="a">
 <li><strong>Die Zahl für den Projektplan.</strong> Bei einer geforderten Sicherheit von 90 % gehört das <strong>90-%-Quantil</strong> in den Plan: <strong>16,6 Tage</strong>, aufgerundet 17. Das sind 47 % mehr als die ursprünglich geplanten 11,3 Tage.</li>
 </ol>
-<div class="sourceCode" id="cb239"><pre class="sourceCode python"><code class="sourceCode python"><span id="cb239-1"><a href="#cb239-1" aria-hidden="true" tabindex="-1"></a>puffer <span class="op">=</span> np.quantile(projekt, <span class="fl">0.90</span>)</span>
-<span id="cb239-2"><a href="#cb239-2" aria-hidden="true" tabindex="-1"></a><span class="bu">print</span>(<span class="ss">f&quot;Termin mit 90 % Sicherheit: </span><span class="sc">{</span>np<span class="sc">.</span>ceil(puffer)<span class="sc">:.0f}</span><span class="ss"> Tage&quot;</span>)</span></code></pre></div>
+<div class="sourceCode" id="cb243"><pre class="sourceCode python"><code class="sourceCode python"><span id="cb243-1"><a href="#cb243-1" aria-hidden="true" tabindex="-1"></a>puffer <span class="op">=</span> np.quantile(projekt, <span class="fl">0.90</span>)</span>
+<span id="cb243-2"><a href="#cb243-2" aria-hidden="true" tabindex="-1"></a><span class="bu">print</span>(<span class="ss">f&quot;Termin mit 90 % Sicherheit: </span><span class="sc">{</span>np<span class="sc">.</span>ceil(puffer)<span class="sc">:.0f}</span><span class="ss"> Tage&quot;</span>)</span></code></pre></div>
 <p>Und die Formulierung gegenüber dem Auftraggeber lautet nicht „der Umbau dauert 17 Tage“, sondern: <em>„In 9 von 10 Fällen sind wir nach 17 Tagen fertig; im Mittel nach 14,4.“</em> Diese zwei Zahlen sind eine belastbare Zusage — eine einzelne ist es nie.</p>
 <h3 id="quiz-loesung-unsicherheit">Micro-Quiz</h3>
 <p><strong>1 — (b).</strong> Das kritische Verhältnis <span class="math inline">1400/(1400+120) = 0{,}921</span> gibt an, wie weit man sich auf die günstigere Fehlerseite stellen soll: Bestellt wird das 92,1-%-Quantil des Bedarfs, hier 38 Stück. (a) ignoriert die Kostenasymmetrie und kostet im Kapitelbeispiel 160 % mehr. (c) verwechselt die Fragestellung: Die Kapitalbindung <em>ist</em> bereits in den 120 € je überzähligem Stück enthalten — sie rechtfertigt keine zusätzliche Kürzung.</p>
 <p><strong>2 — (b).</strong> Der Unterschied liegt darin, <strong>was man wissen muss</strong>: Stochastische Optimierung setzt eine Wahrscheinlichkeitsverteilung voraus und minimiert den Erwartungswert; robuste Optimierung kommt mit einer bloßen Bandbreite aus und sichert den ungünstigsten Fall darin ab. Keines ist „genauer“ (a) — sie beantworten verschiedene Fragen. (c) trifft es nicht: Robuste Optimierung betrachtet nicht mehr Szenarien, sondern eine ganze Menge auf einmal, und interessiert sich darin nur für den schlechtesten Punkt.</p>
-<p><strong>3 — (c).</strong> Bei durchgehender Linearität und ohne nachgelagerte Entscheidung gilt <span class="math inline">\mathbb{E}[f(X)] = f(\mathbb{E}[X])</span> — dann ist Rechnen mit Mittelwerten korrekt. Sobald aber ein Maximum, ein Minimum, ein Betrag oder eine Nachbesserungsentscheidung auftaucht, gilt das nicht mehr: Genau das sind die beiden Fälle aus Schnellstart (asymmetrische Kosten über <code>maximum</code>) und Denkfehler 9.1 (Maximum über parallele Vorgänge). (a) ist die Fehlannahme, um die es im ganzen Kapitel geht; (b) ist zu absolut — es gibt den linearen Fall, in dem es tatsächlich zulässig ist.</p>
+<p><strong>3 — (c).</strong> Bei durchgehender Linearität und ohne nachgelagerte Entscheidung gilt <span class="math inline">\mathbb{E}[f(X)] = f(\mathbb{E}[X])</span> — dann ist Rechnen mit Mittelwerten korrekt. Sobald aber ein Maximum, ein Minimum, ein Betrag oder eine Nachbesserungsentscheidung auftaucht, gilt das nicht mehr: Genau das sind die beiden Fälle aus Schnellstart (asymmetrische Kosten über <code>maximum</code>) und <a href="#sec:unsicherheit-denkfehler">Abschnitt 12.9</a> (Maximum über parallele Vorgänge). (a) ist die Fehlannahme, um die es im ganzen Kapitel geht; (b) ist zu absolut — es gibt den linearen Fall, in dem es tatsächlich zulässig ist.</p>
 <h3 id="selbsttest-loesung-unsicherheit">Selbsttest</h3>
 <ol type="1">
 <li>Wegen der Jensenschen Ungleichung: Bei konvexen Kosten ist <span class="math inline">\mathbb{E}[f(X)] \ge f(\mathbb{E}[X])</span> — Planung mit dem Mittelwert unterschätzt die Kosten systematisch.</li>
@@ -29146,24 +30800,24 @@ F(11{,}33) = 1 - \frac{(18-11{,}33)^2}{(18-6)(18-10)} = 1 - \frac{44{,}4}{96} =
 </ol>
 <hr />
 <h2 id="sec:loesungen-dynamische-programmierung">A.13 Lösungen zu Kapitel „Dynamische Programmierung — Die Bellman-Gleichung und Order-Execution“</h2>
-<p><strong>10.1 — Bausteine.</strong> Stufe = Tag 1–5; Zustand = verbleibende Distanz (ggf. plus Erschöpfungsgrad); Aktion = heutige Tagesetappe; Wertfunktion = minimale Restanstrengung. <strong>Nicht</strong> in den Zustand gehören: bereits gelaufene Kilometer (redundant, wenn die Restdistanz bekannt ist) und das Wetter von gestern (ohne Einfluss auf die Zukunft).</p>
-<p><strong>10.2 — Optimalitätsprinzip.</strong> Weil der Wert eines Zustands nur von den <em>künftigen</em> Entscheidungen abhängt, kann man ihn ab dem Ende rekursiv berechnen. Hängen die Kosten zusätzlich von <strong>früheren</strong> Aktionen ab, ist die Markov-Eigenschaft verletzt — die Lösung: die relevante Vergangenheit <strong>in den Zustand aufnehmen</strong> (dann wächst allerdings der Zustandsraum).</p>
-<p><strong>10.3 — Rückwärtsinduktion.</strong> Mit <span class="math inline">C(n) = n^2 + 2n</span> und 5 Einheiten in 3 Perioden ergibt sich als optimaler Pfad <span class="math inline">2 \to 2 \to 1</span> (oder eine Permutation davon) mit Gesamtkosten <span class="math inline">8 + 8 + 3 = 19</span>. Alles auf einmal kostet <span class="math inline">25 + 10 = 35</span>.</p>
-<p><strong>10.4 — Rucksack als DP.</strong></p>
-<div class="sourceCode" id="cb240"><pre class="sourceCode python"><code class="sourceCode python"><span id="cb240-1"><a href="#cb240-1" aria-hidden="true" tabindex="-1"></a>V <span class="op">=</span> np.zeros((n <span class="op">+</span> <span class="dv">1</span>, kapazitaet <span class="op">+</span> <span class="dv">1</span>))</span>
-<span id="cb240-2"><a href="#cb240-2" aria-hidden="true" tabindex="-1"></a><span class="cf">for</span> i <span class="kw">in</span> <span class="bu">range</span>(<span class="dv">1</span>, n <span class="op">+</span> <span class="dv">1</span>):</span>
-<span id="cb240-3"><a href="#cb240-3" aria-hidden="true" tabindex="-1"></a>    <span class="cf">for</span> c <span class="kw">in</span> <span class="bu">range</span>(kapazitaet <span class="op">+</span> <span class="dv">1</span>):</span>
-<span id="cb240-4"><a href="#cb240-4" aria-hidden="true" tabindex="-1"></a>        V[i][c] <span class="op">=</span> V[i<span class="op">-</span><span class="dv">1</span>][c]</span>
-<span id="cb240-5"><a href="#cb240-5" aria-hidden="true" tabindex="-1"></a>        <span class="cf">if</span> gewicht[i<span class="op">-</span><span class="dv">1</span>] <span class="op">&lt;=</span> c:</span>
-<span id="cb240-6"><a href="#cb240-6" aria-hidden="true" tabindex="-1"></a>            V[i][c] <span class="op">=</span> <span class="bu">max</span>(V[i][c], V[i<span class="op">-</span><span class="dv">1</span>][c <span class="op">-</span> gewicht[i<span class="op">-</span><span class="dv">1</span>]] <span class="op">+</span> nutzen[i<span class="op">-</span><span class="dv">1</span>])</span></code></pre></div>
+<p><strong>13.1 — Bausteine.</strong> Stufe = Tag 1–5; Zustand = verbleibende Distanz (ggf. plus Erschöpfungsgrad); Aktion = heutige Tagesetappe; Wertfunktion = minimale Restanstrengung. <strong>Nicht</strong> in den Zustand gehören: bereits gelaufene Kilometer (redundant, wenn die Restdistanz bekannt ist) und das Wetter von gestern (ohne Einfluss auf die Zukunft).</p>
+<p><strong>13.2 — Optimalitätsprinzip.</strong> Weil der Wert eines Zustands nur von den <em>künftigen</em> Entscheidungen abhängt, kann man ihn ab dem Ende rekursiv berechnen. Hängen die Kosten zusätzlich von <strong>früheren</strong> Aktionen ab, ist die Markov-Eigenschaft verletzt — die Lösung: die relevante Vergangenheit <strong>in den Zustand aufnehmen</strong> (dann wächst allerdings der Zustandsraum).</p>
+<p><strong>13.3 — Rückwärtsinduktion.</strong> Mit <span class="math inline">C(n) = n^2 + 2n</span> und 5 Einheiten in 3 Perioden ergibt sich als optimaler Pfad <span class="math inline">2 \to 2 \to 1</span> (oder eine Permutation davon) mit Gesamtkosten <span class="math inline">8 + 8 + 3 = 19</span>. Alles auf einmal kostet <span class="math inline">25 + 10 = 35</span>.</p>
+<p><strong>13.4 — Rucksack als DP.</strong></p>
+<div class="sourceCode" id="cb244"><pre class="sourceCode python"><code class="sourceCode python"><span id="cb244-1"><a href="#cb244-1" aria-hidden="true" tabindex="-1"></a>V <span class="op">=</span> np.zeros((n <span class="op">+</span> <span class="dv">1</span>, kapazitaet <span class="op">+</span> <span class="dv">1</span>))</span>
+<span id="cb244-2"><a href="#cb244-2" aria-hidden="true" tabindex="-1"></a><span class="cf">for</span> i <span class="kw">in</span> <span class="bu">range</span>(<span class="dv">1</span>, n <span class="op">+</span> <span class="dv">1</span>):</span>
+<span id="cb244-3"><a href="#cb244-3" aria-hidden="true" tabindex="-1"></a>    <span class="cf">for</span> c <span class="kw">in</span> <span class="bu">range</span>(kapazitaet <span class="op">+</span> <span class="dv">1</span>):</span>
+<span id="cb244-4"><a href="#cb244-4" aria-hidden="true" tabindex="-1"></a>        V[i][c] <span class="op">=</span> V[i<span class="op">-</span><span class="dv">1</span>][c]</span>
+<span id="cb244-5"><a href="#cb244-5" aria-hidden="true" tabindex="-1"></a>        <span class="cf">if</span> gewicht[i<span class="op">-</span><span class="dv">1</span>] <span class="op">&lt;=</span> c:</span>
+<span id="cb244-6"><a href="#cb244-6" aria-hidden="true" tabindex="-1"></a>            V[i][c] <span class="op">=</span> <span class="bu">max</span>(V[i][c], V[i<span class="op">-</span><span class="dv">1</span>][c <span class="op">-</span> gewicht[i<span class="op">-</span><span class="dv">1</span>]] <span class="op">+</span> nutzen[i<span class="op">-</span><span class="dv">1</span>])</span></code></pre></div>
 <p>Ergebnis identisch zum MILP (110). Laufzeit <span class="math inline">O(n \cdot C)</span> — bei kleinen ganzzahligen Kapazitäten schneller als Branch-and-Bound, bei großen oder nicht-ganzzahligen Kapazitäten schlechter (dann ist das MILP überlegen). Man nennt das <strong>pseudopolynomiell</strong>.</p>
-<p><strong>10.5 — Risikoaversion kalibrieren.</strong> (a) Zwischen <span class="math inline">\lambda = 10^{-5}</span> (41 %) und <span class="math inline">10^{-4}</span> (78 %); genauer etwa bei <span class="math inline">\lambda \approx 3\cdot10^{-5}</span>. (b) Höheres <span class="math inline">\lambda</span> → höhere Gesamtkosten (man kauft Sicherheit mit Slippage). (c) Iterativ: <span class="math inline">\lambda</span> so wählen, dass der Anteil der Marktauswirkungskosten an den Gesamtkosten bei 20 % liegt — im Programm ausrechnen und per Bisektion einstellen.</p>
-<p><strong>10.6 — Zustandsraum erweitern.</strong> Der Zustand wird zu (Restbestand, Orderbuchtiefe); der Zustandsraum verdreifacht sich, die Rechenzeit ebenfalls. Die Strategie wird <strong>zustandsabhängig</strong>: Bei tiefem Buch wird mehr verkauft, bei dünnem gewartet. Genau diese Adaptivität ist der Mehrwert von DP gegenüber einem festen Pfad.</p>
-<h3 id="finde-den-denkfehler-10.1-der-zustand-der-zu-wenig-weiß">Finde den Denkfehler 10.1 — Der Zustand, der zu wenig weiß</h3>
+<p><strong>13.5 — Risikoaversion kalibrieren.</strong> (a) Zwischen <span class="math inline">\lambda = 10^{-5}</span> (41 %) und <span class="math inline">10^{-4}</span> (78 %); genauer etwa bei <span class="math inline">\lambda \approx 3\cdot10^{-5}</span>. (b) Höheres <span class="math inline">\lambda</span> → höhere Gesamtkosten (man kauft Sicherheit mit Slippage). (c) Iterativ: <span class="math inline">\lambda</span> so wählen, dass der Anteil der Marktauswirkungskosten an den Gesamtkosten bei 20 % liegt — im Programm ausrechnen und per Bisektion einstellen.</p>
+<p><strong>13.6 — Zustandsraum erweitern.</strong> Der Zustand wird zu (Restbestand, Orderbuchtiefe); der Zustandsraum verdreifacht sich, die Rechenzeit ebenfalls. Die Strategie wird <strong>zustandsabhängig</strong>: Bei tiefem Buch wird mehr verkauft, bei dünnem gewartet. Genau diese Adaptivität ist der Mehrwert von DP gegenüber einem festen Pfad.</p>
+<h3 id="finde-den-denkfehler-der-zustand-der-zu-wenig-weiß">Finde den Denkfehler — Der Zustand, der zu wenig weiß</h3>
 <ol type="a">
 <li><strong>Die fehlende Information.</strong> Die Zeile</li>
 </ol>
-<div class="sourceCode" id="cb241"><pre class="sourceCode python"><code class="sourceCode python"><span id="cb241-1"><a href="#cb241-1" aria-hidden="true" tabindex="-1"></a>kosten <span class="op">=</span> (RUESTKOSTEN <span class="cf">if</span> p <span class="op">&gt;</span> <span class="dv">0</span> <span class="cf">else</span> <span class="dv">0</span>) <span class="op">+</span> ...</span></code></pre></div>
+<div class="sourceCode" id="cb245"><pre class="sourceCode python"><code class="sourceCode python"><span id="cb245-1"><a href="#cb245-1" aria-hidden="true" tabindex="-1"></a>kosten <span class="op">=</span> (RUESTKOSTEN <span class="cf">if</span> p <span class="op">&gt;</span> <span class="dv">0</span> <span class="cf">else</span> <span class="dv">0</span>) <span class="op">+</span> ...</span></code></pre></div>
 <p>berechnet die Rüstkosten allein daraus, ob in <em>dieser</em> Periode produziert wird. Die tatsächliche Regel lautet aber: Rüstkosten fallen an, wenn produziert wird <strong>und in der Vorperiode nicht</strong>. Ob in der Vorperiode produziert wurde, steht nirgends im Zustand <code>(t, lager)</code> — die Funktion kann es gar nicht wissen.</p>
 <p>Das Modell nimmt deshalb an, dass <strong>jede</strong> Produktionsperiode eine Rüstung kostet. Es bestraft laufende Produktion, obwohl sie in Wirklichkeit gratis weiterläuft.</p>
 <ol start="2" type="a">
@@ -29201,11 +30855,11 @@ F(11{,}33) = 1 - \frac{(18-11{,}33)^2}{(18-6)(18-10)} = 1 - \frac{44{,}4}{96} =
 <ol start="3" type="a">
 <li><strong>Der korrigierte Zustand</strong> lautet <code>(t, lager, lief_vorher)</code> mit einem zusätzlichen Wahrheitswert:</li>
 </ol>
-<div class="sourceCode" id="cb242"><pre class="sourceCode python"><code class="sourceCode python"><span id="cb242-1"><a href="#cb242-1" aria-hidden="true" tabindex="-1"></a><span class="at">@functools.lru_cache</span>(<span class="va">None</span>)</span>
-<span id="cb242-2"><a href="#cb242-2" aria-hidden="true" tabindex="-1"></a><span class="kw">def</span> V(t, lager, lief_vorher):</span>
-<span id="cb242-3"><a href="#cb242-3" aria-hidden="true" tabindex="-1"></a>    ...</span>
-<span id="cb242-4"><a href="#cb242-4" aria-hidden="true" tabindex="-1"></a>    kosten <span class="op">=</span> (RUESTKOSTEN <span class="cf">if</span> (p <span class="op">&gt;</span> <span class="dv">0</span> <span class="kw">and</span> <span class="kw">not</span> lief_vorher) <span class="cf">else</span> <span class="dv">0</span>) <span class="op">+</span> ...</span>
-<span id="cb242-5"><a href="#cb242-5" aria-hidden="true" tabindex="-1"></a>    rest, plan <span class="op">=</span> V(t <span class="op">+</span> <span class="dv">1</span>, neu, p <span class="op">&gt;</span> <span class="dv">0</span>)</span></code></pre></div>
+<div class="sourceCode" id="cb246"><pre class="sourceCode python"><code class="sourceCode python"><span id="cb246-1"><a href="#cb246-1" aria-hidden="true" tabindex="-1"></a><span class="at">@functools.lru_cache</span>(<span class="va">None</span>)</span>
+<span id="cb246-2"><a href="#cb246-2" aria-hidden="true" tabindex="-1"></a><span class="kw">def</span> V(t, lager, lief_vorher):</span>
+<span id="cb246-3"><a href="#cb246-3" aria-hidden="true" tabindex="-1"></a>    ...</span>
+<span id="cb246-4"><a href="#cb246-4" aria-hidden="true" tabindex="-1"></a>    kosten <span class="op">=</span> (RUESTKOSTEN <span class="cf">if</span> (p <span class="op">&gt;</span> <span class="dv">0</span> <span class="kw">and</span> <span class="kw">not</span> lief_vorher) <span class="cf">else</span> <span class="dv">0</span>) <span class="op">+</span> ...</span>
+<span id="cb246-5"><a href="#cb246-5" aria-hidden="true" tabindex="-1"></a>    rest, plan <span class="op">=</span> V(t <span class="op">+</span> <span class="dv">1</span>, neu, p <span class="op">&gt;</span> <span class="dv">0</span>)</span></code></pre></div>
 <p>Damit findet die Rückwärtsinduktion <span class="math inline">(3, 1, 4, 2)</span> für 70 € — das nachgerechnete Optimum. Der Zustandsraum <strong>verdoppelt</strong> sich (je Lagerstand zwei Varianten, „lief“ und „lief nicht“). Das ist der übliche Preis: Vollständigkeit des Zustands kostet Größe, und genau hier beginnt der Fluch der Dimensionalität.</p>
 <ol start="4" type="a">
 <li><strong>Warum der richtige Betrag das Tückische ist.</strong> Man würde erwarten, dass ein falsches Modell auch einen falschen Kostenbetrag ausgibt — dann fiele es beim Nachrechnen auf. Hier nicht: Für den von ihm gewählten Plan <span class="math inline">(5,0,5,0)</span> stimmt die Rechnung zufällig, weil in diesem Plan tatsächlich jede Produktionsperiode auf eine Pause folgt. Modellannahme und Wirklichkeit fallen für <strong>genau diese eine Lösung</strong> zusammen.</li>
@@ -29218,7 +30872,7 @@ F(11{,}33) = 1 - \frac{(18-11{,}33)^2}{(18-6)(18-10)} = 1 - \frac{44{,}4}{96} =
 <h3 id="quiz-loesung-dynamische-programmierung">Micro-Quiz</h3>
 <p><strong>1 — (b).</strong> <span class="math inline">V_t</span> setzt <span class="math inline">V_{t+1}</span> voraus: Eine Entscheidung lässt sich erst bewerten, wenn feststeht, was sie für die Zukunft bedeutet. Am Ende ist dieser Wert bekannt (<span class="math inline">V_T = g</span>), deshalb beginnt die Rechnung dort. (a) verwechselt ein mathematisches Erfordernis mit einer Implementierungsfrage; (c) ist frei erfunden und hätte mit der Rechenrichtung ohnehin nichts zu tun.</p>
 <p><strong>2 — (b).</strong> Das Optimalitätsprinzip sagt, dass jedes <strong>Reststück</strong> einer optimalen Lösung selbst optimal ist. Deshalb genügt es, je Zustand einen einzigen Wert zu speichern, statt alle Wege dorthin zu unterscheiden. (a) ist die verbreitetste Fehldeutung — sie beschriebe gieriges Vorgehen, und genau das scheitert im Schnellstart dieses Kapitels (21 statt 14 Minuten). (c) ist eine Allgemeinplatz-Aussage ohne Bezug zum Prinzip.</p>
-<p><strong>3 — (b).</strong> Der Rabatt hängt von der bisher kumulierten Menge ab; ohne diese Größe im Zustand kann das Modell die Kosten der nächsten Bestellung nicht bestimmen — dasselbe Muster wie in Denkfehler 10.1. (a) übersieht genau das: Kosten, die von der Vorgeschichte abhängen, <strong>sind</strong> Zustandsinformation. (c) ist zu absolut — DP bleibt anwendbar, der Zustandsraum wird nur größer; ob sich stattdessen ein MILP lohnt, ist eine Frage der Größe, nicht der Eignung.</p>
+<p><strong>3 — (b).</strong> Der Rabatt hängt von der bisher kumulierten Menge ab; ohne diese Größe im Zustand kann das Modell die Kosten der nächsten Bestellung nicht bestimmen — dasselbe Muster wie in <a href="#sec:dynamische-programmierung-denkfehler">Abschnitt 13.7</a>. (a) übersieht genau das: Kosten, die von der Vorgeschichte abhängen, <strong>sind</strong> Zustandsinformation. (c) ist zu absolut — DP bleibt anwendbar, der Zustandsraum wird nur größer; ob sich stattdessen ein MILP lohnt, ist eine Frage der Größe, nicht der Eignung.</p>
 <h3 id="selbsttest-loesung-dynamische-programmierung">Selbsttest</h3>
 <ol type="1">
 <li>Jeder Teilabschnitt einer optimalen Strategie ist selbst optimal für den Zustand, in dem er beginnt.</li>
@@ -29229,16 +30883,16 @@ F(11{,}33) = 1 - \frac{(18-11{,}33)^2}{(18-6)(18-10)} = 1 - \frac{44{,}4}{96} =
 </ol>
 <hr />
 <h2 id="sec:loesungen-mehrziel">A.14 Lösungen zu Kapitel „Mehrere Ziele — Pareto-Fronten statt Gewichte“</h2>
-<p><strong>Dominanz prüfen.</strong> P (14 000 €, 6 000 kg) und Q (13 800 €, 6 100 kg): <strong>keiner dominiert den anderen.</strong> Q ist billiger, P ist sauberer — beide sind pareto-optimal, die Wahl ist eine Präferenzfrage.</p>
+<p><strong>14.1 — Dominanz prüfen.</strong> P (14 000 €, 6 000 kg) und Q (13 800 €, 6 100 kg): <strong>keiner dominiert den anderen.</strong> Q ist billiger, P ist sauberer — beide sind pareto-optimal, die Wahl ist eine Präferenzfrage.</p>
 <p>R (14 000 €, 6 100 kg) dagegen wird <strong>von beiden dominiert</strong>: gleich teuer wie P, aber schmutziger; schmutziger als Q <em>und</em> teurer. R kann man wegwerfen, ohne jemanden zu fragen — und genau das ist der Zweck des Dominanzbegriffs: Er trennt die Fälle, in denen der Modellierer entscheiden darf, von denen, in denen er es nicht darf.</p>
-<p><strong>Der Schattenpreis in der Praxis.</strong> Man geht die Front von unten durch, solange der Schattenpreis unter 0,90 €/kg liegt. Aus der Ausgabe: 0,58 — 0,93 — 0,40 — 0,59 — 0,77 — 0,65 — 0,77 — 1,09 — 1,32. Die Werte steigen nicht monoton, weil die Front bei ganzzahligen Modellen keine glatte Kurve ist; maßgeblich ist deshalb nicht der einzelne Schritt, sondern der <strong>Gesamtschattenpreis</strong> gegenüber dem Kostenminimum.</p>
+<p><strong>14.2 — Der Schattenpreis in der Praxis.</strong> Man geht die Front von unten durch, solange der Schattenpreis unter 0,90 €/kg liegt. Aus der Ausgabe: 0,58 — 0,93 — 0,40 — 0,59 — 0,77 — 0,65 — 0,77 — 1,09 — 1,32. Die Werte steigen nicht monoton, weil die Front bei ganzzahligen Modellen keine glatte Kurve ist; maßgeblich ist deshalb nicht der einzelne Schritt, sondern der <strong>Gesamtschattenpreis</strong> gegenüber dem Kostenminimum.</p>
 <p>Der letzte Punkt, dessen Gesamtschattenpreis unter 0,90 € liegt, ist <strong>14 189 € / 5 632 kg</strong>: 646 € Aufpreis für 843 kg Ersparnis, also 0,77 €/kg. Der nächste Punkt kostet 1,09 €/kg und liegt damit über dem internen Preis.</p>
 <p>Begründung in einem Satz: <em>„Für 646 Euro sparen wir 843 Kilogramm CO₂ — zu 77 Cent je Kilogramm, während wir intern mit 90 Cent rechnen.“</em></p>
-<p><strong>Mehr Trassen.</strong> Mit 8 statt 5 Trassen wird der Engpass schwächer. Zu erwarten ist eine <strong>kürzere</strong> Front: Der Zielkonflikt entsteht ja allein aus der Knappheit; je mehr Trassen, desto näher rücken Kostenminimum und CO₂-Minimum zusammen. Im Grenzfall genügend vieler Trassen fallen beide zusammen — die Bahn ist billiger <em>und</em> sauberer, also gibt es gar keinen Konflikt mehr und die Front schrumpft auf einen Punkt.</p>
+<p><strong>14.3 — Mehr Trassen.</strong> Mit 8 statt 5 Trassen wird der Engpass schwächer. Zu erwarten ist eine <strong>kürzere</strong> Front: Der Zielkonflikt entsteht ja allein aus der Knappheit; je mehr Trassen, desto näher rücken Kostenminimum und CO₂-Minimum zusammen. Im Grenzfall genügend vieler Trassen fallen beide zusammen — die Bahn ist billiger <em>und</em> sauberer, also gibt es gar keinen Konflikt mehr und die Front schrumpft auf einen Punkt.</p>
 <p>Der Lehrpunkt: <strong>Ein Zielkonflikt ist keine Eigenschaft der Ziele, sondern der Knappheit.</strong> Wer ihn auflösen will, sollte zuerst prüfen, ob sich die Ressource vermehren lässt, statt über Gewichte zu verhandeln.</p>
-<p><strong>Die Front der Relaxation.</strong> Ohne <code>integrality</code> ist der zulässige Bereich konvex, und die Pareto-Front liegt vollständig auf ihrer eigenen unteren konvexen Hülle. Es gibt also <strong>keinen</strong> Punkt oberhalb — jeder Punkt der Front ist durch ein passendes Gewicht erreichbar.</p>
+<p><strong>14.4 — Die Front der Relaxation.</strong> Ohne <code>integrality</code> ist der zulässige Bereich konvex, und die Pareto-Front liegt vollständig auf ihrer eigenen unteren konvexen Hülle. Es gibt also <strong>keinen</strong> Punkt oberhalb — jeder Punkt der Front ist durch ein passendes Gewicht erreichbar.</p>
 <p>Genau das ist der Grund, warum das Problem in Lehrbüchern zur linearen Programmierung nicht vorkommt und in der betrieblichen Praxis ständig: Sobald „welcher Träger“, „welches Lager“ oder „welche Schicht“ entschieden wird, zerfällt der Bereich in einzelne Punkte, und zwischen ihnen entstehen die Einbuchtungen, in denen die nicht gestützten Lösungen liegen.</p>
-<p><strong>Drei Ziele.</strong> Die Front wird zu einer Fläche im dreidimensionalen Zielraum. Das ε-Verfahren braucht dann ein <strong>Gitter</strong> über zwei Schranken statt einer Folge über eine — der Aufwand wächst von <span class="math inline">O(k)</span> auf <span class="math inline">O(k^2)</span>, bei <span class="math inline">m</span> Zielen auf <span class="math inline">O(k^{m-1})</span>.</p>
+<p><strong>14.5 — Drei Ziele.</strong> Die Front wird zu einer Fläche im dreidimensionalen Zielraum. Das ε-Verfahren braucht dann ein <strong>Gitter</strong> über zwei Schranken statt einer Folge über eine — der Aufwand wächst von <span class="math inline">O(k)</span> auf <span class="math inline">O(k^2)</span>, bei <span class="math inline">m</span> Zielen auf <span class="math inline">O(k^{m-1})</span>.</p>
 <p>Zwei praktische Folgerungen: Erstens ist bei drei und mehr Zielen die vollständige Front meist nicht mehr bezahlbar; man arbeitet dann mit einer Stichprobe oder mit Metaheuristiken, die eine Front approximieren (NSGA-II, in <code>pymoo</code> enthalten). Zweitens ist eine Front mit hunderten Punkten für die Entscheidung ohnehin unbrauchbar — ab drei Zielen ist die bessere Frage meist, ob sich zwei davon zusammenfassen lassen.</p>
 <h3 id="denkfehler-loesung-mehrziel">Finde den Denkfehler — „Wir haben die Gewichte sauber kalibriert“</h3>
 <p><strong>Der Lösungsraum wurde nicht vollständig abgetastet — und zwar aus prinzipiellen Gründen.</strong></p>
@@ -29262,15 +30916,15 @@ F(11{,}33) = 1 - \frac{(18-11{,}33)^2}{(18-6)(18-10)} = 1 - \frac{44{,}4}{96} =
 </ol>
 <hr />
 <h2 id="sec:loesungen-prognose">A.15 Lösungen zu Kapitel „Predict-then-Optimize“</h2>
-<p><strong>Andere Preise.</strong> Der Überhang kostet nur noch 1,50 €, die Fehlmenge weiterhin 6 €. Das kritische Verhältnis steigt von <span class="math inline">6/9 = 0{,}667</span> auf <span class="math inline">6/7{,}5 = 0{,}80</span>. Die Bestellmenge verschiebt sich also <strong>nach oben</strong> — man bestellt jetzt das 80-%-Quantil statt des 66,7-%-Quantils.</p>
+<p><strong>15.1 — Andere Preise.</strong> Der Überhang kostet nur noch 1,50 €, die Fehlmenge weiterhin 6 €. Das kritische Verhältnis steigt von <span class="math inline">6/9 = 0{,}667</span> auf <span class="math inline">6/7{,}5 = 0{,}80</span>. Die Bestellmenge verschiebt sich also <strong>nach oben</strong> — man bestellt jetzt das 80-%-Quantil statt des 66,7-%-Quantils.</p>
 <p>Das ist die richtige Richtung und leicht zu merken: Je billiger der Überhang, desto großzügiger darf man ansetzen. Im Grenzfall kostenloser Entsorgung (<span class="math inline">c_+ \to 0</span>) geht das kritische Verhältnis gegen 1 — man bestellt so viel, dass praktisch nie etwas fehlt.</p>
-<p><strong>Wann ist der Mittelwert richtig?</strong> Nur wenn <span class="math inline">c_- = c_+</span> <strong>und</strong> die Nachfrageverteilung symmetrisch ist. Dann liegt das kritische Verhältnis bei 0,5, das 50-%-Quantil ist der Median, und bei Symmetrie fällt der Median mit dem Mittelwert zusammen.</p>
+<p><strong>15.2 — Wann ist der Mittelwert richtig?</strong> Nur wenn <span class="math inline">c_- = c_+</span> <strong>und</strong> die Nachfrageverteilung symmetrisch ist. Dann liegt das kritische Verhältnis bei 0,5, das 50-%-Quantil ist der Median, und bei Symmetrie fällt der Median mit dem Mittelwert zusammen.</p>
 <p>Beide Bedingungen sind unrealistisch. Fehlmenge und Überhang kosten fast nie dasselbe — bei Frischware ist der Überhang teurer, bei Ersatzteilen die Fehlmenge um Größenordnungen. Und Nachfrageverteilungen sind meist rechtsschief. Der Mittelwert ist damit die Ausnahme, nicht die Regel — er wird nur benutzt, weil Regressionsmodelle ihn standardmäßig liefern.</p>
-<p><strong>Die Kennzahl der Prognoseabteilung.</strong> Die Rangfolge bleibt: Die Punktprognose gewinnt auch beim MAPE, weil beide Maße den <em>Erwartungswert</em> belohnen — der MAPE etwas anders gewichtet, aber ebenfalls symmetrisch in dem Sinne, dass er nicht weiß, dass Unterschätzung teurer ist als Überschätzung.</p>
+<p><strong>15.3 — Die Kennzahl der Prognoseabteilung.</strong> Die Rangfolge bleibt: Die Punktprognose gewinnt auch beim MAPE, weil beide Maße den <em>Erwartungswert</em> belohnen — der MAPE etwas anders gewichtet, aber ebenfalls symmetrisch in dem Sinne, dass er nicht weiß, dass Unterschätzung teurer ist als Überschätzung.</p>
 <p>Das ist kein Zufall, sondern der Kern des Kapitels: <strong>Jedes rein statistische Fehlermaß ignoriert die Kostenasymmetrie.</strong> Man kann das Problem nicht lösen, indem man das Fehlermaß wechselt; man muss die Kosten selbst messen. (Die einzige Ausnahme ist der <em>Pinball Loss</em> — genau das Maß, das die Quantilregression minimiert, und das ist eben kein allgemeines Prognosemaß, sondern eines für ein bestimmtes Quantil.)</p>
-<p><strong>Zwei Quantile.</strong> Das Band ist an <strong>Aktionstagen</strong> deutlich breiter — dort ist die Streuung im Modell fast viermal so groß. Genau das ist die Information, die eine Punktprognose plus fester Zuschlag wegwirft.</p>
+<p><strong>15.4 — Zwei Quantile.</strong> Das Band ist an <strong>Aktionstagen</strong> deutlich breiter — dort ist die Streuung im Modell fast viermal so groß. Genau das ist die Information, die eine Punktprognose plus fester Zuschlag wegwirft.</p>
 <p>Ein praktischer Nebeneffekt: Ein solches Band ist die verständlichste Form, Unsicherheit an die Disposition zu berichten. „Zwischen 130 und 210” sagt einem Menschen mehr als „170 ± Sicherheitszuschlag”.</p>
-<p><strong>Der Wert der Merkmale.</strong> Zu erwarten ist, dass die <strong>Kosten stärker steigen als der MSE</strong>. Der Grund: Das Merkmal „Aktion” trägt zwei verschiedene Informationen — es verschiebt den Erwartungswert (um 45 Stück) <em>und</em> die Streuung (von 8 auf 30). Der MSE bemerkt nur den ersten Teil; die Entscheidungskosten spüren beide.</p>
+<p><strong>15.5 — Der Wert der Merkmale.</strong> Zu erwarten ist, dass die <strong>Kosten stärker steigen als der MSE</strong>. Der Grund: Das Merkmal „Aktion” trägt zwei verschiedene Informationen — es verschiebt den Erwartungswert (um 45 Stück) <em>und</em> die Streuung (von 8 auf 30). Der MSE bemerkt nur den ersten Teil; die Entscheidungskosten spüren beide.</p>
 <p>Der Lehrsatz dahinter: <strong>Der Wert eines Merkmals hängt davon ab, wofür man es benutzt.</strong> Eine Merkmalsauswahl, die nach MSE-Beitrag sortiert, wirft möglicherweise genau die Merkmale weg, die für die Entscheidung am wichtigsten sind — nämlich die, die etwas über die Unsicherheit sagen.</p>
 <h3 id="denkfehler-loesung-prognose">Finde den Denkfehler — „Wir haben die Prognose um 18 % verbessert“</h3>
 <p><strong>Der Sicherheitszuschlag stammt aus den Residuen des alten Modells.</strong></p>
@@ -29298,17 +30952,17 @@ F(11{,}33) = 1 - \frac{(18-11{,}33)^2}{(18-6)(18-10)} = 1 - \frac{44{,}4}{96} =
 </ol>
 <hr />
 <h2 id="sec:loesungen-bruecke">A.16 Lösungen zu Kapitel „Die Strukturbrücke — dieselbe Mathematik, zwei Welten“</h2>
-<p><strong>Die dritte Ressource.</strong> „Liquidität” — wie schnell sich eine Position ohne Kursabschlag verkaufen lässt — entspricht in der Werkstatt der <strong>Umrüstbarkeit</strong> oder der <strong>Vorlaufzeit</strong>: Wie schnell lässt sich die Fertigung von diesem Produkt wieder wegdrehen, wenn der Auftrag storniert wird? In beiden Fällen ist es eine knappe Größe, die nichts mit dem Ertrag zu tun hat und trotzdem die Auswahl einschränkt.</p>
+<p><strong>16.1 — Die dritte Ressource.</strong> „Liquidität” — wie schnell sich eine Position ohne Kursabschlag verkaufen lässt — entspricht in der Werkstatt der <strong>Umrüstbarkeit</strong> oder der <strong>Vorlaufzeit</strong>: Wie schnell lässt sich die Fertigung von diesem Produkt wieder wegdrehen, wenn der Auftrag storniert wird? In beiden Fällen ist es eine knappe Größe, die nichts mit dem Ertrag zu tun hat und trotzdem die Auswahl einschränkt.</p>
 <p>Im Modell ist es schlicht eine weitere Zeile in <code>kapazitaeten</code> und ein weiterer Eintrag in jedem <code>verbrauch</code>. Genau das ist der Punkt des Kapitels: Eine neue Ressource kostet keinen Modellcode.</p>
-<p><strong>Den Schattenpreis lesen.</strong> Bis zu <strong>602,60 €</strong> für 10 Einheiten (10 × 60,26 €) lohnt sich der Kauf — darüber nicht.</p>
+<p><strong>16.2 — Den Schattenpreis lesen.</strong> Bis zu <strong>602,60 €</strong> für 10 Einheiten (10 × 60,26 €) lohnt sich der Kauf — darüber nicht.</p>
 <p>Die Einschränkung aus <a href="#sec:lp-entartung">Abschnitt 5.9</a>: Der Schattenpreis gilt nur <strong>lokal</strong>, solange sich die optimale Basis nicht ändert. Nach einer gewissen Erhöhung wird eine andere Nebenbedingung bindend (hier voraussichtlich das Kapital), und ab dort ist die zusätzliche Einheit weniger wert. Bei 10 Einheiten auf 90 ist das eine Erhöhung um 11 % — schon groß genug, dass man es nachrechnen sollte, statt zu extrapolieren.</p>
 <p>Zweite Einschränkung: Bei <strong>Entartung</strong> ist der Schattenpreis nicht eindeutig. Verschiedene Solver können dann verschiedene, gleichermaßen gültige Werte liefern — auch das steht in <a href="#sec:lp-entartung">Abschnitt 5.9</a>.</p>
-<p><strong>Die Brücke rückwärts.</strong> Shrinkage hilft, wenn man eine <strong>Kovarianzmatrix</strong> aus wenigen Beobachtungen schätzt. Bei Lieferzeiten tritt genau dasselbe Problem auf, sobald man die <em>Korrelationen zwischen</em> Lieferanten braucht — und die braucht man, sobald Lieferanten gemeinsame Ursachen haben: derselbe Hafen, dasselbe Vorprodukt, dieselbe Region.</p>
+<p><strong>16.3 — Die Brücke rückwärts.</strong> Shrinkage hilft, wenn man eine <strong>Kovarianzmatrix</strong> aus wenigen Beobachtungen schätzt. Bei Lieferzeiten tritt genau dasselbe Problem auf, sobald man die <em>Korrelationen zwischen</em> Lieferanten braucht — und die braucht man, sobald Lieferanten gemeinsame Ursachen haben: derselbe Hafen, dasselbe Vorprodukt, dieselbe Region.</p>
 <p>Bei 40 Lieferanten hat die Kovarianzmatrix 820 zu schätzende Einträge. Wer dafür 36 Monatswerte hat, schätzt 820 Zahlen aus 36 Beobachtungen — dasselbe Missverhältnis wie bei Aktienrenditen, mit denselben Folgen (<code>Kovarianz_Falle.py</code>).</p>
 <p>Benötigt würden: Lieferzeit-Zeitreihen je Lieferant über denselben Zeitraum, gleich getaktet. Genau daran scheitert es in der Praxis meist — die Daten liegen in Bestellvorgängen, nicht in einer Matrix.</p>
-<p><strong>CVaR mit Ganzzahligkeit.</strong> Man ergänzt Binärvariablen <span class="math inline">y_j</span> je Lieferant und die Kopplung <span class="math inline">w_j \le y_j</span> sowie <span class="math inline">\sum_j y_j \le 3</span>. Da CVXPY gemischt-ganzzahlige Probleme unterstützt, genügt <code>cp.Variable(n, boolean=True)</code>.</p>
+<p><strong>16.4 — CVaR mit Ganzzahligkeit.</strong> Man ergänzt Binärvariablen <span class="math inline">y_j</span> je Lieferant und die Kopplung <span class="math inline">w_j \le y_j</span> sowie <span class="math inline">\sum_j y_j \le 3</span>. Da CVXPY gemischt-ganzzahlige Probleme unterstützt, genügt <code>cp.Variable(n, boolean=True)</code>.</p>
 <p>Zu erwarten ist ein <strong>höherer</strong> CVaR: Der zulässige Bereich wird kleiner, und die Feinabstimmung über sechs Lieferanten fällt weg. Der Aufschlag ist der Preis der Vertragswirklichkeit — und genau die Zahl, die man dem Einkauf vorlegt, wenn dort jemand sagt, drei Lieferanten seien genug.</p>
-<p><strong>Die eigene Brücke.</strong> Freie Antwort. Eine gute Bearbeitung nennt das Modell, die Entsprechung und <strong>die Zeile der Grenztabelle, die im Weg steht</strong> — meist ist es die dritte (Teilbarkeit) oder die erste (gemessen gegen geschätzt). Wenn keine im Weg steht, ist die Übertragung wahrscheinlich zu oberflächlich geprüft.</p>
+<p><strong>16.5 — Die eigene Brücke.</strong> Freie Antwort. Eine gute Bearbeitung nennt das Modell, die Entsprechung und <strong>die Zeile der Grenztabelle, die im Weg steht</strong> — meist ist es die dritte (Teilbarkeit) oder die erste (gemessen gegen geschätzt). Wenn keine im Weg steht, ist die Übertragung wahrscheinlich zu oberflächlich geprüft.</p>
 <h3 id="denkfehler-loesung-bruecke">Finde den Denkfehler — „Das ist doch dasselbe Problem“</h3>
 <p><strong>Fehler 1: Varianz ist hier das falsche Risikomaß — genau der Fall, für den es CVaR gibt.</strong></p>
 <p>Markowitz minimiert die <strong>Varianz</strong>, und die bestraft Abweichungen nach <em>beiden</em> Seiten gleich. Ein Lieferant, der manchmal zwei Tage zu früh liefert, erhöht die Varianz genauso wie einer, der zwei Tage zu spät liefert — obwohl das eine harmlos und das andere teuer ist.</p>
@@ -29332,20 +30986,20 @@ F(11{,}33) = 1 - \frac{(18-11{,}33)^2}{(18-6)(18-10)} = 1 - \frac{44{,}4}{96} =
 </ol>
 <hr />
 <h2 id="sec:loesungen-supplychain">A.17 Lösungen zu Kapitel „Supply-Chain und Energieeinsatz unter Unsicherheit“</h2>
-<p><strong>Der Umschlagpunkt.</strong> Bei 60 MW statt 120 MW halbiert sich die Grenzkostendifferenz je Stunde (83 €/MWh × 60 MW = 4 980 €/h). Der Umschlagpunkt verdoppelt sich auf <strong>7,7 Stunden</strong>.</p>
+<p><strong>17.1 — Der Umschlagpunkt.</strong> Bei 60 MW statt 120 MW halbiert sich die Grenzkostendifferenz je Stunde (83 €/MWh × 60 MW = 4 980 €/h). Der Umschlagpunkt verdoppelt sich auf <strong>7,7 Stunden</strong>.</p>
 <p>Das ist plausibel: Je kleiner die abzudeckende Leistung, desto länger dauert es, bis der Grenzkostenvorteil des großen Blocks seine Anfahrkosten einspielt. Ein Kernblock lohnt sich für eine kleine Restlast noch weniger als für eine große — was erklärt, warum Grundlastblöcke gerade dann unwirtschaftlich werden, wenn viel Wind einspeist und nur eine kleine Restlast bleibt.</p>
-<p><strong>Die fehlende Nebenbedingung.</strong> Analog zum Anfahren braucht man eine Abfahr-Indikatorvariable <span class="math inline">b_{k,t} \ge u_{k,t-1} - u_{k,t}</span> und dann:</p>
+<p><strong>17.2 — Die fehlende Nebenbedingung.</strong> Analog zum Anfahren braucht man eine Abfahr-Indikatorvariable <span class="math inline">b_{k,t} \ge u_{k,t-1} - u_{k,t}</span> und dann:</p>
 <p><span class="math display">
 u_{k,\tau} \le 1 - b_{k,t} \qquad \text{für } \tau = t, \dots, t + M_k - 1
 </span></p>
 <p>In Worten: Wer abfährt, bleibt <span class="math inline">M_k</span> Stunden aus.</p>
 <p>Der reale Sachverhalt: Ein abgeschalteter Dampfblock kühlt aus und darf aus werkstofftechnischen Gründen nicht sofort wieder hochgefahren werden — die Temperaturwechsel würden das Material schädigen. Bei Gasturbinen ist die Mindeststillstandszeit kurz oder null, bei Kernblöcken beträgt sie viele Stunden.</p>
-<p><strong>Wie viele Szenarien?</strong> Zu erwarten ist, dass der Commitment-Plan ab einer gewissen Szenarienzahl stabil bleibt — oft schon bei 20 bis 40. Der Grund: Die erste Stufe ist binär und <strong>grob</strong>; sie kann nur ganze Blockstunden verschieben. Feine Unterschiede in der Szenarienmenge ändern daran nichts mehr.</p>
+<p><strong>17.3 — Wie viele Szenarien?</strong> Zu erwarten ist, dass der Commitment-Plan ab einer gewissen Szenarienzahl stabil bleibt — oft schon bei 20 bis 40. Der Grund: Die erste Stufe ist binär und <strong>grob</strong>; sie kann nur ganze Blockstunden verschieben. Feine Unterschiede in der Szenarienmenge ändern daran nichts mehr.</p>
 <p>Der Zusammenhang mit <a href="#sec:prognose-messfalle">Abschnitt 15.6</a> ist der interessante Teil: Dort ging es um die Zahl der <strong>Beobachtungen</strong> bei einer Bewertung, hier um die Zahl der <strong>Szenarien</strong> in einem Modell. Beide Male lautet die Frage nicht „wie viele sind genug?“, sondern „ab wann ändert sich die Antwort nicht mehr?” — und beide Male beantwortet man sie, indem man es ausprobiert, statt eine Faustregel zu übernehmen.</p>
-<p><strong>Der Wert eines Speichers.</strong> Der Speicher braucht Variablen für Ladung, Entladung und Füllstand je Szenario und Stunde, mit der Bilanz <span class="math inline">F_{t} = F_{t-1} + \eta\, L_t - E_t/\eta</span> und Grenzen für Leistung und Kapazität. Er gehört in die <strong>zweite</strong> Stufe: Wann geladen wird, darf sich am Tag selbst entscheiden.</p>
+<p><strong>17.4 — Der Wert eines Speichers.</strong> Der Speicher braucht Variablen für Ladung, Entladung und Füllstand je Szenario und Stunde, mit der Bilanz <span class="math inline">F_{t} = F_{t-1} + \eta\, L_t - E_t/\eta</span> und Grenzen für Leistung und Kapazität. Er gehört in die <strong>zweite</strong> Stufe: Wann geladen wird, darf sich am Tag selbst entscheiden.</p>
 <p>Zu erwarten ist ein deutlicher Rückgang der erwarteten Kosten, und zwar aus zwei Quellen: Er verschiebt Energie aus billigen in teure Stunden <em>und</em> er ersetzt Vorhaltung — ein Speicher ist in Sekunden verfügbar, ein Kernblock in acht Stunden. Der zweite Effekt ist der größere und wird bei einer Betrachtung ohne Szenarien komplett übersehen.</p>
 <p>Der Wert je MWh Kapazität ergibt sich als Kostenersparnis geteilt durch 400 MWh. Er ist mit den Investitionskosten vergleichbar — dieselbe Rechnung wie der Schattenpreis in <a href="#kap-lp">Kapitel 5</a>, nur über einen ganzen Tag.</p>
-<p><strong>Wenn es größer wird.</strong> Mit 20 Blöcken und 168 Stunden hat die erste Stufe 3 360 Binärvariablen statt 120, und die Szenarienkopplung vervielfacht die kontinuierlichen Variablen. Zu erwarten ist, dass der MIP-Gap nach dem Zeitlimit nicht mehr auf null geht.</p>
+<p><strong>17.5 — Wenn es größer wird.</strong> Mit 20 Blöcken und 168 Stunden hat die erste Stufe 3 360 Binärvariablen statt 120, und die Szenarienkopplung vervielfacht die kontinuierlichen Variablen. Zu erwarten ist, dass der MIP-Gap nach dem Zeitlimit nicht mehr auf null geht.</p>
 <p>Zwei Wege aus <a href="#kap-metaheuristiken">Kapitel 9</a>: <strong>Erstens</strong> — und in der Praxis meist ausreichend — den Gap akzeptieren; 1 bis 2 % sind bei Unit Commitment üblich und betriebswirtschaftlich belanglos. <strong>Zweitens</strong> LNS: Das Commitment eines Tages herausbrechen und exakt neu optimieren, während der Rest der Woche festbleibt. Das ist genau die Struktur aus <code>Large_Neighborhood_Search.py</code> — ein zusammenhängendes Fenster zerstören und mit dem exakten Solver reparieren.</p>
 <p>Was <strong>nicht</strong> funktioniert: eine reine Metaheuristik ohne Solver. Die Fahrweise ist bei gegebenem Commitment ein LP mit tausenden Variablen; die will man nicht heuristisch lösen.</p>
 <h3 id="denkfehler-loesung-supplychain">Finde den Denkfehler — „Wir rechnen mit dem P50-Szenario“</h3>
@@ -29371,13 +31025,13 @@ u_{k,\tau} \le 1 - b_{k,t} \qquad \text{für } \tau = t, \dots, t + M_k - 1
 </ol>
 <hr />
 <h2 id="sec:loesungen-finanzdaten">A.18 Lösungen zu Kapitel „Finanzdaten-Modellierung — Renditen, Kovarianz und Shrinkage“</h2>
-<p><strong>11.1 — Renditeart.</strong> (a) diskret. (b) logarithmisch. (c) logarithmisch (bzw. diskret kumuliert über Produkt). (d) logarithmisch (statistische Eigenschaften).</p>
-<p><strong>11.2 — Mittelwertfalle.</strong> (a) Arithmetisches Mittel: <span class="math inline">(60-40+60-40)/4 = +10\,\%</span>. (b) <span class="math inline">10\,000 \cdot 1{,}6 \cdot 0{,}6 \cdot 1{,}6 \cdot 0{,}6 = 10\,000 \cdot 0{,}9216 = \mathbf{9216\ €}</span> — ein <strong>Verlust</strong>. (c) Geometrisches Mittel: <span class="math inline">0{,}9216^{1/4} - 1 = -2{,}0\,\%</span> p. a. Der Unterschied zwischen <span class="math inline">+10\,\%</span> und <span class="math inline">-2\,\%</span> ist der Grund, warum Fondswerbung gern arithmetische Mittel zeigt.</p>
-<p><strong>11.3 — Konditionszahl.</strong> Erwartetes Muster: Bei <span class="math inline">T = 40 &lt; N = 30</span>… (hier <span class="math inline">T &gt; N</span>, aber knapp): sehr große Konditionszahl, kleinster Eigenwert nahe null. Bei <span class="math inline">T = 100</span>: deutlich besser. Bei <span class="math inline">T = 1000</span>: stabil. Faustregel <span class="math inline">T \ge 5N</span> bis <span class="math inline">10N</span>.</p>
-<p><strong>11.4 — Spaltenreihenfolge.</strong> <code>raw["Close"].columns</code> ist alphabetisch; <code>raw["Close"][tickers]</code> stellt die eigene Reihenfolge her. Existiert ein Ticker nicht, wirft <code>[tickers]</code> einen <code>KeyError</code> — <strong>das ist erwünscht</strong>: lieber ein lauter Fehler als eine stille Verschiebung.</p>
-<p><strong>11.5 — Beide Ziele vergleichen.</strong> Erwartetes Ergebnis: Das Konstant-Korrelations-Ziel schneidet bei Aktien meist etwas besser ab, weil es die unterschiedlichen Einzelvolatilitäten erhält. Der Unterschied ist aber kleiner als der Unterschied zwischen „mit“ und „ohne“ Shrinkage — die Wahl des Ziels ist zweitrangig gegenüber der Entscheidung, überhaupt zu schrumpfen.</p>
-<p><strong>11.6 — Error-Maximizer messen.</strong> (a)/(b) Erwartetes Ergebnis: Die Gleichgewichtung schlägt die Stichproben-Optimierung bis etwa <span class="math inline">T/N \approx 5</span>–10; Ledoit-Wolf schlägt sie schon früher. (c) <strong>Praktische Folgerung:</strong> Bei knapper Datenlage ist 1/N ein ernstzunehmender Kandidat, und jede Optimierung muss sich daran messen lassen.</p>
-<h3 id="finde-den-denkfehler-11.1-das-risikofreie-portfolio">Finde den Denkfehler 11.1 — Das risikofreie Portfolio</h3>
+<p><strong>18.1 — Renditeart.</strong> (a) diskret. (b) logarithmisch. (c) logarithmisch (bzw. diskret kumuliert über Produkt). (d) logarithmisch (statistische Eigenschaften).</p>
+<p><strong>18.2 — Mittelwertfalle.</strong> (a) Arithmetisches Mittel: <span class="math inline">(60-40+60-40)/4 = +10\,\%</span>. (b) <span class="math inline">10\,000 \cdot 1{,}6 \cdot 0{,}6 \cdot 1{,}6 \cdot 0{,}6 = 10\,000 \cdot 0{,}9216 = \mathbf{9216\ €}</span> — ein <strong>Verlust</strong>. (c) Geometrisches Mittel: <span class="math inline">0{,}9216^{1/4} - 1 = -2{,}0\,\%</span> p. a. Der Unterschied zwischen <span class="math inline">+10\,\%</span> und <span class="math inline">-2\,\%</span> ist der Grund, warum Fondswerbung gern arithmetische Mittel zeigt.</p>
+<p><strong>18.3 — Konditionszahl.</strong> Erwartetes Muster: Bei <span class="math inline">T = 40 &lt; N = 30</span>… (hier <span class="math inline">T &gt; N</span>, aber knapp): sehr große Konditionszahl, kleinster Eigenwert nahe null. Bei <span class="math inline">T = 100</span>: deutlich besser. Bei <span class="math inline">T = 1000</span>: stabil. Faustregel <span class="math inline">T \ge 5N</span> bis <span class="math inline">10N</span>.</p>
+<p><strong>18.4 — Spaltenreihenfolge.</strong> <code>raw["Close"].columns</code> ist alphabetisch; <code>raw["Close"][tickers]</code> stellt die eigene Reihenfolge her. Existiert ein Ticker nicht, wirft <code>[tickers]</code> einen <code>KeyError</code> — <strong>das ist erwünscht</strong>: lieber ein lauter Fehler als eine stille Verschiebung.</p>
+<p><strong>18.5 — Beide Ziele vergleichen.</strong> Erwartetes Ergebnis: Das Konstant-Korrelations-Ziel schneidet bei Aktien meist etwas besser ab, weil es die unterschiedlichen Einzelvolatilitäten erhält. Der Unterschied ist aber kleiner als der Unterschied zwischen „mit“ und „ohne“ Shrinkage — die Wahl des Ziels ist zweitrangig gegenüber der Entscheidung, überhaupt zu schrumpfen.</p>
+<p><strong>18.6 — Error-Maximizer messen.</strong> (a)/(b) Erwartetes Ergebnis: Die Gleichgewichtung schlägt die Stichproben-Optimierung bis etwa <span class="math inline">T/N \approx 5</span>–10; Ledoit-Wolf schlägt sie schon früher. (c) <strong>Praktische Folgerung:</strong> Bei knapper Datenlage ist 1/N ein ernstzunehmender Kandidat, und jede Optimierung muss sich daran messen lassen.</p>
+<h3 id="finde-den-denkfehler-das-risikofreie-portfolio">Finde den Denkfehler — Das risikofreie Portfolio</h3>
 <ol type="a">
 <li><strong>Der Rang.</strong> Eine aus <span class="math inline">T</span> Beobachtungen geschätzte Kovarianzmatrix hat höchstens den Rang <span class="math inline">T-1</span> — hier also <strong>19</strong> statt der nötigen 30. Geometrisch heißt das: Die 20 beobachteten Renditevektoren spannen nur einen 19-dimensionalen Unterraum des 30-dimensionalen Anlageraums auf. Es bleiben <strong>11 Richtungen</strong> übrig, über die die Daten schlicht <strong>nichts</strong> aussagen.</li>
 </ol>
@@ -29419,7 +31073,7 @@ u_{k,\tau} \le 1 - b_{k,t} \qquad \text{für } \tau = t, \dots, t + M_k - 1
 </ol>
 <hr />
 <h2 id="sec:loesungen-markowitz">A.19 Lösungen zu Kapitel „Die moderne Portfoliotheorie nach Markowitz“</h2>
-<p><strong>12.1 — Diversifikationseffekt.</strong></p>
+<p><strong>19.1 — Diversifikationseffekt.</strong></p>
 <table>
 <thead>
 <tr class="header">
@@ -29458,13 +31112,13 @@ u_{k,\tau} \le 1 - b_{k,t} \qquad \text{für } \tau = t, \dots, t + M_k - 1
 </table>
 <p>Rechenweg für <span class="math inline">(0{,}5;\ 0{,}5)</span>: <span class="math inline">\sigma_p^2 = 0{,}25\cdot0{,}0625 + 0{,}25\cdot0{,}0144 + 2\cdot0{,}25\cdot(-0{,}2)\cdot0{,}25\cdot0{,}12 = 0{,}015625 + 0{,}0036 - 0{,}003 = 0{,}016225</span>, also <span class="math inline">\sigma_p = 12{,}74\,\%</span>.</p>
 <p>Beste Sharpe Ratio unter den vier Kandidaten: <span class="math inline">(0{,}3;\ 0{,}7)</span>. Das exakte Optimum liegt bei <span class="math inline">w_1 = 0{,}318</span>. <strong>Bemerkenswert:</strong> Die Mischung <span class="math inline">(0{,}3;\ 0{,}7)</span> hat mit 10,08 % eine <strong>geringere</strong> Volatilität als <em>beide</em> Einzeltitel (25 % und 12 %) — genau der Diversifikationseffekt, den die negative Korrelation ermöglicht.</p>
-<p><strong>12.2 — Lambda deuten.</strong> Von <span class="math inline">\lambda=0</span> (GMV, linker unterer Punkt der Kurve) wandert die Lösung entlang der Effizienzgrenze nach rechts oben, bis sie bei <span class="math inline">\lambda\to\infty</span> im Titel mit der höchsten Rendite endet (bzw. an der Positionsobergrenze).</p>
-<p><strong>12.3 — Korn-Transformation.</strong> <span class="math inline">\text{SR}(c\mathbf{w}) = \frac{c\mathbf{w}^\top\boldsymbol{\mu}-r_f}{\sqrt{c^2\mathbf{w}^\top\boldsymbol{\Sigma}\mathbf{w}}}</span> — bei einem Portfolio mit <span class="math inline">\sum w_i = 1</span> und Überrenditen geschrieben als <span class="math inline">\mathbf{w}^\top(\boldsymbol{\mu}-r_f\mathbf{1})</span> kürzt sich <span class="math inline">c</span> heraus. Mit der Bedingung <span class="math inline">\sum w_i = 1</span> ist die Skala jedoch <strong>fixiert</strong>, man kann also nicht frei skalieren. Die Transformation ersetzt diese Bedingung durch <span class="math inline">\sum y_i = \kappa</span> mit freiem <span class="math inline">\kappa</span> und normiert stattdessen die Überrendite auf 1 — dadurch wird die Skala wieder frei und das Problem konvex.</p>
-<p><strong>12.4 — Restriktionen kosten.</strong> Erwartetes Muster: Sharpe Ratio sinkt monoton mit strengerer Grenze. Unlösbar wird es bei <span class="math inline">w_{\max} &lt; 1/n</span> — dann kann die Summe der Gewichte 1 nicht mehr erreicht werden.</p>
-<p><strong>12.5 — Den Sektorfehler nachstellen.</strong> (a) AAPL, AMZN, CVX, GS statt AAPL, MSFT, NVDA, AMZN. (b) Die Gewichte unterscheiden sich deutlich, weil die eigentlich zu begrenzenden Tech-Titel frei laufen. (c) <strong>Nein</strong> — die Kennzahlen sehen völlig plausibel aus. Genau das macht den Fehler so gefährlich.</p>
-<p><strong>12.6 — Kardinalität.</strong> Erwartung: Die Sharpe Ratio sinkt leicht, die Rechenzeit steigt deutlich (MIQP statt QP). Bei <span class="math inline">K \ge 5</span> und <span class="math inline">w_{\max} = 0{,}20</span> ist die Restriktion praktisch nicht mehr bindend.</p>
-<p><strong>12.7 — Out-of-Sample.</strong> Typisches Ergebnis: Max-Sharpe schneidet in der zweiten Hälfte <strong>schlechter</strong> ab als in der ersten — es hat Schätzrauschen mitoptimiert. GMV ist stabiler (keine Renditeprognose nötig), 1/N oft überraschend gut. Mit Ledoit-Wolf verbessern sich GMV und Max-Sharpe spürbar. <strong>Praxisfolgerung:</strong> Renditeprognosen sind viel unzuverlässiger als Risikoschätzungen — Modelle, die ohne sie auskommen, sind robuster.</p>
-<h3 id="finde-den-denkfehler-12.1-zwölf-gleiche-anlagen-ein-sehr-ungleiches-portfolio">Finde den Denkfehler 12.1 — Zwölf gleiche Anlagen, ein sehr ungleiches Portfolio</h3>
+<p><strong>19.2 — Lambda deuten.</strong> Von <span class="math inline">\lambda=0</span> (GMV, linker unterer Punkt der Kurve) wandert die Lösung entlang der Effizienzgrenze nach rechts oben, bis sie bei <span class="math inline">\lambda\to\infty</span> im Titel mit der höchsten Rendite endet (bzw. an der Positionsobergrenze).</p>
+<p><strong>19.3 — Korn-Transformation.</strong> <span class="math inline">\text{SR}(c\mathbf{w}) = \frac{c\mathbf{w}^\top\boldsymbol{\mu}-r_f}{\sqrt{c^2\mathbf{w}^\top\boldsymbol{\Sigma}\mathbf{w}}}</span> — bei einem Portfolio mit <span class="math inline">\sum w_i = 1</span> und Überrenditen geschrieben als <span class="math inline">\mathbf{w}^\top(\boldsymbol{\mu}-r_f\mathbf{1})</span> kürzt sich <span class="math inline">c</span> heraus. Mit der Bedingung <span class="math inline">\sum w_i = 1</span> ist die Skala jedoch <strong>fixiert</strong>, man kann also nicht frei skalieren. Die Transformation ersetzt diese Bedingung durch <span class="math inline">\sum y_i = \kappa</span> mit freiem <span class="math inline">\kappa</span> und normiert stattdessen die Überrendite auf 1 — dadurch wird die Skala wieder frei und das Problem konvex.</p>
+<p><strong>19.4 — Restriktionen kosten.</strong> Erwartetes Muster: Sharpe Ratio sinkt monoton mit strengerer Grenze. Unlösbar wird es bei <span class="math inline">w_{\max} &lt; 1/n</span> — dann kann die Summe der Gewichte 1 nicht mehr erreicht werden.</p>
+<p><strong>19.5 — Den Sektorfehler nachstellen.</strong> (a) AAPL, AMZN, CVX, GS statt AAPL, MSFT, NVDA, AMZN. (b) Die Gewichte unterscheiden sich deutlich, weil die eigentlich zu begrenzenden Tech-Titel frei laufen. (c) <strong>Nein</strong> — die Kennzahlen sehen völlig plausibel aus. Genau das macht den Fehler so gefährlich.</p>
+<p><strong>19.6 — Kardinalität.</strong> Erwartung: Die Sharpe Ratio sinkt leicht, die Rechenzeit steigt deutlich (MIQP statt QP). Bei <span class="math inline">K \ge 5</span> und <span class="math inline">w_{\max} = 0{,}20</span> ist die Restriktion praktisch nicht mehr bindend.</p>
+<p><strong>19.7 — Out-of-Sample.</strong> Typisches Ergebnis: Max-Sharpe schneidet in der zweiten Hälfte <strong>schlechter</strong> ab als in der ersten — es hat Schätzrauschen mitoptimiert. GMV ist stabiler (keine Renditeprognose nötig), 1/N oft überraschend gut. Mit Ledoit-Wolf verbessern sich GMV und Max-Sharpe spürbar. <strong>Praxisfolgerung:</strong> Renditeprognosen sind viel unzuverlässiger als Risikoschätzungen — Modelle, die ohne sie auskommen, sind robuster.</p>
+<h3 id="finde-den-denkfehler-zwölf-gleiche-anlagen-ein-sehr-ungleiches-portfolio">Finde den Denkfehler — Zwölf gleiche Anlagen, ein sehr ungleiches Portfolio</h3>
 <ol type="a">
 <li><strong>Woher die Spanne kommt.</strong> Aus reinem Rauschen. Der Mittelwert von 250 Beobachtungen einer Größe mit Standardabweichung <span class="math inline">\sigma = 1{,}2\,\%</span> hat selbst noch den <strong>Standardfehler</strong></li>
 </ol>
@@ -29495,7 +31149,7 @@ T \ge \left(\frac{2\sigma}{\mu}\right)^2 = \left(\frac{2 \cdot 0{,}012}{0{,}0004
 <ol type="1">
 <li><strong>Renditeschätzung ganz vermeiden.</strong> Das <strong>Minimum-Varianz-Portfolio</strong> minimiert nur <span class="math inline">\mathbf{w}^\top\boldsymbol{\Sigma}\mathbf{w}</span> und braucht überhaupt kein <span class="math inline">\boldsymbol{\mu}</span>. Damit fällt die unzuverlässigste Eingangsgröße ersatzlos weg. Das ist das wirksamste Mittel, weil es das Problem nicht abmildert, sondern <strong>beseitigt</strong> — man kann eine Größe nicht falsch schätzen, die man nicht verwendet.</li>
 <li><strong>Stark schrumpfen.</strong> Wenn Renditen gebraucht werden, zieht man sie kräftig zum Gesamtmittel (James-Stein) oder zu einer Gleichgewichtsannahme (Black-Litterman) — deutlich stärker als bei Kovarianzen, aus den Gründen unter (c).</li>
-<li><strong>Freiheit begrenzen.</strong> Obergrenzen je Position (etwa 15 %), Sektorgrenzen, maximale Abweichung von einer Referenzgewichtung. Was der Optimierer nicht darf, kann er auch nicht auf Rauschen setzen — dasselbe Rezept wie in <a href="#kapitel-11">Denkfehler 11.1</a>.</li>
+<li><strong>Freiheit begrenzen.</strong> Obergrenzen je Position (etwa 15 %), Sektorgrenzen, maximale Abweichung von einer Referenzgewichtung. Was der Optimierer nicht darf, kann er auch nicht auf Rauschen setzen — dasselbe Rezept wie in <a href="#sec:finanzdaten-denkfehler">Abschnitt 18.8</a>.</li>
 </ol>
 <p><strong>Und die Kontrollfrage für den Alltag:</strong> Rechnen Sie Ihr Modell mit den Daten des halben Zeitraums und dann mit denen der anderen Hälfte. Wenn die Gewichte dabei stark springen, optimieren Sie Rauschen — unabhängig davon, wie gut die Kennzahlen im Schätzzeitraum aussehen.</p>
 <h3 id="quiz-loesung-markowitz">Micro-Quiz</h3>
@@ -29512,13 +31166,13 @@ T \ge \left(\frac{2\sigma}{\mu}\right)^2 = \left(\frac{2 \cdot 0{,}012}{0{,}0004
 </ol>
 <hr />
 <h2 id="sec:loesungen-cvar">A.20 Lösungen zu Kapitel „Tail-Risiko, CVaR und Transaktionskosten“</h2>
-<p><strong>13.1 — VaR und CVaR von Hand.</strong> Sortierte Verluste: <span class="math inline">-2{,}0; -1{,}2; -0{,}8; -0{,}4; 0{,}3; 0{,}6; 1{,}1; 2{,}1; 5{,}4; 8{,}9</span>. Das 80 %-Quantil ist der 8. Wert: <span class="math inline">\text{VaR}_{80\%} = 2{,}1</span>. $_{80%} = $ Mittel der schlechtesten 20 % <span class="math inline">= (5{,}4+8{,}9)/2 = \mathbf{7{,}15}</span>.</p>
-<p><strong>13.2 — Subadditivität.</strong> Ein Risikomaß sollte Diversifikation nie bestrafen: Das Risiko eines zusammengelegten Portfolios darf nicht größer sein als die Summe der Einzelrisiken. Wird das verletzt, hätte eine Bank einen Anreiz, Portfolios künstlich aufzuspalten, um Eigenkapitalanforderungen zu senken — ökonomisch unsinnig.</p>
-<p><strong>13.3 — Rockafellar-Uryasev nachvollziehen.</strong> (a) Schlechtestes Drittel von <span class="math inline">(1,4,9)</span> ist <span class="math inline">\{9\}</span> → CVaR <span class="math inline">= 9</span>. (b) Mit <span class="math inline">\frac{1}{S(1-\alpha)} = \frac{1}{3\cdot(1/3)} = 1</span>: <span class="math inline">\gamma=0</span>: <span class="math inline">0 + (1+4+9) = 14</span>. <span class="math inline">\gamma=1</span>: <span class="math inline">1 + (0+3+8) = 12</span>. <span class="math inline">\gamma=4</span>: <span class="math inline">4 + (0+0+5) = \mathbf{9}</span>. <span class="math inline">\gamma=5</span>: <span class="math inline">5+4 = 9</span>. <span class="math inline">\gamma=9</span>: <span class="math inline">9+0 = 9</span>. (c) Minimum ab <span class="math inline">\gamma = 4</span> bei <strong>9</strong> — identisch mit (a) ✓. (Das Minimum wird auf einem ganzen Intervall angenommen, weil die Funktion stückweise linear ist — genau der Grund, warum der CVaR nicht <em>streng</em> konvex ist.)</p>
-<p><strong>13.4 — Einheiten prüfen.</strong> In einem Modell, das annualisierte Rendite gegen täglichen CVaR verrechnet, wirkt <span class="math inline">1{,}5</span> effektiv als <span class="math inline">1{,}5/252 \approx 0{,}006</span> auf Tagesbasis — der Risikoterm ist also um Faktor 252 zu leicht gewichtet. Um dieselbe Wirkung wie <code>RISIKOAVERSION = 1.5</code> im konsistenten Tagesmodell zu erzielen, hätte man dort <code>lambda_risk = 1.5 * 252 = 378</code> setzen müssen.</p>
-<p><strong>13.5 — Risikoaversion kalibrieren.</strong> (a) Konkav, ähnlich der Markowitz-Frontier, aber im Rendite-CVaR-Raum. (b) Bei Normalverteilung entspricht CVaR-Optimierung ungefähr der Varianz-Optimierung; die Ergebnisse divergieren umso stärker, je schiefer die Verteilung ist. (c) Empfehlung ohne Fachjargon: „Bei dieser Einstellung liegt der durchschnittliche Verlust an den schlechtesten fünf Prozent der Tage bei X Prozent — bei einer erwarteten Rendite von Y Prozent.“ Das ist entscheidbar; „<span class="math inline">\lambda = 4</span>“ ist es nicht.</p>
-<p><strong>13.6 — Grenze statt Strafe.</strong> (a) Mit engerer Grenze sinkt die erreichbare Rendite; bei <span class="math inline">\tau = 0</span> bleibt das Altportfolio. (b) <strong>Vorteil der Grenze:</strong> garantierte Obergrenze für die Handelsaktivität — wichtig, wenn Liquidität oder Compliance eine harte Schranke verlangen. <strong>Nachteil:</strong> Sie kann das Modell unlösbar machen und ignoriert, dass ein sehr lohnender Trade den Aufwand wert wäre. (c) Strafe bei ökonomischer Abwägung, Grenze bei regulatorischen oder Liquiditätsvorgaben.</p>
-<h3 id="finde-den-denkfehler-13.1-das-risikobudget-das-durch-diversifikation-stieg">Finde den Denkfehler 13.1 — Das Risikobudget, das durch Diversifikation stieg</h3>
+<p><strong>20.1 — VaR und CVaR von Hand.</strong> Sortierte Verluste: <span class="math inline">-2{,}0; -1{,}2; -0{,}8; -0{,}4; 0{,}3; 0{,}6; 1{,}1; 2{,}1; 5{,}4; 8{,}9</span>. Das 80 %-Quantil ist der 8. Wert: <span class="math inline">\text{VaR}_{80\%} = 2{,}1</span>. $_{80%} = $ Mittel der schlechtesten 20 % <span class="math inline">= (5{,}4+8{,}9)/2 = \mathbf{7{,}15}</span>.</p>
+<p><strong>20.2 — Subadditivität.</strong> Ein Risikomaß sollte Diversifikation nie bestrafen: Das Risiko eines zusammengelegten Portfolios darf nicht größer sein als die Summe der Einzelrisiken. Wird das verletzt, hätte eine Bank einen Anreiz, Portfolios künstlich aufzuspalten, um Eigenkapitalanforderungen zu senken — ökonomisch unsinnig.</p>
+<p><strong>20.3 — Rockafellar-Uryasev nachvollziehen.</strong> (a) Schlechtestes Drittel von <span class="math inline">(1,4,9)</span> ist <span class="math inline">\{9\}</span> → CVaR <span class="math inline">= 9</span>. (b) Mit <span class="math inline">\frac{1}{S(1-\alpha)} = \frac{1}{3\cdot(1/3)} = 1</span>: <span class="math inline">\gamma=0</span>: <span class="math inline">0 + (1+4+9) = 14</span>. <span class="math inline">\gamma=1</span>: <span class="math inline">1 + (0+3+8) = 12</span>. <span class="math inline">\gamma=4</span>: <span class="math inline">4 + (0+0+5) = \mathbf{9}</span>. <span class="math inline">\gamma=5</span>: <span class="math inline">5+4 = 9</span>. <span class="math inline">\gamma=9</span>: <span class="math inline">9+0 = 9</span>. (c) Minimum ab <span class="math inline">\gamma = 4</span> bei <strong>9</strong> — identisch mit (a) ✓. (Das Minimum wird auf einem ganzen Intervall angenommen, weil die Funktion stückweise linear ist — genau der Grund, warum der CVaR nicht <em>streng</em> konvex ist.)</p>
+<p><strong>20.4 — Einheiten prüfen.</strong> In einem Modell, das annualisierte Rendite gegen täglichen CVaR verrechnet, wirkt <span class="math inline">1{,}5</span> effektiv als <span class="math inline">1{,}5/252 \approx 0{,}006</span> auf Tagesbasis — der Risikoterm ist also um Faktor 252 zu leicht gewichtet. Um dieselbe Wirkung wie <code>RISIKOAVERSION = 1.5</code> im konsistenten Tagesmodell zu erzielen, hätte man dort <code>lambda_risk = 1.5 * 252 = 378</code> setzen müssen.</p>
+<p><strong>20.5 — Risikoaversion kalibrieren.</strong> (a) Konkav, ähnlich der Markowitz-Frontier, aber im Rendite-CVaR-Raum. (b) Bei Normalverteilung entspricht CVaR-Optimierung ungefähr der Varianz-Optimierung; die Ergebnisse divergieren umso stärker, je schiefer die Verteilung ist. (c) Empfehlung ohne Fachjargon: „Bei dieser Einstellung liegt der durchschnittliche Verlust an den schlechtesten fünf Prozent der Tage bei X Prozent — bei einer erwarteten Rendite von Y Prozent.“ Das ist entscheidbar; „<span class="math inline">\lambda = 4</span>“ ist es nicht.</p>
+<p><strong>20.6 — Grenze statt Strafe.</strong> (a) Mit engerer Grenze sinkt die erreichbare Rendite; bei <span class="math inline">\tau = 0</span> bleibt das Altportfolio. (b) <strong>Vorteil der Grenze:</strong> garantierte Obergrenze für die Handelsaktivität — wichtig, wenn Liquidität oder Compliance eine harte Schranke verlangen. <strong>Nachteil:</strong> Sie kann das Modell unlösbar machen und ignoriert, dass ein sehr lohnender Trade den Aufwand wert wäre. (c) Strafe bei ökonomischer Abwägung, Grenze bei regulatorischen oder Liquiditätsvorgaben.</p>
+<h3 id="finde-den-denkfehler-das-risikobudget-das-durch-diversifikation-stieg">Finde den Denkfehler — Das Risikobudget, das durch Diversifikation stieg</h3>
 <ol type="a">
 <li><strong>Die entscheidende Wahrscheinlichkeit.</strong> Bei zwei unabhängigen Anleihen mit je 4 % Ausfallwahrscheinlichkeit fällt <strong>mindestens eine</strong> aus mit</li>
 </ol>
@@ -29561,13 +31215,13 @@ T \ge \left(\frac{2\sigma}{\mu}\right)^2 = \left(\frac{2 \cdot 0{,}012}{0{,}0004
 </ol>
 <hr />
 <h2 id="sec:loesungen-handelsmaschine">A.21 Lösungen zu Kapitel „Die vollständige quantitative Handelsmaschine“</h2>
-<p><strong>14.1 — Lookahead erkennen.</strong> (a) sauber (<code>:heute</code>). (b) <strong>Lookahead</strong> — gesamter Zeitraum. (c) <strong>Lookahead</strong> — Volatilität über den ganzen Zeitraum enthält Zukunft. (d) sauber — Gewichte aus Daten bis heute, angewendet auf heute (idealerweise auf morgen). (e) <strong>Survivorship-Bias</strong> — das Universum wird danach gefiltert, wer über den gesamten Zeitraum Daten hat.</p>
-<p><strong>14.2 — Kennzahlen deuten.</strong> A: Sharpe <span class="math inline">= (12-2)/22 = 0{,}45</span>, Calmar <span class="math inline">= 12/35 = 0{,}34</span>. B: Sharpe <span class="math inline">= (8-2)/9 = 0{,}67</span>, Calmar <span class="math inline">= 8/12 = 0{,}67</span>. <strong>Empfehlung: B</strong> — für einen Pensionsfonds ist der Drawdown entscheidend, weil laufende Auszahlungen in einer Verlustphase Substanz vernichten. B ist in beiden risikoadjustierten Maßen besser.</p>
-<p><strong>14.3 — Rebalancing-Kalender.</strong> Etwa 25–30 % der Termine fallen aus. Die Kennzahlen ändern sich messbar — in welche Richtung, ist zufällig. Genau das ist der Punkt: Der Fehler verzerrt, ohne aufzufallen.</p>
-<p><strong>14.4 — Rebalancing-Frequenz.</strong> Typisches Muster: Turnover und Kosten steigen etwa linear mit der Frequenz, der Bruttoertrag verbessert sich nur unterproportional. Bei 0,15 % Gebühren ist monatlich meist vertretbar, bei 0,5 % eher quartalsweise. Ein <strong>Toleranzband</strong> (nur handeln bei Abweichung &gt; x %) schlägt fast immer die feste Frequenz.</p>
-<p><strong>14.5 — Krisenverhalten.</strong> Erwartung: Die Überrendite ist selten stabil; oft stammt sie aus wenigen Perioden. Folgerung: Eine gute Gesamtkennzahl kann von einer einzigen glücklichen Phase getragen sein — <strong>immer</strong> nach Teilzeiträumen aufschlüsseln.</p>
-<p><strong>14.6 — Data Snooping messen.</strong> Erwartetes Ergebnis: Die beste In-Sample-Sharpe-Ratio liegt deutlich über dem Mittelwert aller Varianten; auf dem zurückgehaltenen Zeitraum fällt sie Richtung Mittelwert zurück. Die <strong>Differenz zwischen (a) und (c) ist der Selektionseffekt</strong> — genau das, was die Deflated Sharpe Ratio korrigieren soll.</p>
-<h3 id="finde-den-denkfehler-14.1-die-strategie-mit-dem-hochsignifikanten-ergebnis">Finde den Denkfehler 14.1 — Die Strategie mit dem hochsignifikanten Ergebnis</h3>
+<p><strong>21.1 — Lookahead erkennen.</strong> (a) sauber (<code>:heute</code>). (b) <strong>Lookahead</strong> — gesamter Zeitraum. (c) <strong>Lookahead</strong> — Volatilität über den ganzen Zeitraum enthält Zukunft. (d) sauber — Gewichte aus Daten bis heute, angewendet auf heute (idealerweise auf morgen). (e) <strong>Survivorship-Bias</strong> — das Universum wird danach gefiltert, wer über den gesamten Zeitraum Daten hat.</p>
+<p><strong>21.2 — Kennzahlen deuten.</strong> A: Sharpe <span class="math inline">= (12-2)/22 = 0{,}45</span>, Calmar <span class="math inline">= 12/35 = 0{,}34</span>. B: Sharpe <span class="math inline">= (8-2)/9 = 0{,}67</span>, Calmar <span class="math inline">= 8/12 = 0{,}67</span>. <strong>Empfehlung: B</strong> — für einen Pensionsfonds ist der Drawdown entscheidend, weil laufende Auszahlungen in einer Verlustphase Substanz vernichten. B ist in beiden risikoadjustierten Maßen besser.</p>
+<p><strong>21.3 — Rebalancing-Kalender.</strong> Etwa 25–30 % der Termine fallen aus. Die Kennzahlen ändern sich messbar — in welche Richtung, ist zufällig. Genau das ist der Punkt: Der Fehler verzerrt, ohne aufzufallen.</p>
+<p><strong>21.4 — Rebalancing-Frequenz.</strong> Typisches Muster: Turnover und Kosten steigen etwa linear mit der Frequenz, der Bruttoertrag verbessert sich nur unterproportional. Bei 0,15 % Gebühren ist monatlich meist vertretbar, bei 0,5 % eher quartalsweise. Ein <strong>Toleranzband</strong> (nur handeln bei Abweichung &gt; x %) schlägt fast immer die feste Frequenz.</p>
+<p><strong>21.5 — Krisenverhalten.</strong> Erwartung: Die Überrendite ist selten stabil; oft stammt sie aus wenigen Perioden. Folgerung: Eine gute Gesamtkennzahl kann von einer einzigen glücklichen Phase getragen sein — <strong>immer</strong> nach Teilzeiträumen aufschlüsseln.</p>
+<p><strong>21.6 — Data Snooping messen.</strong> Erwartetes Ergebnis: Die beste In-Sample-Sharpe-Ratio liegt deutlich über dem Mittelwert aller Varianten; auf dem zurückgehaltenen Zeitraum fällt sie Richtung Mittelwert zurück. Die <strong>Differenz zwischen (a) und (c) ist der Selektionseffekt</strong> — genau das, was die Deflated Sharpe Ratio korrigieren soll.</p>
+<h3 id="finde-den-denkfehler-die-strategie-mit-dem-hochsignifikanten-ergebnis">Finde den Denkfehler — Die Strategie mit dem hochsignifikanten Ergebnis</h3>
 <ol type="a">
 <li><strong>Warum ein korrekter Backtest wertlos sein kann.</strong> Der Backtest misst genau das, was er messen soll: die Wertentwicklung <em>dieser einen</em> Strategie. Die Frage, die beantwortet werden soll, lautet aber anders — nämlich: <em>„Ist dieses Ergebnis besser, als es Zufall erklären kann?“</em></li>
 </ol>
@@ -29632,13 +31286,14 @@ T \ge \left(\frac{2\sigma}{\mu}\right)^2 = \left(\frac{2 \cdot 0{,}012}{0{,}0004
 </ol>
 <hr />
 <h2 id="sec:loesungen-praxisfallen">A.22 Lösungen zu Kapitel „Praxisfallen und der Weg zum produktiven Einsatz“</h2>
-<p><strong>15.1 — Hart oder weich, revisited.</strong> (a) hart: gesetzliche Ruhezeit, Qualifikationspflicht. (b) weich: individuelle Wunschtage, Vermeidung von Freistunden. (c) diskutabel: Höchstzahl Vertretungsstunden pro Tag (tariflich vs. Notfall), gleichmäßige Wochenendverteilung.</p>
-<p><strong>15.2 — Zeitlimit wählen.</strong> (a) 1–3 s, Gap 5–10 % (Echtzeit schlägt Optimalität). (b) 1–5 min, Gap 1–2 %. (c) Stunden, Gap ~0 % (einmalige, folgenreiche Entscheidung). (d) 30–60 s, Gap 1 % — die Datenunsicherheit ist ohnehin größer.</p>
-<p><strong>15.3 — Relaxation einbauen.</strong> Muster wie in <code>Infeasibility_Diagnose.py</code>: Schlupfvariable je Mindestbesetzung, Strafe deutlich über allen weichen Zielen, aber endlich. Wichtig: <strong>gestaffelte</strong> Strafen, damit der Solver die <em>am wenigsten schmerzhafte</em> Verletzung wählt.</p>
-<p><strong>15.4 — Erklärbarkeit.</strong> Report-Struktur: (1) Zielwert und Aufschlüsselung nach Bestandteilen; (2) je Entscheidung die bindenden Bedingungen; (3) Schattenpreise der knappsten Ressourcen mit Handlungsempfehlung.</p>
-<p><strong>15.5 — Gap gegen Laufzeit.</strong> Erwartetes Muster: Von 10 % auf 2 % kostet wenig Zeit; von 1 % auf 0 % kann die Laufzeit um Größenordnungen steigen, ohne dass sich der Zielwert nennenswert verbessert. Empfehlung: Gap dort ansetzen, wo die Kurve knickt — typischerweise 1–2 %.</p>
-<p><strong>15.6 — Post-Mortem.</strong> Bewertungskriterien: Wird zwischen <strong>Symptom</strong>, <strong>Ursache</strong> und <strong>fehlender Prüfung</strong> unterschieden? Ist die abgeleitete Regel allgemein genug, um beim nächsten Projekt zu helfen (z. B. „Nach jeder Vorzeichenumkehr eine numerische Gegenprobe“), aber konkret genug, um überprüfbar zu sein?</p>
-<h3 id="finde-den-denkfehler-15.1-das-modell-das-seit-einem-jahr-nicht-mehr-optimiert">Finde den Denkfehler 15.1 — Das Modell, das seit einem Jahr nicht mehr optimiert</h3>
+<p><strong>22.1 — Hart oder weich, revisited.</strong> (a) hart: gesetzliche Ruhezeit, Qualifikationspflicht. (b) weich: individuelle Wunschtage, Vermeidung von Freistunden. (c) diskutabel: Höchstzahl Vertretungsstunden pro Tag (tariflich vs. Notfall), gleichmäßige Wochenendverteilung.</p>
+<p><strong>22.2 — Zeitlimit wählen.</strong> (a) 1–3 s, Gap 5–10 % (Echtzeit schlägt Optimalität). (b) 1–5 min, Gap 1–2 %. (c) Stunden, Gap ~0 % (einmalige, folgenreiche Entscheidung). (d) 30–60 s, Gap 1 % — die Datenunsicherheit ist ohnehin größer.</p>
+<p><strong>22.3 — Relaxation einbauen.</strong> Muster wie in <code>Infeasibility_Diagnose.py</code>: Schlupfvariable je Mindestbesetzung, Strafe deutlich über allen weichen Zielen, aber endlich. Wichtig: <strong>gestaffelte</strong> Strafen, damit der Solver die <em>am wenigsten schmerzhafte</em> Verletzung wählt.</p>
+<p><strong>22.4 — Erklärbarkeit.</strong> Report-Struktur: (1) Zielwert und Aufschlüsselung nach Bestandteilen; (2) je Entscheidung die bindenden Bedingungen; (3) Schattenpreise der knappsten Ressourcen mit Handlungsempfehlung.</p>
+<p><strong>22.5 — Den Bericht in die Irre führen.</strong> (a) Der Plan kippt: <em>Rahmen</em> fällt von 47,5 auf <strong>40</strong> — das Minimum aus dem Liefervertrag —, <em>Deckel</em> steigt von 97,5 auf <strong>120</strong>, die Marktgrenze. Der Deckungsbeitrag springt von 3 930 € auf <strong>5 190 €</strong>. Mit ihm wechselt die Engpassstruktur: „Kapazität Lackieren” bindet <strong>nicht mehr</strong>, dafür bindet jetzt „Liefervertrag Rahmen” — und zwar als <em>Kosten</em> von 25 € je Stück, weil der Vertrag zur Herstellung eines inzwischen unattraktiven Produkts zwingt. Alle Schattenpreise steigen deutlich (Träger von 18 € auf 58 €). Der entscheidende Punkt der Aufgabe: Der Satz <em>„Teuerste Bindung ist Liefervertrag Träger”</em> steht <strong>wörtlich unverändert</strong> im Bericht — obwohl die Zahl dahinter sich mehr als verdreifacht hat und ein anderer Engpass die Fabrik begrenzt. Ein Bericht, der sich nicht ändert, ist kein Beweis dafür, dass sich nichts geändert hat. (b) Etwa: <em>„Unter der Annahme eines Deckungsbeitrags von 9 € je Deckel ist ‚Liefervertrag Träger’ die teuerste Bindung (18 € je Stück).”</em> Die Aussage bekommt damit ihre Voraussetzung mit — und wird angreifbar, was sie sein soll. (c) Mindestens eines von beidem: den <strong>Gültigkeitsbereich</strong> jedes Schattenpreises (bis wohin gilt er?), oder das Ergebnis einer <strong>Sensitivitätsrechnung</strong> über die unsichersten Eingangsgrößen — etwa „bei ±20 % Deckungsbeitrag Deckel bleibt die Rangfolge/kippt sie”. Das Programm rechnet den Gültigkeitsbereich für die auffälligste Stellschraube bereits aus; ihn für alle auszuweisen ist eine kleine Erweiterung.</p>
+<p><strong>22.6 — Gap gegen Laufzeit.</strong> Erwartetes Muster: Von 10 % auf 2 % kostet wenig Zeit; von 1 % auf 0 % kann die Laufzeit um Größenordnungen steigen, ohne dass sich der Zielwert nennenswert verbessert. Empfehlung: Gap dort ansetzen, wo die Kurve knickt — typischerweise 1–2 %.</p>
+<p><strong>22.7 — Post-Mortem.</strong> Bewertungskriterien: Wird zwischen <strong>Symptom</strong>, <strong>Ursache</strong> und <strong>fehlender Prüfung</strong> unterschieden? Ist die abgeleitete Regel allgemein genug, um beim nächsten Projekt zu helfen (z. B. „Nach jeder Vorzeichenumkehr eine numerische Gegenprobe“), aber konkret genug, um überprüfbar zu sein?</p>
+<h3 id="finde-den-denkfehler-das-modell-das-seit-einem-jahr-nicht-mehr-optimiert">Finde den Denkfehler — Das Modell, das seit einem Jahr nicht mehr optimiert</h3>
 <ol type="a">
 <li><strong>Warum die konstante Laufzeit das Symptom ist.</strong> Ein Solver, der fertig wird, braucht so lange, wie das Problem eben dauert — und diese Zeit wächst mit den Daten. Eine Laufzeit, die über Jahre exakt bei 3,00 Sekunden liegt, kann deshalb nur eines bedeuten: Der Job wird nicht fertig, sondern <strong>abgeschnitten</strong>.</li>
 </ol>
@@ -29697,29 +31352,31 @@ T \ge \left(\frac{2\sigma}{\mu}\right)^2 = \left(\frac{2 \cdot 0{,}012}{0{,}0004
 <li>Weil die Datenunsicherheit (oft ±10 %) die verbleibende Optimalitätslücke bei Weitem übersteigt.</li>
 <li>Jeder Lauf arbeitet auf einem unveränderlichen, mit ID versehenen Datenstand — nur so sind Ergebnisse reproduzierbar und belegbar.</li>
 <li>Die <strong>Einführung</strong>: mangelnde Akzeptanz, weil Ergebnisse nicht nachvollziehbar sind.</li>
+<li>Sie berührt den Plan, ohne ihn zu verteuern — die Lösung liegt genau auf ihrer Grenze, wäre aber auch ohne sie dieselbe (Entartung). Für eine Nachverhandlung folgt: <strong>nichts tun.</strong> Der Aufwand brächte 0 €. „Bindend” ist ein geometrischer, „teuer” ein wirtschaftlicher Befund.</li>
+<li>Weil der Schattenpreis nur für die <strong>nächste</strong> Einheit gilt und sein Gültigkeitsbereich endet, sobald ein anderer Engpass bindend wird. Realistische Lockerungen sind unterschiedlich groß — eine Sonderschicht bringt 50 Einheiten, ein nachverhandelter Vertrag 10. Der Preis je Einheit sagt daher nichts darüber, welcher Hebel insgesamt am meisten bringt; dafür muss man die Lockerung rechnen, nicht den Preis multiplizieren.</li>
 </ol>
 <hr />
 <p><em>Zurück zum</em> <strong>Wegweiser</strong> <em>oder weiter zu</em> <strong><a href="#anhang-modellierungsmuster">Anhang B</a> — Modellierungsmuster</strong></p>
 <h2 id="sec:loesungen-testing">A.23 Lösungen zu Kapitel „Testen, Messen, Ausliefern“</h2>
-<p><strong>Den Schnellstart reparieren.</strong> Zwei Wege: (a) <strong>Abrunden statt runden</strong> — <code>np.floor</code> statt <code>np.round</code>. Das ist immer zulässig, weil weniger produzieren nie eine Kapazität sprengt, kostet aber Deckungsbeitrag und ist im Allgemeinen <strong>nicht</strong> die optimale ganzzahlige Lösung. (b) <strong>Ganzzahlig modellieren</strong> — <code>linprog(..., integrality=1)</code> bzw. <code>IntVar</code>. Das ist der richtige Weg.</p>
+<p><strong>23.1 — Den Schnellstart reparieren.</strong> Zwei Wege: (a) <strong>Abrunden statt runden</strong> — <code>np.floor</code> statt <code>np.round</code>. Das ist immer zulässig, weil weniger produzieren nie eine Kapazität sprengt, kostet aber Deckungsbeitrag und ist im Allgemeinen <strong>nicht</strong> die optimale ganzzahlige Lösung. (b) <strong>Ganzzahlig modellieren</strong> — <code>linprog(..., integrality=1)</code> bzw. <code>IntVar</code>. Das ist der richtige Weg.</p>
 <p>Warum das ein eigenes Kapitel wert ist (<a href="#kap-milp">Kapitel 6</a>): Runden ist nicht nur ungenau, sondern kann <em>beliebig</em> danebenliegen. Es gibt Instanzen, bei denen die gerundete LP-Lösung nicht nur suboptimal, sondern unzulässig ist — genau das zeigt der Schnellstart — und andere, bei denen zwischen gerundetem LP und echtem Optimum Welten liegen (<code>Runden_Gegenbeispiel.py</code>).</p>
-<p><strong>Eine Invariante mehr.</strong></p>
-<div class="sourceCode" id="cb243"><pre class="sourceCode python"><code class="sourceCode python"><span id="cb243-1"><a href="#cb243-1" aria-hidden="true" tabindex="-1"></a><span class="kw">def</span> test_kapazitaeten_verdoppeln(bauer):</span>
-<span id="cb243-2"><a href="#cb243-2" aria-hidden="true" tabindex="-1"></a>    problem <span class="op">=</span> schreinerei()</span>
-<span id="cb243-3"><a href="#cb243-3" aria-hidden="true" tabindex="-1"></a>    doppelt <span class="op">=</span> Produktionsproblem(</span>
-<span id="cb243-4"><a href="#cb243-4" aria-hidden="true" tabindex="-1"></a>        produkte<span class="op">=</span>problem.produkte,</span>
-<span id="cb243-5"><a href="#cb243-5" aria-hidden="true" tabindex="-1"></a>        kapazitaeten<span class="op">=</span>{r: <span class="dv">2</span> <span class="op">*</span> k <span class="cf">for</span> r, k <span class="kw">in</span> problem.kapazitaeten.items()})</span>
-<span id="cb243-6"><a href="#cb243-6" aria-hidden="true" tabindex="-1"></a>    basis, gross <span class="op">=</span> bauer(problem), bauer(doppelt)</span>
-<span id="cb243-7"><a href="#cb243-7" aria-hidden="true" tabindex="-1"></a>    <span class="cf">assert</span> gross.zielwert <span class="op">==</span> pytest.approx(<span class="dv">2</span> <span class="op">*</span> basis.zielwert, rel<span class="op">=</span><span class="fl">1e-9</span>)</span></code></pre></div>
+<p><strong>23.2 — Eine Invariante mehr.</strong></p>
+<div class="sourceCode" id="cb247"><pre class="sourceCode python"><code class="sourceCode python"><span id="cb247-1"><a href="#cb247-1" aria-hidden="true" tabindex="-1"></a><span class="kw">def</span> test_kapazitaeten_verdoppeln(bauer):</span>
+<span id="cb247-2"><a href="#cb247-2" aria-hidden="true" tabindex="-1"></a>    problem <span class="op">=</span> schreinerei()</span>
+<span id="cb247-3"><a href="#cb247-3" aria-hidden="true" tabindex="-1"></a>    doppelt <span class="op">=</span> Produktionsproblem(</span>
+<span id="cb247-4"><a href="#cb247-4" aria-hidden="true" tabindex="-1"></a>        produkte<span class="op">=</span>problem.produkte,</span>
+<span id="cb247-5"><a href="#cb247-5" aria-hidden="true" tabindex="-1"></a>        kapazitaeten<span class="op">=</span>{r: <span class="dv">2</span> <span class="op">*</span> k <span class="cf">for</span> r, k <span class="kw">in</span> problem.kapazitaeten.items()})</span>
+<span id="cb247-6"><a href="#cb247-6" aria-hidden="true" tabindex="-1"></a>    basis, gross <span class="op">=</span> bauer(problem), bauer(doppelt)</span>
+<span id="cb247-7"><a href="#cb247-7" aria-hidden="true" tabindex="-1"></a>    <span class="cf">assert</span> gross.zielwert <span class="op">==</span> pytest.approx(<span class="dv">2</span> <span class="op">*</span> basis.zielwert, rel<span class="op">=</span><span class="fl">1e-9</span>)</span></code></pre></div>
 <p>Bei einem <strong>LP</strong> gilt das exakt: Der zulässige Bereich wird um den Faktor 2 gestreckt, und weil die Zielfunktion linear ist, skaliert das Optimum mit. Bei einem <strong>MILP</strong> gilt es nicht: Die Ganzzahligkeitsbedingung skaliert nicht mit. Aus 30,67 wird beim Verdoppeln 61,33 — und ob dazwischen eine bessere ganzzahlige Lösung liegt, hängt vom Einzelfall ab. Der Test wäre dort also falsch.</p>
-<p><strong>Eine eigene Mutation.</strong> Zwei lohnende Kandidaten:</p>
-<div class="sourceCode" id="cb244"><pre class="sourceCode python"><code class="sourceCode python"><span id="cb244-1"><a href="#cb244-1" aria-hidden="true" tabindex="-1"></a>(<span class="st">&quot;Kapazitaetspruefung mit falschem Vergleich&quot;</span>,</span>
-<span id="cb244-2"><a href="#cb244-2" aria-hidden="true" tabindex="-1"></a> <span class="st">&quot;if ist &gt; grenze + toleranz:&quot;</span>, <span class="st">&quot;if ist &lt; grenze - toleranz:&quot;</span>),</span>
-<span id="cb244-3"><a href="#cb244-3" aria-hidden="true" tabindex="-1"></a>(<span class="st">&quot;Toleranz mit falschem Vorzeichen&quot;</span>,</span>
-<span id="cb244-4"><a href="#cb244-4" aria-hidden="true" tabindex="-1"></a> <span class="st">&quot;if (mengen &lt; -toleranz).any():&quot;</span>, <span class="st">&quot;if (mengen &lt; toleranz).any():&quot;</span>),</span></code></pre></div>
+<p><strong>23.3 — Eine eigene Mutation.</strong> Zwei lohnende Kandidaten:</p>
+<div class="sourceCode" id="cb248"><pre class="sourceCode python"><code class="sourceCode python"><span id="cb248-1"><a href="#cb248-1" aria-hidden="true" tabindex="-1"></a>(<span class="st">&quot;Kapazitaetspruefung mit falschem Vergleich&quot;</span>,</span>
+<span id="cb248-2"><a href="#cb248-2" aria-hidden="true" tabindex="-1"></a> <span class="st">&quot;if ist &gt; grenze + toleranz:&quot;</span>, <span class="st">&quot;if ist &lt; grenze - toleranz:&quot;</span>),</span>
+<span id="cb248-3"><a href="#cb248-3" aria-hidden="true" tabindex="-1"></a>(<span class="st">&quot;Toleranz mit falschem Vorzeichen&quot;</span>,</span>
+<span id="cb248-4"><a href="#cb248-4" aria-hidden="true" tabindex="-1"></a> <span class="st">&quot;if (mengen &lt; -toleranz).any():&quot;</span>, <span class="st">&quot;if (mengen &lt; toleranz).any():&quot;</span>),</span></code></pre></div>
 <p>Die erste wird getötet (<code>test_pruefung_findet_kapazitaetsverletzung</code>). Die zweite ist interessanter: Sie macht die Prüfung <em>strenger</em> statt schwächer — eine Lösung mit einer Menge von exakt 0 würde als negativ beanstandet. Ob sie überlebt, hängt daran, ob die Suite eine Instanz enthält, in der ein Produkt mit Menge 0 vorkommt. In der Schreinerei ist das nicht der Fall — die Mutation überlebt also und zeigt eine echte Lücke: Es fehlt eine Testinstanz, in der ein Produkt nicht produziert wird.</p>
-<p><strong>Der Benchmark mit MILP.</strong> Zu erwarten ist, dass sich die Reihenfolge ändert. Beim reinen LP entscheidet vor allem der Modellaufbau in Python; beim MILP verschiebt sich das Gewicht zum Lösen, und dort spielen die Branch-and-Bound-Heuristiken der Bibliotheken gegeneinander. Die Spalte „Anteil” sollte bei allen deutlich <strong>fallen</strong> — nicht weil der Aufbau schneller würde, sondern weil das Lösen langsamer wird. Genau deshalb steht im Kapitel, dass die Tabelle nichts über MILPs sagt.</p>
-<p><strong>Der Dienst mit Zeitlimit.</strong> Der Modellbauer in <code>or_kern.py</code> nimmt bisher kein Zeitlimit entgegen — das ist der erste Schritt (bei GLOP <code>solver.SetTimeLimit(millisekunden)</code>). Danach im Arbeiter durchreichen und den Status auswerten: Liefert der Solver <code>ZEITLIMIT</code>, ist <code>stand</code> weiterhin <code>gescheitert</code>, aber mit einer anderen Begründung als bei <code>UNZULAESSIG</code> — der Unterschied zwischen „rechne länger” und „ändere das Modell” (<a href="#kap-milp">Kapitel 6</a>).</p>
+<p><strong>23.4 — Der Benchmark mit MILP.</strong> Zu erwarten ist, dass sich die Reihenfolge ändert. Beim reinen LP entscheidet vor allem der Modellaufbau in Python; beim MILP verschiebt sich das Gewicht zum Lösen, und dort spielen die Branch-and-Bound-Heuristiken der Bibliotheken gegeneinander. Die Spalte „Anteil” sollte bei allen deutlich <strong>fallen</strong> — nicht weil der Aufbau schneller würde, sondern weil das Lösen langsamer wird. Genau deshalb steht im Kapitel, dass die Tabelle nichts über MILPs sagt.</p>
+<p><strong>23.5 — Der Dienst mit Zeitlimit.</strong> Der Modellbauer in <code>or_kern.py</code> nimmt bisher kein Zeitlimit entgegen — das ist der erste Schritt (bei GLOP <code>solver.SetTimeLimit(millisekunden)</code>). Danach im Arbeiter durchreichen und den Status auswerten: Liefert der Solver <code>ZEITLIMIT</code>, ist <code>stand</code> weiterhin <code>gescheitert</code>, aber mit einer anderen Begründung als bei <code>UNZULAESSIG</code> — der Unterschied zwischen „rechne länger” und „ändere das Modell” (<a href="#kap-milp">Kapitel 6</a>).</p>
 <p>Für den Test braucht es eine Instanz, die das Limit reißt. Ein LP eignet sich schlecht dafür; nehmen Sie ein MILP mit einigen hundert Binärvariablen und ein Limit von 0,1 Sekunden.</p>
 <h3 id="denkfehler-loesung-testing">Finde den Denkfehler — „Die Suite ist grün, das Modell stimmt”</h3>
 <p><strong>Alle Prüfungen benutzen dieselbe falsche Zahl.</strong></p>
@@ -29966,6 +31623,7 @@ T \ge \left(\frac{2\sigma}{\mu}\right)^2 = \left(\frac{2 \cdot 0{,}012}{0{,}0004
 </tbody>
 </table>
 <blockquote>
+<p><strong>Umgekehrte Richtung:</strong> Wer von einem Satz aus der Besprechung kommt und das Muster sucht, findet in <a href="#sec:modellierung-glossar">Abschnitt 4.6</a> ein Lexikon, das genau so herum aufgebaut ist — und die Wendungen benennt, bei denen es keine eindeutige Übersetzung gibt.</p>
 <p>Die Spalte „Wo im Buch“ nennt das Kapitel, in dem das Muster <strong>im Zusammenhang</strong> vorkommt — nicht die einzige Stelle, an der es taugt. Die Nummern entstehen beim Bauen; im Quelltext dieses Anhangs steht keine einzige.</p>
 </blockquote>
 <hr />
@@ -29973,8 +31631,8 @@ T \ge \left(\frac{2\sigma}{\mu}\right)^2 = \left(\frac{2 \cdot 0{,}012}{0{,}0004
 <h3 id="b1-aktivierungsschalter-fixkosten">B1 — Aktivierungsschalter (Fixkosten)</h3>
 <p><strong>Regel.</strong> „Wenn überhaupt etwas produziert wird, fallen Rüstkosten <span class="math inline">F</span> an.“</p>
 <p><span class="math display">x \le M\,y,\qquad y\in\{0,1\},\ x\ge0</span> Zielfunktion: <span class="math inline">\dots + F\,y</span></p>
-<div class="sourceCode" id="cb245"><pre class="sourceCode python"><code class="sourceCode python"><span id="cb245-1"><a href="#cb245-1" aria-hidden="true" tabindex="-1"></a>modell.Add(x <span class="op">&lt;=</span> M <span class="op">*</span> y)              <span class="co"># CP-SAT</span></span>
-<span id="cb245-2"><a href="#cb245-2" aria-hidden="true" tabindex="-1"></a><span class="co"># LP/MILP:  Zeile  x - M*y &lt;= 0</span></span></code></pre></div>
+<div class="sourceCode" id="cb249"><pre class="sourceCode python"><code class="sourceCode python"><span id="cb249-1"><a href="#cb249-1" aria-hidden="true" tabindex="-1"></a>modell.Add(x <span class="op">&lt;=</span> M <span class="op">*</span> y)              <span class="co"># CP-SAT</span></span>
+<span id="cb249-2"><a href="#cb249-2" aria-hidden="true" tabindex="-1"></a><span class="co"># LP/MILP:  Zeile  x - M*y &lt;= 0</span></span></code></pre></div>
 <blockquote>
 <p>⚠️ <strong><span class="math inline">M</span> so klein wie möglich</strong> — idealerweise die ohnehin vorhandene Kapazitätsgrenze von <span class="math inline">x</span>. Zu großes <span class="math inline">M</span> macht die LP-Relaxation wertlos (<a href="#sec:milp-modellierungstricks-big-m-und-logische-bedingungen">Abschnitt 6.5</a>).</p>
 </blockquote>
@@ -29985,18 +31643,18 @@ T \ge \left(\frac{2\sigma}{\mu}\right)^2 = \left(\frac{2 \cdot 0{,}012}{0{,}0004
 <h3 id="b3-implikation">B3 — Implikation</h3>
 <p><strong>Regel.</strong> „Wenn A gewählt wird, muss auch B gewählt werden.“</p>
 <p><span class="math display">y_A \le y_B</span></p>
-<div class="sourceCode" id="cb246"><pre class="sourceCode python"><code class="sourceCode python"><span id="cb246-1"><a href="#cb246-1" aria-hidden="true" tabindex="-1"></a>modell.AddImplication(y_a, y_b)     <span class="co"># CP-SAT, gleichwertig und lesbarer</span></span></code></pre></div>
+<div class="sourceCode" id="cb250"><pre class="sourceCode python"><code class="sourceCode python"><span id="cb250-1"><a href="#cb250-1" aria-hidden="true" tabindex="-1"></a>modell.AddImplication(y_a, y_b)     <span class="co"># CP-SAT, gleichwertig und lesbarer</span></span></code></pre></div>
 <p>Für die Umkehrung („nur wenn“) einfach vertauschen. Für Äquivalenz: <span class="math inline">y_A = y_B</span>.</p>
 <h3 id="b4-entweder-oder-disjunktive-bedingung">B4 — Entweder-Oder (disjunktive Bedingung)</h3>
 <p><strong>Regel.</strong> „Es muss <span class="math inline">f(\mathbf{x}) \le b_1</span> <strong>oder</strong> <span class="math inline">g(\mathbf{x}) \le b_2</span> gelten.“</p>
 <p><span class="math display">f(\mathbf{x}) \le b_1 + M(1-y),\qquad g(\mathbf{x}) \le b_2 + M y</span></p>
-<div class="sourceCode" id="cb247"><pre class="sourceCode python"><code class="sourceCode python"><span id="cb247-1"><a href="#cb247-1" aria-hidden="true" tabindex="-1"></a><span class="co"># CP-SAT: viel eleganter ueber Reifizierung</span></span>
-<span id="cb247-2"><a href="#cb247-2" aria-hidden="true" tabindex="-1"></a>modell.Add(f_ausdruck <span class="op">&lt;=</span> b1).OnlyEnforceIf(y)</span>
-<span id="cb247-3"><a href="#cb247-3" aria-hidden="true" tabindex="-1"></a>modell.Add(g_ausdruck <span class="op">&lt;=</span> b2).OnlyEnforceIf(y.Not())</span></code></pre></div>
+<div class="sourceCode" id="cb251"><pre class="sourceCode python"><code class="sourceCode python"><span id="cb251-1"><a href="#cb251-1" aria-hidden="true" tabindex="-1"></a><span class="co"># CP-SAT: viel eleganter ueber Reifizierung</span></span>
+<span id="cb251-2"><a href="#cb251-2" aria-hidden="true" tabindex="-1"></a>modell.Add(f_ausdruck <span class="op">&lt;=</span> b1).OnlyEnforceIf(y)</span>
+<span id="cb251-3"><a href="#cb251-3" aria-hidden="true" tabindex="-1"></a>modell.Add(g_ausdruck <span class="op">&lt;=</span> b2).OnlyEnforceIf(y.Not())</span></code></pre></div>
 <h3 id="b5-exklusiv-oder">B5 — Exklusiv-Oder</h3>
 <p><strong>Regel.</strong> „Genau eine der Optionen wird gewählt.“</p>
 <p><span class="math display">\sum_{j=1}^N y_j = 1</span></p>
-<div class="sourceCode" id="cb248"><pre class="sourceCode python"><code class="sourceCode python"><span id="cb248-1"><a href="#cb248-1" aria-hidden="true" tabindex="-1"></a>modell.AddExactlyOne(y)             <span class="co"># bzw. AddAtMostOne / AddBoolOr</span></span></code></pre></div>
+<div class="sourceCode" id="cb252"><pre class="sourceCode python"><code class="sourceCode python"><span id="cb252-1"><a href="#cb252-1" aria-hidden="true" tabindex="-1"></a>modell.AddExactlyOne(y)             <span class="co"># bzw. AddAtMostOne / AddBoolOr</span></span></code></pre></div>
 <h3 id="b6-kardinalität">B6 — Kardinalität</h3>
 <p><strong>Regel.</strong> „Höchstens (mindestens, genau) <span class="math inline">K</span> von <span class="math inline">N</span>.“</p>
 <p><span class="math display">\sum_j y_j \le K \qquad(\ \ge K,\ = K\ )</span></p>
@@ -30021,14 +31679,14 @@ T \ge \left(\frac{2\sigma}{\mu}\right)^2 = \left(\frac{2 \cdot 0{,}012}{0{,}0004
 <p><strong>Regel.</strong> „Die Abweichung vom Zielwert soll klein sein, egal in welche Richtung.“</p>
 <p><span class="math display">|x - z| \le d \quad\Longleftrightarrow\quad x - z \le d\ \ \text{und}\ \ z - x \le d</span></p>
 <p>In der <strong>Zielfunktion</strong> (Minimierung von <span class="math inline">|x-z|</span>) genügt: <span class="math display">\min d \quad\text{u. d. N.}\quad x-z \le d,\quad z-x \le d</span></p>
-<div class="sourceCode" id="cb249"><pre class="sourceCode python"><code class="sourceCode python"><span id="cb249-1"><a href="#cb249-1" aria-hidden="true" tabindex="-1"></a>turnover <span class="op">=</span> cp.norm1(w <span class="op">-</span> w_alt)      <span class="co"># CVXPY macht das automatisch</span></span></code></pre></div>
+<div class="sourceCode" id="cb253"><pre class="sourceCode python"><code class="sourceCode python"><span id="cb253-1"><a href="#cb253-1" aria-hidden="true" tabindex="-1"></a>turnover <span class="op">=</span> cp.norm1(w <span class="op">-</span> w_alt)      <span class="co"># CVXPY macht das automatisch</span></span></code></pre></div>
 <h3 id="b11-minmax-in-der-zielfunktion">B11 — Min/Max in der Zielfunktion</h3>
 <p><strong>Regel.</strong> „Der am schlechtesten gestellte Beteiligte soll möglichst gut dastehen“ (Maximin/Fairness).</p>
 <p><span class="math display">\max t \quad\text{u. d. N.}\quad t \le f_i(\mathbf{x})\ \ \forall i</span></p>
-<div class="sourceCode" id="cb250"><pre class="sourceCode python"><code class="sourceCode python"><span id="cb250-1"><a href="#cb250-1" aria-hidden="true" tabindex="-1"></a>modell.AddMaxEquality(max_var, liste)   <span class="co"># CP-SAT</span></span>
-<span id="cb250-2"><a href="#cb250-2" aria-hidden="true" tabindex="-1"></a>modell.AddMinEquality(min_var, liste)</span>
-<span id="cb250-3"><a href="#cb250-3" aria-hidden="true" tabindex="-1"></a><span class="co"># Fairness ueber die Spannweite:</span></span>
-<span id="cb250-4"><a href="#cb250-4" aria-hidden="true" tabindex="-1"></a>modell.Add(spannweite <span class="op">==</span> max_var <span class="op">-</span> min_var)   <span class="co"># dann minimieren</span></span></code></pre></div>
+<div class="sourceCode" id="cb254"><pre class="sourceCode python"><code class="sourceCode python"><span id="cb254-1"><a href="#cb254-1" aria-hidden="true" tabindex="-1"></a>modell.AddMaxEquality(max_var, liste)   <span class="co"># CP-SAT</span></span>
+<span id="cb254-2"><a href="#cb254-2" aria-hidden="true" tabindex="-1"></a>modell.AddMinEquality(min_var, liste)</span>
+<span id="cb254-3"><a href="#cb254-3" aria-hidden="true" tabindex="-1"></a><span class="co"># Fairness ueber die Spannweite:</span></span>
+<span id="cb254-4"><a href="#cb254-4" aria-hidden="true" tabindex="-1"></a>modell.Add(spannweite <span class="op">==</span> max_var <span class="op">-</span> min_var)   <span class="co"># dann minimieren</span></span></code></pre></div>
 <h3 id="b12-verhältnis-bedingung">B12 — Verhältnis-Bedingung</h3>
 <p><strong>Regel.</strong> „Der Anteil von Gruppe G soll mindestens 30 % betragen.“</p>
 <p><span class="math display">\frac{\sum_{i\in G} x_i}{\sum_i x_i} \ge 0{,}3 \quad\Longleftrightarrow\quad \sum_{i\in G} x_i \ge 0{,}3\sum_i x_i</span></p>
@@ -30039,12 +31697,12 @@ T \ge \left(\frac{2\sigma}{\mu}\right)^2 = \left(\frac{2 \cdot 0{,}012}{0{,}0004
 <p><strong>Regel.</strong> „Entweder wir arbeiten mit diesem Lieferanten gar nicht, oder wir nehmen ihm im Jahr mindestens 500 Einheiten ab.“</p>
 <p>Ein <strong>Schalter für den ganzen Zeitraum</strong>, nicht je Periode:</p>
 <p><span class="math display">Q\,y \le \sum_{t} x_{t} \le U\,y, \qquad y \in \{0,1\},\ x_t \ge 0</span></p>
-<div class="sourceCode" id="cb251"><pre class="sourceCode python"><code class="sourceCode python"><span id="cb251-1"><a href="#cb251-1" aria-hidden="true" tabindex="-1"></a><span class="co"># y_s ist EINE Variable je Lieferant - nicht eine je Lieferant UND Periode</span></span>
-<span id="cb251-2"><a href="#cb251-2" aria-hidden="true" tabindex="-1"></a>y <span class="op">=</span> {s: modell.NewBoolVar(<span class="ss">f&quot;vertrag_</span><span class="sc">{</span>s<span class="sc">}</span><span class="ss">&quot;</span>) <span class="cf">for</span> s <span class="kw">in</span> lieferanten}</span>
-<span id="cb251-3"><a href="#cb251-3" aria-hidden="true" tabindex="-1"></a><span class="cf">for</span> s <span class="kw">in</span> lieferanten:</span>
-<span id="cb251-4"><a href="#cb251-4" aria-hidden="true" tabindex="-1"></a>    jahresmenge <span class="op">=</span> <span class="bu">sum</span>(x[s, t] <span class="cf">for</span> t <span class="kw">in</span> perioden)</span>
-<span id="cb251-5"><a href="#cb251-5" aria-hidden="true" tabindex="-1"></a>    modell.Add(jahresmenge <span class="op">&gt;=</span> MINDESTMENGE[s] <span class="op">*</span> y[s])</span>
-<span id="cb251-6"><a href="#cb251-6" aria-hidden="true" tabindex="-1"></a>    modell.Add(jahresmenge <span class="op">&lt;=</span> JAHRESKAPAZITAET[s] <span class="op">*</span> y[s])   <span class="co"># koppelt x an y</span></span></code></pre></div>
+<div class="sourceCode" id="cb255"><pre class="sourceCode python"><code class="sourceCode python"><span id="cb255-1"><a href="#cb255-1" aria-hidden="true" tabindex="-1"></a><span class="co"># y_s ist EINE Variable je Lieferant - nicht eine je Lieferant UND Periode</span></span>
+<span id="cb255-2"><a href="#cb255-2" aria-hidden="true" tabindex="-1"></a>y <span class="op">=</span> {s: modell.NewBoolVar(<span class="ss">f&quot;vertrag_</span><span class="sc">{</span>s<span class="sc">}</span><span class="ss">&quot;</span>) <span class="cf">for</span> s <span class="kw">in</span> lieferanten}</span>
+<span id="cb255-3"><a href="#cb255-3" aria-hidden="true" tabindex="-1"></a><span class="cf">for</span> s <span class="kw">in</span> lieferanten:</span>
+<span id="cb255-4"><a href="#cb255-4" aria-hidden="true" tabindex="-1"></a>    jahresmenge <span class="op">=</span> <span class="bu">sum</span>(x[s, t] <span class="cf">for</span> t <span class="kw">in</span> perioden)</span>
+<span id="cb255-5"><a href="#cb255-5" aria-hidden="true" tabindex="-1"></a>    modell.Add(jahresmenge <span class="op">&gt;=</span> MINDESTMENGE[s] <span class="op">*</span> y[s])</span>
+<span id="cb255-6"><a href="#cb255-6" aria-hidden="true" tabindex="-1"></a>    modell.Add(jahresmenge <span class="op">&lt;=</span> JAHRESKAPAZITAET[s] <span class="op">*</span> y[s])   <span class="co"># koppelt x an y</span></span></code></pre></div>
 <blockquote>
 <p>⚠️ <strong>Die häufigste Verwechslung:</strong> <span class="math inline">L\,y_t \le x_t</span> <strong>je Periode</strong> (B2) ist ein <em>anderes</em> Modell — es verlangt in jeder einzelnen Periode eine Mindestmenge und ist erheblich strenger. Wer den Jahresvertrag so formuliert, erzeugt ein unlösbares Modell und sucht den Fehler dann in den Daten.</p>
 </blockquote>
@@ -30055,11 +31713,11 @@ T \ge \left(\frac{2\sigma}{\mu}\right)^2 = \left(\frac{2 \cdot 0{,}012}{0{,}0004
 <p><strong>Regel.</strong> „Alle Maßnahmen zusammen dürfen 2 Mio. € nicht überschreiten.“</p>
 <p><span class="math display">\sum_i c_i x_i \le B</span></p>
 <p>Mit <span class="math inline">x_i \in \{0,1\}</span> ist das ein <strong>Rucksackproblem</strong> — dasselbe Muster, das <a href="#kap-milp">Kapitel 6</a> an <code>Rucksack.py</code> vorrechnet und <a href="#kap-dekomposition">Kapitel 10</a> als Pricing-Teilproblem wiederverwendet.</p>
-<div class="sourceCode" id="cb252"><pre class="sourceCode python"><code class="sourceCode python"><span id="cb252-1"><a href="#cb252-1" aria-hidden="true" tabindex="-1"></a>modell.Add(<span class="bu">sum</span>(KOSTEN[i] <span class="op">*</span> x[i] <span class="cf">for</span> i <span class="kw">in</span> massnahmen) <span class="op">&lt;=</span> BUDGET)</span>
-<span id="cb252-2"><a href="#cb252-2" aria-hidden="true" tabindex="-1"></a><span class="co"># Mehrere Toepfe: je Topf eine Zeile - NICHT die Summe ueber alle Toepfe</span></span>
-<span id="cb252-3"><a href="#cb252-3" aria-hidden="true" tabindex="-1"></a><span class="cf">for</span> topf, grenze <span class="kw">in</span> BUDGETS.items():</span>
-<span id="cb252-4"><a href="#cb252-4" aria-hidden="true" tabindex="-1"></a>    modell.Add(<span class="bu">sum</span>(KOSTEN[i] <span class="op">*</span> x[i] <span class="cf">for</span> i <span class="kw">in</span> massnahmen</span>
-<span id="cb252-5"><a href="#cb252-5" aria-hidden="true" tabindex="-1"></a>                   <span class="cf">if</span> TOPF[i] <span class="op">==</span> topf) <span class="op">&lt;=</span> grenze)</span></code></pre></div>
+<div class="sourceCode" id="cb256"><pre class="sourceCode python"><code class="sourceCode python"><span id="cb256-1"><a href="#cb256-1" aria-hidden="true" tabindex="-1"></a>modell.Add(<span class="bu">sum</span>(KOSTEN[i] <span class="op">*</span> x[i] <span class="cf">for</span> i <span class="kw">in</span> massnahmen) <span class="op">&lt;=</span> BUDGET)</span>
+<span id="cb256-2"><a href="#cb256-2" aria-hidden="true" tabindex="-1"></a><span class="co"># Mehrere Toepfe: je Topf eine Zeile - NICHT die Summe ueber alle Toepfe</span></span>
+<span id="cb256-3"><a href="#cb256-3" aria-hidden="true" tabindex="-1"></a><span class="cf">for</span> topf, grenze <span class="kw">in</span> BUDGETS.items():</span>
+<span id="cb256-4"><a href="#cb256-4" aria-hidden="true" tabindex="-1"></a>    modell.Add(<span class="bu">sum</span>(KOSTEN[i] <span class="op">*</span> x[i] <span class="cf">for</span> i <span class="kw">in</span> massnahmen</span>
+<span id="cb256-5"><a href="#cb256-5" aria-hidden="true" tabindex="-1"></a>                   <span class="cf">if</span> TOPF[i] <span class="op">==</span> topf) <span class="op">&lt;=</span> grenze)</span></code></pre></div>
 <blockquote>
 <p>💡 <strong>Der Schattenpreis des Budgets ist die Zahl, nach der die Geschäftsführung fragt:</strong> „Was bringt der nächste Euro?“ Bei einem <strong>LP</strong> ist er direkt ablesbar. Bei <strong>Ganzzahligkeit gibt es ihn nicht</strong> — die Dualwerte der Relaxation sind keine gültige Antwort. Rechnen Sie stattdessen mit erhöhtem Budget neu und vergleichen Sie die Zielwerte (<a href="#sec:lp-entartung">Abschnitt 5.9</a>).</p>
 </blockquote>
@@ -30074,16 +31732,16 @@ T \ge \left(\frac{2\sigma}{\mu}\right)^2 = \left(\frac{2 \cdot 0{,}012}{0{,}0004
 <p>Mit Mindestwartezeit <span class="math inline">w</span>: <span class="math inline">\text{start}_B \ge \text{ende}_A + w</span>.</p>
 <h3 id="b14-nichtüberlappung">B14 — Nichtüberlappung</h3>
 <p><strong>Regel.</strong> „Eine Maschine bearbeitet nur einen Job gleichzeitig.“</p>
-<div class="sourceCode" id="cb253"><pre class="sourceCode python"><code class="sourceCode python"><span id="cb253-1"><a href="#cb253-1" aria-hidden="true" tabindex="-1"></a>modell.AddNoOverlap([intervall_1, intervall_2, ...])</span></code></pre></div>
+<div class="sourceCode" id="cb257"><pre class="sourceCode python"><code class="sourceCode python"><span id="cb257-1"><a href="#cb257-1" aria-hidden="true" tabindex="-1"></a>modell.AddNoOverlap([intervall_1, intervall_2, ...])</span></code></pre></div>
 <p>In MILP bräuchte man je Paar eine Disjunktion (B4) — bei <span class="math inline">k</span> Jobs sind das <span class="math inline">\binom{k}{2}</span> Konstruktionen. <strong>Nehmen Sie hier CP-SAT.</strong></p>
 <h3 id="b15-kumulative-ressource">B15 — Kumulative Ressource</h3>
 <p><strong>Regel.</strong> „Zu keinem Zeitpunkt dürfen mehr als 3 Arbeiten gleichzeitig laufen“ bzw. „die Stromlast darf 500 kW nie übersteigen“.</p>
-<div class="sourceCode" id="cb254"><pre class="sourceCode python"><code class="sourceCode python"><span id="cb254-1"><a href="#cb254-1" aria-hidden="true" tabindex="-1"></a>modell.AddCumulative(intervalle, bedarfe, kapazitaet)</span></code></pre></div>
+<div class="sourceCode" id="cb258"><pre class="sourceCode python"><code class="sourceCode python"><span id="cb258-1"><a href="#cb258-1" aria-hidden="true" tabindex="-1"></a>modell.AddCumulative(intervalle, bedarfe, kapazitaet)</span></code></pre></div>
 <h3 id="b16-gleitendes-fenster">B16 — Gleitendes Fenster</h3>
 <p><strong>Regel.</strong> „Höchstens 5 Arbeitstage in Folge“ / „mindestens 2 freie Tage je Woche“.</p>
 <p><span class="math display">\sum_{u=t}^{t+5} x_u \le 5 \qquad \forall t</span></p>
-<div class="sourceCode" id="cb255"><pre class="sourceCode python"><code class="sourceCode python"><span id="cb255-1"><a href="#cb255-1" aria-hidden="true" tabindex="-1"></a><span class="cf">for</span> t <span class="kw">in</span> <span class="bu">range</span>(<span class="bu">len</span>(tage) <span class="op">-</span> <span class="dv">5</span>):</span>
-<span id="cb255-2"><a href="#cb255-2" aria-hidden="true" tabindex="-1"></a>    modell.Add(<span class="bu">sum</span>(x[p, u] <span class="cf">for</span> u <span class="kw">in</span> <span class="bu">range</span>(t, t <span class="op">+</span> <span class="dv">6</span>)) <span class="op">&lt;=</span> <span class="dv">5</span>)</span></code></pre></div>
+<div class="sourceCode" id="cb259"><pre class="sourceCode python"><code class="sourceCode python"><span id="cb259-1"><a href="#cb259-1" aria-hidden="true" tabindex="-1"></a><span class="cf">for</span> t <span class="kw">in</span> <span class="bu">range</span>(<span class="bu">len</span>(tage) <span class="op">-</span> <span class="dv">5</span>):</span>
+<span id="cb259-2"><a href="#cb259-2" aria-hidden="true" tabindex="-1"></a>    modell.Add(<span class="bu">sum</span>(x[p, u] <span class="cf">for</span> u <span class="kw">in</span> <span class="bu">range</span>(t, t <span class="op">+</span> <span class="dv">6</span>)) <span class="op">&lt;=</span> <span class="dv">5</span>)</span></code></pre></div>
 <h3 id="b17-umrüst--bzw.-wechselkosten">B17 — Umrüst- bzw. Wechselkosten</h3>
 <p><strong>Regel.</strong> „Ein Produktwechsel kostet Rüstzeit.“</p>
 <p>Hilfsvariable <span class="math inline">z_t \in \{0,1\}</span> = „in Periode <span class="math inline">t</span> wird gewechselt“:</p>
@@ -30094,9 +31752,9 @@ T \ge \left(\frac{2\sigma}{\mu}\right)^2 = \left(\frac{2 \cdot 0{,}012}{0{,}0004
 <p>B17 verbucht den Wechsel in der <em>Zielfunktion</em>. Sobald die Maschine ausgelastet ist, gehört er zusätzlich in die <em>Kapazitätszeile</em>:</p>
 <p><span class="math display">\sum_j a_j\,x_{j,t} \;+\; \sum_j r_j\,y_{j,t} \;\le\; C_t \qquad \forall t</span></p>
 <p>mit <span class="math inline">a_j</span> Stückzeit, <span class="math inline">r_j</span> Rüstzeit, <span class="math inline">y_{j,t}\in\{0,1\}</span> = „Produkt <span class="math inline">j</span> läuft in Periode <span class="math inline">t</span>“ (gekoppelt über B1: <span class="math inline">x_{j,t} \le M\,y_{j,t}</span>).</p>
-<div class="sourceCode" id="cb256"><pre class="sourceCode python"><code class="sourceCode python"><span id="cb256-1"><a href="#cb256-1" aria-hidden="true" tabindex="-1"></a><span class="cf">for</span> t <span class="kw">in</span> perioden:</span>
-<span id="cb256-2"><a href="#cb256-2" aria-hidden="true" tabindex="-1"></a>    modell.Add(<span class="bu">sum</span>(STUECKZEIT[j] <span class="op">*</span> x[j, t] <span class="cf">for</span> j <span class="kw">in</span> produkte)</span>
-<span id="cb256-3"><a href="#cb256-3" aria-hidden="true" tabindex="-1"></a>               <span class="op">+</span> <span class="bu">sum</span>(RUESTZEIT[j] <span class="op">*</span> y[j, t] <span class="cf">for</span> j <span class="kw">in</span> produkte) <span class="op">&lt;=</span> KAPAZITAET[t])</span></code></pre></div>
+<div class="sourceCode" id="cb260"><pre class="sourceCode python"><code class="sourceCode python"><span id="cb260-1"><a href="#cb260-1" aria-hidden="true" tabindex="-1"></a><span class="cf">for</span> t <span class="kw">in</span> perioden:</span>
+<span id="cb260-2"><a href="#cb260-2" aria-hidden="true" tabindex="-1"></a>    modell.Add(<span class="bu">sum</span>(STUECKZEIT[j] <span class="op">*</span> x[j, t] <span class="cf">for</span> j <span class="kw">in</span> produkte)</span>
+<span id="cb260-3"><a href="#cb260-3" aria-hidden="true" tabindex="-1"></a>               <span class="op">+</span> <span class="bu">sum</span>(RUESTZEIT[j] <span class="op">*</span> y[j, t] <span class="cf">for</span> j <span class="kw">in</span> produkte) <span class="op">&lt;=</span> KAPAZITAET[t])</span></code></pre></div>
 <blockquote>
 <p>⚠️ <strong>Wer die Rüstzeit nur als Kosten führt, erhält Pläne, die in der Halle nicht laufen.</strong> Das Modell verteilt die Produktion dann auf viele kleine Lose, weil ein zusätzlicher Wechsel zwar etwas kostet, aber keine Zeit verbraucht — die Rechnung geht auf dem Papier auf und in der Schicht nicht.</p>
 </blockquote>
@@ -30112,15 +31770,15 @@ T \ge \left(\frac{2\sigma}{\mu}\right)^2 = \left(\frac{2 \cdot 0{,}012}{0{,}0004
 <p><strong>Regel.</strong> „Erst die Besetzung sicherstellen, dann die Fairness optimieren.“</p>
 <p><strong>Variante A — Gewichtung:</strong> Strafen um Größenordnungen staffeln (<span class="math inline">10\,000 \gg 100 \gg 1</span>). Einfach, aber bei extremen Skalenunterschieden numerisch heikel.</p>
 <p><strong>Variante B — Zweistufig lösen (sauberer):</strong></p>
-<div class="sourceCode" id="cb257"><pre class="sourceCode python"><code class="sourceCode python"><span id="cb257-1"><a href="#cb257-1" aria-hidden="true" tabindex="-1"></a><span class="co"># Stufe 1: nur das Hauptziel</span></span>
-<span id="cb257-2"><a href="#cb257-2" aria-hidden="true" tabindex="-1"></a>modell.Minimize(unbesetzte_schichten)</span>
-<span id="cb257-3"><a href="#cb257-3" aria-hidden="true" tabindex="-1"></a>loeser.Solve(modell)</span>
-<span id="cb257-4"><a href="#cb257-4" aria-hidden="true" tabindex="-1"></a>bestwert <span class="op">=</span> loeser.ObjectiveValue()</span>
-<span id="cb257-5"><a href="#cb257-5" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb257-6"><a href="#cb257-6" aria-hidden="true" tabindex="-1"></a><span class="co"># Stufe 2: Hauptziel fixieren, Nebenziel optimieren</span></span>
-<span id="cb257-7"><a href="#cb257-7" aria-hidden="true" tabindex="-1"></a>modell.Add(unbesetzte_schichten <span class="op">&lt;=</span> <span class="bu">int</span>(bestwert))</span>
-<span id="cb257-8"><a href="#cb257-8" aria-hidden="true" tabindex="-1"></a>modell.Minimize(unfairness)</span>
-<span id="cb257-9"><a href="#cb257-9" aria-hidden="true" tabindex="-1"></a>loeser.Solve(modell)</span></code></pre></div>
+<div class="sourceCode" id="cb261"><pre class="sourceCode python"><code class="sourceCode python"><span id="cb261-1"><a href="#cb261-1" aria-hidden="true" tabindex="-1"></a><span class="co"># Stufe 1: nur das Hauptziel</span></span>
+<span id="cb261-2"><a href="#cb261-2" aria-hidden="true" tabindex="-1"></a>modell.Minimize(unbesetzte_schichten)</span>
+<span id="cb261-3"><a href="#cb261-3" aria-hidden="true" tabindex="-1"></a>loeser.Solve(modell)</span>
+<span id="cb261-4"><a href="#cb261-4" aria-hidden="true" tabindex="-1"></a>bestwert <span class="op">=</span> loeser.ObjectiveValue()</span>
+<span id="cb261-5"><a href="#cb261-5" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb261-6"><a href="#cb261-6" aria-hidden="true" tabindex="-1"></a><span class="co"># Stufe 2: Hauptziel fixieren, Nebenziel optimieren</span></span>
+<span id="cb261-7"><a href="#cb261-7" aria-hidden="true" tabindex="-1"></a>modell.Add(unbesetzte_schichten <span class="op">&lt;=</span> <span class="bu">int</span>(bestwert))</span>
+<span id="cb261-8"><a href="#cb261-8" aria-hidden="true" tabindex="-1"></a>modell.Minimize(unfairness)</span>
+<span id="cb261-9"><a href="#cb261-9" aria-hidden="true" tabindex="-1"></a>loeser.Solve(modell)</span></code></pre></div>
 <h3 id="b20-symmetriebrechung">B20 — Symmetriebrechung</h3>
 <p><strong>Regel.</strong> „Drei identische Maschinen — der Solver soll nicht alle Vertauschungen durchprobieren.“</p>
 <p><span class="math display">\text{start}_1 \le \text{start}_2 \le \text{start}_3 \qquad\text{bzw.}\qquad \sum_j x_{1j} \ge \sum_j x_{2j}</span></p>
@@ -30129,7 +31787,7 @@ T \ge \left(\frac{2\sigma}{\mu}\right)^2 = \left(\frac{2 \cdot 0{,}012}{0{,}0004
 <p><strong>Regel.</strong> „Rechne nicht mit dem geschätzten Wert, sondern mit dem ungünstigsten plausiblen.“</p>
 <p>Bei Box-Unsicherheit <span class="math inline">\mu_i \in [\hat\mu_i - \delta_i, \hat\mu_i + \delta_i]</span> und <span class="math inline">w \ge 0</span>: <span class="math display">\hat{\boldsymbol{\mu}}^\top\mathbf{w} \;\longrightarrow\; \hat{\boldsymbol{\mu}}^\top\mathbf{w} - \boldsymbol{\delta}^\top\mathbf{w}</span></p>
 <p>Abgestuft (Bertsimas/Sim): nur die <span class="math inline">\Gamma</span> ungünstigsten gleichzeitig:</p>
-<div class="sourceCode" id="cb258"><pre class="sourceCode python"><code class="sourceCode python"><span id="cb258-1"><a href="#cb258-1" aria-hidden="true" tabindex="-1"></a>abzug <span class="op">=</span> cp.sum_largest(cp.multiply(delta, w), Gamma)</span></code></pre></div>
+<div class="sourceCode" id="cb262"><pre class="sourceCode python"><code class="sourceCode python"><span id="cb262-1"><a href="#cb262-1" aria-hidden="true" tabindex="-1"></a>abzug <span class="op">=</span> cp.sum_largest(cp.multiply(delta, w), Gamma)</span></code></pre></div>
 <hr />
 <h2 id="netzwerke">Netzwerke</h2>
 <h3 id="b22-flusserhaltung">B22 — Flusserhaltung</h3>
@@ -30229,22 +31887,22 @@ T \ge \left(\frac{2\sigma}{\mu}\right)^2 = \left(\frac{2 \cdot 0{,}012}{0{,}0004
 <p><strong>Bedeutung.</strong> Es gibt <strong>keinen einzigen Punkt</strong>, der alle Bedingungen gleichzeitig erfüllt. Das ist eine Aussage über Ihr Modell, nicht über den Solver.</p>
 <h3 id="diagnose-in-fünf-schritten">Diagnose in fünf Schritten</h3>
 <p><strong>Schritt 1 — Trivialprüfungen von Hand.</strong> Rechnen Sie die offensichtlichen Bilanzen nach, <strong>bevor</strong> Sie den Solver befragen:</p>
-<div class="sourceCode" id="cb259"><pre class="sourceCode python"><code class="sourceCode python"><span id="cb259-1"><a href="#cb259-1" aria-hidden="true" tabindex="-1"></a><span class="cf">assert</span> summe_angebot <span class="op">&gt;=</span> summe_bedarf, <span class="st">&quot;Angebot deckt Bedarf nicht&quot;</span></span>
-<span id="cb259-2"><a href="#cb259-2" aria-hidden="true" tabindex="-1"></a><span class="cf">assert</span> anzahl_personal <span class="op">*</span> max_schichten <span class="op">&gt;=</span> anzahl_schichten, <span class="st">&quot;zu wenig Personal&quot;</span></span>
-<span id="cb259-3"><a href="#cb259-3" aria-hidden="true" tabindex="-1"></a><span class="cf">for</span> slot, fach <span class="kw">in</span> <span class="bu">enumerate</span>(faecher):</span>
-<span id="cb259-4"><a href="#cb259-4" aria-hidden="true" tabindex="-1"></a>    qualifiziert <span class="op">=</span> [p <span class="cf">for</span> p <span class="kw">in</span> personal <span class="cf">if</span> fach <span class="kw">in</span> qualifikation[p]]</span>
-<span id="cb259-5"><a href="#cb259-5" aria-hidden="true" tabindex="-1"></a>    <span class="cf">assert</span> qualifiziert, <span class="ss">f&quot;Fuer Slot </span><span class="sc">{</span>slot<span class="sc">}</span><span class="ss"> (</span><span class="sc">{</span>fach<span class="sc">}</span><span class="ss">) gibt es niemanden&quot;</span></span></code></pre></div>
+<div class="sourceCode" id="cb263"><pre class="sourceCode python"><code class="sourceCode python"><span id="cb263-1"><a href="#cb263-1" aria-hidden="true" tabindex="-1"></a><span class="cf">assert</span> summe_angebot <span class="op">&gt;=</span> summe_bedarf, <span class="st">&quot;Angebot deckt Bedarf nicht&quot;</span></span>
+<span id="cb263-2"><a href="#cb263-2" aria-hidden="true" tabindex="-1"></a><span class="cf">assert</span> anzahl_personal <span class="op">*</span> max_schichten <span class="op">&gt;=</span> anzahl_schichten, <span class="st">&quot;zu wenig Personal&quot;</span></span>
+<span id="cb263-3"><a href="#cb263-3" aria-hidden="true" tabindex="-1"></a><span class="cf">for</span> slot, fach <span class="kw">in</span> <span class="bu">enumerate</span>(faecher):</span>
+<span id="cb263-4"><a href="#cb263-4" aria-hidden="true" tabindex="-1"></a>    qualifiziert <span class="op">=</span> [p <span class="cf">for</span> p <span class="kw">in</span> personal <span class="cf">if</span> fach <span class="kw">in</span> qualifikation[p]]</span>
+<span id="cb263-5"><a href="#cb263-5" aria-hidden="true" tabindex="-1"></a>    <span class="cf">assert</span> qualifiziert, <span class="ss">f&quot;Fuer Slot </span><span class="sc">{</span>slot<span class="sc">}</span><span class="ss"> (</span><span class="sc">{</span>fach<span class="sc">}</span><span class="ss">) gibt es niemanden&quot;</span></span></code></pre></div>
 <p>Erfahrungsgemäß findet dieser Schritt <strong>die Mehrzahl</strong> aller Fälle.</p>
 <p><strong>Schritt 2 — Bedingungen einzeln abschalten.</strong> Kommentieren Sie Bedingungsgruppen nacheinander aus. Wird das Modell lösbar, ist die zuletzt entfernte Gruppe (mit-)verantwortlich.</p>
 <p><strong>Schritt 3 — Schlupfvariablen einbauen (das wirksamste Mittel).</strong></p>
-<div class="sourceCode" id="cb260"><pre class="sourceCode python"><code class="sourceCode python"><span id="cb260-1"><a href="#cb260-1" aria-hidden="true" tabindex="-1"></a><span class="co"># statt:  modell.Add(bedingung)</span></span>
-<span id="cb260-2"><a href="#cb260-2" aria-hidden="true" tabindex="-1"></a>schlupf <span class="op">=</span> modell.NewIntVar(<span class="dv">0</span>, obergrenze, <span class="ss">f&quot;schlupf_</span><span class="sc">{</span>name<span class="sc">}</span><span class="ss">&quot;</span>)</span>
-<span id="cb260-3"><a href="#cb260-3" aria-hidden="true" tabindex="-1"></a>modell.Add(linke_seite <span class="op">&lt;=</span> rechte_seite <span class="op">+</span> schlupf)</span>
-<span id="cb260-4"><a href="#cb260-4" aria-hidden="true" tabindex="-1"></a>strafen.append(<span class="dv">10_000</span> <span class="op">*</span> schlupf)</span></code></pre></div>
+<div class="sourceCode" id="cb264"><pre class="sourceCode python"><code class="sourceCode python"><span id="cb264-1"><a href="#cb264-1" aria-hidden="true" tabindex="-1"></a><span class="co"># statt:  modell.Add(bedingung)</span></span>
+<span id="cb264-2"><a href="#cb264-2" aria-hidden="true" tabindex="-1"></a>schlupf <span class="op">=</span> modell.NewIntVar(<span class="dv">0</span>, obergrenze, <span class="ss">f&quot;schlupf_</span><span class="sc">{</span>name<span class="sc">}</span><span class="ss">&quot;</span>)</span>
+<span id="cb264-3"><a href="#cb264-3" aria-hidden="true" tabindex="-1"></a>modell.Add(linke_seite <span class="op">&lt;=</span> rechte_seite <span class="op">+</span> schlupf)</span>
+<span id="cb264-4"><a href="#cb264-4" aria-hidden="true" tabindex="-1"></a>strafen.append(<span class="dv">10_000</span> <span class="op">*</span> schlupf)</span></code></pre></div>
 <p>Nach dem Lösen zeigen die Schlupfvariablen mit Wert &gt; 0 <strong>präzise, welche Bedingung</strong> wo und um wie viel verletzt werden musste. Das ist zugleich die produktionstaugliche Lösung (Muster B18).</p>
 <p><strong>Schritt 4 — Zeitfenster und Erreichbarkeit prüfen.</strong> Bei Scheduling und Routing: Ist jeder Termin überhaupt physisch erreichbar?</p>
-<div class="sourceCode" id="cb261"><pre class="sourceCode python"><code class="sourceCode python"><span id="cb261-1"><a href="#cb261-1" aria-hidden="true" tabindex="-1"></a><span class="cf">for</span> kunde, (frueh, spaet) <span class="kw">in</span> <span class="bu">enumerate</span>(zeitfenster):</span>
-<span id="cb261-2"><a href="#cb261-2" aria-hidden="true" tabindex="-1"></a>    <span class="cf">assert</span> distanz[depot][kunde] <span class="op">&lt;=</span> spaet, <span class="ss">f&quot;Kunde </span><span class="sc">{</span>kunde<span class="sc">}</span><span class="ss"> nicht rechtzeitig erreichbar&quot;</span></span></code></pre></div>
+<div class="sourceCode" id="cb265"><pre class="sourceCode python"><code class="sourceCode python"><span id="cb265-1"><a href="#cb265-1" aria-hidden="true" tabindex="-1"></a><span class="cf">for</span> kunde, (frueh, spaet) <span class="kw">in</span> <span class="bu">enumerate</span>(zeitfenster):</span>
+<span id="cb265-2"><a href="#cb265-2" aria-hidden="true" tabindex="-1"></a>    <span class="cf">assert</span> distanz[depot][kunde] <span class="op">&lt;=</span> spaet, <span class="ss">f&quot;Kunde </span><span class="sc">{</span>kunde<span class="sc">}</span><span class="ss"> nicht rechtzeitig erreichbar&quot;</span></span></code></pre></div>
 <p><strong>Schritt 5 — Rundungs- und Einheitenfehler.</strong> Sind Kapazitäten in Stunden, Verbräuche aber in Minuten? Rechnen CP-SAT-Modelle mit ganzen Zahlen, wo Sie Nachkommastellen brauchen? Ein klassischer Fall: <code>sum(w) == 1</code> mit Gleitkommazahlen — nutzen Sie eine Toleranz oder rechnen Sie in Ganzzahlen (Promille).</p>
 <h3 id="wenn-die-fünf-schritte-nicht-reichen-den-konflikt-einkreisen">Wenn die fünf Schritte nicht reichen: den Konflikt einkreisen</h3>
 <p><strong>Warum Schritt 2 so oft ins Leere läuft.</strong> Bedingungen einzeln abzuschalten funktioniert nur, solange es <em>einen</em> Schuldigen gibt. Überlagern sich zwei unabhängige Widersprüche, bleibt das Modell nach jeder einzelnen Abschaltung unlösbar — die Suche endet mit null Treffern, obwohl beide Widersprüche unverändert im Modell stehen. Genau dann steht man vor einem Modell mit tausenden Restriktionen und einem Statuscode.</p>
@@ -30253,231 +31911,231 @@ T \ge \left(\frac{2\sigma}{\mu}\right)^2 = \left(\frac{2 \cdot 0{,}012}{0{,}0004
 <p>Nimm eine Bedingung versuchsweise heraus. Bleibt der Rest unlösbar, wurde sie nicht gebraucht: weg damit, endgültig. Wird der Rest lösbar, war sie beteiligt: sie bleibt.</p>
 </blockquote>
 <p>Nach genau einem Durchlauf über alle <span class="math inline">n</span> Bedingungen ist die übrig gebliebene Menge <strong>unreduzierbar</strong> — entfernt man aus ihr irgendeine Bedingung, ist der Rest lösbar. Das ist ein <em>Irreducible Infeasible Subset</em>, kurz IIS. Kommerzielle Solver bieten das als fertige Funktion an (<code>computeIIS</code> bei Gurobi, der Conflict Refiner bei CPLEX); im Open-Source-Werkzeugkasten dieses Buchs gibt es sie nicht — sie ist aber in zwanzig Zeilen selbst geschrieben, und sie kostet <span class="math inline">n</span> Aufrufe des Solvers statt <span class="math inline">2^n</span> durchprobierter Teilmengen.</p>
-<div class="sourceCode" id="cb262"><pre class="sourceCode python"><code class="sourceCode python"><span id="cb262-1"><a href="#cb262-1" aria-hidden="true" tabindex="-1"></a><span class="co">#!/usr/bin/env python3</span></span>
-<span id="cb262-2"><a href="#cb262-2" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb262-3"><a href="#cb262-3" aria-hidden="true" tabindex="-1"></a><span class="co"># Konfliktsuche.py</span></span>
-<span id="cb262-4"><a href="#cb262-4" aria-hidden="true" tabindex="-1"></a><span class="co">&quot;&quot;&quot;</span></span>
-<span id="cb262-5"><a href="#cb262-5" aria-hidden="true" tabindex="-1"></a><span class="co">Anhang Fehlerdiagnose: Den Konflikt finden, der INFEASIBLE verursacht.</span></span>
-<span id="cb262-6"><a href="#cb262-6" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb262-7"><a href="#cb262-7" aria-hidden="true" tabindex="-1"></a><span class="co">Ein Deletion Filter (auch: IIS, Irreducible Infeasible Subset) isoliert aus</span></span>
-<span id="cb262-8"><a href="#cb262-8" aria-hidden="true" tabindex="-1"></a><span class="co">einem unloesbaren Modell eine kleinste widerspruechliche Teilmenge von</span></span>
-<span id="cb262-9"><a href="#cb262-9" aria-hidden="true" tabindex="-1"></a><span class="co">Bedingungen: Nimmt man aus ihr auch nur eine einzige Bedingung heraus, ist</span></span>
-<span id="cb262-10"><a href="#cb262-10" aria-hidden="true" tabindex="-1"></a><span class="co">der Rest wieder loesbar.</span></span>
-<span id="cb262-11"><a href="#cb262-11" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb262-12"><a href="#cb262-12" aria-hidden="true" tabindex="-1"></a><span class="co">Das Programm zeigt sechs Dinge:</span></span>
-<span id="cb262-13"><a href="#cb262-13" aria-hidden="true" tabindex="-1"></a><span class="co">  1. Der Solver meldet INFEASIBLE - und sonst nichts.</span></span>
-<span id="cb262-14"><a href="#cb262-14" aria-hidden="true" tabindex="-1"></a><span class="co">  2. Die naive Suche (&quot;jede Bedingung einmal weglassen&quot;) findet hier gar nichts.</span></span>
-<span id="cb262-15"><a href="#cb262-15" aria-hidden="true" tabindex="-1"></a><span class="co">  3. Der Deletion Filter findet einen Konflikt in n Solveraufrufen.</span></span>
-<span id="cb262-16"><a href="#cb262-16" aria-hidden="true" tabindex="-1"></a><span class="co">  4. Ein Konflikt ist selten einer: nach der Reparatur folgt der naechste.</span></span>
-<span id="cb262-17"><a href="#cb262-17" aria-hidden="true" tabindex="-1"></a><span class="co">  5. &quot;Den&quot; kleinsten Konflikt gibt es nicht - dieses Modell enthaelt neun.</span></span>
-<span id="cb262-18"><a href="#cb262-18" aria-hidden="true" tabindex="-1"></a><span class="co">  6. Welchen davon man zu sehen bekommt, steuert die Pruefreihenfolge.</span></span>
-<span id="cb262-19"><a href="#cb262-19" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb262-20"><a href="#cb262-20" aria-hidden="true" tabindex="-1"></a><span class="co">Abgrenzung zu Infeasibility_Diagnose.py (Kapitel Praxisfallen): Dort geht es</span></span>
-<span id="cb262-21"><a href="#cb262-21" aria-hidden="true" tabindex="-1"></a><span class="co">um die Relaxation - das Modell soll trotz Widerspruch eine brauchbare Antwort</span></span>
-<span id="cb262-22"><a href="#cb262-22" aria-hidden="true" tabindex="-1"></a><span class="co">liefern. Hier geht es um die Diagnose - welche Bedingungen widersprechen sich</span></span>
-<span id="cb262-23"><a href="#cb262-23" aria-hidden="true" tabindex="-1"></a><span class="co">ueberhaupt. Beides zusammen ergibt den Umgang mit INFEASIBLE in Produktion.</span></span>
-<span id="cb262-24"><a href="#cb262-24" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb262-25"><a href="#cb262-25" aria-hidden="true" tabindex="-1"></a><span class="co">Benoetigt: numpy, scipy</span></span>
-<span id="cb262-26"><a href="#cb262-26" aria-hidden="true" tabindex="-1"></a><span class="co">&quot;&quot;&quot;</span></span>
-<span id="cb262-27"><a href="#cb262-27" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb262-28"><a href="#cb262-28" aria-hidden="true" tabindex="-1"></a><span class="im">from</span> __future__ <span class="im">import</span> annotations</span>
-<span id="cb262-29"><a href="#cb262-29" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb262-30"><a href="#cb262-30" aria-hidden="true" tabindex="-1"></a><span class="im">import</span> numpy <span class="im">as</span> np</span>
-<span id="cb262-31"><a href="#cb262-31" aria-hidden="true" tabindex="-1"></a><span class="im">from</span> scipy.optimize <span class="im">import</span> linprog</span>
-<span id="cb262-32"><a href="#cb262-32" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb262-33"><a href="#cb262-33" aria-hidden="true" tabindex="-1"></a>PRODUKTE <span class="op">=</span> [<span class="st">&quot;Rahmen&quot;</span>, <span class="st">&quot;Gehaeuse&quot;</span>, <span class="st">&quot;Deckel&quot;</span>, <span class="st">&quot;Traeger&quot;</span>, <span class="st">&quot;Halter&quot;</span>]</span>
-<span id="cb262-34"><a href="#cb262-34" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb262-35"><a href="#cb262-35" aria-hidden="true" tabindex="-1"></a><span class="co"># Jede Bedingung traegt einen sprechenden Namen - das ist keine Kosmetik,</span></span>
-<span id="cb262-36"><a href="#cb262-36" aria-hidden="true" tabindex="-1"></a><span class="co"># sondern die Voraussetzung dafuer, dass der Befund lesbar wird.</span></span>
-<span id="cb262-37"><a href="#cb262-37" aria-hidden="true" tabindex="-1"></a><span class="co"># (Name, Koeffizienten je Produkt, Richtung, rechte Seite)</span></span>
-<span id="cb262-38"><a href="#cb262-38" aria-hidden="true" tabindex="-1"></a>BEDINGUNGEN: <span class="bu">list</span>[<span class="bu">tuple</span>[<span class="bu">str</span>, <span class="bu">list</span>[<span class="bu">float</span>], <span class="bu">str</span>, <span class="bu">float</span>]] <span class="op">=</span> [</span>
-<span id="cb262-39"><a href="#cb262-39" aria-hidden="true" tabindex="-1"></a>    (<span class="st">&quot;Kapazitaet Montage&quot;</span>,       [<span class="dv">3</span>, <span class="dv">2</span>, <span class="dv">1</span>, <span class="dv">4</span>, <span class="dv">2</span>],      <span class="st">&quot;&lt;=&quot;</span>,   <span class="dv">400</span>),</span>
-<span id="cb262-40"><a href="#cb262-40" aria-hidden="true" tabindex="-1"></a>    (<span class="st">&quot;Kapazitaet Lackieren&quot;</span>,     [<span class="dv">2</span>, <span class="dv">3</span>, <span class="dv">0</span>, <span class="dv">1</span>, <span class="dv">0</span>],      <span class="st">&quot;&lt;=&quot;</span>,   <span class="dv">150</span>),</span>
-<span id="cb262-41"><a href="#cb262-41" aria-hidden="true" tabindex="-1"></a>    (<span class="st">&quot;Kapazitaet Pruefung&quot;</span>,      [<span class="dv">1</span>, <span class="dv">1</span>, <span class="dv">1</span>, <span class="dv">1</span>, <span class="dv">1</span>],      <span class="st">&quot;&lt;=&quot;</span>,   <span class="dv">300</span>),</span>
-<span id="cb262-42"><a href="#cb262-42" aria-hidden="true" tabindex="-1"></a>    (<span class="st">&quot;Liefervertrag Rahmen&quot;</span>,     [<span class="dv">1</span>, <span class="dv">0</span>, <span class="dv">0</span>, <span class="dv">0</span>, <span class="dv">0</span>],      <span class="st">&quot;&gt;=&quot;</span>,    <span class="dv">40</span>),</span>
-<span id="cb262-43"><a href="#cb262-43" aria-hidden="true" tabindex="-1"></a>    (<span class="st">&quot;Liefervertrag Gehaeuse&quot;</span>,   [<span class="dv">0</span>, <span class="dv">1</span>, <span class="dv">0</span>, <span class="dv">0</span>, <span class="dv">0</span>],      <span class="st">&quot;&gt;=&quot;</span>,    <span class="dv">30</span>),</span>
-<span id="cb262-44"><a href="#cb262-44" aria-hidden="true" tabindex="-1"></a>    (<span class="st">&quot;Liefervertrag Deckel&quot;</span>,     [<span class="dv">0</span>, <span class="dv">0</span>, <span class="dv">1</span>, <span class="dv">0</span>, <span class="dv">0</span>],      <span class="st">&quot;&gt;=&quot;</span>,    <span class="dv">20</span>),</span>
-<span id="cb262-45"><a href="#cb262-45" aria-hidden="true" tabindex="-1"></a>    (<span class="st">&quot;Liefervertrag Traeger&quot;</span>,    [<span class="dv">0</span>, <span class="dv">0</span>, <span class="dv">0</span>, <span class="dv">1</span>, <span class="dv">0</span>],      <span class="st">&quot;&gt;=&quot;</span>,    <span class="dv">25</span>),</span>
-<span id="cb262-46"><a href="#cb262-46" aria-hidden="true" tabindex="-1"></a>    (<span class="st">&quot;Marktgrenze Rahmen&quot;</span>,       [<span class="dv">1</span>, <span class="dv">0</span>, <span class="dv">0</span>, <span class="dv">0</span>, <span class="dv">0</span>],      <span class="st">&quot;&lt;=&quot;</span>,   <span class="dv">120</span>),</span>
-<span id="cb262-47"><a href="#cb262-47" aria-hidden="true" tabindex="-1"></a>    (<span class="st">&quot;Marktgrenze Gehaeuse&quot;</span>,     [<span class="dv">0</span>, <span class="dv">1</span>, <span class="dv">0</span>, <span class="dv">0</span>, <span class="dv">0</span>],      <span class="st">&quot;&lt;=&quot;</span>,    <span class="dv">90</span>),</span>
-<span id="cb262-48"><a href="#cb262-48" aria-hidden="true" tabindex="-1"></a>    (<span class="st">&quot;Marktgrenze Deckel&quot;</span>,       [<span class="dv">0</span>, <span class="dv">0</span>, <span class="dv">1</span>, <span class="dv">0</span>, <span class="dv">0</span>],      <span class="st">&quot;&lt;=&quot;</span>,   <span class="dv">150</span>),</span>
-<span id="cb262-49"><a href="#cb262-49" aria-hidden="true" tabindex="-1"></a>    (<span class="st">&quot;Marktgrenze Halter&quot;</span>,       [<span class="dv">0</span>, <span class="dv">0</span>, <span class="dv">0</span>, <span class="dv">0</span>, <span class="dv">1</span>],      <span class="st">&quot;&lt;=&quot;</span>,   <span class="dv">200</span>),</span>
-<span id="cb262-50"><a href="#cb262-50" aria-hidden="true" tabindex="-1"></a>    (<span class="st">&quot;Mindestumsatz&quot;</span>,            [<span class="dv">90</span>, <span class="dv">70</span>, <span class="dv">30</span>, <span class="dv">60</span>, <span class="dv">20</span>], <span class="st">&quot;&gt;=&quot;</span>, <span class="dv">12000</span>),</span>
-<span id="cb262-51"><a href="#cb262-51" aria-hidden="true" tabindex="-1"></a>    (<span class="st">&quot;Sortimentsbreite&quot;</span>,         [<span class="dv">0</span>, <span class="dv">0</span>, <span class="dv">1</span>, <span class="dv">1</span>, <span class="dv">1</span>],      <span class="st">&quot;&gt;=&quot;</span>,   <span class="dv">100</span>),</span>
-<span id="cb262-52"><a href="#cb262-52" aria-hidden="true" tabindex="-1"></a>    (<span class="st">&quot;Lackierbudget Schicht 2&quot;</span>,  [<span class="dv">0</span>, <span class="dv">1</span>, <span class="dv">0</span>, <span class="dv">1</span>, <span class="dv">0</span>],      <span class="st">&quot;&lt;=&quot;</span>,    <span class="dv">55</span>),</span>
-<span id="cb262-53"><a href="#cb262-53" aria-hidden="true" tabindex="-1"></a>]</span>
-<span id="cb262-54"><a href="#cb262-54" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb262-55"><a href="#cb262-55" aria-hidden="true" tabindex="-1"></a><span class="co"># Welche Bedingungen koennte ein Planer im Ernstfall wirklich veraendern?</span></span>
-<span id="cb262-56"><a href="#cb262-56" aria-hidden="true" tabindex="-1"></a><span class="co"># Kapazitaeten lassen sich durch Sonderschichten dehnen, Liefervertraege und</span></span>
-<span id="cb262-57"><a href="#cb262-57" aria-hidden="true" tabindex="-1"></a><span class="co"># Marktgrenzen nicht.</span></span>
-<span id="cb262-58"><a href="#cb262-58" aria-hidden="true" tabindex="-1"></a>VERHANDELBAR <span class="op">=</span> {<span class="st">&quot;Kapazitaet Montage&quot;</span>, <span class="st">&quot;Kapazitaet Lackieren&quot;</span>,</span>
-<span id="cb262-59"><a href="#cb262-59" aria-hidden="true" tabindex="-1"></a>                <span class="st">&quot;Kapazitaet Pruefung&quot;</span>, <span class="st">&quot;Lackierbudget Schicht 2&quot;</span>}</span>
-<span id="cb262-60"><a href="#cb262-60" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb262-61"><a href="#cb262-61" aria-hidden="true" tabindex="-1"></a>aufrufe <span class="op">=</span> <span class="dv">0</span>          <span class="co"># zaehlt jeden Solveraufruf mit - der Preis des Verfahrens</span></span>
-<span id="cb262-62"><a href="#cb262-62" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb262-63"><a href="#cb262-63" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb262-64"><a href="#cb262-64" aria-hidden="true" tabindex="-1"></a><span class="kw">def</span> ist_loesbar(auswahl: <span class="bu">list</span>[<span class="bu">int</span>]) <span class="op">-&gt;</span> <span class="bu">bool</span>:</span>
-<span id="cb262-65"><a href="#cb262-65" aria-hidden="true" tabindex="-1"></a>    <span class="co">&quot;&quot;&quot;Gibt es einen Punkt, der ALLE Bedingungen aus &#39;auswahl&#39; erfuellt?</span></span>
-<span id="cb262-66"><a href="#cb262-66" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb262-67"><a href="#cb262-67" aria-hidden="true" tabindex="-1"></a><span class="co">    Es wird nur Zulaessigkeit geprueft, keine Zielfunktion optimiert: die</span></span>
-<span id="cb262-68"><a href="#cb262-68" aria-hidden="true" tabindex="-1"></a><span class="co">    Zielfunktion ist konstant null. INFEASIBLE haengt nie an der Zielfunktion.</span></span>
-<span id="cb262-69"><a href="#cb262-69" aria-hidden="true" tabindex="-1"></a><span class="co">    &quot;&quot;&quot;</span></span>
-<span id="cb262-70"><a href="#cb262-70" aria-hidden="true" tabindex="-1"></a>    <span class="kw">global</span> aufrufe</span>
-<span id="cb262-71"><a href="#cb262-71" aria-hidden="true" tabindex="-1"></a>    aufrufe <span class="op">+=</span> <span class="dv">1</span></span>
-<span id="cb262-72"><a href="#cb262-72" aria-hidden="true" tabindex="-1"></a>    matrix, rechte_seite <span class="op">=</span> [], []</span>
-<span id="cb262-73"><a href="#cb262-73" aria-hidden="true" tabindex="-1"></a>    <span class="cf">for</span> i <span class="kw">in</span> auswahl:</span>
-<span id="cb262-74"><a href="#cb262-74" aria-hidden="true" tabindex="-1"></a>        _, koeffizienten, richtung, grenze <span class="op">=</span> BEDINGUNGEN[i]</span>
-<span id="cb262-75"><a href="#cb262-75" aria-hidden="true" tabindex="-1"></a>        zeile <span class="op">=</span> np.array(koeffizienten, dtype<span class="op">=</span><span class="bu">float</span>)</span>
-<span id="cb262-76"><a href="#cb262-76" aria-hidden="true" tabindex="-1"></a>        <span class="co"># linprog kennt nur &quot;&lt;=&quot;, also &quot;&gt;=&quot; durch Negation umdrehen</span></span>
-<span id="cb262-77"><a href="#cb262-77" aria-hidden="true" tabindex="-1"></a>        matrix.append(zeile <span class="cf">if</span> richtung <span class="op">==</span> <span class="st">&quot;&lt;=&quot;</span> <span class="cf">else</span> <span class="op">-</span>zeile)</span>
-<span id="cb262-78"><a href="#cb262-78" aria-hidden="true" tabindex="-1"></a>        rechte_seite.append(grenze <span class="cf">if</span> richtung <span class="op">==</span> <span class="st">&quot;&lt;=&quot;</span> <span class="cf">else</span> <span class="op">-</span>grenze)</span>
-<span id="cb262-79"><a href="#cb262-79" aria-hidden="true" tabindex="-1"></a>    ergebnis <span class="op">=</span> linprog(np.zeros(<span class="bu">len</span>(PRODUKTE)),</span>
-<span id="cb262-80"><a href="#cb262-80" aria-hidden="true" tabindex="-1"></a>                       A_ub<span class="op">=</span>np.array(matrix), b_ub<span class="op">=</span>np.array(rechte_seite),</span>
-<span id="cb262-81"><a href="#cb262-81" aria-hidden="true" tabindex="-1"></a>                       bounds<span class="op">=</span>(<span class="dv">0</span>, <span class="va">None</span>), method<span class="op">=</span><span class="st">&quot;highs&quot;</span>)</span>
-<span id="cb262-82"><a href="#cb262-82" aria-hidden="true" tabindex="-1"></a>    <span class="cf">return</span> ergebnis.status <span class="op">==</span> <span class="dv">0</span></span>
-<span id="cb262-83"><a href="#cb262-83" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb262-84"><a href="#cb262-84" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb262-85"><a href="#cb262-85" aria-hidden="true" tabindex="-1"></a><span class="kw">def</span> deletion_filter(auswahl: <span class="bu">list</span>[<span class="bu">int</span>]) <span class="op">-&gt;</span> <span class="bu">list</span>[<span class="bu">int</span>]:</span>
-<span id="cb262-86"><a href="#cb262-86" aria-hidden="true" tabindex="-1"></a>    <span class="co">&quot;&quot;&quot;Verkleinert eine unloesbare Menge zu einer kleinsten unloesbaren Menge.</span></span>
-<span id="cb262-87"><a href="#cb262-87" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb262-88"><a href="#cb262-88" aria-hidden="true" tabindex="-1"></a><span class="co">    Der Kern des Verfahrens ist eine einzige Regel: Nimm eine Bedingung</span></span>
-<span id="cb262-89"><a href="#cb262-89" aria-hidden="true" tabindex="-1"></a><span class="co">    versuchsweise heraus. Bleibt der Rest unloesbar, wurde sie fuer den</span></span>
-<span id="cb262-90"><a href="#cb262-90" aria-hidden="true" tabindex="-1"></a><span class="co">    Widerspruch nicht gebraucht - sie darf endgueltig weg. Wird der Rest</span></span>
-<span id="cb262-91"><a href="#cb262-91" aria-hidden="true" tabindex="-1"></a><span class="co">    loesbar, war sie beteiligt und muss bleiben.</span></span>
-<span id="cb262-92"><a href="#cb262-92" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb262-93"><a href="#cb262-93" aria-hidden="true" tabindex="-1"></a><span class="co">    Nach genau einem Durchlauf ueber alle Bedingungen ist das Ergebnis</span></span>
-<span id="cb262-94"><a href="#cb262-94" aria-hidden="true" tabindex="-1"></a><span class="co">    unreduzierbar: n Solveraufrufe statt 2^n Teilmengen.</span></span>
-<span id="cb262-95"><a href="#cb262-95" aria-hidden="true" tabindex="-1"></a><span class="co">    &quot;&quot;&quot;</span></span>
-<span id="cb262-96"><a href="#cb262-96" aria-hidden="true" tabindex="-1"></a>    rest <span class="op">=</span> <span class="bu">list</span>(auswahl)</span>
-<span id="cb262-97"><a href="#cb262-97" aria-hidden="true" tabindex="-1"></a>    <span class="cf">for</span> i <span class="kw">in</span> <span class="bu">list</span>(auswahl):</span>
-<span id="cb262-98"><a href="#cb262-98" aria-hidden="true" tabindex="-1"></a>        probe <span class="op">=</span> [j <span class="cf">for</span> j <span class="kw">in</span> rest <span class="cf">if</span> j <span class="op">!=</span> i]</span>
-<span id="cb262-99"><a href="#cb262-99" aria-hidden="true" tabindex="-1"></a>        <span class="cf">if</span> <span class="kw">not</span> ist_loesbar(probe):</span>
-<span id="cb262-100"><a href="#cb262-100" aria-hidden="true" tabindex="-1"></a>            rest <span class="op">=</span> probe</span>
-<span id="cb262-101"><a href="#cb262-101" aria-hidden="true" tabindex="-1"></a>    <span class="cf">return</span> rest</span>
-<span id="cb262-102"><a href="#cb262-102" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb262-103"><a href="#cb262-103" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb262-104"><a href="#cb262-104" aria-hidden="true" tabindex="-1"></a><span class="kw">def</span> namen(auswahl: <span class="bu">list</span>[<span class="bu">int</span>]) <span class="op">-&gt;</span> <span class="bu">list</span>[<span class="bu">str</span>]:</span>
-<span id="cb262-105"><a href="#cb262-105" aria-hidden="true" tabindex="-1"></a>    <span class="cf">return</span> [BEDINGUNGEN[i][<span class="dv">0</span>] <span class="cf">for</span> i <span class="kw">in</span> auswahl]</span>
-<span id="cb262-106"><a href="#cb262-106" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb262-107"><a href="#cb262-107" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb262-108"><a href="#cb262-108" aria-hidden="true" tabindex="-1"></a><span class="kw">def</span> teil_1_der_befund(alle: <span class="bu">list</span>[<span class="bu">int</span>]) <span class="op">-&gt;</span> <span class="va">None</span>:</span>
-<span id="cb262-109"><a href="#cb262-109" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;=&quot;</span> <span class="op">*</span> <span class="dv">68</span>)</span>
-<span id="cb262-110"><a href="#cb262-110" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;1. Was der Solver sagt&quot;</span>)</span>
-<span id="cb262-111"><a href="#cb262-111" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;=&quot;</span> <span class="op">*</span> <span class="dv">68</span>)</span>
-<span id="cb262-112"><a href="#cb262-112" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;Modell: </span><span class="sc">{</span><span class="bu">len</span>(PRODUKTE)<span class="sc">}</span><span class="ss"> Variablen, </span><span class="sc">{</span><span class="bu">len</span>(BEDINGUNGEN)<span class="sc">}</span><span class="ss"> Bedingungen&quot;</span>)</span>
-<span id="cb262-113"><a href="#cb262-113" aria-hidden="true" tabindex="-1"></a>    status <span class="op">=</span> <span class="st">&quot;OPTIMAL&quot;</span> <span class="cf">if</span> ist_loesbar(alle) <span class="cf">else</span> <span class="st">&quot;INFEASIBLE&quot;</span></span>
-<span id="cb262-114"><a href="#cb262-114" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;Status: </span><span class="sc">{</span>status<span class="sc">}</span><span class="ss">&quot;</span>)</span>
-<span id="cb262-115"><a href="#cb262-115" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;</span><span class="ch">\n</span><span class="st">Mehr ist es nicht. Der Solver nennt keine Ursache, weil es die eine&quot;</span>)</span>
-<span id="cb262-116"><a href="#cb262-116" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;Ursache nicht gibt: Unloesbarkeit ist eine Eigenschaft von Mengen von&quot;</span>)</span>
-<span id="cb262-117"><a href="#cb262-117" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;Bedingungen, nicht von einzelnen Bedingungen.&quot;</span>)</span>
-<span id="cb262-118"><a href="#cb262-118" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb262-119"><a href="#cb262-119" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb262-120"><a href="#cb262-120" aria-hidden="true" tabindex="-1"></a><span class="kw">def</span> teil_2_die_naive_suche(alle: <span class="bu">list</span>[<span class="bu">int</span>]) <span class="op">-&gt;</span> <span class="va">None</span>:</span>
-<span id="cb262-121"><a href="#cb262-121" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;</span><span class="ch">\n</span><span class="st">&quot;</span> <span class="op">+</span> <span class="st">&quot;=&quot;</span> <span class="op">*</span> <span class="dv">68</span>)</span>
-<span id="cb262-122"><a href="#cb262-122" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;2. Die naheliegende Idee - und warum sie hier scheitert&quot;</span>)</span>
-<span id="cb262-123"><a href="#cb262-123" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;=&quot;</span> <span class="op">*</span> <span class="dv">68</span>)</span>
-<span id="cb262-124"><a href="#cb262-124" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;Jede Bedingung einmal weglassen und schauen, ob es dann geht:</span><span class="ch">\n</span><span class="st">&quot;</span>)</span>
-<span id="cb262-125"><a href="#cb262-125" aria-hidden="true" tabindex="-1"></a>    treffer <span class="op">=</span> [i <span class="cf">for</span> i <span class="kw">in</span> alle <span class="cf">if</span> ist_loesbar([j <span class="cf">for</span> j <span class="kw">in</span> alle <span class="cf">if</span> j <span class="op">!=</span> i])]</span>
-<span id="cb262-126"><a href="#cb262-126" aria-hidden="true" tabindex="-1"></a>    <span class="cf">for</span> i <span class="kw">in</span> alle:</span>
-<span id="cb262-127"><a href="#cb262-127" aria-hidden="true" tabindex="-1"></a>        <span class="bu">print</span>(<span class="ss">f&quot;   ohne </span><span class="sc">{</span>BEDINGUNGEN[i][<span class="dv">0</span>]<span class="sc">:&lt;26}</span><span class="ss"> </span><span class="sc">{</span><span class="st">&#39;loesbar&#39;</span> <span class="cf">if</span> i <span class="kw">in</span> treffer <span class="cf">else</span> <span class="st">&#39;weiter unloesbar&#39;</span><span class="sc">}</span><span class="ss">&quot;</span>)</span>
-<span id="cb262-128"><a href="#cb262-128" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;</span><span class="ch">\n</span><span class="ss">Gefundene Schuldige: </span><span class="sc">{</span><span class="bu">len</span>(treffer)<span class="sc">}</span><span class="ss">&quot;</span>)</span>
-<span id="cb262-129"><a href="#cb262-129" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;Keine einzelne Bedingung ist schuld. Genau das ist der Normalfall -&quot;</span>)</span>
-<span id="cb262-130"><a href="#cb262-130" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;und der Grund, warum diese Suche in der Praxis so oft im Nichts endet.&quot;</span>)</span>
-<span id="cb262-131"><a href="#cb262-131" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb262-132"><a href="#cb262-132" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb262-133"><a href="#cb262-133" aria-hidden="true" tabindex="-1"></a><span class="kw">def</span> teil_3_der_filter(alle: <span class="bu">list</span>[<span class="bu">int</span>]) <span class="op">-&gt;</span> <span class="bu">list</span>[<span class="bu">int</span>]:</span>
-<span id="cb262-134"><a href="#cb262-134" aria-hidden="true" tabindex="-1"></a>    <span class="kw">global</span> aufrufe</span>
-<span id="cb262-135"><a href="#cb262-135" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;</span><span class="ch">\n</span><span class="st">&quot;</span> <span class="op">+</span> <span class="st">&quot;=&quot;</span> <span class="op">*</span> <span class="dv">68</span>)</span>
-<span id="cb262-136"><a href="#cb262-136" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;3. Der Deletion Filter&quot;</span>)</span>
-<span id="cb262-137"><a href="#cb262-137" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;=&quot;</span> <span class="op">*</span> <span class="dv">68</span>)</span>
-<span id="cb262-138"><a href="#cb262-138" aria-hidden="true" tabindex="-1"></a>    vorher <span class="op">=</span> aufrufe</span>
-<span id="cb262-139"><a href="#cb262-139" aria-hidden="true" tabindex="-1"></a>    konflikt <span class="op">=</span> deletion_filter(alle)</span>
-<span id="cb262-140"><a href="#cb262-140" aria-hidden="true" tabindex="-1"></a>    kosten <span class="op">=</span> aufrufe <span class="op">-</span> vorher</span>
-<span id="cb262-141"><a href="#cb262-141" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;</span><span class="sc">{</span>kosten<span class="sc">}</span><span class="ss"> Solveraufrufe -&gt; Konflikt aus </span><span class="sc">{</span><span class="bu">len</span>(konflikt)<span class="sc">}</span><span class="ss"> von &quot;</span></span>
-<span id="cb262-142"><a href="#cb262-142" aria-hidden="true" tabindex="-1"></a>          <span class="ss">f&quot;</span><span class="sc">{</span><span class="bu">len</span>(BEDINGUNGEN)<span class="sc">}</span><span class="ss"> Bedingungen:</span><span class="ch">\n</span><span class="ss">&quot;</span>)</span>
-<span id="cb262-143"><a href="#cb262-143" aria-hidden="true" tabindex="-1"></a>    <span class="cf">for</span> name <span class="kw">in</span> namen(konflikt):</span>
-<span id="cb262-144"><a href="#cb262-144" aria-hidden="true" tabindex="-1"></a>        <span class="bu">print</span>(<span class="ss">f&quot;   * </span><span class="sc">{</span>name<span class="sc">}</span><span class="ss">&quot;</span>)</span>
-<span id="cb262-145"><a href="#cb262-145" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;</span><span class="ch">\n</span><span class="st">Probe auf Unreduzierbarkeit - jede einzelne davon weglassen:&quot;</span>)</span>
-<span id="cb262-146"><a href="#cb262-146" aria-hidden="true" tabindex="-1"></a>    <span class="cf">for</span> i <span class="kw">in</span> konflikt:</span>
-<span id="cb262-147"><a href="#cb262-147" aria-hidden="true" tabindex="-1"></a>        rest_loesbar <span class="op">=</span> ist_loesbar([j <span class="cf">for</span> j <span class="kw">in</span> konflikt <span class="cf">if</span> j <span class="op">!=</span> i])</span>
-<span id="cb262-148"><a href="#cb262-148" aria-hidden="true" tabindex="-1"></a>        <span class="bu">print</span>(<span class="ss">f&quot;   ohne </span><span class="sc">{</span>BEDINGUNGEN[i][<span class="dv">0</span>]<span class="sc">:&lt;26}</span><span class="ss"> </span><span class="sc">{</span><span class="st">&#39;loesbar&#39;</span> <span class="cf">if</span> rest_loesbar <span class="cf">else</span> <span class="st">&#39;UNLOESBAR - nicht minimal!&#39;</span><span class="sc">}</span><span class="ss">&quot;</span>)</span>
-<span id="cb262-149"><a href="#cb262-149" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;</span><span class="ch">\n</span><span class="ss">Aufwand: </span><span class="sc">{</span>kosten<span class="sc">}</span><span class="ss"> Aufrufe. Alle Teilmengen durchzuprobieren waeren &quot;</span></span>
-<span id="cb262-150"><a href="#cb262-150" aria-hidden="true" tabindex="-1"></a>          <span class="ss">f&quot;2^</span><span class="sc">{</span><span class="bu">len</span>(BEDINGUNGEN)<span class="sc">}</span><span class="ss"> = </span><span class="sc">{</span><span class="dv">2</span> <span class="op">**</span> <span class="bu">len</span>(BEDINGUNGEN)<span class="sc">:,}</span><span class="ss"> gewesen.&quot;</span>.replace(<span class="st">&quot;,&quot;</span>, <span class="st">&quot;.&quot;</span>))</span>
-<span id="cb262-151"><a href="#cb262-151" aria-hidden="true" tabindex="-1"></a>    <span class="cf">return</span> konflikt</span>
-<span id="cb262-152"><a href="#cb262-152" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb262-153"><a href="#cb262-153" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb262-154"><a href="#cb262-154" aria-hidden="true" tabindex="-1"></a><span class="kw">def</span> teil_4_der_naechste_konflikt(alle: <span class="bu">list</span>[<span class="bu">int</span>], konflikt: <span class="bu">list</span>[<span class="bu">int</span>]) <span class="op">-&gt;</span> <span class="va">None</span>:</span>
-<span id="cb262-155"><a href="#cb262-155" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;</span><span class="ch">\n</span><span class="st">&quot;</span> <span class="op">+</span> <span class="st">&quot;=&quot;</span> <span class="op">*</span> <span class="dv">68</span>)</span>
-<span id="cb262-156"><a href="#cb262-156" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;4. Ein Konflikt ist selten einer&quot;</span>)</span>
-<span id="cb262-157"><a href="#cb262-157" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;=&quot;</span> <span class="op">*</span> <span class="dv">68</span>)</span>
-<span id="cb262-158"><a href="#cb262-158" aria-hidden="true" tabindex="-1"></a>    entfernt <span class="op">=</span> konflikt[<span class="dv">0</span>]</span>
-<span id="cb262-159"><a href="#cb262-159" aria-hidden="true" tabindex="-1"></a>    rest <span class="op">=</span> [i <span class="cf">for</span> i <span class="kw">in</span> alle <span class="cf">if</span> i <span class="op">!=</span> entfernt]</span>
-<span id="cb262-160"><a href="#cb262-160" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;Angenommen, &#39;</span><span class="sc">{</span>BEDINGUNGEN[entfernt][<span class="dv">0</span>]<span class="sc">}</span><span class="ss">&#39; laesst sich verhandeln&quot;</span>)</span>
-<span id="cb262-161"><a href="#cb262-161" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;und wird aus dem Modell genommen. Dann ist das Modell ...&quot;</span>)</span>
-<span id="cb262-162"><a href="#cb262-162" aria-hidden="true" tabindex="-1"></a>    <span class="cf">if</span> ist_loesbar(rest):</span>
-<span id="cb262-163"><a href="#cb262-163" aria-hidden="true" tabindex="-1"></a>        <span class="bu">print</span>(<span class="st">&quot;... loesbar. Fertig.&quot;</span>)</span>
-<span id="cb262-164"><a href="#cb262-164" aria-hidden="true" tabindex="-1"></a>        <span class="cf">return</span></span>
-<span id="cb262-165"><a href="#cb262-165" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;... immer noch unloesbar. Der Filter erneut:</span><span class="ch">\n</span><span class="st">&quot;</span>)</span>
-<span id="cb262-166"><a href="#cb262-166" aria-hidden="true" tabindex="-1"></a>    zweiter <span class="op">=</span> deletion_filter(rest)</span>
-<span id="cb262-167"><a href="#cb262-167" aria-hidden="true" tabindex="-1"></a>    <span class="cf">for</span> name <span class="kw">in</span> namen(zweiter):</span>
-<span id="cb262-168"><a href="#cb262-168" aria-hidden="true" tabindex="-1"></a>        <span class="bu">print</span>(<span class="ss">f&quot;   * </span><span class="sc">{</span>name<span class="sc">}</span><span class="ss">&quot;</span>)</span>
-<span id="cb262-169"><a href="#cb262-169" aria-hidden="true" tabindex="-1"></a>    gemeinsam <span class="op">=</span> <span class="bu">set</span>(zweiter) <span class="op">&amp;</span> <span class="bu">set</span>(konflikt)</span>
-<span id="cb262-170"><a href="#cb262-170" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;</span><span class="ch">\n</span><span class="ss">Ueberschneidung mit dem ersten Konflikt: </span><span class="sc">{</span><span class="bu">len</span>(gemeinsam)<span class="sc">}</span><span class="ss"> Bedingungen&quot;</span>)</span>
-<span id="cb262-171"><a href="#cb262-171" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;Ein zweiter, unabhaengiger Widerspruch, den der erste verdeckt hat.&quot;</span>)</span>
-<span id="cb262-172"><a href="#cb262-172" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;Deshalb ist die Konfliktsuche eine Schleife, kein einzelner Aufruf:&quot;</span>)</span>
-<span id="cb262-173"><a href="#cb262-173" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;reparieren, neu suchen, bis das Modell loesbar ist.&quot;</span>)</span>
-<span id="cb262-174"><a href="#cb262-174" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb262-175"><a href="#cb262-175" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb262-176"><a href="#cb262-176" aria-hidden="true" tabindex="-1"></a><span class="kw">def</span> teil_5_die_reihenfolge(alle: <span class="bu">list</span>[<span class="bu">int</span>]) <span class="op">-&gt;</span> <span class="va">None</span>:</span>
-<span id="cb262-177"><a href="#cb262-177" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;</span><span class="ch">\n</span><span class="st">&quot;</span> <span class="op">+</span> <span class="st">&quot;=&quot;</span> <span class="op">*</span> <span class="dv">68</span>)</span>
-<span id="cb262-178"><a href="#cb262-178" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;5. Es gibt nicht DEN Konflikt&quot;</span>)</span>
-<span id="cb262-179"><a href="#cb262-179" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;=&quot;</span> <span class="op">*</span> <span class="dv">68</span>)</span>
-<span id="cb262-180"><a href="#cb262-180" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;Derselbe Filter, nur eine andere Pruefreihenfolge - 200-mal gewuerfelt:</span><span class="ch">\n</span><span class="st">&quot;</span>)</span>
-<span id="cb262-181"><a href="#cb262-181" aria-hidden="true" tabindex="-1"></a>    zufall <span class="op">=</span> np.random.default_rng(<span class="dv">0</span>)</span>
-<span id="cb262-182"><a href="#cb262-182" aria-hidden="true" tabindex="-1"></a>    haeufigkeit: <span class="bu">dict</span>[<span class="bu">tuple</span>[<span class="bu">int</span>, ...], <span class="bu">int</span>] <span class="op">=</span> {}</span>
-<span id="cb262-183"><a href="#cb262-183" aria-hidden="true" tabindex="-1"></a>    <span class="cf">for</span> _ <span class="kw">in</span> <span class="bu">range</span>(<span class="dv">200</span>):</span>
-<span id="cb262-184"><a href="#cb262-184" aria-hidden="true" tabindex="-1"></a>        ordnung <span class="op">=</span> [<span class="bu">int</span>(i) <span class="cf">for</span> i <span class="kw">in</span> zufall.permutation(alle)]</span>
-<span id="cb262-185"><a href="#cb262-185" aria-hidden="true" tabindex="-1"></a>        schluessel <span class="op">=</span> <span class="bu">tuple</span>(<span class="bu">sorted</span>(deletion_filter(ordnung)))</span>
-<span id="cb262-186"><a href="#cb262-186" aria-hidden="true" tabindex="-1"></a>        haeufigkeit[schluessel] <span class="op">=</span> haeufigkeit.get(schluessel, <span class="dv">0</span>) <span class="op">+</span> <span class="dv">1</span></span>
-<span id="cb262-187"><a href="#cb262-187" aria-hidden="true" tabindex="-1"></a>    <span class="cf">for</span> schluessel, anzahl <span class="kw">in</span> <span class="bu">sorted</span>(haeufigkeit.items(), key<span class="op">=</span><span class="kw">lambda</span> p: <span class="op">-</span>p[<span class="dv">1</span>]):</span>
-<span id="cb262-188"><a href="#cb262-188" aria-hidden="true" tabindex="-1"></a>        <span class="bu">print</span>(<span class="ss">f&quot;   </span><span class="sc">{</span>anzahl<span class="sc">:3d}</span><span class="ss">x  </span><span class="sc">{</span><span class="bu">len</span>(schluessel)<span class="sc">}</span><span class="ss"> Bedingungen: &quot;</span></span>
-<span id="cb262-189"><a href="#cb262-189" aria-hidden="true" tabindex="-1"></a>              <span class="ss">f&quot;</span><span class="sc">{</span><span class="st">&#39;, &#39;</span><span class="sc">.</span>join(namen(<span class="bu">list</span>(schluessel)))<span class="sc">}</span><span class="ss">&quot;</span>)</span>
-<span id="cb262-190"><a href="#cb262-190" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;</span><span class="ch">\n</span><span class="sc">{</span><span class="bu">len</span>(haeufigkeit)<span class="sc">}</span><span class="ss"> verschiedene minimale Konflikte in EINEM Modell.&quot;</span>)</span>
-<span id="cb262-191"><a href="#cb262-191" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;Der Filter liefert *einen* kleinsten Konflikt, nicht *den* kleinsten -&quot;</span>)</span>
-<span id="cb262-192"><a href="#cb262-192" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;den gibt es nicht. Alle oben sind gleichermassen korrekt.&quot;</span>)</span>
-<span id="cb262-193"><a href="#cb262-193" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb262-194"><a href="#cb262-194" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb262-195"><a href="#cb262-195" aria-hidden="true" tabindex="-1"></a><span class="kw">def</span> teil_6_den_befund_steuern(alle: <span class="bu">list</span>[<span class="bu">int</span>]) <span class="op">-&gt;</span> <span class="va">None</span>:</span>
-<span id="cb262-196"><a href="#cb262-196" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;</span><span class="ch">\n</span><span class="st">&quot;</span> <span class="op">+</span> <span class="st">&quot;=&quot;</span> <span class="op">*</span> <span class="dv">68</span>)</span>
-<span id="cb262-197"><a href="#cb262-197" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;6. Den Befund brauchbar machen&quot;</span>)</span>
-<span id="cb262-198"><a href="#cb262-198" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;=&quot;</span> <span class="op">*</span> <span class="dv">68</span>)</span>
-<span id="cb262-199"><a href="#cb262-199" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;Der Filter wirft heraus, was er zuerst in die Hand bekommt. Wer die&quot;</span>)</span>
-<span id="cb262-200"><a href="#cb262-200" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;unveraenderlichen Bedingungen zuerst pruefen laesst, bekommt sie eher&quot;</span>)</span>
-<span id="cb262-201"><a href="#cb262-201" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;aus dem Befund heraus - und sieht dafuer mehr Stellschrauben.</span><span class="ch">\n</span><span class="st">&quot;</span>)</span>
-<span id="cb262-202"><a href="#cb262-202" aria-hidden="true" tabindex="-1"></a>    fest <span class="op">=</span> [i <span class="cf">for</span> i <span class="kw">in</span> alle <span class="cf">if</span> BEDINGUNGEN[i][<span class="dv">0</span>] <span class="kw">not</span> <span class="kw">in</span> VERHANDELBAR]</span>
-<span id="cb262-203"><a href="#cb262-203" aria-hidden="true" tabindex="-1"></a>    frei <span class="op">=</span> [i <span class="cf">for</span> i <span class="kw">in</span> alle <span class="cf">if</span> BEDINGUNGEN[i][<span class="dv">0</span>] <span class="kw">in</span> VERHANDELBAR]</span>
-<span id="cb262-204"><a href="#cb262-204" aria-hidden="true" tabindex="-1"></a>    <span class="cf">for</span> titel, ordnung <span class="kw">in</span> ((<span class="st">&quot;unveraenderliche zuerst&quot;</span>, fest <span class="op">+</span> frei),</span>
-<span id="cb262-205"><a href="#cb262-205" aria-hidden="true" tabindex="-1"></a>                           (<span class="st">&quot;veraenderliche zuerst  &quot;</span>, frei <span class="op">+</span> fest)):</span>
-<span id="cb262-206"><a href="#cb262-206" aria-hidden="true" tabindex="-1"></a>        konflikt <span class="op">=</span> <span class="bu">sorted</span>(deletion_filter(ordnung))</span>
-<span id="cb262-207"><a href="#cb262-207" aria-hidden="true" tabindex="-1"></a>        stellschrauben <span class="op">=</span> [i <span class="cf">for</span> i <span class="kw">in</span> konflikt <span class="cf">if</span> BEDINGUNGEN[i][<span class="dv">0</span>] <span class="kw">in</span> VERHANDELBAR]</span>
-<span id="cb262-208"><a href="#cb262-208" aria-hidden="true" tabindex="-1"></a>        <span class="bu">print</span>(<span class="ss">f&quot;   </span><span class="sc">{</span>titel<span class="sc">}</span><span class="ss"> -&gt; </span><span class="sc">{</span><span class="bu">len</span>(konflikt)<span class="sc">}</span><span class="ss"> Bedingungen, davon &quot;</span></span>
-<span id="cb262-209"><a href="#cb262-209" aria-hidden="true" tabindex="-1"></a>              <span class="ss">f&quot;</span><span class="sc">{</span><span class="bu">len</span>(stellschrauben)<span class="sc">}</span><span class="ss"> veraenderlich&quot;</span>)</span>
-<span id="cb262-210"><a href="#cb262-210" aria-hidden="true" tabindex="-1"></a>        <span class="bu">print</span>(<span class="ss">f&quot;      </span><span class="sc">{</span><span class="st">&#39;, &#39;</span><span class="sc">.</span>join(namen(konflikt))<span class="sc">}</span><span class="ss">&quot;</span>)</span>
-<span id="cb262-211"><a href="#cb262-211" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;</span><span class="ch">\n</span><span class="st">Beide Befunde sind wahr. Nur einer davon nennt dem Planer etwas,&quot;</span>)</span>
-<span id="cb262-212"><a href="#cb262-212" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;das er tatsaechlich tun kann.&quot;</span>)</span>
-<span id="cb262-213"><a href="#cb262-213" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb262-214"><a href="#cb262-214" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb262-215"><a href="#cb262-215" aria-hidden="true" tabindex="-1"></a><span class="cf">if</span> <span class="va">__name__</span> <span class="op">==</span> <span class="st">&quot;__main__&quot;</span>:</span>
-<span id="cb262-216"><a href="#cb262-216" aria-hidden="true" tabindex="-1"></a>    alle <span class="op">=</span> <span class="bu">list</span>(<span class="bu">range</span>(<span class="bu">len</span>(BEDINGUNGEN)))</span>
-<span id="cb262-217"><a href="#cb262-217" aria-hidden="true" tabindex="-1"></a>    teil_1_der_befund(alle)</span>
-<span id="cb262-218"><a href="#cb262-218" aria-hidden="true" tabindex="-1"></a>    teil_2_die_naive_suche(alle)</span>
-<span id="cb262-219"><a href="#cb262-219" aria-hidden="true" tabindex="-1"></a>    konflikt <span class="op">=</span> teil_3_der_filter(alle)</span>
-<span id="cb262-220"><a href="#cb262-220" aria-hidden="true" tabindex="-1"></a>    teil_4_der_naechste_konflikt(alle, konflikt)</span>
-<span id="cb262-221"><a href="#cb262-221" aria-hidden="true" tabindex="-1"></a>    teil_5_die_reihenfolge(alle)</span>
-<span id="cb262-222"><a href="#cb262-222" aria-hidden="true" tabindex="-1"></a>    teil_6_den_befund_steuern(alle)</span>
-<span id="cb262-223"><a href="#cb262-223" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;</span><span class="ch">\n</span><span class="st">&quot;</span> <span class="op">+</span> <span class="st">&quot;=&quot;</span> <span class="op">*</span> <span class="dv">68</span>)</span>
-<span id="cb262-224"><a href="#cb262-224" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;Insgesamt </span><span class="sc">{</span>aufrufe<span class="sc">}</span><span class="ss"> Solveraufrufe fuer die gesamte Diagnose.&quot;</span>)</span>
-<span id="cb262-225"><a href="#cb262-225" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;=&quot;</span> <span class="op">*</span> <span class="dv">68</span>)</span></code></pre></div>
+<div class="sourceCode" id="cb266"><pre class="sourceCode python"><code class="sourceCode python"><span id="cb266-1"><a href="#cb266-1" aria-hidden="true" tabindex="-1"></a><span class="co">#!/usr/bin/env python3</span></span>
+<span id="cb266-2"><a href="#cb266-2" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb266-3"><a href="#cb266-3" aria-hidden="true" tabindex="-1"></a><span class="co"># Konfliktsuche.py</span></span>
+<span id="cb266-4"><a href="#cb266-4" aria-hidden="true" tabindex="-1"></a><span class="co">&quot;&quot;&quot;</span></span>
+<span id="cb266-5"><a href="#cb266-5" aria-hidden="true" tabindex="-1"></a><span class="co">Anhang Fehlerdiagnose: Den Konflikt finden, der INFEASIBLE verursacht.</span></span>
+<span id="cb266-6"><a href="#cb266-6" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb266-7"><a href="#cb266-7" aria-hidden="true" tabindex="-1"></a><span class="co">Ein Deletion Filter (auch: IIS, Irreducible Infeasible Subset) isoliert aus</span></span>
+<span id="cb266-8"><a href="#cb266-8" aria-hidden="true" tabindex="-1"></a><span class="co">einem unloesbaren Modell eine kleinste widerspruechliche Teilmenge von</span></span>
+<span id="cb266-9"><a href="#cb266-9" aria-hidden="true" tabindex="-1"></a><span class="co">Bedingungen: Nimmt man aus ihr auch nur eine einzige Bedingung heraus, ist</span></span>
+<span id="cb266-10"><a href="#cb266-10" aria-hidden="true" tabindex="-1"></a><span class="co">der Rest wieder loesbar.</span></span>
+<span id="cb266-11"><a href="#cb266-11" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb266-12"><a href="#cb266-12" aria-hidden="true" tabindex="-1"></a><span class="co">Das Programm zeigt sechs Dinge:</span></span>
+<span id="cb266-13"><a href="#cb266-13" aria-hidden="true" tabindex="-1"></a><span class="co">  1. Der Solver meldet INFEASIBLE - und sonst nichts.</span></span>
+<span id="cb266-14"><a href="#cb266-14" aria-hidden="true" tabindex="-1"></a><span class="co">  2. Die naive Suche (&quot;jede Bedingung einmal weglassen&quot;) findet hier gar nichts.</span></span>
+<span id="cb266-15"><a href="#cb266-15" aria-hidden="true" tabindex="-1"></a><span class="co">  3. Der Deletion Filter findet einen Konflikt in n Solveraufrufen.</span></span>
+<span id="cb266-16"><a href="#cb266-16" aria-hidden="true" tabindex="-1"></a><span class="co">  4. Ein Konflikt ist selten einer: nach der Reparatur folgt der naechste.</span></span>
+<span id="cb266-17"><a href="#cb266-17" aria-hidden="true" tabindex="-1"></a><span class="co">  5. &quot;Den&quot; kleinsten Konflikt gibt es nicht - dieses Modell enthaelt neun.</span></span>
+<span id="cb266-18"><a href="#cb266-18" aria-hidden="true" tabindex="-1"></a><span class="co">  6. Welchen davon man zu sehen bekommt, steuert die Pruefreihenfolge.</span></span>
+<span id="cb266-19"><a href="#cb266-19" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb266-20"><a href="#cb266-20" aria-hidden="true" tabindex="-1"></a><span class="co">Abgrenzung zu Infeasibility_Diagnose.py (Kapitel Praxisfallen): Dort geht es</span></span>
+<span id="cb266-21"><a href="#cb266-21" aria-hidden="true" tabindex="-1"></a><span class="co">um die Relaxation - das Modell soll trotz Widerspruch eine brauchbare Antwort</span></span>
+<span id="cb266-22"><a href="#cb266-22" aria-hidden="true" tabindex="-1"></a><span class="co">liefern. Hier geht es um die Diagnose - welche Bedingungen widersprechen sich</span></span>
+<span id="cb266-23"><a href="#cb266-23" aria-hidden="true" tabindex="-1"></a><span class="co">ueberhaupt. Beides zusammen ergibt den Umgang mit INFEASIBLE in Produktion.</span></span>
+<span id="cb266-24"><a href="#cb266-24" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb266-25"><a href="#cb266-25" aria-hidden="true" tabindex="-1"></a><span class="co">Benoetigt: numpy, scipy</span></span>
+<span id="cb266-26"><a href="#cb266-26" aria-hidden="true" tabindex="-1"></a><span class="co">&quot;&quot;&quot;</span></span>
+<span id="cb266-27"><a href="#cb266-27" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb266-28"><a href="#cb266-28" aria-hidden="true" tabindex="-1"></a><span class="im">from</span> __future__ <span class="im">import</span> annotations</span>
+<span id="cb266-29"><a href="#cb266-29" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb266-30"><a href="#cb266-30" aria-hidden="true" tabindex="-1"></a><span class="im">import</span> numpy <span class="im">as</span> np</span>
+<span id="cb266-31"><a href="#cb266-31" aria-hidden="true" tabindex="-1"></a><span class="im">from</span> scipy.optimize <span class="im">import</span> linprog</span>
+<span id="cb266-32"><a href="#cb266-32" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb266-33"><a href="#cb266-33" aria-hidden="true" tabindex="-1"></a>PRODUKTE <span class="op">=</span> [<span class="st">&quot;Rahmen&quot;</span>, <span class="st">&quot;Gehaeuse&quot;</span>, <span class="st">&quot;Deckel&quot;</span>, <span class="st">&quot;Traeger&quot;</span>, <span class="st">&quot;Halter&quot;</span>]</span>
+<span id="cb266-34"><a href="#cb266-34" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb266-35"><a href="#cb266-35" aria-hidden="true" tabindex="-1"></a><span class="co"># Jede Bedingung traegt einen sprechenden Namen - das ist keine Kosmetik,</span></span>
+<span id="cb266-36"><a href="#cb266-36" aria-hidden="true" tabindex="-1"></a><span class="co"># sondern die Voraussetzung dafuer, dass der Befund lesbar wird.</span></span>
+<span id="cb266-37"><a href="#cb266-37" aria-hidden="true" tabindex="-1"></a><span class="co"># (Name, Koeffizienten je Produkt, Richtung, rechte Seite)</span></span>
+<span id="cb266-38"><a href="#cb266-38" aria-hidden="true" tabindex="-1"></a>BEDINGUNGEN: <span class="bu">list</span>[<span class="bu">tuple</span>[<span class="bu">str</span>, <span class="bu">list</span>[<span class="bu">float</span>], <span class="bu">str</span>, <span class="bu">float</span>]] <span class="op">=</span> [</span>
+<span id="cb266-39"><a href="#cb266-39" aria-hidden="true" tabindex="-1"></a>    (<span class="st">&quot;Kapazitaet Montage&quot;</span>,       [<span class="dv">3</span>, <span class="dv">2</span>, <span class="dv">1</span>, <span class="dv">4</span>, <span class="dv">2</span>],      <span class="st">&quot;&lt;=&quot;</span>,   <span class="dv">400</span>),</span>
+<span id="cb266-40"><a href="#cb266-40" aria-hidden="true" tabindex="-1"></a>    (<span class="st">&quot;Kapazitaet Lackieren&quot;</span>,     [<span class="dv">2</span>, <span class="dv">3</span>, <span class="dv">0</span>, <span class="dv">1</span>, <span class="dv">0</span>],      <span class="st">&quot;&lt;=&quot;</span>,   <span class="dv">150</span>),</span>
+<span id="cb266-41"><a href="#cb266-41" aria-hidden="true" tabindex="-1"></a>    (<span class="st">&quot;Kapazitaet Pruefung&quot;</span>,      [<span class="dv">1</span>, <span class="dv">1</span>, <span class="dv">1</span>, <span class="dv">1</span>, <span class="dv">1</span>],      <span class="st">&quot;&lt;=&quot;</span>,   <span class="dv">300</span>),</span>
+<span id="cb266-42"><a href="#cb266-42" aria-hidden="true" tabindex="-1"></a>    (<span class="st">&quot;Liefervertrag Rahmen&quot;</span>,     [<span class="dv">1</span>, <span class="dv">0</span>, <span class="dv">0</span>, <span class="dv">0</span>, <span class="dv">0</span>],      <span class="st">&quot;&gt;=&quot;</span>,    <span class="dv">40</span>),</span>
+<span id="cb266-43"><a href="#cb266-43" aria-hidden="true" tabindex="-1"></a>    (<span class="st">&quot;Liefervertrag Gehaeuse&quot;</span>,   [<span class="dv">0</span>, <span class="dv">1</span>, <span class="dv">0</span>, <span class="dv">0</span>, <span class="dv">0</span>],      <span class="st">&quot;&gt;=&quot;</span>,    <span class="dv">30</span>),</span>
+<span id="cb266-44"><a href="#cb266-44" aria-hidden="true" tabindex="-1"></a>    (<span class="st">&quot;Liefervertrag Deckel&quot;</span>,     [<span class="dv">0</span>, <span class="dv">0</span>, <span class="dv">1</span>, <span class="dv">0</span>, <span class="dv">0</span>],      <span class="st">&quot;&gt;=&quot;</span>,    <span class="dv">20</span>),</span>
+<span id="cb266-45"><a href="#cb266-45" aria-hidden="true" tabindex="-1"></a>    (<span class="st">&quot;Liefervertrag Traeger&quot;</span>,    [<span class="dv">0</span>, <span class="dv">0</span>, <span class="dv">0</span>, <span class="dv">1</span>, <span class="dv">0</span>],      <span class="st">&quot;&gt;=&quot;</span>,    <span class="dv">25</span>),</span>
+<span id="cb266-46"><a href="#cb266-46" aria-hidden="true" tabindex="-1"></a>    (<span class="st">&quot;Marktgrenze Rahmen&quot;</span>,       [<span class="dv">1</span>, <span class="dv">0</span>, <span class="dv">0</span>, <span class="dv">0</span>, <span class="dv">0</span>],      <span class="st">&quot;&lt;=&quot;</span>,   <span class="dv">120</span>),</span>
+<span id="cb266-47"><a href="#cb266-47" aria-hidden="true" tabindex="-1"></a>    (<span class="st">&quot;Marktgrenze Gehaeuse&quot;</span>,     [<span class="dv">0</span>, <span class="dv">1</span>, <span class="dv">0</span>, <span class="dv">0</span>, <span class="dv">0</span>],      <span class="st">&quot;&lt;=&quot;</span>,    <span class="dv">90</span>),</span>
+<span id="cb266-48"><a href="#cb266-48" aria-hidden="true" tabindex="-1"></a>    (<span class="st">&quot;Marktgrenze Deckel&quot;</span>,       [<span class="dv">0</span>, <span class="dv">0</span>, <span class="dv">1</span>, <span class="dv">0</span>, <span class="dv">0</span>],      <span class="st">&quot;&lt;=&quot;</span>,   <span class="dv">150</span>),</span>
+<span id="cb266-49"><a href="#cb266-49" aria-hidden="true" tabindex="-1"></a>    (<span class="st">&quot;Marktgrenze Halter&quot;</span>,       [<span class="dv">0</span>, <span class="dv">0</span>, <span class="dv">0</span>, <span class="dv">0</span>, <span class="dv">1</span>],      <span class="st">&quot;&lt;=&quot;</span>,   <span class="dv">200</span>),</span>
+<span id="cb266-50"><a href="#cb266-50" aria-hidden="true" tabindex="-1"></a>    (<span class="st">&quot;Mindestumsatz&quot;</span>,            [<span class="dv">90</span>, <span class="dv">70</span>, <span class="dv">30</span>, <span class="dv">60</span>, <span class="dv">20</span>], <span class="st">&quot;&gt;=&quot;</span>, <span class="dv">12000</span>),</span>
+<span id="cb266-51"><a href="#cb266-51" aria-hidden="true" tabindex="-1"></a>    (<span class="st">&quot;Sortimentsbreite&quot;</span>,         [<span class="dv">0</span>, <span class="dv">0</span>, <span class="dv">1</span>, <span class="dv">1</span>, <span class="dv">1</span>],      <span class="st">&quot;&gt;=&quot;</span>,   <span class="dv">100</span>),</span>
+<span id="cb266-52"><a href="#cb266-52" aria-hidden="true" tabindex="-1"></a>    (<span class="st">&quot;Lackierbudget Schicht 2&quot;</span>,  [<span class="dv">0</span>, <span class="dv">1</span>, <span class="dv">0</span>, <span class="dv">1</span>, <span class="dv">0</span>],      <span class="st">&quot;&lt;=&quot;</span>,    <span class="dv">55</span>),</span>
+<span id="cb266-53"><a href="#cb266-53" aria-hidden="true" tabindex="-1"></a>]</span>
+<span id="cb266-54"><a href="#cb266-54" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb266-55"><a href="#cb266-55" aria-hidden="true" tabindex="-1"></a><span class="co"># Welche Bedingungen koennte ein Planer im Ernstfall wirklich veraendern?</span></span>
+<span id="cb266-56"><a href="#cb266-56" aria-hidden="true" tabindex="-1"></a><span class="co"># Kapazitaeten lassen sich durch Sonderschichten dehnen, Liefervertraege und</span></span>
+<span id="cb266-57"><a href="#cb266-57" aria-hidden="true" tabindex="-1"></a><span class="co"># Marktgrenzen nicht.</span></span>
+<span id="cb266-58"><a href="#cb266-58" aria-hidden="true" tabindex="-1"></a>VERHANDELBAR <span class="op">=</span> {<span class="st">&quot;Kapazitaet Montage&quot;</span>, <span class="st">&quot;Kapazitaet Lackieren&quot;</span>,</span>
+<span id="cb266-59"><a href="#cb266-59" aria-hidden="true" tabindex="-1"></a>                <span class="st">&quot;Kapazitaet Pruefung&quot;</span>, <span class="st">&quot;Lackierbudget Schicht 2&quot;</span>}</span>
+<span id="cb266-60"><a href="#cb266-60" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb266-61"><a href="#cb266-61" aria-hidden="true" tabindex="-1"></a>aufrufe <span class="op">=</span> <span class="dv">0</span>          <span class="co"># zaehlt jeden Solveraufruf mit - der Preis des Verfahrens</span></span>
+<span id="cb266-62"><a href="#cb266-62" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb266-63"><a href="#cb266-63" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb266-64"><a href="#cb266-64" aria-hidden="true" tabindex="-1"></a><span class="kw">def</span> ist_loesbar(auswahl: <span class="bu">list</span>[<span class="bu">int</span>]) <span class="op">-&gt;</span> <span class="bu">bool</span>:</span>
+<span id="cb266-65"><a href="#cb266-65" aria-hidden="true" tabindex="-1"></a>    <span class="co">&quot;&quot;&quot;Gibt es einen Punkt, der ALLE Bedingungen aus &#39;auswahl&#39; erfuellt?</span></span>
+<span id="cb266-66"><a href="#cb266-66" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb266-67"><a href="#cb266-67" aria-hidden="true" tabindex="-1"></a><span class="co">    Es wird nur Zulaessigkeit geprueft, keine Zielfunktion optimiert: die</span></span>
+<span id="cb266-68"><a href="#cb266-68" aria-hidden="true" tabindex="-1"></a><span class="co">    Zielfunktion ist konstant null. INFEASIBLE haengt nie an der Zielfunktion.</span></span>
+<span id="cb266-69"><a href="#cb266-69" aria-hidden="true" tabindex="-1"></a><span class="co">    &quot;&quot;&quot;</span></span>
+<span id="cb266-70"><a href="#cb266-70" aria-hidden="true" tabindex="-1"></a>    <span class="kw">global</span> aufrufe</span>
+<span id="cb266-71"><a href="#cb266-71" aria-hidden="true" tabindex="-1"></a>    aufrufe <span class="op">+=</span> <span class="dv">1</span></span>
+<span id="cb266-72"><a href="#cb266-72" aria-hidden="true" tabindex="-1"></a>    matrix, rechte_seite <span class="op">=</span> [], []</span>
+<span id="cb266-73"><a href="#cb266-73" aria-hidden="true" tabindex="-1"></a>    <span class="cf">for</span> i <span class="kw">in</span> auswahl:</span>
+<span id="cb266-74"><a href="#cb266-74" aria-hidden="true" tabindex="-1"></a>        _, koeffizienten, richtung, grenze <span class="op">=</span> BEDINGUNGEN[i]</span>
+<span id="cb266-75"><a href="#cb266-75" aria-hidden="true" tabindex="-1"></a>        zeile <span class="op">=</span> np.array(koeffizienten, dtype<span class="op">=</span><span class="bu">float</span>)</span>
+<span id="cb266-76"><a href="#cb266-76" aria-hidden="true" tabindex="-1"></a>        <span class="co"># linprog kennt nur &quot;&lt;=&quot;, also &quot;&gt;=&quot; durch Negation umdrehen</span></span>
+<span id="cb266-77"><a href="#cb266-77" aria-hidden="true" tabindex="-1"></a>        matrix.append(zeile <span class="cf">if</span> richtung <span class="op">==</span> <span class="st">&quot;&lt;=&quot;</span> <span class="cf">else</span> <span class="op">-</span>zeile)</span>
+<span id="cb266-78"><a href="#cb266-78" aria-hidden="true" tabindex="-1"></a>        rechte_seite.append(grenze <span class="cf">if</span> richtung <span class="op">==</span> <span class="st">&quot;&lt;=&quot;</span> <span class="cf">else</span> <span class="op">-</span>grenze)</span>
+<span id="cb266-79"><a href="#cb266-79" aria-hidden="true" tabindex="-1"></a>    ergebnis <span class="op">=</span> linprog(np.zeros(<span class="bu">len</span>(PRODUKTE)),</span>
+<span id="cb266-80"><a href="#cb266-80" aria-hidden="true" tabindex="-1"></a>                       A_ub<span class="op">=</span>np.array(matrix), b_ub<span class="op">=</span>np.array(rechte_seite),</span>
+<span id="cb266-81"><a href="#cb266-81" aria-hidden="true" tabindex="-1"></a>                       bounds<span class="op">=</span>(<span class="dv">0</span>, <span class="va">None</span>), method<span class="op">=</span><span class="st">&quot;highs&quot;</span>)</span>
+<span id="cb266-82"><a href="#cb266-82" aria-hidden="true" tabindex="-1"></a>    <span class="cf">return</span> ergebnis.status <span class="op">==</span> <span class="dv">0</span></span>
+<span id="cb266-83"><a href="#cb266-83" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb266-84"><a href="#cb266-84" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb266-85"><a href="#cb266-85" aria-hidden="true" tabindex="-1"></a><span class="kw">def</span> deletion_filter(auswahl: <span class="bu">list</span>[<span class="bu">int</span>]) <span class="op">-&gt;</span> <span class="bu">list</span>[<span class="bu">int</span>]:</span>
+<span id="cb266-86"><a href="#cb266-86" aria-hidden="true" tabindex="-1"></a>    <span class="co">&quot;&quot;&quot;Verkleinert eine unloesbare Menge zu einer kleinsten unloesbaren Menge.</span></span>
+<span id="cb266-87"><a href="#cb266-87" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb266-88"><a href="#cb266-88" aria-hidden="true" tabindex="-1"></a><span class="co">    Der Kern des Verfahrens ist eine einzige Regel: Nimm eine Bedingung</span></span>
+<span id="cb266-89"><a href="#cb266-89" aria-hidden="true" tabindex="-1"></a><span class="co">    versuchsweise heraus. Bleibt der Rest unloesbar, wurde sie fuer den</span></span>
+<span id="cb266-90"><a href="#cb266-90" aria-hidden="true" tabindex="-1"></a><span class="co">    Widerspruch nicht gebraucht - sie darf endgueltig weg. Wird der Rest</span></span>
+<span id="cb266-91"><a href="#cb266-91" aria-hidden="true" tabindex="-1"></a><span class="co">    loesbar, war sie beteiligt und muss bleiben.</span></span>
+<span id="cb266-92"><a href="#cb266-92" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb266-93"><a href="#cb266-93" aria-hidden="true" tabindex="-1"></a><span class="co">    Nach genau einem Durchlauf ueber alle Bedingungen ist das Ergebnis</span></span>
+<span id="cb266-94"><a href="#cb266-94" aria-hidden="true" tabindex="-1"></a><span class="co">    unreduzierbar: n Solveraufrufe statt 2^n Teilmengen.</span></span>
+<span id="cb266-95"><a href="#cb266-95" aria-hidden="true" tabindex="-1"></a><span class="co">    &quot;&quot;&quot;</span></span>
+<span id="cb266-96"><a href="#cb266-96" aria-hidden="true" tabindex="-1"></a>    rest <span class="op">=</span> <span class="bu">list</span>(auswahl)</span>
+<span id="cb266-97"><a href="#cb266-97" aria-hidden="true" tabindex="-1"></a>    <span class="cf">for</span> i <span class="kw">in</span> <span class="bu">list</span>(auswahl):</span>
+<span id="cb266-98"><a href="#cb266-98" aria-hidden="true" tabindex="-1"></a>        probe <span class="op">=</span> [j <span class="cf">for</span> j <span class="kw">in</span> rest <span class="cf">if</span> j <span class="op">!=</span> i]</span>
+<span id="cb266-99"><a href="#cb266-99" aria-hidden="true" tabindex="-1"></a>        <span class="cf">if</span> <span class="kw">not</span> ist_loesbar(probe):</span>
+<span id="cb266-100"><a href="#cb266-100" aria-hidden="true" tabindex="-1"></a>            rest <span class="op">=</span> probe</span>
+<span id="cb266-101"><a href="#cb266-101" aria-hidden="true" tabindex="-1"></a>    <span class="cf">return</span> rest</span>
+<span id="cb266-102"><a href="#cb266-102" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb266-103"><a href="#cb266-103" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb266-104"><a href="#cb266-104" aria-hidden="true" tabindex="-1"></a><span class="kw">def</span> namen(auswahl: <span class="bu">list</span>[<span class="bu">int</span>]) <span class="op">-&gt;</span> <span class="bu">list</span>[<span class="bu">str</span>]:</span>
+<span id="cb266-105"><a href="#cb266-105" aria-hidden="true" tabindex="-1"></a>    <span class="cf">return</span> [BEDINGUNGEN[i][<span class="dv">0</span>] <span class="cf">for</span> i <span class="kw">in</span> auswahl]</span>
+<span id="cb266-106"><a href="#cb266-106" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb266-107"><a href="#cb266-107" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb266-108"><a href="#cb266-108" aria-hidden="true" tabindex="-1"></a><span class="kw">def</span> teil_1_der_befund(alle: <span class="bu">list</span>[<span class="bu">int</span>]) <span class="op">-&gt;</span> <span class="va">None</span>:</span>
+<span id="cb266-109"><a href="#cb266-109" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;=&quot;</span> <span class="op">*</span> <span class="dv">68</span>)</span>
+<span id="cb266-110"><a href="#cb266-110" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;1. Was der Solver sagt&quot;</span>)</span>
+<span id="cb266-111"><a href="#cb266-111" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;=&quot;</span> <span class="op">*</span> <span class="dv">68</span>)</span>
+<span id="cb266-112"><a href="#cb266-112" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;Modell: </span><span class="sc">{</span><span class="bu">len</span>(PRODUKTE)<span class="sc">}</span><span class="ss"> Variablen, </span><span class="sc">{</span><span class="bu">len</span>(BEDINGUNGEN)<span class="sc">}</span><span class="ss"> Bedingungen&quot;</span>)</span>
+<span id="cb266-113"><a href="#cb266-113" aria-hidden="true" tabindex="-1"></a>    status <span class="op">=</span> <span class="st">&quot;OPTIMAL&quot;</span> <span class="cf">if</span> ist_loesbar(alle) <span class="cf">else</span> <span class="st">&quot;INFEASIBLE&quot;</span></span>
+<span id="cb266-114"><a href="#cb266-114" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;Status: </span><span class="sc">{</span>status<span class="sc">}</span><span class="ss">&quot;</span>)</span>
+<span id="cb266-115"><a href="#cb266-115" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;</span><span class="ch">\n</span><span class="st">Mehr ist es nicht. Der Solver nennt keine Ursache, weil es die eine&quot;</span>)</span>
+<span id="cb266-116"><a href="#cb266-116" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;Ursache nicht gibt: Unloesbarkeit ist eine Eigenschaft von Mengen von&quot;</span>)</span>
+<span id="cb266-117"><a href="#cb266-117" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;Bedingungen, nicht von einzelnen Bedingungen.&quot;</span>)</span>
+<span id="cb266-118"><a href="#cb266-118" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb266-119"><a href="#cb266-119" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb266-120"><a href="#cb266-120" aria-hidden="true" tabindex="-1"></a><span class="kw">def</span> teil_2_die_naive_suche(alle: <span class="bu">list</span>[<span class="bu">int</span>]) <span class="op">-&gt;</span> <span class="va">None</span>:</span>
+<span id="cb266-121"><a href="#cb266-121" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;</span><span class="ch">\n</span><span class="st">&quot;</span> <span class="op">+</span> <span class="st">&quot;=&quot;</span> <span class="op">*</span> <span class="dv">68</span>)</span>
+<span id="cb266-122"><a href="#cb266-122" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;2. Die naheliegende Idee - und warum sie hier scheitert&quot;</span>)</span>
+<span id="cb266-123"><a href="#cb266-123" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;=&quot;</span> <span class="op">*</span> <span class="dv">68</span>)</span>
+<span id="cb266-124"><a href="#cb266-124" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;Jede Bedingung einmal weglassen und schauen, ob es dann geht:</span><span class="ch">\n</span><span class="st">&quot;</span>)</span>
+<span id="cb266-125"><a href="#cb266-125" aria-hidden="true" tabindex="-1"></a>    treffer <span class="op">=</span> [i <span class="cf">for</span> i <span class="kw">in</span> alle <span class="cf">if</span> ist_loesbar([j <span class="cf">for</span> j <span class="kw">in</span> alle <span class="cf">if</span> j <span class="op">!=</span> i])]</span>
+<span id="cb266-126"><a href="#cb266-126" aria-hidden="true" tabindex="-1"></a>    <span class="cf">for</span> i <span class="kw">in</span> alle:</span>
+<span id="cb266-127"><a href="#cb266-127" aria-hidden="true" tabindex="-1"></a>        <span class="bu">print</span>(<span class="ss">f&quot;   ohne </span><span class="sc">{</span>BEDINGUNGEN[i][<span class="dv">0</span>]<span class="sc">:&lt;26}</span><span class="ss"> </span><span class="sc">{</span><span class="st">&#39;loesbar&#39;</span> <span class="cf">if</span> i <span class="kw">in</span> treffer <span class="cf">else</span> <span class="st">&#39;weiter unloesbar&#39;</span><span class="sc">}</span><span class="ss">&quot;</span>)</span>
+<span id="cb266-128"><a href="#cb266-128" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;</span><span class="ch">\n</span><span class="ss">Gefundene Schuldige: </span><span class="sc">{</span><span class="bu">len</span>(treffer)<span class="sc">}</span><span class="ss">&quot;</span>)</span>
+<span id="cb266-129"><a href="#cb266-129" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;Keine einzelne Bedingung ist schuld. Genau das ist der Normalfall -&quot;</span>)</span>
+<span id="cb266-130"><a href="#cb266-130" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;und der Grund, warum diese Suche in der Praxis so oft im Nichts endet.&quot;</span>)</span>
+<span id="cb266-131"><a href="#cb266-131" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb266-132"><a href="#cb266-132" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb266-133"><a href="#cb266-133" aria-hidden="true" tabindex="-1"></a><span class="kw">def</span> teil_3_der_filter(alle: <span class="bu">list</span>[<span class="bu">int</span>]) <span class="op">-&gt;</span> <span class="bu">list</span>[<span class="bu">int</span>]:</span>
+<span id="cb266-134"><a href="#cb266-134" aria-hidden="true" tabindex="-1"></a>    <span class="kw">global</span> aufrufe</span>
+<span id="cb266-135"><a href="#cb266-135" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;</span><span class="ch">\n</span><span class="st">&quot;</span> <span class="op">+</span> <span class="st">&quot;=&quot;</span> <span class="op">*</span> <span class="dv">68</span>)</span>
+<span id="cb266-136"><a href="#cb266-136" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;3. Der Deletion Filter&quot;</span>)</span>
+<span id="cb266-137"><a href="#cb266-137" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;=&quot;</span> <span class="op">*</span> <span class="dv">68</span>)</span>
+<span id="cb266-138"><a href="#cb266-138" aria-hidden="true" tabindex="-1"></a>    vorher <span class="op">=</span> aufrufe</span>
+<span id="cb266-139"><a href="#cb266-139" aria-hidden="true" tabindex="-1"></a>    konflikt <span class="op">=</span> deletion_filter(alle)</span>
+<span id="cb266-140"><a href="#cb266-140" aria-hidden="true" tabindex="-1"></a>    kosten <span class="op">=</span> aufrufe <span class="op">-</span> vorher</span>
+<span id="cb266-141"><a href="#cb266-141" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;</span><span class="sc">{</span>kosten<span class="sc">}</span><span class="ss"> Solveraufrufe -&gt; Konflikt aus </span><span class="sc">{</span><span class="bu">len</span>(konflikt)<span class="sc">}</span><span class="ss"> von &quot;</span></span>
+<span id="cb266-142"><a href="#cb266-142" aria-hidden="true" tabindex="-1"></a>          <span class="ss">f&quot;</span><span class="sc">{</span><span class="bu">len</span>(BEDINGUNGEN)<span class="sc">}</span><span class="ss"> Bedingungen:</span><span class="ch">\n</span><span class="ss">&quot;</span>)</span>
+<span id="cb266-143"><a href="#cb266-143" aria-hidden="true" tabindex="-1"></a>    <span class="cf">for</span> name <span class="kw">in</span> namen(konflikt):</span>
+<span id="cb266-144"><a href="#cb266-144" aria-hidden="true" tabindex="-1"></a>        <span class="bu">print</span>(<span class="ss">f&quot;   * </span><span class="sc">{</span>name<span class="sc">}</span><span class="ss">&quot;</span>)</span>
+<span id="cb266-145"><a href="#cb266-145" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;</span><span class="ch">\n</span><span class="st">Probe auf Unreduzierbarkeit - jede einzelne davon weglassen:&quot;</span>)</span>
+<span id="cb266-146"><a href="#cb266-146" aria-hidden="true" tabindex="-1"></a>    <span class="cf">for</span> i <span class="kw">in</span> konflikt:</span>
+<span id="cb266-147"><a href="#cb266-147" aria-hidden="true" tabindex="-1"></a>        rest_loesbar <span class="op">=</span> ist_loesbar([j <span class="cf">for</span> j <span class="kw">in</span> konflikt <span class="cf">if</span> j <span class="op">!=</span> i])</span>
+<span id="cb266-148"><a href="#cb266-148" aria-hidden="true" tabindex="-1"></a>        <span class="bu">print</span>(<span class="ss">f&quot;   ohne </span><span class="sc">{</span>BEDINGUNGEN[i][<span class="dv">0</span>]<span class="sc">:&lt;26}</span><span class="ss"> </span><span class="sc">{</span><span class="st">&#39;loesbar&#39;</span> <span class="cf">if</span> rest_loesbar <span class="cf">else</span> <span class="st">&#39;UNLOESBAR - nicht minimal!&#39;</span><span class="sc">}</span><span class="ss">&quot;</span>)</span>
+<span id="cb266-149"><a href="#cb266-149" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;</span><span class="ch">\n</span><span class="ss">Aufwand: </span><span class="sc">{</span>kosten<span class="sc">}</span><span class="ss"> Aufrufe. Alle Teilmengen durchzuprobieren waeren &quot;</span></span>
+<span id="cb266-150"><a href="#cb266-150" aria-hidden="true" tabindex="-1"></a>          <span class="ss">f&quot;2^</span><span class="sc">{</span><span class="bu">len</span>(BEDINGUNGEN)<span class="sc">}</span><span class="ss"> = </span><span class="sc">{</span><span class="dv">2</span> <span class="op">**</span> <span class="bu">len</span>(BEDINGUNGEN)<span class="sc">:,}</span><span class="ss"> gewesen.&quot;</span>.replace(<span class="st">&quot;,&quot;</span>, <span class="st">&quot;.&quot;</span>))</span>
+<span id="cb266-151"><a href="#cb266-151" aria-hidden="true" tabindex="-1"></a>    <span class="cf">return</span> konflikt</span>
+<span id="cb266-152"><a href="#cb266-152" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb266-153"><a href="#cb266-153" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb266-154"><a href="#cb266-154" aria-hidden="true" tabindex="-1"></a><span class="kw">def</span> teil_4_der_naechste_konflikt(alle: <span class="bu">list</span>[<span class="bu">int</span>], konflikt: <span class="bu">list</span>[<span class="bu">int</span>]) <span class="op">-&gt;</span> <span class="va">None</span>:</span>
+<span id="cb266-155"><a href="#cb266-155" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;</span><span class="ch">\n</span><span class="st">&quot;</span> <span class="op">+</span> <span class="st">&quot;=&quot;</span> <span class="op">*</span> <span class="dv">68</span>)</span>
+<span id="cb266-156"><a href="#cb266-156" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;4. Ein Konflikt ist selten einer&quot;</span>)</span>
+<span id="cb266-157"><a href="#cb266-157" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;=&quot;</span> <span class="op">*</span> <span class="dv">68</span>)</span>
+<span id="cb266-158"><a href="#cb266-158" aria-hidden="true" tabindex="-1"></a>    entfernt <span class="op">=</span> konflikt[<span class="dv">0</span>]</span>
+<span id="cb266-159"><a href="#cb266-159" aria-hidden="true" tabindex="-1"></a>    rest <span class="op">=</span> [i <span class="cf">for</span> i <span class="kw">in</span> alle <span class="cf">if</span> i <span class="op">!=</span> entfernt]</span>
+<span id="cb266-160"><a href="#cb266-160" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;Angenommen, &#39;</span><span class="sc">{</span>BEDINGUNGEN[entfernt][<span class="dv">0</span>]<span class="sc">}</span><span class="ss">&#39; laesst sich verhandeln&quot;</span>)</span>
+<span id="cb266-161"><a href="#cb266-161" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;und wird aus dem Modell genommen. Dann ist das Modell ...&quot;</span>)</span>
+<span id="cb266-162"><a href="#cb266-162" aria-hidden="true" tabindex="-1"></a>    <span class="cf">if</span> ist_loesbar(rest):</span>
+<span id="cb266-163"><a href="#cb266-163" aria-hidden="true" tabindex="-1"></a>        <span class="bu">print</span>(<span class="st">&quot;... loesbar. Fertig.&quot;</span>)</span>
+<span id="cb266-164"><a href="#cb266-164" aria-hidden="true" tabindex="-1"></a>        <span class="cf">return</span></span>
+<span id="cb266-165"><a href="#cb266-165" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;... immer noch unloesbar. Der Filter erneut:</span><span class="ch">\n</span><span class="st">&quot;</span>)</span>
+<span id="cb266-166"><a href="#cb266-166" aria-hidden="true" tabindex="-1"></a>    zweiter <span class="op">=</span> deletion_filter(rest)</span>
+<span id="cb266-167"><a href="#cb266-167" aria-hidden="true" tabindex="-1"></a>    <span class="cf">for</span> name <span class="kw">in</span> namen(zweiter):</span>
+<span id="cb266-168"><a href="#cb266-168" aria-hidden="true" tabindex="-1"></a>        <span class="bu">print</span>(<span class="ss">f&quot;   * </span><span class="sc">{</span>name<span class="sc">}</span><span class="ss">&quot;</span>)</span>
+<span id="cb266-169"><a href="#cb266-169" aria-hidden="true" tabindex="-1"></a>    gemeinsam <span class="op">=</span> <span class="bu">set</span>(zweiter) <span class="op">&amp;</span> <span class="bu">set</span>(konflikt)</span>
+<span id="cb266-170"><a href="#cb266-170" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;</span><span class="ch">\n</span><span class="ss">Ueberschneidung mit dem ersten Konflikt: </span><span class="sc">{</span><span class="bu">len</span>(gemeinsam)<span class="sc">}</span><span class="ss"> Bedingungen&quot;</span>)</span>
+<span id="cb266-171"><a href="#cb266-171" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;Ein zweiter, unabhaengiger Widerspruch, den der erste verdeckt hat.&quot;</span>)</span>
+<span id="cb266-172"><a href="#cb266-172" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;Deshalb ist die Konfliktsuche eine Schleife, kein einzelner Aufruf:&quot;</span>)</span>
+<span id="cb266-173"><a href="#cb266-173" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;reparieren, neu suchen, bis das Modell loesbar ist.&quot;</span>)</span>
+<span id="cb266-174"><a href="#cb266-174" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb266-175"><a href="#cb266-175" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb266-176"><a href="#cb266-176" aria-hidden="true" tabindex="-1"></a><span class="kw">def</span> teil_5_die_reihenfolge(alle: <span class="bu">list</span>[<span class="bu">int</span>]) <span class="op">-&gt;</span> <span class="va">None</span>:</span>
+<span id="cb266-177"><a href="#cb266-177" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;</span><span class="ch">\n</span><span class="st">&quot;</span> <span class="op">+</span> <span class="st">&quot;=&quot;</span> <span class="op">*</span> <span class="dv">68</span>)</span>
+<span id="cb266-178"><a href="#cb266-178" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;5. Es gibt nicht DEN Konflikt&quot;</span>)</span>
+<span id="cb266-179"><a href="#cb266-179" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;=&quot;</span> <span class="op">*</span> <span class="dv">68</span>)</span>
+<span id="cb266-180"><a href="#cb266-180" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;Derselbe Filter, nur eine andere Pruefreihenfolge - 200-mal gewuerfelt:</span><span class="ch">\n</span><span class="st">&quot;</span>)</span>
+<span id="cb266-181"><a href="#cb266-181" aria-hidden="true" tabindex="-1"></a>    zufall <span class="op">=</span> np.random.default_rng(<span class="dv">0</span>)</span>
+<span id="cb266-182"><a href="#cb266-182" aria-hidden="true" tabindex="-1"></a>    haeufigkeit: <span class="bu">dict</span>[<span class="bu">tuple</span>[<span class="bu">int</span>, ...], <span class="bu">int</span>] <span class="op">=</span> {}</span>
+<span id="cb266-183"><a href="#cb266-183" aria-hidden="true" tabindex="-1"></a>    <span class="cf">for</span> _ <span class="kw">in</span> <span class="bu">range</span>(<span class="dv">200</span>):</span>
+<span id="cb266-184"><a href="#cb266-184" aria-hidden="true" tabindex="-1"></a>        ordnung <span class="op">=</span> [<span class="bu">int</span>(i) <span class="cf">for</span> i <span class="kw">in</span> zufall.permutation(alle)]</span>
+<span id="cb266-185"><a href="#cb266-185" aria-hidden="true" tabindex="-1"></a>        schluessel <span class="op">=</span> <span class="bu">tuple</span>(<span class="bu">sorted</span>(deletion_filter(ordnung)))</span>
+<span id="cb266-186"><a href="#cb266-186" aria-hidden="true" tabindex="-1"></a>        haeufigkeit[schluessel] <span class="op">=</span> haeufigkeit.get(schluessel, <span class="dv">0</span>) <span class="op">+</span> <span class="dv">1</span></span>
+<span id="cb266-187"><a href="#cb266-187" aria-hidden="true" tabindex="-1"></a>    <span class="cf">for</span> schluessel, anzahl <span class="kw">in</span> <span class="bu">sorted</span>(haeufigkeit.items(), key<span class="op">=</span><span class="kw">lambda</span> p: <span class="op">-</span>p[<span class="dv">1</span>]):</span>
+<span id="cb266-188"><a href="#cb266-188" aria-hidden="true" tabindex="-1"></a>        <span class="bu">print</span>(<span class="ss">f&quot;   </span><span class="sc">{</span>anzahl<span class="sc">:3d}</span><span class="ss">x  </span><span class="sc">{</span><span class="bu">len</span>(schluessel)<span class="sc">}</span><span class="ss"> Bedingungen: &quot;</span></span>
+<span id="cb266-189"><a href="#cb266-189" aria-hidden="true" tabindex="-1"></a>              <span class="ss">f&quot;</span><span class="sc">{</span><span class="st">&#39;, &#39;</span><span class="sc">.</span>join(namen(<span class="bu">list</span>(schluessel)))<span class="sc">}</span><span class="ss">&quot;</span>)</span>
+<span id="cb266-190"><a href="#cb266-190" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;</span><span class="ch">\n</span><span class="sc">{</span><span class="bu">len</span>(haeufigkeit)<span class="sc">}</span><span class="ss"> verschiedene minimale Konflikte in EINEM Modell.&quot;</span>)</span>
+<span id="cb266-191"><a href="#cb266-191" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;Der Filter liefert *einen* kleinsten Konflikt, nicht *den* kleinsten -&quot;</span>)</span>
+<span id="cb266-192"><a href="#cb266-192" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;den gibt es nicht. Alle oben sind gleichermassen korrekt.&quot;</span>)</span>
+<span id="cb266-193"><a href="#cb266-193" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb266-194"><a href="#cb266-194" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb266-195"><a href="#cb266-195" aria-hidden="true" tabindex="-1"></a><span class="kw">def</span> teil_6_den_befund_steuern(alle: <span class="bu">list</span>[<span class="bu">int</span>]) <span class="op">-&gt;</span> <span class="va">None</span>:</span>
+<span id="cb266-196"><a href="#cb266-196" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;</span><span class="ch">\n</span><span class="st">&quot;</span> <span class="op">+</span> <span class="st">&quot;=&quot;</span> <span class="op">*</span> <span class="dv">68</span>)</span>
+<span id="cb266-197"><a href="#cb266-197" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;6. Den Befund brauchbar machen&quot;</span>)</span>
+<span id="cb266-198"><a href="#cb266-198" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;=&quot;</span> <span class="op">*</span> <span class="dv">68</span>)</span>
+<span id="cb266-199"><a href="#cb266-199" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;Der Filter wirft heraus, was er zuerst in die Hand bekommt. Wer die&quot;</span>)</span>
+<span id="cb266-200"><a href="#cb266-200" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;unveraenderlichen Bedingungen zuerst pruefen laesst, bekommt sie eher&quot;</span>)</span>
+<span id="cb266-201"><a href="#cb266-201" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;aus dem Befund heraus - und sieht dafuer mehr Stellschrauben.</span><span class="ch">\n</span><span class="st">&quot;</span>)</span>
+<span id="cb266-202"><a href="#cb266-202" aria-hidden="true" tabindex="-1"></a>    fest <span class="op">=</span> [i <span class="cf">for</span> i <span class="kw">in</span> alle <span class="cf">if</span> BEDINGUNGEN[i][<span class="dv">0</span>] <span class="kw">not</span> <span class="kw">in</span> VERHANDELBAR]</span>
+<span id="cb266-203"><a href="#cb266-203" aria-hidden="true" tabindex="-1"></a>    frei <span class="op">=</span> [i <span class="cf">for</span> i <span class="kw">in</span> alle <span class="cf">if</span> BEDINGUNGEN[i][<span class="dv">0</span>] <span class="kw">in</span> VERHANDELBAR]</span>
+<span id="cb266-204"><a href="#cb266-204" aria-hidden="true" tabindex="-1"></a>    <span class="cf">for</span> titel, ordnung <span class="kw">in</span> ((<span class="st">&quot;unveraenderliche zuerst&quot;</span>, fest <span class="op">+</span> frei),</span>
+<span id="cb266-205"><a href="#cb266-205" aria-hidden="true" tabindex="-1"></a>                           (<span class="st">&quot;veraenderliche zuerst  &quot;</span>, frei <span class="op">+</span> fest)):</span>
+<span id="cb266-206"><a href="#cb266-206" aria-hidden="true" tabindex="-1"></a>        konflikt <span class="op">=</span> <span class="bu">sorted</span>(deletion_filter(ordnung))</span>
+<span id="cb266-207"><a href="#cb266-207" aria-hidden="true" tabindex="-1"></a>        stellschrauben <span class="op">=</span> [i <span class="cf">for</span> i <span class="kw">in</span> konflikt <span class="cf">if</span> BEDINGUNGEN[i][<span class="dv">0</span>] <span class="kw">in</span> VERHANDELBAR]</span>
+<span id="cb266-208"><a href="#cb266-208" aria-hidden="true" tabindex="-1"></a>        <span class="bu">print</span>(<span class="ss">f&quot;   </span><span class="sc">{</span>titel<span class="sc">}</span><span class="ss"> -&gt; </span><span class="sc">{</span><span class="bu">len</span>(konflikt)<span class="sc">}</span><span class="ss"> Bedingungen, davon &quot;</span></span>
+<span id="cb266-209"><a href="#cb266-209" aria-hidden="true" tabindex="-1"></a>              <span class="ss">f&quot;</span><span class="sc">{</span><span class="bu">len</span>(stellschrauben)<span class="sc">}</span><span class="ss"> veraenderlich&quot;</span>)</span>
+<span id="cb266-210"><a href="#cb266-210" aria-hidden="true" tabindex="-1"></a>        <span class="bu">print</span>(<span class="ss">f&quot;      </span><span class="sc">{</span><span class="st">&#39;, &#39;</span><span class="sc">.</span>join(namen(konflikt))<span class="sc">}</span><span class="ss">&quot;</span>)</span>
+<span id="cb266-211"><a href="#cb266-211" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;</span><span class="ch">\n</span><span class="st">Beide Befunde sind wahr. Nur einer davon nennt dem Planer etwas,&quot;</span>)</span>
+<span id="cb266-212"><a href="#cb266-212" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;das er tatsaechlich tun kann.&quot;</span>)</span>
+<span id="cb266-213"><a href="#cb266-213" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb266-214"><a href="#cb266-214" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb266-215"><a href="#cb266-215" aria-hidden="true" tabindex="-1"></a><span class="cf">if</span> <span class="va">__name__</span> <span class="op">==</span> <span class="st">&quot;__main__&quot;</span>:</span>
+<span id="cb266-216"><a href="#cb266-216" aria-hidden="true" tabindex="-1"></a>    alle <span class="op">=</span> <span class="bu">list</span>(<span class="bu">range</span>(<span class="bu">len</span>(BEDINGUNGEN)))</span>
+<span id="cb266-217"><a href="#cb266-217" aria-hidden="true" tabindex="-1"></a>    teil_1_der_befund(alle)</span>
+<span id="cb266-218"><a href="#cb266-218" aria-hidden="true" tabindex="-1"></a>    teil_2_die_naive_suche(alle)</span>
+<span id="cb266-219"><a href="#cb266-219" aria-hidden="true" tabindex="-1"></a>    konflikt <span class="op">=</span> teil_3_der_filter(alle)</span>
+<span id="cb266-220"><a href="#cb266-220" aria-hidden="true" tabindex="-1"></a>    teil_4_der_naechste_konflikt(alle, konflikt)</span>
+<span id="cb266-221"><a href="#cb266-221" aria-hidden="true" tabindex="-1"></a>    teil_5_die_reihenfolge(alle)</span>
+<span id="cb266-222"><a href="#cb266-222" aria-hidden="true" tabindex="-1"></a>    teil_6_den_befund_steuern(alle)</span>
+<span id="cb266-223"><a href="#cb266-223" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;</span><span class="ch">\n</span><span class="st">&quot;</span> <span class="op">+</span> <span class="st">&quot;=&quot;</span> <span class="op">*</span> <span class="dv">68</span>)</span>
+<span id="cb266-224"><a href="#cb266-224" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;Insgesamt </span><span class="sc">{</span>aufrufe<span class="sc">}</span><span class="ss"> Solveraufrufe fuer die gesamte Diagnose.&quot;</span>)</span>
+<span id="cb266-225"><a href="#cb266-225" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;=&quot;</span> <span class="op">*</span> <span class="dv">68</span>)</span></code></pre></div>
 <p>Die Ausgabe:</p>
 <pre class="text"><code>====================================================================
 1. Was der Solver sagt
@@ -30607,31 +32265,31 @@ Insgesamt 2874 Solveraufrufe fuer die gesamte Diagnose.
 <li><strong>Vorzeichenfehler.</strong> Sie minimieren, wo Sie maximieren wollten (oder umgekehrt), und der Zielwert läuft in die falsche Richtung davon.</li>
 <li><strong>Freie Variablen ohne Nichtnegativität.</strong> <code>bounds=[(None, None)]</code> statt <code>[(0, None)]</code>.</li>
 </ol>
-<div class="sourceCode" id="cb264"><pre class="sourceCode python"><code class="sourceCode python"><span id="cb264-1"><a href="#cb264-1" aria-hidden="true" tabindex="-1"></a><span class="co"># Diagnose: kuenstliche Schranke einziehen und sehen, wohin es laeuft</span></span>
-<span id="cb264-2"><a href="#cb264-2" aria-hidden="true" tabindex="-1"></a>bounds <span class="op">=</span> [(<span class="dv">0</span>, <span class="fl">1e6</span>)] <span class="op">*</span> n</span>
-<span id="cb264-3"><a href="#cb264-3" aria-hidden="true" tabindex="-1"></a>res <span class="op">=</span> linprog(...)</span>
-<span id="cb264-4"><a href="#cb264-4" aria-hidden="true" tabindex="-1"></a>gross <span class="op">=</span> [j <span class="cf">for</span> j <span class="kw">in</span> <span class="bu">range</span>(n) <span class="cf">if</span> res.x[j] <span class="op">&gt;</span> <span class="fl">1e5</span>]</span>
-<span id="cb264-5"><a href="#cb264-5" aria-hidden="true" tabindex="-1"></a><span class="bu">print</span>(<span class="ss">f&quot;Diese Variablen laufen an die Kunstschranke: </span><span class="sc">{</span>gross<span class="sc">}</span><span class="ss">&quot;</span>)</span></code></pre></div>
+<div class="sourceCode" id="cb268"><pre class="sourceCode python"><code class="sourceCode python"><span id="cb268-1"><a href="#cb268-1" aria-hidden="true" tabindex="-1"></a><span class="co"># Diagnose: kuenstliche Schranke einziehen und sehen, wohin es laeuft</span></span>
+<span id="cb268-2"><a href="#cb268-2" aria-hidden="true" tabindex="-1"></a>bounds <span class="op">=</span> [(<span class="dv">0</span>, <span class="fl">1e6</span>)] <span class="op">*</span> n</span>
+<span id="cb268-3"><a href="#cb268-3" aria-hidden="true" tabindex="-1"></a>res <span class="op">=</span> linprog(...)</span>
+<span id="cb268-4"><a href="#cb268-4" aria-hidden="true" tabindex="-1"></a>gross <span class="op">=</span> [j <span class="cf">for</span> j <span class="kw">in</span> <span class="bu">range</span>(n) <span class="cf">if</span> res.x[j] <span class="op">&gt;</span> <span class="fl">1e5</span>]</span>
+<span id="cb268-5"><a href="#cb268-5" aria-hidden="true" tabindex="-1"></a><span class="bu">print</span>(<span class="ss">f&quot;Diese Variablen laufen an die Kunstschranke: </span><span class="sc">{</span>gross<span class="sc">}</span><span class="ss">&quot;</span>)</span></code></pre></div>
 <p>Die so gefundenen Variablen sind die, denen eine echte Beschränkung fehlt.</p>
 <hr />
 <h2 id="c3-zu-langsam">C3 — Zu langsam</h2>
 <h3 id="diagnosereihenfolge">Diagnosereihenfolge</h3>
 <p><strong>1. Ist es überhaupt das Lösen?</strong></p>
-<div class="sourceCode" id="cb265"><pre class="sourceCode python"><code class="sourceCode python"><span id="cb265-1"><a href="#cb265-1" aria-hidden="true" tabindex="-1"></a><span class="im">import</span> time</span>
-<span id="cb265-2"><a href="#cb265-2" aria-hidden="true" tabindex="-1"></a>t0 <span class="op">=</span> time.perf_counter()<span class="op">;</span> modell_bauen()<span class="op">;</span> t1 <span class="op">=</span> time.perf_counter()</span>
-<span id="cb265-3"><a href="#cb265-3" aria-hidden="true" tabindex="-1"></a>loesen()<span class="op">;</span>                                  t2 <span class="op">=</span> time.perf_counter()</span>
-<span id="cb265-4"><a href="#cb265-4" aria-hidden="true" tabindex="-1"></a><span class="bu">print</span>(<span class="ss">f&quot;Aufbau </span><span class="sc">{</span>t1<span class="op">-</span>t0<span class="sc">:.2f}</span><span class="ss">s | Loesen </span><span class="sc">{</span>t2<span class="op">-</span>t1<span class="sc">:.2f}</span><span class="ss">s&quot;</span>)</span></code></pre></div>
+<div class="sourceCode" id="cb269"><pre class="sourceCode python"><code class="sourceCode python"><span id="cb269-1"><a href="#cb269-1" aria-hidden="true" tabindex="-1"></a><span class="im">import</span> time</span>
+<span id="cb269-2"><a href="#cb269-2" aria-hidden="true" tabindex="-1"></a>t0 <span class="op">=</span> time.perf_counter()<span class="op">;</span> modell_bauen()<span class="op">;</span> t1 <span class="op">=</span> time.perf_counter()</span>
+<span id="cb269-3"><a href="#cb269-3" aria-hidden="true" tabindex="-1"></a>loesen()<span class="op">;</span>                                  t2 <span class="op">=</span> time.perf_counter()</span>
+<span id="cb269-4"><a href="#cb269-4" aria-hidden="true" tabindex="-1"></a><span class="bu">print</span>(<span class="ss">f&quot;Aufbau </span><span class="sc">{</span>t1<span class="op">-</span>t0<span class="sc">:.2f}</span><span class="ss">s | Loesen </span><span class="sc">{</span>t2<span class="op">-</span>t1<span class="sc">:.2f}</span><span class="ss">s&quot;</span>)</span></code></pre></div>
 <p>Bei CVXPY und bei Schleifen über Szenarien ist oft der <strong>Aufbau</strong> der Engpass, nicht der Solver (siehe <a href="#sec:cvar-implementierung-cvar-portfolio-mit-reibung">Abschnitt 20.6</a>).</p>
 <p><strong>2. Big-M zu groß?</strong> Der häufigste Grund für explodierende MILP-Laufzeiten. Setzen Sie <span class="math inline">M</span> auf die kleinste gültige Schranke (<a href="#sec:milp-modellierungstricks-big-m-und-logische-bedingungen">Abschnitt 6.5</a>).</p>
 <p><strong>3. Symmetrie im Modell?</strong> Identische Maschinen, austauschbare Mitarbeitende, gleichwertige Fahrzeuge — der Solver durchsucht alle Vertauschungen. Abhilfe: Ordnungsbedingungen (Muster B20).</p>
 <p><strong>4. Falsche Solverfamilie?</strong> Zuordnungsprobleme mit MILP, Routing mit CP-SAT von Hand nachgebaut, konvexe Probleme mit <code>scipy.optimize.minimize</code> — jeweils Größenordnungen langsamer als das passende Werkzeug (<a href="#sec:oekosystem-wann-lohnt-sich-welche-ebene">Abschnitt 3.6</a>).</p>
 <p><strong>5. Wird vektorisiert?</strong></p>
-<div class="sourceCode" id="cb266"><pre class="sourceCode python"><code class="sourceCode python"><span id="cb266-1"><a href="#cb266-1" aria-hidden="true" tabindex="-1"></a><span class="co"># langsam:                       # schnell:</span></span>
-<span id="cb266-2"><a href="#cb266-2" aria-hidden="true" tabindex="-1"></a><span class="cf">for</span> s <span class="kw">in</span> <span class="bu">range</span>(S):               constraints.append(u <span class="op">&gt;=</span> <span class="op">-</span>(R <span class="op">@</span> w) <span class="op">-</span> gamma)</span>
-<span id="cb266-3"><a href="#cb266-3" aria-hidden="true" tabindex="-1"></a>    constraints.append(u[s] <span class="op">&gt;=</span> <span class="op">-</span>R[s] <span class="op">@</span> w <span class="op">-</span> gamma)</span></code></pre></div>
+<div class="sourceCode" id="cb270"><pre class="sourceCode python"><code class="sourceCode python"><span id="cb270-1"><a href="#cb270-1" aria-hidden="true" tabindex="-1"></a><span class="co"># langsam:                       # schnell:</span></span>
+<span id="cb270-2"><a href="#cb270-2" aria-hidden="true" tabindex="-1"></a><span class="cf">for</span> s <span class="kw">in</span> <span class="bu">range</span>(S):               constraints.append(u <span class="op">&gt;=</span> <span class="op">-</span>(R <span class="op">@</span> w) <span class="op">-</span> gamma)</span>
+<span id="cb270-3"><a href="#cb270-3" aria-hidden="true" tabindex="-1"></a>    constraints.append(u[s] <span class="op">&gt;=</span> <span class="op">-</span>R[s] <span class="op">@</span> w <span class="op">-</span> gamma)</span></code></pre></div>
 <p><strong>6. Gap akzeptieren.</strong></p>
-<div class="sourceCode" id="cb267"><pre class="sourceCode python"><code class="sourceCode python"><span id="cb267-1"><a href="#cb267-1" aria-hidden="true" tabindex="-1"></a>loeser.parameters.relative_gap_limit <span class="op">=</span> <span class="fl">0.02</span>     <span class="co"># CP-SAT</span></span>
-<span id="cb267-2"><a href="#cb267-2" aria-hidden="true" tabindex="-1"></a>loeser.parameters.max_time_in_seconds <span class="op">=</span> <span class="fl">30.0</span></span></code></pre></div>
+<div class="sourceCode" id="cb271"><pre class="sourceCode python"><code class="sourceCode python"><span id="cb271-1"><a href="#cb271-1" aria-hidden="true" tabindex="-1"></a>loeser.parameters.relative_gap_limit <span class="op">=</span> <span class="fl">0.02</span>     <span class="co"># CP-SAT</span></span>
+<span id="cb271-2"><a href="#cb271-2" aria-hidden="true" tabindex="-1"></a>loeser.parameters.max_time_in_seconds <span class="op">=</span> <span class="fl">30.0</span></span></code></pre></div>
 <p>Bei ±10 % Datenunsicherheit sind die letzten 2 % Optimalität verlorene Zeit.</p>
 <hr />
 <h2 id="c4-unsinniges-ergebnis">C4 — Unsinniges Ergebnis</h2>
@@ -30645,12 +32303,12 @@ Insgesamt 2874 Solveraufrufe fuer die gesamte Diagnose.
 <li><label><input type="checkbox" /><strong>Index-Reihenfolge.</strong> Zeilen und Spalten vertauscht? Siehe C11.</label></li>
 </ul>
 <h3 id="die-wirksamste-gegenmaßnahme">Die wirksamste Gegenmaßnahme</h3>
-<div class="sourceCode" id="cb268"><pre class="sourceCode python"><code class="sourceCode python"><span id="cb268-1"><a href="#cb268-1" aria-hidden="true" tabindex="-1"></a><span class="co"># Nach JEDEM Lösen: alle Regeln explizit nachprüfen</span></span>
-<span id="cb268-2"><a href="#cb268-2" aria-hidden="true" tabindex="-1"></a><span class="cf">assert</span> <span class="bu">abs</span>(w.<span class="bu">sum</span>() <span class="op">-</span> <span class="dv">1</span>) <span class="op">&lt;</span> <span class="fl">1e-6</span>,       <span class="st">&quot;Budget nicht eingehalten&quot;</span></span>
-<span id="cb268-3"><a href="#cb268-3" aria-hidden="true" tabindex="-1"></a><span class="cf">assert</span> w.<span class="bu">min</span>() <span class="op">&gt;</span> <span class="op">-</span><span class="fl">1e-9</span>,               <span class="st">&quot;negatives Gewicht&quot;</span></span>
-<span id="cb268-4"><a href="#cb268-4" aria-hidden="true" tabindex="-1"></a><span class="cf">assert</span> w.<span class="bu">max</span>() <span class="op">&lt;=</span> grenze <span class="op">+</span> <span class="fl">1e-9</span>,      <span class="st">&quot;Positionsgrenze verletzt&quot;</span></span>
-<span id="cb268-5"><a href="#cb268-5" aria-hidden="true" tabindex="-1"></a><span class="cf">for</span> sektor, idx <span class="kw">in</span> sektoren.items():</span>
-<span id="cb268-6"><a href="#cb268-6" aria-hidden="true" tabindex="-1"></a>    <span class="cf">assert</span> w[idx].<span class="bu">sum</span>() <span class="op">&lt;=</span> limit[sektor] <span class="op">+</span> <span class="fl">1e-9</span>, <span class="ss">f&quot;Sektor </span><span class="sc">{</span>sektor<span class="sc">}</span><span class="ss"> verletzt&quot;</span></span></code></pre></div>
+<div class="sourceCode" id="cb272"><pre class="sourceCode python"><code class="sourceCode python"><span id="cb272-1"><a href="#cb272-1" aria-hidden="true" tabindex="-1"></a><span class="co"># Nach JEDEM Lösen: alle Regeln explizit nachprüfen</span></span>
+<span id="cb272-2"><a href="#cb272-2" aria-hidden="true" tabindex="-1"></a><span class="cf">assert</span> <span class="bu">abs</span>(w.<span class="bu">sum</span>() <span class="op">-</span> <span class="dv">1</span>) <span class="op">&lt;</span> <span class="fl">1e-6</span>,       <span class="st">&quot;Budget nicht eingehalten&quot;</span></span>
+<span id="cb272-3"><a href="#cb272-3" aria-hidden="true" tabindex="-1"></a><span class="cf">assert</span> w.<span class="bu">min</span>() <span class="op">&gt;</span> <span class="op">-</span><span class="fl">1e-9</span>,               <span class="st">&quot;negatives Gewicht&quot;</span></span>
+<span id="cb272-4"><a href="#cb272-4" aria-hidden="true" tabindex="-1"></a><span class="cf">assert</span> w.<span class="bu">max</span>() <span class="op">&lt;=</span> grenze <span class="op">+</span> <span class="fl">1e-9</span>,      <span class="st">&quot;Positionsgrenze verletzt&quot;</span></span>
+<span id="cb272-5"><a href="#cb272-5" aria-hidden="true" tabindex="-1"></a><span class="cf">for</span> sektor, idx <span class="kw">in</span> sektoren.items():</span>
+<span id="cb272-6"><a href="#cb272-6" aria-hidden="true" tabindex="-1"></a>    <span class="cf">assert</span> w[idx].<span class="bu">sum</span>() <span class="op">&lt;=</span> limit[sektor] <span class="op">+</span> <span class="fl">1e-9</span>, <span class="ss">f&quot;Sektor </span><span class="sc">{</span>sektor<span class="sc">}</span><span class="ss"> verletzt&quot;</span></span></code></pre></div>
 <p>Diese Zeilen kosten Sekunden und fangen die Fehlerklasse ab, die der Solver <strong>nicht</strong> melden kann: dass Ihr Modell etwas anderes beschreibt, als Sie glauben.</p>
 <hr />
 <h2 id="c5-instabile-lösung">C5 — Instabile Lösung</h2>
@@ -30692,37 +32350,37 @@ Insgesamt 2874 Solveraufrufe fuer die gesamte Diagnose.
 </tr>
 </tbody>
 </table>
-<div class="sourceCode" id="cb269"><pre class="sourceCode python"><code class="sourceCode python"><span id="cb269-1"><a href="#cb269-1" aria-hidden="true" tabindex="-1"></a>eig <span class="op">=</span> np.linalg.eigvalsh(Sigma)</span>
-<span id="cb269-2"><a href="#cb269-2" aria-hidden="true" tabindex="-1"></a><span class="bu">print</span>(<span class="ss">f&quot;Kondition </span><span class="sc">{</span>eig<span class="sc">.</span><span class="bu">max</span>()<span class="op">/</span>eig<span class="sc">.</span><span class="bu">min</span>()<span class="sc">:.0f}</span><span class="ss"> | kleinster EW </span><span class="sc">{</span>eig<span class="sc">.</span><span class="bu">min</span>()<span class="sc">:.2e}</span><span class="ss">&quot;</span>)</span>
-<span id="cb269-3"><a href="#cb269-3" aria-hidden="true" tabindex="-1"></a><span class="co"># Faustregel: Kondition &gt; 1000 ist bedenklich, &gt; 10000 kritisch</span></span></code></pre></div>
+<div class="sourceCode" id="cb273"><pre class="sourceCode python"><code class="sourceCode python"><span id="cb273-1"><a href="#cb273-1" aria-hidden="true" tabindex="-1"></a>eig <span class="op">=</span> np.linalg.eigvalsh(Sigma)</span>
+<span id="cb273-2"><a href="#cb273-2" aria-hidden="true" tabindex="-1"></a><span class="bu">print</span>(<span class="ss">f&quot;Kondition </span><span class="sc">{</span>eig<span class="sc">.</span><span class="bu">max</span>()<span class="op">/</span>eig<span class="sc">.</span><span class="bu">min</span>()<span class="sc">:.0f}</span><span class="ss"> | kleinster EW </span><span class="sc">{</span>eig<span class="sc">.</span><span class="bu">min</span>()<span class="sc">:.2e}</span><span class="ss">&quot;</span>)</span>
+<span id="cb273-3"><a href="#cb273-3" aria-hidden="true" tabindex="-1"></a><span class="co"># Faustregel: Kondition &gt; 1000 ist bedenklich, &gt; 10000 kritisch</span></span></code></pre></div>
 <h3 id="derselbe-fehler-außerhalb-der-finanzwelt">Derselbe Fehler außerhalb der Finanzwelt</h3>
 <p>Instabilität ist kein Portfolioproblem, sondern ein Skalierungsproblem — und es trifft jedes Modell, in dem Größen sehr verschiedener Ordnung nebeneinanderstehen. Euro-Beträge (<span class="math inline">10^7</span>) und Tonnen-Angaben (<span class="math inline">10^{-3}</span>) in derselben Matrix erzeugen eine Konditionszahl, die aus einer Datenunsicherheit von 0,1 % eine Lösungsänderung von 100 % machen kann. Die Konditionszahl ist genau die Obergrenze dieses Verstärkungsfaktors.</p>
-<div class="sourceCode" id="cb270"><pre class="sourceCode python"><code class="sourceCode python"><span id="cb270-1"><a href="#cb270-1" aria-hidden="true" tabindex="-1"></a><span class="bu">print</span>(<span class="ss">f&quot;Kondition der Restriktionsmatrix: </span><span class="sc">{</span>np<span class="sc">.</span>linalg<span class="sc">.</span>cond(A)<span class="sc">:.1e}</span><span class="ss">&quot;</span>)</span>
-<span id="cb270-2"><a href="#cb270-2" aria-hidden="true" tabindex="-1"></a><span class="co"># Grobe Peilung: Wertebereiche der Koeffizienten anschauen</span></span>
-<span id="cb270-3"><a href="#cb270-3" aria-hidden="true" tabindex="-1"></a><span class="bu">print</span>(<span class="ss">f&quot;kleinster / groesster Betrag: </span><span class="sc">{</span>np<span class="sc">.</span><span class="bu">abs</span>(A[A <span class="op">!=</span> <span class="dv">0</span>])<span class="sc">.</span><span class="bu">min</span>()<span class="sc">:.1e}</span><span class="ss"> &quot;</span></span>
-<span id="cb270-4"><a href="#cb270-4" aria-hidden="true" tabindex="-1"></a>      <span class="ss">f&quot;/ </span><span class="sc">{</span>np<span class="sc">.</span><span class="bu">abs</span>(A)<span class="sc">.</span><span class="bu">max</span>()<span class="sc">:.1e}</span><span class="ss">&quot;</span>)</span></code></pre></div>
+<div class="sourceCode" id="cb274"><pre class="sourceCode python"><code class="sourceCode python"><span id="cb274-1"><a href="#cb274-1" aria-hidden="true" tabindex="-1"></a><span class="bu">print</span>(<span class="ss">f&quot;Kondition der Restriktionsmatrix: </span><span class="sc">{</span>np<span class="sc">.</span>linalg<span class="sc">.</span>cond(A)<span class="sc">:.1e}</span><span class="ss">&quot;</span>)</span>
+<span id="cb274-2"><a href="#cb274-2" aria-hidden="true" tabindex="-1"></a><span class="co"># Grobe Peilung: Wertebereiche der Koeffizienten anschauen</span></span>
+<span id="cb274-3"><a href="#cb274-3" aria-hidden="true" tabindex="-1"></a><span class="bu">print</span>(<span class="ss">f&quot;kleinster / groesster Betrag: </span><span class="sc">{</span>np<span class="sc">.</span><span class="bu">abs</span>(A[A <span class="op">!=</span> <span class="dv">0</span>])<span class="sc">.</span><span class="bu">min</span>()<span class="sc">:.1e}</span><span class="ss"> &quot;</span></span>
+<span id="cb274-4"><a href="#cb274-4" aria-hidden="true" tabindex="-1"></a>      <span class="ss">f&quot;/ </span><span class="sc">{</span>np<span class="sc">.</span><span class="bu">abs</span>(A)<span class="sc">.</span><span class="bu">max</span>()<span class="sc">:.1e}</span><span class="ss">&quot;</span>)</span></code></pre></div>
 <p>Klaffen die Beträge um mehr als drei, vier Größenordnungen auseinander, rechnen Sie in anderen Einheiten (Tausend Euro statt Euro, Kilogramm statt Tonnen) oder skalieren Sie Zeilen und Spalten automatisch. <code>Skalierung_Kondition.py</code> zeigt beides samt Ruiz-Equilibrierung (<a href="#sec:fundament-kondition">Abschnitt 2.7</a>).</p>
 <hr />
 <h2 id="c6-falsche-dualwerte">C6 — Falsche Dualwerte</h2>
 <p><strong>Symptom.</strong> Schattenpreise sind negativ, wo sie positiv sein sollten — oder null bei einer offensichtlich knappen Ressource.</p>
 <h3 id="die-drei-prüfungen">Die drei Prüfungen</h3>
 <p><strong>1. Vorzeichenkonvention.</strong> Haben Sie zur Maximierung negiert?</p>
-<div class="sourceCode" id="cb271"><pre class="sourceCode python"><code class="sourceCode python"><span id="cb271-1"><a href="#cb271-1" aria-hidden="true" tabindex="-1"></a>schattenpreise <span class="op">=</span> <span class="op">-</span>res.ineqlin.marginals    <span class="co"># bei linprog nach Negation</span></span></code></pre></div>
+<div class="sourceCode" id="cb275"><pre class="sourceCode python"><code class="sourceCode python"><span id="cb275-1"><a href="#cb275-1" aria-hidden="true" tabindex="-1"></a>schattenpreise <span class="op">=</span> <span class="op">-</span>res.ineqlin.marginals    <span class="co"># bei linprog nach Negation</span></span></code></pre></div>
 <p>Genau das ist die Vorzeichenfalle aus <a href="#sec:lp-die-vorzeichenfalle-bei-schattenpreisen">Abschnitt 5.7</a>.</p>
 <p><strong>2. Komplementärer Schlupf.</strong></p>
-<div class="sourceCode" id="cb272"><pre class="sourceCode python"><code class="sourceCode python"><span id="cb272-1"><a href="#cb272-1" aria-hidden="true" tabindex="-1"></a><span class="cf">for</span> s, y <span class="kw">in</span> <span class="bu">zip</span>(res.slack, schattenpreise):</span>
-<span id="cb272-2"><a href="#cb272-2" aria-hidden="true" tabindex="-1"></a>    <span class="cf">assert</span> <span class="bu">abs</span>(s <span class="op">*</span> y) <span class="op">&lt;</span> <span class="fl">1e-6</span>, <span class="st">&quot;Komplementaerer Schlupf verletzt!&quot;</span></span></code></pre></div>
+<div class="sourceCode" id="cb276"><pre class="sourceCode python"><code class="sourceCode python"><span id="cb276-1"><a href="#cb276-1" aria-hidden="true" tabindex="-1"></a><span class="cf">for</span> s, y <span class="kw">in</span> <span class="bu">zip</span>(res.slack, schattenpreise):</span>
+<span id="cb276-2"><a href="#cb276-2" aria-hidden="true" tabindex="-1"></a>    <span class="cf">assert</span> <span class="bu">abs</span>(s <span class="op">*</span> y) <span class="op">&lt;</span> <span class="fl">1e-6</span>, <span class="st">&quot;Komplementaerer Schlupf verletzt!&quot;</span></span></code></pre></div>
 <p>Eine Ressource mit Reserve <strong>muss</strong> Schattenpreis 0 haben.</p>
 <p><strong>3. Numerische Gegenprobe — der zuverlässigste Test.</strong></p>
-<div class="sourceCode" id="cb273"><pre class="sourceCode python"><code class="sourceCode python"><span id="cb273-1"><a href="#cb273-1" aria-hidden="true" tabindex="-1"></a>b_plus <span class="op">=</span> b.copy()<span class="op">;</span> b_plus[i] <span class="op">+=</span> <span class="fl">1.0</span></span>
-<span id="cb273-2"><a href="#cb273-2" aria-hidden="true" tabindex="-1"></a>zuwachs <span class="op">=</span> loese(b_plus) <span class="op">-</span> loese(b)</span>
-<span id="cb273-3"><a href="#cb273-3" aria-hidden="true" tabindex="-1"></a><span class="cf">assert</span> <span class="bu">abs</span>(zuwachs <span class="op">-</span> schattenpreise[i]) <span class="op">&lt;</span> <span class="fl">1e-6</span></span></code></pre></div>
+<div class="sourceCode" id="cb277"><pre class="sourceCode python"><code class="sourceCode python"><span id="cb277-1"><a href="#cb277-1" aria-hidden="true" tabindex="-1"></a>b_plus <span class="op">=</span> b.copy()<span class="op">;</span> b_plus[i] <span class="op">+=</span> <span class="fl">1.0</span></span>
+<span id="cb277-2"><a href="#cb277-2" aria-hidden="true" tabindex="-1"></a>zuwachs <span class="op">=</span> loese(b_plus) <span class="op">-</span> loese(b)</span>
+<span id="cb277-3"><a href="#cb277-3" aria-hidden="true" tabindex="-1"></a><span class="cf">assert</span> <span class="bu">abs</span>(zuwachs <span class="op">-</span> schattenpreise[i]) <span class="op">&lt;</span> <span class="fl">1e-6</span></span></code></pre></div>
 <p>Dieser Test ist <strong>unabhängig von jeder Vorzeichenkonvention</strong>. Nutzen Sie ihn.</p>
 <p><strong>4. Wenn alle drei Prüfungen bestehen und der Wert trotzdem seltsam ist: Entartung.</strong> Die drei Prüfungen oben setzen voraus, dass es <em>einen</em> richtigen Schattenpreis gibt. Bei einem entarteten Optimum — mehr aktive Nebenbedingungen als Variablen — gibt es den nicht. Der Wert ist dann nicht falsch, sondern <strong>mehrdeutig</strong>: zwei korrekte Solver liefern für dasselbe Optimum verschiedene Dualwerte, und die numerische Gegenprobe aus Schritt 3 schlägt fehl, weil der Zuwachs nach links und nach rechts unterschiedlich ausfällt.</p>
-<div class="sourceCode" id="cb274"><pre class="sourceCode python"><code class="sourceCode python"><span id="cb274-1"><a href="#cb274-1" aria-hidden="true" tabindex="-1"></a>aktiv <span class="op">=</span> <span class="bu">int</span>(np.<span class="bu">sum</span>(res.slack <span class="op">&lt;</span> <span class="fl">1e-9</span>))          <span class="co"># wie viele Bedingungen sind straff?</span></span>
-<span id="cb274-2"><a href="#cb274-2" aria-hidden="true" tabindex="-1"></a><span class="cf">if</span> aktiv <span class="op">&gt;</span> <span class="bu">len</span>(res.x):</span>
-<span id="cb274-3"><a href="#cb274-3" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;Entartet: </span><span class="sc">{</span>aktiv<span class="sc">}</span><span class="ss"> aktive Bedingungen bei </span><span class="sc">{</span><span class="bu">len</span>(res.x)<span class="sc">}</span><span class="ss"> Variablen.&quot;</span>)</span>
-<span id="cb274-4"><a href="#cb274-4" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;Einen einzelnen Schattenpreis zu berichten waere hier irrefuehrend.&quot;</span>)</span></code></pre></div>
+<div class="sourceCode" id="cb278"><pre class="sourceCode python"><code class="sourceCode python"><span id="cb278-1"><a href="#cb278-1" aria-hidden="true" tabindex="-1"></a>aktiv <span class="op">=</span> <span class="bu">int</span>(np.<span class="bu">sum</span>(res.slack <span class="op">&lt;</span> <span class="fl">1e-9</span>))          <span class="co"># wie viele Bedingungen sind straff?</span></span>
+<span id="cb278-2"><a href="#cb278-2" aria-hidden="true" tabindex="-1"></a><span class="cf">if</span> aktiv <span class="op">&gt;</span> <span class="bu">len</span>(res.x):</span>
+<span id="cb278-3"><a href="#cb278-3" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;Entartet: </span><span class="sc">{</span>aktiv<span class="sc">}</span><span class="ss"> aktive Bedingungen bei </span><span class="sc">{</span><span class="bu">len</span>(res.x)<span class="sc">}</span><span class="ss"> Variablen.&quot;</span>)</span>
+<span id="cb278-4"><a href="#cb278-4" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;Einen einzelnen Schattenpreis zu berichten waere hier irrefuehrend.&quot;</span>)</span></code></pre></div>
 <p>Die belastbare Antwort ist dann keine Zahl, sondern eine <strong>Spanne</strong> über alle optimalen Dualwerte — <code>Toleranzen_und_Entartung.py</code> rechnet sie vor (<a href="#sec:lp-entartung">Abschnitt 5.9</a>).</p>
 <hr />
 <h2 id="c7-widersprüchliche-solver">C7 — Widersprüchliche Solver</h2>
@@ -30778,24 +32436,24 @@ Insgesamt 2874 Solveraufrufe fuer die gesamte Diagnose.
 </tr>
 </tbody>
 </table>
-<div class="sourceCode" id="cb276"><pre class="sourceCode python"><code class="sourceCode python"><span id="cb276-1"><a href="#cb276-1" aria-hidden="true" tabindex="-1"></a><span class="bu">print</span>(problem.is_dcp())                      <span class="co"># False?</span></span>
-<span id="cb276-2"><a href="#cb276-2" aria-hidden="true" tabindex="-1"></a><span class="cf">for</span> c <span class="kw">in</span> problem.constraints:</span>
-<span id="cb276-3"><a href="#cb276-3" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(c.is_dcp(), c)                     <span class="co"># zeigt die Schuldige</span></span>
-<span id="cb276-4"><a href="#cb276-4" aria-hidden="true" tabindex="-1"></a><span class="bu">print</span>(problem.objective.is_dcp())</span></code></pre></div>
+<div class="sourceCode" id="cb280"><pre class="sourceCode python"><code class="sourceCode python"><span id="cb280-1"><a href="#cb280-1" aria-hidden="true" tabindex="-1"></a><span class="bu">print</span>(problem.is_dcp())                      <span class="co"># False?</span></span>
+<span id="cb280-2"><a href="#cb280-2" aria-hidden="true" tabindex="-1"></a><span class="cf">for</span> c <span class="kw">in</span> problem.constraints:</span>
+<span id="cb280-3"><a href="#cb280-3" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(c.is_dcp(), c)                     <span class="co"># zeigt die Schuldige</span></span>
+<span id="cb280-4"><a href="#cb280-4" aria-hidden="true" tabindex="-1"></a><span class="bu">print</span>(problem.objective.is_dcp())</span></code></pre></div>
 <hr />
 <h2 id="c9-importfehler">C9 — Importfehler</h2>
 <pre><code>ImportError: .../highspy/_core...so: undefined symbol: _ZN5Highs13releaseMemoryEv</code></pre>
 <p><strong>Ursache.</strong> <code>ortools</code> und <code>highspy</code> bringen beide eine eigene HiGHS-Kopie mit; sie lassen sich auf vielen Systemen <strong>nicht im selben Prozess</strong> importieren (siehe <a href="#sec:oekosystem-ein-system-vier-programmieransaetze">Abschnitt 3.5</a>). Der Konflikt entsteht auch <strong>indirekt</strong>: <code>cvxpy</code> importiert ein installiertes <code>highspy</code> bei der Solver-Erkennung selbst mit — ein Skript, das erst <code>cvxpy</code> und dann <code>ortools</code> importiert, crasht daher mit derselben Meldung.</p>
-<p><strong>Abhilfen (in dieser Reihenfolge):</strong> 1. Nur eines von beiden im selben Skript verwenden. 2. Getrennte Prozesse (<code>subprocess</code>) — siehe <code>Ein_System_Vier_Ansaetze.py</code>. 3. Auf <code>highspy</code> verzichten: HiGHS ist ohnehin Backend von <code>scipy.optimize.linprog</code> und CVXPY. 4. Getrennte virtuelle Umgebungen.</p>
+<p><strong>Abhilfen (in dieser Reihenfolge):</strong> 1. Nur eines von beiden im selben Skript verwenden. 2. Getrennte Prozesse — ein <code>ProcessPoolExecutor</code> mit <code>mp_context="spawn"</code> und <code>max_tasks_per_child=1</code>, siehe <code>Ein_System_Vier_Ansaetze.py</code>. 3. Auf <code>highspy</code> verzichten: HiGHS ist ohnehin Backend von <code>scipy.optimize.linprog</code> und CVXPY. 4. Getrennte virtuelle Umgebungen.</p>
 <hr />
 <h2 id="c10-verdächtig-guter-backtest">C10 — Verdächtig guter Backtest</h2>
 <p><strong>Faustregel:</strong> Eine Sharpe Ratio über 2 bei einer einfachen Strategie ist fast immer ein Fehler, kein Fund.</p>
 <h3 id="prüfreihenfolge">Prüfreihenfolge</h3>
 <p><strong>1. Lookahead-Selbsttest.</strong></p>
-<div class="sourceCode" id="cb278"><pre class="sourceCode python"><code class="sourceCode python"><span id="cb278-1"><a href="#cb278-1" aria-hidden="true" tabindex="-1"></a>signal_vorher <span class="op">=</span> berechne_signal(stichtag)</span>
-<span id="cb278-2"><a href="#cb278-2" aria-hidden="true" tabindex="-1"></a>kurse.loc[kurse.index <span class="op">&gt;</span> stichtag] <span class="op">*=</span> <span class="fl">3.0</span></span>
-<span id="cb278-3"><a href="#cb278-3" aria-hidden="true" tabindex="-1"></a>signal_nachher <span class="op">=</span> berechne_signal(stichtag)</span>
-<span id="cb278-4"><a href="#cb278-4" aria-hidden="true" tabindex="-1"></a><span class="cf">assert</span> np.allclose(signal_vorher, signal_nachher), <span class="st">&quot;LOOKAHEAD-BIAS!&quot;</span></span></code></pre></div>
+<div class="sourceCode" id="cb282"><pre class="sourceCode python"><code class="sourceCode python"><span id="cb282-1"><a href="#cb282-1" aria-hidden="true" tabindex="-1"></a>signal_vorher <span class="op">=</span> berechne_signal(stichtag)</span>
+<span id="cb282-2"><a href="#cb282-2" aria-hidden="true" tabindex="-1"></a>kurse.loc[kurse.index <span class="op">&gt;</span> stichtag] <span class="op">*=</span> <span class="fl">3.0</span></span>
+<span id="cb282-3"><a href="#cb282-3" aria-hidden="true" tabindex="-1"></a>signal_nachher <span class="op">=</span> berechne_signal(stichtag)</span>
+<span id="cb282-4"><a href="#cb282-4" aria-hidden="true" tabindex="-1"></a><span class="cf">assert</span> np.allclose(signal_vorher, signal_nachher), <span class="st">&quot;LOOKAHEAD-BIAS!&quot;</span></span></code></pre></div>
 <p><strong>2. Zeitindizes prüfen.</strong> <code>iloc[t]</code> gegen <code>iloc[t+1]</code> — die Gewichte von heute gehören auf die Rendite von morgen.</p>
 <p><strong>3. Survivorship.</strong> Wurde das Universum nach Kriterien gefiltert, die erst am Ende bekannt waren (<code>dropna()</code> über den gesamten Zeitraum!)?</p>
 <p><strong>4. Kosten.</strong> Sind Gebühren, Spread und Slippage verbucht?</p>
@@ -30805,15 +32463,15 @@ Insgesamt 2874 Solveraufrufe fuer die gesamte Diagnose.
 <h2 id="c11-vertauschte-spalten">C11 — Vertauschte Spalten</h2>
 <p><strong>Symptom.</strong> Ergebnisse sind plausibel, aber falsch beschriftet — oder eine Sektorgrenze greift auf die falschen Titel.</p>
 <p><strong>Ursache.</strong> <code>yfinance</code> und viele andere Datenquellen liefern Spalten <strong>alphabetisch sortiert</strong>, nicht in der Reihenfolge Ihrer Anfrage.</p>
-<div class="sourceCode" id="cb279"><pre class="sourceCode python"><code class="sourceCode python"><span id="cb279-1"><a href="#cb279-1" aria-hidden="true" tabindex="-1"></a><span class="co"># IMMER nach dem Import:</span></span>
-<span id="cb279-2"><a href="#cb279-2" aria-hidden="true" tabindex="-1"></a>kurse <span class="op">=</span> roh[<span class="st">&quot;Close&quot;</span>][tickers].dropna()          <span class="co"># erzwingt die Reihenfolge</span></span>
-<span id="cb279-3"><a href="#cb279-3" aria-hidden="true" tabindex="-1"></a><span class="cf">assert</span> <span class="bu">list</span>(kurse.columns) <span class="op">==</span> tickers, (</span>
-<span id="cb279-4"><a href="#cb279-4" aria-hidden="true" tabindex="-1"></a>    <span class="ss">f&quot;Reihenfolge weicht ab!</span><span class="ch">\n</span><span class="ss"> erwartet: </span><span class="sc">{</span>tickers<span class="sc">}</span><span class="ch">\n</span><span class="ss"> erhalten: </span><span class="sc">{</span><span class="bu">list</span>(kurse.columns)<span class="sc">}</span><span class="ss">&quot;</span>)</span>
-<span id="cb279-5"><a href="#cb279-5" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb279-6"><a href="#cb279-6" aria-hidden="true" tabindex="-1"></a><span class="co"># Und Gruppen NIE ueber Positionsindizes definieren:</span></span>
-<span id="cb279-7"><a href="#cb279-7" aria-hidden="true" tabindex="-1"></a>SEKTOREN <span class="op">=</span> {<span class="st">&quot;Technologie&quot;</span>: [<span class="st">&quot;AAPL&quot;</span>, <span class="st">&quot;MSFT&quot;</span>, <span class="st">&quot;NVDA&quot;</span>, <span class="st">&quot;AMZN&quot;</span>]}       <span class="co"># gut</span></span>
-<span id="cb279-8"><a href="#cb279-8" aria-hidden="true" tabindex="-1"></a>tech_idx <span class="op">=</span> [tickers.index(t) <span class="cf">for</span> t <span class="kw">in</span> SEKTOREN[<span class="st">&quot;Technologie&quot;</span>]]     <span class="co"># bricht bei Tippfehler</span></span>
-<span id="cb279-9"><a href="#cb279-9" aria-hidden="true" tabindex="-1"></a>tech_indices <span class="op">=</span> [<span class="dv">0</span>, <span class="dv">1</span>, <span class="dv">2</span>, <span class="dv">3</span>]                                        <span class="co"># SCHLECHT</span></span></code></pre></div>
+<div class="sourceCode" id="cb283"><pre class="sourceCode python"><code class="sourceCode python"><span id="cb283-1"><a href="#cb283-1" aria-hidden="true" tabindex="-1"></a><span class="co"># IMMER nach dem Import:</span></span>
+<span id="cb283-2"><a href="#cb283-2" aria-hidden="true" tabindex="-1"></a>kurse <span class="op">=</span> roh[<span class="st">&quot;Close&quot;</span>][tickers].dropna()          <span class="co"># erzwingt die Reihenfolge</span></span>
+<span id="cb283-3"><a href="#cb283-3" aria-hidden="true" tabindex="-1"></a><span class="cf">assert</span> <span class="bu">list</span>(kurse.columns) <span class="op">==</span> tickers, (</span>
+<span id="cb283-4"><a href="#cb283-4" aria-hidden="true" tabindex="-1"></a>    <span class="ss">f&quot;Reihenfolge weicht ab!</span><span class="ch">\n</span><span class="ss"> erwartet: </span><span class="sc">{</span>tickers<span class="sc">}</span><span class="ch">\n</span><span class="ss"> erhalten: </span><span class="sc">{</span><span class="bu">list</span>(kurse.columns)<span class="sc">}</span><span class="ss">&quot;</span>)</span>
+<span id="cb283-5"><a href="#cb283-5" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb283-6"><a href="#cb283-6" aria-hidden="true" tabindex="-1"></a><span class="co"># Und Gruppen NIE ueber Positionsindizes definieren:</span></span>
+<span id="cb283-7"><a href="#cb283-7" aria-hidden="true" tabindex="-1"></a>SEKTOREN <span class="op">=</span> {<span class="st">&quot;Technologie&quot;</span>: [<span class="st">&quot;AAPL&quot;</span>, <span class="st">&quot;MSFT&quot;</span>, <span class="st">&quot;NVDA&quot;</span>, <span class="st">&quot;AMZN&quot;</span>]}       <span class="co"># gut</span></span>
+<span id="cb283-8"><a href="#cb283-8" aria-hidden="true" tabindex="-1"></a>tech_idx <span class="op">=</span> [tickers.index(t) <span class="cf">for</span> t <span class="kw">in</span> SEKTOREN[<span class="st">&quot;Technologie&quot;</span>]]     <span class="co"># bricht bei Tippfehler</span></span>
+<span id="cb283-9"><a href="#cb283-9" aria-hidden="true" tabindex="-1"></a>tech_indices <span class="op">=</span> [<span class="dv">0</span>, <span class="dv">1</span>, <span class="dv">2</span>, <span class="dv">3</span>]                                        <span class="co"># SCHLECHT</span></span></code></pre></div>
 <hr />
 <h2 id="die-goldene-diagnoseregel">Die goldene Diagnoseregel</h2>
 <blockquote>
@@ -30834,51 +32492,51 @@ Insgesamt 2874 Solveraufrufe fuer die gesamte Diagnose.
 <h2 id="d1-scipy-linprog-und-milp">D1 — SciPy: <code>linprog</code> und <code>milp</code></h2>
 <p><strong>Wofür.</strong> Die Einstiegsschicht: keine zusätzliche Installation, HiGHS als Unterbau, ideal für lineare und gemischt-ganzzahlige Probleme in Matrixform. <strong>Wofür nicht:</strong> alles, was sich nicht als Matrix schreiben lässt, und jede nichtlineare Zielfunktion.</p>
 <h3 id="lineares-programm">Lineares Programm</h3>
-<div class="sourceCode" id="cb280"><pre class="sourceCode python"><code class="sourceCode python"><span id="cb280-1"><a href="#cb280-1" aria-hidden="true" tabindex="-1"></a><span class="im">import</span> numpy <span class="im">as</span> np</span>
-<span id="cb280-2"><a href="#cb280-2" aria-hidden="true" tabindex="-1"></a><span class="im">from</span> scipy.optimize <span class="im">import</span> linprog</span>
-<span id="cb280-3"><a href="#cb280-3" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb280-4"><a href="#cb280-4" aria-hidden="true" tabindex="-1"></a><span class="co"># linprog MINIMIERT immer -&gt; zum Maximieren die Zielfunktion negieren</span></span>
-<span id="cb280-5"><a href="#cb280-5" aria-hidden="true" tabindex="-1"></a>ergebnis <span class="op">=</span> linprog(</span>
-<span id="cb280-6"><a href="#cb280-6" aria-hidden="true" tabindex="-1"></a>    c<span class="op">=</span>[<span class="op">-</span><span class="fl">10.0</span>, <span class="op">-</span><span class="fl">15.0</span>, <span class="op">-</span><span class="fl">25.0</span>],                       <span class="co"># Zielkoeffizienten</span></span>
-<span id="cb280-7"><a href="#cb280-7" aria-hidden="true" tabindex="-1"></a>    A_ub<span class="op">=</span>[[<span class="dv">1</span>, <span class="dv">1</span>, <span class="dv">2</span>], [<span class="dv">2</span>, <span class="dv">3</span>, <span class="dv">1</span>]], b_ub<span class="op">=</span>[<span class="dv">40</span>, <span class="dv">50</span>],    <span class="co"># A_ub @ x &lt;= b_ub</span></span>
-<span id="cb280-8"><a href="#cb280-8" aria-hidden="true" tabindex="-1"></a>    A_eq<span class="op">=</span><span class="va">None</span>, b_eq<span class="op">=</span><span class="va">None</span>,                          <span class="co"># Gleichungen, falls vorhanden</span></span>
-<span id="cb280-9"><a href="#cb280-9" aria-hidden="true" tabindex="-1"></a>    bounds<span class="op">=</span>[(<span class="dv">0</span>, <span class="va">None</span>)] <span class="op">*</span> <span class="dv">3</span>,                        <span class="co"># je Variable (unten, oben)</span></span>
-<span id="cb280-10"><a href="#cb280-10" aria-hidden="true" tabindex="-1"></a>    method<span class="op">=</span><span class="st">&quot;highs&quot;</span>)</span>
-<span id="cb280-11"><a href="#cb280-11" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb280-12"><a href="#cb280-12" aria-hidden="true" tabindex="-1"></a><span class="cf">if</span> ergebnis.status <span class="op">==</span> <span class="dv">0</span>:</span>
-<span id="cb280-13"><a href="#cb280-13" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;optimal: </span><span class="sc">{</span><span class="op">-</span>ergebnis<span class="sc">.</span>fun<span class="sc">:.2f}</span><span class="ss">&quot;</span>)         <span class="co"># Vorzeichen zuruecknehmen!</span></span>
-<span id="cb280-14"><a href="#cb280-14" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;x = </span><span class="sc">{</span>np<span class="sc">.</span><span class="bu">round</span>(ergebnis.x, <span class="dv">4</span>)<span class="sc">}</span><span class="ss">&quot;</span>)</span>
-<span id="cb280-15"><a href="#cb280-15" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;Schattenpreise: </span><span class="sc">{</span><span class="op">-</span>ergebnis<span class="sc">.</span>ineqlin<span class="sc">.</span>marginals<span class="sc">}</span><span class="ss">&quot;</span>)</span>
-<span id="cb280-16"><a href="#cb280-16" aria-hidden="true" tabindex="-1"></a><span class="cf">elif</span> ergebnis.status <span class="op">==</span> <span class="dv">2</span>:</span>
-<span id="cb280-17"><a href="#cb280-17" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;INFEASIBLE - kein zulaessiger Punkt&quot;</span>)</span>
-<span id="cb280-18"><a href="#cb280-18" aria-hidden="true" tabindex="-1"></a><span class="cf">elif</span> ergebnis.status <span class="op">==</span> <span class="dv">3</span>:</span>
-<span id="cb280-19"><a href="#cb280-19" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;UNBOUNDED - Zielfunktion unbeschraenkt&quot;</span>)</span>
-<span id="cb280-20"><a href="#cb280-20" aria-hidden="true" tabindex="-1"></a><span class="cf">elif</span> ergebnis.status <span class="op">==</span> <span class="dv">1</span>:</span>
-<span id="cb280-21"><a href="#cb280-21" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;Iterations- oder Zeitlimit erreicht&quot;</span>)</span>
-<span id="cb280-22"><a href="#cb280-22" aria-hidden="true" tabindex="-1"></a><span class="cf">else</span>:</span>
-<span id="cb280-23"><a href="#cb280-23" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;numerisches Problem (status </span><span class="sc">{</span>ergebnis<span class="sc">.</span>status<span class="sc">}</span><span class="ss">): </span><span class="sc">{</span>ergebnis<span class="sc">.</span>message<span class="sc">}</span><span class="ss">&quot;</span>)</span></code></pre></div>
+<div class="sourceCode" id="cb284"><pre class="sourceCode python"><code class="sourceCode python"><span id="cb284-1"><a href="#cb284-1" aria-hidden="true" tabindex="-1"></a><span class="im">import</span> numpy <span class="im">as</span> np</span>
+<span id="cb284-2"><a href="#cb284-2" aria-hidden="true" tabindex="-1"></a><span class="im">from</span> scipy.optimize <span class="im">import</span> linprog</span>
+<span id="cb284-3"><a href="#cb284-3" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb284-4"><a href="#cb284-4" aria-hidden="true" tabindex="-1"></a><span class="co"># linprog MINIMIERT immer -&gt; zum Maximieren die Zielfunktion negieren</span></span>
+<span id="cb284-5"><a href="#cb284-5" aria-hidden="true" tabindex="-1"></a>ergebnis <span class="op">=</span> linprog(</span>
+<span id="cb284-6"><a href="#cb284-6" aria-hidden="true" tabindex="-1"></a>    c<span class="op">=</span>[<span class="op">-</span><span class="fl">10.0</span>, <span class="op">-</span><span class="fl">15.0</span>, <span class="op">-</span><span class="fl">25.0</span>],                       <span class="co"># Zielkoeffizienten</span></span>
+<span id="cb284-7"><a href="#cb284-7" aria-hidden="true" tabindex="-1"></a>    A_ub<span class="op">=</span>[[<span class="dv">1</span>, <span class="dv">1</span>, <span class="dv">2</span>], [<span class="dv">2</span>, <span class="dv">3</span>, <span class="dv">1</span>]], b_ub<span class="op">=</span>[<span class="dv">40</span>, <span class="dv">50</span>],    <span class="co"># A_ub @ x &lt;= b_ub</span></span>
+<span id="cb284-8"><a href="#cb284-8" aria-hidden="true" tabindex="-1"></a>    A_eq<span class="op">=</span><span class="va">None</span>, b_eq<span class="op">=</span><span class="va">None</span>,                          <span class="co"># Gleichungen, falls vorhanden</span></span>
+<span id="cb284-9"><a href="#cb284-9" aria-hidden="true" tabindex="-1"></a>    bounds<span class="op">=</span>[(<span class="dv">0</span>, <span class="va">None</span>)] <span class="op">*</span> <span class="dv">3</span>,                        <span class="co"># je Variable (unten, oben)</span></span>
+<span id="cb284-10"><a href="#cb284-10" aria-hidden="true" tabindex="-1"></a>    method<span class="op">=</span><span class="st">&quot;highs&quot;</span>)</span>
+<span id="cb284-11"><a href="#cb284-11" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb284-12"><a href="#cb284-12" aria-hidden="true" tabindex="-1"></a><span class="cf">if</span> ergebnis.status <span class="op">==</span> <span class="dv">0</span>:</span>
+<span id="cb284-13"><a href="#cb284-13" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;optimal: </span><span class="sc">{</span><span class="op">-</span>ergebnis<span class="sc">.</span>fun<span class="sc">:.2f}</span><span class="ss">&quot;</span>)         <span class="co"># Vorzeichen zuruecknehmen!</span></span>
+<span id="cb284-14"><a href="#cb284-14" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;x = </span><span class="sc">{</span>np<span class="sc">.</span><span class="bu">round</span>(ergebnis.x, <span class="dv">4</span>)<span class="sc">}</span><span class="ss">&quot;</span>)</span>
+<span id="cb284-15"><a href="#cb284-15" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;Schattenpreise: </span><span class="sc">{</span><span class="op">-</span>ergebnis<span class="sc">.</span>ineqlin<span class="sc">.</span>marginals<span class="sc">}</span><span class="ss">&quot;</span>)</span>
+<span id="cb284-16"><a href="#cb284-16" aria-hidden="true" tabindex="-1"></a><span class="cf">elif</span> ergebnis.status <span class="op">==</span> <span class="dv">2</span>:</span>
+<span id="cb284-17"><a href="#cb284-17" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;INFEASIBLE - kein zulaessiger Punkt&quot;</span>)</span>
+<span id="cb284-18"><a href="#cb284-18" aria-hidden="true" tabindex="-1"></a><span class="cf">elif</span> ergebnis.status <span class="op">==</span> <span class="dv">3</span>:</span>
+<span id="cb284-19"><a href="#cb284-19" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;UNBOUNDED - Zielfunktion unbeschraenkt&quot;</span>)</span>
+<span id="cb284-20"><a href="#cb284-20" aria-hidden="true" tabindex="-1"></a><span class="cf">elif</span> ergebnis.status <span class="op">==</span> <span class="dv">1</span>:</span>
+<span id="cb284-21"><a href="#cb284-21" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;Iterations- oder Zeitlimit erreicht&quot;</span>)</span>
+<span id="cb284-22"><a href="#cb284-22" aria-hidden="true" tabindex="-1"></a><span class="cf">else</span>:</span>
+<span id="cb284-23"><a href="#cb284-23" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;numerisches Problem (status </span><span class="sc">{</span>ergebnis<span class="sc">.</span>status<span class="sc">}</span><span class="ss">): </span><span class="sc">{</span>ergebnis<span class="sc">.</span>message<span class="sc">}</span><span class="ss">&quot;</span>)</span></code></pre></div>
 <h3 id="ganzzahlig-milp">Ganzzahlig: <code>milp</code></h3>
-<div class="sourceCode" id="cb281"><pre class="sourceCode python"><code class="sourceCode python"><span id="cb281-1"><a href="#cb281-1" aria-hidden="true" tabindex="-1"></a><span class="im">import</span> numpy <span class="im">as</span> np</span>
-<span id="cb281-2"><a href="#cb281-2" aria-hidden="true" tabindex="-1"></a><span class="im">from</span> scipy.optimize <span class="im">import</span> milp, LinearConstraint, Bounds</span>
-<span id="cb281-3"><a href="#cb281-3" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb281-4"><a href="#cb281-4" aria-hidden="true" tabindex="-1"></a><span class="co"># Ganzzahlig: dasselbe Problem, aber x muss ganzzahlig sein</span></span>
-<span id="cb281-5"><a href="#cb281-5" aria-hidden="true" tabindex="-1"></a>ergebnis <span class="op">=</span> milp(</span>
-<span id="cb281-6"><a href="#cb281-6" aria-hidden="true" tabindex="-1"></a>    c<span class="op">=</span>[<span class="op">-</span><span class="fl">10.0</span>, <span class="op">-</span><span class="fl">15.0</span>, <span class="op">-</span><span class="fl">25.0</span>],                       <span class="co"># auch milp MINIMIERT</span></span>
-<span id="cb281-7"><a href="#cb281-7" aria-hidden="true" tabindex="-1"></a>    constraints<span class="op">=</span>LinearConstraint([[<span class="dv">1</span>, <span class="dv">1</span>, <span class="dv">2</span>], [<span class="dv">2</span>, <span class="dv">3</span>, <span class="dv">1</span>]], <span class="op">-</span>np.inf, [<span class="dv">40</span>, <span class="dv">50</span>]),</span>
-<span id="cb281-8"><a href="#cb281-8" aria-hidden="true" tabindex="-1"></a>    integrality<span class="op">=</span>[<span class="dv">1</span>, <span class="dv">1</span>, <span class="dv">1</span>],                         <span class="co"># 0 = stetig, 1 = ganzzahlig</span></span>
-<span id="cb281-9"><a href="#cb281-9" aria-hidden="true" tabindex="-1"></a>    bounds<span class="op">=</span>Bounds(<span class="dv">0</span>, np.inf))</span>
-<span id="cb281-10"><a href="#cb281-10" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb281-11"><a href="#cb281-11" aria-hidden="true" tabindex="-1"></a><span class="cf">if</span> ergebnis.status <span class="op">==</span> <span class="dv">0</span>:</span>
-<span id="cb281-12"><a href="#cb281-12" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;optimal: </span><span class="sc">{</span><span class="op">-</span>ergebnis<span class="sc">.</span>fun<span class="sc">:.2f}</span><span class="ss">  x = </span><span class="sc">{</span>np<span class="sc">.</span><span class="bu">round</span>(ergebnis.x)<span class="sc">.</span>astype(<span class="bu">int</span>)<span class="sc">}</span><span class="ss">&quot;</span>)</span>
-<span id="cb281-13"><a href="#cb281-13" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;MIP-Gap: </span><span class="sc">{</span>ergebnis<span class="sc">.</span>mip_gap<span class="sc">:.4f}</span><span class="ss">&quot;</span>)</span>
-<span id="cb281-14"><a href="#cb281-14" aria-hidden="true" tabindex="-1"></a><span class="cf">elif</span> ergebnis.status <span class="op">==</span> <span class="dv">1</span>:</span>
-<span id="cb281-15"><a href="#cb281-15" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;Zeitlimit - beste gefundene Loesung nutzen, Gap pruefen&quot;</span>)</span>
-<span id="cb281-16"><a href="#cb281-16" aria-hidden="true" tabindex="-1"></a><span class="cf">elif</span> ergebnis.status <span class="op">==</span> <span class="dv">2</span>:</span>
-<span id="cb281-17"><a href="#cb281-17" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;INFEASIBLE&quot;</span>)</span>
-<span id="cb281-18"><a href="#cb281-18" aria-hidden="true" tabindex="-1"></a><span class="cf">elif</span> ergebnis.status <span class="op">==</span> <span class="dv">3</span>:</span>
-<span id="cb281-19"><a href="#cb281-19" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;UNBOUNDED&quot;</span>)</span>
-<span id="cb281-20"><a href="#cb281-20" aria-hidden="true" tabindex="-1"></a><span class="cf">else</span>:</span>
-<span id="cb281-21"><a href="#cb281-21" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;kein Ergebnis: </span><span class="sc">{</span>ergebnis<span class="sc">.</span>message<span class="sc">}</span><span class="ss">&quot;</span>)</span></code></pre></div>
+<div class="sourceCode" id="cb285"><pre class="sourceCode python"><code class="sourceCode python"><span id="cb285-1"><a href="#cb285-1" aria-hidden="true" tabindex="-1"></a><span class="im">import</span> numpy <span class="im">as</span> np</span>
+<span id="cb285-2"><a href="#cb285-2" aria-hidden="true" tabindex="-1"></a><span class="im">from</span> scipy.optimize <span class="im">import</span> milp, LinearConstraint, Bounds</span>
+<span id="cb285-3"><a href="#cb285-3" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb285-4"><a href="#cb285-4" aria-hidden="true" tabindex="-1"></a><span class="co"># Ganzzahlig: dasselbe Problem, aber x muss ganzzahlig sein</span></span>
+<span id="cb285-5"><a href="#cb285-5" aria-hidden="true" tabindex="-1"></a>ergebnis <span class="op">=</span> milp(</span>
+<span id="cb285-6"><a href="#cb285-6" aria-hidden="true" tabindex="-1"></a>    c<span class="op">=</span>[<span class="op">-</span><span class="fl">10.0</span>, <span class="op">-</span><span class="fl">15.0</span>, <span class="op">-</span><span class="fl">25.0</span>],                       <span class="co"># auch milp MINIMIERT</span></span>
+<span id="cb285-7"><a href="#cb285-7" aria-hidden="true" tabindex="-1"></a>    constraints<span class="op">=</span>LinearConstraint([[<span class="dv">1</span>, <span class="dv">1</span>, <span class="dv">2</span>], [<span class="dv">2</span>, <span class="dv">3</span>, <span class="dv">1</span>]], <span class="op">-</span>np.inf, [<span class="dv">40</span>, <span class="dv">50</span>]),</span>
+<span id="cb285-8"><a href="#cb285-8" aria-hidden="true" tabindex="-1"></a>    integrality<span class="op">=</span>[<span class="dv">1</span>, <span class="dv">1</span>, <span class="dv">1</span>],                         <span class="co"># 0 = stetig, 1 = ganzzahlig</span></span>
+<span id="cb285-9"><a href="#cb285-9" aria-hidden="true" tabindex="-1"></a>    bounds<span class="op">=</span>Bounds(<span class="dv">0</span>, np.inf))</span>
+<span id="cb285-10"><a href="#cb285-10" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb285-11"><a href="#cb285-11" aria-hidden="true" tabindex="-1"></a><span class="cf">if</span> ergebnis.status <span class="op">==</span> <span class="dv">0</span>:</span>
+<span id="cb285-12"><a href="#cb285-12" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;optimal: </span><span class="sc">{</span><span class="op">-</span>ergebnis<span class="sc">.</span>fun<span class="sc">:.2f}</span><span class="ss">  x = </span><span class="sc">{</span>np<span class="sc">.</span><span class="bu">round</span>(ergebnis.x)<span class="sc">.</span>astype(<span class="bu">int</span>)<span class="sc">}</span><span class="ss">&quot;</span>)</span>
+<span id="cb285-13"><a href="#cb285-13" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;MIP-Gap: </span><span class="sc">{</span>ergebnis<span class="sc">.</span>mip_gap<span class="sc">:.4f}</span><span class="ss">&quot;</span>)</span>
+<span id="cb285-14"><a href="#cb285-14" aria-hidden="true" tabindex="-1"></a><span class="cf">elif</span> ergebnis.status <span class="op">==</span> <span class="dv">1</span>:</span>
+<span id="cb285-15"><a href="#cb285-15" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;Zeitlimit - beste gefundene Loesung nutzen, Gap pruefen&quot;</span>)</span>
+<span id="cb285-16"><a href="#cb285-16" aria-hidden="true" tabindex="-1"></a><span class="cf">elif</span> ergebnis.status <span class="op">==</span> <span class="dv">2</span>:</span>
+<span id="cb285-17"><a href="#cb285-17" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;INFEASIBLE&quot;</span>)</span>
+<span id="cb285-18"><a href="#cb285-18" aria-hidden="true" tabindex="-1"></a><span class="cf">elif</span> ergebnis.status <span class="op">==</span> <span class="dv">3</span>:</span>
+<span id="cb285-19"><a href="#cb285-19" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;UNBOUNDED&quot;</span>)</span>
+<span id="cb285-20"><a href="#cb285-20" aria-hidden="true" tabindex="-1"></a><span class="cf">else</span>:</span>
+<span id="cb285-21"><a href="#cb285-21" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;kein Ergebnis: </span><span class="sc">{</span>ergebnis<span class="sc">.</span>message<span class="sc">}</span><span class="ss">&quot;</span>)</span></code></pre></div>
 <h3 id="die-drei-häufigsten-stolpersteine">Die drei häufigsten Stolpersteine</h3>
 <ol type="1">
 <li><strong><code>linprog</code> minimiert immer.</strong> Zum Maximieren <code>c</code> negieren — und beim Ausgeben des Zielwerts das Vorzeichen wieder zurücknehmen. Dieselbe Negation dreht auch die Schattenpreise (<a href="#sec:lp-die-vorzeichenfalle-bei-schattenpreisen">Abschnitt 5.7</a>).</li>
@@ -30888,41 +32546,41 @@ Insgesamt 2874 Solveraufrufe fuer die gesamte Diagnose.
 <hr />
 <h2 id="d2-highs-über-highspy">D2 — HiGHS über <code>highspy</code></h2>
 <p><strong>Wofür.</strong> Derselbe Solver wie unter SciPy, aber direkt gesteuert: Optionen, Warm-Starts, inkrementelles Ändern eines bestehenden Modells. <strong>Wofür nicht:</strong> schnelles Hinschreiben — die CSR-Matrixübergabe ist fehleranfällig.</p>
-<div class="sourceCode" id="cb282"><pre class="sourceCode python"><code class="sourceCode python"><span id="cb282-1"><a href="#cb282-1" aria-hidden="true" tabindex="-1"></a><span class="im">import</span> numpy <span class="im">as</span> np</span>
-<span id="cb282-2"><a href="#cb282-2" aria-hidden="true" tabindex="-1"></a><span class="im">import</span> highspy</span>
-<span id="cb282-3"><a href="#cb282-3" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb282-4"><a href="#cb282-4" aria-hidden="true" tabindex="-1"></a>h <span class="op">=</span> highspy.Highs()</span>
-<span id="cb282-5"><a href="#cb282-5" aria-hidden="true" tabindex="-1"></a>h.setOptionValue(<span class="st">&quot;output_flag&quot;</span>, <span class="va">False</span>)             <span class="co"># Solverprotokoll abschalten</span></span>
-<span id="cb282-6"><a href="#cb282-6" aria-hidden="true" tabindex="-1"></a>h.setOptionValue(<span class="st">&quot;time_limit&quot;</span>, <span class="fl">60.0</span>)</span>
-<span id="cb282-7"><a href="#cb282-7" aria-hidden="true" tabindex="-1"></a>h.setOptionValue(<span class="st">&quot;mip_rel_gap&quot;</span>, <span class="fl">0.01</span>)              <span class="co"># 1 % Gap genuegt</span></span>
-<span id="cb282-8"><a href="#cb282-8" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb282-9"><a href="#cb282-9" aria-hidden="true" tabindex="-1"></a><span class="co"># Variablen: Anzahl, Untergrenzen, Obergrenzen</span></span>
-<span id="cb282-10"><a href="#cb282-10" aria-hidden="true" tabindex="-1"></a>h.addVars(<span class="dv">3</span>, np.zeros(<span class="dv">3</span>), np.full(<span class="dv">3</span>, highspy.kHighsInf))</span>
-<span id="cb282-11"><a href="#cb282-11" aria-hidden="true" tabindex="-1"></a>h.changeObjectiveSense(highspy.ObjSense.kMaximize)</span>
-<span id="cb282-12"><a href="#cb282-12" aria-hidden="true" tabindex="-1"></a><span class="cf">for</span> spalte, wert <span class="kw">in</span> <span class="bu">enumerate</span>([<span class="fl">10.0</span>, <span class="fl">15.0</span>, <span class="fl">25.0</span>]):</span>
-<span id="cb282-13"><a href="#cb282-13" aria-hidden="true" tabindex="-1"></a>    h.changeColCost(spalte, wert)</span>
-<span id="cb282-14"><a href="#cb282-14" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb282-15"><a href="#cb282-15" aria-hidden="true" tabindex="-1"></a><span class="co"># Zeilen im CSR-Format: starts[i] = Beginn von Zeile i in indices/values</span></span>
-<span id="cb282-16"><a href="#cb282-16" aria-hidden="true" tabindex="-1"></a>h.addRows(<span class="dv">2</span>, np.full(<span class="dv">2</span>, <span class="op">-</span>highspy.kHighsInf), np.array([<span class="fl">40.0</span>, <span class="fl">50.0</span>]), <span class="dv">6</span>,</span>
-<span id="cb282-17"><a href="#cb282-17" aria-hidden="true" tabindex="-1"></a>          np.array([<span class="dv">0</span>, <span class="dv">3</span>], dtype<span class="op">=</span>np.int32),                  <span class="co"># starts</span></span>
-<span id="cb282-18"><a href="#cb282-18" aria-hidden="true" tabindex="-1"></a>          np.array([<span class="dv">0</span>, <span class="dv">1</span>, <span class="dv">2</span>, <span class="dv">0</span>, <span class="dv">1</span>, <span class="dv">2</span>], dtype<span class="op">=</span>np.int32),      <span class="co"># Spaltenindizes</span></span>
-<span id="cb282-19"><a href="#cb282-19" aria-hidden="true" tabindex="-1"></a>          np.array([<span class="fl">1.0</span>, <span class="fl">1.0</span>, <span class="fl">2.0</span>, <span class="fl">2.0</span>, <span class="fl">3.0</span>, <span class="fl">1.0</span>]))          <span class="co"># Koeffizienten</span></span>
-<span id="cb282-20"><a href="#cb282-20" aria-hidden="true" tabindex="-1"></a><span class="co"># Ganzzahligkeit: h.changeColsIntegrality(...) mit highspy.HighsVarType.kInteger</span></span>
-<span id="cb282-21"><a href="#cb282-21" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb282-22"><a href="#cb282-22" aria-hidden="true" tabindex="-1"></a>h.run()</span>
-<span id="cb282-23"><a href="#cb282-23" aria-hidden="true" tabindex="-1"></a>status <span class="op">=</span> h.getModelStatus()</span>
-<span id="cb282-24"><a href="#cb282-24" aria-hidden="true" tabindex="-1"></a><span class="cf">if</span> status <span class="op">==</span> highspy.HighsModelStatus.kOptimal:</span>
-<span id="cb282-25"><a href="#cb282-25" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;optimal: </span><span class="sc">{</span>h<span class="sc">.</span>getInfo()<span class="sc">.</span>objective_function_value<span class="sc">:.2f}</span><span class="ss">&quot;</span>)</span>
-<span id="cb282-26"><a href="#cb282-26" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;x = </span><span class="sc">{</span>np<span class="sc">.</span><span class="bu">round</span>(h.getSolution().col_value[:<span class="dv">3</span>], <span class="dv">4</span>)<span class="sc">}</span><span class="ss">&quot;</span>)</span>
-<span id="cb282-27"><a href="#cb282-27" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;Schattenpreise: </span><span class="sc">{</span>np<span class="sc">.</span><span class="bu">round</span>(h.getSolution().row_dual[:<span class="dv">2</span>], <span class="dv">4</span>)<span class="sc">}</span><span class="ss">&quot;</span>)</span>
-<span id="cb282-28"><a href="#cb282-28" aria-hidden="true" tabindex="-1"></a><span class="cf">elif</span> status <span class="op">==</span> highspy.HighsModelStatus.kInfeasible:</span>
-<span id="cb282-29"><a href="#cb282-29" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;INFEASIBLE&quot;</span>)</span>
-<span id="cb282-30"><a href="#cb282-30" aria-hidden="true" tabindex="-1"></a><span class="cf">elif</span> status <span class="op">==</span> highspy.HighsModelStatus.kUnbounded:</span>
-<span id="cb282-31"><a href="#cb282-31" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;UNBOUNDED&quot;</span>)</span>
-<span id="cb282-32"><a href="#cb282-32" aria-hidden="true" tabindex="-1"></a><span class="cf">elif</span> status <span class="op">==</span> highspy.HighsModelStatus.kTimeLimit:</span>
-<span id="cb282-33"><a href="#cb282-33" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;Zeitlimit, Gap </span><span class="sc">{</span>h<span class="sc">.</span>getInfo()<span class="sc">.</span>mip_gap<span class="sc">:.3f}</span><span class="ss">&quot;</span>)</span>
-<span id="cb282-34"><a href="#cb282-34" aria-hidden="true" tabindex="-1"></a><span class="cf">else</span>:</span>
-<span id="cb282-35"><a href="#cb282-35" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;kein Optimum:&quot;</span>, h.modelStatusToString(status))</span></code></pre></div>
+<div class="sourceCode" id="cb286"><pre class="sourceCode python"><code class="sourceCode python"><span id="cb286-1"><a href="#cb286-1" aria-hidden="true" tabindex="-1"></a><span class="im">import</span> numpy <span class="im">as</span> np</span>
+<span id="cb286-2"><a href="#cb286-2" aria-hidden="true" tabindex="-1"></a><span class="im">import</span> highspy</span>
+<span id="cb286-3"><a href="#cb286-3" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb286-4"><a href="#cb286-4" aria-hidden="true" tabindex="-1"></a>h <span class="op">=</span> highspy.Highs()</span>
+<span id="cb286-5"><a href="#cb286-5" aria-hidden="true" tabindex="-1"></a>h.setOptionValue(<span class="st">&quot;output_flag&quot;</span>, <span class="va">False</span>)             <span class="co"># Solverprotokoll abschalten</span></span>
+<span id="cb286-6"><a href="#cb286-6" aria-hidden="true" tabindex="-1"></a>h.setOptionValue(<span class="st">&quot;time_limit&quot;</span>, <span class="fl">60.0</span>)</span>
+<span id="cb286-7"><a href="#cb286-7" aria-hidden="true" tabindex="-1"></a>h.setOptionValue(<span class="st">&quot;mip_rel_gap&quot;</span>, <span class="fl">0.01</span>)              <span class="co"># 1 % Gap genuegt</span></span>
+<span id="cb286-8"><a href="#cb286-8" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb286-9"><a href="#cb286-9" aria-hidden="true" tabindex="-1"></a><span class="co"># Variablen: Anzahl, Untergrenzen, Obergrenzen</span></span>
+<span id="cb286-10"><a href="#cb286-10" aria-hidden="true" tabindex="-1"></a>h.addVars(<span class="dv">3</span>, np.zeros(<span class="dv">3</span>), np.full(<span class="dv">3</span>, highspy.kHighsInf))</span>
+<span id="cb286-11"><a href="#cb286-11" aria-hidden="true" tabindex="-1"></a>h.changeObjectiveSense(highspy.ObjSense.kMaximize)</span>
+<span id="cb286-12"><a href="#cb286-12" aria-hidden="true" tabindex="-1"></a><span class="cf">for</span> spalte, wert <span class="kw">in</span> <span class="bu">enumerate</span>([<span class="fl">10.0</span>, <span class="fl">15.0</span>, <span class="fl">25.0</span>]):</span>
+<span id="cb286-13"><a href="#cb286-13" aria-hidden="true" tabindex="-1"></a>    h.changeColCost(spalte, wert)</span>
+<span id="cb286-14"><a href="#cb286-14" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb286-15"><a href="#cb286-15" aria-hidden="true" tabindex="-1"></a><span class="co"># Zeilen im CSR-Format: starts[i] = Beginn von Zeile i in indices/values</span></span>
+<span id="cb286-16"><a href="#cb286-16" aria-hidden="true" tabindex="-1"></a>h.addRows(<span class="dv">2</span>, np.full(<span class="dv">2</span>, <span class="op">-</span>highspy.kHighsInf), np.array([<span class="fl">40.0</span>, <span class="fl">50.0</span>]), <span class="dv">6</span>,</span>
+<span id="cb286-17"><a href="#cb286-17" aria-hidden="true" tabindex="-1"></a>          np.array([<span class="dv">0</span>, <span class="dv">3</span>], dtype<span class="op">=</span>np.int32),                  <span class="co"># starts</span></span>
+<span id="cb286-18"><a href="#cb286-18" aria-hidden="true" tabindex="-1"></a>          np.array([<span class="dv">0</span>, <span class="dv">1</span>, <span class="dv">2</span>, <span class="dv">0</span>, <span class="dv">1</span>, <span class="dv">2</span>], dtype<span class="op">=</span>np.int32),      <span class="co"># Spaltenindizes</span></span>
+<span id="cb286-19"><a href="#cb286-19" aria-hidden="true" tabindex="-1"></a>          np.array([<span class="fl">1.0</span>, <span class="fl">1.0</span>, <span class="fl">2.0</span>, <span class="fl">2.0</span>, <span class="fl">3.0</span>, <span class="fl">1.0</span>]))          <span class="co"># Koeffizienten</span></span>
+<span id="cb286-20"><a href="#cb286-20" aria-hidden="true" tabindex="-1"></a><span class="co"># Ganzzahligkeit: h.changeColsIntegrality(...) mit highspy.HighsVarType.kInteger</span></span>
+<span id="cb286-21"><a href="#cb286-21" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb286-22"><a href="#cb286-22" aria-hidden="true" tabindex="-1"></a>h.run()</span>
+<span id="cb286-23"><a href="#cb286-23" aria-hidden="true" tabindex="-1"></a>status <span class="op">=</span> h.getModelStatus()</span>
+<span id="cb286-24"><a href="#cb286-24" aria-hidden="true" tabindex="-1"></a><span class="cf">if</span> status <span class="op">==</span> highspy.HighsModelStatus.kOptimal:</span>
+<span id="cb286-25"><a href="#cb286-25" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;optimal: </span><span class="sc">{</span>h<span class="sc">.</span>getInfo()<span class="sc">.</span>objective_function_value<span class="sc">:.2f}</span><span class="ss">&quot;</span>)</span>
+<span id="cb286-26"><a href="#cb286-26" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;x = </span><span class="sc">{</span>np<span class="sc">.</span><span class="bu">round</span>(h.getSolution().col_value[:<span class="dv">3</span>], <span class="dv">4</span>)<span class="sc">}</span><span class="ss">&quot;</span>)</span>
+<span id="cb286-27"><a href="#cb286-27" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;Schattenpreise: </span><span class="sc">{</span>np<span class="sc">.</span><span class="bu">round</span>(h.getSolution().row_dual[:<span class="dv">2</span>], <span class="dv">4</span>)<span class="sc">}</span><span class="ss">&quot;</span>)</span>
+<span id="cb286-28"><a href="#cb286-28" aria-hidden="true" tabindex="-1"></a><span class="cf">elif</span> status <span class="op">==</span> highspy.HighsModelStatus.kInfeasible:</span>
+<span id="cb286-29"><a href="#cb286-29" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;INFEASIBLE&quot;</span>)</span>
+<span id="cb286-30"><a href="#cb286-30" aria-hidden="true" tabindex="-1"></a><span class="cf">elif</span> status <span class="op">==</span> highspy.HighsModelStatus.kUnbounded:</span>
+<span id="cb286-31"><a href="#cb286-31" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;UNBOUNDED&quot;</span>)</span>
+<span id="cb286-32"><a href="#cb286-32" aria-hidden="true" tabindex="-1"></a><span class="cf">elif</span> status <span class="op">==</span> highspy.HighsModelStatus.kTimeLimit:</span>
+<span id="cb286-33"><a href="#cb286-33" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;Zeitlimit, Gap </span><span class="sc">{</span>h<span class="sc">.</span>getInfo()<span class="sc">.</span>mip_gap<span class="sc">:.3f}</span><span class="ss">&quot;</span>)</span>
+<span id="cb286-34"><a href="#cb286-34" aria-hidden="true" tabindex="-1"></a><span class="cf">else</span>:</span>
+<span id="cb286-35"><a href="#cb286-35" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;kein Optimum:&quot;</span>, h.modelStatusToString(status))</span></code></pre></div>
 <h3 id="die-drei-häufigsten-stolpersteine-1">Die drei häufigsten Stolpersteine</h3>
 <ol type="1">
 <li><strong>Nicht zusammen mit <code>ortools</code> importieren.</strong> Beide bringen eine eigene HiGHS-Kopie mit; im selben Prozess endet das in <code>undefined symbol</code> (<a href="#anhang-fehlerdiagnose">Anhang C</a>, C9). Auch <code>cvxpy</code> zieht <code>highspy</code> bei der Solver-Erkennung mit hinein.</li>
@@ -30932,34 +32590,34 @@ Insgesamt 2874 Solveraufrufe fuer die gesamte Diagnose.
 <hr />
 <h2 id="d3-or-tools-pywraplp">D3 — OR-Tools: <code>pywraplp</code></h2>
 <p><strong>Wofür.</strong> Bequeme algebraische Schreibweise für LP und MILP mit umschaltbarem Backend (<code>GLOP</code>, <code>SCIP</code>, <code>CBC</code>, <code>SAT</code>). <strong>Wofür nicht:</strong> Scheduling und kombinatorische Bedingungen — dafür ist CP-SAT (D4) da.</p>
-<div class="sourceCode" id="cb283"><pre class="sourceCode python"><code class="sourceCode python"><span id="cb283-1"><a href="#cb283-1" aria-hidden="true" tabindex="-1"></a><span class="im">from</span> ortools.linear_solver <span class="im">import</span> pywraplp</span>
-<span id="cb283-2"><a href="#cb283-2" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb283-3"><a href="#cb283-3" aria-hidden="true" tabindex="-1"></a><span class="co"># &quot;GLOP&quot; = LP, &quot;SCIP&quot; oder &quot;CBC&quot; = MILP, &quot;SAT&quot; = CP-SAT als MILP-Backend</span></span>
-<span id="cb283-4"><a href="#cb283-4" aria-hidden="true" tabindex="-1"></a>loeser <span class="op">=</span> pywraplp.Solver.CreateSolver(<span class="st">&quot;GLOP&quot;</span>)</span>
-<span id="cb283-5"><a href="#cb283-5" aria-hidden="true" tabindex="-1"></a><span class="cf">if</span> loeser <span class="kw">is</span> <span class="va">None</span>:</span>
-<span id="cb283-6"><a href="#cb283-6" aria-hidden="true" tabindex="-1"></a>    <span class="cf">raise</span> <span class="pp">SystemExit</span>(<span class="st">&quot;Solver nicht verfuegbar&quot;</span>)</span>
-<span id="cb283-7"><a href="#cb283-7" aria-hidden="true" tabindex="-1"></a>loeser.SetTimeLimit(<span class="dv">60_000</span>)                        <span class="co"># Millisekunden!</span></span>
-<span id="cb283-8"><a href="#cb283-8" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb283-9"><a href="#cb283-9" aria-hidden="true" tabindex="-1"></a>unendlich <span class="op">=</span> loeser.infinity()</span>
-<span id="cb283-10"><a href="#cb283-10" aria-hidden="true" tabindex="-1"></a>x <span class="op">=</span> [loeser.NumVar(<span class="dv">0</span>, unendlich, <span class="ss">f&quot;x</span><span class="sc">{</span>j<span class="sc">}</span><span class="ss">&quot;</span>) <span class="cf">for</span> j <span class="kw">in</span> <span class="bu">range</span>(<span class="dv">3</span>)]</span>
-<span id="cb283-11"><a href="#cb283-11" aria-hidden="true" tabindex="-1"></a><span class="co"># ganzzahlig: loeser.IntVar(0, unendlich, &quot;n&quot;) | binaer: loeser.BoolVar(&quot;b&quot;)</span></span>
-<span id="cb283-12"><a href="#cb283-12" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb283-13"><a href="#cb283-13" aria-hidden="true" tabindex="-1"></a>loeser.Add(x[<span class="dv">0</span>] <span class="op">+</span> x[<span class="dv">1</span>] <span class="op">+</span> <span class="dv">2</span> <span class="op">*</span> x[<span class="dv">2</span>] <span class="op">&lt;=</span> <span class="dv">40</span>)</span>
-<span id="cb283-14"><a href="#cb283-14" aria-hidden="true" tabindex="-1"></a>loeser.Add(<span class="dv">2</span> <span class="op">*</span> x[<span class="dv">0</span>] <span class="op">+</span> <span class="dv">3</span> <span class="op">*</span> x[<span class="dv">1</span>] <span class="op">+</span> x[<span class="dv">2</span>] <span class="op">&lt;=</span> <span class="dv">50</span>)</span>
-<span id="cb283-15"><a href="#cb283-15" aria-hidden="true" tabindex="-1"></a>loeser.Maximize(<span class="dv">10</span> <span class="op">*</span> x[<span class="dv">0</span>] <span class="op">+</span> <span class="dv">15</span> <span class="op">*</span> x[<span class="dv">1</span>] <span class="op">+</span> <span class="dv">25</span> <span class="op">*</span> x[<span class="dv">2</span>])</span>
-<span id="cb283-16"><a href="#cb283-16" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb283-17"><a href="#cb283-17" aria-hidden="true" tabindex="-1"></a>status <span class="op">=</span> loeser.Solve()</span>
-<span id="cb283-18"><a href="#cb283-18" aria-hidden="true" tabindex="-1"></a><span class="cf">if</span> status <span class="op">==</span> pywraplp.Solver.OPTIMAL:</span>
-<span id="cb283-19"><a href="#cb283-19" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;optimal: </span><span class="sc">{</span>loeser<span class="sc">.</span>Objective()<span class="sc">.</span>Value()<span class="sc">:.2f}</span><span class="ss">&quot;</span>)</span>
-<span id="cb283-20"><a href="#cb283-20" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;x = </span><span class="sc">{</span>[<span class="bu">round</span>(v.solution_value(), <span class="dv">4</span>) <span class="cf">for</span> v <span class="kw">in</span> x]<span class="sc">}</span><span class="ss">&quot;</span>)</span>
-<span id="cb283-21"><a href="#cb283-21" aria-hidden="true" tabindex="-1"></a><span class="cf">elif</span> status <span class="op">==</span> pywraplp.Solver.FEASIBLE:</span>
-<span id="cb283-22"><a href="#cb283-22" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;zulaessig, nicht bewiesen optimal (Zeitlimit)&quot;</span>)</span>
-<span id="cb283-23"><a href="#cb283-23" aria-hidden="true" tabindex="-1"></a><span class="cf">elif</span> status <span class="op">==</span> pywraplp.Solver.INFEASIBLE:</span>
-<span id="cb283-24"><a href="#cb283-24" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;INFEASIBLE&quot;</span>)</span>
-<span id="cb283-25"><a href="#cb283-25" aria-hidden="true" tabindex="-1"></a><span class="cf">elif</span> status <span class="op">==</span> pywraplp.Solver.UNBOUNDED:</span>
-<span id="cb283-26"><a href="#cb283-26" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;UNBOUNDED&quot;</span>)</span>
-<span id="cb283-27"><a href="#cb283-27" aria-hidden="true" tabindex="-1"></a><span class="cf">else</span>:</span>
-<span id="cb283-28"><a href="#cb283-28" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;ABNORMAL / NOT_SOLVED - Modell oder Solver pruefen&quot;</span>)</span></code></pre></div>
+<div class="sourceCode" id="cb287"><pre class="sourceCode python"><code class="sourceCode python"><span id="cb287-1"><a href="#cb287-1" aria-hidden="true" tabindex="-1"></a><span class="im">from</span> ortools.linear_solver <span class="im">import</span> pywraplp</span>
+<span id="cb287-2"><a href="#cb287-2" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb287-3"><a href="#cb287-3" aria-hidden="true" tabindex="-1"></a><span class="co"># &quot;GLOP&quot; = LP, &quot;SCIP&quot; oder &quot;CBC&quot; = MILP, &quot;SAT&quot; = CP-SAT als MILP-Backend</span></span>
+<span id="cb287-4"><a href="#cb287-4" aria-hidden="true" tabindex="-1"></a>loeser <span class="op">=</span> pywraplp.Solver.CreateSolver(<span class="st">&quot;GLOP&quot;</span>)</span>
+<span id="cb287-5"><a href="#cb287-5" aria-hidden="true" tabindex="-1"></a><span class="cf">if</span> loeser <span class="kw">is</span> <span class="va">None</span>:</span>
+<span id="cb287-6"><a href="#cb287-6" aria-hidden="true" tabindex="-1"></a>    <span class="cf">raise</span> <span class="pp">SystemExit</span>(<span class="st">&quot;Solver nicht verfuegbar&quot;</span>)</span>
+<span id="cb287-7"><a href="#cb287-7" aria-hidden="true" tabindex="-1"></a>loeser.SetTimeLimit(<span class="dv">60_000</span>)                        <span class="co"># Millisekunden!</span></span>
+<span id="cb287-8"><a href="#cb287-8" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb287-9"><a href="#cb287-9" aria-hidden="true" tabindex="-1"></a>unendlich <span class="op">=</span> loeser.infinity()</span>
+<span id="cb287-10"><a href="#cb287-10" aria-hidden="true" tabindex="-1"></a>x <span class="op">=</span> [loeser.NumVar(<span class="dv">0</span>, unendlich, <span class="ss">f&quot;x</span><span class="sc">{</span>j<span class="sc">}</span><span class="ss">&quot;</span>) <span class="cf">for</span> j <span class="kw">in</span> <span class="bu">range</span>(<span class="dv">3</span>)]</span>
+<span id="cb287-11"><a href="#cb287-11" aria-hidden="true" tabindex="-1"></a><span class="co"># ganzzahlig: loeser.IntVar(0, unendlich, &quot;n&quot;) | binaer: loeser.BoolVar(&quot;b&quot;)</span></span>
+<span id="cb287-12"><a href="#cb287-12" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb287-13"><a href="#cb287-13" aria-hidden="true" tabindex="-1"></a>loeser.Add(x[<span class="dv">0</span>] <span class="op">+</span> x[<span class="dv">1</span>] <span class="op">+</span> <span class="dv">2</span> <span class="op">*</span> x[<span class="dv">2</span>] <span class="op">&lt;=</span> <span class="dv">40</span>)</span>
+<span id="cb287-14"><a href="#cb287-14" aria-hidden="true" tabindex="-1"></a>loeser.Add(<span class="dv">2</span> <span class="op">*</span> x[<span class="dv">0</span>] <span class="op">+</span> <span class="dv">3</span> <span class="op">*</span> x[<span class="dv">1</span>] <span class="op">+</span> x[<span class="dv">2</span>] <span class="op">&lt;=</span> <span class="dv">50</span>)</span>
+<span id="cb287-15"><a href="#cb287-15" aria-hidden="true" tabindex="-1"></a>loeser.Maximize(<span class="dv">10</span> <span class="op">*</span> x[<span class="dv">0</span>] <span class="op">+</span> <span class="dv">15</span> <span class="op">*</span> x[<span class="dv">1</span>] <span class="op">+</span> <span class="dv">25</span> <span class="op">*</span> x[<span class="dv">2</span>])</span>
+<span id="cb287-16"><a href="#cb287-16" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb287-17"><a href="#cb287-17" aria-hidden="true" tabindex="-1"></a>status <span class="op">=</span> loeser.Solve()</span>
+<span id="cb287-18"><a href="#cb287-18" aria-hidden="true" tabindex="-1"></a><span class="cf">if</span> status <span class="op">==</span> pywraplp.Solver.OPTIMAL:</span>
+<span id="cb287-19"><a href="#cb287-19" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;optimal: </span><span class="sc">{</span>loeser<span class="sc">.</span>Objective()<span class="sc">.</span>Value()<span class="sc">:.2f}</span><span class="ss">&quot;</span>)</span>
+<span id="cb287-20"><a href="#cb287-20" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;x = </span><span class="sc">{</span>[<span class="bu">round</span>(v.solution_value(), <span class="dv">4</span>) <span class="cf">for</span> v <span class="kw">in</span> x]<span class="sc">}</span><span class="ss">&quot;</span>)</span>
+<span id="cb287-21"><a href="#cb287-21" aria-hidden="true" tabindex="-1"></a><span class="cf">elif</span> status <span class="op">==</span> pywraplp.Solver.FEASIBLE:</span>
+<span id="cb287-22"><a href="#cb287-22" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;zulaessig, nicht bewiesen optimal (Zeitlimit)&quot;</span>)</span>
+<span id="cb287-23"><a href="#cb287-23" aria-hidden="true" tabindex="-1"></a><span class="cf">elif</span> status <span class="op">==</span> pywraplp.Solver.INFEASIBLE:</span>
+<span id="cb287-24"><a href="#cb287-24" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;INFEASIBLE&quot;</span>)</span>
+<span id="cb287-25"><a href="#cb287-25" aria-hidden="true" tabindex="-1"></a><span class="cf">elif</span> status <span class="op">==</span> pywraplp.Solver.UNBOUNDED:</span>
+<span id="cb287-26"><a href="#cb287-26" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;UNBOUNDED&quot;</span>)</span>
+<span id="cb287-27"><a href="#cb287-27" aria-hidden="true" tabindex="-1"></a><span class="cf">else</span>:</span>
+<span id="cb287-28"><a href="#cb287-28" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;ABNORMAL / NOT_SOLVED - Modell oder Solver pruefen&quot;</span>)</span></code></pre></div>
 <h3 id="die-drei-häufigsten-stolpersteine-2">Die drei häufigsten Stolpersteine</h3>
 <ol type="1">
 <li><strong><code>CreateSolver</code> liefert <code>None</code></strong>, wenn der Backend-Name unbekannt oder nicht gebaut ist — immer prüfen, statt am <code>None</code> später zu scheitern.</li>
@@ -30969,40 +32627,40 @@ Insgesamt 2874 Solveraufrufe fuer die gesamte Diagnose.
 <hr />
 <h2 id="d4-cp-sat-cp_model">D4 — CP-SAT: <code>cp_model</code></h2>
 <p><strong>Wofür.</strong> Scheduling, Zuordnung, Reihenfolgen, alles Kombinatorische mit globalen Bedingungen. <strong>Wofür nicht:</strong> stetige Größen — CP-SAT rechnet ausschließlich ganzzahlig. Wer Nachkommastellen braucht, skaliert (Cent statt Euro, Promille statt Anteil).</p>
-<div class="sourceCode" id="cb284"><pre class="sourceCode python"><code class="sourceCode python"><span id="cb284-1"><a href="#cb284-1" aria-hidden="true" tabindex="-1"></a><span class="im">from</span> ortools.sat.python <span class="im">import</span> cp_model</span>
-<span id="cb284-2"><a href="#cb284-2" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb284-3"><a href="#cb284-3" aria-hidden="true" tabindex="-1"></a>modell <span class="op">=</span> cp_model.CpModel()</span>
-<span id="cb284-4"><a href="#cb284-4" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb284-5"><a href="#cb284-5" aria-hidden="true" tabindex="-1"></a><span class="co"># Variablen - CP-SAT rechnet ausschliesslich mit GANZEN Zahlen</span></span>
-<span id="cb284-6"><a href="#cb284-6" aria-hidden="true" tabindex="-1"></a>x <span class="op">=</span> modell.NewIntVar(<span class="dv">0</span>, <span class="dv">100</span>, <span class="st">&quot;x&quot;</span>)                  <span class="co"># untere, obere Schranke, Name</span></span>
-<span id="cb284-7"><a href="#cb284-7" aria-hidden="true" tabindex="-1"></a>y <span class="op">=</span> modell.NewIntVar(<span class="dv">0</span>, <span class="dv">100</span>, <span class="st">&quot;y&quot;</span>)</span>
-<span id="cb284-8"><a href="#cb284-8" aria-hidden="true" tabindex="-1"></a>b <span class="op">=</span> modell.NewBoolVar(<span class="st">&quot;b&quot;</span>)                         <span class="co"># 0/1</span></span>
-<span id="cb284-9"><a href="#cb284-9" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb284-10"><a href="#cb284-10" aria-hidden="true" tabindex="-1"></a><span class="co"># Nebenbedingungen</span></span>
-<span id="cb284-11"><a href="#cb284-11" aria-hidden="true" tabindex="-1"></a>modell.Add(<span class="dv">2</span> <span class="op">*</span> x <span class="op">+</span> <span class="dv">3</span> <span class="op">*</span> y <span class="op">&lt;=</span> <span class="dv">50</span>)</span>
-<span id="cb284-12"><a href="#cb284-12" aria-hidden="true" tabindex="-1"></a>modell.Add(x <span class="op">&gt;=</span> <span class="dv">5</span>).OnlyEnforceIf(b)                <span class="co"># gilt nur, wenn b wahr ist</span></span>
-<span id="cb284-13"><a href="#cb284-13" aria-hidden="true" tabindex="-1"></a>modell.AddAllDifferent([x, y])                     <span class="co"># globale Bedingung</span></span>
-<span id="cb284-14"><a href="#cb284-14" aria-hidden="true" tabindex="-1"></a>modell.AddMaxEquality(z <span class="op">:=</span> modell.NewIntVar(<span class="dv">0</span>, <span class="dv">100</span>, <span class="st">&quot;z&quot;</span>), [x, y])</span>
-<span id="cb284-15"><a href="#cb284-15" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb284-16"><a href="#cb284-16" aria-hidden="true" tabindex="-1"></a>modell.Maximize(<span class="dv">10</span> <span class="op">*</span> x <span class="op">+</span> <span class="dv">15</span> <span class="op">*</span> y <span class="op">-</span> <span class="dv">3</span> <span class="op">*</span> z)</span>
-<span id="cb284-17"><a href="#cb284-17" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb284-18"><a href="#cb284-18" aria-hidden="true" tabindex="-1"></a>loeser <span class="op">=</span> cp_model.CpSolver()</span>
-<span id="cb284-19"><a href="#cb284-19" aria-hidden="true" tabindex="-1"></a>loeser.parameters.max_time_in_seconds <span class="op">=</span> <span class="fl">10.0</span></span>
-<span id="cb284-20"><a href="#cb284-20" aria-hidden="true" tabindex="-1"></a>loeser.parameters.num_workers <span class="op">=</span> <span class="dv">1</span>                  <span class="co"># 1 = reproduzierbar</span></span>
-<span id="cb284-21"><a href="#cb284-21" aria-hidden="true" tabindex="-1"></a>loeser.parameters.random_seed <span class="op">=</span> <span class="dv">1</span></span>
-<span id="cb284-22"><a href="#cb284-22" aria-hidden="true" tabindex="-1"></a>status <span class="op">=</span> loeser.Solve(modell)</span>
-<span id="cb284-23"><a href="#cb284-23" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb284-24"><a href="#cb284-24" aria-hidden="true" tabindex="-1"></a><span class="cf">if</span> status <span class="op">==</span> cp_model.OPTIMAL:</span>
-<span id="cb284-25"><a href="#cb284-25" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;optimal: </span><span class="sc">{</span>loeser<span class="sc">.</span>ObjectiveValue()<span class="sc">:.0f}</span><span class="ss">  x=</span><span class="sc">{</span>loeser<span class="sc">.</span>Value(x)<span class="sc">}</span><span class="ss"> y=</span><span class="sc">{</span>loeser<span class="sc">.</span>Value(y)<span class="sc">}</span><span class="ss">&quot;</span>)</span>
-<span id="cb284-26"><a href="#cb284-26" aria-hidden="true" tabindex="-1"></a><span class="cf">elif</span> status <span class="op">==</span> cp_model.FEASIBLE:</span>
-<span id="cb284-27"><a href="#cb284-27" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;zulaessig, nicht bewiesen optimal - Gap-Schranke: </span><span class="sc">{</span>loeser<span class="sc">.</span>BestObjectiveBound()<span class="sc">}</span><span class="ss">&quot;</span>)</span>
-<span id="cb284-28"><a href="#cb284-28" aria-hidden="true" tabindex="-1"></a><span class="cf">elif</span> status <span class="op">==</span> cp_model.INFEASIBLE:</span>
-<span id="cb284-29"><a href="#cb284-29" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;INFEASIBLE - Bedingungen widersprechen sich&quot;</span>)</span>
-<span id="cb284-30"><a href="#cb284-30" aria-hidden="true" tabindex="-1"></a><span class="cf">elif</span> status <span class="op">==</span> cp_model.MODEL_INVALID:</span>
-<span id="cb284-31"><a href="#cb284-31" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;Modellfehler:&quot;</span>, modell.Validate())</span>
-<span id="cb284-32"><a href="#cb284-32" aria-hidden="true" tabindex="-1"></a><span class="cf">else</span>:</span>
-<span id="cb284-33"><a href="#cb284-33" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;UNKNOWN - Zeit abgelaufen, ohne eine Loesung zu finden&quot;</span>)</span>
-<span id="cb284-34"><a href="#cb284-34" aria-hidden="true" tabindex="-1"></a><span class="bu">print</span>(<span class="ss">f&quot;Laufzeit </span><span class="sc">{</span>loeser<span class="sc">.</span>WallTime()<span class="sc">:.3f}</span><span class="ss">s, </span><span class="sc">{</span>loeser<span class="sc">.</span>NumBranches()<span class="sc">}</span><span class="ss"> Verzweigungen&quot;</span>)</span></code></pre></div>
+<div class="sourceCode" id="cb288"><pre class="sourceCode python"><code class="sourceCode python"><span id="cb288-1"><a href="#cb288-1" aria-hidden="true" tabindex="-1"></a><span class="im">from</span> ortools.sat.python <span class="im">import</span> cp_model</span>
+<span id="cb288-2"><a href="#cb288-2" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb288-3"><a href="#cb288-3" aria-hidden="true" tabindex="-1"></a>modell <span class="op">=</span> cp_model.CpModel()</span>
+<span id="cb288-4"><a href="#cb288-4" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb288-5"><a href="#cb288-5" aria-hidden="true" tabindex="-1"></a><span class="co"># Variablen - CP-SAT rechnet ausschliesslich mit GANZEN Zahlen</span></span>
+<span id="cb288-6"><a href="#cb288-6" aria-hidden="true" tabindex="-1"></a>x <span class="op">=</span> modell.NewIntVar(<span class="dv">0</span>, <span class="dv">100</span>, <span class="st">&quot;x&quot;</span>)                  <span class="co"># untere, obere Schranke, Name</span></span>
+<span id="cb288-7"><a href="#cb288-7" aria-hidden="true" tabindex="-1"></a>y <span class="op">=</span> modell.NewIntVar(<span class="dv">0</span>, <span class="dv">100</span>, <span class="st">&quot;y&quot;</span>)</span>
+<span id="cb288-8"><a href="#cb288-8" aria-hidden="true" tabindex="-1"></a>b <span class="op">=</span> modell.NewBoolVar(<span class="st">&quot;b&quot;</span>)                         <span class="co"># 0/1</span></span>
+<span id="cb288-9"><a href="#cb288-9" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb288-10"><a href="#cb288-10" aria-hidden="true" tabindex="-1"></a><span class="co"># Nebenbedingungen</span></span>
+<span id="cb288-11"><a href="#cb288-11" aria-hidden="true" tabindex="-1"></a>modell.Add(<span class="dv">2</span> <span class="op">*</span> x <span class="op">+</span> <span class="dv">3</span> <span class="op">*</span> y <span class="op">&lt;=</span> <span class="dv">50</span>)</span>
+<span id="cb288-12"><a href="#cb288-12" aria-hidden="true" tabindex="-1"></a>modell.Add(x <span class="op">&gt;=</span> <span class="dv">5</span>).OnlyEnforceIf(b)                <span class="co"># gilt nur, wenn b wahr ist</span></span>
+<span id="cb288-13"><a href="#cb288-13" aria-hidden="true" tabindex="-1"></a>modell.AddAllDifferent([x, y])                     <span class="co"># globale Bedingung</span></span>
+<span id="cb288-14"><a href="#cb288-14" aria-hidden="true" tabindex="-1"></a>modell.AddMaxEquality(z <span class="op">:=</span> modell.NewIntVar(<span class="dv">0</span>, <span class="dv">100</span>, <span class="st">&quot;z&quot;</span>), [x, y])</span>
+<span id="cb288-15"><a href="#cb288-15" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb288-16"><a href="#cb288-16" aria-hidden="true" tabindex="-1"></a>modell.Maximize(<span class="dv">10</span> <span class="op">*</span> x <span class="op">+</span> <span class="dv">15</span> <span class="op">*</span> y <span class="op">-</span> <span class="dv">3</span> <span class="op">*</span> z)</span>
+<span id="cb288-17"><a href="#cb288-17" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb288-18"><a href="#cb288-18" aria-hidden="true" tabindex="-1"></a>loeser <span class="op">=</span> cp_model.CpSolver()</span>
+<span id="cb288-19"><a href="#cb288-19" aria-hidden="true" tabindex="-1"></a>loeser.parameters.max_time_in_seconds <span class="op">=</span> <span class="fl">10.0</span></span>
+<span id="cb288-20"><a href="#cb288-20" aria-hidden="true" tabindex="-1"></a>loeser.parameters.num_workers <span class="op">=</span> <span class="dv">1</span>                  <span class="co"># 1 = reproduzierbar</span></span>
+<span id="cb288-21"><a href="#cb288-21" aria-hidden="true" tabindex="-1"></a>loeser.parameters.random_seed <span class="op">=</span> <span class="dv">1</span></span>
+<span id="cb288-22"><a href="#cb288-22" aria-hidden="true" tabindex="-1"></a>status <span class="op">=</span> loeser.Solve(modell)</span>
+<span id="cb288-23"><a href="#cb288-23" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb288-24"><a href="#cb288-24" aria-hidden="true" tabindex="-1"></a><span class="cf">if</span> status <span class="op">==</span> cp_model.OPTIMAL:</span>
+<span id="cb288-25"><a href="#cb288-25" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;optimal: </span><span class="sc">{</span>loeser<span class="sc">.</span>ObjectiveValue()<span class="sc">:.0f}</span><span class="ss">  x=</span><span class="sc">{</span>loeser<span class="sc">.</span>Value(x)<span class="sc">}</span><span class="ss"> y=</span><span class="sc">{</span>loeser<span class="sc">.</span>Value(y)<span class="sc">}</span><span class="ss">&quot;</span>)</span>
+<span id="cb288-26"><a href="#cb288-26" aria-hidden="true" tabindex="-1"></a><span class="cf">elif</span> status <span class="op">==</span> cp_model.FEASIBLE:</span>
+<span id="cb288-27"><a href="#cb288-27" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;zulaessig, nicht bewiesen optimal - Gap-Schranke: </span><span class="sc">{</span>loeser<span class="sc">.</span>BestObjectiveBound()<span class="sc">}</span><span class="ss">&quot;</span>)</span>
+<span id="cb288-28"><a href="#cb288-28" aria-hidden="true" tabindex="-1"></a><span class="cf">elif</span> status <span class="op">==</span> cp_model.INFEASIBLE:</span>
+<span id="cb288-29"><a href="#cb288-29" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;INFEASIBLE - Bedingungen widersprechen sich&quot;</span>)</span>
+<span id="cb288-30"><a href="#cb288-30" aria-hidden="true" tabindex="-1"></a><span class="cf">elif</span> status <span class="op">==</span> cp_model.MODEL_INVALID:</span>
+<span id="cb288-31"><a href="#cb288-31" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;Modellfehler:&quot;</span>, modell.Validate())</span>
+<span id="cb288-32"><a href="#cb288-32" aria-hidden="true" tabindex="-1"></a><span class="cf">else</span>:</span>
+<span id="cb288-33"><a href="#cb288-33" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;UNKNOWN - Zeit abgelaufen, ohne eine Loesung zu finden&quot;</span>)</span>
+<span id="cb288-34"><a href="#cb288-34" aria-hidden="true" tabindex="-1"></a><span class="bu">print</span>(<span class="ss">f&quot;Laufzeit </span><span class="sc">{</span>loeser<span class="sc">.</span>WallTime()<span class="sc">:.3f}</span><span class="ss">s, </span><span class="sc">{</span>loeser<span class="sc">.</span>NumBranches()<span class="sc">}</span><span class="ss"> Verzweigungen&quot;</span>)</span></code></pre></div>
 <h3 id="die-drei-häufigsten-stolpersteine-3">Die drei häufigsten Stolpersteine</h3>
 <ol type="1">
 <li><strong>Alles ist ganzzahlig.</strong> <code>0.5 * x</code> gibt es nicht. Skalieren Sie das ganze Modell auf eine feinere Einheit, statt zu runden.</li>
@@ -31012,32 +32670,32 @@ Insgesamt 2874 Solveraufrufe fuer die gesamte Diagnose.
 <hr />
 <h2 id="d5-cvxpy">D5 — CVXPY</h2>
 <p><strong>Wofür.</strong> Konvexe Probleme: quadratische Ziele, Normen, CVaR, alles mit Regularisierungstermen. <strong>Wofür nicht:</strong> große kombinatorische Modelle — der Aufbau der Ausdrücke wird dann selbst zum Engpass.</p>
-<div class="sourceCode" id="cb285"><pre class="sourceCode python"><code class="sourceCode python"><span id="cb285-1"><a href="#cb285-1" aria-hidden="true" tabindex="-1"></a><span class="im">import</span> numpy <span class="im">as</span> np</span>
-<span id="cb285-2"><a href="#cb285-2" aria-hidden="true" tabindex="-1"></a><span class="im">import</span> cvxpy <span class="im">as</span> cp</span>
-<span id="cb285-3"><a href="#cb285-3" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb285-4"><a href="#cb285-4" aria-hidden="true" tabindex="-1"></a>x <span class="op">=</span> cp.Variable(<span class="dv">3</span>, nonneg<span class="op">=</span><span class="va">True</span>)                    <span class="co"># nonneg=True statt x &gt;= 0</span></span>
-<span id="cb285-5"><a href="#cb285-5" aria-hidden="true" tabindex="-1"></a>gewichte <span class="op">=</span> cp.Variable(<span class="dv">3</span>)</span>
-<span id="cb285-6"><a href="#cb285-6" aria-hidden="true" tabindex="-1"></a>ganzzahlig <span class="op">=</span> cp.Variable(<span class="dv">3</span>, integer<span class="op">=</span><span class="va">True</span>)          <span class="co"># macht daraus ein MIP</span></span>
-<span id="cb285-7"><a href="#cb285-7" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb285-8"><a href="#cb285-8" aria-hidden="true" tabindex="-1"></a>ziel <span class="op">=</span> cp.Maximize(np.array([<span class="fl">10.0</span>, <span class="fl">15.0</span>, <span class="fl">25.0</span>]) <span class="op">@</span> x)</span>
-<span id="cb285-9"><a href="#cb285-9" aria-hidden="true" tabindex="-1"></a>bedingungen <span class="op">=</span> [np.array([[<span class="dv">1</span>, <span class="dv">1</span>, <span class="dv">2</span>], [<span class="dv">2</span>, <span class="dv">3</span>, <span class="dv">1</span>]]) <span class="op">@</span> x <span class="op">&lt;=</span> np.array([<span class="fl">40.0</span>, <span class="fl">50.0</span>])]</span>
-<span id="cb285-10"><a href="#cb285-10" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb285-11"><a href="#cb285-11" aria-hidden="true" tabindex="-1"></a>problem <span class="op">=</span> cp.Problem(ziel, bedingungen)</span>
-<span id="cb285-12"><a href="#cb285-12" aria-hidden="true" tabindex="-1"></a><span class="cf">if</span> <span class="kw">not</span> problem.is_dcp():                           <span class="co"># VOR dem Loesen pruefen</span></span>
-<span id="cb285-13"><a href="#cb285-13" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;nicht DCP:&quot;</span>, [c <span class="cf">for</span> c <span class="kw">in</span> bedingungen <span class="cf">if</span> <span class="kw">not</span> c.is_dcp()])</span>
-<span id="cb285-14"><a href="#cb285-14" aria-hidden="true" tabindex="-1"></a>problem.solve()</span>
-<span id="cb285-15"><a href="#cb285-15" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb285-16"><a href="#cb285-16" aria-hidden="true" tabindex="-1"></a><span class="cf">if</span> problem.status <span class="op">==</span> cp.OPTIMAL:</span>
-<span id="cb285-17"><a href="#cb285-17" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;optimal: </span><span class="sc">{</span>problem<span class="sc">.</span>value<span class="sc">:.2f}</span><span class="ss">  x = </span><span class="sc">{</span>np<span class="sc">.</span><span class="bu">round</span>(x.value, <span class="dv">4</span>)<span class="sc">}</span><span class="ss">&quot;</span>)</span>
-<span id="cb285-18"><a href="#cb285-18" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;Schattenpreis: </span><span class="sc">{</span>np<span class="sc">.</span><span class="bu">round</span>(bedingungen[<span class="dv">0</span>].dual_value, <span class="dv">4</span>)<span class="sc">}</span><span class="ss">&quot;</span>)</span>
-<span id="cb285-19"><a href="#cb285-19" aria-hidden="true" tabindex="-1"></a><span class="cf">elif</span> problem.status <span class="op">==</span> cp.OPTIMAL_INACCURATE:</span>
-<span id="cb285-20"><a href="#cb285-20" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;Loesung numerisch unsicher - Skalierung pruefen, anderen Solver testen&quot;</span>)</span>
-<span id="cb285-21"><a href="#cb285-21" aria-hidden="true" tabindex="-1"></a><span class="cf">elif</span> problem.status <span class="op">==</span> cp.INFEASIBLE:</span>
-<span id="cb285-22"><a href="#cb285-22" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;INFEASIBLE&quot;</span>)</span>
-<span id="cb285-23"><a href="#cb285-23" aria-hidden="true" tabindex="-1"></a><span class="cf">elif</span> problem.status <span class="op">==</span> cp.UNBOUNDED:</span>
-<span id="cb285-24"><a href="#cb285-24" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;UNBOUNDED&quot;</span>)</span>
-<span id="cb285-25"><a href="#cb285-25" aria-hidden="true" tabindex="-1"></a><span class="cf">else</span>:</span>
-<span id="cb285-26"><a href="#cb285-26" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;Solverfehler:&quot;</span>, problem.status)</span></code></pre></div>
+<div class="sourceCode" id="cb289"><pre class="sourceCode python"><code class="sourceCode python"><span id="cb289-1"><a href="#cb289-1" aria-hidden="true" tabindex="-1"></a><span class="im">import</span> numpy <span class="im">as</span> np</span>
+<span id="cb289-2"><a href="#cb289-2" aria-hidden="true" tabindex="-1"></a><span class="im">import</span> cvxpy <span class="im">as</span> cp</span>
+<span id="cb289-3"><a href="#cb289-3" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb289-4"><a href="#cb289-4" aria-hidden="true" tabindex="-1"></a>x <span class="op">=</span> cp.Variable(<span class="dv">3</span>, nonneg<span class="op">=</span><span class="va">True</span>)                    <span class="co"># nonneg=True statt x &gt;= 0</span></span>
+<span id="cb289-5"><a href="#cb289-5" aria-hidden="true" tabindex="-1"></a>gewichte <span class="op">=</span> cp.Variable(<span class="dv">3</span>)</span>
+<span id="cb289-6"><a href="#cb289-6" aria-hidden="true" tabindex="-1"></a>ganzzahlig <span class="op">=</span> cp.Variable(<span class="dv">3</span>, integer<span class="op">=</span><span class="va">True</span>)          <span class="co"># macht daraus ein MIP</span></span>
+<span id="cb289-7"><a href="#cb289-7" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb289-8"><a href="#cb289-8" aria-hidden="true" tabindex="-1"></a>ziel <span class="op">=</span> cp.Maximize(np.array([<span class="fl">10.0</span>, <span class="fl">15.0</span>, <span class="fl">25.0</span>]) <span class="op">@</span> x)</span>
+<span id="cb289-9"><a href="#cb289-9" aria-hidden="true" tabindex="-1"></a>bedingungen <span class="op">=</span> [np.array([[<span class="dv">1</span>, <span class="dv">1</span>, <span class="dv">2</span>], [<span class="dv">2</span>, <span class="dv">3</span>, <span class="dv">1</span>]]) <span class="op">@</span> x <span class="op">&lt;=</span> np.array([<span class="fl">40.0</span>, <span class="fl">50.0</span>])]</span>
+<span id="cb289-10"><a href="#cb289-10" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb289-11"><a href="#cb289-11" aria-hidden="true" tabindex="-1"></a>problem <span class="op">=</span> cp.Problem(ziel, bedingungen)</span>
+<span id="cb289-12"><a href="#cb289-12" aria-hidden="true" tabindex="-1"></a><span class="cf">if</span> <span class="kw">not</span> problem.is_dcp():                           <span class="co"># VOR dem Loesen pruefen</span></span>
+<span id="cb289-13"><a href="#cb289-13" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;nicht DCP:&quot;</span>, [c <span class="cf">for</span> c <span class="kw">in</span> bedingungen <span class="cf">if</span> <span class="kw">not</span> c.is_dcp()])</span>
+<span id="cb289-14"><a href="#cb289-14" aria-hidden="true" tabindex="-1"></a>problem.solve()</span>
+<span id="cb289-15"><a href="#cb289-15" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb289-16"><a href="#cb289-16" aria-hidden="true" tabindex="-1"></a><span class="cf">if</span> problem.status <span class="op">==</span> cp.OPTIMAL:</span>
+<span id="cb289-17"><a href="#cb289-17" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;optimal: </span><span class="sc">{</span>problem<span class="sc">.</span>value<span class="sc">:.2f}</span><span class="ss">  x = </span><span class="sc">{</span>np<span class="sc">.</span><span class="bu">round</span>(x.value, <span class="dv">4</span>)<span class="sc">}</span><span class="ss">&quot;</span>)</span>
+<span id="cb289-18"><a href="#cb289-18" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;Schattenpreis: </span><span class="sc">{</span>np<span class="sc">.</span><span class="bu">round</span>(bedingungen[<span class="dv">0</span>].dual_value, <span class="dv">4</span>)<span class="sc">}</span><span class="ss">&quot;</span>)</span>
+<span id="cb289-19"><a href="#cb289-19" aria-hidden="true" tabindex="-1"></a><span class="cf">elif</span> problem.status <span class="op">==</span> cp.OPTIMAL_INACCURATE:</span>
+<span id="cb289-20"><a href="#cb289-20" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;Loesung numerisch unsicher - Skalierung pruefen, anderen Solver testen&quot;</span>)</span>
+<span id="cb289-21"><a href="#cb289-21" aria-hidden="true" tabindex="-1"></a><span class="cf">elif</span> problem.status <span class="op">==</span> cp.INFEASIBLE:</span>
+<span id="cb289-22"><a href="#cb289-22" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;INFEASIBLE&quot;</span>)</span>
+<span id="cb289-23"><a href="#cb289-23" aria-hidden="true" tabindex="-1"></a><span class="cf">elif</span> problem.status <span class="op">==</span> cp.UNBOUNDED:</span>
+<span id="cb289-24"><a href="#cb289-24" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;UNBOUNDED&quot;</span>)</span>
+<span id="cb289-25"><a href="#cb289-25" aria-hidden="true" tabindex="-1"></a><span class="cf">else</span>:</span>
+<span id="cb289-26"><a href="#cb289-26" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;Solverfehler:&quot;</span>, problem.status)</span></code></pre></div>
 <h3 id="die-drei-häufigsten-stolpersteine-4">Die drei häufigsten Stolpersteine</h3>
 <ol type="1">
 <li><strong>DCP-Regeln vor dem Lösen prüfen.</strong> <code>problem.is_dcp()</code> und dann die einzelnen Bedingungen — das nennt die Schuldige, statt einen <code>DCPError</code> ohne Ort zu werfen (<a href="#anhang-fehlerdiagnose">Anhang C</a>, C8).</li>
@@ -31048,73 +32706,73 @@ Insgesamt 2874 Solveraufrufe fuer die gesamte Diagnose.
 <h2 id="d6-modellierungssprachen-pyomo-und-linopy">D6 — Modellierungssprachen: Pyomo und Linopy</h2>
 <p><strong>Wofür.</strong> Beide trennen <em>Modell</em> von <em>Solver</em>: dasselbe Modell läuft ohne Änderung unter HiGHS, CBC, Gurobi. Pyomo denkt in <strong>Mengen und Indizes</strong> wie eine mathematische Formulierung; Linopy denkt in <strong>beschrifteten Arrays</strong> und baut Nebenbedingungen als Matrixoperation statt in Python-Schleifen. <strong>Wofür nicht:</strong> ein Modell mit zehn Nebenbedingungen — dort ist der Aufwand höher als der Nutzen.</p>
 <h3 id="pyomo">Pyomo</h3>
-<div class="sourceCode" id="cb286"><pre class="sourceCode python"><code class="sourceCode python"><span id="cb286-1"><a href="#cb286-1" aria-hidden="true" tabindex="-1"></a><span class="im">import</span> pyomo.environ <span class="im">as</span> pyo</span>
-<span id="cb286-2"><a href="#cb286-2" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb286-3"><a href="#cb286-3" aria-hidden="true" tabindex="-1"></a>modell <span class="op">=</span> pyo.ConcreteModel()</span>
-<span id="cb286-4"><a href="#cb286-4" aria-hidden="true" tabindex="-1"></a>modell.J <span class="op">=</span> pyo.RangeSet(<span class="dv">0</span>, <span class="dv">2</span>)                      <span class="co"># Indexmenge</span></span>
-<span id="cb286-5"><a href="#cb286-5" aria-hidden="true" tabindex="-1"></a>modell.x <span class="op">=</span> pyo.Var(modell.J, domain<span class="op">=</span>pyo.NonNegativeReals)</span>
-<span id="cb286-6"><a href="#cb286-6" aria-hidden="true" tabindex="-1"></a><span class="co"># ganzzahlig: domain=pyo.NonNegativeIntegers | binaer: domain=pyo.Binary</span></span>
-<span id="cb286-7"><a href="#cb286-7" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb286-8"><a href="#cb286-8" aria-hidden="true" tabindex="-1"></a>ertrag <span class="op">=</span> {<span class="dv">0</span>: <span class="fl">10.0</span>, <span class="dv">1</span>: <span class="fl">15.0</span>, <span class="dv">2</span>: <span class="fl">25.0</span>}</span>
-<span id="cb286-9"><a href="#cb286-9" aria-hidden="true" tabindex="-1"></a>modell.ziel <span class="op">=</span> pyo.Objective(expr<span class="op">=</span><span class="bu">sum</span>(ertrag[j] <span class="op">*</span> modell.x[j] <span class="cf">for</span> j <span class="kw">in</span> modell.J),</span>
-<span id="cb286-10"><a href="#cb286-10" aria-hidden="true" tabindex="-1"></a>                            sense<span class="op">=</span>pyo.maximize)</span>
-<span id="cb286-11"><a href="#cb286-11" aria-hidden="true" tabindex="-1"></a>modell.montage <span class="op">=</span> pyo.Constraint(</span>
-<span id="cb286-12"><a href="#cb286-12" aria-hidden="true" tabindex="-1"></a>    expr<span class="op">=</span>modell.x[<span class="dv">0</span>] <span class="op">+</span> modell.x[<span class="dv">1</span>] <span class="op">+</span> <span class="dv">2</span> <span class="op">*</span> modell.x[<span class="dv">2</span>] <span class="op">&lt;=</span> <span class="dv">40</span>)</span>
-<span id="cb286-13"><a href="#cb286-13" aria-hidden="true" tabindex="-1"></a>modell.pruefung <span class="op">=</span> pyo.Constraint(</span>
-<span id="cb286-14"><a href="#cb286-14" aria-hidden="true" tabindex="-1"></a>    expr<span class="op">=</span><span class="dv">2</span> <span class="op">*</span> modell.x[<span class="dv">0</span>] <span class="op">+</span> <span class="dv">3</span> <span class="op">*</span> modell.x[<span class="dv">1</span>] <span class="op">+</span> modell.x[<span class="dv">2</span>] <span class="op">&lt;=</span> <span class="dv">50</span>)</span>
-<span id="cb286-15"><a href="#cb286-15" aria-hidden="true" tabindex="-1"></a>modell.dual <span class="op">=</span> pyo.Suffix(direction<span class="op">=</span>pyo.Suffix.IMPORT)   <span class="co"># fuer Schattenpreise</span></span>
-<span id="cb286-16"><a href="#cb286-16" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb286-17"><a href="#cb286-17" aria-hidden="true" tabindex="-1"></a>ergebnis <span class="op">=</span> pyo.SolverFactory(<span class="st">&quot;appsi_highs&quot;</span>).solve(modell)</span>
-<span id="cb286-18"><a href="#cb286-18" aria-hidden="true" tabindex="-1"></a>zustand <span class="op">=</span> ergebnis.solver.termination_condition</span>
-<span id="cb286-19"><a href="#cb286-19" aria-hidden="true" tabindex="-1"></a><span class="cf">if</span> zustand <span class="op">==</span> pyo.TerminationCondition.optimal:</span>
-<span id="cb286-20"><a href="#cb286-20" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;optimal: </span><span class="sc">{</span>pyo<span class="sc">.</span>value(modell.ziel)<span class="sc">:.2f}</span><span class="ss">&quot;</span>)</span>
-<span id="cb286-21"><a href="#cb286-21" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;x = </span><span class="sc">{</span>[<span class="bu">round</span>(pyo.value(modell.x[j]), <span class="dv">4</span>) <span class="cf">for</span> j <span class="kw">in</span> modell.J]<span class="sc">}</span><span class="ss">&quot;</span>)</span>
-<span id="cb286-22"><a href="#cb286-22" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;Schattenpreis Montage: </span><span class="sc">{</span>modell<span class="sc">.</span>dual[modell.montage]<span class="sc">:.4f}</span><span class="ss">&quot;</span>)</span>
-<span id="cb286-23"><a href="#cb286-23" aria-hidden="true" tabindex="-1"></a><span class="cf">elif</span> zustand <span class="op">==</span> pyo.TerminationCondition.infeasible:</span>
-<span id="cb286-24"><a href="#cb286-24" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;INFEASIBLE&quot;</span>)</span>
-<span id="cb286-25"><a href="#cb286-25" aria-hidden="true" tabindex="-1"></a><span class="cf">elif</span> zustand <span class="op">==</span> pyo.TerminationCondition.unbounded:</span>
-<span id="cb286-26"><a href="#cb286-26" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;UNBOUNDED&quot;</span>)</span>
-<span id="cb286-27"><a href="#cb286-27" aria-hidden="true" tabindex="-1"></a><span class="cf">elif</span> zustand <span class="op">==</span> pyo.TerminationCondition.maxTimeLimit:</span>
-<span id="cb286-28"><a href="#cb286-28" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;Zeitlimit&quot;</span>)</span>
-<span id="cb286-29"><a href="#cb286-29" aria-hidden="true" tabindex="-1"></a><span class="cf">else</span>:</span>
-<span id="cb286-30"><a href="#cb286-30" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;kein Optimum:&quot;</span>, zustand)</span></code></pre></div>
+<div class="sourceCode" id="cb290"><pre class="sourceCode python"><code class="sourceCode python"><span id="cb290-1"><a href="#cb290-1" aria-hidden="true" tabindex="-1"></a><span class="im">import</span> pyomo.environ <span class="im">as</span> pyo</span>
+<span id="cb290-2"><a href="#cb290-2" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb290-3"><a href="#cb290-3" aria-hidden="true" tabindex="-1"></a>modell <span class="op">=</span> pyo.ConcreteModel()</span>
+<span id="cb290-4"><a href="#cb290-4" aria-hidden="true" tabindex="-1"></a>modell.J <span class="op">=</span> pyo.RangeSet(<span class="dv">0</span>, <span class="dv">2</span>)                      <span class="co"># Indexmenge</span></span>
+<span id="cb290-5"><a href="#cb290-5" aria-hidden="true" tabindex="-1"></a>modell.x <span class="op">=</span> pyo.Var(modell.J, domain<span class="op">=</span>pyo.NonNegativeReals)</span>
+<span id="cb290-6"><a href="#cb290-6" aria-hidden="true" tabindex="-1"></a><span class="co"># ganzzahlig: domain=pyo.NonNegativeIntegers | binaer: domain=pyo.Binary</span></span>
+<span id="cb290-7"><a href="#cb290-7" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb290-8"><a href="#cb290-8" aria-hidden="true" tabindex="-1"></a>ertrag <span class="op">=</span> {<span class="dv">0</span>: <span class="fl">10.0</span>, <span class="dv">1</span>: <span class="fl">15.0</span>, <span class="dv">2</span>: <span class="fl">25.0</span>}</span>
+<span id="cb290-9"><a href="#cb290-9" aria-hidden="true" tabindex="-1"></a>modell.ziel <span class="op">=</span> pyo.Objective(expr<span class="op">=</span><span class="bu">sum</span>(ertrag[j] <span class="op">*</span> modell.x[j] <span class="cf">for</span> j <span class="kw">in</span> modell.J),</span>
+<span id="cb290-10"><a href="#cb290-10" aria-hidden="true" tabindex="-1"></a>                            sense<span class="op">=</span>pyo.maximize)</span>
+<span id="cb290-11"><a href="#cb290-11" aria-hidden="true" tabindex="-1"></a>modell.montage <span class="op">=</span> pyo.Constraint(</span>
+<span id="cb290-12"><a href="#cb290-12" aria-hidden="true" tabindex="-1"></a>    expr<span class="op">=</span>modell.x[<span class="dv">0</span>] <span class="op">+</span> modell.x[<span class="dv">1</span>] <span class="op">+</span> <span class="dv">2</span> <span class="op">*</span> modell.x[<span class="dv">2</span>] <span class="op">&lt;=</span> <span class="dv">40</span>)</span>
+<span id="cb290-13"><a href="#cb290-13" aria-hidden="true" tabindex="-1"></a>modell.pruefung <span class="op">=</span> pyo.Constraint(</span>
+<span id="cb290-14"><a href="#cb290-14" aria-hidden="true" tabindex="-1"></a>    expr<span class="op">=</span><span class="dv">2</span> <span class="op">*</span> modell.x[<span class="dv">0</span>] <span class="op">+</span> <span class="dv">3</span> <span class="op">*</span> modell.x[<span class="dv">1</span>] <span class="op">+</span> modell.x[<span class="dv">2</span>] <span class="op">&lt;=</span> <span class="dv">50</span>)</span>
+<span id="cb290-15"><a href="#cb290-15" aria-hidden="true" tabindex="-1"></a>modell.dual <span class="op">=</span> pyo.Suffix(direction<span class="op">=</span>pyo.Suffix.IMPORT)   <span class="co"># fuer Schattenpreise</span></span>
+<span id="cb290-16"><a href="#cb290-16" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb290-17"><a href="#cb290-17" aria-hidden="true" tabindex="-1"></a>ergebnis <span class="op">=</span> pyo.SolverFactory(<span class="st">&quot;appsi_highs&quot;</span>).solve(modell)</span>
+<span id="cb290-18"><a href="#cb290-18" aria-hidden="true" tabindex="-1"></a>zustand <span class="op">=</span> ergebnis.solver.termination_condition</span>
+<span id="cb290-19"><a href="#cb290-19" aria-hidden="true" tabindex="-1"></a><span class="cf">if</span> zustand <span class="op">==</span> pyo.TerminationCondition.optimal:</span>
+<span id="cb290-20"><a href="#cb290-20" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;optimal: </span><span class="sc">{</span>pyo<span class="sc">.</span>value(modell.ziel)<span class="sc">:.2f}</span><span class="ss">&quot;</span>)</span>
+<span id="cb290-21"><a href="#cb290-21" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;x = </span><span class="sc">{</span>[<span class="bu">round</span>(pyo.value(modell.x[j]), <span class="dv">4</span>) <span class="cf">for</span> j <span class="kw">in</span> modell.J]<span class="sc">}</span><span class="ss">&quot;</span>)</span>
+<span id="cb290-22"><a href="#cb290-22" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;Schattenpreis Montage: </span><span class="sc">{</span>modell<span class="sc">.</span>dual[modell.montage]<span class="sc">:.4f}</span><span class="ss">&quot;</span>)</span>
+<span id="cb290-23"><a href="#cb290-23" aria-hidden="true" tabindex="-1"></a><span class="cf">elif</span> zustand <span class="op">==</span> pyo.TerminationCondition.infeasible:</span>
+<span id="cb290-24"><a href="#cb290-24" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;INFEASIBLE&quot;</span>)</span>
+<span id="cb290-25"><a href="#cb290-25" aria-hidden="true" tabindex="-1"></a><span class="cf">elif</span> zustand <span class="op">==</span> pyo.TerminationCondition.unbounded:</span>
+<span id="cb290-26"><a href="#cb290-26" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;UNBOUNDED&quot;</span>)</span>
+<span id="cb290-27"><a href="#cb290-27" aria-hidden="true" tabindex="-1"></a><span class="cf">elif</span> zustand <span class="op">==</span> pyo.TerminationCondition.maxTimeLimit:</span>
+<span id="cb290-28"><a href="#cb290-28" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;Zeitlimit&quot;</span>)</span>
+<span id="cb290-29"><a href="#cb290-29" aria-hidden="true" tabindex="-1"></a><span class="cf">else</span>:</span>
+<span id="cb290-30"><a href="#cb290-30" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;kein Optimum:&quot;</span>, zustand)</span></code></pre></div>
 <h3 id="linopy">Linopy</h3>
-<div class="sourceCode" id="cb287"><pre class="sourceCode python"><code class="sourceCode python"><span id="cb287-1"><a href="#cb287-1" aria-hidden="true" tabindex="-1"></a><span class="im">import</span> linopy</span>
-<span id="cb287-2"><a href="#cb287-2" aria-hidden="true" tabindex="-1"></a><span class="im">import</span> numpy <span class="im">as</span> np</span>
-<span id="cb287-3"><a href="#cb287-3" aria-hidden="true" tabindex="-1"></a><span class="im">import</span> pandas <span class="im">as</span> pd</span>
-<span id="cb287-4"><a href="#cb287-4" aria-hidden="true" tabindex="-1"></a><span class="im">import</span> xarray <span class="im">as</span> xr</span>
-<span id="cb287-5"><a href="#cb287-5" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb287-6"><a href="#cb287-6" aria-hidden="true" tabindex="-1"></a><span class="co"># Benannte Indizes statt blosser Listen - sonst heissen die Achsen &quot;dim_0&quot;</span></span>
-<span id="cb287-7"><a href="#cb287-7" aria-hidden="true" tabindex="-1"></a>produkt <span class="op">=</span> pd.Index([<span class="st">&quot;Rahmen&quot;</span>, <span class="st">&quot;Gehaeuse&quot;</span>, <span class="st">&quot;Deckel&quot;</span>], name<span class="op">=</span><span class="st">&quot;produkt&quot;</span>)</span>
-<span id="cb287-8"><a href="#cb287-8" aria-hidden="true" tabindex="-1"></a>ressource <span class="op">=</span> pd.Index([<span class="st">&quot;Montage&quot;</span>, <span class="st">&quot;Pruefung&quot;</span>], name<span class="op">=</span><span class="st">&quot;ressource&quot;</span>)</span>
-<span id="cb287-9"><a href="#cb287-9" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb287-10"><a href="#cb287-10" aria-hidden="true" tabindex="-1"></a>modell <span class="op">=</span> linopy.Model()</span>
-<span id="cb287-11"><a href="#cb287-11" aria-hidden="true" tabindex="-1"></a>modell.add_variables(lower<span class="op">=</span><span class="dv">0</span>, coords<span class="op">=</span>[produkt], name<span class="op">=</span><span class="st">&quot;menge&quot;</span>)</span>
-<span id="cb287-12"><a href="#cb287-12" aria-hidden="true" tabindex="-1"></a>x <span class="op">=</span> modell.variables[<span class="st">&quot;menge&quot;</span>]</span>
-<span id="cb287-13"><a href="#cb287-13" aria-hidden="true" tabindex="-1"></a><span class="co"># ganzzahlig: integer=True | binaer: binary=True</span></span>
-<span id="cb287-14"><a href="#cb287-14" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb287-15"><a href="#cb287-15" aria-hidden="true" tabindex="-1"></a>ertrag <span class="op">=</span> xr.DataArray([<span class="fl">10.0</span>, <span class="fl">15.0</span>, <span class="fl">25.0</span>], coords<span class="op">=</span>[produkt])</span>
-<span id="cb287-16"><a href="#cb287-16" aria-hidden="true" tabindex="-1"></a>verbrauch <span class="op">=</span> xr.DataArray([[<span class="fl">1.0</span>, <span class="fl">1.0</span>, <span class="fl">2.0</span>], [<span class="fl">2.0</span>, <span class="fl">3.0</span>, <span class="fl">1.0</span>]],</span>
-<span id="cb287-17"><a href="#cb287-17" aria-hidden="true" tabindex="-1"></a>                         coords<span class="op">=</span>[ressource, produkt])</span>
-<span id="cb287-18"><a href="#cb287-18" aria-hidden="true" tabindex="-1"></a>vorrat <span class="op">=</span> xr.DataArray([<span class="fl">40.0</span>, <span class="fl">50.0</span>], coords<span class="op">=</span>[ressource])</span>
-<span id="cb287-19"><a href="#cb287-19" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb287-20"><a href="#cb287-20" aria-hidden="true" tabindex="-1"></a>modell.add_objective((ertrag <span class="op">*</span> x).<span class="bu">sum</span>(), sense<span class="op">=</span><span class="st">&quot;max&quot;</span>)</span>
-<span id="cb287-21"><a href="#cb287-21" aria-hidden="true" tabindex="-1"></a><span class="co"># EINE Zeile, so viele Nebenbedingungen wie &#39;ressource&#39; Eintraege hat:</span></span>
-<span id="cb287-22"><a href="#cb287-22" aria-hidden="true" tabindex="-1"></a>modell.add_constraints((verbrauch <span class="op">*</span> x).<span class="bu">sum</span>(<span class="st">&quot;produkt&quot;</span>) <span class="op">&lt;=</span> vorrat, name<span class="op">=</span><span class="st">&quot;kapazitaet&quot;</span>)</span>
-<span id="cb287-23"><a href="#cb287-23" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb287-24"><a href="#cb287-24" aria-hidden="true" tabindex="-1"></a>modell.solve(solver_name<span class="op">=</span><span class="st">&quot;highs&quot;</span>, output_flag<span class="op">=</span><span class="va">False</span>)</span>
-<span id="cb287-25"><a href="#cb287-25" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb287-26"><a href="#cb287-26" aria-hidden="true" tabindex="-1"></a><span class="cf">if</span> modell.termination_condition <span class="op">==</span> <span class="st">&quot;optimal&quot;</span>:</span>
-<span id="cb287-27"><a href="#cb287-27" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;optimal: </span><span class="sc">{</span>modell<span class="sc">.</span>objective<span class="sc">.</span>value<span class="sc">:.2f}</span><span class="ss">&quot;</span>)</span>
-<span id="cb287-28"><a href="#cb287-28" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(x.solution.to_series().<span class="bu">round</span>(<span class="dv">4</span>).to_dict())</span>
-<span id="cb287-29"><a href="#cb287-29" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;Schattenpreise:&quot;</span>,</span>
-<span id="cb287-30"><a href="#cb287-30" aria-hidden="true" tabindex="-1"></a>          modell.constraints[<span class="st">&quot;kapazitaet&quot;</span>].dual.to_series().<span class="bu">round</span>(<span class="dv">4</span>).to_dict())</span>
-<span id="cb287-31"><a href="#cb287-31" aria-hidden="true" tabindex="-1"></a><span class="cf">elif</span> modell.termination_condition <span class="op">==</span> <span class="st">&quot;infeasible&quot;</span>:</span>
-<span id="cb287-32"><a href="#cb287-32" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;INFEASIBLE&quot;</span>)</span>
-<span id="cb287-33"><a href="#cb287-33" aria-hidden="true" tabindex="-1"></a><span class="cf">elif</span> modell.termination_condition <span class="op">==</span> <span class="st">&quot;unbounded&quot;</span>:</span>
-<span id="cb287-34"><a href="#cb287-34" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;UNBOUNDED&quot;</span>)</span>
-<span id="cb287-35"><a href="#cb287-35" aria-hidden="true" tabindex="-1"></a><span class="cf">else</span>:</span>
-<span id="cb287-36"><a href="#cb287-36" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;kein Optimum:&quot;</span>, modell.status, modell.termination_condition)</span></code></pre></div>
+<div class="sourceCode" id="cb291"><pre class="sourceCode python"><code class="sourceCode python"><span id="cb291-1"><a href="#cb291-1" aria-hidden="true" tabindex="-1"></a><span class="im">import</span> linopy</span>
+<span id="cb291-2"><a href="#cb291-2" aria-hidden="true" tabindex="-1"></a><span class="im">import</span> numpy <span class="im">as</span> np</span>
+<span id="cb291-3"><a href="#cb291-3" aria-hidden="true" tabindex="-1"></a><span class="im">import</span> pandas <span class="im">as</span> pd</span>
+<span id="cb291-4"><a href="#cb291-4" aria-hidden="true" tabindex="-1"></a><span class="im">import</span> xarray <span class="im">as</span> xr</span>
+<span id="cb291-5"><a href="#cb291-5" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb291-6"><a href="#cb291-6" aria-hidden="true" tabindex="-1"></a><span class="co"># Benannte Indizes statt blosser Listen - sonst heissen die Achsen &quot;dim_0&quot;</span></span>
+<span id="cb291-7"><a href="#cb291-7" aria-hidden="true" tabindex="-1"></a>produkt <span class="op">=</span> pd.Index([<span class="st">&quot;Rahmen&quot;</span>, <span class="st">&quot;Gehaeuse&quot;</span>, <span class="st">&quot;Deckel&quot;</span>], name<span class="op">=</span><span class="st">&quot;produkt&quot;</span>)</span>
+<span id="cb291-8"><a href="#cb291-8" aria-hidden="true" tabindex="-1"></a>ressource <span class="op">=</span> pd.Index([<span class="st">&quot;Montage&quot;</span>, <span class="st">&quot;Pruefung&quot;</span>], name<span class="op">=</span><span class="st">&quot;ressource&quot;</span>)</span>
+<span id="cb291-9"><a href="#cb291-9" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb291-10"><a href="#cb291-10" aria-hidden="true" tabindex="-1"></a>modell <span class="op">=</span> linopy.Model()</span>
+<span id="cb291-11"><a href="#cb291-11" aria-hidden="true" tabindex="-1"></a>modell.add_variables(lower<span class="op">=</span><span class="dv">0</span>, coords<span class="op">=</span>[produkt], name<span class="op">=</span><span class="st">&quot;menge&quot;</span>)</span>
+<span id="cb291-12"><a href="#cb291-12" aria-hidden="true" tabindex="-1"></a>x <span class="op">=</span> modell.variables[<span class="st">&quot;menge&quot;</span>]</span>
+<span id="cb291-13"><a href="#cb291-13" aria-hidden="true" tabindex="-1"></a><span class="co"># ganzzahlig: integer=True | binaer: binary=True</span></span>
+<span id="cb291-14"><a href="#cb291-14" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb291-15"><a href="#cb291-15" aria-hidden="true" tabindex="-1"></a>ertrag <span class="op">=</span> xr.DataArray([<span class="fl">10.0</span>, <span class="fl">15.0</span>, <span class="fl">25.0</span>], coords<span class="op">=</span>[produkt])</span>
+<span id="cb291-16"><a href="#cb291-16" aria-hidden="true" tabindex="-1"></a>verbrauch <span class="op">=</span> xr.DataArray([[<span class="fl">1.0</span>, <span class="fl">1.0</span>, <span class="fl">2.0</span>], [<span class="fl">2.0</span>, <span class="fl">3.0</span>, <span class="fl">1.0</span>]],</span>
+<span id="cb291-17"><a href="#cb291-17" aria-hidden="true" tabindex="-1"></a>                         coords<span class="op">=</span>[ressource, produkt])</span>
+<span id="cb291-18"><a href="#cb291-18" aria-hidden="true" tabindex="-1"></a>vorrat <span class="op">=</span> xr.DataArray([<span class="fl">40.0</span>, <span class="fl">50.0</span>], coords<span class="op">=</span>[ressource])</span>
+<span id="cb291-19"><a href="#cb291-19" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb291-20"><a href="#cb291-20" aria-hidden="true" tabindex="-1"></a>modell.add_objective((ertrag <span class="op">*</span> x).<span class="bu">sum</span>(), sense<span class="op">=</span><span class="st">&quot;max&quot;</span>)</span>
+<span id="cb291-21"><a href="#cb291-21" aria-hidden="true" tabindex="-1"></a><span class="co"># EINE Zeile, so viele Nebenbedingungen wie &#39;ressource&#39; Eintraege hat:</span></span>
+<span id="cb291-22"><a href="#cb291-22" aria-hidden="true" tabindex="-1"></a>modell.add_constraints((verbrauch <span class="op">*</span> x).<span class="bu">sum</span>(<span class="st">&quot;produkt&quot;</span>) <span class="op">&lt;=</span> vorrat, name<span class="op">=</span><span class="st">&quot;kapazitaet&quot;</span>)</span>
+<span id="cb291-23"><a href="#cb291-23" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb291-24"><a href="#cb291-24" aria-hidden="true" tabindex="-1"></a>modell.solve(solver_name<span class="op">=</span><span class="st">&quot;highs&quot;</span>, output_flag<span class="op">=</span><span class="va">False</span>)</span>
+<span id="cb291-25"><a href="#cb291-25" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb291-26"><a href="#cb291-26" aria-hidden="true" tabindex="-1"></a><span class="cf">if</span> modell.termination_condition <span class="op">==</span> <span class="st">&quot;optimal&quot;</span>:</span>
+<span id="cb291-27"><a href="#cb291-27" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;optimal: </span><span class="sc">{</span>modell<span class="sc">.</span>objective<span class="sc">.</span>value<span class="sc">:.2f}</span><span class="ss">&quot;</span>)</span>
+<span id="cb291-28"><a href="#cb291-28" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(x.solution.to_series().<span class="bu">round</span>(<span class="dv">4</span>).to_dict())</span>
+<span id="cb291-29"><a href="#cb291-29" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;Schattenpreise:&quot;</span>,</span>
+<span id="cb291-30"><a href="#cb291-30" aria-hidden="true" tabindex="-1"></a>          modell.constraints[<span class="st">&quot;kapazitaet&quot;</span>].dual.to_series().<span class="bu">round</span>(<span class="dv">4</span>).to_dict())</span>
+<span id="cb291-31"><a href="#cb291-31" aria-hidden="true" tabindex="-1"></a><span class="cf">elif</span> modell.termination_condition <span class="op">==</span> <span class="st">&quot;infeasible&quot;</span>:</span>
+<span id="cb291-32"><a href="#cb291-32" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;INFEASIBLE&quot;</span>)</span>
+<span id="cb291-33"><a href="#cb291-33" aria-hidden="true" tabindex="-1"></a><span class="cf">elif</span> modell.termination_condition <span class="op">==</span> <span class="st">&quot;unbounded&quot;</span>:</span>
+<span id="cb291-34"><a href="#cb291-34" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;UNBOUNDED&quot;</span>)</span>
+<span id="cb291-35"><a href="#cb291-35" aria-hidden="true" tabindex="-1"></a><span class="cf">else</span>:</span>
+<span id="cb291-36"><a href="#cb291-36" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;kein Optimum:&quot;</span>, modell.status, modell.termination_condition)</span></code></pre></div>
 <h3 id="die-drei-häufigsten-stolpersteine-5">Die drei häufigsten Stolpersteine</h3>
 <ol type="1">
 <li><strong>Der Solver ist ein eigenes Programm.</strong> <code>SolverFactory("appsi_highs")</code> scheitert, wenn HiGHS nicht auffindbar ist — die Fehlermeldung nennt dann das Modell, nicht die fehlende Installation.</li>
diff --git a/OR_HTML_04/graphen.html b/OR_HTML_04/graphen.html
index 9094a9b..ecdbf41 100644
--- a/OR_HTML_04/graphen.html
+++ b/OR_HTML_04/graphen.html
@@ -94,7 +94,7 @@
 </header>
 <div class="site-body">
   <div class="sidebar-overlay" id="sidebar-overlay" hidden></div>
-  <nav class="sidebar" id="sidebar" aria-label="Kapitelnavigation"><div class="sidebar-inhalt"><details class="sidebar-gruppe"><summary>Einstieg</summary><ul><li data-kapitel="vorwort.html"><a href="vorwort.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Vorwort & Lesehilfe</span></a></li><li data-kapitel="notation.html"><a href="notation.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Notation & Abkürzungen</span></a></li></ul></details><details class="sidebar-gruppe"><summary>Teil I: Grundlagen des Operations Research</summary><ul><li data-kapitel="einfuehrung.html"><a href="einfuehrung.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 1: Einführung in Operations Research — Vom Ursprung zur mathematischen Entscheidungsfindung</span></a></li><li data-kapitel="fundament.html"><a href="fundament.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 2: Das mathematische Fundament — Vektoren, Matrizen, Konvexität</span></a></li><li data-kapitel="oekosystem.html"><a href="oekosystem.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 3: Das Python-Ökosystem für OR — Solver, Bindings und Modellierungsschichten</span></a></li><li data-kapitel="modellierung.html"><a href="modellierung.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 4: Vom Management-Wunsch zum Modell</span></a></li></ul></details><details class="sidebar-gruppe" open><summary>Teil II: Die Kernverfahren der deterministischen Optimierung</summary><ul><li data-kapitel="lp.html"><a href="lp.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 5: Lineare Programmierung — Simplex, Dualität und Schattenpreise</span></a></li><li data-kapitel="milp.html"><a href="milp.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 6: Gemischt-ganzzahlige Optimierung — Diskrete Entscheidungen und Branch-and-Bound</span></a></li><li data-kapitel="cpsat.html"><a href="cpsat.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 7: Constraint Programming mit CP-SAT — Logik, Scheduling und Zuweisung</span></a></li><li data-kapitel="graphen.html" class="aktiv"><a href="graphen.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 8: Graphen, Flüsse und Touren — Min-Cost-Flow, Matching und VRP</span></a></li><li data-kapitel="metaheuristiken.html"><a href="metaheuristiken.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 9: Metaheuristiken — wenn der exakte Solver aussteigt</span></a></li><li data-kapitel="dekomposition.html"><a href="dekomposition.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 10: Spaltengenerierung — das Modell umbauen statt die Lösung raten</span></a></li></ul></details><details class="sidebar-gruppe"><summary>Teil III: Nichtlinearität, Unsicherheit und mehrperiodige Dynamik</summary><ul><li data-kapitel="qp-nlp.html"><a href="qp-nlp.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 11: Quadratische und nichtlineare Optimierung — KKT, Lagrange, Konvexität</span></a></li><li data-kapitel="unsicherheit.html"><a href="unsicherheit.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 12: Optimierung unter Unsicherheit — Monte-Carlo, Stochastik, Robustheit</span></a></li><li data-kapitel="dynamische-programmierung.html"><a href="dynamische-programmierung.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 13: Dynamische Programmierung — Die Bellman-Gleichung und Order-Execution</span></a></li><li data-kapitel="mehrziel.html"><a href="mehrziel.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 14: Mehrere Ziele — Pareto-Fronten statt Gewichte</span></a></li><li data-kapitel="prognose.html"><a href="prognose.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 15: Predict-then-Optimize — die bessere Prognose, die schlechtere Entscheidung</span></a></li></ul></details><details class="sidebar-gruppe"><summary>Teil IV: Anwendungen — Energiewirtschaft und Finanzmärkte</summary><ul><li data-kapitel="bruecke.html"><a href="bruecke.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 16: Die Strukturbrücke — dieselbe Mathematik, zwei Welten</span></a></li><li data-kapitel="supplychain.html"><a href="supplychain.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 17: Supply-Chain und Energieeinsatz unter Unsicherheit</span></a></li><li data-kapitel="finanzdaten.html"><a href="finanzdaten.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 18: Finanzdaten-Modellierung — Renditen, Kovarianz und Shrinkage</span></a></li><li data-kapitel="markowitz.html"><a href="markowitz.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 19: Die moderne Portfoliotheorie nach Markowitz</span></a></li><li data-kapitel="cvar.html"><a href="cvar.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 20: Tail-Risiko, CVaR und Transaktionskosten</span></a></li><li data-kapitel="handelsmaschine.html"><a href="handelsmaschine.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 21: Die vollständige quantitative Handelsmaschine</span></a></li></ul></details><details class="sidebar-gruppe"><summary>Teil V: Praxis</summary><ul><li data-kapitel="praxisfallen.html"><a href="praxisfallen.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 22: Praxisfallen und der Weg zum produktiven Einsatz</span></a></li><li data-kapitel="testing.html"><a href="testing.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 23: Testen, Messen, Ausliefern</span></a></li><li data-kapitel="projektwerkstatt.html"><a href="projektwerkstatt.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Projektwerkstatt</span></a></li></ul></details><details class="sidebar-gruppe"><summary>Anhänge</summary><ul><li data-kapitel="anhang-loesungen.html"><a href="anhang-loesungen.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Anhang A: Lösungen zu allen Übungsaufgaben</span></a></li><li data-kapitel="anhang-modellierungsmuster.html"><a href="anhang-modellierungsmuster.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Anhang B: Katalog der Modellierungsmuster</span></a></li><li data-kapitel="anhang-fehlerdiagnose.html"><a href="anhang-fehlerdiagnose.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Anhang C: Fehlerdiagnose-Handbuch</span></a></li><li data-kapitel="anhang-spickzettel.html"><a href="anhang-spickzettel.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Anhang D: Spickzettel der Solver</span></a></li><li data-kapitel="anhang-glossar-literatur.html"><a href="anhang-glossar-literatur.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Anhang E: Glossar und Literatur</span></a></li></ul></details><ul class="sidebar-extra"><li><a href="programme.html"><svg class="icon" aria-hidden="true"><use href="#icon-book"></use></svg> Beispielprogramme</a></li><li><a href="stichwortverzeichnis.html"><svg class="icon" aria-hidden="true"><use href="#icon-search"></use></svg> Stichwortverzeichnis</a></li><li><a href="gesamtdokument.html"><svg class="icon" aria-hidden="true"><use href="#icon-external-link"></use></svg> Gesamtdokument (eine Seite)</a></li><li><a href="Operations_Research_mit_Python_Version_04.pdf" download><svg class="icon" aria-hidden="true"><use href="#icon-download"></use></svg> Download als PDF</a></li></ul></div></nav>
+  <nav class="sidebar" id="sidebar" aria-label="Kapitelnavigation"><div class="sidebar-inhalt"><details class="sidebar-gruppe"><summary>Einstieg</summary><ul><li data-kapitel="vorwort.html"><a href="vorwort.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Vorwort & Lesehilfe</span></a></li><li data-kapitel="notation.html"><a href="notation.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Notation & Abkürzungen</span></a></li></ul></details><details class="sidebar-gruppe"><summary>Teil I: Grundlagen des Operations Research</summary><ul><li data-kapitel="einfuehrung.html"><a href="einfuehrung.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 1: Einführung in Operations Research — Vom Ursprung zur mathematischen Entscheidungsfindung</span></a></li><li data-kapitel="fundament.html"><a href="fundament.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 2: Das mathematische Fundament — Vektoren, Matrizen, Konvexität</span></a></li><li data-kapitel="oekosystem.html"><a href="oekosystem.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 3: Das Python-Ökosystem für OR — Solver, Bindings und Modellierungsschichten</span></a></li><li data-kapitel="modellierung.html"><a href="modellierung.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 4: Vom Management-Wunsch zum Modell</span></a></li><li data-kapitel="synthese-grundlagen.html"><a href="synthese-grundlagen.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Synthese Teil I</span></a></li></ul></details><details class="sidebar-gruppe" open><summary>Teil II: Die Kernverfahren der deterministischen Optimierung</summary><ul><li data-kapitel="lp.html"><a href="lp.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 5: Lineare Programmierung — Simplex, Dualität und Schattenpreise</span></a></li><li data-kapitel="milp.html"><a href="milp.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 6: Gemischt-ganzzahlige Optimierung — Diskrete Entscheidungen und Branch-and-Bound</span></a></li><li data-kapitel="cpsat.html"><a href="cpsat.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 7: Constraint Programming mit CP-SAT — Logik, Scheduling und Zuweisung</span></a></li><li data-kapitel="graphen.html" class="aktiv"><a href="graphen.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 8: Graphen, Flüsse und Touren — Min-Cost-Flow, Matching und VRP</span></a></li><li data-kapitel="metaheuristiken.html"><a href="metaheuristiken.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 9: Metaheuristiken — wenn der exakte Solver aussteigt</span></a></li><li data-kapitel="dekomposition.html"><a href="dekomposition.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 10: Spaltengenerierung — das Modell umbauen statt die Lösung raten</span></a></li><li data-kapitel="synthese-kernverfahren.html"><a href="synthese-kernverfahren.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Synthese Teil II</span></a></li></ul></details><details class="sidebar-gruppe"><summary>Teil III: Nichtlinearität, Unsicherheit und mehrperiodige Dynamik</summary><ul><li data-kapitel="qp-nlp.html"><a href="qp-nlp.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 11: Quadratische und nichtlineare Optimierung — KKT, Lagrange, Konvexität</span></a></li><li data-kapitel="unsicherheit.html"><a href="unsicherheit.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 12: Optimierung unter Unsicherheit — Monte-Carlo, Stochastik, Robustheit</span></a></li><li data-kapitel="dynamische-programmierung.html"><a href="dynamische-programmierung.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 13: Dynamische Programmierung — Die Bellman-Gleichung und Order-Execution</span></a></li><li data-kapitel="mehrziel.html"><a href="mehrziel.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 14: Mehrere Ziele — Pareto-Fronten statt Gewichte</span></a></li><li data-kapitel="prognose.html"><a href="prognose.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 15: Predict-then-Optimize — die bessere Prognose, die schlechtere Entscheidung</span></a></li><li data-kapitel="synthese-nichtlinear.html"><a href="synthese-nichtlinear.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Synthese Teil III</span></a></li></ul></details><details class="sidebar-gruppe"><summary>Teil IV: Anwendungen — Energiewirtschaft und Finanzmärkte</summary><ul><li data-kapitel="bruecke.html"><a href="bruecke.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 16: Die Strukturbrücke — dieselbe Mathematik, zwei Welten</span></a></li><li data-kapitel="supplychain.html"><a href="supplychain.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 17: Supply-Chain und Energieeinsatz unter Unsicherheit</span></a></li><li data-kapitel="finanzdaten.html"><a href="finanzdaten.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 18: Finanzdaten-Modellierung — Renditen, Kovarianz und Shrinkage</span></a></li><li data-kapitel="markowitz.html"><a href="markowitz.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 19: Die moderne Portfoliotheorie nach Markowitz</span></a></li><li data-kapitel="cvar.html"><a href="cvar.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 20: Tail-Risiko, CVaR und Transaktionskosten</span></a></li><li data-kapitel="handelsmaschine.html"><a href="handelsmaschine.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 21: Die vollständige quantitative Handelsmaschine</span></a></li><li data-kapitel="synthese-anwendungen.html"><a href="synthese-anwendungen.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Synthese Teil IV</span></a></li></ul></details><details class="sidebar-gruppe"><summary>Teil V: Praxis</summary><ul><li data-kapitel="praxisfallen.html"><a href="praxisfallen.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 22: Praxisfallen und der Weg zum produktiven Einsatz</span></a></li><li data-kapitel="testing.html"><a href="testing.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 23: Testen, Messen, Ausliefern</span></a></li><li data-kapitel="synthese-praxis.html"><a href="synthese-praxis.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Synthese Teil V</span></a></li><li data-kapitel="projektwerkstatt.html"><a href="projektwerkstatt.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Projektwerkstatt</span></a></li></ul></details><details class="sidebar-gruppe"><summary>Anhänge</summary><ul><li data-kapitel="anhang-loesungen.html"><a href="anhang-loesungen.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Anhang A: Lösungen zu allen Übungsaufgaben</span></a></li><li data-kapitel="anhang-modellierungsmuster.html"><a href="anhang-modellierungsmuster.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Anhang B: Katalog der Modellierungsmuster</span></a></li><li data-kapitel="anhang-fehlerdiagnose.html"><a href="anhang-fehlerdiagnose.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Anhang C: Fehlerdiagnose-Handbuch</span></a></li><li data-kapitel="anhang-spickzettel.html"><a href="anhang-spickzettel.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Anhang D: Spickzettel der Solver</span></a></li><li data-kapitel="anhang-glossar-literatur.html"><a href="anhang-glossar-literatur.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Anhang E: Glossar und Literatur</span></a></li></ul></details><ul class="sidebar-extra"><li><a href="programme.html"><svg class="icon" aria-hidden="true"><use href="#icon-book"></use></svg> Beispielprogramme</a></li><li><a href="stichwortverzeichnis.html"><svg class="icon" aria-hidden="true"><use href="#icon-search"></use></svg> Stichwortverzeichnis</a></li><li><a href="gesamtdokument.html"><svg class="icon" aria-hidden="true"><use href="#icon-external-link"></use></svg> Gesamtdokument (eine Seite)</a></li><li><a href="Operations_Research_mit_Python_Version_04.pdf" download><svg class="icon" aria-hidden="true"><use href="#icon-download"></use></svg> Download als PDF</a></li></ul></div></nav>
   <main class="content">
     <nav class="breadcrumb" aria-label="Breadcrumb"><a href="index.html">Start</a> › <span>Teil II</span> › <span>Kapitel 8: Graphen, Flüsse und Touren — Min-Cost-Flow, Matching und VRP</span></nav>
     <nav class="prev-next"><a class="prev-next-knopf prev-next-prev" href="cpsat.html"><svg class="icon" aria-hidden="true"><use href="#icon-chevron-left"></use></svg><span><small>Zurück</small>Kapitel 7: Constraint Programming mit CP-SAT — Logik, Scheduling und Zuweisung</span></a><a class="prev-next-knopf prev-next-next" href="metaheuristiken.html"><span><small>Weiter</small>Kapitel 9: Metaheuristiken — wenn der exakte Solver aussteigt</span><svg class="icon" aria-hidden="true"><use href="#icon-chevron-right"></use></svg></a></nav>
@@ -783,7 +783,7 @@ u_i - u_j + C \cdot x_{ij} \le C - d_j \qquad \forall i \ne j
 <h2 id="sec:graphen-denkfehler">8.7 Finde den Denkfehler</h2>
 <div class="card card-denkfehler">
 <blockquote>
-<p><strong>🐛 Finde den Denkfehler 7.1: Die vergessene Dimension</strong></p>
+<p><strong>🐛 Finde den Denkfehler: Die vergessene Dimension</strong></p>
 <p>Eine Spedition lässt ihre Tagestouren optimieren: 16 Kunden, 4 Fahrzeuge zu je 10 Paletten, Gesamtbedarf 37 Paletten. Das erste Ergebnis begeistert alle — <strong>326 km</strong>. Nach einem Hinweis aus dem Fuhrpark wird das Modell überarbeitet; jetzt kommen <strong>572 km</strong> heraus, 75 % mehr. Der Auftraggeber ist verärgert: <em>„Ihre erste Version war doch viel besser.“</em></p>
 <p>Der Unterschied zwischen beiden Fassungen ist ein einziger Codeblock:</p>
 <div class="sourceCode" id="cb7"><pre class="sourceCode python"><code class="sourceCode python"><span id="cb7-1"><a href="#cb7-1" aria-hidden="true" tabindex="-1"></a><span class="kw">def</span> bedarf(index):</span>
@@ -1021,7 +1021,7 @@ plausibel aussieht.
 <h2 id="sec:graphen-quiz">8.8 Micro-Quiz</h2>
 <div class="card card-quiz">
 <blockquote>
-<p><strong>❓ Micro-Quiz 7: Drei Fragen zum Selbstcheck</strong></p>
+<p><strong>❓ Micro-Quiz 8: Drei Fragen zum Selbstcheck</strong></p>
 <p>Genau eine Antwort ist jeweils richtig. Auflösung in <a href="anhang-loesungen.html#quiz-loesung-graphen">Anhang A</a>.</p>
 <p><strong>1. Sie lösen ein Zuordnungsproblem (12 Monteure, 12 Aufträge) als LP — ganz ohne Binärvariablen. Das Ergebnis ist trotzdem 0/1-wertig. Warum?</strong> (a) Zufall; bei anderen Daten kämen Brüche heraus. (b) Die Nebenbedingungsmatrix ist total unimodular, deshalb sind alle Ecken des zulässigen Bereichs ganzzahlig — und in einer Ecke liegt das LP-Optimum. (c) <code>linprog</code> rundet die Lösung intern.</p>
 <p><strong>2. Sie ergänzen dasselbe Zuordnungsmodell um die Regel „höchstens 4 Monteure dürfen Überstunden machen“. Was ändert sich?</strong> (a) Nichts — die Struktur bleibt total unimodular. (b) Die Kardinalitätsbedingung passt nicht ins Schema; die totale Unimodularität geht verloren, die Relaxation kann Brüche liefern und Sie brauchen ein MILP. (c) Das Problem wird unlösbar.</p>
diff --git a/OR_HTML_04/handelsmaschine.html b/OR_HTML_04/handelsmaschine.html
index 48a9e6a..221d285 100644
--- a/OR_HTML_04/handelsmaschine.html
+++ b/OR_HTML_04/handelsmaschine.html
@@ -94,10 +94,10 @@
 </header>
 <div class="site-body">
   <div class="sidebar-overlay" id="sidebar-overlay" hidden></div>
-  <nav class="sidebar" id="sidebar" aria-label="Kapitelnavigation"><div class="sidebar-inhalt"><details class="sidebar-gruppe"><summary>Einstieg</summary><ul><li data-kapitel="vorwort.html"><a href="vorwort.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Vorwort & Lesehilfe</span></a></li><li data-kapitel="notation.html"><a href="notation.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Notation & Abkürzungen</span></a></li></ul></details><details class="sidebar-gruppe"><summary>Teil I: Grundlagen des Operations Research</summary><ul><li data-kapitel="einfuehrung.html"><a href="einfuehrung.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 1: Einführung in Operations Research — Vom Ursprung zur mathematischen Entscheidungsfindung</span></a></li><li data-kapitel="fundament.html"><a href="fundament.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 2: Das mathematische Fundament — Vektoren, Matrizen, Konvexität</span></a></li><li data-kapitel="oekosystem.html"><a href="oekosystem.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 3: Das Python-Ökosystem für OR — Solver, Bindings und Modellierungsschichten</span></a></li><li data-kapitel="modellierung.html"><a href="modellierung.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 4: Vom Management-Wunsch zum Modell</span></a></li></ul></details><details class="sidebar-gruppe"><summary>Teil II: Die Kernverfahren der deterministischen Optimierung</summary><ul><li data-kapitel="lp.html"><a href="lp.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 5: Lineare Programmierung — Simplex, Dualität und Schattenpreise</span></a></li><li data-kapitel="milp.html"><a href="milp.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 6: Gemischt-ganzzahlige Optimierung — Diskrete Entscheidungen und Branch-and-Bound</span></a></li><li data-kapitel="cpsat.html"><a href="cpsat.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 7: Constraint Programming mit CP-SAT — Logik, Scheduling und Zuweisung</span></a></li><li data-kapitel="graphen.html"><a href="graphen.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 8: Graphen, Flüsse und Touren — Min-Cost-Flow, Matching und VRP</span></a></li><li data-kapitel="metaheuristiken.html"><a href="metaheuristiken.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 9: Metaheuristiken — wenn der exakte Solver aussteigt</span></a></li><li data-kapitel="dekomposition.html"><a href="dekomposition.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 10: Spaltengenerierung — das Modell umbauen statt die Lösung raten</span></a></li></ul></details><details class="sidebar-gruppe"><summary>Teil III: Nichtlinearität, Unsicherheit und mehrperiodige Dynamik</summary><ul><li data-kapitel="qp-nlp.html"><a href="qp-nlp.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 11: Quadratische und nichtlineare Optimierung — KKT, Lagrange, Konvexität</span></a></li><li data-kapitel="unsicherheit.html"><a href="unsicherheit.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 12: Optimierung unter Unsicherheit — Monte-Carlo, Stochastik, Robustheit</span></a></li><li data-kapitel="dynamische-programmierung.html"><a href="dynamische-programmierung.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 13: Dynamische Programmierung — Die Bellman-Gleichung und Order-Execution</span></a></li><li data-kapitel="mehrziel.html"><a href="mehrziel.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 14: Mehrere Ziele — Pareto-Fronten statt Gewichte</span></a></li><li data-kapitel="prognose.html"><a href="prognose.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 15: Predict-then-Optimize — die bessere Prognose, die schlechtere Entscheidung</span></a></li></ul></details><details class="sidebar-gruppe" open><summary>Teil IV: Anwendungen — Energiewirtschaft und Finanzmärkte</summary><ul><li data-kapitel="bruecke.html"><a href="bruecke.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 16: Die Strukturbrücke — dieselbe Mathematik, zwei Welten</span></a></li><li data-kapitel="supplychain.html"><a href="supplychain.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 17: Supply-Chain und Energieeinsatz unter Unsicherheit</span></a></li><li data-kapitel="finanzdaten.html"><a href="finanzdaten.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 18: Finanzdaten-Modellierung — Renditen, Kovarianz und Shrinkage</span></a></li><li data-kapitel="markowitz.html"><a href="markowitz.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 19: Die moderne Portfoliotheorie nach Markowitz</span></a></li><li data-kapitel="cvar.html"><a href="cvar.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 20: Tail-Risiko, CVaR und Transaktionskosten</span></a></li><li data-kapitel="handelsmaschine.html" class="aktiv"><a href="handelsmaschine.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 21: Die vollständige quantitative Handelsmaschine</span></a></li></ul></details><details class="sidebar-gruppe"><summary>Teil V: Praxis</summary><ul><li data-kapitel="praxisfallen.html"><a href="praxisfallen.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 22: Praxisfallen und der Weg zum produktiven Einsatz</span></a></li><li data-kapitel="testing.html"><a href="testing.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 23: Testen, Messen, Ausliefern</span></a></li><li data-kapitel="projektwerkstatt.html"><a href="projektwerkstatt.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Projektwerkstatt</span></a></li></ul></details><details class="sidebar-gruppe"><summary>Anhänge</summary><ul><li data-kapitel="anhang-loesungen.html"><a href="anhang-loesungen.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Anhang A: Lösungen zu allen Übungsaufgaben</span></a></li><li data-kapitel="anhang-modellierungsmuster.html"><a href="anhang-modellierungsmuster.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Anhang B: Katalog der Modellierungsmuster</span></a></li><li data-kapitel="anhang-fehlerdiagnose.html"><a href="anhang-fehlerdiagnose.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Anhang C: Fehlerdiagnose-Handbuch</span></a></li><li data-kapitel="anhang-spickzettel.html"><a href="anhang-spickzettel.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Anhang D: Spickzettel der Solver</span></a></li><li data-kapitel="anhang-glossar-literatur.html"><a href="anhang-glossar-literatur.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Anhang E: Glossar und Literatur</span></a></li></ul></details><ul class="sidebar-extra"><li><a href="programme.html"><svg class="icon" aria-hidden="true"><use href="#icon-book"></use></svg> Beispielprogramme</a></li><li><a href="stichwortverzeichnis.html"><svg class="icon" aria-hidden="true"><use href="#icon-search"></use></svg> Stichwortverzeichnis</a></li><li><a href="gesamtdokument.html"><svg class="icon" aria-hidden="true"><use href="#icon-external-link"></use></svg> Gesamtdokument (eine Seite)</a></li><li><a href="Operations_Research_mit_Python_Version_04.pdf" download><svg class="icon" aria-hidden="true"><use href="#icon-download"></use></svg> Download als PDF</a></li></ul></div></nav>
+  <nav class="sidebar" id="sidebar" aria-label="Kapitelnavigation"><div class="sidebar-inhalt"><details class="sidebar-gruppe"><summary>Einstieg</summary><ul><li data-kapitel="vorwort.html"><a href="vorwort.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Vorwort & Lesehilfe</span></a></li><li data-kapitel="notation.html"><a href="notation.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Notation & Abkürzungen</span></a></li></ul></details><details class="sidebar-gruppe"><summary>Teil I: Grundlagen des Operations Research</summary><ul><li data-kapitel="einfuehrung.html"><a href="einfuehrung.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 1: Einführung in Operations Research — Vom Ursprung zur mathematischen Entscheidungsfindung</span></a></li><li data-kapitel="fundament.html"><a href="fundament.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 2: Das mathematische Fundament — Vektoren, Matrizen, Konvexität</span></a></li><li data-kapitel="oekosystem.html"><a href="oekosystem.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 3: Das Python-Ökosystem für OR — Solver, Bindings und Modellierungsschichten</span></a></li><li data-kapitel="modellierung.html"><a href="modellierung.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 4: Vom Management-Wunsch zum Modell</span></a></li><li data-kapitel="synthese-grundlagen.html"><a href="synthese-grundlagen.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Synthese Teil I</span></a></li></ul></details><details class="sidebar-gruppe"><summary>Teil II: Die Kernverfahren der deterministischen Optimierung</summary><ul><li data-kapitel="lp.html"><a href="lp.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 5: Lineare Programmierung — Simplex, Dualität und Schattenpreise</span></a></li><li data-kapitel="milp.html"><a href="milp.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 6: Gemischt-ganzzahlige Optimierung — Diskrete Entscheidungen und Branch-and-Bound</span></a></li><li data-kapitel="cpsat.html"><a href="cpsat.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 7: Constraint Programming mit CP-SAT — Logik, Scheduling und Zuweisung</span></a></li><li data-kapitel="graphen.html"><a href="graphen.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 8: Graphen, Flüsse und Touren — Min-Cost-Flow, Matching und VRP</span></a></li><li data-kapitel="metaheuristiken.html"><a href="metaheuristiken.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 9: Metaheuristiken — wenn der exakte Solver aussteigt</span></a></li><li data-kapitel="dekomposition.html"><a href="dekomposition.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 10: Spaltengenerierung — das Modell umbauen statt die Lösung raten</span></a></li><li data-kapitel="synthese-kernverfahren.html"><a href="synthese-kernverfahren.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Synthese Teil II</span></a></li></ul></details><details class="sidebar-gruppe"><summary>Teil III: Nichtlinearität, Unsicherheit und mehrperiodige Dynamik</summary><ul><li data-kapitel="qp-nlp.html"><a href="qp-nlp.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 11: Quadratische und nichtlineare Optimierung — KKT, Lagrange, Konvexität</span></a></li><li data-kapitel="unsicherheit.html"><a href="unsicherheit.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 12: Optimierung unter Unsicherheit — Monte-Carlo, Stochastik, Robustheit</span></a></li><li data-kapitel="dynamische-programmierung.html"><a href="dynamische-programmierung.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 13: Dynamische Programmierung — Die Bellman-Gleichung und Order-Execution</span></a></li><li data-kapitel="mehrziel.html"><a href="mehrziel.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 14: Mehrere Ziele — Pareto-Fronten statt Gewichte</span></a></li><li data-kapitel="prognose.html"><a href="prognose.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 15: Predict-then-Optimize — die bessere Prognose, die schlechtere Entscheidung</span></a></li><li data-kapitel="synthese-nichtlinear.html"><a href="synthese-nichtlinear.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Synthese Teil III</span></a></li></ul></details><details class="sidebar-gruppe" open><summary>Teil IV: Anwendungen — Energiewirtschaft und Finanzmärkte</summary><ul><li data-kapitel="bruecke.html"><a href="bruecke.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 16: Die Strukturbrücke — dieselbe Mathematik, zwei Welten</span></a></li><li data-kapitel="supplychain.html"><a href="supplychain.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 17: Supply-Chain und Energieeinsatz unter Unsicherheit</span></a></li><li data-kapitel="finanzdaten.html"><a href="finanzdaten.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 18: Finanzdaten-Modellierung — Renditen, Kovarianz und Shrinkage</span></a></li><li data-kapitel="markowitz.html"><a href="markowitz.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 19: Die moderne Portfoliotheorie nach Markowitz</span></a></li><li data-kapitel="cvar.html"><a href="cvar.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 20: Tail-Risiko, CVaR und Transaktionskosten</span></a></li><li data-kapitel="handelsmaschine.html" class="aktiv"><a href="handelsmaschine.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 21: Die vollständige quantitative Handelsmaschine</span></a></li><li data-kapitel="synthese-anwendungen.html"><a href="synthese-anwendungen.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Synthese Teil IV</span></a></li></ul></details><details class="sidebar-gruppe"><summary>Teil V: Praxis</summary><ul><li data-kapitel="praxisfallen.html"><a href="praxisfallen.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 22: Praxisfallen und der Weg zum produktiven Einsatz</span></a></li><li data-kapitel="testing.html"><a href="testing.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 23: Testen, Messen, Ausliefern</span></a></li><li data-kapitel="synthese-praxis.html"><a href="synthese-praxis.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Synthese Teil V</span></a></li><li data-kapitel="projektwerkstatt.html"><a href="projektwerkstatt.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Projektwerkstatt</span></a></li></ul></details><details class="sidebar-gruppe"><summary>Anhänge</summary><ul><li data-kapitel="anhang-loesungen.html"><a href="anhang-loesungen.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Anhang A: Lösungen zu allen Übungsaufgaben</span></a></li><li data-kapitel="anhang-modellierungsmuster.html"><a href="anhang-modellierungsmuster.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Anhang B: Katalog der Modellierungsmuster</span></a></li><li data-kapitel="anhang-fehlerdiagnose.html"><a href="anhang-fehlerdiagnose.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Anhang C: Fehlerdiagnose-Handbuch</span></a></li><li data-kapitel="anhang-spickzettel.html"><a href="anhang-spickzettel.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Anhang D: Spickzettel der Solver</span></a></li><li data-kapitel="anhang-glossar-literatur.html"><a href="anhang-glossar-literatur.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Anhang E: Glossar und Literatur</span></a></li></ul></details><ul class="sidebar-extra"><li><a href="programme.html"><svg class="icon" aria-hidden="true"><use href="#icon-book"></use></svg> Beispielprogramme</a></li><li><a href="stichwortverzeichnis.html"><svg class="icon" aria-hidden="true"><use href="#icon-search"></use></svg> Stichwortverzeichnis</a></li><li><a href="gesamtdokument.html"><svg class="icon" aria-hidden="true"><use href="#icon-external-link"></use></svg> Gesamtdokument (eine Seite)</a></li><li><a href="Operations_Research_mit_Python_Version_04.pdf" download><svg class="icon" aria-hidden="true"><use href="#icon-download"></use></svg> Download als PDF</a></li></ul></div></nav>
   <main class="content">
     <nav class="breadcrumb" aria-label="Breadcrumb"><a href="index.html">Start</a> › <span>Teil IV</span> › <span>Kapitel 21: Die vollständige quantitative Handelsmaschine</span></nav>
-    <nav class="prev-next"><a class="prev-next-knopf prev-next-prev" href="cvar.html"><svg class="icon" aria-hidden="true"><use href="#icon-chevron-left"></use></svg><span><small>Zurück</small>Kapitel 20: Tail-Risiko, CVaR und Transaktionskosten</span></a><a class="prev-next-knopf prev-next-next" href="praxisfallen.html"><span><small>Weiter</small>Kapitel 22: Praxisfallen und der Weg zum produktiven Einsatz</span><svg class="icon" aria-hidden="true"><use href="#icon-chevron-right"></use></svg></a></nav>
+    <nav class="prev-next"><a class="prev-next-knopf prev-next-prev" href="cvar.html"><svg class="icon" aria-hidden="true"><use href="#icon-chevron-left"></use></svg><span><small>Zurück</small>Kapitel 20: Tail-Risiko, CVaR und Transaktionskosten</span></a><a class="prev-next-knopf prev-next-next" href="synthese-anwendungen.html"><span><small>Weiter</small>Synthese Teil IV</span><svg class="icon" aria-hidden="true"><use href="#icon-chevron-right"></use></svg></a></nav>
     <article>
     <h1 id="kap-handelsmaschine">Kapitel 21: Die vollständige quantitative Handelsmaschine</h1>
 <div class="card card-blick">
@@ -835,7 +835,7 @@ FEHLER 1+2+3 kombiniert                          25.41 %       +19.80 %
 <p>Die beiden übrigen Selbsttäuschungen sind anders gebaut. Sie entstehen nicht im Code, sondern in der <strong>Arbeitsweise davor</strong> — und hinterlassen im Programm keine Spur. Ein Backtest, der zwanzigmal nachjustiert wurde, sieht am Ende genauso sauber aus wie einer, der beim ersten Versuch funktioniert hat.</p>
 <div class="card card-denkfehler">
 <blockquote>
-<p><strong>🐛 Finde den Denkfehler 14.1: Die Strategie mit dem hochsignifikanten Ergebnis</strong></p>
+<p><strong>🐛 Finde den Denkfehler: Die Strategie mit dem hochsignifikanten Ergebnis</strong></p>
 <p>Eine Analystin entwickelt über mehrere Wochen eine Handelsstrategie. Sie probiert verschiedene Signalfenster, Schwellenwerte, Filter und Haltedauern durch — insgesamt rund <strong>hundert Varianten</strong>. Die beste testet sie sauber: kein Lookahead, korrektes Universum, Transaktionskosten berücksichtigt.</p>
 <p>Das Ergebnis über fünf Jahre: <strong>Sharpe-Kennzahl 1,13</strong>, p-Wert <strong>0,0094</strong>. Der Backtest ist handwerklich einwandfrei — jede der drei Fallen aus <code>Backtest_Fallen.py</code> wurde vermieden. Sie stellt die Strategie vor.</p>
 <p><strong>Ihre Aufgabe:</strong> (a) Der Backtest ist korrekt. Warum ist das Ergebnis trotzdem wertlos? (b) Sehen Sie sich unten die letzte Spalte der Tabelle an: Sie bleibt konstant bei 5 %, obwohl die Zahl der Versuche um das Tausendfache wächst. Wieso ist das kein Widerspruch, sondern der Kern des Problems? (c) Welche Zahl fehlt in ihrem Bericht — eine Zahl, die in keinem Backtest-Ergebnis steht und die sie selbst aufschreiben müsste? (d) Nennen Sie drei Gegenmittel und begründen Sie, warum das dritte nur <strong>einmal</strong> verwendbar ist.</p>
@@ -1033,7 +1033,7 @@ von allen Fehlversuchen genau einen: den erfolgreichsten.
 <h2 id="sec:handelsmaschine-quiz">21.10 Micro-Quiz</h2>
 <div class="card card-quiz">
 <blockquote>
-<p><strong>❓ Micro-Quiz 14: Drei Fragen zum Selbstcheck</strong></p>
+<p><strong>❓ Micro-Quiz 21: Drei Fragen zum Selbstcheck</strong></p>
 <p>Genau eine Antwort ist jeweils richtig. Auflösung in <a href="anhang-loesungen.html#quiz-loesung-handelsmaschine">Anhang A</a>.</p>
 <p><strong>1. Zwei Strategien haben dieselbe Jahresrendite und dieselbe Sharpe-Kennzahl. Was wissen Sie über ihren Verlauf?</strong> (a) Er ist im Wesentlichen gleich — beide Kennzahlen zusammen beschreiben ihn vollständig. (b) <strong>Nichts.</strong> Beide Kennzahlen mitteln über die Zeit und verlieren die Reihenfolge. Dieselben Tagesrenditen können zu einem Rückschlag von 19 % oder von 98 % führen. (c) Die Strategie mit der höheren Schwankung hat den größeren Rückschlag.</p>
 <p><strong>2. Sie haben 50 Strategievarianten getestet und die beste erreicht p = 0,01. Wie bewerten Sie das?</strong> (a) Hochsignifikant — die Wahrscheinlichkeit eines Zufallsbefunds liegt bei 1 %. (b) Bei 50 Versuchen ist ein p-Wert von 0,01 unauffällig: Schon rein zufällig erwartet man etwa 2,5 Treffer unter dem 5-%-Niveau. Die Bonferroni-Schwelle läge bei 0,001. (c) Der p-Wert ist für Handelsstrategien grundsätzlich ungeeignet.</p>
@@ -1068,7 +1068,7 @@ von allen Fehlversuchen genau einen: den erfolgreichsten.
 
     </article>
     <button type="button" class="fortschritt-knopf" data-kapitel="handelsmaschine.html"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg> <span>Als gelesen markieren</span></button>
-    <nav class="prev-next"><a class="prev-next-knopf prev-next-prev" href="cvar.html"><svg class="icon" aria-hidden="true"><use href="#icon-chevron-left"></use></svg><span><small>Zurück</small>Kapitel 20: Tail-Risiko, CVaR und Transaktionskosten</span></a><a class="prev-next-knopf prev-next-next" href="praxisfallen.html"><span><small>Weiter</small>Kapitel 22: Praxisfallen und der Weg zum produktiven Einsatz</span><svg class="icon" aria-hidden="true"><use href="#icon-chevron-right"></use></svg></a></nav>
+    <nav class="prev-next"><a class="prev-next-knopf prev-next-prev" href="cvar.html"><svg class="icon" aria-hidden="true"><use href="#icon-chevron-left"></use></svg><span><small>Zurück</small>Kapitel 20: Tail-Risiko, CVaR und Transaktionskosten</span></a><a class="prev-next-knopf prev-next-next" href="synthese-anwendungen.html"><span><small>Weiter</small>Synthese Teil IV</span><svg class="icon" aria-hidden="true"><use href="#icon-chevron-right"></use></svg></a></nav>
   </main>
 </div>
 <footer class="site-footer">
diff --git a/OR_HTML_04/index.html b/OR_HTML_04/index.html
index 64a753c..12bc292 100644
--- a/OR_HTML_04/index.html
+++ b/OR_HTML_04/index.html
@@ -94,7 +94,7 @@
 </header>
 <div class="site-body">
   <div class="sidebar-overlay" id="sidebar-overlay" hidden></div>
-  <nav class="sidebar" id="sidebar" aria-label="Kapitelnavigation"><div class="sidebar-inhalt"><details class="sidebar-gruppe"><summary>Einstieg</summary><ul><li data-kapitel="vorwort.html"><a href="vorwort.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Vorwort & Lesehilfe</span></a></li><li data-kapitel="notation.html"><a href="notation.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Notation & Abkürzungen</span></a></li></ul></details><details class="sidebar-gruppe"><summary>Teil I: Grundlagen des Operations Research</summary><ul><li data-kapitel="einfuehrung.html"><a href="einfuehrung.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 1: Einführung in Operations Research — Vom Ursprung zur mathematischen Entscheidungsfindung</span></a></li><li data-kapitel="fundament.html"><a href="fundament.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 2: Das mathematische Fundament — Vektoren, Matrizen, Konvexität</span></a></li><li data-kapitel="oekosystem.html"><a href="oekosystem.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 3: Das Python-Ökosystem für OR — Solver, Bindings und Modellierungsschichten</span></a></li><li data-kapitel="modellierung.html"><a href="modellierung.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 4: Vom Management-Wunsch zum Modell</span></a></li></ul></details><details class="sidebar-gruppe"><summary>Teil II: Die Kernverfahren der deterministischen Optimierung</summary><ul><li data-kapitel="lp.html"><a href="lp.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 5: Lineare Programmierung — Simplex, Dualität und Schattenpreise</span></a></li><li data-kapitel="milp.html"><a href="milp.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 6: Gemischt-ganzzahlige Optimierung — Diskrete Entscheidungen und Branch-and-Bound</span></a></li><li data-kapitel="cpsat.html"><a href="cpsat.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 7: Constraint Programming mit CP-SAT — Logik, Scheduling und Zuweisung</span></a></li><li data-kapitel="graphen.html"><a href="graphen.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 8: Graphen, Flüsse und Touren — Min-Cost-Flow, Matching und VRP</span></a></li><li data-kapitel="metaheuristiken.html"><a href="metaheuristiken.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 9: Metaheuristiken — wenn der exakte Solver aussteigt</span></a></li><li data-kapitel="dekomposition.html"><a href="dekomposition.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 10: Spaltengenerierung — das Modell umbauen statt die Lösung raten</span></a></li></ul></details><details class="sidebar-gruppe"><summary>Teil III: Nichtlinearität, Unsicherheit und mehrperiodige Dynamik</summary><ul><li data-kapitel="qp-nlp.html"><a href="qp-nlp.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 11: Quadratische und nichtlineare Optimierung — KKT, Lagrange, Konvexität</span></a></li><li data-kapitel="unsicherheit.html"><a href="unsicherheit.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 12: Optimierung unter Unsicherheit — Monte-Carlo, Stochastik, Robustheit</span></a></li><li data-kapitel="dynamische-programmierung.html"><a href="dynamische-programmierung.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 13: Dynamische Programmierung — Die Bellman-Gleichung und Order-Execution</span></a></li><li data-kapitel="mehrziel.html"><a href="mehrziel.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 14: Mehrere Ziele — Pareto-Fronten statt Gewichte</span></a></li><li data-kapitel="prognose.html"><a href="prognose.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 15: Predict-then-Optimize — die bessere Prognose, die schlechtere Entscheidung</span></a></li></ul></details><details class="sidebar-gruppe"><summary>Teil IV: Anwendungen — Energiewirtschaft und Finanzmärkte</summary><ul><li data-kapitel="bruecke.html"><a href="bruecke.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 16: Die Strukturbrücke — dieselbe Mathematik, zwei Welten</span></a></li><li data-kapitel="supplychain.html"><a href="supplychain.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 17: Supply-Chain und Energieeinsatz unter Unsicherheit</span></a></li><li data-kapitel="finanzdaten.html"><a href="finanzdaten.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 18: Finanzdaten-Modellierung — Renditen, Kovarianz und Shrinkage</span></a></li><li data-kapitel="markowitz.html"><a href="markowitz.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 19: Die moderne Portfoliotheorie nach Markowitz</span></a></li><li data-kapitel="cvar.html"><a href="cvar.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 20: Tail-Risiko, CVaR und Transaktionskosten</span></a></li><li data-kapitel="handelsmaschine.html"><a href="handelsmaschine.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 21: Die vollständige quantitative Handelsmaschine</span></a></li></ul></details><details class="sidebar-gruppe"><summary>Teil V: Praxis</summary><ul><li data-kapitel="praxisfallen.html"><a href="praxisfallen.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 22: Praxisfallen und der Weg zum produktiven Einsatz</span></a></li><li data-kapitel="testing.html"><a href="testing.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 23: Testen, Messen, Ausliefern</span></a></li><li data-kapitel="projektwerkstatt.html"><a href="projektwerkstatt.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Projektwerkstatt</span></a></li></ul></details><details class="sidebar-gruppe"><summary>Anhänge</summary><ul><li data-kapitel="anhang-loesungen.html"><a href="anhang-loesungen.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Anhang A: Lösungen zu allen Übungsaufgaben</span></a></li><li data-kapitel="anhang-modellierungsmuster.html"><a href="anhang-modellierungsmuster.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Anhang B: Katalog der Modellierungsmuster</span></a></li><li data-kapitel="anhang-fehlerdiagnose.html"><a href="anhang-fehlerdiagnose.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Anhang C: Fehlerdiagnose-Handbuch</span></a></li><li data-kapitel="anhang-spickzettel.html"><a href="anhang-spickzettel.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Anhang D: Spickzettel der Solver</span></a></li><li data-kapitel="anhang-glossar-literatur.html"><a href="anhang-glossar-literatur.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Anhang E: Glossar und Literatur</span></a></li></ul></details><ul class="sidebar-extra"><li><a href="programme.html"><svg class="icon" aria-hidden="true"><use href="#icon-book"></use></svg> Beispielprogramme</a></li><li><a href="stichwortverzeichnis.html"><svg class="icon" aria-hidden="true"><use href="#icon-search"></use></svg> Stichwortverzeichnis</a></li><li><a href="gesamtdokument.html"><svg class="icon" aria-hidden="true"><use href="#icon-external-link"></use></svg> Gesamtdokument (eine Seite)</a></li><li><a href="Operations_Research_mit_Python_Version_04.pdf" download><svg class="icon" aria-hidden="true"><use href="#icon-download"></use></svg> Download als PDF</a></li></ul></div></nav>
+  <nav class="sidebar" id="sidebar" aria-label="Kapitelnavigation"><div class="sidebar-inhalt"><details class="sidebar-gruppe"><summary>Einstieg</summary><ul><li data-kapitel="vorwort.html"><a href="vorwort.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Vorwort & Lesehilfe</span></a></li><li data-kapitel="notation.html"><a href="notation.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Notation & Abkürzungen</span></a></li></ul></details><details class="sidebar-gruppe"><summary>Teil I: Grundlagen des Operations Research</summary><ul><li data-kapitel="einfuehrung.html"><a href="einfuehrung.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 1: Einführung in Operations Research — Vom Ursprung zur mathematischen Entscheidungsfindung</span></a></li><li data-kapitel="fundament.html"><a href="fundament.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 2: Das mathematische Fundament — Vektoren, Matrizen, Konvexität</span></a></li><li data-kapitel="oekosystem.html"><a href="oekosystem.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 3: Das Python-Ökosystem für OR — Solver, Bindings und Modellierungsschichten</span></a></li><li data-kapitel="modellierung.html"><a href="modellierung.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 4: Vom Management-Wunsch zum Modell</span></a></li><li data-kapitel="synthese-grundlagen.html"><a href="synthese-grundlagen.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Synthese Teil I</span></a></li></ul></details><details class="sidebar-gruppe"><summary>Teil II: Die Kernverfahren der deterministischen Optimierung</summary><ul><li data-kapitel="lp.html"><a href="lp.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 5: Lineare Programmierung — Simplex, Dualität und Schattenpreise</span></a></li><li data-kapitel="milp.html"><a href="milp.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 6: Gemischt-ganzzahlige Optimierung — Diskrete Entscheidungen und Branch-and-Bound</span></a></li><li data-kapitel="cpsat.html"><a href="cpsat.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 7: Constraint Programming mit CP-SAT — Logik, Scheduling und Zuweisung</span></a></li><li data-kapitel="graphen.html"><a href="graphen.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 8: Graphen, Flüsse und Touren — Min-Cost-Flow, Matching und VRP</span></a></li><li data-kapitel="metaheuristiken.html"><a href="metaheuristiken.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 9: Metaheuristiken — wenn der exakte Solver aussteigt</span></a></li><li data-kapitel="dekomposition.html"><a href="dekomposition.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 10: Spaltengenerierung — das Modell umbauen statt die Lösung raten</span></a></li><li data-kapitel="synthese-kernverfahren.html"><a href="synthese-kernverfahren.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Synthese Teil II</span></a></li></ul></details><details class="sidebar-gruppe"><summary>Teil III: Nichtlinearität, Unsicherheit und mehrperiodige Dynamik</summary><ul><li data-kapitel="qp-nlp.html"><a href="qp-nlp.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 11: Quadratische und nichtlineare Optimierung — KKT, Lagrange, Konvexität</span></a></li><li data-kapitel="unsicherheit.html"><a href="unsicherheit.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 12: Optimierung unter Unsicherheit — Monte-Carlo, Stochastik, Robustheit</span></a></li><li data-kapitel="dynamische-programmierung.html"><a href="dynamische-programmierung.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 13: Dynamische Programmierung — Die Bellman-Gleichung und Order-Execution</span></a></li><li data-kapitel="mehrziel.html"><a href="mehrziel.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 14: Mehrere Ziele — Pareto-Fronten statt Gewichte</span></a></li><li data-kapitel="prognose.html"><a href="prognose.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 15: Predict-then-Optimize — die bessere Prognose, die schlechtere Entscheidung</span></a></li><li data-kapitel="synthese-nichtlinear.html"><a href="synthese-nichtlinear.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Synthese Teil III</span></a></li></ul></details><details class="sidebar-gruppe"><summary>Teil IV: Anwendungen — Energiewirtschaft und Finanzmärkte</summary><ul><li data-kapitel="bruecke.html"><a href="bruecke.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 16: Die Strukturbrücke — dieselbe Mathematik, zwei Welten</span></a></li><li data-kapitel="supplychain.html"><a href="supplychain.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 17: Supply-Chain und Energieeinsatz unter Unsicherheit</span></a></li><li data-kapitel="finanzdaten.html"><a href="finanzdaten.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 18: Finanzdaten-Modellierung — Renditen, Kovarianz und Shrinkage</span></a></li><li data-kapitel="markowitz.html"><a href="markowitz.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 19: Die moderne Portfoliotheorie nach Markowitz</span></a></li><li data-kapitel="cvar.html"><a href="cvar.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 20: Tail-Risiko, CVaR und Transaktionskosten</span></a></li><li data-kapitel="handelsmaschine.html"><a href="handelsmaschine.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 21: Die vollständige quantitative Handelsmaschine</span></a></li><li data-kapitel="synthese-anwendungen.html"><a href="synthese-anwendungen.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Synthese Teil IV</span></a></li></ul></details><details class="sidebar-gruppe"><summary>Teil V: Praxis</summary><ul><li data-kapitel="praxisfallen.html"><a href="praxisfallen.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 22: Praxisfallen und der Weg zum produktiven Einsatz</span></a></li><li data-kapitel="testing.html"><a href="testing.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 23: Testen, Messen, Ausliefern</span></a></li><li data-kapitel="synthese-praxis.html"><a href="synthese-praxis.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Synthese Teil V</span></a></li><li data-kapitel="projektwerkstatt.html"><a href="projektwerkstatt.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Projektwerkstatt</span></a></li></ul></details><details class="sidebar-gruppe"><summary>Anhänge</summary><ul><li data-kapitel="anhang-loesungen.html"><a href="anhang-loesungen.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Anhang A: Lösungen zu allen Übungsaufgaben</span></a></li><li data-kapitel="anhang-modellierungsmuster.html"><a href="anhang-modellierungsmuster.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Anhang B: Katalog der Modellierungsmuster</span></a></li><li data-kapitel="anhang-fehlerdiagnose.html"><a href="anhang-fehlerdiagnose.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Anhang C: Fehlerdiagnose-Handbuch</span></a></li><li data-kapitel="anhang-spickzettel.html"><a href="anhang-spickzettel.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Anhang D: Spickzettel der Solver</span></a></li><li data-kapitel="anhang-glossar-literatur.html"><a href="anhang-glossar-literatur.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Anhang E: Glossar und Literatur</span></a></li></ul></details><ul class="sidebar-extra"><li><a href="programme.html"><svg class="icon" aria-hidden="true"><use href="#icon-book"></use></svg> Beispielprogramme</a></li><li><a href="stichwortverzeichnis.html"><svg class="icon" aria-hidden="true"><use href="#icon-search"></use></svg> Stichwortverzeichnis</a></li><li><a href="gesamtdokument.html"><svg class="icon" aria-hidden="true"><use href="#icon-external-link"></use></svg> Gesamtdokument (eine Seite)</a></li><li><a href="Operations_Research_mit_Python_Version_04.pdf" download><svg class="icon" aria-hidden="true"><use href="#icon-download"></use></svg> Download als PDF</a></li></ul></div></nav>
   <main class="content">
     
     <nav class="prev-next"><span class="prev-next-leer"></span><span class="prev-next-leer"></span></nav>
@@ -126,7 +126,7 @@
 </section>
 <section class="lernpfade">
   <h2>Lernpfade</h2>
-  <div class="kartenraster"><div class="karte karte-pfad"><h3>Pfad A — Vollständiger Lehrgang (100–140 Stunden)</h3><p><a href="einfuehrung.html#kap-einfuehrung">Kapitel 1</a> bis <a href="testing.html#kap-testing">Kapitel 23</a> in Reihenfolge, danach ein Projekt aus der Projektwerkstatt. Empfohlen, wenn Sie OR systematisch lernen wollen. Rechnen Sie mit 4–6 Stunden je Kapitel inklusive Übungen.</p></div><div class="karte karte-pfad"><h3>Pfad B — Planung, Disposition, Personaleinsatz (ca. 25 Stunden)</h3><p><a href="einfuehrung.html#kap-einfuehrung">Kapitel 1</a> (Bausteine) → <a href="fundament.html#kap-fundament">Kapitel 2</a> (bis <a href="fundament.html#sec:fundament-konvexitaet-die-grenze-zwischen-leicht-und">Abschnitt 2.5</a>) → <a href="modellierung.html#kap-modellierung">Kapitel 4</a> (vom Wunsch zum Modell) → <a href="lp.html#kap-lp">Kapitel 5</a> (LP, Schattenpreise) → <a href="milp.html#kap-milp">Kapitel 6</a> (Ja/Nein-Entscheidungen) → <a href="cpsat.html#kap-cpsat">Kapitel 7</a> (CP-SAT, Scheduling) → Projekt P1 (Vertretungsplaner) oder P2 (Schichtplanung). Das ist der kürzeste Weg zu einem einsetzbaren Dienstplan-Optimierer.</p></div><div class="karte karte-pfad"><h3>Pfad C — Logistik und Tourenplanung (ca. 25 Stunden)</h3><p><a href="einfuehrung.html#kap-einfuehrung">Kapitel 1</a> → <a href="fundament.html#kap-fundament">Kapitel 2</a> (bis <a href="fundament.html#sec:fundament-der-zulaessige-loesungsraum-und-das-polyeder">Abschnitt 2.4</a>) → <a href="lp.html#kap-lp">Kapitel 5</a> → <a href="milp.html#kap-milp">Kapitel 6</a> → <a href="graphen.html#kap-graphen">Kapitel 8</a> (Graphen, VRP) → Projekt P3 (Liefertouren) oder P4 (Lagernetzwerk).</p></div><div class="karte karte-pfad"><h3>Pfad D — Quantitative Finance (ca. 30 Stunden)</h3><p><a href="einfuehrung.html#kap-einfuehrung">Kapitel 1</a> → <a href="fundament.html#kap-fundament">Kapitel 2</a> → <a href="qp-nlp.html#kap-qp-nlp">Kapitel 11</a> (QP, KKT) → <a href="finanzdaten.html#kap-finanzdaten">Kapitel 18</a> (Daten, Shrinkage) → <a href="markowitz.html#kap-markowitz">Kapitel 19</a> (Markowitz) → <a href="cvar.html#kap-cvar">Kapitel 20</a> (CVaR) → <a href="handelsmaschine.html#kap-handelsmaschine">Kapitel 21</a> (Backtest) → Projekt P6 (Portfolio-Rebalancer) oder P7 (Risikoreport). Wichtig: Überspringen Sie <a href="finanzdaten.html#kap-finanzdaten">Kapitel 18</a> nicht. Wer direkt bei Markowitz einsteigt, optimiert Schätzrauschen und wundert sich über absurde Gewichte.</p></div><div class="karte karte-pfad"><h3>Pfad E — Ich habe morgen ein konkretes Problem (2–4 Stunden)</h3><p>Lesen Sie <a href="einfuehrung.html#sec:einfuehrung-historischer-kontext-und-evolution">Abschnitt 1.5</a> (die vier Bausteine), dann <a href="anhang-modellierungsmuster.html#anhang-modellierungsmuster">Anhang B</a> ([Modellierungsmuster](anhang-modellierungsmuster.html)) und suchen Sie dort das Muster, das zu Ihrem Problem passt. Von jedem Muster führt ein Verweis in das zuständige Kapitel. Wie die gewählte Bibliothek es schreibt, steht in <a href="anhang-spickzettel.html#anhang-spickzettel">Anhang D</a> ([Spickzettel](anhang-spickzettel.html)); wenn etwas nicht läuft, in <a href="anhang-fehlerdiagnose.html#anhang-fehlerdiagnose">Anhang C</a> ([Fehlerdiagnose](anhang-fehlerdiagnose.html)).</p></div></div>
+  <div class="kartenraster"><div class="karte karte-pfad"><h3>Pfad A — Vollständiger Lehrgang (100–140 Stunden)</h3><p><a href="einfuehrung.html#kap-einfuehrung">Kapitel 1</a> bis <a href="testing.html#kap-testing">Kapitel 23</a> in Reihenfolge, danach ein Projekt aus der Projektwerkstatt. Empfohlen, wenn Sie OR systematisch lernen wollen. Rechnen Sie mit 4–6 Stunden je Kapitel inklusive Übungen.</p></div><div class="karte karte-pfad"><h3>Pfad B — Planung, Disposition, Personaleinsatz (ca. 25 Stunden)</h3><p><a href="einfuehrung.html#kap-einfuehrung">Kapitel 1</a> (Bausteine) → <a href="fundament.html#kap-fundament">Kapitel 2</a> (bis <a href="fundament.html#sec:fundament-konvexitaet-die-grenze-zwischen-leicht-und">Abschnitt 2.5</a>) → <a href="modellierung.html#kap-modellierung">Kapitel 4</a> (vom Wunsch zum Modell) → <a href="lp.html#kap-lp">Kapitel 5</a> (LP, Schattenpreise) → <a href="milp.html#kap-milp">Kapitel 6</a> (Ja/Nein-Entscheidungen) → <a href="cpsat.html#kap-cpsat">Kapitel 7</a> (CP-SAT, Scheduling) → Projekt P1 (Vertretungsplaner) oder P2 (Schichtplanung). Das ist der kürzeste Weg zu einem einsetzbaren Dienstplan-Optimierer.</p></div><div class="karte karte-pfad"><h3>Pfad C — Logistik und Tourenplanung (ca. 25 Stunden)</h3><p><a href="einfuehrung.html#kap-einfuehrung">Kapitel 1</a> → <a href="fundament.html#kap-fundament">Kapitel 2</a> (bis <a href="fundament.html#sec:fundament-der-zulaessige-loesungsraum-und-das-polyeder">Abschnitt 2.4</a>) → <a href="lp.html#kap-lp">Kapitel 5</a> → <a href="milp.html#kap-milp">Kapitel 6</a> → <a href="graphen.html#kap-graphen">Kapitel 8</a> (Graphen, VRP) → Projekt P3 (Liefertouren) oder P4 (Lagernetzwerk).</p></div><div class="karte karte-pfad"><h3>Pfad D — Quantitative Finance (ca. 30 Stunden)</h3><p><a href="einfuehrung.html#kap-einfuehrung">Kapitel 1</a> → <a href="fundament.html#kap-fundament">Kapitel 2</a> → <a href="qp-nlp.html#kap-qp-nlp">Kapitel 11</a> (QP, KKT) → <a href="finanzdaten.html#kap-finanzdaten">Kapitel 18</a> (Daten, Shrinkage) → <a href="markowitz.html#kap-markowitz">Kapitel 19</a> (Markowitz) → <a href="cvar.html#kap-cvar">Kapitel 20</a> (CVaR) → <a href="handelsmaschine.html#kap-handelsmaschine">Kapitel 21</a> (Backtest) → Projekt P6 (Portfolio-Rebalancer) oder P7 (Risikoreport). Wichtig: Überspringen Sie <a href="finanzdaten.html#kap-finanzdaten">Kapitel 18</a> nicht. Wer direkt bei Markowitz einsteigt, optimiert Schätzrauschen und wundert sich über absurde Gewichte.</p></div><div class="karte karte-pfad"><h3>Pfad E — Ich habe morgen ein konkretes Problem (2–4 Stunden)</h3><p>Lesen Sie <a href="einfuehrung.html#sec:einfuehrung-historischer-kontext-und-evolution">Abschnitt 1.5</a> (die vier Bausteine) und <a href="modellierung.html#sec:modellierung-glossar">Abschnitt 4.6</a> (welcher Satz welcher Baustein ist), dann <a href="anhang-modellierungsmuster.html#anhang-modellierungsmuster">Anhang B</a> ([Modellierungsmuster](anhang-modellierungsmuster.html)) und suchen Sie dort das Muster, das zu Ihrem Problem passt. Von jedem Muster führt ein Verweis in das zuständige Kapitel. Wie die gewählte Bibliothek es schreibt, steht in <a href="anhang-spickzettel.html#anhang-spickzettel">Anhang D</a> ([Spickzettel](anhang-spickzettel.html)); wenn etwas nicht läuft, in <a href="anhang-fehlerdiagnose.html#anhang-fehlerdiagnose">Anhang C</a> ([Fehlerdiagnose](anhang-fehlerdiagnose.html)).</p></div></div>
 </section>
 <section class="kapitelgruppe"><h2>Teil I: Grundlagen des Operations Research</h2><div class="kartenraster"><a class="karte karte-kapitel" href="einfuehrung.html"><span class="karte-nummer">Kapitel 1</span><h3>Einführung in Operations Research — Vom Ursprung zur mathematischen Entscheidungsfindung</h3><p>Was Operations Research ist, warum Ausprobieren ab einer gewissen Problemgröße hoffnungslos wird, und aus welchen vier Bausteinen jedes Opti…</p><span class="karte-zeit">⏱ ca. 3,5 Stunden inklusive Übungen.</span></a><a class="karte karte-kapitel" href="fundament.html"><span class="karte-nummer">Kapitel 2</span><h3>Das mathematische Fundament — Vektoren, Matrizen, Konvexität</h3><p>Um die Sprache, in der Optimierungsmodelle aufgeschrieben werden, und um die eine Eigenschaft, die darüber entscheidet, ob ein Problem verlä…</p><span class="karte-zeit">⏱ ca. 5 Stunden.</span></a><a class="karte karte-kapitel" href="oekosystem.html"><span class="karte-nummer">Kapitel 3</span><h3>Das Python-Ökosystem für OR — Solver, Bindings und Modellierungsschichten</h3><p>Warum es für Optimierung in Python mehrere konkurrierende Bibliotheken gibt, was sie unterscheidet, und wie Sie in unter einer Minute die ri…</p><span class="karte-zeit">⏱ ca. 4 Stunden.</span></a><a class="karte karte-kapitel" href="modellierung.html"><span class="karte-nummer">Kapitel 4</span><h3>Vom Management-Wunsch zum Modell</h3><p>Um den Schritt, der vor jedem Solver kommt und über den kaum ein Lehrbuch spricht: aus einem Satz in einer Besprechung ein Modell zu machen.…</p><span class="karte-zeit">⏱ ca. 3 Stunden.</span></a></div></section><section class="kapitelgruppe"><h2>Teil II: Die Kernverfahren der deterministischen Optimierung</h2><div class="kartenraster"><a class="karte karte-kapitel" href="lp.html"><span class="karte-nummer">Kapitel 5</span><h3>Lineare Programmierung — Simplex, Dualität und Schattenpreise</h3><p>Um das Kernverfahren des Operations Research. Wir bauen den Simplex-Algorithmus selbst — nicht um ihn zu verwenden, sondern um zu verstehen,…</p><span class="karte-zeit">⏱ ca. 7 Stunden — das umfangreichste Kapitel von Teil II.</span></a><a class="karte karte-kapitel" href="milp.html"><span class="karte-nummer">Kapitel 6</span><h3>Gemischt-ganzzahlige Optimierung — Diskrete Entscheidungen und Branch-and-Bound</h3><p>Um Entscheidungen, die nicht teilbar sind: ganze Maschinen, Ja/Nein, „höchstens fünf davon“. Wir zeigen mit einem konkreten Gegenbeispiel, w…</p><span class="karte-zeit">⏱ ca. 6,5 Stunden.</span></a><a class="karte karte-kapitel" href="cpsat.html"><span class="karte-nummer">Kapitel 7</span><h3>Constraint Programming mit CP-SAT — Logik, Scheduling und Zuweisung</h3><p>Um ein völlig anderes Denkmodell: Statt algebraischer Ungleichungen arbeitet Constraint Programming mit Wertebereichen und logischen Regeln.…</p><span class="karte-zeit">⏱ ca. 6,5 Stunden.</span></a><a class="karte karte-kapitel" href="graphen.html"><span class="karte-nummer">Kapitel 8</span><h3>Graphen, Flüsse und Touren — Min-Cost-Flow, Matching und VRP</h3><p>Um Probleme, deren natürliche Sprache der Graph ist: Was fließt wohin? Wer wird wem zugeordnet? Welche Route fährt welches Fahrzeug?…</p><span class="karte-zeit">⏱ ca. 6 Stunden.</span></a><a class="karte karte-kapitel" href="metaheuristiken.html"><span class="karte-nummer">Kapitel 9</span><h3>Metaheuristiken — wenn der exakte Solver aussteigt</h3><p>Um den Fall, für den die bisherigen Kapitel keine Antwort haben: Das Problem ist zu groß, der Solver kommt im Zeitlimit nicht zu einem brauc…</p><span class="karte-zeit">⏱ ca. 5 Stunden.</span></a><a class="karte karte-kapitel" href="dekomposition.html"><span class="karte-nummer">Kapitel 10</span><h3>Spaltengenerierung — das Modell umbauen statt die Lösung raten</h3><p>Um die andere Antwort auf die Frage aus Kapitel 9: Was tun, wenn der Solver an der Größe scheitert? Statt die Lösung zu approximieren, formu…</p><span class="karte-zeit">⏱ ca. 3 Stunden.</span></a></div></section><section class="kapitelgruppe"><h2>Teil III: Nichtlinearität, Unsicherheit und mehrperiodige Dynamik</h2><div class="kartenraster"><a class="karte karte-kapitel" href="qp-nlp.html"><span class="karte-nummer">Kapitel 11</span><h3>Quadratische und nichtlineare Optimierung — KKT, Lagrange, Konvexität</h3><p>Risiko ist quadratisch. Sobald Varianz ins Spiel kommt, verlässt man die Welt der Polyeder. Dieses Kapitel liefert das mathematische Fundame…</p><span class="karte-zeit">⏱ ca. 6,5 Stunden.</span></a><a class="karte karte-kapitel" href="unsicherheit.html"><span class="karte-nummer">Kapitel 12</span><h3>Optimierung unter Unsicherheit — Monte-Carlo, Stochastik, Robustheit</h3><p>Bisher waren alle Parameter bekannt. In der Realität sind Nachfrage, Rendite und Fahrzeit Zufallsgrößen. Dieses Kapitel zeigt vier Wege, dam…</p><span class="karte-zeit">⏱ ca. 6,5 Stunden.</span></a><a class="karte karte-kapitel" href="dynamische-programmierung.html"><span class="karte-nummer">Kapitel 13</span><h3>Dynamische Programmierung — Die Bellman-Gleichung und Order-Execution</h3><p>Um Entscheidungsketten: Was heute klug ist, hängt davon ab, was morgen noch möglich sein wird. Die Bellman-Gleichung löst solche Probleme du…</p><span class="karte-zeit">⏱ ca. 5 Stunden.</span></a><a class="karte karte-kapitel" href="mehrziel.html"><span class="karte-nummer">Kapitel 14</span><h3>Mehrere Ziele — Pareto-Fronten statt Gewichte</h3><p>Um den Normalfall, den die bisherigen Kapitel umgangen haben: Es gibt nicht ein Ziel, sondern zwei, die gegeneinander stehen. Kosten und CO₂…</p><span class="karte-zeit">⏱ ca. 4 Stunden.</span></a><a class="karte karte-kapitel" href="prognose.html"><span class="karte-nummer">Kapitel 15</span><h3>Predict-then-Optimize — die bessere Prognose, die schlechtere Entscheidung</h3><p>Um die Naht zwischen zwei Welten, die in getrennten Abteilungen sitzen: Ein Modell prognostiziert, ein anderes entscheidet. Beide arbeiten s…</p><span class="karte-zeit">⏱ ca. 3,5 Stunden.</span></a></div></section><section class="kapitelgruppe"><h2>Teil IV: Anwendungen — Energiewirtschaft und Finanzmärkte</h2><div class="kartenraster"><a class="karte karte-kapitel" href="bruecke.html"><span class="karte-nummer">Kapitel 16</span><h3>Die Strukturbrücke — dieselbe Mathematik, zwei Welten</h3><p>Um den Nachweis, dass die Verfahren aus Teil II und III unverändert in der Finanzwelt funktionieren — und um die drei Stellen, an denen die …</p><span class="karte-zeit">⏱ ca. 2,5 Stunden.</span></a><a class="karte karte-kapitel" href="supplychain.html"><span class="karte-nummer">Kapitel 17</span><h3>Supply-Chain und Energieeinsatz unter Unsicherheit</h3><p>Um einen zusammenhängenden Industriefall, der die Werkzeuge aus Teil II und III zusammenführt: gemischt-ganzzahlige Entscheidungen, Szenarie…</p><span class="karte-zeit">⏱ ca. 4 Stunden.</span></a><a class="karte karte-kapitel" href="finanzdaten.html"><span class="karte-nummer">Kapitel 18</span><h3>Finanzdaten-Modellierung — Renditen, Kovarianz und Shrinkage</h3><p>Um die Eingangsdaten der Portfoliooptimierung — und darum, warum sie trügerisch sind. Wer historische Kovarianzen ungefiltert in einen Optim…</p><span class="karte-zeit">⏱ ca. 5 Stunden.</span></a><a class="karte karte-kapitel" href="markowitz.html"><span class="karte-nummer">Kapitel 19</span><h3>Die moderne Portfoliotheorie nach Markowitz</h3><p>Um das Modell, das 1952 die quantitative Finanzwirtschaft begründete — und um die Restriktionen, ohne die es in der Praxis unbrauchbar bleib…</p><span class="karte-zeit">⏱ ca. 6 Stunden.</span></a><a class="karte karte-kapitel" href="cvar.html"><span class="karte-nummer">Kapitel 20</span><h3>Tail-Risiko, CVaR und Transaktionskosten</h3><p>Um zwei Schwächen des Markowitz-Modells: Es unterschätzt Extremverluste und ignoriert die Kosten des Umschichtens. Beide lassen sich mit kon…</p><span class="karte-zeit">⏱ ca. 5 Stunden.</span></a><a class="karte karte-kapitel" href="handelsmaschine.html"><span class="karte-nummer">Kapitel 21</span><h3>Die vollständige quantitative Handelsmaschine</h3><p>Um das Zusammenführen von allem: Datenpipeline, Signal, Optimierung, Rebalancing, Kostenverbuchung und ein Backtest, der nicht lügt.…</p><span class="karte-zeit">⏱ ca. 6 Stunden.</span></a></div></section><section class="kapitelgruppe"><h2>Teil V: Praxis</h2><div class="kartenraster"><a class="karte karte-kapitel" href="praxisfallen.html"><span class="karte-nummer">Kapitel 22</span><h3>Praxisfallen und der Weg zum produktiven Einsatz</h3><p>Um alles, was zwischen einem funktionierenden Notebook und einem System steht, das Menschen tatsächlich benutzen.…</p><span class="karte-zeit">⏱ ca. 4 Stunden.</span></a><a class="karte karte-kapitel" href="testing.html"><span class="karte-nummer">Kapitel 23</span><h3>Testen, Messen, Ausliefern</h3><p>Um die drei Fragen, die zwischen einem funktionierenden Modell und einem System stehen, auf das sich jemand verlässt: Woher weiß ich, dass e…</p><span class="karte-zeit">⏱ ca. 5 Stunden.</span></a></div></section>
 
diff --git a/OR_HTML_04/lp.html b/OR_HTML_04/lp.html
index aa16f60..11dda27 100644
--- a/OR_HTML_04/lp.html
+++ b/OR_HTML_04/lp.html
@@ -94,10 +94,10 @@
 </header>
 <div class="site-body">
   <div class="sidebar-overlay" id="sidebar-overlay" hidden></div>
-  <nav class="sidebar" id="sidebar" aria-label="Kapitelnavigation"><div class="sidebar-inhalt"><details class="sidebar-gruppe"><summary>Einstieg</summary><ul><li data-kapitel="vorwort.html"><a href="vorwort.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Vorwort & Lesehilfe</span></a></li><li data-kapitel="notation.html"><a href="notation.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Notation & Abkürzungen</span></a></li></ul></details><details class="sidebar-gruppe"><summary>Teil I: Grundlagen des Operations Research</summary><ul><li data-kapitel="einfuehrung.html"><a href="einfuehrung.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 1: Einführung in Operations Research — Vom Ursprung zur mathematischen Entscheidungsfindung</span></a></li><li data-kapitel="fundament.html"><a href="fundament.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 2: Das mathematische Fundament — Vektoren, Matrizen, Konvexität</span></a></li><li data-kapitel="oekosystem.html"><a href="oekosystem.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 3: Das Python-Ökosystem für OR — Solver, Bindings und Modellierungsschichten</span></a></li><li data-kapitel="modellierung.html"><a href="modellierung.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 4: Vom Management-Wunsch zum Modell</span></a></li></ul></details><details class="sidebar-gruppe" open><summary>Teil II: Die Kernverfahren der deterministischen Optimierung</summary><ul><li data-kapitel="lp.html" class="aktiv"><a href="lp.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 5: Lineare Programmierung — Simplex, Dualität und Schattenpreise</span></a></li><li data-kapitel="milp.html"><a href="milp.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 6: Gemischt-ganzzahlige Optimierung — Diskrete Entscheidungen und Branch-and-Bound</span></a></li><li data-kapitel="cpsat.html"><a href="cpsat.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 7: Constraint Programming mit CP-SAT — Logik, Scheduling und Zuweisung</span></a></li><li data-kapitel="graphen.html"><a href="graphen.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 8: Graphen, Flüsse und Touren — Min-Cost-Flow, Matching und VRP</span></a></li><li data-kapitel="metaheuristiken.html"><a href="metaheuristiken.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 9: Metaheuristiken — wenn der exakte Solver aussteigt</span></a></li><li data-kapitel="dekomposition.html"><a href="dekomposition.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 10: Spaltengenerierung — das Modell umbauen statt die Lösung raten</span></a></li></ul></details><details class="sidebar-gruppe"><summary>Teil III: Nichtlinearität, Unsicherheit und mehrperiodige Dynamik</summary><ul><li data-kapitel="qp-nlp.html"><a href="qp-nlp.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 11: Quadratische und nichtlineare Optimierung — KKT, Lagrange, Konvexität</span></a></li><li data-kapitel="unsicherheit.html"><a href="unsicherheit.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 12: Optimierung unter Unsicherheit — Monte-Carlo, Stochastik, Robustheit</span></a></li><li data-kapitel="dynamische-programmierung.html"><a href="dynamische-programmierung.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 13: Dynamische Programmierung — Die Bellman-Gleichung und Order-Execution</span></a></li><li data-kapitel="mehrziel.html"><a href="mehrziel.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 14: Mehrere Ziele — Pareto-Fronten statt Gewichte</span></a></li><li data-kapitel="prognose.html"><a href="prognose.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 15: Predict-then-Optimize — die bessere Prognose, die schlechtere Entscheidung</span></a></li></ul></details><details class="sidebar-gruppe"><summary>Teil IV: Anwendungen — Energiewirtschaft und Finanzmärkte</summary><ul><li data-kapitel="bruecke.html"><a href="bruecke.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 16: Die Strukturbrücke — dieselbe Mathematik, zwei Welten</span></a></li><li data-kapitel="supplychain.html"><a href="supplychain.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 17: Supply-Chain und Energieeinsatz unter Unsicherheit</span></a></li><li data-kapitel="finanzdaten.html"><a href="finanzdaten.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 18: Finanzdaten-Modellierung — Renditen, Kovarianz und Shrinkage</span></a></li><li data-kapitel="markowitz.html"><a href="markowitz.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 19: Die moderne Portfoliotheorie nach Markowitz</span></a></li><li data-kapitel="cvar.html"><a href="cvar.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 20: Tail-Risiko, CVaR und Transaktionskosten</span></a></li><li data-kapitel="handelsmaschine.html"><a href="handelsmaschine.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 21: Die vollständige quantitative Handelsmaschine</span></a></li></ul></details><details class="sidebar-gruppe"><summary>Teil V: Praxis</summary><ul><li data-kapitel="praxisfallen.html"><a href="praxisfallen.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 22: Praxisfallen und der Weg zum produktiven Einsatz</span></a></li><li data-kapitel="testing.html"><a href="testing.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 23: Testen, Messen, Ausliefern</span></a></li><li data-kapitel="projektwerkstatt.html"><a href="projektwerkstatt.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Projektwerkstatt</span></a></li></ul></details><details class="sidebar-gruppe"><summary>Anhänge</summary><ul><li data-kapitel="anhang-loesungen.html"><a href="anhang-loesungen.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Anhang A: Lösungen zu allen Übungsaufgaben</span></a></li><li data-kapitel="anhang-modellierungsmuster.html"><a href="anhang-modellierungsmuster.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Anhang B: Katalog der Modellierungsmuster</span></a></li><li data-kapitel="anhang-fehlerdiagnose.html"><a href="anhang-fehlerdiagnose.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Anhang C: Fehlerdiagnose-Handbuch</span></a></li><li data-kapitel="anhang-spickzettel.html"><a href="anhang-spickzettel.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Anhang D: Spickzettel der Solver</span></a></li><li data-kapitel="anhang-glossar-literatur.html"><a href="anhang-glossar-literatur.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Anhang E: Glossar und Literatur</span></a></li></ul></details><ul class="sidebar-extra"><li><a href="programme.html"><svg class="icon" aria-hidden="true"><use href="#icon-book"></use></svg> Beispielprogramme</a></li><li><a href="stichwortverzeichnis.html"><svg class="icon" aria-hidden="true"><use href="#icon-search"></use></svg> Stichwortverzeichnis</a></li><li><a href="gesamtdokument.html"><svg class="icon" aria-hidden="true"><use href="#icon-external-link"></use></svg> Gesamtdokument (eine Seite)</a></li><li><a href="Operations_Research_mit_Python_Version_04.pdf" download><svg class="icon" aria-hidden="true"><use href="#icon-download"></use></svg> Download als PDF</a></li></ul></div></nav>
+  <nav class="sidebar" id="sidebar" aria-label="Kapitelnavigation"><div class="sidebar-inhalt"><details class="sidebar-gruppe"><summary>Einstieg</summary><ul><li data-kapitel="vorwort.html"><a href="vorwort.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Vorwort & Lesehilfe</span></a></li><li data-kapitel="notation.html"><a href="notation.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Notation & Abkürzungen</span></a></li></ul></details><details class="sidebar-gruppe"><summary>Teil I: Grundlagen des Operations Research</summary><ul><li data-kapitel="einfuehrung.html"><a href="einfuehrung.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 1: Einführung in Operations Research — Vom Ursprung zur mathematischen Entscheidungsfindung</span></a></li><li data-kapitel="fundament.html"><a href="fundament.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 2: Das mathematische Fundament — Vektoren, Matrizen, Konvexität</span></a></li><li data-kapitel="oekosystem.html"><a href="oekosystem.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 3: Das Python-Ökosystem für OR — Solver, Bindings und Modellierungsschichten</span></a></li><li data-kapitel="modellierung.html"><a href="modellierung.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 4: Vom Management-Wunsch zum Modell</span></a></li><li data-kapitel="synthese-grundlagen.html"><a href="synthese-grundlagen.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Synthese Teil I</span></a></li></ul></details><details class="sidebar-gruppe" open><summary>Teil II: Die Kernverfahren der deterministischen Optimierung</summary><ul><li data-kapitel="lp.html" class="aktiv"><a href="lp.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 5: Lineare Programmierung — Simplex, Dualität und Schattenpreise</span></a></li><li data-kapitel="milp.html"><a href="milp.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 6: Gemischt-ganzzahlige Optimierung — Diskrete Entscheidungen und Branch-and-Bound</span></a></li><li data-kapitel="cpsat.html"><a href="cpsat.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 7: Constraint Programming mit CP-SAT — Logik, Scheduling und Zuweisung</span></a></li><li data-kapitel="graphen.html"><a href="graphen.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 8: Graphen, Flüsse und Touren — Min-Cost-Flow, Matching und VRP</span></a></li><li data-kapitel="metaheuristiken.html"><a href="metaheuristiken.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 9: Metaheuristiken — wenn der exakte Solver aussteigt</span></a></li><li data-kapitel="dekomposition.html"><a href="dekomposition.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 10: Spaltengenerierung — das Modell umbauen statt die Lösung raten</span></a></li><li data-kapitel="synthese-kernverfahren.html"><a href="synthese-kernverfahren.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Synthese Teil II</span></a></li></ul></details><details class="sidebar-gruppe"><summary>Teil III: Nichtlinearität, Unsicherheit und mehrperiodige Dynamik</summary><ul><li data-kapitel="qp-nlp.html"><a href="qp-nlp.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 11: Quadratische und nichtlineare Optimierung — KKT, Lagrange, Konvexität</span></a></li><li data-kapitel="unsicherheit.html"><a href="unsicherheit.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 12: Optimierung unter Unsicherheit — Monte-Carlo, Stochastik, Robustheit</span></a></li><li data-kapitel="dynamische-programmierung.html"><a href="dynamische-programmierung.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 13: Dynamische Programmierung — Die Bellman-Gleichung und Order-Execution</span></a></li><li data-kapitel="mehrziel.html"><a href="mehrziel.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 14: Mehrere Ziele — Pareto-Fronten statt Gewichte</span></a></li><li data-kapitel="prognose.html"><a href="prognose.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 15: Predict-then-Optimize — die bessere Prognose, die schlechtere Entscheidung</span></a></li><li data-kapitel="synthese-nichtlinear.html"><a href="synthese-nichtlinear.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Synthese Teil III</span></a></li></ul></details><details class="sidebar-gruppe"><summary>Teil IV: Anwendungen — Energiewirtschaft und Finanzmärkte</summary><ul><li data-kapitel="bruecke.html"><a href="bruecke.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 16: Die Strukturbrücke — dieselbe Mathematik, zwei Welten</span></a></li><li data-kapitel="supplychain.html"><a href="supplychain.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 17: Supply-Chain und Energieeinsatz unter Unsicherheit</span></a></li><li data-kapitel="finanzdaten.html"><a href="finanzdaten.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 18: Finanzdaten-Modellierung — Renditen, Kovarianz und Shrinkage</span></a></li><li data-kapitel="markowitz.html"><a href="markowitz.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 19: Die moderne Portfoliotheorie nach Markowitz</span></a></li><li data-kapitel="cvar.html"><a href="cvar.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 20: Tail-Risiko, CVaR und Transaktionskosten</span></a></li><li data-kapitel="handelsmaschine.html"><a href="handelsmaschine.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 21: Die vollständige quantitative Handelsmaschine</span></a></li><li data-kapitel="synthese-anwendungen.html"><a href="synthese-anwendungen.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Synthese Teil IV</span></a></li></ul></details><details class="sidebar-gruppe"><summary>Teil V: Praxis</summary><ul><li data-kapitel="praxisfallen.html"><a href="praxisfallen.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 22: Praxisfallen und der Weg zum produktiven Einsatz</span></a></li><li data-kapitel="testing.html"><a href="testing.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 23: Testen, Messen, Ausliefern</span></a></li><li data-kapitel="synthese-praxis.html"><a href="synthese-praxis.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Synthese Teil V</span></a></li><li data-kapitel="projektwerkstatt.html"><a href="projektwerkstatt.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Projektwerkstatt</span></a></li></ul></details><details class="sidebar-gruppe"><summary>Anhänge</summary><ul><li data-kapitel="anhang-loesungen.html"><a href="anhang-loesungen.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Anhang A: Lösungen zu allen Übungsaufgaben</span></a></li><li data-kapitel="anhang-modellierungsmuster.html"><a href="anhang-modellierungsmuster.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Anhang B: Katalog der Modellierungsmuster</span></a></li><li data-kapitel="anhang-fehlerdiagnose.html"><a href="anhang-fehlerdiagnose.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Anhang C: Fehlerdiagnose-Handbuch</span></a></li><li data-kapitel="anhang-spickzettel.html"><a href="anhang-spickzettel.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Anhang D: Spickzettel der Solver</span></a></li><li data-kapitel="anhang-glossar-literatur.html"><a href="anhang-glossar-literatur.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Anhang E: Glossar und Literatur</span></a></li></ul></details><ul class="sidebar-extra"><li><a href="programme.html"><svg class="icon" aria-hidden="true"><use href="#icon-book"></use></svg> Beispielprogramme</a></li><li><a href="stichwortverzeichnis.html"><svg class="icon" aria-hidden="true"><use href="#icon-search"></use></svg> Stichwortverzeichnis</a></li><li><a href="gesamtdokument.html"><svg class="icon" aria-hidden="true"><use href="#icon-external-link"></use></svg> Gesamtdokument (eine Seite)</a></li><li><a href="Operations_Research_mit_Python_Version_04.pdf" download><svg class="icon" aria-hidden="true"><use href="#icon-download"></use></svg> Download als PDF</a></li></ul></div></nav>
   <main class="content">
     <nav class="breadcrumb" aria-label="Breadcrumb"><a href="index.html">Start</a> › <span>Teil II</span> › <span>Kapitel 5: Lineare Programmierung — Simplex, Dualität und Schattenpreise</span></nav>
-    <nav class="prev-next"><a class="prev-next-knopf prev-next-prev" href="modellierung.html"><svg class="icon" aria-hidden="true"><use href="#icon-chevron-left"></use></svg><span><small>Zurück</small>Kapitel 4: Vom Management-Wunsch zum Modell</span></a><a class="prev-next-knopf prev-next-next" href="milp.html"><span><small>Weiter</small>Kapitel 6: Gemischt-ganzzahlige Optimierung — Diskrete Entscheidungen und Branch-and-Bound</span><svg class="icon" aria-hidden="true"><use href="#icon-chevron-right"></use></svg></a></nav>
+    <nav class="prev-next"><a class="prev-next-knopf prev-next-prev" href="synthese-grundlagen.html"><svg class="icon" aria-hidden="true"><use href="#icon-chevron-left"></use></svg><span><small>Zurück</small>Synthese Teil I</span></a><a class="prev-next-knopf prev-next-next" href="milp.html"><span><small>Weiter</small>Kapitel 6: Gemischt-ganzzahlige Optimierung — Diskrete Entscheidungen und Branch-and-Bound</span><svg class="icon" aria-hidden="true"><use href="#icon-chevron-right"></use></svg></a></nav>
     <article>
     <h1 id="teil-kernverfahren">Teil II: Die Kernverfahren der deterministischen Optimierung</h1>
 <p>Die nächsten vier Kapitel behandeln Probleme, bei denen <strong>alle Daten bekannt</strong> sind: Kosten, Kapazitäten, Zeiten stehen fest. Das klingt nach einer starken Vereinfachung, deckt aber den größten Teil der betrieblichen Planung ab — und ist die Grundlage für alles Weitere.</p>
@@ -1121,7 +1121,7 @@ Pruefung: komplementaerer Schlupf fuer alle Ressourcen erfuellt.
 </blockquote>
 <blockquote>
 <p><strong>⚠️ Grenzen der Schattenpreis-Aussage</strong></p>
-<p>Der Schattenpreis gilt nur <strong>lokal</strong>, in einem begrenzten Intervall um die aktuelle Kapazität. Kauft man 200 Prüfstunden zu, wird irgendwann eine andere Ressource zum Engpass, und der Schattenpreis springt auf einen neuen Wert (oder auf null). Wer große Kapazitätsänderungen bewerten will, muss das Modell <strong>neu rechnen</strong> — nicht linear hochrechnen. Übung 4.6 macht diesen Effekt sichtbar.</p>
+<p>Der Schattenpreis gilt nur <strong>lokal</strong>, in einem begrenzten Intervall um die aktuelle Kapazität. Kauft man 200 Prüfstunden zu, wird irgendwann eine andere Ressource zum Engpass, und der Schattenpreis springt auf einen neuen Wert (oder auf null). Wer große Kapazitätsänderungen bewerten will, muss das Modell <strong>neu rechnen</strong> — nicht linear hochrechnen. Die Aufgabe <em>Gültigkeitsbereich des Schattenpreises</em> (<a href="#sec:lp-uebungsaufgaben">Abschnitt 5.10</a>) macht diesen Effekt sichtbar.</p>
 </blockquote>
 <hr />
 <h2 id="sec:lp-entartung">5.9 Wann Schattenpreise lügen: Entartung und Toleranzen</h2>
@@ -1532,7 +1532,7 @@ brauchbare Aussage. Ein erfundener Einzelwert ist es nicht.</code></pre>
 <h2 id="sec:lp-denkfehler">5.11 Finde den Denkfehler</h2>
 <div class="card card-denkfehler">
 <blockquote>
-<p><strong>🐛 Finde den Denkfehler 4.1: Die 380 000-Euro-Maschine</strong></p>
+<p><strong>🐛 Finde den Denkfehler: Die 380 000-Euro-Maschine</strong></p>
 <p>Ein Werksleiter lässt die Engpässe seiner Fertigung analysieren. Das Skript liefert für den Lackierofen einen Schattenpreis von <strong>50 €/Stunde</strong>. Er rechnet:</p>
 <blockquote>
 <p><em>„Ein zweiter Lackierofen bringt 2 000 zusätzliche Stunden im Jahr. Bei 50 € &gt; je Stunde sind das 100 000 € Deckungsbeitrag pro Jahr. Die Maschine kostet 380 000 € &gt; und amortisiert sich in 3,8 Jahren. Wir kaufen.“</em></p>
@@ -1556,7 +1556,7 @@ brauchbare Aussage. Ein erfundener Einzelwert ist es nicht.</code></pre>
 <h2 id="sec:lp-quiz">5.12 Micro-Quiz</h2>
 <div class="card card-quiz">
 <blockquote>
-<p><strong>❓ Micro-Quiz 4: Drei Fragen zum Selbstcheck</strong></p>
+<p><strong>❓ Micro-Quiz 5: Drei Fragen zum Selbstcheck</strong></p>
 <p>Genau eine Antwort ist jeweils richtig. Auflösung in <a href="anhang-loesungen.html#quiz-loesung-lp">Anhang A</a>.</p>
 <p><strong>1. Eine Nebenbedingung hat den Schlupf <span class="math inline">s_i = 12</span> und den Schattenpreis <span class="math inline">y_i = 0</span>. Was folgt daraus?</strong> (a) Der Solver hat einen Fehler gemacht — bei positivem Schlupf muss der Dualwert ebenfalls positiv sein. (b) Von dieser Ressource sind 12 Einheiten übrig; sie ist kein Engpass, und Zukauf bringt nichts. Das ist genau der komplementäre Schlupf. (c) Die Ressource ist voll ausgelastet, wird aber nicht benötigt.</p>
 <p><strong>2. Ihr Modell hat 5 Variablen. In der optimalen Ecke sind 7 Nebenbedingungen aktiv. Was bedeutet das für Ihren Bericht ans Management?</strong> (a) Nichts Besonderes — mehr aktive Bedingungen heißt nur, dass das Modell gut ausgelastet ist. (b) Das Modell ist entartet: Der Plan ist eindeutig, die Schattenpreise sind es nicht. Statt Einzelwerten gehören Spannen in den Bericht. (c) Das Modell ist unlösbar, weil mehr Bedingungen als Variablen aktiv sind.</p>
@@ -1588,7 +1588,7 @@ brauchbare Aussage. Ein erfundener Einzelwert ist es nicht.</code></pre>
 
     </article>
     <button type="button" class="fortschritt-knopf" data-kapitel="lp.html"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg> <span>Als gelesen markieren</span></button>
-    <nav class="prev-next"><a class="prev-next-knopf prev-next-prev" href="modellierung.html"><svg class="icon" aria-hidden="true"><use href="#icon-chevron-left"></use></svg><span><small>Zurück</small>Kapitel 4: Vom Management-Wunsch zum Modell</span></a><a class="prev-next-knopf prev-next-next" href="milp.html"><span><small>Weiter</small>Kapitel 6: Gemischt-ganzzahlige Optimierung — Diskrete Entscheidungen und Branch-and-Bound</span><svg class="icon" aria-hidden="true"><use href="#icon-chevron-right"></use></svg></a></nav>
+    <nav class="prev-next"><a class="prev-next-knopf prev-next-prev" href="synthese-grundlagen.html"><svg class="icon" aria-hidden="true"><use href="#icon-chevron-left"></use></svg><span><small>Zurück</small>Synthese Teil I</span></a><a class="prev-next-knopf prev-next-next" href="milp.html"><span><small>Weiter</small>Kapitel 6: Gemischt-ganzzahlige Optimierung — Diskrete Entscheidungen und Branch-and-Bound</span><svg class="icon" aria-hidden="true"><use href="#icon-chevron-right"></use></svg></a></nav>
   </main>
 </div>
 <footer class="site-footer">
diff --git a/OR_HTML_04/markowitz.html b/OR_HTML_04/markowitz.html
index 58971a0..6a937c3 100644
--- a/OR_HTML_04/markowitz.html
+++ b/OR_HTML_04/markowitz.html
@@ -94,7 +94,7 @@
 </header>
 <div class="site-body">
   <div class="sidebar-overlay" id="sidebar-overlay" hidden></div>
-  <nav class="sidebar" id="sidebar" aria-label="Kapitelnavigation"><div class="sidebar-inhalt"><details class="sidebar-gruppe"><summary>Einstieg</summary><ul><li data-kapitel="vorwort.html"><a href="vorwort.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Vorwort & Lesehilfe</span></a></li><li data-kapitel="notation.html"><a href="notation.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Notation & Abkürzungen</span></a></li></ul></details><details class="sidebar-gruppe"><summary>Teil I: Grundlagen des Operations Research</summary><ul><li data-kapitel="einfuehrung.html"><a href="einfuehrung.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 1: Einführung in Operations Research — Vom Ursprung zur mathematischen Entscheidungsfindung</span></a></li><li data-kapitel="fundament.html"><a href="fundament.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 2: Das mathematische Fundament — Vektoren, Matrizen, Konvexität</span></a></li><li data-kapitel="oekosystem.html"><a href="oekosystem.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 3: Das Python-Ökosystem für OR — Solver, Bindings und Modellierungsschichten</span></a></li><li data-kapitel="modellierung.html"><a href="modellierung.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 4: Vom Management-Wunsch zum Modell</span></a></li></ul></details><details class="sidebar-gruppe"><summary>Teil II: Die Kernverfahren der deterministischen Optimierung</summary><ul><li data-kapitel="lp.html"><a href="lp.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 5: Lineare Programmierung — Simplex, Dualität und Schattenpreise</span></a></li><li data-kapitel="milp.html"><a href="milp.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 6: Gemischt-ganzzahlige Optimierung — Diskrete Entscheidungen und Branch-and-Bound</span></a></li><li data-kapitel="cpsat.html"><a href="cpsat.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 7: Constraint Programming mit CP-SAT — Logik, Scheduling und Zuweisung</span></a></li><li data-kapitel="graphen.html"><a href="graphen.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 8: Graphen, Flüsse und Touren — Min-Cost-Flow, Matching und VRP</span></a></li><li data-kapitel="metaheuristiken.html"><a href="metaheuristiken.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 9: Metaheuristiken — wenn der exakte Solver aussteigt</span></a></li><li data-kapitel="dekomposition.html"><a href="dekomposition.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 10: Spaltengenerierung — das Modell umbauen statt die Lösung raten</span></a></li></ul></details><details class="sidebar-gruppe"><summary>Teil III: Nichtlinearität, Unsicherheit und mehrperiodige Dynamik</summary><ul><li data-kapitel="qp-nlp.html"><a href="qp-nlp.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 11: Quadratische und nichtlineare Optimierung — KKT, Lagrange, Konvexität</span></a></li><li data-kapitel="unsicherheit.html"><a href="unsicherheit.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 12: Optimierung unter Unsicherheit — Monte-Carlo, Stochastik, Robustheit</span></a></li><li data-kapitel="dynamische-programmierung.html"><a href="dynamische-programmierung.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 13: Dynamische Programmierung — Die Bellman-Gleichung und Order-Execution</span></a></li><li data-kapitel="mehrziel.html"><a href="mehrziel.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 14: Mehrere Ziele — Pareto-Fronten statt Gewichte</span></a></li><li data-kapitel="prognose.html"><a href="prognose.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 15: Predict-then-Optimize — die bessere Prognose, die schlechtere Entscheidung</span></a></li></ul></details><details class="sidebar-gruppe" open><summary>Teil IV: Anwendungen — Energiewirtschaft und Finanzmärkte</summary><ul><li data-kapitel="bruecke.html"><a href="bruecke.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 16: Die Strukturbrücke — dieselbe Mathematik, zwei Welten</span></a></li><li data-kapitel="supplychain.html"><a href="supplychain.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 17: Supply-Chain und Energieeinsatz unter Unsicherheit</span></a></li><li data-kapitel="finanzdaten.html"><a href="finanzdaten.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 18: Finanzdaten-Modellierung — Renditen, Kovarianz und Shrinkage</span></a></li><li data-kapitel="markowitz.html" class="aktiv"><a href="markowitz.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 19: Die moderne Portfoliotheorie nach Markowitz</span></a></li><li data-kapitel="cvar.html"><a href="cvar.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 20: Tail-Risiko, CVaR und Transaktionskosten</span></a></li><li data-kapitel="handelsmaschine.html"><a href="handelsmaschine.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 21: Die vollständige quantitative Handelsmaschine</span></a></li></ul></details><details class="sidebar-gruppe"><summary>Teil V: Praxis</summary><ul><li data-kapitel="praxisfallen.html"><a href="praxisfallen.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 22: Praxisfallen und der Weg zum produktiven Einsatz</span></a></li><li data-kapitel="testing.html"><a href="testing.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 23: Testen, Messen, Ausliefern</span></a></li><li data-kapitel="projektwerkstatt.html"><a href="projektwerkstatt.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Projektwerkstatt</span></a></li></ul></details><details class="sidebar-gruppe"><summary>Anhänge</summary><ul><li data-kapitel="anhang-loesungen.html"><a href="anhang-loesungen.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Anhang A: Lösungen zu allen Übungsaufgaben</span></a></li><li data-kapitel="anhang-modellierungsmuster.html"><a href="anhang-modellierungsmuster.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Anhang B: Katalog der Modellierungsmuster</span></a></li><li data-kapitel="anhang-fehlerdiagnose.html"><a href="anhang-fehlerdiagnose.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Anhang C: Fehlerdiagnose-Handbuch</span></a></li><li data-kapitel="anhang-spickzettel.html"><a href="anhang-spickzettel.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Anhang D: Spickzettel der Solver</span></a></li><li data-kapitel="anhang-glossar-literatur.html"><a href="anhang-glossar-literatur.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Anhang E: Glossar und Literatur</span></a></li></ul></details><ul class="sidebar-extra"><li><a href="programme.html"><svg class="icon" aria-hidden="true"><use href="#icon-book"></use></svg> Beispielprogramme</a></li><li><a href="stichwortverzeichnis.html"><svg class="icon" aria-hidden="true"><use href="#icon-search"></use></svg> Stichwortverzeichnis</a></li><li><a href="gesamtdokument.html"><svg class="icon" aria-hidden="true"><use href="#icon-external-link"></use></svg> Gesamtdokument (eine Seite)</a></li><li><a href="Operations_Research_mit_Python_Version_04.pdf" download><svg class="icon" aria-hidden="true"><use href="#icon-download"></use></svg> Download als PDF</a></li></ul></div></nav>
+  <nav class="sidebar" id="sidebar" aria-label="Kapitelnavigation"><div class="sidebar-inhalt"><details class="sidebar-gruppe"><summary>Einstieg</summary><ul><li data-kapitel="vorwort.html"><a href="vorwort.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Vorwort & Lesehilfe</span></a></li><li data-kapitel="notation.html"><a href="notation.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Notation & Abkürzungen</span></a></li></ul></details><details class="sidebar-gruppe"><summary>Teil I: Grundlagen des Operations Research</summary><ul><li data-kapitel="einfuehrung.html"><a href="einfuehrung.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 1: Einführung in Operations Research — Vom Ursprung zur mathematischen Entscheidungsfindung</span></a></li><li data-kapitel="fundament.html"><a href="fundament.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 2: Das mathematische Fundament — Vektoren, Matrizen, Konvexität</span></a></li><li data-kapitel="oekosystem.html"><a href="oekosystem.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 3: Das Python-Ökosystem für OR — Solver, Bindings und Modellierungsschichten</span></a></li><li data-kapitel="modellierung.html"><a href="modellierung.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 4: Vom Management-Wunsch zum Modell</span></a></li><li data-kapitel="synthese-grundlagen.html"><a href="synthese-grundlagen.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Synthese Teil I</span></a></li></ul></details><details class="sidebar-gruppe"><summary>Teil II: Die Kernverfahren der deterministischen Optimierung</summary><ul><li data-kapitel="lp.html"><a href="lp.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 5: Lineare Programmierung — Simplex, Dualität und Schattenpreise</span></a></li><li data-kapitel="milp.html"><a href="milp.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 6: Gemischt-ganzzahlige Optimierung — Diskrete Entscheidungen und Branch-and-Bound</span></a></li><li data-kapitel="cpsat.html"><a href="cpsat.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 7: Constraint Programming mit CP-SAT — Logik, Scheduling und Zuweisung</span></a></li><li data-kapitel="graphen.html"><a href="graphen.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 8: Graphen, Flüsse und Touren — Min-Cost-Flow, Matching und VRP</span></a></li><li data-kapitel="metaheuristiken.html"><a href="metaheuristiken.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 9: Metaheuristiken — wenn der exakte Solver aussteigt</span></a></li><li data-kapitel="dekomposition.html"><a href="dekomposition.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 10: Spaltengenerierung — das Modell umbauen statt die Lösung raten</span></a></li><li data-kapitel="synthese-kernverfahren.html"><a href="synthese-kernverfahren.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Synthese Teil II</span></a></li></ul></details><details class="sidebar-gruppe"><summary>Teil III: Nichtlinearität, Unsicherheit und mehrperiodige Dynamik</summary><ul><li data-kapitel="qp-nlp.html"><a href="qp-nlp.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 11: Quadratische und nichtlineare Optimierung — KKT, Lagrange, Konvexität</span></a></li><li data-kapitel="unsicherheit.html"><a href="unsicherheit.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 12: Optimierung unter Unsicherheit — Monte-Carlo, Stochastik, Robustheit</span></a></li><li data-kapitel="dynamische-programmierung.html"><a href="dynamische-programmierung.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 13: Dynamische Programmierung — Die Bellman-Gleichung und Order-Execution</span></a></li><li data-kapitel="mehrziel.html"><a href="mehrziel.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 14: Mehrere Ziele — Pareto-Fronten statt Gewichte</span></a></li><li data-kapitel="prognose.html"><a href="prognose.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 15: Predict-then-Optimize — die bessere Prognose, die schlechtere Entscheidung</span></a></li><li data-kapitel="synthese-nichtlinear.html"><a href="synthese-nichtlinear.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Synthese Teil III</span></a></li></ul></details><details class="sidebar-gruppe" open><summary>Teil IV: Anwendungen — Energiewirtschaft und Finanzmärkte</summary><ul><li data-kapitel="bruecke.html"><a href="bruecke.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 16: Die Strukturbrücke — dieselbe Mathematik, zwei Welten</span></a></li><li data-kapitel="supplychain.html"><a href="supplychain.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 17: Supply-Chain und Energieeinsatz unter Unsicherheit</span></a></li><li data-kapitel="finanzdaten.html"><a href="finanzdaten.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 18: Finanzdaten-Modellierung — Renditen, Kovarianz und Shrinkage</span></a></li><li data-kapitel="markowitz.html" class="aktiv"><a href="markowitz.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 19: Die moderne Portfoliotheorie nach Markowitz</span></a></li><li data-kapitel="cvar.html"><a href="cvar.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 20: Tail-Risiko, CVaR und Transaktionskosten</span></a></li><li data-kapitel="handelsmaschine.html"><a href="handelsmaschine.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 21: Die vollständige quantitative Handelsmaschine</span></a></li><li data-kapitel="synthese-anwendungen.html"><a href="synthese-anwendungen.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Synthese Teil IV</span></a></li></ul></details><details class="sidebar-gruppe"><summary>Teil V: Praxis</summary><ul><li data-kapitel="praxisfallen.html"><a href="praxisfallen.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 22: Praxisfallen und der Weg zum produktiven Einsatz</span></a></li><li data-kapitel="testing.html"><a href="testing.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 23: Testen, Messen, Ausliefern</span></a></li><li data-kapitel="synthese-praxis.html"><a href="synthese-praxis.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Synthese Teil V</span></a></li><li data-kapitel="projektwerkstatt.html"><a href="projektwerkstatt.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Projektwerkstatt</span></a></li></ul></details><details class="sidebar-gruppe"><summary>Anhänge</summary><ul><li data-kapitel="anhang-loesungen.html"><a href="anhang-loesungen.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Anhang A: Lösungen zu allen Übungsaufgaben</span></a></li><li data-kapitel="anhang-modellierungsmuster.html"><a href="anhang-modellierungsmuster.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Anhang B: Katalog der Modellierungsmuster</span></a></li><li data-kapitel="anhang-fehlerdiagnose.html"><a href="anhang-fehlerdiagnose.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Anhang C: Fehlerdiagnose-Handbuch</span></a></li><li data-kapitel="anhang-spickzettel.html"><a href="anhang-spickzettel.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Anhang D: Spickzettel der Solver</span></a></li><li data-kapitel="anhang-glossar-literatur.html"><a href="anhang-glossar-literatur.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Anhang E: Glossar und Literatur</span></a></li></ul></details><ul class="sidebar-extra"><li><a href="programme.html"><svg class="icon" aria-hidden="true"><use href="#icon-book"></use></svg> Beispielprogramme</a></li><li><a href="stichwortverzeichnis.html"><svg class="icon" aria-hidden="true"><use href="#icon-search"></use></svg> Stichwortverzeichnis</a></li><li><a href="gesamtdokument.html"><svg class="icon" aria-hidden="true"><use href="#icon-external-link"></use></svg> Gesamtdokument (eine Seite)</a></li><li><a href="Operations_Research_mit_Python_Version_04.pdf" download><svg class="icon" aria-hidden="true"><use href="#icon-download"></use></svg> Download als PDF</a></li></ul></div></nav>
   <main class="content">
     <nav class="breadcrumb" aria-label="Breadcrumb"><a href="index.html">Start</a> › <span>Teil IV</span> › <span>Kapitel 19: Die moderne Portfoliotheorie nach Markowitz</span></nav>
     <nav class="prev-next"><a class="prev-next-knopf prev-next-prev" href="finanzdaten.html"><svg class="icon" aria-hidden="true"><use href="#icon-chevron-left"></use></svg><span><small>Zurück</small>Kapitel 18: Finanzdaten-Modellierung — Renditen, Kovarianz und Shrinkage</span></a><a class="prev-next-knopf prev-next-next" href="cvar.html"><span><small>Weiter</small>Kapitel 20: Tail-Risiko, CVaR und Transaktionskosten</span><svg class="icon" aria-hidden="true"><use href="#icon-chevron-right"></use></svg></a></nav>
@@ -861,7 +861,7 @@ obwohl Formel und Simulation nichts voneinander wissen.</code></pre>
 <p><a href="finanzdaten.html#kap-finanzdaten">Kapitel 18</a> hat gezeigt, was eine schlecht geschätzte <strong>Kovarianzmatrix</strong> anrichtet. Bei den erwarteten <strong>Renditen</strong> ist es schlimmer — und weil sie in der Zielfunktion stehen statt in der Nebenbedingung, fällt es schwerer auf.</p>
 <div class="card card-denkfehler">
 <blockquote>
-<p><strong>🐛 Finde den Denkfehler 12.1: Zwölf gleiche Anlagen, ein sehr ungleiches Portfolio</strong></p>
+<p><strong>🐛 Finde den Denkfehler: Zwölf gleiche Anlagen, ein sehr ungleiches Portfolio</strong></p>
 <p>Ein Analyst optimiert ein Portfolio aus zwölf Anlagen. Erwartete Renditen und Kovarianzen schätzt er aus einem Jahr Tagesdaten — 250 Beobachtungen, in der Praxis durchaus üblich.</p>
 <p>Zur Kontrolle bauen wir das Experiment so, dass die richtige Antwort <strong>feststeht</strong>: Alle zwölf Anlagen haben in Wahrheit exakt dieselbe Rendite (0,0400 % täglich) und dieselbe Schwankung, und sie sind unabhängig. Ein korrektes Verfahren müsste also gleichgewichten.</p>
 <p>Der Optimierer legt stattdessen im Mittel <strong>38 %</strong> in eine einzige Anlage — und meldet für das Portfolio eine Tagesrendite von <strong>0,1261 %</strong>, mehr als das Dreifache dessen, was überhaupt erzielbar ist.</p>
@@ -1057,7 +1057,7 @@ Drei praktische Konsequenzen:
 <h2 id="sec:markowitz-quiz">19.9 Micro-Quiz</h2>
 <div class="card card-quiz">
 <blockquote>
-<p><strong>❓ Micro-Quiz 12: Drei Fragen zum Selbstcheck</strong></p>
+<p><strong>❓ Micro-Quiz 19: Drei Fragen zum Selbstcheck</strong></p>
 <p>Genau eine Antwort ist jeweils richtig. Auflösung in <a href="anhang-loesungen.html#quiz-loesung-markowitz">Anhang A</a>.</p>
 <p><strong>1. Auf der Effizienzlinie liegt das Portfolio mit der höchsten Rendite. Warum ist es trotzdem selten die richtige Wahl?</strong> (a) Weil es rechnerisch instabil ist. (b) Weil es das schlechteste Verhältnis von Rendite zu Risiko hat und zwangsläufig vollständig in die renditestärkste Einzelanlage geht — also gar nicht mehr diversifiziert ist. (c) Weil CVXPY dort keine Lösung mehr findet.</p>
 <p><strong>2. Warum ist das Minimum-Varianz-Portfolio in der Praxis oft robuster als das Maximum-Sharpe-Portfolio?</strong> (a) Weil es weniger Nebenbedingungen hat. (b) Weil es <strong>ohne Renditeschätzung</strong> auskommt. Renditen sind die mit Abstand am unzuverlässigsten geschätzte Eingangsgröße; wer sie nicht braucht, umgeht das Problem. (c) Weil es immer die höhere Rendite erzielt.</p>
diff --git a/OR_HTML_04/mehrziel.html b/OR_HTML_04/mehrziel.html
index bd46844..0e7ca27 100644
--- a/OR_HTML_04/mehrziel.html
+++ b/OR_HTML_04/mehrziel.html
@@ -94,7 +94,7 @@
 </header>
 <div class="site-body">
   <div class="sidebar-overlay" id="sidebar-overlay" hidden></div>
-  <nav class="sidebar" id="sidebar" aria-label="Kapitelnavigation"><div class="sidebar-inhalt"><details class="sidebar-gruppe"><summary>Einstieg</summary><ul><li data-kapitel="vorwort.html"><a href="vorwort.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Vorwort & Lesehilfe</span></a></li><li data-kapitel="notation.html"><a href="notation.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Notation & Abkürzungen</span></a></li></ul></details><details class="sidebar-gruppe"><summary>Teil I: Grundlagen des Operations Research</summary><ul><li data-kapitel="einfuehrung.html"><a href="einfuehrung.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 1: Einführung in Operations Research — Vom Ursprung zur mathematischen Entscheidungsfindung</span></a></li><li data-kapitel="fundament.html"><a href="fundament.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 2: Das mathematische Fundament — Vektoren, Matrizen, Konvexität</span></a></li><li data-kapitel="oekosystem.html"><a href="oekosystem.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 3: Das Python-Ökosystem für OR — Solver, Bindings und Modellierungsschichten</span></a></li><li data-kapitel="modellierung.html"><a href="modellierung.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 4: Vom Management-Wunsch zum Modell</span></a></li></ul></details><details class="sidebar-gruppe"><summary>Teil II: Die Kernverfahren der deterministischen Optimierung</summary><ul><li data-kapitel="lp.html"><a href="lp.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 5: Lineare Programmierung — Simplex, Dualität und Schattenpreise</span></a></li><li data-kapitel="milp.html"><a href="milp.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 6: Gemischt-ganzzahlige Optimierung — Diskrete Entscheidungen und Branch-and-Bound</span></a></li><li data-kapitel="cpsat.html"><a href="cpsat.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 7: Constraint Programming mit CP-SAT — Logik, Scheduling und Zuweisung</span></a></li><li data-kapitel="graphen.html"><a href="graphen.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 8: Graphen, Flüsse und Touren — Min-Cost-Flow, Matching und VRP</span></a></li><li data-kapitel="metaheuristiken.html"><a href="metaheuristiken.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 9: Metaheuristiken — wenn der exakte Solver aussteigt</span></a></li><li data-kapitel="dekomposition.html"><a href="dekomposition.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 10: Spaltengenerierung — das Modell umbauen statt die Lösung raten</span></a></li></ul></details><details class="sidebar-gruppe" open><summary>Teil III: Nichtlinearität, Unsicherheit und mehrperiodige Dynamik</summary><ul><li data-kapitel="qp-nlp.html"><a href="qp-nlp.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 11: Quadratische und nichtlineare Optimierung — KKT, Lagrange, Konvexität</span></a></li><li data-kapitel="unsicherheit.html"><a href="unsicherheit.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 12: Optimierung unter Unsicherheit — Monte-Carlo, Stochastik, Robustheit</span></a></li><li data-kapitel="dynamische-programmierung.html"><a href="dynamische-programmierung.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 13: Dynamische Programmierung — Die Bellman-Gleichung und Order-Execution</span></a></li><li data-kapitel="mehrziel.html" class="aktiv"><a href="mehrziel.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 14: Mehrere Ziele — Pareto-Fronten statt Gewichte</span></a></li><li data-kapitel="prognose.html"><a href="prognose.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 15: Predict-then-Optimize — die bessere Prognose, die schlechtere Entscheidung</span></a></li></ul></details><details class="sidebar-gruppe"><summary>Teil IV: Anwendungen — Energiewirtschaft und Finanzmärkte</summary><ul><li data-kapitel="bruecke.html"><a href="bruecke.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 16: Die Strukturbrücke — dieselbe Mathematik, zwei Welten</span></a></li><li data-kapitel="supplychain.html"><a href="supplychain.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 17: Supply-Chain und Energieeinsatz unter Unsicherheit</span></a></li><li data-kapitel="finanzdaten.html"><a href="finanzdaten.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 18: Finanzdaten-Modellierung — Renditen, Kovarianz und Shrinkage</span></a></li><li data-kapitel="markowitz.html"><a href="markowitz.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 19: Die moderne Portfoliotheorie nach Markowitz</span></a></li><li data-kapitel="cvar.html"><a href="cvar.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 20: Tail-Risiko, CVaR und Transaktionskosten</span></a></li><li data-kapitel="handelsmaschine.html"><a href="handelsmaschine.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 21: Die vollständige quantitative Handelsmaschine</span></a></li></ul></details><details class="sidebar-gruppe"><summary>Teil V: Praxis</summary><ul><li data-kapitel="praxisfallen.html"><a href="praxisfallen.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 22: Praxisfallen und der Weg zum produktiven Einsatz</span></a></li><li data-kapitel="testing.html"><a href="testing.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 23: Testen, Messen, Ausliefern</span></a></li><li data-kapitel="projektwerkstatt.html"><a href="projektwerkstatt.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Projektwerkstatt</span></a></li></ul></details><details class="sidebar-gruppe"><summary>Anhänge</summary><ul><li data-kapitel="anhang-loesungen.html"><a href="anhang-loesungen.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Anhang A: Lösungen zu allen Übungsaufgaben</span></a></li><li data-kapitel="anhang-modellierungsmuster.html"><a href="anhang-modellierungsmuster.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Anhang B: Katalog der Modellierungsmuster</span></a></li><li data-kapitel="anhang-fehlerdiagnose.html"><a href="anhang-fehlerdiagnose.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Anhang C: Fehlerdiagnose-Handbuch</span></a></li><li data-kapitel="anhang-spickzettel.html"><a href="anhang-spickzettel.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Anhang D: Spickzettel der Solver</span></a></li><li data-kapitel="anhang-glossar-literatur.html"><a href="anhang-glossar-literatur.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Anhang E: Glossar und Literatur</span></a></li></ul></details><ul class="sidebar-extra"><li><a href="programme.html"><svg class="icon" aria-hidden="true"><use href="#icon-book"></use></svg> Beispielprogramme</a></li><li><a href="stichwortverzeichnis.html"><svg class="icon" aria-hidden="true"><use href="#icon-search"></use></svg> Stichwortverzeichnis</a></li><li><a href="gesamtdokument.html"><svg class="icon" aria-hidden="true"><use href="#icon-external-link"></use></svg> Gesamtdokument (eine Seite)</a></li><li><a href="Operations_Research_mit_Python_Version_04.pdf" download><svg class="icon" aria-hidden="true"><use href="#icon-download"></use></svg> Download als PDF</a></li></ul></div></nav>
+  <nav class="sidebar" id="sidebar" aria-label="Kapitelnavigation"><div class="sidebar-inhalt"><details class="sidebar-gruppe"><summary>Einstieg</summary><ul><li data-kapitel="vorwort.html"><a href="vorwort.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Vorwort & Lesehilfe</span></a></li><li data-kapitel="notation.html"><a href="notation.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Notation & Abkürzungen</span></a></li></ul></details><details class="sidebar-gruppe"><summary>Teil I: Grundlagen des Operations Research</summary><ul><li data-kapitel="einfuehrung.html"><a href="einfuehrung.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 1: Einführung in Operations Research — Vom Ursprung zur mathematischen Entscheidungsfindung</span></a></li><li data-kapitel="fundament.html"><a href="fundament.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 2: Das mathematische Fundament — Vektoren, Matrizen, Konvexität</span></a></li><li data-kapitel="oekosystem.html"><a href="oekosystem.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 3: Das Python-Ökosystem für OR — Solver, Bindings und Modellierungsschichten</span></a></li><li data-kapitel="modellierung.html"><a href="modellierung.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 4: Vom Management-Wunsch zum Modell</span></a></li><li data-kapitel="synthese-grundlagen.html"><a href="synthese-grundlagen.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Synthese Teil I</span></a></li></ul></details><details class="sidebar-gruppe"><summary>Teil II: Die Kernverfahren der deterministischen Optimierung</summary><ul><li data-kapitel="lp.html"><a href="lp.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 5: Lineare Programmierung — Simplex, Dualität und Schattenpreise</span></a></li><li data-kapitel="milp.html"><a href="milp.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 6: Gemischt-ganzzahlige Optimierung — Diskrete Entscheidungen und Branch-and-Bound</span></a></li><li data-kapitel="cpsat.html"><a href="cpsat.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 7: Constraint Programming mit CP-SAT — Logik, Scheduling und Zuweisung</span></a></li><li data-kapitel="graphen.html"><a href="graphen.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 8: Graphen, Flüsse und Touren — Min-Cost-Flow, Matching und VRP</span></a></li><li data-kapitel="metaheuristiken.html"><a href="metaheuristiken.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 9: Metaheuristiken — wenn der exakte Solver aussteigt</span></a></li><li data-kapitel="dekomposition.html"><a href="dekomposition.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 10: Spaltengenerierung — das Modell umbauen statt die Lösung raten</span></a></li><li data-kapitel="synthese-kernverfahren.html"><a href="synthese-kernverfahren.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Synthese Teil II</span></a></li></ul></details><details class="sidebar-gruppe" open><summary>Teil III: Nichtlinearität, Unsicherheit und mehrperiodige Dynamik</summary><ul><li data-kapitel="qp-nlp.html"><a href="qp-nlp.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 11: Quadratische und nichtlineare Optimierung — KKT, Lagrange, Konvexität</span></a></li><li data-kapitel="unsicherheit.html"><a href="unsicherheit.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 12: Optimierung unter Unsicherheit — Monte-Carlo, Stochastik, Robustheit</span></a></li><li data-kapitel="dynamische-programmierung.html"><a href="dynamische-programmierung.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 13: Dynamische Programmierung — Die Bellman-Gleichung und Order-Execution</span></a></li><li data-kapitel="mehrziel.html" class="aktiv"><a href="mehrziel.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 14: Mehrere Ziele — Pareto-Fronten statt Gewichte</span></a></li><li data-kapitel="prognose.html"><a href="prognose.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 15: Predict-then-Optimize — die bessere Prognose, die schlechtere Entscheidung</span></a></li><li data-kapitel="synthese-nichtlinear.html"><a href="synthese-nichtlinear.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Synthese Teil III</span></a></li></ul></details><details class="sidebar-gruppe"><summary>Teil IV: Anwendungen — Energiewirtschaft und Finanzmärkte</summary><ul><li data-kapitel="bruecke.html"><a href="bruecke.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 16: Die Strukturbrücke — dieselbe Mathematik, zwei Welten</span></a></li><li data-kapitel="supplychain.html"><a href="supplychain.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 17: Supply-Chain und Energieeinsatz unter Unsicherheit</span></a></li><li data-kapitel="finanzdaten.html"><a href="finanzdaten.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 18: Finanzdaten-Modellierung — Renditen, Kovarianz und Shrinkage</span></a></li><li data-kapitel="markowitz.html"><a href="markowitz.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 19: Die moderne Portfoliotheorie nach Markowitz</span></a></li><li data-kapitel="cvar.html"><a href="cvar.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 20: Tail-Risiko, CVaR und Transaktionskosten</span></a></li><li data-kapitel="handelsmaschine.html"><a href="handelsmaschine.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 21: Die vollständige quantitative Handelsmaschine</span></a></li><li data-kapitel="synthese-anwendungen.html"><a href="synthese-anwendungen.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Synthese Teil IV</span></a></li></ul></details><details class="sidebar-gruppe"><summary>Teil V: Praxis</summary><ul><li data-kapitel="praxisfallen.html"><a href="praxisfallen.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 22: Praxisfallen und der Weg zum produktiven Einsatz</span></a></li><li data-kapitel="testing.html"><a href="testing.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 23: Testen, Messen, Ausliefern</span></a></li><li data-kapitel="synthese-praxis.html"><a href="synthese-praxis.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Synthese Teil V</span></a></li><li data-kapitel="projektwerkstatt.html"><a href="projektwerkstatt.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Projektwerkstatt</span></a></li></ul></details><details class="sidebar-gruppe"><summary>Anhänge</summary><ul><li data-kapitel="anhang-loesungen.html"><a href="anhang-loesungen.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Anhang A: Lösungen zu allen Übungsaufgaben</span></a></li><li data-kapitel="anhang-modellierungsmuster.html"><a href="anhang-modellierungsmuster.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Anhang B: Katalog der Modellierungsmuster</span></a></li><li data-kapitel="anhang-fehlerdiagnose.html"><a href="anhang-fehlerdiagnose.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Anhang C: Fehlerdiagnose-Handbuch</span></a></li><li data-kapitel="anhang-spickzettel.html"><a href="anhang-spickzettel.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Anhang D: Spickzettel der Solver</span></a></li><li data-kapitel="anhang-glossar-literatur.html"><a href="anhang-glossar-literatur.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Anhang E: Glossar und Literatur</span></a></li></ul></details><ul class="sidebar-extra"><li><a href="programme.html"><svg class="icon" aria-hidden="true"><use href="#icon-book"></use></svg> Beispielprogramme</a></li><li><a href="stichwortverzeichnis.html"><svg class="icon" aria-hidden="true"><use href="#icon-search"></use></svg> Stichwortverzeichnis</a></li><li><a href="gesamtdokument.html"><svg class="icon" aria-hidden="true"><use href="#icon-external-link"></use></svg> Gesamtdokument (eine Seite)</a></li><li><a href="Operations_Research_mit_Python_Version_04.pdf" download><svg class="icon" aria-hidden="true"><use href="#icon-download"></use></svg> Download als PDF</a></li></ul></div></nav>
   <main class="content">
     <nav class="breadcrumb" aria-label="Breadcrumb"><a href="index.html">Start</a> › <span>Teil III</span> › <span>Kapitel 14: Mehrere Ziele — Pareto-Fronten statt Gewichte</span></nav>
     <nav class="prev-next"><a class="prev-next-knopf prev-next-prev" href="dynamische-programmierung.html"><svg class="icon" aria-hidden="true"><use href="#icon-chevron-left"></use></svg><span><small>Zurück</small>Kapitel 13: Dynamische Programmierung — Die Bellman-Gleichung und Order-Execution</span></a><a class="prev-next-knopf prev-next-next" href="prognose.html"><span><small>Weiter</small>Kapitel 15: Predict-then-Optimize — die bessere Prognose, die schlechtere Entscheidung</span><svg class="icon" aria-hidden="true"><use href="#icon-chevron-right"></use></svg></a></nav>
@@ -252,7 +252,7 @@ f_j(x) &lt; f_j(y)\ \text{ für mindestens ein } j
 </tr>
 <tr class="odd">
 <td><span class="math inline">w</span></td>
-<td>„So viele Euro ist mir ein Kilogramm CO₂ wert.“ Ein <strong>Wechselkurs</strong>, kein Wichtigkeitsregler (<a href="cpsat.html#sec:cpsat-denkfehler">Abschnitt 7.9</a>).</td>
+<td>„So viele Euro ist mir ein Kilogramm CO₂ wert.“ Ein <strong>Wechselkurs</strong>, kein Wichtigkeitsregler (<a href="cpsat.html#sec:cpsat-denkfehler">Abschnitt 7.10</a>).</td>
 </tr>
 <tr class="even">
 <td><span class="math inline">\min_{x \in X}</span></td>
diff --git a/OR_HTML_04/metaheuristiken.html b/OR_HTML_04/metaheuristiken.html
index 8d0f816..580255f 100644
--- a/OR_HTML_04/metaheuristiken.html
+++ b/OR_HTML_04/metaheuristiken.html
@@ -94,7 +94,7 @@
 </header>
 <div class="site-body">
   <div class="sidebar-overlay" id="sidebar-overlay" hidden></div>
-  <nav class="sidebar" id="sidebar" aria-label="Kapitelnavigation"><div class="sidebar-inhalt"><details class="sidebar-gruppe"><summary>Einstieg</summary><ul><li data-kapitel="vorwort.html"><a href="vorwort.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Vorwort & Lesehilfe</span></a></li><li data-kapitel="notation.html"><a href="notation.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Notation & Abkürzungen</span></a></li></ul></details><details class="sidebar-gruppe"><summary>Teil I: Grundlagen des Operations Research</summary><ul><li data-kapitel="einfuehrung.html"><a href="einfuehrung.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 1: Einführung in Operations Research — Vom Ursprung zur mathematischen Entscheidungsfindung</span></a></li><li data-kapitel="fundament.html"><a href="fundament.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 2: Das mathematische Fundament — Vektoren, Matrizen, Konvexität</span></a></li><li data-kapitel="oekosystem.html"><a href="oekosystem.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 3: Das Python-Ökosystem für OR — Solver, Bindings und Modellierungsschichten</span></a></li><li data-kapitel="modellierung.html"><a href="modellierung.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 4: Vom Management-Wunsch zum Modell</span></a></li></ul></details><details class="sidebar-gruppe" open><summary>Teil II: Die Kernverfahren der deterministischen Optimierung</summary><ul><li data-kapitel="lp.html"><a href="lp.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 5: Lineare Programmierung — Simplex, Dualität und Schattenpreise</span></a></li><li data-kapitel="milp.html"><a href="milp.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 6: Gemischt-ganzzahlige Optimierung — Diskrete Entscheidungen und Branch-and-Bound</span></a></li><li data-kapitel="cpsat.html"><a href="cpsat.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 7: Constraint Programming mit CP-SAT — Logik, Scheduling und Zuweisung</span></a></li><li data-kapitel="graphen.html"><a href="graphen.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 8: Graphen, Flüsse und Touren — Min-Cost-Flow, Matching und VRP</span></a></li><li data-kapitel="metaheuristiken.html" class="aktiv"><a href="metaheuristiken.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 9: Metaheuristiken — wenn der exakte Solver aussteigt</span></a></li><li data-kapitel="dekomposition.html"><a href="dekomposition.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 10: Spaltengenerierung — das Modell umbauen statt die Lösung raten</span></a></li></ul></details><details class="sidebar-gruppe"><summary>Teil III: Nichtlinearität, Unsicherheit und mehrperiodige Dynamik</summary><ul><li data-kapitel="qp-nlp.html"><a href="qp-nlp.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 11: Quadratische und nichtlineare Optimierung — KKT, Lagrange, Konvexität</span></a></li><li data-kapitel="unsicherheit.html"><a href="unsicherheit.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 12: Optimierung unter Unsicherheit — Monte-Carlo, Stochastik, Robustheit</span></a></li><li data-kapitel="dynamische-programmierung.html"><a href="dynamische-programmierung.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 13: Dynamische Programmierung — Die Bellman-Gleichung und Order-Execution</span></a></li><li data-kapitel="mehrziel.html"><a href="mehrziel.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 14: Mehrere Ziele — Pareto-Fronten statt Gewichte</span></a></li><li data-kapitel="prognose.html"><a href="prognose.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 15: Predict-then-Optimize — die bessere Prognose, die schlechtere Entscheidung</span></a></li></ul></details><details class="sidebar-gruppe"><summary>Teil IV: Anwendungen — Energiewirtschaft und Finanzmärkte</summary><ul><li data-kapitel="bruecke.html"><a href="bruecke.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 16: Die Strukturbrücke — dieselbe Mathematik, zwei Welten</span></a></li><li data-kapitel="supplychain.html"><a href="supplychain.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 17: Supply-Chain und Energieeinsatz unter Unsicherheit</span></a></li><li data-kapitel="finanzdaten.html"><a href="finanzdaten.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 18: Finanzdaten-Modellierung — Renditen, Kovarianz und Shrinkage</span></a></li><li data-kapitel="markowitz.html"><a href="markowitz.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 19: Die moderne Portfoliotheorie nach Markowitz</span></a></li><li data-kapitel="cvar.html"><a href="cvar.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 20: Tail-Risiko, CVaR und Transaktionskosten</span></a></li><li data-kapitel="handelsmaschine.html"><a href="handelsmaschine.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 21: Die vollständige quantitative Handelsmaschine</span></a></li></ul></details><details class="sidebar-gruppe"><summary>Teil V: Praxis</summary><ul><li data-kapitel="praxisfallen.html"><a href="praxisfallen.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 22: Praxisfallen und der Weg zum produktiven Einsatz</span></a></li><li data-kapitel="testing.html"><a href="testing.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 23: Testen, Messen, Ausliefern</span></a></li><li data-kapitel="projektwerkstatt.html"><a href="projektwerkstatt.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Projektwerkstatt</span></a></li></ul></details><details class="sidebar-gruppe"><summary>Anhänge</summary><ul><li data-kapitel="anhang-loesungen.html"><a href="anhang-loesungen.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Anhang A: Lösungen zu allen Übungsaufgaben</span></a></li><li data-kapitel="anhang-modellierungsmuster.html"><a href="anhang-modellierungsmuster.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Anhang B: Katalog der Modellierungsmuster</span></a></li><li data-kapitel="anhang-fehlerdiagnose.html"><a href="anhang-fehlerdiagnose.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Anhang C: Fehlerdiagnose-Handbuch</span></a></li><li data-kapitel="anhang-spickzettel.html"><a href="anhang-spickzettel.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Anhang D: Spickzettel der Solver</span></a></li><li data-kapitel="anhang-glossar-literatur.html"><a href="anhang-glossar-literatur.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Anhang E: Glossar und Literatur</span></a></li></ul></details><ul class="sidebar-extra"><li><a href="programme.html"><svg class="icon" aria-hidden="true"><use href="#icon-book"></use></svg> Beispielprogramme</a></li><li><a href="stichwortverzeichnis.html"><svg class="icon" aria-hidden="true"><use href="#icon-search"></use></svg> Stichwortverzeichnis</a></li><li><a href="gesamtdokument.html"><svg class="icon" aria-hidden="true"><use href="#icon-external-link"></use></svg> Gesamtdokument (eine Seite)</a></li><li><a href="Operations_Research_mit_Python_Version_04.pdf" download><svg class="icon" aria-hidden="true"><use href="#icon-download"></use></svg> Download als PDF</a></li></ul></div></nav>
+  <nav class="sidebar" id="sidebar" aria-label="Kapitelnavigation"><div class="sidebar-inhalt"><details class="sidebar-gruppe"><summary>Einstieg</summary><ul><li data-kapitel="vorwort.html"><a href="vorwort.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Vorwort & Lesehilfe</span></a></li><li data-kapitel="notation.html"><a href="notation.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Notation & Abkürzungen</span></a></li></ul></details><details class="sidebar-gruppe"><summary>Teil I: Grundlagen des Operations Research</summary><ul><li data-kapitel="einfuehrung.html"><a href="einfuehrung.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 1: Einführung in Operations Research — Vom Ursprung zur mathematischen Entscheidungsfindung</span></a></li><li data-kapitel="fundament.html"><a href="fundament.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 2: Das mathematische Fundament — Vektoren, Matrizen, Konvexität</span></a></li><li data-kapitel="oekosystem.html"><a href="oekosystem.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 3: Das Python-Ökosystem für OR — Solver, Bindings und Modellierungsschichten</span></a></li><li data-kapitel="modellierung.html"><a href="modellierung.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 4: Vom Management-Wunsch zum Modell</span></a></li><li data-kapitel="synthese-grundlagen.html"><a href="synthese-grundlagen.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Synthese Teil I</span></a></li></ul></details><details class="sidebar-gruppe" open><summary>Teil II: Die Kernverfahren der deterministischen Optimierung</summary><ul><li data-kapitel="lp.html"><a href="lp.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 5: Lineare Programmierung — Simplex, Dualität und Schattenpreise</span></a></li><li data-kapitel="milp.html"><a href="milp.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 6: Gemischt-ganzzahlige Optimierung — Diskrete Entscheidungen und Branch-and-Bound</span></a></li><li data-kapitel="cpsat.html"><a href="cpsat.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 7: Constraint Programming mit CP-SAT — Logik, Scheduling und Zuweisung</span></a></li><li data-kapitel="graphen.html"><a href="graphen.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 8: Graphen, Flüsse und Touren — Min-Cost-Flow, Matching und VRP</span></a></li><li data-kapitel="metaheuristiken.html" class="aktiv"><a href="metaheuristiken.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 9: Metaheuristiken — wenn der exakte Solver aussteigt</span></a></li><li data-kapitel="dekomposition.html"><a href="dekomposition.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 10: Spaltengenerierung — das Modell umbauen statt die Lösung raten</span></a></li><li data-kapitel="synthese-kernverfahren.html"><a href="synthese-kernverfahren.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Synthese Teil II</span></a></li></ul></details><details class="sidebar-gruppe"><summary>Teil III: Nichtlinearität, Unsicherheit und mehrperiodige Dynamik</summary><ul><li data-kapitel="qp-nlp.html"><a href="qp-nlp.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 11: Quadratische und nichtlineare Optimierung — KKT, Lagrange, Konvexität</span></a></li><li data-kapitel="unsicherheit.html"><a href="unsicherheit.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 12: Optimierung unter Unsicherheit — Monte-Carlo, Stochastik, Robustheit</span></a></li><li data-kapitel="dynamische-programmierung.html"><a href="dynamische-programmierung.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 13: Dynamische Programmierung — Die Bellman-Gleichung und Order-Execution</span></a></li><li data-kapitel="mehrziel.html"><a href="mehrziel.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 14: Mehrere Ziele — Pareto-Fronten statt Gewichte</span></a></li><li data-kapitel="prognose.html"><a href="prognose.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 15: Predict-then-Optimize — die bessere Prognose, die schlechtere Entscheidung</span></a></li><li data-kapitel="synthese-nichtlinear.html"><a href="synthese-nichtlinear.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Synthese Teil III</span></a></li></ul></details><details class="sidebar-gruppe"><summary>Teil IV: Anwendungen — Energiewirtschaft und Finanzmärkte</summary><ul><li data-kapitel="bruecke.html"><a href="bruecke.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 16: Die Strukturbrücke — dieselbe Mathematik, zwei Welten</span></a></li><li data-kapitel="supplychain.html"><a href="supplychain.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 17: Supply-Chain und Energieeinsatz unter Unsicherheit</span></a></li><li data-kapitel="finanzdaten.html"><a href="finanzdaten.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 18: Finanzdaten-Modellierung — Renditen, Kovarianz und Shrinkage</span></a></li><li data-kapitel="markowitz.html"><a href="markowitz.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 19: Die moderne Portfoliotheorie nach Markowitz</span></a></li><li data-kapitel="cvar.html"><a href="cvar.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 20: Tail-Risiko, CVaR und Transaktionskosten</span></a></li><li data-kapitel="handelsmaschine.html"><a href="handelsmaschine.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 21: Die vollständige quantitative Handelsmaschine</span></a></li><li data-kapitel="synthese-anwendungen.html"><a href="synthese-anwendungen.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Synthese Teil IV</span></a></li></ul></details><details class="sidebar-gruppe"><summary>Teil V: Praxis</summary><ul><li data-kapitel="praxisfallen.html"><a href="praxisfallen.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 22: Praxisfallen und der Weg zum produktiven Einsatz</span></a></li><li data-kapitel="testing.html"><a href="testing.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 23: Testen, Messen, Ausliefern</span></a></li><li data-kapitel="synthese-praxis.html"><a href="synthese-praxis.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Synthese Teil V</span></a></li><li data-kapitel="projektwerkstatt.html"><a href="projektwerkstatt.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Projektwerkstatt</span></a></li></ul></details><details class="sidebar-gruppe"><summary>Anhänge</summary><ul><li data-kapitel="anhang-loesungen.html"><a href="anhang-loesungen.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Anhang A: Lösungen zu allen Übungsaufgaben</span></a></li><li data-kapitel="anhang-modellierungsmuster.html"><a href="anhang-modellierungsmuster.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Anhang B: Katalog der Modellierungsmuster</span></a></li><li data-kapitel="anhang-fehlerdiagnose.html"><a href="anhang-fehlerdiagnose.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Anhang C: Fehlerdiagnose-Handbuch</span></a></li><li data-kapitel="anhang-spickzettel.html"><a href="anhang-spickzettel.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Anhang D: Spickzettel der Solver</span></a></li><li data-kapitel="anhang-glossar-literatur.html"><a href="anhang-glossar-literatur.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Anhang E: Glossar und Literatur</span></a></li></ul></details><ul class="sidebar-extra"><li><a href="programme.html"><svg class="icon" aria-hidden="true"><use href="#icon-book"></use></svg> Beispielprogramme</a></li><li><a href="stichwortverzeichnis.html"><svg class="icon" aria-hidden="true"><use href="#icon-search"></use></svg> Stichwortverzeichnis</a></li><li><a href="gesamtdokument.html"><svg class="icon" aria-hidden="true"><use href="#icon-external-link"></use></svg> Gesamtdokument (eine Seite)</a></li><li><a href="Operations_Research_mit_Python_Version_04.pdf" download><svg class="icon" aria-hidden="true"><use href="#icon-download"></use></svg> Download als PDF</a></li></ul></div></nav>
   <main class="content">
     <nav class="breadcrumb" aria-label="Breadcrumb"><a href="index.html">Start</a> › <span>Teil II</span> › <span>Kapitel 9: Metaheuristiken — wenn der exakte Solver aussteigt</span></nav>
     <nav class="prev-next"><a class="prev-next-knopf prev-next-prev" href="graphen.html"><svg class="icon" aria-hidden="true"><use href="#icon-chevron-left"></use></svg><span><small>Zurück</small>Kapitel 8: Graphen, Flüsse und Touren — Min-Cost-Flow, Matching und VRP</span></a><a class="prev-next-knopf prev-next-next" href="dekomposition.html"><span><small>Weiter</small>Kapitel 10: Spaltengenerierung — das Modell umbauen statt die Lösung raten</span><svg class="icon" aria-hidden="true"><use href="#icon-chevron-right"></use></svg></a></nav>
diff --git a/OR_HTML_04/milp.html b/OR_HTML_04/milp.html
index ae0af97..97f3d07 100644
--- a/OR_HTML_04/milp.html
+++ b/OR_HTML_04/milp.html
@@ -94,7 +94,7 @@
 </header>
 <div class="site-body">
   <div class="sidebar-overlay" id="sidebar-overlay" hidden></div>
-  <nav class="sidebar" id="sidebar" aria-label="Kapitelnavigation"><div class="sidebar-inhalt"><details class="sidebar-gruppe"><summary>Einstieg</summary><ul><li data-kapitel="vorwort.html"><a href="vorwort.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Vorwort & Lesehilfe</span></a></li><li data-kapitel="notation.html"><a href="notation.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Notation & Abkürzungen</span></a></li></ul></details><details class="sidebar-gruppe"><summary>Teil I: Grundlagen des Operations Research</summary><ul><li data-kapitel="einfuehrung.html"><a href="einfuehrung.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 1: Einführung in Operations Research — Vom Ursprung zur mathematischen Entscheidungsfindung</span></a></li><li data-kapitel="fundament.html"><a href="fundament.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 2: Das mathematische Fundament — Vektoren, Matrizen, Konvexität</span></a></li><li data-kapitel="oekosystem.html"><a href="oekosystem.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 3: Das Python-Ökosystem für OR — Solver, Bindings und Modellierungsschichten</span></a></li><li data-kapitel="modellierung.html"><a href="modellierung.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 4: Vom Management-Wunsch zum Modell</span></a></li></ul></details><details class="sidebar-gruppe" open><summary>Teil II: Die Kernverfahren der deterministischen Optimierung</summary><ul><li data-kapitel="lp.html"><a href="lp.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 5: Lineare Programmierung — Simplex, Dualität und Schattenpreise</span></a></li><li data-kapitel="milp.html" class="aktiv"><a href="milp.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 6: Gemischt-ganzzahlige Optimierung — Diskrete Entscheidungen und Branch-and-Bound</span></a></li><li data-kapitel="cpsat.html"><a href="cpsat.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 7: Constraint Programming mit CP-SAT — Logik, Scheduling und Zuweisung</span></a></li><li data-kapitel="graphen.html"><a href="graphen.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 8: Graphen, Flüsse und Touren — Min-Cost-Flow, Matching und VRP</span></a></li><li data-kapitel="metaheuristiken.html"><a href="metaheuristiken.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 9: Metaheuristiken — wenn der exakte Solver aussteigt</span></a></li><li data-kapitel="dekomposition.html"><a href="dekomposition.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 10: Spaltengenerierung — das Modell umbauen statt die Lösung raten</span></a></li></ul></details><details class="sidebar-gruppe"><summary>Teil III: Nichtlinearität, Unsicherheit und mehrperiodige Dynamik</summary><ul><li data-kapitel="qp-nlp.html"><a href="qp-nlp.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 11: Quadratische und nichtlineare Optimierung — KKT, Lagrange, Konvexität</span></a></li><li data-kapitel="unsicherheit.html"><a href="unsicherheit.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 12: Optimierung unter Unsicherheit — Monte-Carlo, Stochastik, Robustheit</span></a></li><li data-kapitel="dynamische-programmierung.html"><a href="dynamische-programmierung.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 13: Dynamische Programmierung — Die Bellman-Gleichung und Order-Execution</span></a></li><li data-kapitel="mehrziel.html"><a href="mehrziel.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 14: Mehrere Ziele — Pareto-Fronten statt Gewichte</span></a></li><li data-kapitel="prognose.html"><a href="prognose.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 15: Predict-then-Optimize — die bessere Prognose, die schlechtere Entscheidung</span></a></li></ul></details><details class="sidebar-gruppe"><summary>Teil IV: Anwendungen — Energiewirtschaft und Finanzmärkte</summary><ul><li data-kapitel="bruecke.html"><a href="bruecke.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 16: Die Strukturbrücke — dieselbe Mathematik, zwei Welten</span></a></li><li data-kapitel="supplychain.html"><a href="supplychain.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 17: Supply-Chain und Energieeinsatz unter Unsicherheit</span></a></li><li data-kapitel="finanzdaten.html"><a href="finanzdaten.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 18: Finanzdaten-Modellierung — Renditen, Kovarianz und Shrinkage</span></a></li><li data-kapitel="markowitz.html"><a href="markowitz.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 19: Die moderne Portfoliotheorie nach Markowitz</span></a></li><li data-kapitel="cvar.html"><a href="cvar.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 20: Tail-Risiko, CVaR und Transaktionskosten</span></a></li><li data-kapitel="handelsmaschine.html"><a href="handelsmaschine.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 21: Die vollständige quantitative Handelsmaschine</span></a></li></ul></details><details class="sidebar-gruppe"><summary>Teil V: Praxis</summary><ul><li data-kapitel="praxisfallen.html"><a href="praxisfallen.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 22: Praxisfallen und der Weg zum produktiven Einsatz</span></a></li><li data-kapitel="testing.html"><a href="testing.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 23: Testen, Messen, Ausliefern</span></a></li><li data-kapitel="projektwerkstatt.html"><a href="projektwerkstatt.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Projektwerkstatt</span></a></li></ul></details><details class="sidebar-gruppe"><summary>Anhänge</summary><ul><li data-kapitel="anhang-loesungen.html"><a href="anhang-loesungen.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Anhang A: Lösungen zu allen Übungsaufgaben</span></a></li><li data-kapitel="anhang-modellierungsmuster.html"><a href="anhang-modellierungsmuster.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Anhang B: Katalog der Modellierungsmuster</span></a></li><li data-kapitel="anhang-fehlerdiagnose.html"><a href="anhang-fehlerdiagnose.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Anhang C: Fehlerdiagnose-Handbuch</span></a></li><li data-kapitel="anhang-spickzettel.html"><a href="anhang-spickzettel.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Anhang D: Spickzettel der Solver</span></a></li><li data-kapitel="anhang-glossar-literatur.html"><a href="anhang-glossar-literatur.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Anhang E: Glossar und Literatur</span></a></li></ul></details><ul class="sidebar-extra"><li><a href="programme.html"><svg class="icon" aria-hidden="true"><use href="#icon-book"></use></svg> Beispielprogramme</a></li><li><a href="stichwortverzeichnis.html"><svg class="icon" aria-hidden="true"><use href="#icon-search"></use></svg> Stichwortverzeichnis</a></li><li><a href="gesamtdokument.html"><svg class="icon" aria-hidden="true"><use href="#icon-external-link"></use></svg> Gesamtdokument (eine Seite)</a></li><li><a href="Operations_Research_mit_Python_Version_04.pdf" download><svg class="icon" aria-hidden="true"><use href="#icon-download"></use></svg> Download als PDF</a></li></ul></div></nav>
+  <nav class="sidebar" id="sidebar" aria-label="Kapitelnavigation"><div class="sidebar-inhalt"><details class="sidebar-gruppe"><summary>Einstieg</summary><ul><li data-kapitel="vorwort.html"><a href="vorwort.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Vorwort & Lesehilfe</span></a></li><li data-kapitel="notation.html"><a href="notation.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Notation & Abkürzungen</span></a></li></ul></details><details class="sidebar-gruppe"><summary>Teil I: Grundlagen des Operations Research</summary><ul><li data-kapitel="einfuehrung.html"><a href="einfuehrung.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 1: Einführung in Operations Research — Vom Ursprung zur mathematischen Entscheidungsfindung</span></a></li><li data-kapitel="fundament.html"><a href="fundament.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 2: Das mathematische Fundament — Vektoren, Matrizen, Konvexität</span></a></li><li data-kapitel="oekosystem.html"><a href="oekosystem.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 3: Das Python-Ökosystem für OR — Solver, Bindings und Modellierungsschichten</span></a></li><li data-kapitel="modellierung.html"><a href="modellierung.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 4: Vom Management-Wunsch zum Modell</span></a></li><li data-kapitel="synthese-grundlagen.html"><a href="synthese-grundlagen.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Synthese Teil I</span></a></li></ul></details><details class="sidebar-gruppe" open><summary>Teil II: Die Kernverfahren der deterministischen Optimierung</summary><ul><li data-kapitel="lp.html"><a href="lp.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 5: Lineare Programmierung — Simplex, Dualität und Schattenpreise</span></a></li><li data-kapitel="milp.html" class="aktiv"><a href="milp.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 6: Gemischt-ganzzahlige Optimierung — Diskrete Entscheidungen und Branch-and-Bound</span></a></li><li data-kapitel="cpsat.html"><a href="cpsat.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 7: Constraint Programming mit CP-SAT — Logik, Scheduling und Zuweisung</span></a></li><li data-kapitel="graphen.html"><a href="graphen.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 8: Graphen, Flüsse und Touren — Min-Cost-Flow, Matching und VRP</span></a></li><li data-kapitel="metaheuristiken.html"><a href="metaheuristiken.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 9: Metaheuristiken — wenn der exakte Solver aussteigt</span></a></li><li data-kapitel="dekomposition.html"><a href="dekomposition.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 10: Spaltengenerierung — das Modell umbauen statt die Lösung raten</span></a></li><li data-kapitel="synthese-kernverfahren.html"><a href="synthese-kernverfahren.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Synthese Teil II</span></a></li></ul></details><details class="sidebar-gruppe"><summary>Teil III: Nichtlinearität, Unsicherheit und mehrperiodige Dynamik</summary><ul><li data-kapitel="qp-nlp.html"><a href="qp-nlp.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 11: Quadratische und nichtlineare Optimierung — KKT, Lagrange, Konvexität</span></a></li><li data-kapitel="unsicherheit.html"><a href="unsicherheit.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 12: Optimierung unter Unsicherheit — Monte-Carlo, Stochastik, Robustheit</span></a></li><li data-kapitel="dynamische-programmierung.html"><a href="dynamische-programmierung.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 13: Dynamische Programmierung — Die Bellman-Gleichung und Order-Execution</span></a></li><li data-kapitel="mehrziel.html"><a href="mehrziel.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 14: Mehrere Ziele — Pareto-Fronten statt Gewichte</span></a></li><li data-kapitel="prognose.html"><a href="prognose.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 15: Predict-then-Optimize — die bessere Prognose, die schlechtere Entscheidung</span></a></li><li data-kapitel="synthese-nichtlinear.html"><a href="synthese-nichtlinear.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Synthese Teil III</span></a></li></ul></details><details class="sidebar-gruppe"><summary>Teil IV: Anwendungen — Energiewirtschaft und Finanzmärkte</summary><ul><li data-kapitel="bruecke.html"><a href="bruecke.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 16: Die Strukturbrücke — dieselbe Mathematik, zwei Welten</span></a></li><li data-kapitel="supplychain.html"><a href="supplychain.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 17: Supply-Chain und Energieeinsatz unter Unsicherheit</span></a></li><li data-kapitel="finanzdaten.html"><a href="finanzdaten.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 18: Finanzdaten-Modellierung — Renditen, Kovarianz und Shrinkage</span></a></li><li data-kapitel="markowitz.html"><a href="markowitz.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 19: Die moderne Portfoliotheorie nach Markowitz</span></a></li><li data-kapitel="cvar.html"><a href="cvar.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 20: Tail-Risiko, CVaR und Transaktionskosten</span></a></li><li data-kapitel="handelsmaschine.html"><a href="handelsmaschine.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 21: Die vollständige quantitative Handelsmaschine</span></a></li><li data-kapitel="synthese-anwendungen.html"><a href="synthese-anwendungen.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Synthese Teil IV</span></a></li></ul></details><details class="sidebar-gruppe"><summary>Teil V: Praxis</summary><ul><li data-kapitel="praxisfallen.html"><a href="praxisfallen.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 22: Praxisfallen und der Weg zum produktiven Einsatz</span></a></li><li data-kapitel="testing.html"><a href="testing.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 23: Testen, Messen, Ausliefern</span></a></li><li data-kapitel="synthese-praxis.html"><a href="synthese-praxis.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Synthese Teil V</span></a></li><li data-kapitel="projektwerkstatt.html"><a href="projektwerkstatt.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Projektwerkstatt</span></a></li></ul></details><details class="sidebar-gruppe"><summary>Anhänge</summary><ul><li data-kapitel="anhang-loesungen.html"><a href="anhang-loesungen.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Anhang A: Lösungen zu allen Übungsaufgaben</span></a></li><li data-kapitel="anhang-modellierungsmuster.html"><a href="anhang-modellierungsmuster.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Anhang B: Katalog der Modellierungsmuster</span></a></li><li data-kapitel="anhang-fehlerdiagnose.html"><a href="anhang-fehlerdiagnose.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Anhang C: Fehlerdiagnose-Handbuch</span></a></li><li data-kapitel="anhang-spickzettel.html"><a href="anhang-spickzettel.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Anhang D: Spickzettel der Solver</span></a></li><li data-kapitel="anhang-glossar-literatur.html"><a href="anhang-glossar-literatur.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Anhang E: Glossar und Literatur</span></a></li></ul></details><ul class="sidebar-extra"><li><a href="programme.html"><svg class="icon" aria-hidden="true"><use href="#icon-book"></use></svg> Beispielprogramme</a></li><li><a href="stichwortverzeichnis.html"><svg class="icon" aria-hidden="true"><use href="#icon-search"></use></svg> Stichwortverzeichnis</a></li><li><a href="gesamtdokument.html"><svg class="icon" aria-hidden="true"><use href="#icon-external-link"></use></svg> Gesamtdokument (eine Seite)</a></li><li><a href="Operations_Research_mit_Python_Version_04.pdf" download><svg class="icon" aria-hidden="true"><use href="#icon-download"></use></svg> Download als PDF</a></li></ul></div></nav>
   <main class="content">
     <nav class="breadcrumb" aria-label="Breadcrumb"><a href="index.html">Start</a> › <span>Teil II</span> › <span>Kapitel 6: Gemischt-ganzzahlige Optimierung — Diskrete Entscheidungen und Branch-and-Bound</span></nav>
     <nav class="prev-next"><a class="prev-next-knopf prev-next-prev" href="lp.html"><svg class="icon" aria-hidden="true"><use href="#icon-chevron-left"></use></svg><span><small>Zurück</small>Kapitel 5: Lineare Programmierung — Simplex, Dualität und Schattenpreise</span></a><a class="prev-next-knopf prev-next-next" href="cpsat.html"><span><small>Weiter</small>Kapitel 7: Constraint Programming mit CP-SAT — Logik, Scheduling und Zuweisung</span><svg class="icon" aria-hidden="true"><use href="#icon-chevron-right"></use></svg></a></nav>
@@ -592,7 +592,7 @@ L\,y_i \le x_i &amp;\le U\,y_i &amp;&amp; \forall i \quad \text{(semikontinuierl
 </blockquote>
 <blockquote>
 <p><strong>📎 Zwei Bausteine aus <code>or_kern.py</code></strong></p>
-<p>Das Programm wertet den Solver nicht über <code>ergebnis.success</code> aus, sondern über <code>status_von_scipy()</code> und das <code>Loesung</code>-Objekt aus dem gemeinsamen Unterbau (<a href="praxisfallen.html#sec:praxisfallen-or-kern">Abschnitt 22.5</a>). Der Unterschied ist kein Schönheitsfehler:</p>
+<p>Das Programm wertet den Solver nicht über <code>ergebnis.success</code> aus, sondern über <code>status_von_scipy()</code> und das <code>Loesung</code>-Objekt aus dem gemeinsamen Unterbau (<a href="praxisfallen.html#sec:praxisfallen-or-kern">Abschnitt 22.6</a>). Der Unterschied ist kein Schönheitsfehler:</p>
 <ul>
 <li><code>success</code> ist <strong>ein Bit</strong>. Es unterscheidet nicht zwischen „es gibt keine Lösung“ (Modellfehler — das Modell muss geändert werden) und „die Zeit war um“ (Rechenproblem — mehr Zeit oder ein besserer Startwert hilft). Das sind zwei völlig verschiedene Nachrichten an völlig verschiedene Adressaten.</li>
 <li>Das <code>Loesung</code>-Objekt führt neben dem Zielwert die <strong>Schranke</strong> mit und rechnet daraus den Gap aus. Erst dadurch steht in der Ausgabe <code>Gap: 0.00%</code> — die Zusage, dass hier wirklich das Optimum gefunden <em>und bewiesen</em> wurde und nicht bloß irgendetwas.</li>
@@ -863,7 +863,7 @@ Abnahmepruefung: alle Nebenbedingungen geprueft und eingehalten.
 </tr>
 <tr class="even">
 <td><code>status = status_von_scipy(ergebnis)</code></td>
-<td>übersetzt den SciPy-Rückgabewert in die gemeinsame Sprache aus <a href="praxisfallen.html#sec:praxisfallen-or-kern">Abschnitt 22.5</a> — die drei <code>if</code>-Zweige darunter behandeln Modellfehler, Abbruch ohne Lösung und „zulässig, aber unbewiesen“ getrennt</td>
+<td>übersetzt den SciPy-Rückgabewert in die gemeinsame Sprache aus <a href="praxisfallen.html#sec:praxisfallen-or-kern">Abschnitt 22.6</a> — die drei <code>if</code>-Zweige darunter behandeln Modellfehler, Abbruch ohne Lösung und „zulässig, aber unbewiesen“ getrennt</td>
 </tr>
 <tr class="odd">
 <td><code>schranke=-ergebnis.mip_dual_bound</code></td>
@@ -1342,68 +1342,69 @@ mit Warm-Start                 8.44s       150     69,134.14</code></pre>
 <span id="cb12-83"><a href="#cb12-83" aria-hidden="true" tabindex="-1"></a></span>
 <span id="cb12-84"><a href="#cb12-84" aria-hidden="true" tabindex="-1"></a>    loeser <span class="op">=</span> cp_model.CpSolver()</span>
 <span id="cb12-85"><a href="#cb12-85" aria-hidden="true" tabindex="-1"></a>    loeser.parameters.max_time_in_seconds <span class="op">=</span> zeitlimit</span>
-<span id="cb12-86"><a href="#cb12-86" aria-hidden="true" tabindex="-1"></a>    <span class="co"># Ein Arbeiter und fester Startwert, damit die Messung reproduzierbar ist.</span></span>
-<span id="cb12-87"><a href="#cb12-87" aria-hidden="true" tabindex="-1"></a>    <span class="co"># Im Produktivbetrieb laesst man beides auf den Standardwerten.</span></span>
-<span id="cb12-88"><a href="#cb12-88" aria-hidden="true" tabindex="-1"></a>    loeser.parameters.num_workers <span class="op">=</span> <span class="dv">1</span></span>
-<span id="cb12-89"><a href="#cb12-89" aria-hidden="true" tabindex="-1"></a>    loeser.parameters.random_seed <span class="op">=</span> <span class="dv">1</span></span>
-<span id="cb12-90"><a href="#cb12-90" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb12-91"><a href="#cb12-91" aria-hidden="true" tabindex="-1"></a>    t0 <span class="op">=</span> time.perf_counter()</span>
-<span id="cb12-92"><a href="#cb12-92" aria-hidden="true" tabindex="-1"></a>    status <span class="op">=</span> loeser.Solve(modell)</span>
-<span id="cb12-93"><a href="#cb12-93" aria-hidden="true" tabindex="-1"></a>    dauer_s <span class="op">=</span> time.perf_counter() <span class="op">-</span> t0</span>
-<span id="cb12-94"><a href="#cb12-94" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb12-95"><a href="#cb12-95" aria-hidden="true" tabindex="-1"></a>    <span class="cf">if</span> status <span class="kw">not</span> <span class="kw">in</span> (cp_model.OPTIMAL, cp_model.FEASIBLE):</span>
-<span id="cb12-96"><a href="#cb12-96" aria-hidden="true" tabindex="-1"></a>        <span class="cf">raise</span> <span class="pp">RuntimeError</span>(<span class="ss">f&quot;Kein Plan gefunden: </span><span class="sc">{</span>loeser<span class="sc">.</span>StatusName(status)<span class="sc">}</span><span class="ss">&quot;</span>)</span>
-<span id="cb12-97"><a href="#cb12-97" aria-hidden="true" tabindex="-1"></a>    <span class="cf">return</span> loeser.StatusName(status), <span class="bu">int</span>(loeser.ObjectiveValue()), dauer_s</span>
-<span id="cb12-98"><a href="#cb12-98" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb12-86"><a href="#cb12-86" aria-hidden="true" tabindex="-1"></a>    <span class="co"># Ein Arbeiter und fester Startwert, damit die Messung reproduzierbar ist -</span></span>
+<span id="cb12-87"><a href="#cb12-87" aria-hidden="true" tabindex="-1"></a>    <span class="co"># der Seed allein genuegt dafuer NICHT (Kapitel Constraint Programming).</span></span>
+<span id="cb12-88"><a href="#cb12-88" aria-hidden="true" tabindex="-1"></a>    <span class="co"># Im Produktivbetrieb laesst man beides auf den Standardwerten.</span></span>
+<span id="cb12-89"><a href="#cb12-89" aria-hidden="true" tabindex="-1"></a>    loeser.parameters.num_workers <span class="op">=</span> <span class="dv">1</span></span>
+<span id="cb12-90"><a href="#cb12-90" aria-hidden="true" tabindex="-1"></a>    loeser.parameters.random_seed <span class="op">=</span> <span class="dv">1</span></span>
+<span id="cb12-91"><a href="#cb12-91" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb12-92"><a href="#cb12-92" aria-hidden="true" tabindex="-1"></a>    t0 <span class="op">=</span> time.perf_counter()</span>
+<span id="cb12-93"><a href="#cb12-93" aria-hidden="true" tabindex="-1"></a>    status <span class="op">=</span> loeser.Solve(modell)</span>
+<span id="cb12-94"><a href="#cb12-94" aria-hidden="true" tabindex="-1"></a>    dauer_s <span class="op">=</span> time.perf_counter() <span class="op">-</span> t0</span>
+<span id="cb12-95"><a href="#cb12-95" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb12-96"><a href="#cb12-96" aria-hidden="true" tabindex="-1"></a>    <span class="cf">if</span> status <span class="kw">not</span> <span class="kw">in</span> (cp_model.OPTIMAL, cp_model.FEASIBLE):</span>
+<span id="cb12-97"><a href="#cb12-97" aria-hidden="true" tabindex="-1"></a>        <span class="cf">raise</span> <span class="pp">RuntimeError</span>(<span class="ss">f&quot;Kein Plan gefunden: </span><span class="sc">{</span>loeser<span class="sc">.</span>StatusName(status)<span class="sc">}</span><span class="ss">&quot;</span>)</span>
+<span id="cb12-98"><a href="#cb12-98" aria-hidden="true" tabindex="-1"></a>    <span class="cf">return</span> loeser.StatusName(status), <span class="bu">int</span>(loeser.ObjectiveValue()), dauer_s</span>
 <span id="cb12-99"><a href="#cb12-99" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb12-100"><a href="#cb12-100" aria-hidden="true" tabindex="-1"></a><span class="cf">if</span> <span class="va">__name__</span> <span class="op">==</span> <span class="st">&quot;__main__&quot;</span>:</span>
-<span id="cb12-101"><a href="#cb12-101" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;=&quot;</span> <span class="op">*</span> <span class="dv">78</span>)</span>
-<span id="cb12-102"><a href="#cb12-102" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;  WARM-START: WENN DIE HEURISTIK MEHR WEISS ALS DER SOLVER&quot;</span>)</span>
-<span id="cb12-103"><a href="#cb12-103" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;=&quot;</span> <span class="op">*</span> <span class="dv">78</span>)</span>
-<span id="cb12-104"><a href="#cb12-104" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;Lastverteilung: Auftraege auf gleichartige Maschinen verteilen,&quot;</span>)</span>
-<span id="cb12-105"><a href="#cb12-105" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;sodass die letzte Maschine so frueh wie moeglich fertig wird.</span><span class="ch">\n</span><span class="st">&quot;</span>)</span>
-<span id="cb12-106"><a href="#cb12-106" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb12-107"><a href="#cb12-107" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;</span><span class="sc">{</span><span class="st">&#39;Instanz&#39;</span><span class="sc">:&lt;22}</span><span class="ss"> </span><span class="sc">{</span><span class="st">&#39;Variante&#39;</span><span class="sc">:&lt;22}</span><span class="ss"> </span><span class="sc">{</span><span class="st">&#39;Makespan&#39;</span><span class="sc">:&gt;9}</span><span class="ss"> </span><span class="sc">{</span><span class="st">&#39;Zeit&#39;</span><span class="sc">:&gt;9}</span><span class="ss"> &quot;</span></span>
-<span id="cb12-108"><a href="#cb12-108" aria-hidden="true" tabindex="-1"></a>          <span class="ss">f&quot;</span><span class="sc">{</span><span class="st">&#39;Faktor&#39;</span><span class="sc">:&gt;8}</span><span class="ss">&quot;</span>)</span>
-<span id="cb12-109"><a href="#cb12-109" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;-&quot;</span> <span class="op">*</span> <span class="dv">78</span>)</span>
-<span id="cb12-110"><a href="#cb12-110" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb12-111"><a href="#cb12-111" aria-hidden="true" tabindex="-1"></a>    <span class="cf">for</span> n_auftraege, n_maschinen <span class="kw">in</span> [(<span class="dv">60</span>, <span class="dv">7</span>), (<span class="dv">80</span>, <span class="dv">9</span>)]:</span>
-<span id="cb12-112"><a href="#cb12-112" aria-hidden="true" tabindex="-1"></a>        dauer <span class="op">=</span> RNG.integers(<span class="dv">10</span>, <span class="dv">90</span>, n_auftraege)</span>
-<span id="cb12-113"><a href="#cb12-113" aria-hidden="true" tabindex="-1"></a>        start, lpt_wert <span class="op">=</span> lpt_heuristik(dauer, n_maschinen)</span>
-<span id="cb12-114"><a href="#cb12-114" aria-hidden="true" tabindex="-1"></a>        untere_schranke <span class="op">=</span> dauer.<span class="bu">sum</span>() <span class="op">/</span> n_maschinen</span>
-<span id="cb12-115"><a href="#cb12-115" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb12-116"><a href="#cb12-116" aria-hidden="true" tabindex="-1"></a>        instanz <span class="op">=</span> <span class="ss">f&quot;</span><span class="sc">{</span>n_auftraege<span class="sc">}</span><span class="ss"> Auftr., </span><span class="sc">{</span>n_maschinen<span class="sc">}</span><span class="ss"> Masch.&quot;</span></span>
-<span id="cb12-117"><a href="#cb12-117" aria-hidden="true" tabindex="-1"></a>        <span class="bu">print</span>(<span class="ss">f&quot;</span><span class="sc">{</span>instanz<span class="sc">:&lt;22}</span><span class="ss"> </span><span class="sc">{</span><span class="st">&#39;LPT-Heuristik&#39;</span><span class="sc">:&lt;22}</span><span class="ss"> </span><span class="sc">{</span>lpt_wert<span class="sc">:&gt;9}</span><span class="ss"> &quot;</span></span>
-<span id="cb12-118"><a href="#cb12-118" aria-hidden="true" tabindex="-1"></a>              <span class="ss">f&quot;</span><span class="sc">{</span><span class="st">&#39;&lt; 0.001s&#39;</span><span class="sc">:&gt;9}</span><span class="ss"> </span><span class="sc">{</span><span class="st">&#39;&#39;</span><span class="sc">:&gt;8}</span><span class="ss">&quot;</span>)</span>
-<span id="cb12-119"><a href="#cb12-119" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb12-120"><a href="#cb12-120" aria-hidden="true" tabindex="-1"></a>        _, ziel_kalt, zeit_kalt <span class="op">=</span> loese(dauer, n_maschinen, <span class="fl">60.0</span>)</span>
-<span id="cb12-121"><a href="#cb12-121" aria-hidden="true" tabindex="-1"></a>        <span class="bu">print</span>(<span class="ss">f&quot;</span><span class="sc">{</span><span class="st">&#39;&#39;</span><span class="sc">:&lt;22}</span><span class="ss"> </span><span class="sc">{</span><span class="st">&#39;CP-SAT kalt&#39;</span><span class="sc">:&lt;22}</span><span class="ss"> </span><span class="sc">{</span>ziel_kalt<span class="sc">:&gt;9}</span><span class="ss"> &quot;</span></span>
-<span id="cb12-122"><a href="#cb12-122" aria-hidden="true" tabindex="-1"></a>              <span class="ss">f&quot;</span><span class="sc">{</span>zeit_kalt<span class="sc">:&gt;8.3f}</span><span class="ss">s </span><span class="sc">{</span><span class="st">&#39;1,0x&#39;</span><span class="sc">:&gt;8}</span><span class="ss">&quot;</span>)</span>
-<span id="cb12-123"><a href="#cb12-123" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb12-124"><a href="#cb12-124" aria-hidden="true" tabindex="-1"></a>        _, ziel_warm, zeit_warm <span class="op">=</span> loese(dauer, n_maschinen, <span class="fl">60.0</span>, hinweis<span class="op">=</span>start)</span>
-<span id="cb12-125"><a href="#cb12-125" aria-hidden="true" tabindex="-1"></a>        <span class="bu">print</span>(<span class="ss">f&quot;</span><span class="sc">{</span><span class="st">&#39;&#39;</span><span class="sc">:&lt;22}</span><span class="ss"> </span><span class="sc">{</span><span class="st">&#39;CP-SAT + LPT-Hinweis&#39;</span><span class="sc">:&lt;22}</span><span class="ss"> </span><span class="sc">{</span>ziel_warm<span class="sc">:&gt;9}</span><span class="ss"> &quot;</span></span>
-<span id="cb12-126"><a href="#cb12-126" aria-hidden="true" tabindex="-1"></a>              <span class="ss">f&quot;</span><span class="sc">{</span>zeit_warm<span class="sc">:&gt;8.3f}</span><span class="ss">s </span><span class="sc">{</span>zeit_kalt <span class="op">/</span> zeit_warm<span class="sc">:&gt;7.1f}</span><span class="ss">x&quot;</span>)</span>
-<span id="cb12-127"><a href="#cb12-127" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb12-128"><a href="#cb12-128" aria-hidden="true" tabindex="-1"></a>        <span class="cf">assert</span> ziel_kalt <span class="op">==</span> ziel_warm, <span class="op">\</span></span>
-<span id="cb12-129"><a href="#cb12-129" aria-hidden="true" tabindex="-1"></a>            <span class="st">&quot;Der Hinweis darf das Optimum nicht veraendern - nur den Weg dorthin!&quot;</span></span>
-<span id="cb12-130"><a href="#cb12-130" aria-hidden="true" tabindex="-1"></a>        <span class="bu">print</span>(<span class="ss">f&quot;</span><span class="sc">{</span><span class="st">&#39;&#39;</span><span class="sc">:&lt;22}</span><span class="ss"> </span><span class="sc">{</span><span class="st">&#39;untere Schranke&#39;</span><span class="sc">:&lt;22}</span><span class="ss"> </span><span class="sc">{</span>untere_schranke<span class="sc">:&gt;9.1f}</span><span class="ss">&quot;</span>)</span>
-<span id="cb12-131"><a href="#cb12-131" aria-hidden="true" tabindex="-1"></a>        <span class="bu">print</span>(<span class="st">&quot;-&quot;</span> <span class="op">*</span> <span class="dv">78</span>)</span>
-<span id="cb12-132"><a href="#cb12-132" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb12-133"><a href="#cb12-133" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;</span><span class="ch">\n</span><span class="st">Drei Beobachtungen:&quot;</span>)</span>
-<span id="cb12-134"><a href="#cb12-134" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;1. Der Hinweis aendert das ERGEBNIS nicht - beide Laeufe finden&quot;</span>)</span>
-<span id="cb12-135"><a href="#cb12-135" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;   dasselbe Optimum. Er aendert nur, wie lange der Beweis dauert.&quot;</span>)</span>
-<span id="cb12-136"><a href="#cb12-136" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;   Genau deshalb ist ein Warm-Start ungefaehrlich: Ein schlechter&quot;</span>)</span>
-<span id="cb12-137"><a href="#cb12-137" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;   Hinweis kostet Zeit, er verfaelscht aber nie die Loesung.&quot;</span>)</span>
-<span id="cb12-138"><a href="#cb12-138" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;2. Die LPT-Heuristik liegt schon sehr nah am Optimum. Ihr Wert fuer&quot;</span>)</span>
-<span id="cb12-139"><a href="#cb12-139" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;   den Solver liegt weniger in der Qualitaet als darin, dass sie&quot;</span>)</span>
-<span id="cb12-140"><a href="#cb12-140" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;   SOFORT da ist - der Solver kann von Beginn an alles verwerfen,&quot;</span>)</span>
-<span id="cb12-141"><a href="#cb12-141" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;   was schlechter ist.&quot;</span>)</span>
-<span id="cb12-142"><a href="#cb12-142" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;3. Der Faktor schwankt von Instanz zu Instanz - oben 2,2x und 1,4x -&quot;</span>)</span>
-<span id="cb12-143"><a href="#cb12-143" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;   und laesst sich NICHT aus der Problemgroesse ableiten. Er haengt&quot;</span>)</span>
-<span id="cb12-144"><a href="#cb12-144" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;   davon ab, wie schnell der Solver von allein eine vergleichbar gute&quot;</span>)</span>
-<span id="cb12-145"><a href="#cb12-145" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;   Loesung findet. Das ist die eigentliche Lehre: Ein Warm-Start ist&quot;</span>)</span>
-<span id="cb12-146"><a href="#cb12-146" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;   eine Messung wert, keine Glaubensfrage.&quot;</span>)</span>
-<span id="cb12-147"><a href="#cb12-147" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;=&quot;</span> <span class="op">*</span> <span class="dv">78</span>)</span></code></pre></div>
+<span id="cb12-100"><a href="#cb12-100" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb12-101"><a href="#cb12-101" aria-hidden="true" tabindex="-1"></a><span class="cf">if</span> <span class="va">__name__</span> <span class="op">==</span> <span class="st">&quot;__main__&quot;</span>:</span>
+<span id="cb12-102"><a href="#cb12-102" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;=&quot;</span> <span class="op">*</span> <span class="dv">78</span>)</span>
+<span id="cb12-103"><a href="#cb12-103" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;  WARM-START: WENN DIE HEURISTIK MEHR WEISS ALS DER SOLVER&quot;</span>)</span>
+<span id="cb12-104"><a href="#cb12-104" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;=&quot;</span> <span class="op">*</span> <span class="dv">78</span>)</span>
+<span id="cb12-105"><a href="#cb12-105" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;Lastverteilung: Auftraege auf gleichartige Maschinen verteilen,&quot;</span>)</span>
+<span id="cb12-106"><a href="#cb12-106" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;sodass die letzte Maschine so frueh wie moeglich fertig wird.</span><span class="ch">\n</span><span class="st">&quot;</span>)</span>
+<span id="cb12-107"><a href="#cb12-107" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb12-108"><a href="#cb12-108" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;</span><span class="sc">{</span><span class="st">&#39;Instanz&#39;</span><span class="sc">:&lt;22}</span><span class="ss"> </span><span class="sc">{</span><span class="st">&#39;Variante&#39;</span><span class="sc">:&lt;22}</span><span class="ss"> </span><span class="sc">{</span><span class="st">&#39;Makespan&#39;</span><span class="sc">:&gt;9}</span><span class="ss"> </span><span class="sc">{</span><span class="st">&#39;Zeit&#39;</span><span class="sc">:&gt;9}</span><span class="ss"> &quot;</span></span>
+<span id="cb12-109"><a href="#cb12-109" aria-hidden="true" tabindex="-1"></a>          <span class="ss">f&quot;</span><span class="sc">{</span><span class="st">&#39;Faktor&#39;</span><span class="sc">:&gt;8}</span><span class="ss">&quot;</span>)</span>
+<span id="cb12-110"><a href="#cb12-110" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;-&quot;</span> <span class="op">*</span> <span class="dv">78</span>)</span>
+<span id="cb12-111"><a href="#cb12-111" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb12-112"><a href="#cb12-112" aria-hidden="true" tabindex="-1"></a>    <span class="cf">for</span> n_auftraege, n_maschinen <span class="kw">in</span> [(<span class="dv">60</span>, <span class="dv">7</span>), (<span class="dv">80</span>, <span class="dv">9</span>)]:</span>
+<span id="cb12-113"><a href="#cb12-113" aria-hidden="true" tabindex="-1"></a>        dauer <span class="op">=</span> RNG.integers(<span class="dv">10</span>, <span class="dv">90</span>, n_auftraege)</span>
+<span id="cb12-114"><a href="#cb12-114" aria-hidden="true" tabindex="-1"></a>        start, lpt_wert <span class="op">=</span> lpt_heuristik(dauer, n_maschinen)</span>
+<span id="cb12-115"><a href="#cb12-115" aria-hidden="true" tabindex="-1"></a>        untere_schranke <span class="op">=</span> dauer.<span class="bu">sum</span>() <span class="op">/</span> n_maschinen</span>
+<span id="cb12-116"><a href="#cb12-116" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb12-117"><a href="#cb12-117" aria-hidden="true" tabindex="-1"></a>        instanz <span class="op">=</span> <span class="ss">f&quot;</span><span class="sc">{</span>n_auftraege<span class="sc">}</span><span class="ss"> Auftr., </span><span class="sc">{</span>n_maschinen<span class="sc">}</span><span class="ss"> Masch.&quot;</span></span>
+<span id="cb12-118"><a href="#cb12-118" aria-hidden="true" tabindex="-1"></a>        <span class="bu">print</span>(<span class="ss">f&quot;</span><span class="sc">{</span>instanz<span class="sc">:&lt;22}</span><span class="ss"> </span><span class="sc">{</span><span class="st">&#39;LPT-Heuristik&#39;</span><span class="sc">:&lt;22}</span><span class="ss"> </span><span class="sc">{</span>lpt_wert<span class="sc">:&gt;9}</span><span class="ss"> &quot;</span></span>
+<span id="cb12-119"><a href="#cb12-119" aria-hidden="true" tabindex="-1"></a>              <span class="ss">f&quot;</span><span class="sc">{</span><span class="st">&#39;&lt; 0.001s&#39;</span><span class="sc">:&gt;9}</span><span class="ss"> </span><span class="sc">{</span><span class="st">&#39;&#39;</span><span class="sc">:&gt;8}</span><span class="ss">&quot;</span>)</span>
+<span id="cb12-120"><a href="#cb12-120" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb12-121"><a href="#cb12-121" aria-hidden="true" tabindex="-1"></a>        _, ziel_kalt, zeit_kalt <span class="op">=</span> loese(dauer, n_maschinen, <span class="fl">60.0</span>)</span>
+<span id="cb12-122"><a href="#cb12-122" aria-hidden="true" tabindex="-1"></a>        <span class="bu">print</span>(<span class="ss">f&quot;</span><span class="sc">{</span><span class="st">&#39;&#39;</span><span class="sc">:&lt;22}</span><span class="ss"> </span><span class="sc">{</span><span class="st">&#39;CP-SAT kalt&#39;</span><span class="sc">:&lt;22}</span><span class="ss"> </span><span class="sc">{</span>ziel_kalt<span class="sc">:&gt;9}</span><span class="ss"> &quot;</span></span>
+<span id="cb12-123"><a href="#cb12-123" aria-hidden="true" tabindex="-1"></a>              <span class="ss">f&quot;</span><span class="sc">{</span>zeit_kalt<span class="sc">:&gt;8.3f}</span><span class="ss">s </span><span class="sc">{</span><span class="st">&#39;1,0x&#39;</span><span class="sc">:&gt;8}</span><span class="ss">&quot;</span>)</span>
+<span id="cb12-124"><a href="#cb12-124" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb12-125"><a href="#cb12-125" aria-hidden="true" tabindex="-1"></a>        _, ziel_warm, zeit_warm <span class="op">=</span> loese(dauer, n_maschinen, <span class="fl">60.0</span>, hinweis<span class="op">=</span>start)</span>
+<span id="cb12-126"><a href="#cb12-126" aria-hidden="true" tabindex="-1"></a>        <span class="bu">print</span>(<span class="ss">f&quot;</span><span class="sc">{</span><span class="st">&#39;&#39;</span><span class="sc">:&lt;22}</span><span class="ss"> </span><span class="sc">{</span><span class="st">&#39;CP-SAT + LPT-Hinweis&#39;</span><span class="sc">:&lt;22}</span><span class="ss"> </span><span class="sc">{</span>ziel_warm<span class="sc">:&gt;9}</span><span class="ss"> &quot;</span></span>
+<span id="cb12-127"><a href="#cb12-127" aria-hidden="true" tabindex="-1"></a>              <span class="ss">f&quot;</span><span class="sc">{</span>zeit_warm<span class="sc">:&gt;8.3f}</span><span class="ss">s </span><span class="sc">{</span>zeit_kalt <span class="op">/</span> zeit_warm<span class="sc">:&gt;7.1f}</span><span class="ss">x&quot;</span>)</span>
+<span id="cb12-128"><a href="#cb12-128" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb12-129"><a href="#cb12-129" aria-hidden="true" tabindex="-1"></a>        <span class="cf">assert</span> ziel_kalt <span class="op">==</span> ziel_warm, <span class="op">\</span></span>
+<span id="cb12-130"><a href="#cb12-130" aria-hidden="true" tabindex="-1"></a>            <span class="st">&quot;Der Hinweis darf das Optimum nicht veraendern - nur den Weg dorthin!&quot;</span></span>
+<span id="cb12-131"><a href="#cb12-131" aria-hidden="true" tabindex="-1"></a>        <span class="bu">print</span>(<span class="ss">f&quot;</span><span class="sc">{</span><span class="st">&#39;&#39;</span><span class="sc">:&lt;22}</span><span class="ss"> </span><span class="sc">{</span><span class="st">&#39;untere Schranke&#39;</span><span class="sc">:&lt;22}</span><span class="ss"> </span><span class="sc">{</span>untere_schranke<span class="sc">:&gt;9.1f}</span><span class="ss">&quot;</span>)</span>
+<span id="cb12-132"><a href="#cb12-132" aria-hidden="true" tabindex="-1"></a>        <span class="bu">print</span>(<span class="st">&quot;-&quot;</span> <span class="op">*</span> <span class="dv">78</span>)</span>
+<span id="cb12-133"><a href="#cb12-133" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb12-134"><a href="#cb12-134" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;</span><span class="ch">\n</span><span class="st">Drei Beobachtungen:&quot;</span>)</span>
+<span id="cb12-135"><a href="#cb12-135" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;1. Der Hinweis aendert das ERGEBNIS nicht - beide Laeufe finden&quot;</span>)</span>
+<span id="cb12-136"><a href="#cb12-136" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;   dasselbe Optimum. Er aendert nur, wie lange der Beweis dauert.&quot;</span>)</span>
+<span id="cb12-137"><a href="#cb12-137" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;   Genau deshalb ist ein Warm-Start ungefaehrlich: Ein schlechter&quot;</span>)</span>
+<span id="cb12-138"><a href="#cb12-138" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;   Hinweis kostet Zeit, er verfaelscht aber nie die Loesung.&quot;</span>)</span>
+<span id="cb12-139"><a href="#cb12-139" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;2. Die LPT-Heuristik liegt schon sehr nah am Optimum. Ihr Wert fuer&quot;</span>)</span>
+<span id="cb12-140"><a href="#cb12-140" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;   den Solver liegt weniger in der Qualitaet als darin, dass sie&quot;</span>)</span>
+<span id="cb12-141"><a href="#cb12-141" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;   SOFORT da ist - der Solver kann von Beginn an alles verwerfen,&quot;</span>)</span>
+<span id="cb12-142"><a href="#cb12-142" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;   was schlechter ist.&quot;</span>)</span>
+<span id="cb12-143"><a href="#cb12-143" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;3. Der Faktor schwankt von Instanz zu Instanz - oben 2,2x und 1,4x -&quot;</span>)</span>
+<span id="cb12-144"><a href="#cb12-144" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;   und laesst sich NICHT aus der Problemgroesse ableiten. Er haengt&quot;</span>)</span>
+<span id="cb12-145"><a href="#cb12-145" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;   davon ab, wie schnell der Solver von allein eine vergleichbar gute&quot;</span>)</span>
+<span id="cb12-146"><a href="#cb12-146" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;   Loesung findet. Das ist die eigentliche Lehre: Ein Warm-Start ist&quot;</span>)</span>
+<span id="cb12-147"><a href="#cb12-147" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;   eine Messung wert, keine Glaubensfrage.&quot;</span>)</span>
+<span id="cb12-148"><a href="#cb12-148" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;=&quot;</span> <span class="op">*</span> <span class="dv">78</span>)</span></code></pre></div>
 <p><strong>Erwartete Ausgabe (Zeiten hardwareabhängig):</strong></p>
 <pre><code>==============================================================================
   WARM-START: WENN DIE HEURISTIK MEHR WEISS ALS DER SOLVER
@@ -1453,7 +1454,7 @@ Instanz                Variante                Makespan      Zeit   Faktor
 <p>Die Warnung „<span class="math inline">M</span> so klein wie möglich“ wird meist mit der Laufzeit begründet: schwache Relaxation, mehr Knoten. Das stimmt — und ist die <strong>harmlosere</strong> Hälfte der Wahrheit.</p>
 <div class="card card-denkfehler">
 <blockquote>
-<p><strong>🐛 Finde den Denkfehler 5.1: Elf Lager, die keine Fixkosten kosten</strong></p>
+<p><strong>🐛 Finde den Denkfehler: Elf Lager, die keine Fixkosten kosten</strong></p>
 <p>Ein Team plant Standorte: 12 mögliche Lager, 40 Kunden, Fixkosten je eröffnetem Lager. Für das Big-M in der Kopplung</p>
 <p><span class="math display">\sum_j x_{ij} \le M \cdot y_i</span></p>
 <p>setzt jemand „sicherheitshalber“ eine sehr große Zahl ein. Das Modell läuft durch und meldet Gesamtkosten von <strong>12 441,96 €</strong>. Mit einem knapp gewählten <span class="math inline">M</span> hatte dasselbe Modell zuvor 26 525,28 € gemeldet. Das Team freut sich über die Einsparung.</p>
@@ -1749,7 +1750,7 @@ funktioniert immer.
 <h2 id="sec:milp-quiz">6.11 Micro-Quiz</h2>
 <div class="card card-quiz">
 <blockquote>
-<p><strong>❓ Micro-Quiz 5: Drei Fragen zum Selbstcheck</strong></p>
+<p><strong>❓ Micro-Quiz 6: Drei Fragen zum Selbstcheck</strong></p>
 <p>Genau eine Antwort ist jeweils richtig. Auflösung in <a href="anhang-loesungen.html#quiz-loesung-milp">Anhang A</a>.</p>
 <p><strong>1. Ihr Solver meldet nach dem Zeitlimit: Incumbent 48 200 €, Schranke 47 100 €. Was berichten Sie dem Auftraggeber?</strong> (a) „Der Solver ist nicht fertig geworden, das Ergebnis ist unbrauchbar.“ (b) „Wir haben einen Plan für 48 200 €. Er ist garantiert höchstens 2,3 % teurer als das theoretisch bestmögliche.“ (c) „Der optimale Wert liegt bei 47 100 €, wir müssen den Plan nur noch dorthin verbessern.“</p>
 <p><strong>2. In Ihrem Fixkostenmodell ist <span class="math inline">M = 10^9</span>, die tatsächliche Anlagenkapazität beträgt 500. Welche Gefahr ist die größere?</strong> (a) Der Solver braucht mehr Knoten und wird langsamer. (b) Binärvariablen können bei Werten um <span class="math inline">10^{-8}</span> hängenbleiben, gelten dem Solver als 0 — und Anlagen produzieren, ohne dass ihre Fixkosten je verbucht werden. (c) Die Zielfunktion wird numerisch instabil und liefert negative Kosten.</p>
diff --git a/OR_HTML_04/modellierung.html b/OR_HTML_04/modellierung.html
index 87181ac..04c1a15 100644
--- a/OR_HTML_04/modellierung.html
+++ b/OR_HTML_04/modellierung.html
@@ -94,10 +94,10 @@
 </header>
 <div class="site-body">
   <div class="sidebar-overlay" id="sidebar-overlay" hidden></div>
-  <nav class="sidebar" id="sidebar" aria-label="Kapitelnavigation"><div class="sidebar-inhalt"><details class="sidebar-gruppe"><summary>Einstieg</summary><ul><li data-kapitel="vorwort.html"><a href="vorwort.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Vorwort & Lesehilfe</span></a></li><li data-kapitel="notation.html"><a href="notation.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Notation & Abkürzungen</span></a></li></ul></details><details class="sidebar-gruppe" open><summary>Teil I: Grundlagen des Operations Research</summary><ul><li data-kapitel="einfuehrung.html"><a href="einfuehrung.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 1: Einführung in Operations Research — Vom Ursprung zur mathematischen Entscheidungsfindung</span></a></li><li data-kapitel="fundament.html"><a href="fundament.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 2: Das mathematische Fundament — Vektoren, Matrizen, Konvexität</span></a></li><li data-kapitel="oekosystem.html"><a href="oekosystem.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 3: Das Python-Ökosystem für OR — Solver, Bindings und Modellierungsschichten</span></a></li><li data-kapitel="modellierung.html" class="aktiv"><a href="modellierung.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 4: Vom Management-Wunsch zum Modell</span></a></li></ul></details><details class="sidebar-gruppe"><summary>Teil II: Die Kernverfahren der deterministischen Optimierung</summary><ul><li data-kapitel="lp.html"><a href="lp.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 5: Lineare Programmierung — Simplex, Dualität und Schattenpreise</span></a></li><li data-kapitel="milp.html"><a href="milp.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 6: Gemischt-ganzzahlige Optimierung — Diskrete Entscheidungen und Branch-and-Bound</span></a></li><li data-kapitel="cpsat.html"><a href="cpsat.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 7: Constraint Programming mit CP-SAT — Logik, Scheduling und Zuweisung</span></a></li><li data-kapitel="graphen.html"><a href="graphen.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 8: Graphen, Flüsse und Touren — Min-Cost-Flow, Matching und VRP</span></a></li><li data-kapitel="metaheuristiken.html"><a href="metaheuristiken.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 9: Metaheuristiken — wenn der exakte Solver aussteigt</span></a></li><li data-kapitel="dekomposition.html"><a href="dekomposition.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 10: Spaltengenerierung — das Modell umbauen statt die Lösung raten</span></a></li></ul></details><details class="sidebar-gruppe"><summary>Teil III: Nichtlinearität, Unsicherheit und mehrperiodige Dynamik</summary><ul><li data-kapitel="qp-nlp.html"><a href="qp-nlp.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 11: Quadratische und nichtlineare Optimierung — KKT, Lagrange, Konvexität</span></a></li><li data-kapitel="unsicherheit.html"><a href="unsicherheit.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 12: Optimierung unter Unsicherheit — Monte-Carlo, Stochastik, Robustheit</span></a></li><li data-kapitel="dynamische-programmierung.html"><a href="dynamische-programmierung.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 13: Dynamische Programmierung — Die Bellman-Gleichung und Order-Execution</span></a></li><li data-kapitel="mehrziel.html"><a href="mehrziel.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 14: Mehrere Ziele — Pareto-Fronten statt Gewichte</span></a></li><li data-kapitel="prognose.html"><a href="prognose.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 15: Predict-then-Optimize — die bessere Prognose, die schlechtere Entscheidung</span></a></li></ul></details><details class="sidebar-gruppe"><summary>Teil IV: Anwendungen — Energiewirtschaft und Finanzmärkte</summary><ul><li data-kapitel="bruecke.html"><a href="bruecke.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 16: Die Strukturbrücke — dieselbe Mathematik, zwei Welten</span></a></li><li data-kapitel="supplychain.html"><a href="supplychain.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 17: Supply-Chain und Energieeinsatz unter Unsicherheit</span></a></li><li data-kapitel="finanzdaten.html"><a href="finanzdaten.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 18: Finanzdaten-Modellierung — Renditen, Kovarianz und Shrinkage</span></a></li><li data-kapitel="markowitz.html"><a href="markowitz.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 19: Die moderne Portfoliotheorie nach Markowitz</span></a></li><li data-kapitel="cvar.html"><a href="cvar.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 20: Tail-Risiko, CVaR und Transaktionskosten</span></a></li><li data-kapitel="handelsmaschine.html"><a href="handelsmaschine.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 21: Die vollständige quantitative Handelsmaschine</span></a></li></ul></details><details class="sidebar-gruppe"><summary>Teil V: Praxis</summary><ul><li data-kapitel="praxisfallen.html"><a href="praxisfallen.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 22: Praxisfallen und der Weg zum produktiven Einsatz</span></a></li><li data-kapitel="testing.html"><a href="testing.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 23: Testen, Messen, Ausliefern</span></a></li><li data-kapitel="projektwerkstatt.html"><a href="projektwerkstatt.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Projektwerkstatt</span></a></li></ul></details><details class="sidebar-gruppe"><summary>Anhänge</summary><ul><li data-kapitel="anhang-loesungen.html"><a href="anhang-loesungen.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Anhang A: Lösungen zu allen Übungsaufgaben</span></a></li><li data-kapitel="anhang-modellierungsmuster.html"><a href="anhang-modellierungsmuster.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Anhang B: Katalog der Modellierungsmuster</span></a></li><li data-kapitel="anhang-fehlerdiagnose.html"><a href="anhang-fehlerdiagnose.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Anhang C: Fehlerdiagnose-Handbuch</span></a></li><li data-kapitel="anhang-spickzettel.html"><a href="anhang-spickzettel.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Anhang D: Spickzettel der Solver</span></a></li><li data-kapitel="anhang-glossar-literatur.html"><a href="anhang-glossar-literatur.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Anhang E: Glossar und Literatur</span></a></li></ul></details><ul class="sidebar-extra"><li><a href="programme.html"><svg class="icon" aria-hidden="true"><use href="#icon-book"></use></svg> Beispielprogramme</a></li><li><a href="stichwortverzeichnis.html"><svg class="icon" aria-hidden="true"><use href="#icon-search"></use></svg> Stichwortverzeichnis</a></li><li><a href="gesamtdokument.html"><svg class="icon" aria-hidden="true"><use href="#icon-external-link"></use></svg> Gesamtdokument (eine Seite)</a></li><li><a href="Operations_Research_mit_Python_Version_04.pdf" download><svg class="icon" aria-hidden="true"><use href="#icon-download"></use></svg> Download als PDF</a></li></ul></div></nav>
+  <nav class="sidebar" id="sidebar" aria-label="Kapitelnavigation"><div class="sidebar-inhalt"><details class="sidebar-gruppe"><summary>Einstieg</summary><ul><li data-kapitel="vorwort.html"><a href="vorwort.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Vorwort & Lesehilfe</span></a></li><li data-kapitel="notation.html"><a href="notation.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Notation & Abkürzungen</span></a></li></ul></details><details class="sidebar-gruppe" open><summary>Teil I: Grundlagen des Operations Research</summary><ul><li data-kapitel="einfuehrung.html"><a href="einfuehrung.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 1: Einführung in Operations Research — Vom Ursprung zur mathematischen Entscheidungsfindung</span></a></li><li data-kapitel="fundament.html"><a href="fundament.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 2: Das mathematische Fundament — Vektoren, Matrizen, Konvexität</span></a></li><li data-kapitel="oekosystem.html"><a href="oekosystem.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 3: Das Python-Ökosystem für OR — Solver, Bindings und Modellierungsschichten</span></a></li><li data-kapitel="modellierung.html" class="aktiv"><a href="modellierung.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 4: Vom Management-Wunsch zum Modell</span></a></li><li data-kapitel="synthese-grundlagen.html"><a href="synthese-grundlagen.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Synthese Teil I</span></a></li></ul></details><details class="sidebar-gruppe"><summary>Teil II: Die Kernverfahren der deterministischen Optimierung</summary><ul><li data-kapitel="lp.html"><a href="lp.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 5: Lineare Programmierung — Simplex, Dualität und Schattenpreise</span></a></li><li data-kapitel="milp.html"><a href="milp.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 6: Gemischt-ganzzahlige Optimierung — Diskrete Entscheidungen und Branch-and-Bound</span></a></li><li data-kapitel="cpsat.html"><a href="cpsat.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 7: Constraint Programming mit CP-SAT — Logik, Scheduling und Zuweisung</span></a></li><li data-kapitel="graphen.html"><a href="graphen.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 8: Graphen, Flüsse und Touren — Min-Cost-Flow, Matching und VRP</span></a></li><li data-kapitel="metaheuristiken.html"><a href="metaheuristiken.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 9: Metaheuristiken — wenn der exakte Solver aussteigt</span></a></li><li data-kapitel="dekomposition.html"><a href="dekomposition.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 10: Spaltengenerierung — das Modell umbauen statt die Lösung raten</span></a></li><li data-kapitel="synthese-kernverfahren.html"><a href="synthese-kernverfahren.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Synthese Teil II</span></a></li></ul></details><details class="sidebar-gruppe"><summary>Teil III: Nichtlinearität, Unsicherheit und mehrperiodige Dynamik</summary><ul><li data-kapitel="qp-nlp.html"><a href="qp-nlp.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 11: Quadratische und nichtlineare Optimierung — KKT, Lagrange, Konvexität</span></a></li><li data-kapitel="unsicherheit.html"><a href="unsicherheit.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 12: Optimierung unter Unsicherheit — Monte-Carlo, Stochastik, Robustheit</span></a></li><li data-kapitel="dynamische-programmierung.html"><a href="dynamische-programmierung.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 13: Dynamische Programmierung — Die Bellman-Gleichung und Order-Execution</span></a></li><li data-kapitel="mehrziel.html"><a href="mehrziel.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 14: Mehrere Ziele — Pareto-Fronten statt Gewichte</span></a></li><li data-kapitel="prognose.html"><a href="prognose.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 15: Predict-then-Optimize — die bessere Prognose, die schlechtere Entscheidung</span></a></li><li data-kapitel="synthese-nichtlinear.html"><a href="synthese-nichtlinear.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Synthese Teil III</span></a></li></ul></details><details class="sidebar-gruppe"><summary>Teil IV: Anwendungen — Energiewirtschaft und Finanzmärkte</summary><ul><li data-kapitel="bruecke.html"><a href="bruecke.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 16: Die Strukturbrücke — dieselbe Mathematik, zwei Welten</span></a></li><li data-kapitel="supplychain.html"><a href="supplychain.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 17: Supply-Chain und Energieeinsatz unter Unsicherheit</span></a></li><li data-kapitel="finanzdaten.html"><a href="finanzdaten.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 18: Finanzdaten-Modellierung — Renditen, Kovarianz und Shrinkage</span></a></li><li data-kapitel="markowitz.html"><a href="markowitz.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 19: Die moderne Portfoliotheorie nach Markowitz</span></a></li><li data-kapitel="cvar.html"><a href="cvar.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 20: Tail-Risiko, CVaR und Transaktionskosten</span></a></li><li data-kapitel="handelsmaschine.html"><a href="handelsmaschine.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 21: Die vollständige quantitative Handelsmaschine</span></a></li><li data-kapitel="synthese-anwendungen.html"><a href="synthese-anwendungen.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Synthese Teil IV</span></a></li></ul></details><details class="sidebar-gruppe"><summary>Teil V: Praxis</summary><ul><li data-kapitel="praxisfallen.html"><a href="praxisfallen.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 22: Praxisfallen und der Weg zum produktiven Einsatz</span></a></li><li data-kapitel="testing.html"><a href="testing.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 23: Testen, Messen, Ausliefern</span></a></li><li data-kapitel="synthese-praxis.html"><a href="synthese-praxis.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Synthese Teil V</span></a></li><li data-kapitel="projektwerkstatt.html"><a href="projektwerkstatt.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Projektwerkstatt</span></a></li></ul></details><details class="sidebar-gruppe"><summary>Anhänge</summary><ul><li data-kapitel="anhang-loesungen.html"><a href="anhang-loesungen.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Anhang A: Lösungen zu allen Übungsaufgaben</span></a></li><li data-kapitel="anhang-modellierungsmuster.html"><a href="anhang-modellierungsmuster.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Anhang B: Katalog der Modellierungsmuster</span></a></li><li data-kapitel="anhang-fehlerdiagnose.html"><a href="anhang-fehlerdiagnose.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Anhang C: Fehlerdiagnose-Handbuch</span></a></li><li data-kapitel="anhang-spickzettel.html"><a href="anhang-spickzettel.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Anhang D: Spickzettel der Solver</span></a></li><li data-kapitel="anhang-glossar-literatur.html"><a href="anhang-glossar-literatur.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Anhang E: Glossar und Literatur</span></a></li></ul></details><ul class="sidebar-extra"><li><a href="programme.html"><svg class="icon" aria-hidden="true"><use href="#icon-book"></use></svg> Beispielprogramme</a></li><li><a href="stichwortverzeichnis.html"><svg class="icon" aria-hidden="true"><use href="#icon-search"></use></svg> Stichwortverzeichnis</a></li><li><a href="gesamtdokument.html"><svg class="icon" aria-hidden="true"><use href="#icon-external-link"></use></svg> Gesamtdokument (eine Seite)</a></li><li><a href="Operations_Research_mit_Python_Version_04.pdf" download><svg class="icon" aria-hidden="true"><use href="#icon-download"></use></svg> Download als PDF</a></li></ul></div></nav>
   <main class="content">
     <nav class="breadcrumb" aria-label="Breadcrumb"><a href="index.html">Start</a> › <span>Teil I</span> › <span>Kapitel 4: Vom Management-Wunsch zum Modell</span></nav>
-    <nav class="prev-next"><a class="prev-next-knopf prev-next-prev" href="oekosystem.html"><svg class="icon" aria-hidden="true"><use href="#icon-chevron-left"></use></svg><span><small>Zurück</small>Kapitel 3: Das Python-Ökosystem für OR — Solver, Bindings und Modellierungsschichten</span></a><a class="prev-next-knopf prev-next-next" href="lp.html"><span><small>Weiter</small>Kapitel 5: Lineare Programmierung — Simplex, Dualität und Schattenpreise</span><svg class="icon" aria-hidden="true"><use href="#icon-chevron-right"></use></svg></a></nav>
+    <nav class="prev-next"><a class="prev-next-knopf prev-next-prev" href="oekosystem.html"><svg class="icon" aria-hidden="true"><use href="#icon-chevron-left"></use></svg><span><small>Zurück</small>Kapitel 3: Das Python-Ökosystem für OR — Solver, Bindings und Modellierungsschichten</span></a><a class="prev-next-knopf prev-next-next" href="synthese-grundlagen.html"><span><small>Weiter</small>Synthese Teil I</span><svg class="icon" aria-hidden="true"><use href="#icon-chevron-right"></use></svg></a></nav>
     <article>
     <h1 id="kap-modellierung">Kapitel 4: Vom Management-Wunsch zum Modell</h1>
 <div class="card card-blick">
@@ -206,6 +206,7 @@ Deckungsbeitrag maximieren  -&gt; BD     Umsatz  40,000   DB 19,000</code></pre>
 <li>… erkennen, dass ein Satz wie „Stammkunden dürfen wir nicht verlieren” mehrere Lesarten hat, und den Unterschied in Euro beziffern.</li>
 <li>… begründen, wann eine Regel hart und wann sie weich sein muss — und was eine harte Regel im Betrieb anrichtet, wenn sie einmal nicht erfüllbar ist.</li>
 <li>… einen Kennzahlen-Fehlanreiz benennen, bevor er in die Zielfunktion gerät.</li>
+<li>… einen Satz aus einer Besprechung in den passenden Modellierungsbaustein übersetzen — und die fünf Wendungen erkennen, bei denen genau das nicht geht, ohne vorher nachzufragen.</li>
 </ol>
 <hr />
 <h2 id="sec:modellierung-vier-fragen">4.3 Ein Satz ist noch kein Modell</h2>
@@ -706,7 +707,7 @@ Drei Dinge, die deshalb vor dem ersten Modell geklaert gehoeren:
 </tbody>
 </table>
 <p>Bei 3 000 € ändert sich <strong>nichts</strong>: Die Strafe liegt unter dem Deckungsbeitrag, den die Stammkundenaufträge verdrängen würden. Bei 10 000 € kommt genau Lesart A heraus.</p>
-<p>Daraus folgt eine Einsicht, die das Modellieren erleichtert: <strong>Eine harte Regel ist eine weiche mit hinreichend großer Strafe.</strong> Man kann also immer weich anfangen und die Strafe hochdrehen, bis die Regel greift — und sieht dabei, was sie kostet. Was ein Strafgewicht darüber hinaus bedeutet und warum zwei Gewichte einen <em>Wechselkurs</em> festlegen und keine Wichtigkeiten, steht in <a href="cpsat.html#sec:cpsat-denkfehler">Abschnitt 7.9</a>.</p>
+<p>Daraus folgt eine Einsicht, die das Modellieren erleichtert: <strong>Eine harte Regel ist eine weiche mit hinreichend großer Strafe.</strong> Man kann also immer weich anfangen und die Strafe hochdrehen, bis die Regel greift — und sieht dabei, was sie kostet. Was ein Strafgewicht darüber hinaus bedeutet und warum zwei Gewichte einen <em>Wechselkurs</em> festlegen und keine Wichtigkeiten, steht in <a href="cpsat.html#sec:cpsat-denkfehler">Abschnitt 7.10</a>.</p>
 <h3 id="teil-4-ein-quartal-später">Teil 4: Ein Quartal später</h3>
 <p>Die harte Lesart A wurde eingebaut, alles lief drei Monate lang. Dann fragt Weber einen Auftrag über 320 Maschinenstunden an — mehr, als der ganze Zeitraum hergibt.</p>
 <pre><code>Lesart A (hart):  UNZULAESSIG - der Nachtlauf bricht ab
@@ -728,7 +729,219 @@ Lesart C (weich): loesbar - 66,000 EUR Deckungsbeitrag, 1 Stammauftrag abgelehnt
 <p>Frage 5 ist die wichtigste. Sie verwandelt eine abstrakte Zielangabe in einen konkreten Plan, den man ablehnen kann — und Ablehnung ist die einzige Form von Anforderungsklärung, die zuverlässig funktioniert.</p>
 </blockquote>
 <hr />
-<h2 id="sec:modellierung-uebungsaufgaben">4.6 Übungsaufgaben</h2>
+<h2 id="sec:modellierung-glossar">4.6 Deutsch — OR: ein Übersetzungslexikon</h2>
+<p>Die zwölf Fragen liefern Sätze. Sätze sind noch kein Modell — aber die meisten von ihnen haben eine <strong>Standardübersetzung</strong>, und wer sie kennt, spart sich das Nachdenken für die Fälle, in denen es keine gibt.</p>
+<p>Die Tabelle liest sich von links nach rechts: Was in der Besprechung <strong>gesagt</strong> wird, was es <strong>bedeutet</strong>, und welcher <strong>Baustein</strong> daraus wird. Die B-Nummern verweisen auf <a href="anhang-modellierungsmuster.html#anhang-modellierungsmuster">Anhang B</a>, wo jedes Muster mit Formulierung und Code steht.</p>
+<table>
+<colgroup>
+<col style="width: 33%" />
+<col style="width: 33%" />
+<col style="width: 33%" />
+</colgroup>
+<thead>
+<tr class="header">
+<th>Was gesagt wird</th>
+<th>Was gemeint ist</th>
+<th>Baustein</th>
+</tr>
+</thead>
+<tbody>
+<tr class="odd">
+<td>„Wir haben nur 400 Stunden.”</td>
+<td>eine Obergrenze, die nicht überschritten werden darf</td>
+<td>harte Kapazitätsgrenze <span class="math inline">\le b</span> (<a href="lp.html#kap-lp">Kapitel 5</a>)</td>
+</tr>
+<tr class="even">
+<td>„Mehr als zwei Millionen gibt es nicht.”</td>
+<td>dasselbe, auf Geld</td>
+<td>Budgetlimit (B27)</td>
+</tr>
+<tr class="odd">
+<td>„Möglichst nicht über 40 Stunden.”</td>
+<td>eine Grenze, die im Notfall gebrochen werden darf</td>
+<td>weiche Grenze mit Strafkosten (B8)</td>
+</tr>
+<tr class="even">
+<td>„Wir können nur ganze Kisten liefern.”</td>
+<td>die Menge ist nicht teilbar</td>
+<td>Ganzzahligkeitsbedingung (<a href="milp.html#kap-milp">Kapitel 6</a>)</td>
+</tr>
+<tr class="odd">
+<td>„Wenn wir die Anlage nutzen, fallen Fixkosten an.”</td>
+<td>Kosten, die erst ab der ersten Einheit anfallen</td>
+<td>Aktivierungsschalter (B1)</td>
+</tr>
+<tr class="even">
+<td>„Entweder gar nicht oder mindestens 50.”</td>
+<td>kein Betrieb im Kleinen</td>
+<td>semikontinuierliche Variable (B2)</td>
+</tr>
+<tr class="odd">
+<td>„Wenn wir A bauen, brauchen wir auch B.”</td>
+<td>eine Folgeverpflichtung</td>
+<td>Implikation (B3)</td>
+</tr>
+<tr class="even">
+<td>„Höchstens drei Positionen im Depot.”</td>
+<td>eine Obergrenze auf die <strong>Anzahl</strong>, nicht die Menge</td>
+<td>Kardinalität (B6)</td>
+</tr>
+<tr class="odd">
+<td>„Der Anteil muss mindestens 30 % betragen.”</td>
+<td>eine Bedingung auf ein <strong>Verhältnis</strong></td>
+<td>Verhältnis-Bedingung (B12)</td>
+</tr>
+<tr class="even">
+<td>„Jeder Auftrag genau einem Mitarbeiter.”</td>
+<td>eine vollständige, eindeutige Zuordnung</td>
+<td>Zuordnung 1:1 (B23)</td>
+</tr>
+<tr class="odd">
+<td>„Eine Maschine kann nur eines gleichzeitig.”</td>
+<td>zeitliche Ausschließlichkeit</td>
+<td>Nichtüberlappung (B14)</td>
+</tr>
+<tr class="even">
+<td>„B kann erst nach A.”</td>
+<td>eine Reihenfolge</td>
+<td>Vorrangbeziehung (B13)</td>
+</tr>
+<tr class="odd">
+<td>„Höchstens fünf Tage am Stück.”</td>
+<td>eine Bedingung über ein <strong>gleitendes Fenster</strong></td>
+<td>gleitendes Fenster (B16)</td>
+</tr>
+<tr class="even">
+<td>„Umstellen kostet uns eine halbe Stunde.”</td>
+<td>reihenfolgeabhängige Kosten</td>
+<td>Umrüstkosten (B17), Rüstzeit als Kapazität (B26)</td>
+</tr>
+<tr class="odd">
+<td>„Was reinkommt, muss auch wieder raus.”</td>
+<td>Erhaltung an jedem Knoten</td>
+<td>Flusserhaltung (B22)</td>
+</tr>
+<tr class="even">
+<td>„Notfalls brechen wir die Regel.”</td>
+<td>die Bedingung ist weich, aber teuer</td>
+<td>Schlupfvariablen (B18)</td>
+</tr>
+<tr class="odd">
+<td>„Erst Termintreue, dann Kosten.”</td>
+<td>eine Rangfolge zwischen Zielen</td>
+<td>hierarchische Ziele (B19)</td>
+</tr>
+<tr class="even">
+<td>„Es soll gerecht zugehen.”</td>
+<td>den Schlechtestgestellten verbessern</td>
+<td>Min/Max in der Zielfunktion (B11)</td>
+</tr>
+<tr class="odd">
+<td>„Was brächte uns eine zusätzliche Stunde?”</td>
+<td>die Frage nach dem Grenzwert einer Ressource</td>
+<td>Schattenpreis (<a href="lp.html#kap-lp">Kapitel 5</a>, <a href="praxisfallen.html#sec:praxisfallen-attribution">Abschnitt 22.4</a>)</td>
+</tr>
+<tr class="even">
+<td>„Mit 95 % Sicherheit muss es halten.”</td>
+<td>eine Zusage auf eine <strong>Quote</strong>, nicht auf einen Mittelwert</td>
+<td>Chance Constraint (<a href="unsicherheit.html#sec:unsicherheit-chance-constraints">Abschnitt 12.7</a>)</td>
+</tr>
+<tr class="odd">
+<td>„Wir sichern uns gegen Schätzfehler ab.”</td>
+<td>gegen die ungünstigste Parameterlage planen</td>
+<td>Worst-Case-Abzug (B21)</td>
+</tr>
+</tbody>
+</table>
+<h3 id="fünf-wendungen-bei-denen-die-übersetzung-eine-entscheidung-erzwingt">Fünf Wendungen, bei denen die Übersetzung eine Entscheidung erzwingt</h3>
+<p>Die Tabelle oben tut so, als sei die Zuordnung eindeutig. Bei den folgenden fünf ist sie es nicht — und <strong>das Nachfragen ist die eigentliche Modellierungsarbeit</strong>:</p>
+<table>
+<colgroup>
+<col style="width: 50%" />
+<col style="width: 50%" />
+</colgroup>
+<thead>
+<tr class="header">
+<th>Wendung</th>
+<th>Die Frage, die dahinter steckt</th>
+</tr>
+</thead>
+<tbody>
+<tr class="odd">
+<td><strong>„möglichst”</strong></td>
+<td>Hart oder weich? Und wenn weich: Was darf ein Verstoß kosten? Ohne Zahl ist „möglichst” keine Bedingung, sondern eine Stimmung.</td>
+</tr>
+<tr class="even">
+<td><strong>„nicht mehr als drei pro Woche”</strong></td>
+<td>Je Person oder über alle zusammen? Kalenderwoche oder gleitende sieben Tage? Beide Lesarten sind vertretbar und ergeben verschiedene Modelle.</td>
+</tr>
+<tr class="odd">
+<td><strong>„im Durchschnitt”</strong></td>
+<td>Fast immer eine Falle. Der Durchschnittskunde kauft nie — siehe <a href="unsicherheit.html#sec:unsicherheit-der-fluch-des-durchschnitts">Abschnitt 12.3</a>. Gemeint ist meist ein Quantil („in 9 von 10 Fällen”).</td>
+</tr>
+<tr class="even">
+<td><strong>„so schnell wie möglich”</strong></td>
+<td>Welche Zahl? Ende des letzten Auftrags, Summe aller Fertigstellungszeiten oder größte Verspätung? Drei Zielfunktionen, drei verschiedene Pläne.</td>
+</tr>
+<tr class="odd">
+<td><strong>„fair”</strong></td>
+<td>Den Schlechtesten verbessern, die Spannweite verkleinern oder gleiche Anteile erzwingen? Erst die Wahl macht daraus ein Modell — und sie gehört dem Betrieb, nicht dem Modellierer.</td>
+</tr>
+</tbody>
+</table>
+<blockquote>
+<p><strong>🎯 Der Nutzen dieser Liste</strong> Sie ersetzt kein Nachdenken. Sie sorgt dafür, dass das Nachdenken an den <strong>richtigen</strong> vier oder fünf Stellen stattfindet, statt an allen zwanzig gleichzeitig.</p>
+</blockquote>
+<h3 id="und-die-gegenrichtung-or-deutsch">Und die Gegenrichtung: OR — Deutsch</h3>
+<p>Dieselbe Barriere gibt es rückwärts. Diese Sätze haben sich bewährt, wenn ein Ergebnis jemandem erklärt werden muss, der das Modell nicht kennt:</p>
+<table>
+<colgroup>
+<col style="width: 50%" />
+<col style="width: 50%" />
+</colgroup>
+<thead>
+<tr class="header">
+<th>Fachbegriff</th>
+<th>Was Sie in der Besprechung sagen</th>
+</tr>
+</thead>
+<tbody>
+<tr class="odd">
+<td>Schattenpreis / Dualwert</td>
+<td>„Die nächste Stunde auf dieser Maschine wäre uns 9 € wert.”</td>
+</tr>
+<tr class="even">
+<td>bindende Bedingung mit Dualwert 0</td>
+<td>„Die Regel berührt den Plan, kostet uns aber nichts — dort zu verhandeln bringt nichts.”</td>
+</tr>
+<tr class="odd">
+<td><code>INFEASIBLE</code></td>
+<td>„Ihre Regeln widersprechen sich.” <strong>Nicht:</strong> „Der Computer schafft es nicht.”</td>
+</tr>
+<tr class="even">
+<td>Optimalitätslücke von 2 %</td>
+<td>„Besser als das hier geht es höchstens um 2 % — und die liegen unter unserer Datenungenauigkeit.”</td>
+</tr>
+<tr class="odd">
+<td>CVaR</td>
+<td>„Wenn es schiefgeht, verlieren wir im Mittel so viel.” (Der VaR sagt nur, <strong>ob</strong> es schiefgeht.)</td>
+</tr>
+<tr class="even">
+<td>EVPI</td>
+<td>„Selbst eine perfekte Prognose wäre uns höchstens so viel wert.”</td>
+</tr>
+<tr class="odd">
+<td>Relaxation</td>
+<td>„Wir haben die Regel probeweise gelockert, um zu sehen, was sie kostet.”</td>
+</tr>
+<tr class="even">
+<td>Chance Constraint</td>
+<td>„Der Plan hält in 95 von 100 Fällen — und der nächste Prozentpunkt kostet …”</td>
+</tr>
+</tbody>
+</table>
+<hr />
+<h2 id="sec:modellierung-uebungsaufgaben">4.7 Übungsaufgaben</h2>
 <blockquote>
 <p>Lösungen: <a href="anhang-loesungen.html#sec:loesungen-modellierung">Abschnitt A.4</a>.</p>
 </blockquote>
@@ -736,9 +949,10 @@ Lesart C (weich): loesbar - 66,000 EUR Deckungsbeitrag, 1 Stammauftrag abgelehnt
 <p><strong>Aufgabe 4.2 ⭐ — Frage 5 anwenden.</strong> Ein Krankenhaus möchte „die Wartezeiten in der Notaufnahme senken”. Wenden Sie Frage 5 an: Welcher Plan käme heraus, wenn genau die durchschnittliche Wartezeit minimiert würde — und was wäre daran nicht akzeptabel?</p>
 <p><strong>Aufgabe 4.3 ⭐⭐ — Der Kompromiss dazwischen.</strong> Zwischen Lesart A (12 500 €) und Lesart B (3 500 €) liegt Spielraum. Bauen Sie eine Variante, in der jeder Stammkunde <strong>mindestens die Hälfte</strong> seiner Auftragsstunden zugeteilt bekommt. Was kostet sie?</p>
 <p><strong>Aufgabe 4.4 ⭐⭐ — Zwei Ziele gleichzeitig.</strong> Maximieren Sie <span class="math inline">\text{DB} + \lambda \cdot \text{Umsatz}</span> für <span class="math inline">\lambda \in \{0; 0{,}1; 0{,}3; 1\}</span> und tragen Sie die Ergebnisse als Tabelle auf. Ab welchem <span class="math inline">\lambda</span> kippt der Plan von der DB- in die Umsatzlösung? Was sagt dieser Wert dem Betrieb?</p>
-<p><strong>Aufgabe 4.5 ⭐⭐⭐ — Die Anforderung schreiben.</strong> Formulieren Sie für den Fall dieses Kapitels eine vollständige, prüfbare Anforderung: Ziel, harte Regeln, weiche Regeln mit Strafgewichten, Verhalten bei Unlösbarkeit, auszuweisende Kennzahlen. Zwei Seiten genügen — sie sind mehr wert als zwei Wochen Programmierung.</p>
+<p><strong>Aufgabe 4.5 ⭐⭐ — Übersetzen, wo es nicht eindeutig ist.</strong> Übersetzen Sie mit <a href="#sec:modellierung-glossar">Abschnitt 4.6</a>: (a) „Die Monteure sollen möglichst gleichmäßig ausgelastet sein.” Nennen Sie <strong>drei</strong> Zielfunktionen, die alle „gleichmäßig” bedeuten können, und je einen Fall, in dem die Wahl den Plan sichtbar ändert. (b) „Kein Kunde darf länger als drei Tage warten.” Formulieren Sie die Bedingung einmal hart und einmal weich. Welche Frage müssen Sie dem Betrieb stellen, um zu entscheiden? (c) Suchen Sie in einer echten Anforderung aus Ihrem Umfeld einen Satz, der nach der Tabelle eindeutig aussieht, es aber nicht ist.</p>
+<p><strong>Aufgabe 4.6 ⭐⭐⭐ — Die Anforderung schreiben.</strong> Formulieren Sie für den Fall dieses Kapitels eine vollständige, prüfbare Anforderung: Ziel, harte Regeln, weiche Regeln mit Strafgewichten, Verhalten bei Unlösbarkeit, auszuweisende Kennzahlen. Zwei Seiten genügen — sie sind mehr wert als zwei Wochen Programmierung.</p>
 <hr />
-<h2 id="sec:modellierung-denkfehler">4.7 Finde den Denkfehler</h2>
+<h2 id="sec:modellierung-denkfehler">4.8 Finde den Denkfehler</h2>
 <div class="card card-denkfehler">
 <blockquote>
 <p><strong>🐛 „Die Engpassmaschine soll zu mindestens 92 % ausgelastet sein”</strong></p>
@@ -752,7 +966,7 @@ Lesart C (weich): loesbar - 66,000 EUR Deckungsbeitrag, 1 Stammauftrag abgelehnt
 </blockquote>
 </div>
 <hr />
-<h2 id="sec:modellierung-quiz">4.8 Micro-Quiz</h2>
+<h2 id="sec:modellierung-quiz">4.9 Micro-Quiz</h2>
 <div class="card card-quiz">
 <blockquote>
 <p><strong>❓ Drei Fragen</strong></p>
@@ -762,7 +976,7 @@ Lesart C (weich): loesbar - 66,000 EUR Deckungsbeitrag, 1 Stammauftrag abgelehnt
 </blockquote>
 </div>
 <hr />
-<h2 id="sec:modellierung-selbsttest">4.9 Selbsttest</h2>
+<h2 id="sec:modellierung-selbsttest">4.10 Selbsttest</h2>
 <ol type="1">
 <li>Warum ist „Was ist Ihnen wichtig?” eine schlechte Frage und „Welche Zahl steht im Jahresbericht?” eine gute?</li>
 <li>Nennen Sie zwei Kennzahlen aus Ihrem eigenen Arbeitsumfeld, deren Maximierung schaden würde.</li>
@@ -771,19 +985,20 @@ Lesart C (weich): loesbar - 66,000 EUR Deckungsbeitrag, 1 Stammauftrag abgelehnt
 <li>Was antworten Sie auf die Frage „Was soll passieren, wenn es keine zulässige Lösung gibt?” — und warum ist „das kommt nicht vor” keine Antwort?</li>
 </ol>
 <hr />
-<h2 id="sec:modellierung-zusammenfassung">4.10 Zusammenfassung</h2>
+<h2 id="sec:modellierung-zusammenfassung">4.11 Zusammenfassung</h2>
 <ul>
 <li>Ein Modell rechnet aus, was <strong>aufgeschrieben</strong> wurde, nicht was gemeint war. Die Zielfunktion ist eine vollständige Aussage: Was nicht darin steht, ist wertlos.</li>
 <li>Die <strong>Zielgröße</strong> ist die folgenreichste Entscheidung eines OR-Projekts. Umsatz, Auslastung und Deckungsbeitrag führten hier auf demselben Datensatz zu drei verschiedenen Plänen mit 24 500 € Unterschied.</li>
 <li><strong>Auslastung ist ein Ergebnis, kein Ziel.</strong> Bei knapper Kapazität ist die Maschine ohnehin voll; entscheidend ist, womit.</li>
 <li>Ein Satz aus einer Besprechung hat meist <strong>mehrere Lesarten</strong>. „Stammkunden nicht verlieren” kostete je nach Lesart 3 500 € oder 12 500 € — bei identischem Ergebnis für die Kunden.</li>
 <li><strong>Hart ist nur, was rechtlich oder physikalisch unmöglich ist.</strong> Eine harte Regel ist eine weiche mit hinreichend großer Strafe; der Unterschied zeigt sich erst, wenn sie einmal nicht erfüllbar ist — dann liefert die harte Variante gar nichts mehr.</li>
+<li><strong>Die meisten Sätze haben eine Standardübersetzung</strong> — das Lexikon in <a href="#sec:modellierung-glossar">Abschnitt 4.6</a> nennt sie. Sein Wert liegt aber in den fünf Wendungen, bei denen es keine gibt: „möglichst”, „nicht mehr als”, „im Durchschnitt”, „so schnell wie möglich”, „fair”. Dort ist Nachfragen die Modellierungsarbeit.</li>
 <li>Die vier Fragen — worüber wird entschieden, woran gemessen, was ist unverhandelbar, was bei Unlösbarkeit — gehören in die erste Besprechung. Der Leitfaden in <a href="#sec:modellierung-leitfaden">Abschnitt 4.5</a> macht zwölf daraus.</li>
 </ul>
 
     </article>
     <button type="button" class="fortschritt-knopf" data-kapitel="modellierung.html"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg> <span>Als gelesen markieren</span></button>
-    <nav class="prev-next"><a class="prev-next-knopf prev-next-prev" href="oekosystem.html"><svg class="icon" aria-hidden="true"><use href="#icon-chevron-left"></use></svg><span><small>Zurück</small>Kapitel 3: Das Python-Ökosystem für OR — Solver, Bindings und Modellierungsschichten</span></a><a class="prev-next-knopf prev-next-next" href="lp.html"><span><small>Weiter</small>Kapitel 5: Lineare Programmierung — Simplex, Dualität und Schattenpreise</span><svg class="icon" aria-hidden="true"><use href="#icon-chevron-right"></use></svg></a></nav>
+    <nav class="prev-next"><a class="prev-next-knopf prev-next-prev" href="oekosystem.html"><svg class="icon" aria-hidden="true"><use href="#icon-chevron-left"></use></svg><span><small>Zurück</small>Kapitel 3: Das Python-Ökosystem für OR — Solver, Bindings und Modellierungsschichten</span></a><a class="prev-next-knopf prev-next-next" href="synthese-grundlagen.html"><span><small>Weiter</small>Synthese Teil I</span><svg class="icon" aria-hidden="true"><use href="#icon-chevron-right"></use></svg></a></nav>
   </main>
 </div>
 <footer class="site-footer">
diff --git a/OR_HTML_04/notation.html b/OR_HTML_04/notation.html
index be7f518..1994cca 100644
--- a/OR_HTML_04/notation.html
+++ b/OR_HTML_04/notation.html
@@ -94,7 +94,7 @@
 </header>
 <div class="site-body">
   <div class="sidebar-overlay" id="sidebar-overlay" hidden></div>
-  <nav class="sidebar" id="sidebar" aria-label="Kapitelnavigation"><div class="sidebar-inhalt"><details class="sidebar-gruppe" open><summary>Einstieg</summary><ul><li data-kapitel="vorwort.html"><a href="vorwort.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Vorwort & Lesehilfe</span></a></li><li data-kapitel="notation.html" class="aktiv"><a href="notation.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Notation & Abkürzungen</span></a></li></ul></details><details class="sidebar-gruppe"><summary>Teil I: Grundlagen des Operations Research</summary><ul><li data-kapitel="einfuehrung.html"><a href="einfuehrung.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 1: Einführung in Operations Research — Vom Ursprung zur mathematischen Entscheidungsfindung</span></a></li><li data-kapitel="fundament.html"><a href="fundament.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 2: Das mathematische Fundament — Vektoren, Matrizen, Konvexität</span></a></li><li data-kapitel="oekosystem.html"><a href="oekosystem.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 3: Das Python-Ökosystem für OR — Solver, Bindings und Modellierungsschichten</span></a></li><li data-kapitel="modellierung.html"><a href="modellierung.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 4: Vom Management-Wunsch zum Modell</span></a></li></ul></details><details class="sidebar-gruppe"><summary>Teil II: Die Kernverfahren der deterministischen Optimierung</summary><ul><li data-kapitel="lp.html"><a href="lp.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 5: Lineare Programmierung — Simplex, Dualität und Schattenpreise</span></a></li><li data-kapitel="milp.html"><a href="milp.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 6: Gemischt-ganzzahlige Optimierung — Diskrete Entscheidungen und Branch-and-Bound</span></a></li><li data-kapitel="cpsat.html"><a href="cpsat.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 7: Constraint Programming mit CP-SAT — Logik, Scheduling und Zuweisung</span></a></li><li data-kapitel="graphen.html"><a href="graphen.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 8: Graphen, Flüsse und Touren — Min-Cost-Flow, Matching und VRP</span></a></li><li data-kapitel="metaheuristiken.html"><a href="metaheuristiken.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 9: Metaheuristiken — wenn der exakte Solver aussteigt</span></a></li><li data-kapitel="dekomposition.html"><a href="dekomposition.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 10: Spaltengenerierung — das Modell umbauen statt die Lösung raten</span></a></li></ul></details><details class="sidebar-gruppe"><summary>Teil III: Nichtlinearität, Unsicherheit und mehrperiodige Dynamik</summary><ul><li data-kapitel="qp-nlp.html"><a href="qp-nlp.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 11: Quadratische und nichtlineare Optimierung — KKT, Lagrange, Konvexität</span></a></li><li data-kapitel="unsicherheit.html"><a href="unsicherheit.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 12: Optimierung unter Unsicherheit — Monte-Carlo, Stochastik, Robustheit</span></a></li><li data-kapitel="dynamische-programmierung.html"><a href="dynamische-programmierung.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 13: Dynamische Programmierung — Die Bellman-Gleichung und Order-Execution</span></a></li><li data-kapitel="mehrziel.html"><a href="mehrziel.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 14: Mehrere Ziele — Pareto-Fronten statt Gewichte</span></a></li><li data-kapitel="prognose.html"><a href="prognose.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 15: Predict-then-Optimize — die bessere Prognose, die schlechtere Entscheidung</span></a></li></ul></details><details class="sidebar-gruppe"><summary>Teil IV: Anwendungen — Energiewirtschaft und Finanzmärkte</summary><ul><li data-kapitel="bruecke.html"><a href="bruecke.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 16: Die Strukturbrücke — dieselbe Mathematik, zwei Welten</span></a></li><li data-kapitel="supplychain.html"><a href="supplychain.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 17: Supply-Chain und Energieeinsatz unter Unsicherheit</span></a></li><li data-kapitel="finanzdaten.html"><a href="finanzdaten.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 18: Finanzdaten-Modellierung — Renditen, Kovarianz und Shrinkage</span></a></li><li data-kapitel="markowitz.html"><a href="markowitz.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 19: Die moderne Portfoliotheorie nach Markowitz</span></a></li><li data-kapitel="cvar.html"><a href="cvar.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 20: Tail-Risiko, CVaR und Transaktionskosten</span></a></li><li data-kapitel="handelsmaschine.html"><a href="handelsmaschine.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 21: Die vollständige quantitative Handelsmaschine</span></a></li></ul></details><details class="sidebar-gruppe"><summary>Teil V: Praxis</summary><ul><li data-kapitel="praxisfallen.html"><a href="praxisfallen.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 22: Praxisfallen und der Weg zum produktiven Einsatz</span></a></li><li data-kapitel="testing.html"><a href="testing.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 23: Testen, Messen, Ausliefern</span></a></li><li data-kapitel="projektwerkstatt.html"><a href="projektwerkstatt.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Projektwerkstatt</span></a></li></ul></details><details class="sidebar-gruppe"><summary>Anhänge</summary><ul><li data-kapitel="anhang-loesungen.html"><a href="anhang-loesungen.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Anhang A: Lösungen zu allen Übungsaufgaben</span></a></li><li data-kapitel="anhang-modellierungsmuster.html"><a href="anhang-modellierungsmuster.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Anhang B: Katalog der Modellierungsmuster</span></a></li><li data-kapitel="anhang-fehlerdiagnose.html"><a href="anhang-fehlerdiagnose.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Anhang C: Fehlerdiagnose-Handbuch</span></a></li><li data-kapitel="anhang-spickzettel.html"><a href="anhang-spickzettel.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Anhang D: Spickzettel der Solver</span></a></li><li data-kapitel="anhang-glossar-literatur.html"><a href="anhang-glossar-literatur.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Anhang E: Glossar und Literatur</span></a></li></ul></details><ul class="sidebar-extra"><li><a href="programme.html"><svg class="icon" aria-hidden="true"><use href="#icon-book"></use></svg> Beispielprogramme</a></li><li><a href="stichwortverzeichnis.html"><svg class="icon" aria-hidden="true"><use href="#icon-search"></use></svg> Stichwortverzeichnis</a></li><li><a href="gesamtdokument.html"><svg class="icon" aria-hidden="true"><use href="#icon-external-link"></use></svg> Gesamtdokument (eine Seite)</a></li><li><a href="Operations_Research_mit_Python_Version_04.pdf" download><svg class="icon" aria-hidden="true"><use href="#icon-download"></use></svg> Download als PDF</a></li></ul></div></nav>
+  <nav class="sidebar" id="sidebar" aria-label="Kapitelnavigation"><div class="sidebar-inhalt"><details class="sidebar-gruppe" open><summary>Einstieg</summary><ul><li data-kapitel="vorwort.html"><a href="vorwort.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Vorwort & Lesehilfe</span></a></li><li data-kapitel="notation.html" class="aktiv"><a href="notation.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Notation & Abkürzungen</span></a></li></ul></details><details class="sidebar-gruppe"><summary>Teil I: Grundlagen des Operations Research</summary><ul><li data-kapitel="einfuehrung.html"><a href="einfuehrung.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 1: Einführung in Operations Research — Vom Ursprung zur mathematischen Entscheidungsfindung</span></a></li><li data-kapitel="fundament.html"><a href="fundament.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 2: Das mathematische Fundament — Vektoren, Matrizen, Konvexität</span></a></li><li data-kapitel="oekosystem.html"><a href="oekosystem.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 3: Das Python-Ökosystem für OR — Solver, Bindings und Modellierungsschichten</span></a></li><li data-kapitel="modellierung.html"><a href="modellierung.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 4: Vom Management-Wunsch zum Modell</span></a></li><li data-kapitel="synthese-grundlagen.html"><a href="synthese-grundlagen.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Synthese Teil I</span></a></li></ul></details><details class="sidebar-gruppe"><summary>Teil II: Die Kernverfahren der deterministischen Optimierung</summary><ul><li data-kapitel="lp.html"><a href="lp.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 5: Lineare Programmierung — Simplex, Dualität und Schattenpreise</span></a></li><li data-kapitel="milp.html"><a href="milp.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 6: Gemischt-ganzzahlige Optimierung — Diskrete Entscheidungen und Branch-and-Bound</span></a></li><li data-kapitel="cpsat.html"><a href="cpsat.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 7: Constraint Programming mit CP-SAT — Logik, Scheduling und Zuweisung</span></a></li><li data-kapitel="graphen.html"><a href="graphen.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 8: Graphen, Flüsse und Touren — Min-Cost-Flow, Matching und VRP</span></a></li><li data-kapitel="metaheuristiken.html"><a href="metaheuristiken.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 9: Metaheuristiken — wenn der exakte Solver aussteigt</span></a></li><li data-kapitel="dekomposition.html"><a href="dekomposition.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 10: Spaltengenerierung — das Modell umbauen statt die Lösung raten</span></a></li><li data-kapitel="synthese-kernverfahren.html"><a href="synthese-kernverfahren.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Synthese Teil II</span></a></li></ul></details><details class="sidebar-gruppe"><summary>Teil III: Nichtlinearität, Unsicherheit und mehrperiodige Dynamik</summary><ul><li data-kapitel="qp-nlp.html"><a href="qp-nlp.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 11: Quadratische und nichtlineare Optimierung — KKT, Lagrange, Konvexität</span></a></li><li data-kapitel="unsicherheit.html"><a href="unsicherheit.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 12: Optimierung unter Unsicherheit — Monte-Carlo, Stochastik, Robustheit</span></a></li><li data-kapitel="dynamische-programmierung.html"><a href="dynamische-programmierung.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 13: Dynamische Programmierung — Die Bellman-Gleichung und Order-Execution</span></a></li><li data-kapitel="mehrziel.html"><a href="mehrziel.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 14: Mehrere Ziele — Pareto-Fronten statt Gewichte</span></a></li><li data-kapitel="prognose.html"><a href="prognose.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 15: Predict-then-Optimize — die bessere Prognose, die schlechtere Entscheidung</span></a></li><li data-kapitel="synthese-nichtlinear.html"><a href="synthese-nichtlinear.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Synthese Teil III</span></a></li></ul></details><details class="sidebar-gruppe"><summary>Teil IV: Anwendungen — Energiewirtschaft und Finanzmärkte</summary><ul><li data-kapitel="bruecke.html"><a href="bruecke.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 16: Die Strukturbrücke — dieselbe Mathematik, zwei Welten</span></a></li><li data-kapitel="supplychain.html"><a href="supplychain.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 17: Supply-Chain und Energieeinsatz unter Unsicherheit</span></a></li><li data-kapitel="finanzdaten.html"><a href="finanzdaten.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 18: Finanzdaten-Modellierung — Renditen, Kovarianz und Shrinkage</span></a></li><li data-kapitel="markowitz.html"><a href="markowitz.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 19: Die moderne Portfoliotheorie nach Markowitz</span></a></li><li data-kapitel="cvar.html"><a href="cvar.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 20: Tail-Risiko, CVaR und Transaktionskosten</span></a></li><li data-kapitel="handelsmaschine.html"><a href="handelsmaschine.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 21: Die vollständige quantitative Handelsmaschine</span></a></li><li data-kapitel="synthese-anwendungen.html"><a href="synthese-anwendungen.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Synthese Teil IV</span></a></li></ul></details><details class="sidebar-gruppe"><summary>Teil V: Praxis</summary><ul><li data-kapitel="praxisfallen.html"><a href="praxisfallen.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 22: Praxisfallen und der Weg zum produktiven Einsatz</span></a></li><li data-kapitel="testing.html"><a href="testing.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 23: Testen, Messen, Ausliefern</span></a></li><li data-kapitel="synthese-praxis.html"><a href="synthese-praxis.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Synthese Teil V</span></a></li><li data-kapitel="projektwerkstatt.html"><a href="projektwerkstatt.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Projektwerkstatt</span></a></li></ul></details><details class="sidebar-gruppe"><summary>Anhänge</summary><ul><li data-kapitel="anhang-loesungen.html"><a href="anhang-loesungen.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Anhang A: Lösungen zu allen Übungsaufgaben</span></a></li><li data-kapitel="anhang-modellierungsmuster.html"><a href="anhang-modellierungsmuster.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Anhang B: Katalog der Modellierungsmuster</span></a></li><li data-kapitel="anhang-fehlerdiagnose.html"><a href="anhang-fehlerdiagnose.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Anhang C: Fehlerdiagnose-Handbuch</span></a></li><li data-kapitel="anhang-spickzettel.html"><a href="anhang-spickzettel.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Anhang D: Spickzettel der Solver</span></a></li><li data-kapitel="anhang-glossar-literatur.html"><a href="anhang-glossar-literatur.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Anhang E: Glossar und Literatur</span></a></li></ul></details><ul class="sidebar-extra"><li><a href="programme.html"><svg class="icon" aria-hidden="true"><use href="#icon-book"></use></svg> Beispielprogramme</a></li><li><a href="stichwortverzeichnis.html"><svg class="icon" aria-hidden="true"><use href="#icon-search"></use></svg> Stichwortverzeichnis</a></li><li><a href="gesamtdokument.html"><svg class="icon" aria-hidden="true"><use href="#icon-external-link"></use></svg> Gesamtdokument (eine Seite)</a></li><li><a href="Operations_Research_mit_Python_Version_04.pdf" download><svg class="icon" aria-hidden="true"><use href="#icon-download"></use></svg> Download als PDF</a></li></ul></div></nav>
   <main class="content">
     <nav class="breadcrumb" aria-label="Breadcrumb"><a href="index.html">Start</a> › <span>Notation & Abkürzungen</span></nav>
     <nav class="prev-next"><a class="prev-next-knopf prev-next-prev" href="vorwort.html"><svg class="icon" aria-hidden="true"><use href="#icon-chevron-left"></use></svg><span><small>Zurück</small>Vorwort & Lesehilfe</span></a><a class="prev-next-knopf prev-next-next" href="einfuehrung.html"><span><small>Weiter</small>Kapitel 1: Einführung in Operations Research — Vom Ursprung zur mathematischen Entscheidungsfindung</span><svg class="icon" aria-hidden="true"><use href="#icon-chevron-right"></use></svg></a></nav>
diff --git a/OR_HTML_04/oekosystem.html b/OR_HTML_04/oekosystem.html
index 88a1408..f429a49 100644
--- a/OR_HTML_04/oekosystem.html
+++ b/OR_HTML_04/oekosystem.html
@@ -94,7 +94,7 @@
 </header>
 <div class="site-body">
   <div class="sidebar-overlay" id="sidebar-overlay" hidden></div>
-  <nav class="sidebar" id="sidebar" aria-label="Kapitelnavigation"><div class="sidebar-inhalt"><details class="sidebar-gruppe"><summary>Einstieg</summary><ul><li data-kapitel="vorwort.html"><a href="vorwort.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Vorwort & Lesehilfe</span></a></li><li data-kapitel="notation.html"><a href="notation.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Notation & Abkürzungen</span></a></li></ul></details><details class="sidebar-gruppe" open><summary>Teil I: Grundlagen des Operations Research</summary><ul><li data-kapitel="einfuehrung.html"><a href="einfuehrung.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 1: Einführung in Operations Research — Vom Ursprung zur mathematischen Entscheidungsfindung</span></a></li><li data-kapitel="fundament.html"><a href="fundament.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 2: Das mathematische Fundament — Vektoren, Matrizen, Konvexität</span></a></li><li data-kapitel="oekosystem.html" class="aktiv"><a href="oekosystem.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 3: Das Python-Ökosystem für OR — Solver, Bindings und Modellierungsschichten</span></a></li><li data-kapitel="modellierung.html"><a href="modellierung.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 4: Vom Management-Wunsch zum Modell</span></a></li></ul></details><details class="sidebar-gruppe"><summary>Teil II: Die Kernverfahren der deterministischen Optimierung</summary><ul><li data-kapitel="lp.html"><a href="lp.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 5: Lineare Programmierung — Simplex, Dualität und Schattenpreise</span></a></li><li data-kapitel="milp.html"><a href="milp.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 6: Gemischt-ganzzahlige Optimierung — Diskrete Entscheidungen und Branch-and-Bound</span></a></li><li data-kapitel="cpsat.html"><a href="cpsat.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 7: Constraint Programming mit CP-SAT — Logik, Scheduling und Zuweisung</span></a></li><li data-kapitel="graphen.html"><a href="graphen.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 8: Graphen, Flüsse und Touren — Min-Cost-Flow, Matching und VRP</span></a></li><li data-kapitel="metaheuristiken.html"><a href="metaheuristiken.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 9: Metaheuristiken — wenn der exakte Solver aussteigt</span></a></li><li data-kapitel="dekomposition.html"><a href="dekomposition.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 10: Spaltengenerierung — das Modell umbauen statt die Lösung raten</span></a></li></ul></details><details class="sidebar-gruppe"><summary>Teil III: Nichtlinearität, Unsicherheit und mehrperiodige Dynamik</summary><ul><li data-kapitel="qp-nlp.html"><a href="qp-nlp.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 11: Quadratische und nichtlineare Optimierung — KKT, Lagrange, Konvexität</span></a></li><li data-kapitel="unsicherheit.html"><a href="unsicherheit.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 12: Optimierung unter Unsicherheit — Monte-Carlo, Stochastik, Robustheit</span></a></li><li data-kapitel="dynamische-programmierung.html"><a href="dynamische-programmierung.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 13: Dynamische Programmierung — Die Bellman-Gleichung und Order-Execution</span></a></li><li data-kapitel="mehrziel.html"><a href="mehrziel.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 14: Mehrere Ziele — Pareto-Fronten statt Gewichte</span></a></li><li data-kapitel="prognose.html"><a href="prognose.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 15: Predict-then-Optimize — die bessere Prognose, die schlechtere Entscheidung</span></a></li></ul></details><details class="sidebar-gruppe"><summary>Teil IV: Anwendungen — Energiewirtschaft und Finanzmärkte</summary><ul><li data-kapitel="bruecke.html"><a href="bruecke.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 16: Die Strukturbrücke — dieselbe Mathematik, zwei Welten</span></a></li><li data-kapitel="supplychain.html"><a href="supplychain.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 17: Supply-Chain und Energieeinsatz unter Unsicherheit</span></a></li><li data-kapitel="finanzdaten.html"><a href="finanzdaten.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 18: Finanzdaten-Modellierung — Renditen, Kovarianz und Shrinkage</span></a></li><li data-kapitel="markowitz.html"><a href="markowitz.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 19: Die moderne Portfoliotheorie nach Markowitz</span></a></li><li data-kapitel="cvar.html"><a href="cvar.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 20: Tail-Risiko, CVaR und Transaktionskosten</span></a></li><li data-kapitel="handelsmaschine.html"><a href="handelsmaschine.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 21: Die vollständige quantitative Handelsmaschine</span></a></li></ul></details><details class="sidebar-gruppe"><summary>Teil V: Praxis</summary><ul><li data-kapitel="praxisfallen.html"><a href="praxisfallen.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 22: Praxisfallen und der Weg zum produktiven Einsatz</span></a></li><li data-kapitel="testing.html"><a href="testing.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 23: Testen, Messen, Ausliefern</span></a></li><li data-kapitel="projektwerkstatt.html"><a href="projektwerkstatt.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Projektwerkstatt</span></a></li></ul></details><details class="sidebar-gruppe"><summary>Anhänge</summary><ul><li data-kapitel="anhang-loesungen.html"><a href="anhang-loesungen.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Anhang A: Lösungen zu allen Übungsaufgaben</span></a></li><li data-kapitel="anhang-modellierungsmuster.html"><a href="anhang-modellierungsmuster.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Anhang B: Katalog der Modellierungsmuster</span></a></li><li data-kapitel="anhang-fehlerdiagnose.html"><a href="anhang-fehlerdiagnose.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Anhang C: Fehlerdiagnose-Handbuch</span></a></li><li data-kapitel="anhang-spickzettel.html"><a href="anhang-spickzettel.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Anhang D: Spickzettel der Solver</span></a></li><li data-kapitel="anhang-glossar-literatur.html"><a href="anhang-glossar-literatur.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Anhang E: Glossar und Literatur</span></a></li></ul></details><ul class="sidebar-extra"><li><a href="programme.html"><svg class="icon" aria-hidden="true"><use href="#icon-book"></use></svg> Beispielprogramme</a></li><li><a href="stichwortverzeichnis.html"><svg class="icon" aria-hidden="true"><use href="#icon-search"></use></svg> Stichwortverzeichnis</a></li><li><a href="gesamtdokument.html"><svg class="icon" aria-hidden="true"><use href="#icon-external-link"></use></svg> Gesamtdokument (eine Seite)</a></li><li><a href="Operations_Research_mit_Python_Version_04.pdf" download><svg class="icon" aria-hidden="true"><use href="#icon-download"></use></svg> Download als PDF</a></li></ul></div></nav>
+  <nav class="sidebar" id="sidebar" aria-label="Kapitelnavigation"><div class="sidebar-inhalt"><details class="sidebar-gruppe"><summary>Einstieg</summary><ul><li data-kapitel="vorwort.html"><a href="vorwort.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Vorwort & Lesehilfe</span></a></li><li data-kapitel="notation.html"><a href="notation.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Notation & Abkürzungen</span></a></li></ul></details><details class="sidebar-gruppe" open><summary>Teil I: Grundlagen des Operations Research</summary><ul><li data-kapitel="einfuehrung.html"><a href="einfuehrung.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 1: Einführung in Operations Research — Vom Ursprung zur mathematischen Entscheidungsfindung</span></a></li><li data-kapitel="fundament.html"><a href="fundament.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 2: Das mathematische Fundament — Vektoren, Matrizen, Konvexität</span></a></li><li data-kapitel="oekosystem.html" class="aktiv"><a href="oekosystem.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 3: Das Python-Ökosystem für OR — Solver, Bindings und Modellierungsschichten</span></a></li><li data-kapitel="modellierung.html"><a href="modellierung.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 4: Vom Management-Wunsch zum Modell</span></a></li><li data-kapitel="synthese-grundlagen.html"><a href="synthese-grundlagen.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Synthese Teil I</span></a></li></ul></details><details class="sidebar-gruppe"><summary>Teil II: Die Kernverfahren der deterministischen Optimierung</summary><ul><li data-kapitel="lp.html"><a href="lp.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 5: Lineare Programmierung — Simplex, Dualität und Schattenpreise</span></a></li><li data-kapitel="milp.html"><a href="milp.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 6: Gemischt-ganzzahlige Optimierung — Diskrete Entscheidungen und Branch-and-Bound</span></a></li><li data-kapitel="cpsat.html"><a href="cpsat.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 7: Constraint Programming mit CP-SAT — Logik, Scheduling und Zuweisung</span></a></li><li data-kapitel="graphen.html"><a href="graphen.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 8: Graphen, Flüsse und Touren — Min-Cost-Flow, Matching und VRP</span></a></li><li data-kapitel="metaheuristiken.html"><a href="metaheuristiken.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 9: Metaheuristiken — wenn der exakte Solver aussteigt</span></a></li><li data-kapitel="dekomposition.html"><a href="dekomposition.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 10: Spaltengenerierung — das Modell umbauen statt die Lösung raten</span></a></li><li data-kapitel="synthese-kernverfahren.html"><a href="synthese-kernverfahren.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Synthese Teil II</span></a></li></ul></details><details class="sidebar-gruppe"><summary>Teil III: Nichtlinearität, Unsicherheit und mehrperiodige Dynamik</summary><ul><li data-kapitel="qp-nlp.html"><a href="qp-nlp.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 11: Quadratische und nichtlineare Optimierung — KKT, Lagrange, Konvexität</span></a></li><li data-kapitel="unsicherheit.html"><a href="unsicherheit.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 12: Optimierung unter Unsicherheit — Monte-Carlo, Stochastik, Robustheit</span></a></li><li data-kapitel="dynamische-programmierung.html"><a href="dynamische-programmierung.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 13: Dynamische Programmierung — Die Bellman-Gleichung und Order-Execution</span></a></li><li data-kapitel="mehrziel.html"><a href="mehrziel.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 14: Mehrere Ziele — Pareto-Fronten statt Gewichte</span></a></li><li data-kapitel="prognose.html"><a href="prognose.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 15: Predict-then-Optimize — die bessere Prognose, die schlechtere Entscheidung</span></a></li><li data-kapitel="synthese-nichtlinear.html"><a href="synthese-nichtlinear.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Synthese Teil III</span></a></li></ul></details><details class="sidebar-gruppe"><summary>Teil IV: Anwendungen — Energiewirtschaft und Finanzmärkte</summary><ul><li data-kapitel="bruecke.html"><a href="bruecke.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 16: Die Strukturbrücke — dieselbe Mathematik, zwei Welten</span></a></li><li data-kapitel="supplychain.html"><a href="supplychain.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 17: Supply-Chain und Energieeinsatz unter Unsicherheit</span></a></li><li data-kapitel="finanzdaten.html"><a href="finanzdaten.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 18: Finanzdaten-Modellierung — Renditen, Kovarianz und Shrinkage</span></a></li><li data-kapitel="markowitz.html"><a href="markowitz.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 19: Die moderne Portfoliotheorie nach Markowitz</span></a></li><li data-kapitel="cvar.html"><a href="cvar.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 20: Tail-Risiko, CVaR und Transaktionskosten</span></a></li><li data-kapitel="handelsmaschine.html"><a href="handelsmaschine.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 21: Die vollständige quantitative Handelsmaschine</span></a></li><li data-kapitel="synthese-anwendungen.html"><a href="synthese-anwendungen.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Synthese Teil IV</span></a></li></ul></details><details class="sidebar-gruppe"><summary>Teil V: Praxis</summary><ul><li data-kapitel="praxisfallen.html"><a href="praxisfallen.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 22: Praxisfallen und der Weg zum produktiven Einsatz</span></a></li><li data-kapitel="testing.html"><a href="testing.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 23: Testen, Messen, Ausliefern</span></a></li><li data-kapitel="synthese-praxis.html"><a href="synthese-praxis.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Synthese Teil V</span></a></li><li data-kapitel="projektwerkstatt.html"><a href="projektwerkstatt.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Projektwerkstatt</span></a></li></ul></details><details class="sidebar-gruppe"><summary>Anhänge</summary><ul><li data-kapitel="anhang-loesungen.html"><a href="anhang-loesungen.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Anhang A: Lösungen zu allen Übungsaufgaben</span></a></li><li data-kapitel="anhang-modellierungsmuster.html"><a href="anhang-modellierungsmuster.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Anhang B: Katalog der Modellierungsmuster</span></a></li><li data-kapitel="anhang-fehlerdiagnose.html"><a href="anhang-fehlerdiagnose.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Anhang C: Fehlerdiagnose-Handbuch</span></a></li><li data-kapitel="anhang-spickzettel.html"><a href="anhang-spickzettel.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Anhang D: Spickzettel der Solver</span></a></li><li data-kapitel="anhang-glossar-literatur.html"><a href="anhang-glossar-literatur.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Anhang E: Glossar und Literatur</span></a></li></ul></details><ul class="sidebar-extra"><li><a href="programme.html"><svg class="icon" aria-hidden="true"><use href="#icon-book"></use></svg> Beispielprogramme</a></li><li><a href="stichwortverzeichnis.html"><svg class="icon" aria-hidden="true"><use href="#icon-search"></use></svg> Stichwortverzeichnis</a></li><li><a href="gesamtdokument.html"><svg class="icon" aria-hidden="true"><use href="#icon-external-link"></use></svg> Gesamtdokument (eine Seite)</a></li><li><a href="Operations_Research_mit_Python_Version_04.pdf" download><svg class="icon" aria-hidden="true"><use href="#icon-download"></use></svg> Download als PDF</a></li></ul></div></nav>
   <main class="content">
     <nav class="breadcrumb" aria-label="Breadcrumb"><a href="index.html">Start</a> › <span>Teil I</span> › <span>Kapitel 3: Das Python-Ökosystem für OR — Solver, Bindings und Modellierungsschichten</span></nav>
     <nav class="prev-next"><a class="prev-next-knopf prev-next-prev" href="fundament.html"><svg class="icon" aria-hidden="true"><use href="#icon-chevron-left"></use></svg><span><small>Zurück</small>Kapitel 2: Das mathematische Fundament — Vektoren, Matrizen, Konvexität</span></a><a class="prev-next-knopf prev-next-next" href="modellierung.html"><span><small>Weiter</small>Kapitel 4: Vom Management-Wunsch zum Modell</span><svg class="icon" aria-hidden="true"><use href="#icon-chevron-right"></use></svg></a></nav>
@@ -421,6 +421,35 @@ Weizen 0.750 kg, Soja 0.250 kg -&gt; 0.5350 EUR/kg</code></pre>
 <p><strong>Abhilfe:</strong> Jeden Solver in einem <strong>eigenen Prozess</strong> ausführen — genau das tut das folgende Programm. Alternativ: getrennte virtuelle Umgebungen, oder auf <code>highspy</code> verzichten und HiGHS über <code>scipy.optimize.linprog</code> bzw. CVXPY ansprechen (dort ist es ohnehin als Backend verfügbar).</p>
 <p>Der Installationstest im Vorspann umgeht die Falle bereits: Er lädt <code>ortools</code> zuerst, prüft <code>highspy</code> und <code>cvxpy</code> in der Paketübersicht nur auf Anwesenheit (<code>importlib.util.find_spec</code>) und importiert CVXPY erst im Funktionstest.</p>
 </blockquote>
+<h3 id="wie-die-isolation-aussieht-wenn-sie-tragen-soll">Wie die Isolation aussieht, wenn sie tragen soll</h3>
+<p>„Eigener Prozess” ist schnell gesagt. Die naheliegende Umsetzung — ein Codeschnipsel als Zeichenkette an <code>python -c</code> übergeben — funktioniert und ist trotzdem die schlechteste: Der Schnipsel ist für Editor, Linter und Testwerkzeug unsichtbar, ein Tippfehler darin fällt erst zur Laufzeit auf, und übergeben lassen sich nur Zeichenketten.</p>
+<p>Tragfähig ist stattdessen: <strong>jeder Solver eine gewöhnliche Funktion mit lokalem Import</strong>, ausgeführt von einem <code>ProcessPoolExecutor</code> mit zwei Einstellungen, die zusammen die Garantie ergeben:</p>
+<table>
+<colgroup>
+<col style="width: 50%" />
+<col style="width: 50%" />
+</colgroup>
+<thead>
+<tr class="header">
+<th>Einstellung</th>
+<th>Wozu</th>
+</tr>
+</thead>
+<tbody>
+<tr class="odd">
+<td><code>mp_context=multiprocessing.get_context("spawn")</code></td>
+<td>Der Kindprozess startet mit einem <strong>frischen</strong> Interpreter, statt den Speicher des Elternprozesses zu erben. Unter Linux ist <code>fork</code> der Standard — und damit wäre alles, was hier schon importiert ist, auch dort importiert.</td>
+</tr>
+<tr class="even">
+<td><code>max_tasks_per_child=1</code></td>
+<td>Jede Aufgabe bekommt einen <strong>neuen</strong> Prozess. Ohne das verwendet der Pool seinen Arbeiter wieder, und beim zweiten Solver ist der Konflikt zurück. Genau dieser Fehler ist leicht zu machen und schwer zu finden.</td>
+</tr>
+</tbody>
+</table>
+<blockquote>
+<p><strong>⚠️ <code>max_tasks_per_child=1</code> ist nicht optional</strong> Ein Pool ohne diese Angabe ist der <strong>Normalfall</strong> — er soll seine Arbeiter ja wiederverwenden. Wer die Isolation über einen Pool herstellt und das vergisst, hat einen Prozesswechsel programmiert, aber keine Isolation gewonnen: Die zweite Aufgabe landet im selben Interpreter wie die erste. Der Absturz kommt dann nicht beim ersten Solver, sondern beim zweiten — und sieht aus wie ein Problem des zweiten.</p>
+</blockquote>
+<p>Denselben Aufbau verwenden <code>Solverwechsel_CPSAT_HiGHS.py</code> (<a href="praxisfallen.html#kap-praxisfallen">Kapitel 22</a>) und <code>Benchmark_Skalierung.py</code> (<a href="testing.html#kap-testing">Kapitel 23</a>). Dort wandern zusätzlich <strong>Datenobjekte</strong> über die Prozessgrenze statt Zeichenketten — möglich, weil Domänenmodell und Lösungs-DTO keinen Solver kennen (<a href="praxisfallen.html#sec:praxisfallen-or-kern">Abschnitt 22.6</a>).</p>
 <div class="sourceCode" id="cb6"><pre class="sourceCode python"><code class="sourceCode python"><span id="cb6-1"><a href="#cb6-1" aria-hidden="true" tabindex="-1"></a><span class="co">#!/usr/bin/env python3</span></span>
 <span id="cb6-2"><a href="#cb6-2" aria-hidden="true" tabindex="-1"></a></span>
 <span id="cb6-3"><a href="#cb6-3" aria-hidden="true" tabindex="-1"></a><span class="co"># Ein_System_Vier_Ansaetze.py</span></span>
@@ -431,132 +460,157 @@ Weizen 0.750 kg, Soja 0.250 kg -&gt; 0.5350 EUR/kg</code></pre>
 <span id="cb6-8"><a href="#cb6-8" aria-hidden="true" tabindex="-1"></a><span class="co">          2*x1 + 3*x2 + x3 &lt;= 50</span></span>
 <span id="cb6-9"><a href="#cb6-9" aria-hidden="true" tabindex="-1"></a><span class="co">          x &gt;= 0</span></span>
 <span id="cb6-10"><a href="#cb6-10" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb6-11"><a href="#cb6-11" aria-hidden="true" tabindex="-1"></a><span class="co">Deckt scipy.optimize, highspy, CVXPY und OR-Tools/GLOP ab, mit Kreuzvergleich am Ende.</span></span>
-<span id="cb6-12"><a href="#cb6-12" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb6-13"><a href="#cb6-13" aria-hidden="true" tabindex="-1"></a><span class="co">WICHTIG: Jeder Solver läuft in einem EIGENEN Prozess, weil sich ortools und</span></span>
-<span id="cb6-14"><a href="#cb6-14" aria-hidden="true" tabindex="-1"></a><span class="co">highspy auf vielen Systemen nicht gemeinsam importieren lassen (beide bringen</span></span>
-<span id="cb6-15"><a href="#cb6-15" aria-hidden="true" tabindex="-1"></a><span class="co">eine eigene HiGHS-Kopie mit -&gt; Symbolkonflikt).</span></span>
-<span id="cb6-16"><a href="#cb6-16" aria-hidden="true" tabindex="-1"></a><span class="co">&quot;&quot;&quot;</span></span>
+<span id="cb6-11"><a href="#cb6-11" aria-hidden="true" tabindex="-1"></a><span class="co">Deckt scipy.optimize, highspy, CVXPY und OR-Tools/GLOP ab, mit Kreuzvergleich</span></span>
+<span id="cb6-12"><a href="#cb6-12" aria-hidden="true" tabindex="-1"></a><span class="co">am Ende.</span></span>
+<span id="cb6-13"><a href="#cb6-13" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb6-14"><a href="#cb6-14" aria-hidden="true" tabindex="-1"></a><span class="co">WICHTIG: Jeder Solver laeuft in einem EIGENEN Prozess, weil sich ortools und</span></span>
+<span id="cb6-15"><a href="#cb6-15" aria-hidden="true" tabindex="-1"></a><span class="co">highspy auf vielen Systemen nicht gemeinsam importieren lassen (beide bringen</span></span>
+<span id="cb6-16"><a href="#cb6-16" aria-hidden="true" tabindex="-1"></a><span class="co">eine eigene HiGHS-Kopie mit -&gt; Symbolkonflikt).</span></span>
 <span id="cb6-17"><a href="#cb6-17" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb6-18"><a href="#cb6-18" aria-hidden="true" tabindex="-1"></a><span class="im">import</span> json</span>
-<span id="cb6-19"><a href="#cb6-19" aria-hidden="true" tabindex="-1"></a><span class="im">import</span> subprocess</span>
-<span id="cb6-20"><a href="#cb6-20" aria-hidden="true" tabindex="-1"></a><span class="im">import</span> sys</span>
-<span id="cb6-21"><a href="#cb6-21" aria-hidden="true" tabindex="-1"></a><span class="im">import</span> textwrap</span>
-<span id="cb6-22"><a href="#cb6-22" aria-hidden="true" tabindex="-1"></a><span class="im">import</span> time</span>
-<span id="cb6-23"><a href="#cb6-23" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb6-24"><a href="#cb6-24" aria-hidden="true" tabindex="-1"></a>ERWARTET <span class="op">=</span> <span class="fl">530.0</span>            <span class="co"># Ergebnis der Handrechnung zum Produktionsprogramm</span></span>
-<span id="cb6-25"><a href="#cb6-25" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb6-26"><a href="#cb6-26" aria-hidden="true" tabindex="-1"></a><span class="co"># Jeder Eintrag ist ein eigenständiges Miniprogramm, das sein Ergebnis als</span></span>
-<span id="cb6-27"><a href="#cb6-27" aria-hidden="true" tabindex="-1"></a><span class="co"># JSON auf stdout ausgibt. So bleibt jeder Import in seinem eigenen Prozess.</span></span>
-<span id="cb6-28"><a href="#cb6-28" aria-hidden="true" tabindex="-1"></a>ANSAETZE: <span class="bu">dict</span>[<span class="bu">str</span>, <span class="bu">str</span>] <span class="op">=</span> {</span>
-<span id="cb6-29"><a href="#cb6-29" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb6-30"><a href="#cb6-30" aria-hidden="true" tabindex="-1"></a>    <span class="st">&quot;scipy.optimize.linprog&quot;</span>: <span class="st">&quot;&quot;&quot;</span></span>
-<span id="cb6-31"><a href="#cb6-31" aria-hidden="true" tabindex="-1"></a><span class="st">        from scipy.optimize import linprog</span></span>
-<span id="cb6-32"><a href="#cb6-32" aria-hidden="true" tabindex="-1"></a><span class="st">        res = linprog(c=[-10.0, -15.0, -25.0],           # linprog MINIMIERT -&gt; negieren</span></span>
-<span id="cb6-33"><a href="#cb6-33" aria-hidden="true" tabindex="-1"></a><span class="st">                      A_ub=[[1, 1, 2], [2, 3, 1]], b_ub=[40, 50],</span></span>
-<span id="cb6-34"><a href="#cb6-34" aria-hidden="true" tabindex="-1"></a><span class="st">                      bounds=[(0, None)] * 3, method=&quot;highs&quot;)</span></span>
-<span id="cb6-35"><a href="#cb6-35" aria-hidden="true" tabindex="-1"></a><span class="st">        ausgabe = (-res.fun, list(res.x))</span></span>
-<span id="cb6-36"><a href="#cb6-36" aria-hidden="true" tabindex="-1"></a><span class="st">    &quot;&quot;&quot;</span>,</span>
+<span id="cb6-18"><a href="#cb6-18" aria-hidden="true" tabindex="-1"></a><span class="co">Die Isolation besorgt ein ProcessPoolExecutor. Drei Einstellungen ergeben</span></span>
+<span id="cb6-19"><a href="#cb6-19" aria-hidden="true" tabindex="-1"></a><span class="co">zusammen die Garantie:</span></span>
+<span id="cb6-20"><a href="#cb6-20" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb6-21"><a href="#cb6-21" aria-hidden="true" tabindex="-1"></a><span class="co">  mp_context &quot;spawn&quot;     Der Kindprozess startet mit einem FRISCHEN</span></span>
+<span id="cb6-22"><a href="#cb6-22" aria-hidden="true" tabindex="-1"></a><span class="co">                         Interpreter, statt den Speicher des Elternprozesses</span></span>
+<span id="cb6-23"><a href="#cb6-23" aria-hidden="true" tabindex="-1"></a><span class="co">                         zu erben. Was hier schon importiert ist, ist dort</span></span>
+<span id="cb6-24"><a href="#cb6-24" aria-hidden="true" tabindex="-1"></a><span class="co">                         nicht importiert. Mit dem Standard &quot;fork&quot; auf Linux</span></span>
+<span id="cb6-25"><a href="#cb6-25" aria-hidden="true" tabindex="-1"></a><span class="co">                         waere das nicht so.</span></span>
+<span id="cb6-26"><a href="#cb6-26" aria-hidden="true" tabindex="-1"></a><span class="co">  max_tasks_per_child=1  Jede Aufgabe bekommt einen NEUEN Prozess. Ohne das</span></span>
+<span id="cb6-27"><a href="#cb6-27" aria-hidden="true" tabindex="-1"></a><span class="co">                         wuerde der Pool seinen Arbeiter wiederverwenden - und</span></span>
+<span id="cb6-28"><a href="#cb6-28" aria-hidden="true" tabindex="-1"></a><span class="co">                         beim zweiten Solver waere der Konflikt zurueck.</span></span>
+<span id="cb6-29"><a href="#cb6-29" aria-hidden="true" tabindex="-1"></a><span class="co">  max_workers=1          Haelt die vier Laeufe nacheinander. Nicht aus</span></span>
+<span id="cb6-30"><a href="#cb6-30" aria-hidden="true" tabindex="-1"></a><span class="co">                         Vorsicht, sondern damit die gemessenen Zeiten</span></span>
+<span id="cb6-31"><a href="#cb6-31" aria-hidden="true" tabindex="-1"></a><span class="co">                         vergleichbar bleiben.</span></span>
+<span id="cb6-32"><a href="#cb6-32" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb6-33"><a href="#cb6-33" aria-hidden="true" tabindex="-1"></a><span class="co">Jeder Solver steht in einer eigenen Funktion mit LOKALEM Import. Das ist der</span></span>
+<span id="cb6-34"><a href="#cb6-34" aria-hidden="true" tabindex="-1"></a><span class="co">Unterschied zu einem Codestring, den man an &#39;python -c&#39; uebergibt: Die</span></span>
+<span id="cb6-35"><a href="#cb6-35" aria-hidden="true" tabindex="-1"></a><span class="co">Funktion laesst sich einzeln aufrufen, testen und vom Editor pruefen - ein</span></span>
+<span id="cb6-36"><a href="#cb6-36" aria-hidden="true" tabindex="-1"></a><span class="co">String nicht.</span></span>
 <span id="cb6-37"><a href="#cb6-37" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb6-38"><a href="#cb6-38" aria-hidden="true" tabindex="-1"></a>    <span class="st">&quot;highspy (natives HiGHS)&quot;</span>: <span class="st">&quot;&quot;&quot;</span></span>
-<span id="cb6-39"><a href="#cb6-39" aria-hidden="true" tabindex="-1"></a><span class="st">        import numpy as np, highspy</span></span>
-<span id="cb6-40"><a href="#cb6-40" aria-hidden="true" tabindex="-1"></a><span class="st">        h = highspy.Highs()</span></span>
-<span id="cb6-41"><a href="#cb6-41" aria-hidden="true" tabindex="-1"></a><span class="st">        h.setOptionValue(&quot;output_flag&quot;, False)</span></span>
-<span id="cb6-42"><a href="#cb6-42" aria-hidden="true" tabindex="-1"></a><span class="st">        h.addVars(3, np.zeros(3), np.full(3, highspy.kHighsInf))</span></span>
-<span id="cb6-43"><a href="#cb6-43" aria-hidden="true" tabindex="-1"></a><span class="st">        h.changeObjectiveSense(highspy.ObjSense.kMaximize)</span></span>
-<span id="cb6-44"><a href="#cb6-44" aria-hidden="true" tabindex="-1"></a><span class="st">        for j, wert in enumerate([10.0, 15.0, 25.0]):</span></span>
-<span id="cb6-45"><a href="#cb6-45" aria-hidden="true" tabindex="-1"></a><span class="st">            h.changeColCost(j, wert)</span></span>
-<span id="cb6-46"><a href="#cb6-46" aria-hidden="true" tabindex="-1"></a><span class="st">        # CSR-Format: starts[i] = Beginn von Zeile i in indices/values</span></span>
-<span id="cb6-47"><a href="#cb6-47" aria-hidden="true" tabindex="-1"></a><span class="st">        h.addRows(2, np.full(2, -highspy.kHighsInf), np.array([40.0, 50.0]), 6,</span></span>
-<span id="cb6-48"><a href="#cb6-48" aria-hidden="true" tabindex="-1"></a><span class="st">                  np.array([0, 3], dtype=np.int32),</span></span>
-<span id="cb6-49"><a href="#cb6-49" aria-hidden="true" tabindex="-1"></a><span class="st">                  np.array([0, 1, 2, 0, 1, 2], dtype=np.int32),</span></span>
-<span id="cb6-50"><a href="#cb6-50" aria-hidden="true" tabindex="-1"></a><span class="st">                  np.array([1.0, 1.0, 2.0, 2.0, 3.0, 1.0]))</span></span>
-<span id="cb6-51"><a href="#cb6-51" aria-hidden="true" tabindex="-1"></a><span class="st">        h.run()</span></span>
-<span id="cb6-52"><a href="#cb6-52" aria-hidden="true" tabindex="-1"></a><span class="st">        ausgabe = (h.getInfo().objective_function_value,</span></span>
-<span id="cb6-53"><a href="#cb6-53" aria-hidden="true" tabindex="-1"></a><span class="st">                   list(h.getSolution().col_value[:3]))</span></span>
-<span id="cb6-54"><a href="#cb6-54" aria-hidden="true" tabindex="-1"></a><span class="st">    &quot;&quot;&quot;</span>,</span>
-<span id="cb6-55"><a href="#cb6-55" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb6-56"><a href="#cb6-56" aria-hidden="true" tabindex="-1"></a>    <span class="st">&quot;cvxpy&quot;</span>: <span class="st">&quot;&quot;&quot;</span></span>
-<span id="cb6-57"><a href="#cb6-57" aria-hidden="true" tabindex="-1"></a><span class="st">        import numpy as np, cvxpy as cp</span></span>
-<span id="cb6-58"><a href="#cb6-58" aria-hidden="true" tabindex="-1"></a><span class="st">        x = cp.Variable(3, nonneg=True)</span></span>
-<span id="cb6-59"><a href="#cb6-59" aria-hidden="true" tabindex="-1"></a><span class="st">        problem = cp.Problem(cp.Maximize(np.array([10.0, 15.0, 25.0]) @ x),</span></span>
-<span id="cb6-60"><a href="#cb6-60" aria-hidden="true" tabindex="-1"></a><span class="st">                             [np.array([[1, 1, 2], [2, 3, 1]]) @ x &lt;= np.array([40, 50])])</span></span>
-<span id="cb6-61"><a href="#cb6-61" aria-hidden="true" tabindex="-1"></a><span class="st">        problem.solve()</span></span>
-<span id="cb6-62"><a href="#cb6-62" aria-hidden="true" tabindex="-1"></a><span class="st">        ausgabe = (float(problem.value), [float(v) for v in x.value])</span></span>
-<span id="cb6-63"><a href="#cb6-63" aria-hidden="true" tabindex="-1"></a><span class="st">    &quot;&quot;&quot;</span>,</span>
-<span id="cb6-64"><a href="#cb6-64" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb6-65"><a href="#cb6-65" aria-hidden="true" tabindex="-1"></a>    <span class="st">&quot;ortools / GLOP&quot;</span>: <span class="st">&quot;&quot;&quot;</span></span>
-<span id="cb6-66"><a href="#cb6-66" aria-hidden="true" tabindex="-1"></a><span class="st">        from ortools.linear_solver import pywraplp</span></span>
-<span id="cb6-67"><a href="#cb6-67" aria-hidden="true" tabindex="-1"></a><span class="st">        s = pywraplp.Solver.CreateSolver(&quot;GLOP&quot;)</span></span>
-<span id="cb6-68"><a href="#cb6-68" aria-hidden="true" tabindex="-1"></a><span class="st">        x = [s.NumVar(0, s.infinity(), f&quot;x{j+1}&quot;) for j in range(3)]</span></span>
-<span id="cb6-69"><a href="#cb6-69" aria-hidden="true" tabindex="-1"></a><span class="st">        A = [[1, 1, 2], [2, 3, 1]]</span></span>
-<span id="cb6-70"><a href="#cb6-70" aria-hidden="true" tabindex="-1"></a><span class="st">        for i, kap in enumerate([40, 50]):</span></span>
-<span id="cb6-71"><a href="#cb6-71" aria-hidden="true" tabindex="-1"></a><span class="st">            s.Add(sum(A[i][j] * x[j] for j in range(3)) &lt;= kap)</span></span>
-<span id="cb6-72"><a href="#cb6-72" aria-hidden="true" tabindex="-1"></a><span class="st">        s.Maximize(10 * x[0] + 15 * x[1] + 25 * x[2])</span></span>
-<span id="cb6-73"><a href="#cb6-73" aria-hidden="true" tabindex="-1"></a><span class="st">        s.Solve()</span></span>
-<span id="cb6-74"><a href="#cb6-74" aria-hidden="true" tabindex="-1"></a><span class="st">        ausgabe = (s.Objective().Value(), [v.solution_value() for v in x])</span></span>
-<span id="cb6-75"><a href="#cb6-75" aria-hidden="true" tabindex="-1"></a><span class="st">    &quot;&quot;&quot;</span>,</span>
-<span id="cb6-76"><a href="#cb6-76" aria-hidden="true" tabindex="-1"></a>}</span>
-<span id="cb6-77"><a href="#cb6-77" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb6-38"><a href="#cb6-38" aria-hidden="true" tabindex="-1"></a><span class="co">Benoetigt: scipy, highspy, cvxpy, ortools</span></span>
+<span id="cb6-39"><a href="#cb6-39" aria-hidden="true" tabindex="-1"></a><span class="co">&quot;&quot;&quot;</span></span>
+<span id="cb6-40"><a href="#cb6-40" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb6-41"><a href="#cb6-41" aria-hidden="true" tabindex="-1"></a><span class="im">import</span> multiprocessing</span>
+<span id="cb6-42"><a href="#cb6-42" aria-hidden="true" tabindex="-1"></a><span class="im">import</span> time</span>
+<span id="cb6-43"><a href="#cb6-43" aria-hidden="true" tabindex="-1"></a><span class="im">from</span> concurrent.futures <span class="im">import</span> ProcessPoolExecutor</span>
+<span id="cb6-44"><a href="#cb6-44" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb6-45"><a href="#cb6-45" aria-hidden="true" tabindex="-1"></a>ERWARTET <span class="op">=</span> <span class="fl">530.0</span>            <span class="co"># Ergebnis der Handrechnung zum Produktionsprogramm</span></span>
+<span id="cb6-46"><a href="#cb6-46" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb6-47"><a href="#cb6-47" aria-hidden="true" tabindex="-1"></a><span class="co"># Die Instanz - einmal notiert, von allen vier Funktionen benutzt.</span></span>
+<span id="cb6-48"><a href="#cb6-48" aria-hidden="true" tabindex="-1"></a>ZIEL <span class="op">=</span> [<span class="fl">10.0</span>, <span class="fl">15.0</span>, <span class="fl">25.0</span>]</span>
+<span id="cb6-49"><a href="#cb6-49" aria-hidden="true" tabindex="-1"></a>MATRIX <span class="op">=</span> [[<span class="dv">1</span>, <span class="dv">1</span>, <span class="dv">2</span>], [<span class="dv">2</span>, <span class="dv">3</span>, <span class="dv">1</span>]]</span>
+<span id="cb6-50"><a href="#cb6-50" aria-hidden="true" tabindex="-1"></a>KAPAZITAET <span class="op">=</span> [<span class="fl">40.0</span>, <span class="fl">50.0</span>]</span>
+<span id="cb6-51"><a href="#cb6-51" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb6-52"><a href="#cb6-52" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb6-53"><a href="#cb6-53" aria-hidden="true" tabindex="-1"></a><span class="kw">def</span> loese_mit_scipy() <span class="op">-&gt;</span> <span class="bu">tuple</span>[<span class="bu">float</span>, <span class="bu">list</span>[<span class="bu">float</span>]]:</span>
+<span id="cb6-54"><a href="#cb6-54" aria-hidden="true" tabindex="-1"></a>    <span class="im">from</span> scipy.optimize <span class="im">import</span> linprog</span>
+<span id="cb6-55"><a href="#cb6-55" aria-hidden="true" tabindex="-1"></a>    ergebnis <span class="op">=</span> linprog(c<span class="op">=</span>[<span class="op">-</span>w <span class="cf">for</span> w <span class="kw">in</span> ZIEL],          <span class="co"># linprog MINIMIERT -&gt; negieren</span></span>
+<span id="cb6-56"><a href="#cb6-56" aria-hidden="true" tabindex="-1"></a>                       A_ub<span class="op">=</span>MATRIX, b_ub<span class="op">=</span>KAPAZITAET,</span>
+<span id="cb6-57"><a href="#cb6-57" aria-hidden="true" tabindex="-1"></a>                       bounds<span class="op">=</span>[(<span class="dv">0</span>, <span class="va">None</span>)] <span class="op">*</span> <span class="dv">3</span>, method<span class="op">=</span><span class="st">&quot;highs&quot;</span>)</span>
+<span id="cb6-58"><a href="#cb6-58" aria-hidden="true" tabindex="-1"></a>    <span class="cf">return</span> <span class="op">-</span>ergebnis.fun, <span class="bu">list</span>(ergebnis.x)</span>
+<span id="cb6-59"><a href="#cb6-59" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb6-60"><a href="#cb6-60" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb6-61"><a href="#cb6-61" aria-hidden="true" tabindex="-1"></a><span class="kw">def</span> loese_mit_highspy() <span class="op">-&gt;</span> <span class="bu">tuple</span>[<span class="bu">float</span>, <span class="bu">list</span>[<span class="bu">float</span>]]:</span>
+<span id="cb6-62"><a href="#cb6-62" aria-hidden="true" tabindex="-1"></a>    <span class="im">import</span> highspy</span>
+<span id="cb6-63"><a href="#cb6-63" aria-hidden="true" tabindex="-1"></a>    <span class="im">import</span> numpy <span class="im">as</span> np</span>
+<span id="cb6-64"><a href="#cb6-64" aria-hidden="true" tabindex="-1"></a>    h <span class="op">=</span> highspy.Highs()</span>
+<span id="cb6-65"><a href="#cb6-65" aria-hidden="true" tabindex="-1"></a>    h.setOptionValue(<span class="st">&quot;output_flag&quot;</span>, <span class="va">False</span>)</span>
+<span id="cb6-66"><a href="#cb6-66" aria-hidden="true" tabindex="-1"></a>    h.addVars(<span class="dv">3</span>, np.zeros(<span class="dv">3</span>), np.full(<span class="dv">3</span>, highspy.kHighsInf))</span>
+<span id="cb6-67"><a href="#cb6-67" aria-hidden="true" tabindex="-1"></a>    h.changeObjectiveSense(highspy.ObjSense.kMaximize)</span>
+<span id="cb6-68"><a href="#cb6-68" aria-hidden="true" tabindex="-1"></a>    <span class="cf">for</span> j, wert <span class="kw">in</span> <span class="bu">enumerate</span>(ZIEL):</span>
+<span id="cb6-69"><a href="#cb6-69" aria-hidden="true" tabindex="-1"></a>        h.changeColCost(j, wert)</span>
+<span id="cb6-70"><a href="#cb6-70" aria-hidden="true" tabindex="-1"></a>    <span class="co"># CSR-Format: starts[i] = Beginn von Zeile i in indices/values</span></span>
+<span id="cb6-71"><a href="#cb6-71" aria-hidden="true" tabindex="-1"></a>    h.addRows(<span class="dv">2</span>, np.full(<span class="dv">2</span>, <span class="op">-</span>highspy.kHighsInf), np.array(KAPAZITAET), <span class="dv">6</span>,</span>
+<span id="cb6-72"><a href="#cb6-72" aria-hidden="true" tabindex="-1"></a>              np.array([<span class="dv">0</span>, <span class="dv">3</span>], dtype<span class="op">=</span>np.int32),</span>
+<span id="cb6-73"><a href="#cb6-73" aria-hidden="true" tabindex="-1"></a>              np.array([<span class="dv">0</span>, <span class="dv">1</span>, <span class="dv">2</span>, <span class="dv">0</span>, <span class="dv">1</span>, <span class="dv">2</span>], dtype<span class="op">=</span>np.int32),</span>
+<span id="cb6-74"><a href="#cb6-74" aria-hidden="true" tabindex="-1"></a>              np.array([<span class="bu">float</span>(w) <span class="cf">for</span> zeile <span class="kw">in</span> MATRIX <span class="cf">for</span> w <span class="kw">in</span> zeile]))</span>
+<span id="cb6-75"><a href="#cb6-75" aria-hidden="true" tabindex="-1"></a>    h.run()</span>
+<span id="cb6-76"><a href="#cb6-76" aria-hidden="true" tabindex="-1"></a>    <span class="cf">return</span> (h.getInfo().objective_function_value,</span>
+<span id="cb6-77"><a href="#cb6-77" aria-hidden="true" tabindex="-1"></a>            <span class="bu">list</span>(h.getSolution().col_value[:<span class="dv">3</span>]))</span>
 <span id="cb6-78"><a href="#cb6-78" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb6-79"><a href="#cb6-79" aria-hidden="true" tabindex="-1"></a><span class="kw">def</span> fuehre_in_eigenem_prozess_aus(quelltext: <span class="bu">str</span>) <span class="op">-&gt;</span> <span class="bu">tuple</span>[<span class="bu">float</span>, <span class="bu">list</span>[<span class="bu">float</span>]]:</span>
-<span id="cb6-80"><a href="#cb6-80" aria-hidden="true" tabindex="-1"></a>    <span class="co">&quot;&quot;&quot;Startet den Codeschnipsel als separaten Python-Prozess und liest das Ergebnis.&quot;&quot;&quot;</span></span>
-<span id="cb6-81"><a href="#cb6-81" aria-hidden="true" tabindex="-1"></a>    programm <span class="op">=</span> textwrap.dedent(quelltext) <span class="op">+</span> <span class="st">&quot;</span><span class="ch">\n</span><span class="st">import json; print(json.dumps(ausgabe))</span><span class="ch">\n</span><span class="st">&quot;</span></span>
-<span id="cb6-82"><a href="#cb6-82" aria-hidden="true" tabindex="-1"></a>    ergebnis <span class="op">=</span> subprocess.run([sys.executable, <span class="st">&quot;-c&quot;</span>, programm],</span>
-<span id="cb6-83"><a href="#cb6-83" aria-hidden="true" tabindex="-1"></a>                              capture_output<span class="op">=</span><span class="va">True</span>, text<span class="op">=</span><span class="va">True</span>, timeout<span class="op">=</span><span class="dv">120</span>)</span>
-<span id="cb6-84"><a href="#cb6-84" aria-hidden="true" tabindex="-1"></a>    <span class="cf">if</span> ergebnis.returncode <span class="op">!=</span> <span class="dv">0</span>:</span>
-<span id="cb6-85"><a href="#cb6-85" aria-hidden="true" tabindex="-1"></a>        <span class="cf">raise</span> <span class="pp">RuntimeError</span>(ergebnis.stderr.strip().splitlines()[<span class="op">-</span><span class="dv">1</span>])</span>
-<span id="cb6-86"><a href="#cb6-86" aria-hidden="true" tabindex="-1"></a>    wert, loesung <span class="op">=</span> json.loads(ergebnis.stdout.strip().splitlines()[<span class="op">-</span><span class="dv">1</span>])</span>
-<span id="cb6-87"><a href="#cb6-87" aria-hidden="true" tabindex="-1"></a>    <span class="cf">return</span> wert, loesung</span>
+<span id="cb6-79"><a href="#cb6-79" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb6-80"><a href="#cb6-80" aria-hidden="true" tabindex="-1"></a><span class="kw">def</span> loese_mit_cvxpy() <span class="op">-&gt;</span> <span class="bu">tuple</span>[<span class="bu">float</span>, <span class="bu">list</span>[<span class="bu">float</span>]]:</span>
+<span id="cb6-81"><a href="#cb6-81" aria-hidden="true" tabindex="-1"></a>    <span class="im">import</span> cvxpy <span class="im">as</span> cp</span>
+<span id="cb6-82"><a href="#cb6-82" aria-hidden="true" tabindex="-1"></a>    <span class="im">import</span> numpy <span class="im">as</span> np</span>
+<span id="cb6-83"><a href="#cb6-83" aria-hidden="true" tabindex="-1"></a>    x <span class="op">=</span> cp.Variable(<span class="dv">3</span>, nonneg<span class="op">=</span><span class="va">True</span>)</span>
+<span id="cb6-84"><a href="#cb6-84" aria-hidden="true" tabindex="-1"></a>    problem <span class="op">=</span> cp.Problem(cp.Maximize(np.array(ZIEL) <span class="op">@</span> x),</span>
+<span id="cb6-85"><a href="#cb6-85" aria-hidden="true" tabindex="-1"></a>                         [np.array(MATRIX) <span class="op">@</span> x <span class="op">&lt;=</span> np.array(KAPAZITAET)])</span>
+<span id="cb6-86"><a href="#cb6-86" aria-hidden="true" tabindex="-1"></a>    problem.solve()</span>
+<span id="cb6-87"><a href="#cb6-87" aria-hidden="true" tabindex="-1"></a>    <span class="cf">return</span> <span class="bu">float</span>(problem.value), [<span class="bu">float</span>(v) <span class="cf">for</span> v <span class="kw">in</span> x.value]</span>
 <span id="cb6-88"><a href="#cb6-88" aria-hidden="true" tabindex="-1"></a></span>
 <span id="cb6-89"><a href="#cb6-89" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb6-90"><a href="#cb6-90" aria-hidden="true" tabindex="-1"></a><span class="cf">if</span> <span class="va">__name__</span> <span class="op">==</span> <span class="st">&quot;__main__&quot;</span>:</span>
-<span id="cb6-91"><a href="#cb6-91" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;=&quot;</span> <span class="op">*</span> <span class="dv">78</span>)</span>
-<span id="cb6-92"><a href="#cb6-92" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;  EIN SYSTEM - VIER ANSAETZE (je eigener Prozess)&quot;</span>)</span>
-<span id="cb6-93"><a href="#cb6-93" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;=&quot;</span> <span class="op">*</span> <span class="dv">78</span>)</span>
-<span id="cb6-94"><a href="#cb6-94" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;</span><span class="sc">{</span><span class="st">&#39;Bibliothek&#39;</span><span class="sc">:&lt;26}</span><span class="ss"> </span><span class="sc">{</span><span class="st">&#39;Z*&#39;</span><span class="sc">:&gt;10}</span><span class="ss"> </span><span class="sc">{</span><span class="st">&#39;x1&#39;</span><span class="sc">:&gt;7}</span><span class="ss"> </span><span class="sc">{</span><span class="st">&#39;x2&#39;</span><span class="sc">:&gt;7}</span><span class="ss"> </span><span class="sc">{</span><span class="st">&#39;x3&#39;</span><span class="sc">:&gt;7}</span><span class="ss"> </span><span class="sc">{</span><span class="st">&#39;Zeit&#39;</span><span class="sc">:&gt;10}</span><span class="ss">&quot;</span>)</span>
-<span id="cb6-95"><a href="#cb6-95" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;-&quot;</span> <span class="op">*</span> <span class="dv">78</span>)</span>
-<span id="cb6-96"><a href="#cb6-96" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb6-97"><a href="#cb6-97" aria-hidden="true" tabindex="-1"></a>    werte <span class="op">=</span> []</span>
-<span id="cb6-98"><a href="#cb6-98" aria-hidden="true" tabindex="-1"></a>    <span class="cf">for</span> name, quelltext <span class="kw">in</span> ANSAETZE.items():</span>
-<span id="cb6-99"><a href="#cb6-99" aria-hidden="true" tabindex="-1"></a>        t0 <span class="op">=</span> time.perf_counter()</span>
-<span id="cb6-100"><a href="#cb6-100" aria-hidden="true" tabindex="-1"></a>        <span class="cf">try</span>:</span>
-<span id="cb6-101"><a href="#cb6-101" aria-hidden="true" tabindex="-1"></a>            wert, x <span class="op">=</span> fuehre_in_eigenem_prozess_aus(quelltext)</span>
-<span id="cb6-102"><a href="#cb6-102" aria-hidden="true" tabindex="-1"></a>        <span class="cf">except</span> <span class="pp">RuntimeError</span> <span class="im">as</span> fehler:</span>
-<span id="cb6-103"><a href="#cb6-103" aria-hidden="true" tabindex="-1"></a>            <span class="bu">print</span>(<span class="ss">f&quot;</span><span class="sc">{</span>name<span class="sc">:&lt;26}</span><span class="ss"> nicht verfuegbar: </span><span class="sc">{</span>fehler[:<span class="dv">40</span>]<span class="sc">}</span><span class="ss">&quot;</span>)</span>
-<span id="cb6-104"><a href="#cb6-104" aria-hidden="true" tabindex="-1"></a>            <span class="cf">continue</span></span>
-<span id="cb6-105"><a href="#cb6-105" aria-hidden="true" tabindex="-1"></a>        dauer <span class="op">=</span> time.perf_counter() <span class="op">-</span> t0</span>
-<span id="cb6-106"><a href="#cb6-106" aria-hidden="true" tabindex="-1"></a>        werte.append(wert)</span>
-<span id="cb6-107"><a href="#cb6-107" aria-hidden="true" tabindex="-1"></a>        <span class="bu">print</span>(<span class="ss">f&quot;</span><span class="sc">{</span>name<span class="sc">:&lt;26}</span><span class="ss"> </span><span class="sc">{</span>wert<span class="sc">:&gt;10.2f}</span><span class="ss"> </span><span class="sc">{</span>x[<span class="dv">0</span>]<span class="sc">:&gt;7.2f}</span><span class="ss"> </span><span class="sc">{</span>x[<span class="dv">1</span>]<span class="sc">:&gt;7.2f}</span><span class="ss"> </span><span class="sc">{</span>x[<span class="dv">2</span>]<span class="sc">:&gt;7.2f}</span><span class="ss"> &quot;</span></span>
-<span id="cb6-108"><a href="#cb6-108" aria-hidden="true" tabindex="-1"></a>              <span class="ss">f&quot;</span><span class="sc">{</span>dauer<span class="sc">:&gt;8.2f}</span><span class="ss"> s&quot;</span>)</span>
-<span id="cb6-109"><a href="#cb6-109" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb6-110"><a href="#cb6-110" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;-&quot;</span> <span class="op">*</span> <span class="dv">78</span>)</span>
-<span id="cb6-111"><a href="#cb6-111" aria-hidden="true" tabindex="-1"></a>    spanne <span class="op">=</span> <span class="bu">max</span>(werte) <span class="op">-</span> <span class="bu">min</span>(werte)</span>
-<span id="cb6-112"><a href="#cb6-112" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;Spannweite zwischen den Bibliotheken: </span><span class="sc">{</span>spanne<span class="sc">:.2e}</span><span class="ss">&quot;</span>)</span>
-<span id="cb6-113"><a href="#cb6-113" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;Abweichung zur Handrechnung (</span><span class="sc">{</span>ERWARTET<span class="sc">:.0f}</span><span class="ss">):        &quot;</span></span>
-<span id="cb6-114"><a href="#cb6-114" aria-hidden="true" tabindex="-1"></a>          <span class="ss">f&quot;</span><span class="sc">{</span><span class="bu">abs</span>(werte[<span class="dv">0</span>] <span class="op">-</span> ERWARTET)<span class="sc">:.2e}</span><span class="ss">&quot;</span>)</span>
-<span id="cb6-115"><a href="#cb6-115" aria-hidden="true" tabindex="-1"></a>    <span class="cf">assert</span> spanne <span class="op">&lt;</span> <span class="fl">1e-6</span>, <span class="st">&quot;Die Bibliotheken widersprechen sich!&quot;</span></span>
-<span id="cb6-116"><a href="#cb6-116" aria-hidden="true" tabindex="-1"></a>    <span class="cf">assert</span> <span class="bu">abs</span>(werte[<span class="dv">0</span>] <span class="op">-</span> ERWARTET) <span class="op">&lt;</span> <span class="fl">1e-6</span>, <span class="st">&quot;Ergebnis weicht von der Handrechnung ab!&quot;</span></span>
-<span id="cb6-117"><a href="#cb6-117" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;Alle Wege fuehren zum selben, von Hand bestaetigten Optimum.&quot;</span>)</span>
-<span id="cb6-118"><a href="#cb6-118" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;(Die Zeiten enthalten den Prozessstart und den Import - sie messen&quot;</span>)</span>
-<span id="cb6-119"><a href="#cb6-119" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot; NICHT die reine Solverleistung, siehe Uebung 3.5.)&quot;</span>)</span>
-<span id="cb6-120"><a href="#cb6-120" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;=&quot;</span> <span class="op">*</span> <span class="dv">78</span>)</span></code></pre></div>
+<span id="cb6-90"><a href="#cb6-90" aria-hidden="true" tabindex="-1"></a><span class="kw">def</span> loese_mit_ortools() <span class="op">-&gt;</span> <span class="bu">tuple</span>[<span class="bu">float</span>, <span class="bu">list</span>[<span class="bu">float</span>]]:</span>
+<span id="cb6-91"><a href="#cb6-91" aria-hidden="true" tabindex="-1"></a>    <span class="im">from</span> ortools.linear_solver <span class="im">import</span> pywraplp</span>
+<span id="cb6-92"><a href="#cb6-92" aria-hidden="true" tabindex="-1"></a>    s <span class="op">=</span> pywraplp.Solver.CreateSolver(<span class="st">&quot;GLOP&quot;</span>)</span>
+<span id="cb6-93"><a href="#cb6-93" aria-hidden="true" tabindex="-1"></a>    x <span class="op">=</span> [s.NumVar(<span class="dv">0</span>, s.infinity(), <span class="ss">f&quot;x</span><span class="sc">{</span>j<span class="op">+</span><span class="dv">1</span><span class="sc">}</span><span class="ss">&quot;</span>) <span class="cf">for</span> j <span class="kw">in</span> <span class="bu">range</span>(<span class="dv">3</span>)]</span>
+<span id="cb6-94"><a href="#cb6-94" aria-hidden="true" tabindex="-1"></a>    <span class="cf">for</span> i, kapazitaet <span class="kw">in</span> <span class="bu">enumerate</span>(KAPAZITAET):</span>
+<span id="cb6-95"><a href="#cb6-95" aria-hidden="true" tabindex="-1"></a>        s.Add(<span class="bu">sum</span>(MATRIX[i][j] <span class="op">*</span> x[j] <span class="cf">for</span> j <span class="kw">in</span> <span class="bu">range</span>(<span class="dv">3</span>)) <span class="op">&lt;=</span> kapazitaet)</span>
+<span id="cb6-96"><a href="#cb6-96" aria-hidden="true" tabindex="-1"></a>    s.Maximize(<span class="bu">sum</span>(ZIEL[j] <span class="op">*</span> x[j] <span class="cf">for</span> j <span class="kw">in</span> <span class="bu">range</span>(<span class="dv">3</span>)))</span>
+<span id="cb6-97"><a href="#cb6-97" aria-hidden="true" tabindex="-1"></a>    s.Solve()</span>
+<span id="cb6-98"><a href="#cb6-98" aria-hidden="true" tabindex="-1"></a>    <span class="cf">return</span> s.Objective().Value(), [v.solution_value() <span class="cf">for</span> v <span class="kw">in</span> x]</span>
+<span id="cb6-99"><a href="#cb6-99" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb6-100"><a href="#cb6-100" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb6-101"><a href="#cb6-101" aria-hidden="true" tabindex="-1"></a>ANSAETZE <span class="op">=</span> {</span>
+<span id="cb6-102"><a href="#cb6-102" aria-hidden="true" tabindex="-1"></a>    <span class="st">&quot;scipy.optimize.linprog&quot;</span>: loese_mit_scipy,</span>
+<span id="cb6-103"><a href="#cb6-103" aria-hidden="true" tabindex="-1"></a>    <span class="st">&quot;highspy (natives HiGHS)&quot;</span>: loese_mit_highspy,</span>
+<span id="cb6-104"><a href="#cb6-104" aria-hidden="true" tabindex="-1"></a>    <span class="st">&quot;cvxpy&quot;</span>: loese_mit_cvxpy,</span>
+<span id="cb6-105"><a href="#cb6-105" aria-hidden="true" tabindex="-1"></a>    <span class="st">&quot;ortools / GLOP&quot;</span>: loese_mit_ortools,</span>
+<span id="cb6-106"><a href="#cb6-106" aria-hidden="true" tabindex="-1"></a>}</span>
+<span id="cb6-107"><a href="#cb6-107" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb6-108"><a href="#cb6-108" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb6-109"><a href="#cb6-109" aria-hidden="true" tabindex="-1"></a><span class="cf">if</span> <span class="va">__name__</span> <span class="op">==</span> <span class="st">&quot;__main__&quot;</span>:</span>
+<span id="cb6-110"><a href="#cb6-110" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;=&quot;</span> <span class="op">*</span> <span class="dv">78</span>)</span>
+<span id="cb6-111"><a href="#cb6-111" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;  EIN SYSTEM - VIER ANSAETZE (je eigener Prozess)&quot;</span>)</span>
+<span id="cb6-112"><a href="#cb6-112" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;=&quot;</span> <span class="op">*</span> <span class="dv">78</span>)</span>
+<span id="cb6-113"><a href="#cb6-113" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;</span><span class="sc">{</span><span class="st">&#39;Bibliothek&#39;</span><span class="sc">:&lt;26}</span><span class="ss"> </span><span class="sc">{</span><span class="st">&#39;Z*&#39;</span><span class="sc">:&gt;10}</span><span class="ss"> </span><span class="sc">{</span><span class="st">&#39;x1&#39;</span><span class="sc">:&gt;7}</span><span class="ss"> </span><span class="sc">{</span><span class="st">&#39;x2&#39;</span><span class="sc">:&gt;7}</span><span class="ss"> </span><span class="sc">{</span><span class="st">&#39;x3&#39;</span><span class="sc">:&gt;7}</span><span class="ss"> </span><span class="sc">{</span><span class="st">&#39;Zeit&#39;</span><span class="sc">:&gt;10}</span><span class="ss">&quot;</span>)</span>
+<span id="cb6-114"><a href="#cb6-114" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;-&quot;</span> <span class="op">*</span> <span class="dv">78</span>)</span>
+<span id="cb6-115"><a href="#cb6-115" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb6-116"><a href="#cb6-116" aria-hidden="true" tabindex="-1"></a>    werte <span class="op">=</span> []</span>
+<span id="cb6-117"><a href="#cb6-117" aria-hidden="true" tabindex="-1"></a>    <span class="co"># Ein Pool, vier Aufgaben, vier frische Prozesse. Der Kontext muss</span></span>
+<span id="cb6-118"><a href="#cb6-118" aria-hidden="true" tabindex="-1"></a>    <span class="co"># &quot;spawn&quot; sein - siehe Modulkommentar.</span></span>
+<span id="cb6-119"><a href="#cb6-119" aria-hidden="true" tabindex="-1"></a>    <span class="cf">with</span> ProcessPoolExecutor(</span>
+<span id="cb6-120"><a href="#cb6-120" aria-hidden="true" tabindex="-1"></a>            max_workers<span class="op">=</span><span class="dv">1</span>,</span>
+<span id="cb6-121"><a href="#cb6-121" aria-hidden="true" tabindex="-1"></a>            mp_context<span class="op">=</span>multiprocessing.get_context(<span class="st">&quot;spawn&quot;</span>),</span>
+<span id="cb6-122"><a href="#cb6-122" aria-hidden="true" tabindex="-1"></a>            max_tasks_per_child<span class="op">=</span><span class="dv">1</span>) <span class="im">as</span> pool:</span>
+<span id="cb6-123"><a href="#cb6-123" aria-hidden="true" tabindex="-1"></a>        <span class="cf">for</span> name, funktion <span class="kw">in</span> ANSAETZE.items():</span>
+<span id="cb6-124"><a href="#cb6-124" aria-hidden="true" tabindex="-1"></a>            beginn <span class="op">=</span> time.perf_counter()</span>
+<span id="cb6-125"><a href="#cb6-125" aria-hidden="true" tabindex="-1"></a>            <span class="cf">try</span>:</span>
+<span id="cb6-126"><a href="#cb6-126" aria-hidden="true" tabindex="-1"></a>                wert, x <span class="op">=</span> pool.submit(funktion).result(timeout<span class="op">=</span><span class="dv">120</span>)</span>
+<span id="cb6-127"><a href="#cb6-127" aria-hidden="true" tabindex="-1"></a>            <span class="cf">except</span> <span class="pp">Exception</span> <span class="im">as</span> fehler:                     <span class="co"># Bibliothek fehlt o. Ae.</span></span>
+<span id="cb6-128"><a href="#cb6-128" aria-hidden="true" tabindex="-1"></a>                <span class="bu">print</span>(<span class="ss">f&quot;</span><span class="sc">{</span>name<span class="sc">:&lt;26}</span><span class="ss"> nicht verfuegbar: </span><span class="sc">{</span><span class="bu">str</span>(fehler)[:<span class="dv">40</span>]<span class="sc">}</span><span class="ss">&quot;</span>)</span>
+<span id="cb6-129"><a href="#cb6-129" aria-hidden="true" tabindex="-1"></a>                <span class="cf">continue</span></span>
+<span id="cb6-130"><a href="#cb6-130" aria-hidden="true" tabindex="-1"></a>            dauer <span class="op">=</span> time.perf_counter() <span class="op">-</span> beginn</span>
+<span id="cb6-131"><a href="#cb6-131" aria-hidden="true" tabindex="-1"></a>            werte.append(wert)</span>
+<span id="cb6-132"><a href="#cb6-132" aria-hidden="true" tabindex="-1"></a>            <span class="bu">print</span>(<span class="ss">f&quot;</span><span class="sc">{</span>name<span class="sc">:&lt;26}</span><span class="ss"> </span><span class="sc">{</span>wert<span class="sc">:&gt;10.2f}</span><span class="ss"> </span><span class="sc">{</span>x[<span class="dv">0</span>]<span class="sc">:&gt;7.2f}</span><span class="ss"> </span><span class="sc">{</span>x[<span class="dv">1</span>]<span class="sc">:&gt;7.2f}</span><span class="ss"> </span><span class="sc">{</span>x[<span class="dv">2</span>]<span class="sc">:&gt;7.2f}</span><span class="ss"> &quot;</span></span>
+<span id="cb6-133"><a href="#cb6-133" aria-hidden="true" tabindex="-1"></a>                  <span class="ss">f&quot;</span><span class="sc">{</span>dauer<span class="sc">:&gt;8.2f}</span><span class="ss"> s&quot;</span>)</span>
+<span id="cb6-134"><a href="#cb6-134" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb6-135"><a href="#cb6-135" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;-&quot;</span> <span class="op">*</span> <span class="dv">78</span>)</span>
+<span id="cb6-136"><a href="#cb6-136" aria-hidden="true" tabindex="-1"></a>    spanne <span class="op">=</span> <span class="bu">max</span>(werte) <span class="op">-</span> <span class="bu">min</span>(werte)</span>
+<span id="cb6-137"><a href="#cb6-137" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;Spannweite zwischen den Bibliotheken: </span><span class="sc">{</span>spanne<span class="sc">:.2e}</span><span class="ss">&quot;</span>)</span>
+<span id="cb6-138"><a href="#cb6-138" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;Abweichung zur Handrechnung (</span><span class="sc">{</span>ERWARTET<span class="sc">:.0f}</span><span class="ss">):        &quot;</span></span>
+<span id="cb6-139"><a href="#cb6-139" aria-hidden="true" tabindex="-1"></a>          <span class="ss">f&quot;</span><span class="sc">{</span><span class="bu">abs</span>(werte[<span class="dv">0</span>] <span class="op">-</span> ERWARTET)<span class="sc">:.2e}</span><span class="ss">&quot;</span>)</span>
+<span id="cb6-140"><a href="#cb6-140" aria-hidden="true" tabindex="-1"></a>    <span class="cf">assert</span> spanne <span class="op">&lt;</span> <span class="fl">1e-6</span>, <span class="st">&quot;Die Bibliotheken widersprechen sich!&quot;</span></span>
+<span id="cb6-141"><a href="#cb6-141" aria-hidden="true" tabindex="-1"></a>    <span class="cf">assert</span> <span class="bu">abs</span>(werte[<span class="dv">0</span>] <span class="op">-</span> ERWARTET) <span class="op">&lt;</span> <span class="fl">1e-6</span>, <span class="st">&quot;Ergebnis weicht von der Handrechnung ab!&quot;</span></span>
+<span id="cb6-142"><a href="#cb6-142" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;Alle Wege fuehren zum selben, von Hand bestaetigten Optimum.&quot;</span>)</span>
+<span id="cb6-143"><a href="#cb6-143" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;(Die Zeiten enthalten Prozessstart und Import - sie messen NICHT die&quot;</span>)</span>
+<span id="cb6-144"><a href="#cb6-144" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot; reine Solverleistung. Die Uebungsaufgabe &#39;Laufzeitvergleich&#39; trennt beides.)&quot;</span>)</span>
+<span id="cb6-145"><a href="#cb6-145" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;=&quot;</span> <span class="op">*</span> <span class="dv">78</span>)</span></code></pre></div>
 <p><strong>Erwartete Ausgabe (Zeiten hardwareabhängig):</strong></p>
 <pre><code>==============================================================================
   EIN SYSTEM - VIER ANSAETZE (je eigener Prozess)
 ==============================================================================
 Bibliothek                         Z*      x1      x2      x3       Zeit
 ------------------------------------------------------------------------------
-scipy.optimize.linprog         530.00    0.00   12.00   14.00     0.55 s
-highspy (natives HiGHS)        530.00    0.00   12.00   14.00     0.17 s
-cvxpy                          530.00    0.00   12.00   14.00     1.52 s
-ortools / GLOP                 530.00    0.00   12.00   14.00     0.09 s
+scipy.optimize.linprog         530.00    0.00   12.00   14.00     0.59 s
+highspy (natives HiGHS)        530.00    0.00   12.00   14.00     0.12 s
+cvxpy                          530.00    0.00   12.00   14.00     1.24 s
+ortools / GLOP                 530.00    0.00   12.00   14.00     0.33 s
 ------------------------------------------------------------------------------
 Spannweite zwischen den Bibliotheken: 2.41e-08
 Abweichung zur Handrechnung (530):        0.00e+00
 Alle Wege fuehren zum selben, von Hand bestaetigten Optimum.
-(Die Zeiten enthalten den Prozessstart und den Import - sie messen
- NICHT die reine Solverleistung, siehe Uebung 3.5.)
+(Die Zeiten enthalten Prozessstart und Import - sie messen NICHT die
+ reine Solverleistung. Die Uebungsaufgabe &#39;Laufzeitvergleich&#39; trennt beides.)
 ==============================================================================</code></pre>
 <blockquote>
 <p><strong>🎯 Merksatz zur Spannweite</strong> Die vier Bibliotheken stimmen <strong>nicht auf die letzte Stelle</strong> überein, sondern nur bis auf <span class="math inline">2{,}4 \times 10^{-8}</span>. Das ist normal: Solver arbeiten mit endlicher Genauigkeit und brechen ab, sobald ihre eigene Toleranz erreicht ist. <strong>Vergleichen Sie Solver-Ergebnisse deshalb nie mit <code>==</code></strong>, sondern immer mit einer Toleranz — <code>abs(a - b) &lt; 1e-6</code> oder <code>np.isclose()</code>. Wer auf exakte Gleichheit prüft, baut sich Tests, die zufällig mal bestehen und mal nicht.</p>
@@ -1341,7 +1395,7 @@ Groesse                    Variante                      Aufbau    Loesen  Aufba
 <h2 id="sec:oekosystem-denkfehler">3.10 Finde den Denkfehler</h2>
 <div class="card card-denkfehler">
 <blockquote>
-<p><strong>🐛 Finde den Denkfehler 3.1: Der Solver, der angeblich dreimal schneller ist</strong></p>
+<p><strong>🐛 Finde den Denkfehler: Der Solver, der angeblich dreimal schneller ist</strong></p>
 <p>Ein Team vergleicht zwei Bibliotheken für sein Zuordnungsproblem und schreibt ins Protokoll: <em>„CVXPY braucht 1,9 s, SciPy nur 0,6 s — wir setzen auf SciPy.“</em> Gemessen wurde so:</p>
 <div class="sourceCode" id="cb14"><pre class="sourceCode python"><code class="sourceCode python"><span id="cb14-1"><a href="#cb14-1" aria-hidden="true" tabindex="-1"></a><span class="im">import</span> time</span>
 <span id="cb14-2"><a href="#cb14-2" aria-hidden="true" tabindex="-1"></a></span>
diff --git a/OR_HTML_04/praxisfallen.html b/OR_HTML_04/praxisfallen.html
index 4748e0d..0daf359 100644
--- a/OR_HTML_04/praxisfallen.html
+++ b/OR_HTML_04/praxisfallen.html
@@ -94,10 +94,10 @@
 </header>
 <div class="site-body">
   <div class="sidebar-overlay" id="sidebar-overlay" hidden></div>
-  <nav class="sidebar" id="sidebar" aria-label="Kapitelnavigation"><div class="sidebar-inhalt"><details class="sidebar-gruppe"><summary>Einstieg</summary><ul><li data-kapitel="vorwort.html"><a href="vorwort.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Vorwort & Lesehilfe</span></a></li><li data-kapitel="notation.html"><a href="notation.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Notation & Abkürzungen</span></a></li></ul></details><details class="sidebar-gruppe"><summary>Teil I: Grundlagen des Operations Research</summary><ul><li data-kapitel="einfuehrung.html"><a href="einfuehrung.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 1: Einführung in Operations Research — Vom Ursprung zur mathematischen Entscheidungsfindung</span></a></li><li data-kapitel="fundament.html"><a href="fundament.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 2: Das mathematische Fundament — Vektoren, Matrizen, Konvexität</span></a></li><li data-kapitel="oekosystem.html"><a href="oekosystem.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 3: Das Python-Ökosystem für OR — Solver, Bindings und Modellierungsschichten</span></a></li><li data-kapitel="modellierung.html"><a href="modellierung.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 4: Vom Management-Wunsch zum Modell</span></a></li></ul></details><details class="sidebar-gruppe"><summary>Teil II: Die Kernverfahren der deterministischen Optimierung</summary><ul><li data-kapitel="lp.html"><a href="lp.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 5: Lineare Programmierung — Simplex, Dualität und Schattenpreise</span></a></li><li data-kapitel="milp.html"><a href="milp.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 6: Gemischt-ganzzahlige Optimierung — Diskrete Entscheidungen und Branch-and-Bound</span></a></li><li data-kapitel="cpsat.html"><a href="cpsat.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 7: Constraint Programming mit CP-SAT — Logik, Scheduling und Zuweisung</span></a></li><li data-kapitel="graphen.html"><a href="graphen.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 8: Graphen, Flüsse und Touren — Min-Cost-Flow, Matching und VRP</span></a></li><li data-kapitel="metaheuristiken.html"><a href="metaheuristiken.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 9: Metaheuristiken — wenn der exakte Solver aussteigt</span></a></li><li data-kapitel="dekomposition.html"><a href="dekomposition.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 10: Spaltengenerierung — das Modell umbauen statt die Lösung raten</span></a></li></ul></details><details class="sidebar-gruppe"><summary>Teil III: Nichtlinearität, Unsicherheit und mehrperiodige Dynamik</summary><ul><li data-kapitel="qp-nlp.html"><a href="qp-nlp.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 11: Quadratische und nichtlineare Optimierung — KKT, Lagrange, Konvexität</span></a></li><li data-kapitel="unsicherheit.html"><a href="unsicherheit.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 12: Optimierung unter Unsicherheit — Monte-Carlo, Stochastik, Robustheit</span></a></li><li data-kapitel="dynamische-programmierung.html"><a href="dynamische-programmierung.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 13: Dynamische Programmierung — Die Bellman-Gleichung und Order-Execution</span></a></li><li data-kapitel="mehrziel.html"><a href="mehrziel.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 14: Mehrere Ziele — Pareto-Fronten statt Gewichte</span></a></li><li data-kapitel="prognose.html"><a href="prognose.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 15: Predict-then-Optimize — die bessere Prognose, die schlechtere Entscheidung</span></a></li></ul></details><details class="sidebar-gruppe"><summary>Teil IV: Anwendungen — Energiewirtschaft und Finanzmärkte</summary><ul><li data-kapitel="bruecke.html"><a href="bruecke.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 16: Die Strukturbrücke — dieselbe Mathematik, zwei Welten</span></a></li><li data-kapitel="supplychain.html"><a href="supplychain.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 17: Supply-Chain und Energieeinsatz unter Unsicherheit</span></a></li><li data-kapitel="finanzdaten.html"><a href="finanzdaten.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 18: Finanzdaten-Modellierung — Renditen, Kovarianz und Shrinkage</span></a></li><li data-kapitel="markowitz.html"><a href="markowitz.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 19: Die moderne Portfoliotheorie nach Markowitz</span></a></li><li data-kapitel="cvar.html"><a href="cvar.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 20: Tail-Risiko, CVaR und Transaktionskosten</span></a></li><li data-kapitel="handelsmaschine.html"><a href="handelsmaschine.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 21: Die vollständige quantitative Handelsmaschine</span></a></li></ul></details><details class="sidebar-gruppe" open><summary>Teil V: Praxis</summary><ul><li data-kapitel="praxisfallen.html" class="aktiv"><a href="praxisfallen.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 22: Praxisfallen und der Weg zum produktiven Einsatz</span></a></li><li data-kapitel="testing.html"><a href="testing.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 23: Testen, Messen, Ausliefern</span></a></li><li data-kapitel="projektwerkstatt.html"><a href="projektwerkstatt.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Projektwerkstatt</span></a></li></ul></details><details class="sidebar-gruppe"><summary>Anhänge</summary><ul><li data-kapitel="anhang-loesungen.html"><a href="anhang-loesungen.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Anhang A: Lösungen zu allen Übungsaufgaben</span></a></li><li data-kapitel="anhang-modellierungsmuster.html"><a href="anhang-modellierungsmuster.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Anhang B: Katalog der Modellierungsmuster</span></a></li><li data-kapitel="anhang-fehlerdiagnose.html"><a href="anhang-fehlerdiagnose.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Anhang C: Fehlerdiagnose-Handbuch</span></a></li><li data-kapitel="anhang-spickzettel.html"><a href="anhang-spickzettel.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Anhang D: Spickzettel der Solver</span></a></li><li data-kapitel="anhang-glossar-literatur.html"><a href="anhang-glossar-literatur.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Anhang E: Glossar und Literatur</span></a></li></ul></details><ul class="sidebar-extra"><li><a href="programme.html"><svg class="icon" aria-hidden="true"><use href="#icon-book"></use></svg> Beispielprogramme</a></li><li><a href="stichwortverzeichnis.html"><svg class="icon" aria-hidden="true"><use href="#icon-search"></use></svg> Stichwortverzeichnis</a></li><li><a href="gesamtdokument.html"><svg class="icon" aria-hidden="true"><use href="#icon-external-link"></use></svg> Gesamtdokument (eine Seite)</a></li><li><a href="Operations_Research_mit_Python_Version_04.pdf" download><svg class="icon" aria-hidden="true"><use href="#icon-download"></use></svg> Download als PDF</a></li></ul></div></nav>
+  <nav class="sidebar" id="sidebar" aria-label="Kapitelnavigation"><div class="sidebar-inhalt"><details class="sidebar-gruppe"><summary>Einstieg</summary><ul><li data-kapitel="vorwort.html"><a href="vorwort.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Vorwort & Lesehilfe</span></a></li><li data-kapitel="notation.html"><a href="notation.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Notation & Abkürzungen</span></a></li></ul></details><details class="sidebar-gruppe"><summary>Teil I: Grundlagen des Operations Research</summary><ul><li data-kapitel="einfuehrung.html"><a href="einfuehrung.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 1: Einführung in Operations Research — Vom Ursprung zur mathematischen Entscheidungsfindung</span></a></li><li data-kapitel="fundament.html"><a href="fundament.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 2: Das mathematische Fundament — Vektoren, Matrizen, Konvexität</span></a></li><li data-kapitel="oekosystem.html"><a href="oekosystem.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 3: Das Python-Ökosystem für OR — Solver, Bindings und Modellierungsschichten</span></a></li><li data-kapitel="modellierung.html"><a href="modellierung.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 4: Vom Management-Wunsch zum Modell</span></a></li><li data-kapitel="synthese-grundlagen.html"><a href="synthese-grundlagen.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Synthese Teil I</span></a></li></ul></details><details class="sidebar-gruppe"><summary>Teil II: Die Kernverfahren der deterministischen Optimierung</summary><ul><li data-kapitel="lp.html"><a href="lp.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 5: Lineare Programmierung — Simplex, Dualität und Schattenpreise</span></a></li><li data-kapitel="milp.html"><a href="milp.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 6: Gemischt-ganzzahlige Optimierung — Diskrete Entscheidungen und Branch-and-Bound</span></a></li><li data-kapitel="cpsat.html"><a href="cpsat.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 7: Constraint Programming mit CP-SAT — Logik, Scheduling und Zuweisung</span></a></li><li data-kapitel="graphen.html"><a href="graphen.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 8: Graphen, Flüsse und Touren — Min-Cost-Flow, Matching und VRP</span></a></li><li data-kapitel="metaheuristiken.html"><a href="metaheuristiken.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 9: Metaheuristiken — wenn der exakte Solver aussteigt</span></a></li><li data-kapitel="dekomposition.html"><a href="dekomposition.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 10: Spaltengenerierung — das Modell umbauen statt die Lösung raten</span></a></li><li data-kapitel="synthese-kernverfahren.html"><a href="synthese-kernverfahren.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Synthese Teil II</span></a></li></ul></details><details class="sidebar-gruppe"><summary>Teil III: Nichtlinearität, Unsicherheit und mehrperiodige Dynamik</summary><ul><li data-kapitel="qp-nlp.html"><a href="qp-nlp.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 11: Quadratische und nichtlineare Optimierung — KKT, Lagrange, Konvexität</span></a></li><li data-kapitel="unsicherheit.html"><a href="unsicherheit.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 12: Optimierung unter Unsicherheit — Monte-Carlo, Stochastik, Robustheit</span></a></li><li data-kapitel="dynamische-programmierung.html"><a href="dynamische-programmierung.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 13: Dynamische Programmierung — Die Bellman-Gleichung und Order-Execution</span></a></li><li data-kapitel="mehrziel.html"><a href="mehrziel.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 14: Mehrere Ziele — Pareto-Fronten statt Gewichte</span></a></li><li data-kapitel="prognose.html"><a href="prognose.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 15: Predict-then-Optimize — die bessere Prognose, die schlechtere Entscheidung</span></a></li><li data-kapitel="synthese-nichtlinear.html"><a href="synthese-nichtlinear.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Synthese Teil III</span></a></li></ul></details><details class="sidebar-gruppe"><summary>Teil IV: Anwendungen — Energiewirtschaft und Finanzmärkte</summary><ul><li data-kapitel="bruecke.html"><a href="bruecke.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 16: Die Strukturbrücke — dieselbe Mathematik, zwei Welten</span></a></li><li data-kapitel="supplychain.html"><a href="supplychain.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 17: Supply-Chain und Energieeinsatz unter Unsicherheit</span></a></li><li data-kapitel="finanzdaten.html"><a href="finanzdaten.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 18: Finanzdaten-Modellierung — Renditen, Kovarianz und Shrinkage</span></a></li><li data-kapitel="markowitz.html"><a href="markowitz.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 19: Die moderne Portfoliotheorie nach Markowitz</span></a></li><li data-kapitel="cvar.html"><a href="cvar.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 20: Tail-Risiko, CVaR und Transaktionskosten</span></a></li><li data-kapitel="handelsmaschine.html"><a href="handelsmaschine.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 21: Die vollständige quantitative Handelsmaschine</span></a></li><li data-kapitel="synthese-anwendungen.html"><a href="synthese-anwendungen.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Synthese Teil IV</span></a></li></ul></details><details class="sidebar-gruppe" open><summary>Teil V: Praxis</summary><ul><li data-kapitel="praxisfallen.html" class="aktiv"><a href="praxisfallen.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 22: Praxisfallen und der Weg zum produktiven Einsatz</span></a></li><li data-kapitel="testing.html"><a href="testing.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 23: Testen, Messen, Ausliefern</span></a></li><li data-kapitel="synthese-praxis.html"><a href="synthese-praxis.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Synthese Teil V</span></a></li><li data-kapitel="projektwerkstatt.html"><a href="projektwerkstatt.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Projektwerkstatt</span></a></li></ul></details><details class="sidebar-gruppe"><summary>Anhänge</summary><ul><li data-kapitel="anhang-loesungen.html"><a href="anhang-loesungen.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Anhang A: Lösungen zu allen Übungsaufgaben</span></a></li><li data-kapitel="anhang-modellierungsmuster.html"><a href="anhang-modellierungsmuster.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Anhang B: Katalog der Modellierungsmuster</span></a></li><li data-kapitel="anhang-fehlerdiagnose.html"><a href="anhang-fehlerdiagnose.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Anhang C: Fehlerdiagnose-Handbuch</span></a></li><li data-kapitel="anhang-spickzettel.html"><a href="anhang-spickzettel.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Anhang D: Spickzettel der Solver</span></a></li><li data-kapitel="anhang-glossar-literatur.html"><a href="anhang-glossar-literatur.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Anhang E: Glossar und Literatur</span></a></li></ul></details><ul class="sidebar-extra"><li><a href="programme.html"><svg class="icon" aria-hidden="true"><use href="#icon-book"></use></svg> Beispielprogramme</a></li><li><a href="stichwortverzeichnis.html"><svg class="icon" aria-hidden="true"><use href="#icon-search"></use></svg> Stichwortverzeichnis</a></li><li><a href="gesamtdokument.html"><svg class="icon" aria-hidden="true"><use href="#icon-external-link"></use></svg> Gesamtdokument (eine Seite)</a></li><li><a href="Operations_Research_mit_Python_Version_04.pdf" download><svg class="icon" aria-hidden="true"><use href="#icon-download"></use></svg> Download als PDF</a></li></ul></div></nav>
   <main class="content">
     <nav class="breadcrumb" aria-label="Breadcrumb"><a href="index.html">Start</a> › <span>Teil V</span> › <span>Kapitel 22: Praxisfallen und der Weg zum produktiven Einsatz</span></nav>
-    <nav class="prev-next"><a class="prev-next-knopf prev-next-prev" href="handelsmaschine.html"><svg class="icon" aria-hidden="true"><use href="#icon-chevron-left"></use></svg><span><small>Zurück</small>Kapitel 21: Die vollständige quantitative Handelsmaschine</span></a><a class="prev-next-knopf prev-next-next" href="testing.html"><span><small>Weiter</small>Kapitel 23: Testen, Messen, Ausliefern</span><svg class="icon" aria-hidden="true"><use href="#icon-chevron-right"></use></svg></a></nav>
+    <nav class="prev-next"><a class="prev-next-knopf prev-next-prev" href="synthese-anwendungen.html"><svg class="icon" aria-hidden="true"><use href="#icon-chevron-left"></use></svg><span><small>Zurück</small>Synthese Teil IV</span></a><a class="prev-next-knopf prev-next-next" href="testing.html"><span><small>Weiter</small>Kapitel 23: Testen, Messen, Ausliefern</span><svg class="icon" aria-hidden="true"><use href="#icon-chevron-right"></use></svg></a></nav>
     <article>
     <h1 id="teil-praxis">Teil V: Praxis</h1>
 <hr />
@@ -112,6 +112,7 @@
 <p><strong>Programme:</strong><br />
 <code>Infeasibility_Diagnose.py</code><br />
 <code>Erklaerbarkeit.py</code><br />
+<code>Constraint_Attribution.py</code><br />
 <code>Betriebsueberwachung.py</code><br />
 <code>or_kern.py</code><br />
 <code>Solverwechsel_CPSAT_HiGHS.py</code></p>
@@ -194,6 +195,7 @@
 <li>… die fünf typischen Praxisfallen benennen und je ein Gegenmittel nennen.</li>
 <li>… ein unlösbares Modell in einen „am wenigsten schlechten“ Plan verwandeln.</li>
 <li>… Solver-Ergebnisse erklärbar machen (<em>Explainable OR</em>).</li>
+<li>… für jede Nebenbedingung beziffern, was sie den Plan kostet — und begründen, warum der Schattenpreis diese Frage nur für die <em>nächste</em> Einheit beantwortet.</li>
 <li>… Zeitlimits und Optimalitätslücken sinnvoll setzen.</li>
 <li>… die Architektur einer produktionsreifen OR-Plattform skizzieren.</li>
 <li>… eine <strong>modellunabhängige Abnahmeprüfung</strong> schreiben, die eine Lösung gegen die Anforderungen prüft statt gegen das Modell.</li>
@@ -441,6 +443,7 @@
    Blockierend und kostenrelevant sind zwei verschiedene Dinge.
 ==============================================================================</code></pre>
 <p>Der letzte Punkt ist der eigentliche Lerneffekt: Die Obergrenze schließt Ben zwar technisch aus, aber selbst wenn er dürfte, wäre er wegen seiner Vorbelastung immer noch teurer als Anna. <strong>Eine bindende Bedingung zu lockern hilft nur, wenn sie tatsächlich die kostenrelevante ist</strong> — sonst ist die Mühe umsonst.</p>
+<p>Derselbe Unterschied kehrt auf Modellebene wieder, und dort lässt er sich in Euro beziffern: <a href="#sec:praxisfallen-attribution">Abschnitt 22.4</a> misst für jede Bedingung, was sie den ganzen Plan kostet — und baut daraus einen Bericht, den man vorlegen kann.</p>
 <h3 id="falle-3-regimewechsel-und-schätzfehler">Falle 3 — Regimewechsel und Schätzfehler</h3>
 <p>Ein Modell, das auf einer mehrjährigen Aufwärtsphase kalibriert wurde, kennt keine Liquiditätskrise und keine Zinswende.</p>
 <ul>
@@ -488,7 +491,438 @@
 <p>Dem gegenüber steht die <strong>Datenunsicherheit</strong>: Ihre Nachfrageprognose ist um ±10 % genau, Ihre Fahrzeiten um ±15 %. Die letzten 2 % Optimalität in einem Modell zu erkämpfen, dessen Eingangsdaten um 10 % schwanken, ist verlorene Zeit. <strong>Optimieren Sie nicht genauer, als Ihre Daten sind.</strong></p>
 </blockquote>
 <hr />
-<h2 id="sec:praxisfallen-architektur-einer-produktionsreifen-or-plattform">22.4 Architektur einer produktionsreifen OR-Plattform</h2>
+<h2 id="sec:praxisfallen-attribution">22.4 Constraint Attribution: welche Bedingung kostet wie viel?</h2>
+<p>Der Constraint-Trace beantwortet „warum <strong>diese</strong> Zuweisung?“. Der Deletion Filter in <a href="anhang-fehlerdiagnose.html#anhang-fehlerdiagnose">Anhang C</a> beantwortet „warum geht es <strong>gar nicht</strong>?“. Der häufigste Fall in der Praxis liegt dazwischen, und für ihn hat bisher niemand ein Werkzeug bekommen:</p>
+<blockquote>
+<p><em>Das Modell rechnet. Der Plan ist zulässig. Und trotzdem ist er enttäuschend — nur weiß niemand, woran es liegt.</em></p>
+</blockquote>
+<p>Die Antwort heißt <strong>Constraint Attribution</strong>: Jede Bedingungsgruppe wird einzeln gelockert, und gemessen wird, was sich am Zielwert ändert. Das ist dasselbe Verfahren wie der Deletion Filter — nur mit <strong>Kosten</strong> statt Zulässigkeit als Kriterium.</p>
+<p>Gerechnet wird auf derselben Fabrik wie die Konfliktsuche in <a href="anhang-fehlerdiagnose.html#anhang-fehlerdiagnose">Anhang C</a>, aber <strong>nach der Reparatur</strong>: Dort war die Lackierkapazität von 150 Stunden der Kern des Widerspruchs (<span class="math inline">2 \cdot 40 + 3 \cdot 30 = 170 &gt; 150</span>). Eine zweite Schicht hat sie auf 210 gebracht, der Mindestumsatz wurde auf 10 000 € gesenkt. Jetzt ist das Modell lösbar — und die Frage lautet nicht mehr „warum nicht?“, sondern „was kostet uns was?“.</p>
+<div class="sourceCode" id="cb5"><pre class="sourceCode python"><code class="sourceCode python"><span id="cb5-1"><a href="#cb5-1" aria-hidden="true" tabindex="-1"></a><span class="co">#!/usr/bin/env python3</span></span>
+<span id="cb5-2"><a href="#cb5-2" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb5-3"><a href="#cb5-3" aria-hidden="true" tabindex="-1"></a><span class="co"># Constraint_Attribution.py</span></span>
+<span id="cb5-4"><a href="#cb5-4" aria-hidden="true" tabindex="-1"></a><span class="co">&quot;&quot;&quot;</span></span>
+<span id="cb5-5"><a href="#cb5-5" aria-hidden="true" tabindex="-1"></a><span class="co">Kapitel Praxisfallen: Welche Bedingung kostet wie viel - und was sagt man</span></span>
+<span id="cb5-6"><a href="#cb5-6" aria-hidden="true" tabindex="-1"></a><span class="co">dem Management?</span></span>
+<span id="cb5-7"><a href="#cb5-7" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb5-8"><a href="#cb5-8" aria-hidden="true" tabindex="-1"></a><span class="co">Zwischen den beiden bekannten Faellen klafft eine Luecke:</span></span>
+<span id="cb5-9"><a href="#cb5-9" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb5-10"><a href="#cb5-10" aria-hidden="true" tabindex="-1"></a><span class="co">  * Erklaerbarkeit.py beantwortet &quot;warum diese eine Zuweisung?&quot;</span></span>
+<span id="cb5-11"><a href="#cb5-11" aria-hidden="true" tabindex="-1"></a><span class="co">  * Konfliktsuche.py (Anhang Fehlerdiagnose) beantwortet &quot;warum geht es gar</span></span>
+<span id="cb5-12"><a href="#cb5-12" aria-hidden="true" tabindex="-1"></a><span class="co">    nicht?&quot;</span></span>
+<span id="cb5-13"><a href="#cb5-13" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb5-14"><a href="#cb5-14" aria-hidden="true" tabindex="-1"></a><span class="co">Der haeufigste Fall in der Praxis liegt dazwischen: Das Modell rechnet, der</span></span>
+<span id="cb5-15"><a href="#cb5-15" aria-hidden="true" tabindex="-1"></a><span class="co">Plan ist zulaessig - und trotzdem unbefriedigend. Niemand weiss, WORAN es</span></span>
+<span id="cb5-16"><a href="#cb5-16" aria-hidden="true" tabindex="-1"></a><span class="co">liegt. Genau das beantwortet Constraint Attribution.</span></span>
+<span id="cb5-17"><a href="#cb5-17" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb5-18"><a href="#cb5-18" aria-hidden="true" tabindex="-1"></a><span class="co">Gerechnet wird auf derselben Fabrik wie in Konfliktsuche.py, nur nach der</span></span>
+<span id="cb5-19"><a href="#cb5-19" aria-hidden="true" tabindex="-1"></a><span class="co">Reparatur: Dort war die Lackierkapazitaet von 150 Stunden der Kern des</span></span>
+<span id="cb5-20"><a href="#cb5-20" aria-hidden="true" tabindex="-1"></a><span class="co">Widerspruchs (2*40 + 3*30 = 170 &gt; 150). Eine zweite Schicht hat sie auf 210</span></span>
+<span id="cb5-21"><a href="#cb5-21" aria-hidden="true" tabindex="-1"></a><span class="co">gebracht, und der Mindestumsatz wurde auf 10.000 EUR gesenkt. Jetzt ist das</span></span>
+<span id="cb5-22"><a href="#cb5-22" aria-hidden="true" tabindex="-1"></a><span class="co">Modell loesbar - und die Frage lautet nicht mehr &quot;warum nicht?&quot;, sondern</span></span>
+<span id="cb5-23"><a href="#cb5-23" aria-hidden="true" tabindex="-1"></a><span class="co">&quot;was kostet uns was?&quot;.</span></span>
+<span id="cb5-24"><a href="#cb5-24" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb5-25"><a href="#cb5-25" aria-hidden="true" tabindex="-1"></a><span class="co">Gezeigt werden vier Dinge:</span></span>
+<span id="cb5-26"><a href="#cb5-26" aria-hidden="true" tabindex="-1"></a><span class="co">  1. Welche Bedingungen binden - und dass &quot;bindend&quot; nicht &quot;teuer&quot; heisst.</span></span>
+<span id="cb5-27"><a href="#cb5-27" aria-hidden="true" tabindex="-1"></a><span class="co">  2. Dass der Schattenpreis eine MOMENTAUFNAHME ist: hochgerechnet auf eine</span></span>
+<span id="cb5-28"><a href="#cb5-28" aria-hidden="true" tabindex="-1"></a><span class="co">     realistische Sonderschicht verspricht er hier das Doppelte des</span></span>
+<span id="cb5-29"><a href="#cb5-29" aria-hidden="true" tabindex="-1"></a><span class="co">     tatsaechlichen Nutzens.</span></span>
+<span id="cb5-30"><a href="#cb5-30" aria-hidden="true" tabindex="-1"></a><span class="co">  3. Dass ein Wunsch aus dem Vertrieb nicht teuer, sondern unmoeglich sein</span></span>
+<span id="cb5-31"><a href="#cb5-31" aria-hidden="true" tabindex="-1"></a><span class="co">     kann - und welche Bedingungen ihn gemeinsam blockieren.</span></span>
+<span id="cb5-32"><a href="#cb5-32" aria-hidden="true" tabindex="-1"></a><span class="co">  4. Wie aus alledem ein Bericht in Alltagssprache wird.</span></span>
+<span id="cb5-33"><a href="#cb5-33" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb5-34"><a href="#cb5-34" aria-hidden="true" tabindex="-1"></a><span class="co">Benoetigt: numpy, scipy</span></span>
+<span id="cb5-35"><a href="#cb5-35" aria-hidden="true" tabindex="-1"></a><span class="co">&quot;&quot;&quot;</span></span>
+<span id="cb5-36"><a href="#cb5-36" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb5-37"><a href="#cb5-37" aria-hidden="true" tabindex="-1"></a><span class="im">from</span> __future__ <span class="im">import</span> annotations</span>
+<span id="cb5-38"><a href="#cb5-38" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb5-39"><a href="#cb5-39" aria-hidden="true" tabindex="-1"></a><span class="im">import</span> textwrap</span>
+<span id="cb5-40"><a href="#cb5-40" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb5-41"><a href="#cb5-41" aria-hidden="true" tabindex="-1"></a><span class="im">import</span> numpy <span class="im">as</span> np</span>
+<span id="cb5-42"><a href="#cb5-42" aria-hidden="true" tabindex="-1"></a><span class="im">from</span> scipy.optimize <span class="im">import</span> linprog</span>
+<span id="cb5-43"><a href="#cb5-43" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb5-44"><a href="#cb5-44" aria-hidden="true" tabindex="-1"></a>PRODUKTE <span class="op">=</span> [<span class="st">&quot;Rahmen&quot;</span>, <span class="st">&quot;Gehaeuse&quot;</span>, <span class="st">&quot;Deckel&quot;</span>, <span class="st">&quot;Traeger&quot;</span>, <span class="st">&quot;Halter&quot;</span>]</span>
+<span id="cb5-45"><a href="#cb5-45" aria-hidden="true" tabindex="-1"></a>DECKUNGSBEITRAG <span class="op">=</span> np.array([<span class="fl">35.0</span>, <span class="fl">28.0</span>, <span class="fl">9.0</span>, <span class="fl">22.0</span>, <span class="fl">6.0</span>])   <span class="co"># EUR je Stueck</span></span>
+<span id="cb5-46"><a href="#cb5-46" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb5-47"><a href="#cb5-47" aria-hidden="true" tabindex="-1"></a><span class="co"># Dieselben Bedingungen wie in Konfliktsuche.py, mit den beiden Reparaturen.</span></span>
+<span id="cb5-48"><a href="#cb5-48" aria-hidden="true" tabindex="-1"></a><span class="co"># Der sprechende Name ist keine Kosmetik: Ohne ihn ist kein Bericht moeglich,</span></span>
+<span id="cb5-49"><a href="#cb5-49" aria-hidden="true" tabindex="-1"></a><span class="co"># der jemandem ausserhalb der Modellierung etwas sagt.</span></span>
+<span id="cb5-50"><a href="#cb5-50" aria-hidden="true" tabindex="-1"></a>BEDINGUNGEN: <span class="bu">list</span>[<span class="bu">tuple</span>[<span class="bu">str</span>, <span class="bu">list</span>[<span class="bu">float</span>], <span class="bu">str</span>, <span class="bu">float</span>]] <span class="op">=</span> [</span>
+<span id="cb5-51"><a href="#cb5-51" aria-hidden="true" tabindex="-1"></a>    (<span class="st">&quot;Kapazitaet Montage&quot;</span>,       [<span class="dv">3</span>, <span class="dv">2</span>, <span class="dv">1</span>, <span class="dv">4</span>, <span class="dv">2</span>],      <span class="st">&quot;&lt;=&quot;</span>,   <span class="dv">400</span>),</span>
+<span id="cb5-52"><a href="#cb5-52" aria-hidden="true" tabindex="-1"></a>    (<span class="st">&quot;Kapazitaet Lackieren&quot;</span>,     [<span class="dv">2</span>, <span class="dv">3</span>, <span class="dv">0</span>, <span class="dv">1</span>, <span class="dv">0</span>],      <span class="st">&quot;&lt;=&quot;</span>,   <span class="dv">210</span>),</span>
+<span id="cb5-53"><a href="#cb5-53" aria-hidden="true" tabindex="-1"></a>    (<span class="st">&quot;Kapazitaet Pruefung&quot;</span>,      [<span class="dv">1</span>, <span class="dv">1</span>, <span class="dv">1</span>, <span class="dv">1</span>, <span class="dv">1</span>],      <span class="st">&quot;&lt;=&quot;</span>,   <span class="dv">300</span>),</span>
+<span id="cb5-54"><a href="#cb5-54" aria-hidden="true" tabindex="-1"></a>    (<span class="st">&quot;Liefervertrag Rahmen&quot;</span>,     [<span class="dv">1</span>, <span class="dv">0</span>, <span class="dv">0</span>, <span class="dv">0</span>, <span class="dv">0</span>],      <span class="st">&quot;&gt;=&quot;</span>,    <span class="dv">40</span>),</span>
+<span id="cb5-55"><a href="#cb5-55" aria-hidden="true" tabindex="-1"></a>    (<span class="st">&quot;Liefervertrag Gehaeuse&quot;</span>,   [<span class="dv">0</span>, <span class="dv">1</span>, <span class="dv">0</span>, <span class="dv">0</span>, <span class="dv">0</span>],      <span class="st">&quot;&gt;=&quot;</span>,    <span class="dv">30</span>),</span>
+<span id="cb5-56"><a href="#cb5-56" aria-hidden="true" tabindex="-1"></a>    (<span class="st">&quot;Liefervertrag Deckel&quot;</span>,     [<span class="dv">0</span>, <span class="dv">0</span>, <span class="dv">1</span>, <span class="dv">0</span>, <span class="dv">0</span>],      <span class="st">&quot;&gt;=&quot;</span>,    <span class="dv">20</span>),</span>
+<span id="cb5-57"><a href="#cb5-57" aria-hidden="true" tabindex="-1"></a>    (<span class="st">&quot;Liefervertrag Traeger&quot;</span>,    [<span class="dv">0</span>, <span class="dv">0</span>, <span class="dv">0</span>, <span class="dv">1</span>, <span class="dv">0</span>],      <span class="st">&quot;&gt;=&quot;</span>,    <span class="dv">25</span>),</span>
+<span id="cb5-58"><a href="#cb5-58" aria-hidden="true" tabindex="-1"></a>    (<span class="st">&quot;Marktgrenze Rahmen&quot;</span>,       [<span class="dv">1</span>, <span class="dv">0</span>, <span class="dv">0</span>, <span class="dv">0</span>, <span class="dv">0</span>],      <span class="st">&quot;&lt;=&quot;</span>,   <span class="dv">120</span>),</span>
+<span id="cb5-59"><a href="#cb5-59" aria-hidden="true" tabindex="-1"></a>    (<span class="st">&quot;Marktgrenze Gehaeuse&quot;</span>,     [<span class="dv">0</span>, <span class="dv">1</span>, <span class="dv">0</span>, <span class="dv">0</span>, <span class="dv">0</span>],      <span class="st">&quot;&lt;=&quot;</span>,    <span class="dv">90</span>),</span>
+<span id="cb5-60"><a href="#cb5-60" aria-hidden="true" tabindex="-1"></a>    (<span class="st">&quot;Marktgrenze Deckel&quot;</span>,       [<span class="dv">0</span>, <span class="dv">0</span>, <span class="dv">1</span>, <span class="dv">0</span>, <span class="dv">0</span>],      <span class="st">&quot;&lt;=&quot;</span>,   <span class="dv">150</span>),</span>
+<span id="cb5-61"><a href="#cb5-61" aria-hidden="true" tabindex="-1"></a>    (<span class="st">&quot;Marktgrenze Halter&quot;</span>,       [<span class="dv">0</span>, <span class="dv">0</span>, <span class="dv">0</span>, <span class="dv">0</span>, <span class="dv">1</span>],      <span class="st">&quot;&lt;=&quot;</span>,   <span class="dv">200</span>),</span>
+<span id="cb5-62"><a href="#cb5-62" aria-hidden="true" tabindex="-1"></a>    (<span class="st">&quot;Mindestumsatz&quot;</span>,            [<span class="dv">90</span>, <span class="dv">70</span>, <span class="dv">30</span>, <span class="dv">60</span>, <span class="dv">20</span>], <span class="st">&quot;&gt;=&quot;</span>, <span class="dv">10000</span>),</span>
+<span id="cb5-63"><a href="#cb5-63" aria-hidden="true" tabindex="-1"></a>    (<span class="st">&quot;Sortimentsbreite&quot;</span>,         [<span class="dv">0</span>, <span class="dv">0</span>, <span class="dv">1</span>, <span class="dv">1</span>, <span class="dv">1</span>],      <span class="st">&quot;&gt;=&quot;</span>,   <span class="dv">100</span>),</span>
+<span id="cb5-64"><a href="#cb5-64" aria-hidden="true" tabindex="-1"></a>    (<span class="st">&quot;Lackierbudget Schicht 2&quot;</span>,  [<span class="dv">0</span>, <span class="dv">1</span>, <span class="dv">0</span>, <span class="dv">1</span>, <span class="dv">0</span>],      <span class="st">&quot;&lt;=&quot;</span>,    <span class="dv">55</span>),</span>
+<span id="cb5-65"><a href="#cb5-65" aria-hidden="true" tabindex="-1"></a>]</span>
+<span id="cb5-66"><a href="#cb5-66" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb5-67"><a href="#cb5-67" aria-hidden="true" tabindex="-1"></a><span class="co"># Was liesse sich im Ernstfall wirklich bewegen - und um wie viel? Nicht &quot;eine</span></span>
+<span id="cb5-68"><a href="#cb5-68" aria-hidden="true" tabindex="-1"></a><span class="co"># Einheit&quot;, sondern der Schritt, den ein Planer tatsaechlich gehen kann: eine</span></span>
+<span id="cb5-69"><a href="#cb5-69" aria-hidden="true" tabindex="-1"></a><span class="co"># Sonderschicht, ein nachverhandelter Vertrag. Genau an dieser Groesse</span></span>
+<span id="cb5-70"><a href="#cb5-70" aria-hidden="true" tabindex="-1"></a><span class="co"># scheitert das blosse Hochrechnen des Schattenpreises.</span></span>
+<span id="cb5-71"><a href="#cb5-71" aria-hidden="true" tabindex="-1"></a>STELLSCHRAUBEN: <span class="bu">dict</span>[<span class="bu">str</span>, <span class="bu">tuple</span>[<span class="bu">float</span>, <span class="bu">str</span>]] <span class="op">=</span> {</span>
+<span id="cb5-72"><a href="#cb5-72" aria-hidden="true" tabindex="-1"></a>    <span class="st">&quot;Kapazitaet Montage&quot;</span>:      (<span class="op">+</span><span class="dv">50</span>, <span class="st">&quot;eine Sonderschicht Montage&quot;</span>),</span>
+<span id="cb5-73"><a href="#cb5-73" aria-hidden="true" tabindex="-1"></a>    <span class="st">&quot;Kapazitaet Lackieren&quot;</span>:    (<span class="op">+</span><span class="dv">30</span>, <span class="st">&quot;eine Sonderschicht Lackieren&quot;</span>),</span>
+<span id="cb5-74"><a href="#cb5-74" aria-hidden="true" tabindex="-1"></a>    <span class="st">&quot;Kapazitaet Pruefung&quot;</span>:     (<span class="op">+</span><span class="dv">50</span>, <span class="st">&quot;eine Sonderschicht Pruefung&quot;</span>),</span>
+<span id="cb5-75"><a href="#cb5-75" aria-hidden="true" tabindex="-1"></a>    <span class="st">&quot;Lackierbudget Schicht 2&quot;</span>: (<span class="op">+</span><span class="dv">10</span>, <span class="st">&quot;10 Stunden mehr Budget in Schicht 2&quot;</span>),</span>
+<span id="cb5-76"><a href="#cb5-76" aria-hidden="true" tabindex="-1"></a>    <span class="st">&quot;Liefervertrag Traeger&quot;</span>:   (<span class="op">-</span><span class="dv">10</span>, <span class="st">&quot;10 Stueck weniger Abnahmepflicht Traeger&quot;</span>),</span>
+<span id="cb5-77"><a href="#cb5-77" aria-hidden="true" tabindex="-1"></a>    <span class="st">&quot;Liefervertrag Gehaeuse&quot;</span>:  (<span class="op">-</span><span class="dv">10</span>, <span class="st">&quot;10 Stueck weniger Abnahmepflicht Gehaeuse&quot;</span>),</span>
+<span id="cb5-78"><a href="#cb5-78" aria-hidden="true" tabindex="-1"></a>}</span>
+<span id="cb5-79"><a href="#cb5-79" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb5-80"><a href="#cb5-80" aria-hidden="true" tabindex="-1"></a>WUNSCH_MENGE <span class="op">=</span> <span class="fl">55.0</span>      <span class="co"># der Vertrieb haette gern mehr Rahmen</span></span>
+<span id="cb5-81"><a href="#cb5-81" aria-hidden="true" tabindex="-1"></a>WUNSCH_PRODUKT <span class="op">=</span> <span class="st">&quot;Rahmen&quot;</span></span>
+<span id="cb5-82"><a href="#cb5-82" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb5-83"><a href="#cb5-83" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb5-84"><a href="#cb5-84" aria-hidden="true" tabindex="-1"></a><span class="kw">def</span> loese(bedingungen: <span class="bu">list</span>[<span class="bu">tuple</span>[<span class="bu">str</span>, <span class="bu">list</span>[<span class="bu">float</span>], <span class="bu">str</span>, <span class="bu">float</span>]]):</span>
+<span id="cb5-85"><a href="#cb5-85" aria-hidden="true" tabindex="-1"></a>    <span class="co">&quot;&quot;&quot;Maximiert den Deckungsbeitrag. linprog minimiert, daher das Vorzeichen.&quot;&quot;&quot;</span></span>
+<span id="cb5-86"><a href="#cb5-86" aria-hidden="true" tabindex="-1"></a>    matrix, rechte_seite <span class="op">=</span> [], []</span>
+<span id="cb5-87"><a href="#cb5-87" aria-hidden="true" tabindex="-1"></a>    <span class="cf">for</span> _, koeffizienten, richtung, grenze <span class="kw">in</span> bedingungen:</span>
+<span id="cb5-88"><a href="#cb5-88" aria-hidden="true" tabindex="-1"></a>        zeile <span class="op">=</span> np.array(koeffizienten, dtype<span class="op">=</span><span class="bu">float</span>)</span>
+<span id="cb5-89"><a href="#cb5-89" aria-hidden="true" tabindex="-1"></a>        matrix.append(zeile <span class="cf">if</span> richtung <span class="op">==</span> <span class="st">&quot;&lt;=&quot;</span> <span class="cf">else</span> <span class="op">-</span>zeile)</span>
+<span id="cb5-90"><a href="#cb5-90" aria-hidden="true" tabindex="-1"></a>        rechte_seite.append(grenze <span class="cf">if</span> richtung <span class="op">==</span> <span class="st">&quot;&lt;=&quot;</span> <span class="cf">else</span> <span class="op">-</span>grenze)</span>
+<span id="cb5-91"><a href="#cb5-91" aria-hidden="true" tabindex="-1"></a>    <span class="cf">return</span> linprog(<span class="op">-</span>DECKUNGSBEITRAG,</span>
+<span id="cb5-92"><a href="#cb5-92" aria-hidden="true" tabindex="-1"></a>                   A_ub<span class="op">=</span>np.array(matrix), b_ub<span class="op">=</span>np.array(rechte_seite),</span>
+<span id="cb5-93"><a href="#cb5-93" aria-hidden="true" tabindex="-1"></a>                   bounds<span class="op">=</span>[(<span class="dv">0</span>, <span class="va">None</span>)] <span class="op">*</span> <span class="bu">len</span>(PRODUKTE), method<span class="op">=</span><span class="st">&quot;highs&quot;</span>)</span>
+<span id="cb5-94"><a href="#cb5-94" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb5-95"><a href="#cb5-95" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb5-96"><a href="#cb5-96" aria-hidden="true" tabindex="-1"></a><span class="kw">def</span> geaendert(name: <span class="bu">str</span>, delta: <span class="bu">float</span>,</span>
+<span id="cb5-97"><a href="#cb5-97" aria-hidden="true" tabindex="-1"></a>              basis<span class="op">=</span><span class="va">None</span>) <span class="op">-&gt;</span> <span class="bu">list</span>[<span class="bu">tuple</span>[<span class="bu">str</span>, <span class="bu">list</span>[<span class="bu">float</span>], <span class="bu">str</span>, <span class="bu">float</span>]]:</span>
+<span id="cb5-98"><a href="#cb5-98" aria-hidden="true" tabindex="-1"></a>    <span class="co">&quot;&quot;&quot;Dieselben Bedingungen, eine davon um delta verschoben.&quot;&quot;&quot;</span></span>
+<span id="cb5-99"><a href="#cb5-99" aria-hidden="true" tabindex="-1"></a>    <span class="cf">return</span> [(n, k, r, g <span class="op">+</span> delta <span class="cf">if</span> n <span class="op">==</span> name <span class="cf">else</span> g)</span>
+<span id="cb5-100"><a href="#cb5-100" aria-hidden="true" tabindex="-1"></a>            <span class="cf">for</span> n, k, r, g <span class="kw">in</span> (basis <span class="kw">or</span> BEDINGUNGEN)]</span>
+<span id="cb5-101"><a href="#cb5-101" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb5-102"><a href="#cb5-102" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb5-103"><a href="#cb5-103" aria-hidden="true" tabindex="-1"></a><span class="kw">def</span> auswertung(ergebnis, bedingungen<span class="op">=</span><span class="va">None</span>):</span>
+<span id="cb5-104"><a href="#cb5-104" aria-hidden="true" tabindex="-1"></a>    <span class="co">&quot;&quot;&quot;Schlupf und Schattenpreis je Bedingung.&quot;&quot;&quot;</span></span>
+<span id="cb5-105"><a href="#cb5-105" aria-hidden="true" tabindex="-1"></a>    x <span class="op">=</span> ergebnis.x</span>
+<span id="cb5-106"><a href="#cb5-106" aria-hidden="true" tabindex="-1"></a>    dual <span class="op">=</span> ergebnis.ineqlin.marginals</span>
+<span id="cb5-107"><a href="#cb5-107" aria-hidden="true" tabindex="-1"></a>    zeilen <span class="op">=</span> []</span>
+<span id="cb5-108"><a href="#cb5-108" aria-hidden="true" tabindex="-1"></a>    <span class="cf">for</span> i, (name, koeff, richtung, grenze) <span class="kw">in</span> <span class="bu">enumerate</span>(bedingungen <span class="kw">or</span> BEDINGUNGEN):</span>
+<span id="cb5-109"><a href="#cb5-109" aria-hidden="true" tabindex="-1"></a>        links <span class="op">=</span> <span class="bu">float</span>(np.array(koeff, dtype<span class="op">=</span><span class="bu">float</span>) <span class="op">@</span> x)</span>
+<span id="cb5-110"><a href="#cb5-110" aria-hidden="true" tabindex="-1"></a>        schlupf <span class="op">=</span> (grenze <span class="op">-</span> links) <span class="cf">if</span> richtung <span class="op">==</span> <span class="st">&quot;&lt;=&quot;</span> <span class="cf">else</span> (links <span class="op">-</span> grenze)</span>
+<span id="cb5-111"><a href="#cb5-111" aria-hidden="true" tabindex="-1"></a>        zeilen.append((name, links, richtung, grenze, schlupf, <span class="bu">abs</span>(dual[i])))</span>
+<span id="cb5-112"><a href="#cb5-112" aria-hidden="true" tabindex="-1"></a>    <span class="cf">return</span> zeilen</span>
+<span id="cb5-113"><a href="#cb5-113" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb5-114"><a href="#cb5-114" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb5-115"><a href="#cb5-115" aria-hidden="true" tabindex="-1"></a><span class="kw">def</span> blockierer(bedingungen, zusatz) <span class="op">-&gt;</span> <span class="bu">list</span>[<span class="bu">str</span>]:</span>
+<span id="cb5-116"><a href="#cb5-116" aria-hidden="true" tabindex="-1"></a>    <span class="co">&quot;&quot;&quot;Welche Bedingungen verhindern &#39;zusatz&#39; - einzeln weggelassen.</span></span>
+<span id="cb5-117"><a href="#cb5-117" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb5-118"><a href="#cb5-118" aria-hidden="true" tabindex="-1"></a><span class="co">    Dasselbe Vorgehen wie der Deletion Filter in Konfliktsuche.py, nur mit</span></span>
+<span id="cb5-119"><a href="#cb5-119" aria-hidden="true" tabindex="-1"></a><span class="co">    umgekehrtem Vorzeichen: Dort wird gesucht, was den Widerspruch AUSMACHT,</span></span>
+<span id="cb5-120"><a href="#cb5-120" aria-hidden="true" tabindex="-1"></a><span class="co">    hier, was einen Wunsch VERHINDERT. Wird das Modell ohne eine Bedingung</span></span>
+<span id="cb5-121"><a href="#cb5-121" aria-hidden="true" tabindex="-1"></a><span class="co">    loesbar, gehoert sie zum Konflikt.</span></span>
+<span id="cb5-122"><a href="#cb5-122" aria-hidden="true" tabindex="-1"></a><span class="co">    &quot;&quot;&quot;</span></span>
+<span id="cb5-123"><a href="#cb5-123" aria-hidden="true" tabindex="-1"></a>    gefunden <span class="op">=</span> []</span>
+<span id="cb5-124"><a href="#cb5-124" aria-hidden="true" tabindex="-1"></a>    <span class="cf">for</span> i, (name, _, _, _) <span class="kw">in</span> <span class="bu">enumerate</span>(bedingungen):</span>
+<span id="cb5-125"><a href="#cb5-125" aria-hidden="true" tabindex="-1"></a>        rest <span class="op">=</span> [c <span class="cf">for</span> j, c <span class="kw">in</span> <span class="bu">enumerate</span>(bedingungen) <span class="cf">if</span> j <span class="op">!=</span> i] <span class="op">+</span> [zusatz]</span>
+<span id="cb5-126"><a href="#cb5-126" aria-hidden="true" tabindex="-1"></a>        <span class="cf">if</span> loese(rest).success:</span>
+<span id="cb5-127"><a href="#cb5-127" aria-hidden="true" tabindex="-1"></a>            gefunden.append(name)</span>
+<span id="cb5-128"><a href="#cb5-128" aria-hidden="true" tabindex="-1"></a>    <span class="cf">return</span> gefunden</span>
+<span id="cb5-129"><a href="#cb5-129" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb5-130"><a href="#cb5-130" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb5-131"><a href="#cb5-131" aria-hidden="true" tabindex="-1"></a><span class="kw">def</span> euro(betrag: <span class="bu">float</span>) <span class="op">-&gt;</span> <span class="bu">str</span>:</span>
+<span id="cb5-132"><a href="#cb5-132" aria-hidden="true" tabindex="-1"></a>    <span class="cf">return</span> <span class="ss">f&quot;</span><span class="sc">{</span>betrag<span class="sc">:,.2f}</span><span class="ss"> EUR&quot;</span></span>
+<span id="cb5-133"><a href="#cb5-133" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb5-134"><a href="#cb5-134" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb5-135"><a href="#cb5-135" aria-hidden="true" tabindex="-1"></a><span class="cf">if</span> <span class="va">__name__</span> <span class="op">==</span> <span class="st">&quot;__main__&quot;</span>:</span>
+<span id="cb5-136"><a href="#cb5-136" aria-hidden="true" tabindex="-1"></a>    basis <span class="op">=</span> loese(BEDINGUNGEN)</span>
+<span id="cb5-137"><a href="#cb5-137" aria-hidden="true" tabindex="-1"></a>    db_basis <span class="op">=</span> <span class="op">-</span>basis.fun</span>
+<span id="cb5-138"><a href="#cb5-138" aria-hidden="true" tabindex="-1"></a>    plan <span class="op">=</span> <span class="bu">dict</span>(<span class="bu">zip</span>(PRODUKTE, basis.x))</span>
+<span id="cb5-139"><a href="#cb5-139" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb5-140"><a href="#cb5-140" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;=&quot;</span> <span class="op">*</span> <span class="dv">78</span>)</span>
+<span id="cb5-141"><a href="#cb5-141" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;  CONSTRAINT ATTRIBUTION: Was kostet uns welche Bedingung?&quot;</span>)</span>
+<span id="cb5-142"><a href="#cb5-142" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;=&quot;</span> <span class="op">*</span> <span class="dv">78</span>)</span>
+<span id="cb5-143"><a href="#cb5-143" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;Status: </span><span class="sc">{</span>basis<span class="sc">.</span>message<span class="sc">.</span>split(<span class="st">&#39;(&#39;</span>)[<span class="dv">0</span>]<span class="sc">.</span>strip()<span class="sc">}</span><span class="ss">&quot;</span>)</span>
+<span id="cb5-144"><a href="#cb5-144" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;Deckungsbeitrag des Plans: </span><span class="sc">{</span>euro(db_basis)<span class="sc">}</span><span class="ch">\n</span><span class="ss">&quot;</span>)</span>
+<span id="cb5-145"><a href="#cb5-145" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;  &quot;</span> <span class="op">+</span> <span class="st">&quot;  &quot;</span>.join(<span class="ss">f&quot;</span><span class="sc">{</span>p<span class="sc">}</span><span class="ss">: </span><span class="sc">{</span>m<span class="sc">:.1f}</span><span class="ss">&quot;</span> <span class="cf">for</span> p, m <span class="kw">in</span> plan.items()))</span>
+<span id="cb5-146"><a href="#cb5-146" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb5-147"><a href="#cb5-147" aria-hidden="true" tabindex="-1"></a>    <span class="co"># --- 1. Wer begrenzt den Plan? -----------------------------------------</span></span>
+<span id="cb5-148"><a href="#cb5-148" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;</span><span class="ch">\n</span><span class="st">&quot;</span> <span class="op">+</span> <span class="st">&quot;=&quot;</span> <span class="op">*</span> <span class="dv">78</span>)</span>
+<span id="cb5-149"><a href="#cb5-149" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;  (1) Welche Bedingungen binden - und was kostet die naechste Einheit?&quot;</span>)</span>
+<span id="cb5-150"><a href="#cb5-150" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;=&quot;</span> <span class="op">*</span> <span class="dv">78</span>)</span>
+<span id="cb5-151"><a href="#cb5-151" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;</span><span class="sc">{</span><span class="st">&#39;Bedingung&#39;</span><span class="sc">:&lt;24}</span><span class="ss"> </span><span class="sc">{</span><span class="st">&#39;genutzt&#39;</span><span class="sc">:&gt;9}</span><span class="ss"> </span><span class="sc">{</span><span class="st">&#39;Grenze&#39;</span><span class="sc">:&gt;7}</span><span class="ss"> </span><span class="sc">{</span><span class="st">&#39;Schlupf&#39;</span><span class="sc">:&gt;8}</span><span class="ss"> &quot;</span></span>
+<span id="cb5-152"><a href="#cb5-152" aria-hidden="true" tabindex="-1"></a>          <span class="ss">f&quot;</span><span class="sc">{</span><span class="st">&#39;Schattenpreis&#39;</span><span class="sc">:&gt;11}</span><span class="ss">&quot;</span>)</span>
+<span id="cb5-153"><a href="#cb5-153" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;-&quot;</span> <span class="op">*</span> <span class="dv">78</span>)</span>
+<span id="cb5-154"><a href="#cb5-154" aria-hidden="true" tabindex="-1"></a>    bindend <span class="op">=</span> []</span>
+<span id="cb5-155"><a href="#cb5-155" aria-hidden="true" tabindex="-1"></a>    <span class="cf">for</span> name, links, richtung, grenze, schlupf, dual <span class="kw">in</span> auswertung(basis):</span>
+<span id="cb5-156"><a href="#cb5-156" aria-hidden="true" tabindex="-1"></a>        marke <span class="op">=</span> <span class="st">&quot;&quot;</span></span>
+<span id="cb5-157"><a href="#cb5-157" aria-hidden="true" tabindex="-1"></a>        <span class="cf">if</span> <span class="bu">abs</span>(schlupf) <span class="op">&lt;</span> <span class="fl">1e-6</span>:</span>
+<span id="cb5-158"><a href="#cb5-158" aria-hidden="true" tabindex="-1"></a>            bindend.append((name, dual))</span>
+<span id="cb5-159"><a href="#cb5-159" aria-hidden="true" tabindex="-1"></a>            marke <span class="op">=</span> <span class="st">&quot;  &lt;-- bindend&quot;</span></span>
+<span id="cb5-160"><a href="#cb5-160" aria-hidden="true" tabindex="-1"></a>        <span class="bu">print</span>(<span class="ss">f&quot;</span><span class="sc">{</span>name<span class="sc">:&lt;24}</span><span class="ss"> </span><span class="sc">{</span>links<span class="sc">:&gt;9.1f}</span><span class="ss"> </span><span class="sc">{</span>grenze<span class="sc">:&gt;7.0f}</span><span class="ss"> </span><span class="sc">{</span>schlupf<span class="sc">:&gt;8.1f}</span><span class="ss"> &quot;</span></span>
+<span id="cb5-161"><a href="#cb5-161" aria-hidden="true" tabindex="-1"></a>              <span class="ss">f&quot;</span><span class="sc">{</span>dual<span class="sc">:&gt;11.2f}{</span>marke<span class="sc">}</span><span class="ss">&quot;</span>)</span>
+<span id="cb5-162"><a href="#cb5-162" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb5-163"><a href="#cb5-163" aria-hidden="true" tabindex="-1"></a>    ohne_preis <span class="op">=</span> [n <span class="cf">for</span> n, d <span class="kw">in</span> bindend <span class="cf">if</span> d <span class="op">&lt;</span> <span class="fl">1e-9</span>]</span>
+<span id="cb5-164"><a href="#cb5-164" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;</span><span class="ch">\n</span><span class="ss">  </span><span class="sc">{</span><span class="bu">len</span>(bindend)<span class="sc">}</span><span class="ss"> Bedingungen binden. Aber: &quot;</span></span>
+<span id="cb5-165"><a href="#cb5-165" aria-hidden="true" tabindex="-1"></a>          <span class="ss">f&quot;</span><span class="sc">{</span><span class="st">&#39;, &#39;</span><span class="sc">.</span>join(ohne_preis)<span class="sc">}</span><span class="ss"> bindet&quot;</span>)</span>
+<span id="cb5-166"><a href="#cb5-166" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;  mit einem Schattenpreis von 0,00 EUR - sie beruehrt den Plan, ohne ihn&quot;</span>)</span>
+<span id="cb5-167"><a href="#cb5-167" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;  zu verteuern. Bindend und kostenrelevant sind zwei verschiedene Dinge.&quot;</span>)</span>
+<span id="cb5-168"><a href="#cb5-168" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb5-169"><a href="#cb5-169" aria-hidden="true" tabindex="-1"></a>    <span class="co"># --- 2. Der Schattenpreis als Momentaufnahme ---------------------------</span></span>
+<span id="cb5-170"><a href="#cb5-170" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;</span><span class="ch">\n</span><span class="st">&quot;</span> <span class="op">+</span> <span class="st">&quot;=&quot;</span> <span class="op">*</span> <span class="dv">78</span>)</span>
+<span id="cb5-171"><a href="#cb5-171" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;  (2) Was der Schattenpreis verschweigt&quot;</span>)</span>
+<span id="cb5-172"><a href="#cb5-172" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;=&quot;</span> <span class="op">*</span> <span class="dv">78</span>)</span>
+<span id="cb5-173"><a href="#cb5-173" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;Der Schattenpreis gilt fuer die NAECHSTE Einheit. Ein Planer kauft aber&quot;</span>)</span>
+<span id="cb5-174"><a href="#cb5-174" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;keine Einheit, sondern eine ganze Schicht. Beides gegenuebergestellt:</span><span class="ch">\n</span><span class="st">&quot;</span>)</span>
+<span id="cb5-175"><a href="#cb5-175" aria-hidden="true" tabindex="-1"></a>    preise <span class="op">=</span> {name: dual <span class="cf">for</span> name, <span class="op">*</span>_, dual <span class="kw">in</span> auswertung(basis)}</span>
+<span id="cb5-176"><a href="#cb5-176" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;</span><span class="sc">{</span><span class="st">&#39;Stellschraube&#39;</span><span class="sc">:&lt;24}</span><span class="ss"> </span><span class="sc">{</span><span class="st">&#39;Preis&#39;</span><span class="sc">:&gt;9}</span><span class="ss"> </span><span class="sc">{</span><span class="st">&#39;Schritt&#39;</span><span class="sc">:&gt;7}</span><span class="ss"> &quot;</span></span>
+<span id="cb5-177"><a href="#cb5-177" aria-hidden="true" tabindex="-1"></a>          <span class="ss">f&quot;</span><span class="sc">{</span><span class="st">&#39;hochgerechnet&#39;</span><span class="sc">:&gt;13}</span><span class="ss"> </span><span class="sc">{</span><span class="st">&#39;gemessen&#39;</span><span class="sc">:&gt;9}</span><span class="ss"> </span><span class="sc">{</span><span class="st">&#39;Abw.&#39;</span><span class="sc">:&gt;9}</span><span class="ss">&quot;</span>)</span>
+<span id="cb5-178"><a href="#cb5-178" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;-&quot;</span> <span class="op">*</span> <span class="dv">78</span>)</span>
+<span id="cb5-179"><a href="#cb5-179" aria-hidden="true" tabindex="-1"></a>    wirkung <span class="op">=</span> {}</span>
+<span id="cb5-180"><a href="#cb5-180" aria-hidden="true" tabindex="-1"></a>    <span class="cf">for</span> name, (delta, _) <span class="kw">in</span> STELLSCHRAUBEN.items():</span>
+<span id="cb5-181"><a href="#cb5-181" aria-hidden="true" tabindex="-1"></a>        ergebnis <span class="op">=</span> loese(geaendert(name, delta))</span>
+<span id="cb5-182"><a href="#cb5-182" aria-hidden="true" tabindex="-1"></a>        echt <span class="op">=</span> (<span class="op">-</span>ergebnis.fun) <span class="op">-</span> db_basis <span class="cf">if</span> ergebnis.success <span class="cf">else</span> <span class="fl">0.0</span></span>
+<span id="cb5-183"><a href="#cb5-183" aria-hidden="true" tabindex="-1"></a>        linear <span class="op">=</span> preise[name] <span class="op">*</span> <span class="bu">abs</span>(delta)</span>
+<span id="cb5-184"><a href="#cb5-184" aria-hidden="true" tabindex="-1"></a>        wirkung[name] <span class="op">=</span> echt</span>
+<span id="cb5-185"><a href="#cb5-185" aria-hidden="true" tabindex="-1"></a>        <span class="bu">print</span>(<span class="ss">f&quot;</span><span class="sc">{</span>name<span class="sc">:&lt;24}</span><span class="ss"> </span><span class="sc">{</span>preise[name]<span class="sc">:&gt;9.2f}</span><span class="ss"> </span><span class="sc">{</span>delta<span class="sc">:&gt;+7.0f}</span><span class="ss"> &quot;</span></span>
+<span id="cb5-186"><a href="#cb5-186" aria-hidden="true" tabindex="-1"></a>              <span class="ss">f&quot;</span><span class="sc">{</span>linear<span class="sc">:&gt;13.2f}</span><span class="ss"> </span><span class="sc">{</span>echt<span class="sc">:&gt;9.2f}</span><span class="ss"> </span><span class="sc">{</span>echt <span class="op">-</span> linear<span class="sc">:&gt;+9.2f}</span><span class="ss">&quot;</span>)</span>
+<span id="cb5-187"><a href="#cb5-187" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb5-188"><a href="#cb5-188" aria-hidden="true" tabindex="-1"></a>    <span class="co"># Wo endet der Gueltigkeitsbereich? Schrittweise nachfahren.</span></span>
+<span id="cb5-189"><a href="#cb5-189" aria-hidden="true" tabindex="-1"></a>    abweichler <span class="op">=</span> <span class="bu">max</span>(STELLSCHRAUBEN,</span>
+<span id="cb5-190"><a href="#cb5-190" aria-hidden="true" tabindex="-1"></a>                     key<span class="op">=</span><span class="kw">lambda</span> n: preise[n] <span class="op">*</span> <span class="bu">abs</span>(STELLSCHRAUBEN[n][<span class="dv">0</span>]) <span class="op">-</span> wirkung[n])</span>
+<span id="cb5-191"><a href="#cb5-191" aria-hidden="true" tabindex="-1"></a>    delta_max <span class="op">=</span> STELLSCHRAUBEN[abweichler][<span class="dv">0</span>]</span>
+<span id="cb5-192"><a href="#cb5-192" aria-hidden="true" tabindex="-1"></a>    grenze_gueltig <span class="op">=</span> <span class="fl">0.0</span></span>
+<span id="cb5-193"><a href="#cb5-193" aria-hidden="true" tabindex="-1"></a>    schritt <span class="op">=</span> delta_max <span class="op">/</span> <span class="fl">60.0</span></span>
+<span id="cb5-194"><a href="#cb5-194" aria-hidden="true" tabindex="-1"></a>    vorher <span class="op">=</span> db_basis</span>
+<span id="cb5-195"><a href="#cb5-195" aria-hidden="true" tabindex="-1"></a>    <span class="cf">for</span> i <span class="kw">in</span> <span class="bu">range</span>(<span class="dv">1</span>, <span class="dv">61</span>):</span>
+<span id="cb5-196"><a href="#cb5-196" aria-hidden="true" tabindex="-1"></a>        d <span class="op">=</span> schritt <span class="op">*</span> i</span>
+<span id="cb5-197"><a href="#cb5-197" aria-hidden="true" tabindex="-1"></a>        e <span class="op">=</span> loese(geaendert(abweichler, d))</span>
+<span id="cb5-198"><a href="#cb5-198" aria-hidden="true" tabindex="-1"></a>        db <span class="op">=</span> <span class="op">-</span>e.fun <span class="cf">if</span> e.success <span class="cf">else</span> vorher</span>
+<span id="cb5-199"><a href="#cb5-199" aria-hidden="true" tabindex="-1"></a>        <span class="cf">if</span> db <span class="op">-</span> vorher <span class="op">&gt;</span> <span class="fl">1e-9</span>:</span>
+<span id="cb5-200"><a href="#cb5-200" aria-hidden="true" tabindex="-1"></a>            grenze_gueltig <span class="op">=</span> d</span>
+<span id="cb5-201"><a href="#cb5-201" aria-hidden="true" tabindex="-1"></a>        vorher <span class="op">=</span> db</span>
+<span id="cb5-202"><a href="#cb5-202" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;</span><span class="ch">\n</span><span class="ss">  &#39;</span><span class="sc">{</span>abweichler<span class="sc">}</span><span class="ss">&#39;: hochgerechnet &quot;</span></span>
+<span id="cb5-203"><a href="#cb5-203" aria-hidden="true" tabindex="-1"></a>          <span class="ss">f&quot;</span><span class="sc">{</span>preise[abweichler] <span class="op">*</span> <span class="bu">abs</span>(delta_max)<span class="sc">:.2f}</span><span class="ss"> EUR, tatsaechlich &quot;</span></span>
+<span id="cb5-204"><a href="#cb5-204" aria-hidden="true" tabindex="-1"></a>          <span class="ss">f&quot;</span><span class="sc">{</span>wirkung[abweichler]<span class="sc">:.2f}</span><span class="ss"> EUR.&quot;</span>)</span>
+<span id="cb5-205"><a href="#cb5-205" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;  Der Preis von </span><span class="sc">{</span>preise[abweichler]<span class="sc">:.2f}</span><span class="ss"> EUR gilt nur bis &quot;</span></span>
+<span id="cb5-206"><a href="#cb5-206" aria-hidden="true" tabindex="-1"></a>          <span class="ss">f&quot;+</span><span class="sc">{</span>grenze_gueltig<span class="sc">:.0f}</span><span class="ss"> Stunden. Jede weitere Stunde&quot;</span>)</span>
+<span id="cb5-207"><a href="#cb5-207" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;  dieser Sonderschicht bringt exakt nichts - der Engpass ist dann ein anderer.&quot;</span>)</span>
+<span id="cb5-208"><a href="#cb5-208" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb5-209"><a href="#cb5-209" aria-hidden="true" tabindex="-1"></a>    nach_preis <span class="op">=</span> <span class="bu">sorted</span>(STELLSCHRAUBEN, key<span class="op">=</span><span class="kw">lambda</span> n: <span class="op">-</span>preise[n])[<span class="dv">0</span>]</span>
+<span id="cb5-210"><a href="#cb5-210" aria-hidden="true" tabindex="-1"></a>    nach_wirkung <span class="op">=</span> <span class="bu">max</span>(wirkung, key<span class="op">=</span>wirkung.get)</span>
+<span id="cb5-211"><a href="#cb5-211" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;</span><span class="ch">\n</span><span class="ss">  Und die Ranglisten drehen sich: Nach Schattenpreis fuehrt&quot;</span>)</span>
+<span id="cb5-212"><a href="#cb5-212" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;  &#39;</span><span class="sc">{</span>nach_preis<span class="sc">}</span><span class="ss">&#39; (</span><span class="sc">{</span>preise[nach_preis]<span class="sc">:.2f}</span><span class="ss"> EUR je Einheit),&quot;</span>)</span>
+<span id="cb5-213"><a href="#cb5-213" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;  nach tatsaechlicher Wirkung &#39;</span><span class="sc">{</span>nach_wirkung<span class="sc">}</span><span class="ss">&#39; &quot;</span></span>
+<span id="cb5-214"><a href="#cb5-214" aria-hidden="true" tabindex="-1"></a>          <span class="ss">f&quot;(</span><span class="sc">{</span>wirkung[nach_wirkung]<span class="sc">:.2f}</span><span class="ss"> EUR).&quot;</span>)</span>
+<span id="cb5-215"><a href="#cb5-215" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;  Der Schattenpreis sagt, was eine Einheit wert ist - nicht, wie viele&quot;</span>)</span>
+<span id="cb5-216"><a href="#cb5-216" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;  Einheiten zu haben sind.&quot;</span>)</span>
+<span id="cb5-217"><a href="#cb5-217" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb5-218"><a href="#cb5-218" aria-hidden="true" tabindex="-1"></a>    <span class="co"># --- 3. Der Wunsch aus dem Vertrieb ------------------------------------</span></span>
+<span id="cb5-219"><a href="#cb5-219" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;</span><span class="ch">\n</span><span class="st">&quot;</span> <span class="op">+</span> <span class="st">&quot;=&quot;</span> <span class="op">*</span> <span class="dv">78</span>)</span>
+<span id="cb5-220"><a href="#cb5-220" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;  (3) Was-waere-wenn: mindestens </span><span class="sc">{</span>WUNSCH_MENGE<span class="sc">:.0f}</span><span class="ss"> &quot;</span></span>
+<span id="cb5-221"><a href="#cb5-221" aria-hidden="true" tabindex="-1"></a>          <span class="ss">f&quot;</span><span class="sc">{</span>WUNSCH_PRODUKT<span class="sc">}</span><span class="ss"> statt </span><span class="sc">{</span>plan[WUNSCH_PRODUKT]<span class="sc">:.1f}</span><span class="ss">&quot;</span>)</span>
+<span id="cb5-222"><a href="#cb5-222" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;=&quot;</span> <span class="op">*</span> <span class="dv">78</span>)</span>
+<span id="cb5-223"><a href="#cb5-223" aria-hidden="true" tabindex="-1"></a>    wunsch <span class="op">=</span> (<span class="ss">f&quot;Wunsch Vertrieb </span><span class="sc">{</span>WUNSCH_PRODUKT<span class="sc">}</span><span class="ss">&quot;</span>,</span>
+<span id="cb5-224"><a href="#cb5-224" aria-hidden="true" tabindex="-1"></a>              [<span class="dv">1</span> <span class="cf">if</span> p <span class="op">==</span> WUNSCH_PRODUKT <span class="cf">else</span> <span class="dv">0</span> <span class="cf">for</span> p <span class="kw">in</span> PRODUKTE], <span class="st">&quot;&gt;=&quot;</span>, WUNSCH_MENGE)</span>
+<span id="cb5-225"><a href="#cb5-225" aria-hidden="true" tabindex="-1"></a>    mit_wunsch <span class="op">=</span> loese(BEDINGUNGEN <span class="op">+</span> [wunsch])</span>
+<span id="cb5-226"><a href="#cb5-226" aria-hidden="true" tabindex="-1"></a>    schuldige: <span class="bu">list</span>[<span class="bu">str</span>] <span class="op">=</span> []</span>
+<span id="cb5-227"><a href="#cb5-227" aria-hidden="true" tabindex="-1"></a>    engpass <span class="op">=</span> noetig <span class="op">=</span> <span class="va">None</span></span>
+<span id="cb5-228"><a href="#cb5-228" aria-hidden="true" tabindex="-1"></a>    wunsch_gratis <span class="op">=</span> <span class="va">False</span></span>
+<span id="cb5-229"><a href="#cb5-229" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb5-230"><a href="#cb5-230" aria-hidden="true" tabindex="-1"></a>    <span class="cf">if</span> mit_wunsch.success:</span>
+<span id="cb5-231"><a href="#cb5-231" aria-hidden="true" tabindex="-1"></a>        <span class="bu">print</span>(<span class="ss">f&quot;Erfuellbar, kostet </span><span class="sc">{</span>euro(db_basis <span class="op">-</span> (<span class="op">-</span>mit_wunsch.fun))<span class="sc">}</span><span class="ss">.&quot;</span>)</span>
+<span id="cb5-232"><a href="#cb5-232" aria-hidden="true" tabindex="-1"></a>    <span class="cf">else</span>:</span>
+<span id="cb5-233"><a href="#cb5-233" aria-hidden="true" tabindex="-1"></a>        schuldige <span class="op">=</span> blockierer(BEDINGUNGEN, wunsch)</span>
+<span id="cb5-234"><a href="#cb5-234" aria-hidden="true" tabindex="-1"></a>        <span class="bu">print</span>(<span class="st">&quot;Der Wunsch ist nicht teuer - er ist UNMOEGLICH.</span><span class="ch">\n</span><span class="st">&quot;</span>)</span>
+<span id="cb5-235"><a href="#cb5-235" aria-hidden="true" tabindex="-1"></a>        <span class="bu">print</span>(<span class="ss">f&quot;Blockiert wird er von </span><span class="sc">{</span><span class="bu">len</span>(schuldige)<span class="sc">}</span><span class="ss"> Bedingungen gemeinsam. &quot;</span></span>
+<span id="cb5-236"><a href="#cb5-236" aria-hidden="true" tabindex="-1"></a>              <span class="ss">f&quot;Faellt eine davon&quot;</span>)</span>
+<span id="cb5-237"><a href="#cb5-237" aria-hidden="true" tabindex="-1"></a>        <span class="bu">print</span>(<span class="st">&quot;weg, ist er erfuellbar; keine allein ist &#39;der&#39; Grund:&quot;</span>)</span>
+<span id="cb5-238"><a href="#cb5-238" aria-hidden="true" tabindex="-1"></a>        <span class="cf">for</span> name <span class="kw">in</span> schuldige:</span>
+<span id="cb5-239"><a href="#cb5-239" aria-hidden="true" tabindex="-1"></a>            e <span class="op">=</span> loese([c <span class="cf">for</span> c <span class="kw">in</span> BEDINGUNGEN <span class="cf">if</span> c[<span class="dv">0</span>] <span class="op">!=</span> name] <span class="op">+</span> [wunsch])</span>
+<span id="cb5-240"><a href="#cb5-240" aria-hidden="true" tabindex="-1"></a>            <span class="bu">print</span>(<span class="ss">f&quot;   ohne &#39;</span><span class="sc">{</span>name<span class="sc">}</span><span class="ss">&#39;: moeglich, Deckungsbeitrag </span><span class="sc">{</span>euro(<span class="op">-</span>e.fun)<span class="sc">}</span><span class="ss">&quot;</span>)</span>
+<span id="cb5-241"><a href="#cb5-241" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb5-242"><a href="#cb5-242" aria-hidden="true" tabindex="-1"></a>        engpass <span class="op">=</span> <span class="bu">next</span>((n <span class="cf">for</span> n <span class="kw">in</span> schuldige <span class="cf">if</span> n <span class="kw">in</span> STELLSCHRAUBEN), schuldige[<span class="dv">0</span>])</span>
+<span id="cb5-243"><a href="#cb5-243" aria-hidden="true" tabindex="-1"></a>        <span class="cf">for</span> schritt <span class="kw">in</span> <span class="bu">range</span>(<span class="dv">1</span>, <span class="dv">61</span>):</span>
+<span id="cb5-244"><a href="#cb5-244" aria-hidden="true" tabindex="-1"></a>            <span class="cf">if</span> loese(geaendert(engpass, schritt) <span class="op">+</span> [wunsch]).success:</span>
+<span id="cb5-245"><a href="#cb5-245" aria-hidden="true" tabindex="-1"></a>                noetig <span class="op">=</span> schritt</span>
+<span id="cb5-246"><a href="#cb5-246" aria-hidden="true" tabindex="-1"></a>                <span class="cf">break</span></span>
+<span id="cb5-247"><a href="#cb5-247" aria-hidden="true" tabindex="-1"></a>        <span class="cf">if</span> noetig <span class="kw">is</span> <span class="kw">not</span> <span class="va">None</span>:</span>
+<span id="cb5-248"><a href="#cb5-248" aria-hidden="true" tabindex="-1"></a>            e <span class="op">=</span> loese(geaendert(engpass, noetig) <span class="op">+</span> [wunsch])</span>
+<span id="cb5-249"><a href="#cb5-249" aria-hidden="true" tabindex="-1"></a>            ohne <span class="op">=</span> loese(geaendert(engpass, noetig))</span>
+<span id="cb5-250"><a href="#cb5-250" aria-hidden="true" tabindex="-1"></a>            wunsch_gratis <span class="op">=</span> <span class="bu">abs</span>((<span class="op">-</span>e.fun) <span class="op">-</span> (<span class="op">-</span>ohne.fun)) <span class="op">&lt;</span> <span class="fl">1e-6</span></span>
+<span id="cb5-251"><a href="#cb5-251" aria-hidden="true" tabindex="-1"></a>            <span class="bu">print</span>(<span class="ss">f&quot;</span><span class="ch">\n</span><span class="ss">   Mit +</span><span class="sc">{</span>noetig<span class="sc">}</span><span class="ss"> bei &#39;</span><span class="sc">{</span>engpass<span class="sc">}</span><span class="ss">&#39; wird der Wunsch erfuellbar:&quot;</span>)</span>
+<span id="cb5-252"><a href="#cb5-252" aria-hidden="true" tabindex="-1"></a>            <span class="bu">print</span>(<span class="ss">f&quot;   Deckungsbeitrag </span><span class="sc">{</span>euro(<span class="op">-</span>e.fun)<span class="sc">}</span><span class="ss"> &quot;</span></span>
+<span id="cb5-253"><a href="#cb5-253" aria-hidden="true" tabindex="-1"></a>                  <span class="ss">f&quot;(</span><span class="sc">{</span><span class="op">-</span>e<span class="sc">.</span>fun <span class="op">-</span> db_basis<span class="sc">:+,.2f}</span><span class="ss"> gegenueber heute).&quot;</span>)</span>
+<span id="cb5-254"><a href="#cb5-254" aria-hidden="true" tabindex="-1"></a>            <span class="cf">if</span> wunsch_gratis:</span>
+<span id="cb5-255"><a href="#cb5-255" aria-hidden="true" tabindex="-1"></a>                <span class="bu">print</span>(<span class="ss">f&quot;   Und ohne den Wunsch ergaebe dieselbe Lockerung &quot;</span></span>
+<span id="cb5-256"><a href="#cb5-256" aria-hidden="true" tabindex="-1"></a>                      <span class="ss">f&quot;</span><span class="sc">{</span>euro(<span class="op">-</span>ohne.fun)<span class="sc">}</span><span class="ss"> bei&quot;</span>)</span>
+<span id="cb5-257"><a href="#cb5-257" aria-hidden="true" tabindex="-1"></a>                <span class="bu">print</span>(<span class="ss">f&quot;   </span><span class="sc">{</span>ohne<span class="sc">.</span>x[PRODUKTE.index(WUNSCH_PRODUKT)]<span class="sc">:.0f}</span><span class="ss"> &quot;</span></span>
+<span id="cb5-258"><a href="#cb5-258" aria-hidden="true" tabindex="-1"></a>                      <span class="ss">f&quot;</span><span class="sc">{</span>WUNSCH_PRODUKT<span class="sc">}</span><span class="ss"> - der Wunsch kostet also NICHTS.&quot;</span>)</span>
+<span id="cb5-259"><a href="#cb5-259" aria-hidden="true" tabindex="-1"></a>                <span class="bu">print</span>(<span class="st">&quot;   Er war nie das Problem. Der Engpass war es.&quot;</span>)</span>
+<span id="cb5-260"><a href="#cb5-260" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb5-261"><a href="#cb5-261" aria-hidden="true" tabindex="-1"></a>    <span class="co"># --- 4. Der Bericht ----------------------------------------------------</span></span>
+<span id="cb5-262"><a href="#cb5-262" aria-hidden="true" tabindex="-1"></a>    <span class="co"># Aus denselben Zahlen, die oben in Tabellen stehen, wird hier Prosa. Kein</span></span>
+<span id="cb5-263"><a href="#cb5-263" aria-hidden="true" tabindex="-1"></a>    <span class="co"># Satz enthaelt eine Zahl, die nicht vorher gerechnet wurde - das ist der</span></span>
+<span id="cb5-264"><a href="#cb5-264" aria-hidden="true" tabindex="-1"></a>    <span class="co"># ganze Trick und zugleich die Bedingung dafuer, dass der Bericht nicht</span></span>
+<span id="cb5-265"><a href="#cb5-265" aria-hidden="true" tabindex="-1"></a>    <span class="co"># irgendwann leise falsch wird.</span></span>
+<span id="cb5-266"><a href="#cb5-266" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;</span><span class="ch">\n</span><span class="st">&quot;</span> <span class="op">+</span> <span class="st">&quot;=&quot;</span> <span class="op">*</span> <span class="dv">78</span>)</span>
+<span id="cb5-267"><a href="#cb5-267" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;  (4) Und so steht es in der Vorlage fuer die Abteilungsleiterrunde&quot;</span>)</span>
+<span id="cb5-268"><a href="#cb5-268" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;=&quot;</span> <span class="op">*</span> <span class="dv">78</span>)</span>
+<span id="cb5-269"><a href="#cb5-269" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb5-270"><a href="#cb5-270" aria-hidden="true" tabindex="-1"></a>    teuerste <span class="op">=</span> <span class="bu">sorted</span>(((n, d) <span class="cf">for</span> n, d <span class="kw">in</span> bindend <span class="cf">if</span> d <span class="op">&gt;</span> <span class="dv">0</span>), key<span class="op">=</span><span class="kw">lambda</span> t: <span class="op">-</span>t[<span class="dv">1</span>])</span>
+<span id="cb5-271"><a href="#cb5-271" aria-hidden="true" tabindex="-1"></a>    gross <span class="op">=</span> STELLSCHRAUBEN[nach_wirkung][<span class="dv">1</span>]</span>
+<span id="cb5-272"><a href="#cb5-272" aria-hidden="true" tabindex="-1"></a>    klein <span class="op">=</span> STELLSCHRAUBEN[abweichler][<span class="dv">1</span>]</span>
+<span id="cb5-273"><a href="#cb5-273" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb5-274"><a href="#cb5-274" aria-hidden="true" tabindex="-1"></a>    absaetze <span class="op">=</span> [</span>
+<span id="cb5-275"><a href="#cb5-275" aria-hidden="true" tabindex="-1"></a>        <span class="ss">f&quot;Der Plan bringt </span><span class="sc">{</span>euro(db_basis)<span class="sc">}</span><span class="ss"> Deckungsbeitrag. Begrenzt wird er von &quot;</span></span>
+<span id="cb5-276"><a href="#cb5-276" aria-hidden="true" tabindex="-1"></a>        <span class="ss">f&quot;</span><span class="sc">{</span><span class="bu">len</span>(bindend)<span class="sc">}</span><span class="ss"> Bedingungen, von denen </span><span class="sc">{</span><span class="bu">len</span>(teuerste)<span class="sc">}</span><span class="ss"> tatsaechlich Geld &quot;</span></span>
+<span id="cb5-277"><a href="#cb5-277" aria-hidden="true" tabindex="-1"></a>        <span class="ss">f&quot;kosten; </span><span class="ch">\&quot;</span><span class="sc">{</span>ohne_preis[<span class="dv">0</span>]<span class="sc">}</span><span class="ch">\&quot;</span><span class="ss"> beruehrt den Plan, ohne ihn zu verteuern.&quot;</span>,</span>
+<span id="cb5-278"><a href="#cb5-278" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb5-279"><a href="#cb5-279" aria-hidden="true" tabindex="-1"></a>        <span class="ss">f&quot;Teuerste Bindung ist </span><span class="ch">\&quot;</span><span class="sc">{</span>teuerste[<span class="dv">0</span>][<span class="dv">0</span>]<span class="sc">}</span><span class="ch">\&quot;</span><span class="ss"> mit &quot;</span></span>
+<span id="cb5-280"><a href="#cb5-280" aria-hidden="true" tabindex="-1"></a>        <span class="ss">f&quot;</span><span class="sc">{</span>teuerste[<span class="dv">0</span>][<span class="dv">1</span>]<span class="sc">:.2f}</span><span class="ss"> EUR je Einheit, gefolgt von </span><span class="ch">\&quot;</span><span class="sc">{</span>teuerste[<span class="dv">1</span>][<span class="dv">0</span>]<span class="sc">}</span><span class="ch">\&quot;</span><span class="ss"> &quot;</span></span>
+<span id="cb5-281"><a href="#cb5-281" aria-hidden="true" tabindex="-1"></a>        <span class="ss">f&quot;mit </span><span class="sc">{</span>teuerste[<span class="dv">1</span>][<span class="dv">1</span>]<span class="sc">:.2f}</span><span class="ss"> EUR.&quot;</span>,</span>
+<span id="cb5-282"><a href="#cb5-282" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb5-283"><a href="#cb5-283" aria-hidden="true" tabindex="-1"></a>        <span class="ss">f&quot;Die groesste einzelne Verbesserung bringt </span><span class="sc">{</span>gross<span class="sc">}</span><span class="ss">: &quot;</span></span>
+<span id="cb5-284"><a href="#cb5-284" aria-hidden="true" tabindex="-1"></a>        <span class="ss">f&quot;</span><span class="sc">{</span>euro(wirkung[nach_wirkung])<span class="sc">}</span><span class="ss"> mehr Deckungsbeitrag. </span><span class="sc">{</span>klein[<span class="dv">0</span>]<span class="sc">.</span>upper()<span class="sc">}{</span>klein[<span class="dv">1</span>:]<span class="sc">}</span><span class="ss"> &quot;</span></span>
+<span id="cb5-285"><a href="#cb5-285" aria-hidden="true" tabindex="-1"></a>        <span class="ss">f&quot;dagegen bringt nur </span><span class="sc">{</span>euro(wirkung[abweichler])<span class="sc">}</span><span class="ss"> statt der rechnerischen &quot;</span></span>
+<span id="cb5-286"><a href="#cb5-286" aria-hidden="true" tabindex="-1"></a>        <span class="ss">f&quot;</span><span class="sc">{</span>euro(preise[abweichler] <span class="op">*</span> <span class="bu">abs</span>(delta_max))<span class="sc">}</span><span class="ss"> - ab +</span><span class="sc">{</span>grenze_gueltig<span class="sc">:.0f}</span><span class="ss"> &quot;</span></span>
+<span id="cb5-287"><a href="#cb5-287" aria-hidden="true" tabindex="-1"></a>        <span class="ss">f&quot;Stunden begrenzt uns etwas anderes. Wer die ganze Schicht bezahlt, &quot;</span></span>
+<span id="cb5-288"><a href="#cb5-288" aria-hidden="true" tabindex="-1"></a>        <span class="ss">f&quot;bezahlt die zweite Haelfte umsonst.&quot;</span>,</span>
+<span id="cb5-289"><a href="#cb5-289" aria-hidden="true" tabindex="-1"></a>    ]</span>
+<span id="cb5-290"><a href="#cb5-290" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb5-291"><a href="#cb5-291" aria-hidden="true" tabindex="-1"></a>    <span class="cf">if</span> schuldige <span class="kw">and</span> noetig <span class="kw">is</span> <span class="kw">not</span> <span class="va">None</span>:</span>
+<span id="cb5-292"><a href="#cb5-292" aria-hidden="true" tabindex="-1"></a>        namen <span class="op">=</span> <span class="st">&quot;, &quot;</span>.join(<span class="ss">f&#39;&quot;</span><span class="sc">{</span>s<span class="sc">}</span><span class="ss">&quot;&#39;</span> <span class="cf">for</span> s <span class="kw">in</span> schuldige)</span>
+<span id="cb5-293"><a href="#cb5-293" aria-hidden="true" tabindex="-1"></a>        satz <span class="op">=</span> (<span class="ss">f&quot;Zum Wunsch des Vertriebs (</span><span class="sc">{</span>WUNSCH_MENGE<span class="sc">:.0f}</span><span class="ss"> </span><span class="sc">{</span>WUNSCH_PRODUKT<span class="sc">}</span><span class="ss"> statt &quot;</span></span>
+<span id="cb5-294"><a href="#cb5-294" aria-hidden="true" tabindex="-1"></a>                <span class="ss">f&quot;</span><span class="sc">{</span>plan[WUNSCH_PRODUKT]<span class="sc">:.1f}</span><span class="ss">): Er ist mit der heutigen Ausstattung &quot;</span></span>
+<span id="cb5-295"><a href="#cb5-295" aria-hidden="true" tabindex="-1"></a>                <span class="ss">f&quot;nicht erfuellbar - nicht aus Kostengruenden, sondern weil </span><span class="sc">{</span>namen<span class="sc">}</span><span class="ss"> &quot;</span></span>
+<span id="cb5-296"><a href="#cb5-296" aria-hidden="true" tabindex="-1"></a>                <span class="ss">f&quot;ihn gemeinsam blockieren. Mit +</span><span class="sc">{</span>noetig<span class="sc">}</span><span class="ss"> Stunden bei &quot;</span></span>
+<span id="cb5-297"><a href="#cb5-297" aria-hidden="true" tabindex="-1"></a>                <span class="ss">f&#39;&quot;</span><span class="sc">{</span>engpass<span class="sc">}</span><span class="ss">&quot; wird er moeglich&#39;</span>)</span>
+<span id="cb5-298"><a href="#cb5-298" aria-hidden="true" tabindex="-1"></a>        satz <span class="op">+=</span> (<span class="st">&quot;, und er kostet dann nichts: Der Plan waehlt diese Menge von &quot;</span></span>
+<span id="cb5-299"><a href="#cb5-299" aria-hidden="true" tabindex="-1"></a>                 <span class="st">&quot;sich aus.&quot;</span> <span class="cf">if</span> wunsch_gratis <span class="cf">else</span> <span class="st">&quot;.&quot;</span>)</span>
+<span id="cb5-300"><a href="#cb5-300" aria-hidden="true" tabindex="-1"></a>        absaetze.append(satz)</span>
+<span id="cb5-301"><a href="#cb5-301" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb5-302"><a href="#cb5-302" aria-hidden="true" tabindex="-1"></a>    <span class="cf">for</span> absatz <span class="kw">in</span> absaetze:</span>
+<span id="cb5-303"><a href="#cb5-303" aria-hidden="true" tabindex="-1"></a>        <span class="bu">print</span>()</span>
+<span id="cb5-304"><a href="#cb5-304" aria-hidden="true" tabindex="-1"></a>        <span class="bu">print</span>(textwrap.fill(absatz, width<span class="op">=</span><span class="dv">76</span>))</span>
+<span id="cb5-305"><a href="#cb5-305" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;</span><span class="ch">\n</span><span class="st">&quot;</span> <span class="op">+</span> <span class="st">&quot;=&quot;</span> <span class="op">*</span> <span class="dv">78</span>)</span></code></pre></div>
+<p><strong>Ausgabe:</strong></p>
+<pre><code>==============================================================================
+  CONSTRAINT ATTRIBUTION: Was kostet uns welche Bedingung?
+==============================================================================
+Status: Optimization terminated successfully.
+Deckungsbeitrag des Plans: 3,930.00 EUR
+
+  Rahmen: 47.5  Gehaeuse: 30.0  Deckel: 97.5  Traeger: 25.0  Halter: 0.0
+
+==============================================================================
+  (1) Welche Bedingungen binden - und was kostet die naechste Einheit?
+==============================================================================
+Bedingung                  genutzt  Grenze  Schlupf Schattenpreis
+------------------------------------------------------------------------------
+Kapazitaet Montage           400.0     400      0.0        9.00  &lt;-- bindend
+Kapazitaet Lackieren         210.0     210      0.0        4.00  &lt;-- bindend
+Kapazitaet Pruefung          200.0     300    100.0        0.00
+Liefervertrag Rahmen          47.5      40      7.5        0.00
+Liefervertrag Gehaeuse        30.0      30      0.0        2.00  &lt;-- bindend
+Liefervertrag Deckel          97.5      20     77.5        0.00
+Liefervertrag Traeger         25.0      25      0.0       18.00  &lt;-- bindend
+Marktgrenze Rahmen            47.5     120     72.5        0.00
+Marktgrenze Gehaeuse          30.0      90     60.0        0.00
+Marktgrenze Deckel            97.5     150     52.5        0.00
+Marktgrenze Halter             0.0     200    200.0        0.00
+Mindestumsatz              10800.0   10000    800.0        0.00
+Sortimentsbreite             122.5     100     22.5        0.00
+Lackierbudget Schicht 2       55.0      55      0.0        0.00  &lt;-- bindend
+
+  5 Bedingungen binden. Aber: Lackierbudget Schicht 2 bindet
+  mit einem Schattenpreis von 0,00 EUR - sie beruehrt den Plan, ohne ihn
+  zu verteuern. Bindend und kostenrelevant sind zwei verschiedene Dinge.
+
+==============================================================================
+  (2) Was der Schattenpreis verschweigt
+==============================================================================
+Der Schattenpreis gilt fuer die NAECHSTE Einheit. Ein Planer kauft aber
+keine Einheit, sondern eine ganze Schicht. Beides gegenuebergestellt:
+
+Stellschraube                Preis Schritt hochgerechnet  gemessen      Abw.
+------------------------------------------------------------------------------
+Kapazitaet Montage            9.00     +50        450.00    450.00     +0.00
+Kapazitaet Lackieren          4.00     +30        120.00     60.00    -60.00
+Kapazitaet Pruefung           0.00     +50          0.00      0.00     +0.00
+Lackierbudget Schicht 2       0.00     +10          0.00      0.00     +0.00
+Liefervertrag Traeger        18.00     -10        180.00    180.00     +0.00
+Liefervertrag Gehaeuse        2.00     -10         20.00     18.00     -2.00
+
+  &#39;Kapazitaet Lackieren&#39;: hochgerechnet 120.00 EUR, tatsaechlich 60.00 EUR.
+  Der Preis von 4.00 EUR gilt nur bis +15 Stunden. Jede weitere Stunde
+  dieser Sonderschicht bringt exakt nichts - der Engpass ist dann ein anderer.
+
+  Und die Ranglisten drehen sich: Nach Schattenpreis fuehrt
+  &#39;Liefervertrag Traeger&#39; (18.00 EUR je Einheit),
+  nach tatsaechlicher Wirkung &#39;Kapazitaet Montage&#39; (450.00 EUR).
+  Der Schattenpreis sagt, was eine Einheit wert ist - nicht, wie viele
+  Einheiten zu haben sind.
+
+==============================================================================
+  (3) Was-waere-wenn: mindestens 55 Rahmen statt 47.5
+==============================================================================
+Der Wunsch ist nicht teuer - er ist UNMOEGLICH.
+
+Blockiert wird er von 3 Bedingungen gemeinsam. Faellt eine davon
+weg, ist er erfuellbar; keine allein ist &#39;der&#39; Grund:
+   ohne &#39;Kapazitaet Lackieren&#39;: moeglich, Deckungsbeitrag 3,990.00 EUR
+   ohne &#39;Liefervertrag Gehaeuse&#39;: moeglich, Deckungsbeitrag 3,948.00 EUR
+   ohne &#39;Liefervertrag Traeger&#39;: moeglich, Deckungsbeitrag 4,320.00 EUR
+
+   Mit +15 bei &#39;Kapazitaet Lackieren&#39; wird der Wunsch erfuellbar:
+   Deckungsbeitrag 3,990.00 EUR (+60.00 gegenueber heute).
+   Und ohne den Wunsch ergaebe dieselbe Lockerung 3,990.00 EUR bei
+   55 Rahmen - der Wunsch kostet also NICHTS.
+   Er war nie das Problem. Der Engpass war es.
+
+==============================================================================
+  (4) Und so steht es in der Vorlage fuer die Abteilungsleiterrunde
+==============================================================================
+
+Der Plan bringt 3,930.00 EUR Deckungsbeitrag. Begrenzt wird er von 5
+Bedingungen, von denen 4 tatsaechlich Geld kosten; &quot;Lackierbudget Schicht 2&quot;
+beruehrt den Plan, ohne ihn zu verteuern.
+
+Teuerste Bindung ist &quot;Liefervertrag Traeger&quot; mit 18.00 EUR je Einheit,
+gefolgt von &quot;Kapazitaet Montage&quot; mit 9.00 EUR.
+
+Die groesste einzelne Verbesserung bringt eine Sonderschicht Montage: 450.00
+EUR mehr Deckungsbeitrag. Eine Sonderschicht Lackieren dagegen bringt nur
+60.00 EUR statt der rechnerischen 120.00 EUR - ab +15 Stunden begrenzt uns
+etwas anderes. Wer die ganze Schicht bezahlt, bezahlt die zweite Haelfte
+umsonst.
+
+Zum Wunsch des Vertriebs (55 Rahmen statt 47.5): Er ist mit der heutigen
+Ausstattung nicht erfuellbar - nicht aus Kostengruenden, sondern weil
+&quot;Kapazitaet Lackieren&quot;, &quot;Liefervertrag Gehaeuse&quot;, &quot;Liefervertrag Traeger&quot;
+ihn gemeinsam blockieren. Mit +15 Stunden bei &quot;Kapazitaet Lackieren&quot; wird er
+moeglich, und er kostet dann nichts: Der Plan waehlt diese Menge von sich
+aus.
+
+==============================================================================</code></pre>
+<h3 id="drei-befunde-und-keiner-steht-im-solverergebnis">Drei Befunde, und keiner steht im Solverergebnis</h3>
+<p><strong>Erstens: bindend heißt nicht teuer.</strong> Fünf Bedingungen binden, aber „Lackierbudget Schicht 2“ tut es mit einem Schattenpreis von <strong>0,00 €</strong>. Sie berührt den Plan, ohne ihn zu verteuern — wer sie nachverhandelt, gewinnt nichts. Das ist derselbe Unterschied, den <code>Erklaerbarkeit.py</code> oben an einer einzelnen Zuweisung zeigt, hier im Dualwert eines LP.</p>
+<p><strong>Zweitens: Der Schattenpreis ist eine Momentaufnahme.</strong> Er gilt für die <strong>nächste</strong> Einheit. Ein Planer kauft aber keine Einheit, sondern eine Schicht. Für die Lackiererei verspricht die Hochrechnung <span class="math inline">4{,}00 \cdot 30 = 120</span> €; gemessen kommen <strong>60 €</strong>. Der Preis von 4,00 € gilt exakt bis <strong>+15 Stunden</strong>, danach begrenzt etwas anderes — <strong>die zweite Hälfte der Sonderschicht wäre bezahlt und wirkungslos.</strong></p>
+<p>Und die Ranglisten drehen sich dabei um: Nach Schattenpreis führt der Trägervertrag mit 18,00 € je Stück, nach tatsächlicher Wirkung die Montage-Sonderschicht mit 450 €. Der Schattenpreis sagt, was <strong>eine</strong> Einheit wert ist — nicht, wie viele Einheiten zu haben sind. Für die Frage „welchen Hebel ziehen wir?“ ist das der entscheidende Unterschied.</p>
+<p><strong>Drittens: Ein Wunsch kann unmöglich statt teuer sein.</strong> Der Vertrieb hätte gern 55 Rahmen statt 47,5. Das Modell antwortet nicht mit einem Preis, sondern mit <code>INFEASIBLE</code> — und drei Bedingungen blockieren den Wunsch <strong>gemeinsam</strong>: Fällt eine davon weg, ist er erfüllbar, keine allein ist „der“ Grund. Genau die Struktur, die <a href="anhang-fehlerdiagnose.html#anhang-fehlerdiagnose">Anhang C</a> für den unlösbaren Fall beschreibt, hier auf einen Wunsch angewandt.</p>
+<p>Die Pointe steht am Ende: Mit +15 Stunden Lackierkapazität wird der Wunsch erfüllbar — und kostet dann <strong>nichts</strong>. Der Plan wählt diese Menge von sich aus, sobald der Engpass weg ist. Der Konflikt bestand nie zwischen Vertrieb und Produktion. Er bestand zwischen dem Vertrieb und der Lackiererei, und niemand wusste das.</p>
+<blockquote>
+<p><strong>🎯 Die drei Fragen, jetzt auf Modellebene</strong> Die Faustregel oben stellt sie für eine einzelne Zuweisung. Constraint Attribution stellt dieselben drei für den <strong>ganzen Plan</strong>: 1. <strong>Warum dieser Zielwert?</strong> — welche Bedingungen binden, und welche davon kosten Geld. 2. <strong>Warum nicht besser?</strong> — was eine realistische Lockerung wirklich bringt, gemessen statt hochgerechnet. 3. <strong>Was ist mit meinem Wunsch?</strong> — erfüllbar und zu welchem Preis, oder unmöglich und warum.</p>
+</blockquote>
+<h3 id="vom-zahlenwerk-zur-vorlage">Vom Zahlenwerk zur Vorlage</h3>
+<p>Alle drei Antworten stehen bis hierhin in Tabellen. Tabellen liest niemand in einer Abteilungsleiterrunde. Teil (4) des Programms baut aus <strong>denselben</strong> Zahlen einen Text — und das ist weniger trivial, als es aussieht:</p>
+<ul>
+<li><strong>Kein Satz enthält eine Zahl, die nicht vorher gerechnet wurde.</strong> Auch nicht die Rangfolge, auch nicht die Namen der blockierenden Bedingungen. Sobald sich das Modell ändert, ändert sich der Bericht mit — er kann nicht leise falsch werden.</li>
+<li><strong>Der sprechende Name jeder Bedingung ist die Voraussetzung dafür.</strong> <code>A_ub[7]</code> ergibt keinen Satz. Deshalb tragen die Bedingungen in beiden Programmen einen Namen, und deshalb ist das keine Kosmetik.</li>
+</ul>
+<blockquote>
+<p><strong>⚠️ Was ein solcher Bericht nicht leistet</strong> Er erklärt das <strong>Modell</strong>, nicht die <strong>Wirklichkeit</strong>. „Liefervertrag Träger kostet 18 € je Stück“ heißt: <em>in diesem Modell, mit diesen Deckungsbeiträgen</em>. Ist ein Deckungsbeitrag falsch geschätzt, ist der Bericht überzeugend <strong>und</strong> falsch — die gefährlichste Kombination. Ein generierter Text macht ein Modell nicht richtiger, nur schwerer anzuzweifeln. Deshalb gehört zu jedem solchen Bericht die Angabe, worauf er beruht.</p>
+</blockquote>
+<hr />
+<h2 id="sec:praxisfallen-architektur-einer-produktionsreifen-or-plattform">22.5 Architektur einer produktionsreifen OR-Plattform</h2>
 <figure>
 <img src="bilder_04/kap15_or_plattform.svg" alt="Abb. 22.2: Architektur einer produktionsreifen OR-Plattform" />
 <figcaption aria-hidden="true">Abb. 22.2: Architektur einer produktionsreifen OR-Plattform</figcaption>
@@ -552,7 +986,7 @@
 <p><strong>⚠️ Der häufigste Projektfehler</strong> Nicht das Modell scheitert, sondern die <strong>Einführung</strong>. Ein technisch überlegener Plan, den die Disponentin nicht versteht und dem sie nicht traut, wird umgangen — sie plant weiter in ihrer Tabelle. Rechnen Sie mindestens so viel Zeit für Erklärbarkeit, Schulung und schrittweise Einführung ein wie für das Modell selbst.</p>
 </blockquote>
 <hr />
-<h2 id="sec:praxisfallen-or-kern">22.5 Der gemeinsame Unterbau: <code>or_kern.py</code></h2>
+<h2 id="sec:praxisfallen-or-kern">22.6 Der gemeinsame Unterbau: <code>or_kern.py</code></h2>
 <p>Die fünf Prinzipien oben beschreiben eine Plattform. Der Weg dorthin beginnt aber viel kleiner — mit der Frage, welche Teile eines Optimierungsprogramms <strong>immer dieselben</strong> sind.</p>
 <p>Sehen Sie sich die Programme dieses Buchs an: Jedes liest Daten ein, baut ein Modell, wertet einen Solverstatus aus und prüft das Ergebnis. Nur der mittlere Schritt ist wirklich problemspezifisch. Die anderen drei schreibt man in jedem Projekt neu — und macht dabei jedes Mal dieselben Fehler.</p>
 <h3 id="die-vier-schichten">Die vier Schichten</h3>
@@ -669,510 +1103,510 @@
 <p><strong>⚠️ Eine Besonderheit beim Import</strong></p>
 <p><code>or_kern.py</code> importiert von sich aus <strong>keine</strong> Solverbibliothek. Die Statusübersetzer laden ihre Bibliothek erst beim Aufruf. Das ist kein Stilmittel, sondern notwendig: <code>ortools</code> und <code>highspy</code> vertragen sich nicht im selben Prozess (<a href="oekosystem.html#sec:oekosystem-ein-system-vier-programmieransaetze">Abschnitt 3.5</a>). Ein Modul, das beide importierte, wäre mit keinem von beiden benutzbar.</p>
 </blockquote>
-<div class="sourceCode" id="cb5"><pre class="sourceCode python"><code class="sourceCode python"><span id="cb5-1"><a href="#cb5-1" aria-hidden="true" tabindex="-1"></a><span class="co">#!/usr/bin/env python3</span></span>
-<span id="cb5-2"><a href="#cb5-2" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb5-3"><a href="#cb5-3" aria-hidden="true" tabindex="-1"></a><span class="co"># or_kern.py</span></span>
-<span id="cb5-4"><a href="#cb5-4" aria-hidden="true" tabindex="-1"></a><span class="co">&quot;&quot;&quot;</span></span>
-<span id="cb5-5"><a href="#cb5-5" aria-hidden="true" tabindex="-1"></a><span class="co">Kapitel Praxisfallen: Der gemeinsame Unterbau fuer produktionsreife OR-Modelle.</span></span>
-<span id="cb5-6"><a href="#cb5-6" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb5-7"><a href="#cb5-7" aria-hidden="true" tabindex="-1"></a><span class="co">Alle Beispiele dieses Buchs loesen dieselben vier Aufgaben immer wieder:</span></span>
-<span id="cb5-8"><a href="#cb5-8" aria-hidden="true" tabindex="-1"></a><span class="co">Daten einlesen und pruefen, ein Modell bauen, den Solverstatus auswerten, die</span></span>
-<span id="cb5-9"><a href="#cb5-9" aria-hidden="true" tabindex="-1"></a><span class="co">Loesung gegen die Wirklichkeit kontrollieren. Dieses Modul zieht diese vier</span></span>
-<span id="cb5-10"><a href="#cb5-10" aria-hidden="true" tabindex="-1"></a><span class="co">Aufgaben aus den Einzelprogrammen heraus.</span></span>
-<span id="cb5-11"><a href="#cb5-11" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb5-12"><a href="#cb5-12" aria-hidden="true" tabindex="-1"></a><span class="co">    Rohdaten (Excel/CSV)</span></span>
-<span id="cb5-13"><a href="#cb5-13" aria-hidden="true" tabindex="-1"></a><span class="co">        -&gt; Domaenenmodell (Pydantic, geprueft)</span></span>
-<span id="cb5-14"><a href="#cb5-14" aria-hidden="true" tabindex="-1"></a><span class="co">            -&gt; Modellbauer (solverabhaengig)</span></span>
-<span id="cb5-15"><a href="#cb5-15" aria-hidden="true" tabindex="-1"></a><span class="co">                -&gt; Loesung (DTO, solverunabhaengig)</span></span>
-<span id="cb5-16"><a href="#cb5-16" aria-hidden="true" tabindex="-1"></a><span class="co">                    -&gt; Abnahmepruefung</span></span>
-<span id="cb5-17"><a href="#cb5-17" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb5-18"><a href="#cb5-18" aria-hidden="true" tabindex="-1"></a><span class="co">Der Sinn dieser Trennung: Die Domaenenschicht weiss nichts von Solvern, die</span></span>
-<span id="cb5-19"><a href="#cb5-19" aria-hidden="true" tabindex="-1"></a><span class="co">Loesungsschicht weiss nichts vom Modellaufbau. Wer den Solver wechselt, tauscht</span></span>
-<span id="cb5-20"><a href="#cb5-20" aria-hidden="true" tabindex="-1"></a><span class="co">genau EINEN Baustein aus - der Rest bleibt.</span></span>
-<span id="cb5-21"><a href="#cb5-21" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb5-22"><a href="#cb5-22" aria-hidden="true" tabindex="-1"></a><span class="co">WICHTIG ZUM IMPORT: Dieses Modul importiert von sich aus KEINE Solver-</span></span>
-<span id="cb5-23"><a href="#cb5-23" aria-hidden="true" tabindex="-1"></a><span class="co">bibliothek. Der Grund steht im Kapitel Oekosystem: ortools und highspy vertragen sich</span></span>
-<span id="cb5-24"><a href="#cb5-24" aria-hidden="true" tabindex="-1"></a><span class="co">nicht im selben Prozess. Die Statusuebersetzer laden ihre Bibliothek erst,</span></span>
-<span id="cb5-25"><a href="#cb5-25" aria-hidden="true" tabindex="-1"></a><span class="co">wenn sie aufgerufen werden - so bleibt or_kern.py mit jedem Solver benutzbar.</span></span>
-<span id="cb5-26"><a href="#cb5-26" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb5-27"><a href="#cb5-27" aria-hidden="true" tabindex="-1"></a><span class="co">Benoetigt: pydantic (v2), numpy; optional pandas und openpyxl fuer Excel.</span></span>
-<span id="cb5-28"><a href="#cb5-28" aria-hidden="true" tabindex="-1"></a><span class="co">&quot;&quot;&quot;</span></span>
-<span id="cb5-29"><a href="#cb5-29" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb5-30"><a href="#cb5-30" aria-hidden="true" tabindex="-1"></a><span class="im">from</span> __future__ <span class="im">import</span> annotations</span>
-<span id="cb5-31"><a href="#cb5-31" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb5-32"><a href="#cb5-32" aria-hidden="true" tabindex="-1"></a><span class="im">from</span> enum <span class="im">import</span> Enum</span>
-<span id="cb5-33"><a href="#cb5-33" aria-hidden="true" tabindex="-1"></a><span class="im">from</span> typing <span class="im">import</span> Annotated, Any, Sequence</span>
-<span id="cb5-34"><a href="#cb5-34" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb5-35"><a href="#cb5-35" aria-hidden="true" tabindex="-1"></a><span class="im">import</span> numpy <span class="im">as</span> np</span>
-<span id="cb5-36"><a href="#cb5-36" aria-hidden="true" tabindex="-1"></a><span class="im">from</span> pydantic <span class="im">import</span> BaseModel, Field, model_validator</span>
-<span id="cb5-37"><a href="#cb5-37" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb5-38"><a href="#cb5-38" aria-hidden="true" tabindex="-1"></a><span class="co"># Wiederverwendbare Feldtypen. Sie tragen die Pruefung im Typ, nicht im Code -</span></span>
-<span id="cb5-39"><a href="#cb5-39" aria-hidden="true" tabindex="-1"></a><span class="co"># damit gilt sie ueberall, wo der Typ verwendet wird.</span></span>
-<span id="cb5-40"><a href="#cb5-40" aria-hidden="true" tabindex="-1"></a>PositiveZahl <span class="op">=</span> Annotated[<span class="bu">float</span>, Field(gt<span class="op">=</span><span class="dv">0</span>)]</span>
-<span id="cb5-41"><a href="#cb5-41" aria-hidden="true" tabindex="-1"></a>NichtNegativ <span class="op">=</span> Annotated[<span class="bu">float</span>, Field(ge<span class="op">=</span><span class="dv">0</span>)]</span>
-<span id="cb5-42"><a href="#cb5-42" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb5-43"><a href="#cb5-43" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb5-44"><a href="#cb5-44" aria-hidden="true" tabindex="-1"></a><span class="co"># --- 1. Solverstatus: eine Sprache fuer fuenf Bibliotheken -------------------</span></span>
-<span id="cb5-45"><a href="#cb5-45" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb5-46"><a href="#cb5-46" aria-hidden="true" tabindex="-1"></a><span class="kw">class</span> SolverStatus(<span class="bu">str</span>, Enum):</span>
-<span id="cb5-47"><a href="#cb5-47" aria-hidden="true" tabindex="-1"></a>    <span class="co">&quot;&quot;&quot;Was ein Solverlauf ergeben hat - unabhaengig davon, wer gerechnet hat.</span></span>
-<span id="cb5-48"><a href="#cb5-48" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb5-49"><a href="#cb5-49" aria-hidden="true" tabindex="-1"></a><span class="co">    Die fuenf im Buch verwendeten Bibliotheken benennen dasselbe Ergebnis</span></span>
-<span id="cb5-50"><a href="#cb5-50" aria-hidden="true" tabindex="-1"></a><span class="co">    unterschiedlich: &#39;Optimal&#39;, &#39;OPTIMAL&#39;, 2, &#39;optimal&#39;. Wer darauf direkt</span></span>
-<span id="cb5-51"><a href="#cb5-51" aria-hidden="true" tabindex="-1"></a><span class="co">    prueft, bindet seinen Auswertungscode an eine Bibliothek.</span></span>
-<span id="cb5-52"><a href="#cb5-52" aria-hidden="true" tabindex="-1"></a><span class="co">    &quot;&quot;&quot;</span></span>
-<span id="cb5-53"><a href="#cb5-53" aria-hidden="true" tabindex="-1"></a>    OPTIMAL <span class="op">=</span> <span class="st">&quot;optimal&quot;</span>              <span class="co"># beweisbar bestmoeglich</span></span>
-<span id="cb5-54"><a href="#cb5-54" aria-hidden="true" tabindex="-1"></a>    ZULAESSIG <span class="op">=</span> <span class="st">&quot;zulaessig&quot;</span>          <span class="co"># brauchbare Loesung, Beweis fehlt</span></span>
-<span id="cb5-55"><a href="#cb5-55" aria-hidden="true" tabindex="-1"></a>    UNZULAESSIG <span class="op">=</span> <span class="st">&quot;unzulaessig&quot;</span>      <span class="co"># es gibt keine Loesung (Aussage ueber das Modell)</span></span>
-<span id="cb5-56"><a href="#cb5-56" aria-hidden="true" tabindex="-1"></a>    UNBESCHRAENKT <span class="op">=</span> <span class="st">&quot;unbeschraenkt&quot;</span>  <span class="co"># Ziel waechst ins Unendliche</span></span>
-<span id="cb5-57"><a href="#cb5-57" aria-hidden="true" tabindex="-1"></a>    ZEITLIMIT <span class="op">=</span> <span class="st">&quot;zeitlimit&quot;</span>          <span class="co"># abgebrochen, nichts Brauchbares gefunden</span></span>
-<span id="cb5-58"><a href="#cb5-58" aria-hidden="true" tabindex="-1"></a>    FEHLERHAFT <span class="op">=</span> <span class="st">&quot;fehlerhaft&quot;</span>        <span class="co"># das Modell ist kein gueltiges Modell</span></span>
-<span id="cb5-59"><a href="#cb5-59" aria-hidden="true" tabindex="-1"></a>    UNBEKANNT <span class="op">=</span> <span class="st">&quot;unbekannt&quot;</span>          <span class="co"># alles Uebrige</span></span>
-<span id="cb5-60"><a href="#cb5-60" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb5-61"><a href="#cb5-61" aria-hidden="true" tabindex="-1"></a>    <span class="at">@property</span></span>
-<span id="cb5-62"><a href="#cb5-62" aria-hidden="true" tabindex="-1"></a>    <span class="kw">def</span> brauchbar(<span class="va">self</span>) <span class="op">-&gt;</span> <span class="bu">bool</span>:</span>
-<span id="cb5-63"><a href="#cb5-63" aria-hidden="true" tabindex="-1"></a>        <span class="co">&quot;&quot;&quot;Habe ich etwas in der Hand, das ich ausfuehren kann?&quot;&quot;&quot;</span></span>
-<span id="cb5-64"><a href="#cb5-64" aria-hidden="true" tabindex="-1"></a>        <span class="cf">return</span> <span class="va">self</span> <span class="kw">in</span> (SolverStatus.OPTIMAL, SolverStatus.ZULAESSIG)</span>
-<span id="cb5-65"><a href="#cb5-65" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb5-66"><a href="#cb5-66" aria-hidden="true" tabindex="-1"></a>    <span class="at">@property</span></span>
-<span id="cb5-67"><a href="#cb5-67" aria-hidden="true" tabindex="-1"></a>    <span class="kw">def</span> modellfehler(<span class="va">self</span>) <span class="op">-&gt;</span> <span class="bu">bool</span>:</span>
-<span id="cb5-68"><a href="#cb5-68" aria-hidden="true" tabindex="-1"></a>        <span class="co">&quot;&quot;&quot;Liegt die Ursache im Modell (und nicht in der Rechenzeit)?&quot;&quot;&quot;</span></span>
-<span id="cb5-69"><a href="#cb5-69" aria-hidden="true" tabindex="-1"></a>        <span class="cf">return</span> <span class="va">self</span> <span class="kw">in</span> (SolverStatus.UNZULAESSIG, SolverStatus.UNBESCHRAENKT,</span>
-<span id="cb5-70"><a href="#cb5-70" aria-hidden="true" tabindex="-1"></a>                        SolverStatus.FEHLERHAFT)</span>
-<span id="cb5-71"><a href="#cb5-71" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb5-72"><a href="#cb5-72" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb5-73"><a href="#cb5-73" aria-hidden="true" tabindex="-1"></a><span class="kw">def</span> status_von_pywraplp(rohstatus: <span class="bu">int</span>) <span class="op">-&gt;</span> SolverStatus:</span>
-<span id="cb5-74"><a href="#cb5-74" aria-hidden="true" tabindex="-1"></a>    <span class="co">&quot;&quot;&quot;OR-Tools linear_solver (GLOP, SCIP, CBC).&quot;&quot;&quot;</span></span>
-<span id="cb5-75"><a href="#cb5-75" aria-hidden="true" tabindex="-1"></a>    <span class="im">from</span> ortools.linear_solver <span class="im">import</span> pywraplp</span>
-<span id="cb5-76"><a href="#cb5-76" aria-hidden="true" tabindex="-1"></a>    zuordnung <span class="op">=</span> {</span>
-<span id="cb5-77"><a href="#cb5-77" aria-hidden="true" tabindex="-1"></a>        pywraplp.Solver.OPTIMAL: SolverStatus.OPTIMAL,</span>
-<span id="cb5-78"><a href="#cb5-78" aria-hidden="true" tabindex="-1"></a>        pywraplp.Solver.FEASIBLE: SolverStatus.ZULAESSIG,</span>
-<span id="cb5-79"><a href="#cb5-79" aria-hidden="true" tabindex="-1"></a>        pywraplp.Solver.INFEASIBLE: SolverStatus.UNZULAESSIG,</span>
-<span id="cb5-80"><a href="#cb5-80" aria-hidden="true" tabindex="-1"></a>        pywraplp.Solver.UNBOUNDED: SolverStatus.UNBESCHRAENKT,</span>
-<span id="cb5-81"><a href="#cb5-81" aria-hidden="true" tabindex="-1"></a>        pywraplp.Solver.ABNORMAL: SolverStatus.FEHLERHAFT,</span>
-<span id="cb5-82"><a href="#cb5-82" aria-hidden="true" tabindex="-1"></a>        pywraplp.Solver.NOT_SOLVED: SolverStatus.ZEITLIMIT,</span>
-<span id="cb5-83"><a href="#cb5-83" aria-hidden="true" tabindex="-1"></a>    }</span>
-<span id="cb5-84"><a href="#cb5-84" aria-hidden="true" tabindex="-1"></a>    <span class="cf">return</span> zuordnung.get(rohstatus, SolverStatus.UNBEKANNT)</span>
-<span id="cb5-85"><a href="#cb5-85" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb5-86"><a href="#cb5-86" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb5-87"><a href="#cb5-87" aria-hidden="true" tabindex="-1"></a><span class="kw">def</span> status_von_cpsat(rohstatus: <span class="bu">int</span>) <span class="op">-&gt;</span> SolverStatus:</span>
-<span id="cb5-88"><a href="#cb5-88" aria-hidden="true" tabindex="-1"></a>    <span class="co">&quot;&quot;&quot;OR-Tools CP-SAT (siehe Kapitel CP-SAT, alle fuenf Faelle).&quot;&quot;&quot;</span></span>
-<span id="cb5-89"><a href="#cb5-89" aria-hidden="true" tabindex="-1"></a>    <span class="im">from</span> ortools.sat.python <span class="im">import</span> cp_model</span>
-<span id="cb5-90"><a href="#cb5-90" aria-hidden="true" tabindex="-1"></a>    zuordnung <span class="op">=</span> {</span>
-<span id="cb5-91"><a href="#cb5-91" aria-hidden="true" tabindex="-1"></a>        cp_model.OPTIMAL: SolverStatus.OPTIMAL,</span>
-<span id="cb5-92"><a href="#cb5-92" aria-hidden="true" tabindex="-1"></a>        cp_model.FEASIBLE: SolverStatus.ZULAESSIG,</span>
-<span id="cb5-93"><a href="#cb5-93" aria-hidden="true" tabindex="-1"></a>        cp_model.INFEASIBLE: SolverStatus.UNZULAESSIG,</span>
-<span id="cb5-94"><a href="#cb5-94" aria-hidden="true" tabindex="-1"></a>        cp_model.MODEL_INVALID: SolverStatus.FEHLERHAFT,</span>
-<span id="cb5-95"><a href="#cb5-95" aria-hidden="true" tabindex="-1"></a>        cp_model.UNKNOWN: SolverStatus.ZEITLIMIT,</span>
-<span id="cb5-96"><a href="#cb5-96" aria-hidden="true" tabindex="-1"></a>    }</span>
-<span id="cb5-97"><a href="#cb5-97" aria-hidden="true" tabindex="-1"></a>    <span class="cf">return</span> zuordnung.get(rohstatus, SolverStatus.UNBEKANNT)</span>
-<span id="cb5-98"><a href="#cb5-98" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb5-99"><a href="#cb5-99" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb5-100"><a href="#cb5-100" aria-hidden="true" tabindex="-1"></a><span class="kw">def</span> status_von_highs(statustext: <span class="bu">str</span>) <span class="op">-&gt;</span> SolverStatus:</span>
-<span id="cb5-101"><a href="#cb5-101" aria-hidden="true" tabindex="-1"></a>    <span class="co">&quot;&quot;&quot;HiGHS ueber highspy - hier kommt der Status als Text.&quot;&quot;&quot;</span></span>
-<span id="cb5-102"><a href="#cb5-102" aria-hidden="true" tabindex="-1"></a>    zuordnung <span class="op">=</span> {</span>
-<span id="cb5-103"><a href="#cb5-103" aria-hidden="true" tabindex="-1"></a>        <span class="st">&quot;Optimal&quot;</span>: SolverStatus.OPTIMAL,</span>
-<span id="cb5-104"><a href="#cb5-104" aria-hidden="true" tabindex="-1"></a>        <span class="st">&quot;Time limit reached&quot;</span>: SolverStatus.ZULAESSIG,   <span class="co"># meist mit Loesung</span></span>
-<span id="cb5-105"><a href="#cb5-105" aria-hidden="true" tabindex="-1"></a>        <span class="st">&quot;Solution limit reached&quot;</span>: SolverStatus.ZULAESSIG,</span>
-<span id="cb5-106"><a href="#cb5-106" aria-hidden="true" tabindex="-1"></a>        <span class="st">&quot;Infeasible&quot;</span>: SolverStatus.UNZULAESSIG,</span>
-<span id="cb5-107"><a href="#cb5-107" aria-hidden="true" tabindex="-1"></a>        <span class="st">&quot;Unbounded&quot;</span>: SolverStatus.UNBESCHRAENKT,</span>
-<span id="cb5-108"><a href="#cb5-108" aria-hidden="true" tabindex="-1"></a>        <span class="st">&quot;Primal infeasible or unbounded&quot;</span>: SolverStatus.UNZULAESSIG,</span>
-<span id="cb5-109"><a href="#cb5-109" aria-hidden="true" tabindex="-1"></a>        <span class="st">&quot;Model error&quot;</span>: SolverStatus.FEHLERHAFT,</span>
-<span id="cb5-110"><a href="#cb5-110" aria-hidden="true" tabindex="-1"></a>    }</span>
-<span id="cb5-111"><a href="#cb5-111" aria-hidden="true" tabindex="-1"></a>    <span class="cf">return</span> zuordnung.get(statustext, SolverStatus.UNBEKANNT)</span>
-<span id="cb5-112"><a href="#cb5-112" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb5-113"><a href="#cb5-113" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb5-114"><a href="#cb5-114" aria-hidden="true" tabindex="-1"></a><span class="kw">def</span> status_von_scipy(ergebnis: Any) <span class="op">-&gt;</span> SolverStatus:</span>
-<span id="cb5-115"><a href="#cb5-115" aria-hidden="true" tabindex="-1"></a>    <span class="co">&quot;&quot;&quot;scipy.optimize.linprog und milp liefern ein Ergebnisobjekt mit .status.&quot;&quot;&quot;</span></span>
-<span id="cb5-116"><a href="#cb5-116" aria-hidden="true" tabindex="-1"></a>    zuordnung <span class="op">=</span> {</span>
-<span id="cb5-117"><a href="#cb5-117" aria-hidden="true" tabindex="-1"></a>        <span class="dv">0</span>: SolverStatus.OPTIMAL,</span>
-<span id="cb5-118"><a href="#cb5-118" aria-hidden="true" tabindex="-1"></a>        <span class="dv">1</span>: SolverStatus.ZEITLIMIT,        <span class="co"># Iterations-/Zeitgrenze</span></span>
-<span id="cb5-119"><a href="#cb5-119" aria-hidden="true" tabindex="-1"></a>        <span class="dv">2</span>: SolverStatus.UNZULAESSIG,</span>
-<span id="cb5-120"><a href="#cb5-120" aria-hidden="true" tabindex="-1"></a>        <span class="dv">3</span>: SolverStatus.UNBESCHRAENKT,</span>
-<span id="cb5-121"><a href="#cb5-121" aria-hidden="true" tabindex="-1"></a>        <span class="dv">4</span>: SolverStatus.FEHLERHAFT,       <span class="co"># numerische Schwierigkeiten</span></span>
-<span id="cb5-122"><a href="#cb5-122" aria-hidden="true" tabindex="-1"></a>    }</span>
-<span id="cb5-123"><a href="#cb5-123" aria-hidden="true" tabindex="-1"></a>    <span class="cf">return</span> zuordnung.get(<span class="bu">int</span>(ergebnis.status), SolverStatus.UNBEKANNT)</span>
-<span id="cb5-124"><a href="#cb5-124" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb5-125"><a href="#cb5-125" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb5-126"><a href="#cb5-126" aria-hidden="true" tabindex="-1"></a><span class="kw">def</span> status_von_cvxpy(statustext: <span class="bu">str</span>) <span class="op">-&gt;</span> SolverStatus:</span>
-<span id="cb5-127"><a href="#cb5-127" aria-hidden="true" tabindex="-1"></a>    <span class="co">&quot;&quot;&quot;CVXPY - Statuszeichenketten wie &#39;optimal&#39; oder &#39;infeasible&#39;.&quot;&quot;&quot;</span></span>
-<span id="cb5-128"><a href="#cb5-128" aria-hidden="true" tabindex="-1"></a>    zuordnung <span class="op">=</span> {</span>
-<span id="cb5-129"><a href="#cb5-129" aria-hidden="true" tabindex="-1"></a>        <span class="st">&quot;optimal&quot;</span>: SolverStatus.OPTIMAL,</span>
-<span id="cb5-130"><a href="#cb5-130" aria-hidden="true" tabindex="-1"></a>        <span class="st">&quot;optimal_inaccurate&quot;</span>: SolverStatus.ZULAESSIG,</span>
-<span id="cb5-131"><a href="#cb5-131" aria-hidden="true" tabindex="-1"></a>        <span class="st">&quot;infeasible&quot;</span>: SolverStatus.UNZULAESSIG,</span>
-<span id="cb5-132"><a href="#cb5-132" aria-hidden="true" tabindex="-1"></a>        <span class="st">&quot;infeasible_inaccurate&quot;</span>: SolverStatus.UNZULAESSIG,</span>
-<span id="cb5-133"><a href="#cb5-133" aria-hidden="true" tabindex="-1"></a>        <span class="st">&quot;unbounded&quot;</span>: SolverStatus.UNBESCHRAENKT,</span>
-<span id="cb5-134"><a href="#cb5-134" aria-hidden="true" tabindex="-1"></a>        <span class="st">&quot;unbounded_inaccurate&quot;</span>: SolverStatus.UNBESCHRAENKT,</span>
-<span id="cb5-135"><a href="#cb5-135" aria-hidden="true" tabindex="-1"></a>    }</span>
-<span id="cb5-136"><a href="#cb5-136" aria-hidden="true" tabindex="-1"></a>    <span class="cf">return</span> zuordnung.get(statustext, SolverStatus.UNBEKANNT)</span>
-<span id="cb5-137"><a href="#cb5-137" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb5-138"><a href="#cb5-138" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb5-139"><a href="#cb5-139" aria-hidden="true" tabindex="-1"></a><span class="co"># --- 2. Die Loesung als solverunabhaengiges Datenobjekt ----------------------</span></span>
-<span id="cb5-140"><a href="#cb5-140" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb5-141"><a href="#cb5-141" aria-hidden="true" tabindex="-1"></a><span class="kw">class</span> Loesung(BaseModel):</span>
-<span id="cb5-142"><a href="#cb5-142" aria-hidden="true" tabindex="-1"></a>    <span class="co">&quot;&quot;&quot;Das Ergebnis eines Solverlaufs, so wie es weiterverarbeitet wird.</span></span>
-<span id="cb5-143"><a href="#cb5-143" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb5-144"><a href="#cb5-144" aria-hidden="true" tabindex="-1"></a><span class="co">    Bewusst OHNE Referenz auf Solver, Modell oder Variablen: Ein Bericht, ein</span></span>
-<span id="cb5-145"><a href="#cb5-145" aria-hidden="true" tabindex="-1"></a><span class="co">    Test oder eine Weiterverarbeitung soll nicht wissen muessen, womit</span></span>
-<span id="cb5-146"><a href="#cb5-146" aria-hidden="true" tabindex="-1"></a><span class="co">    gerechnet wurde.</span></span>
-<span id="cb5-147"><a href="#cb5-147" aria-hidden="true" tabindex="-1"></a><span class="co">    &quot;&quot;&quot;</span></span>
-<span id="cb5-148"><a href="#cb5-148" aria-hidden="true" tabindex="-1"></a>    status: SolverStatus</span>
-<span id="cb5-149"><a href="#cb5-149" aria-hidden="true" tabindex="-1"></a>    werte: <span class="bu">dict</span>[<span class="bu">str</span>, <span class="bu">float</span>] <span class="op">=</span> Field(default_factory<span class="op">=</span><span class="bu">dict</span>)</span>
-<span id="cb5-150"><a href="#cb5-150" aria-hidden="true" tabindex="-1"></a>    zielwert: <span class="bu">float</span> <span class="op">|</span> <span class="va">None</span> <span class="op">=</span> <span class="va">None</span></span>
-<span id="cb5-151"><a href="#cb5-151" aria-hidden="true" tabindex="-1"></a>    schranke: <span class="bu">float</span> <span class="op">|</span> <span class="va">None</span> <span class="op">=</span> <span class="va">None</span></span>
-<span id="cb5-152"><a href="#cb5-152" aria-hidden="true" tabindex="-1"></a>    laufzeit: <span class="bu">float</span> <span class="op">|</span> <span class="va">None</span> <span class="op">=</span> <span class="va">None</span></span>
-<span id="cb5-153"><a href="#cb5-153" aria-hidden="true" tabindex="-1"></a>    <span class="co"># Schattenpreise je Nebenbedingung, sofern der Solver sie liefert</span></span>
-<span id="cb5-154"><a href="#cb5-154" aria-hidden="true" tabindex="-1"></a>    <span class="co"># (nur bei kontinuierlichen Problemen, siehe Kapitel LP). Auch das ist</span></span>
-<span id="cb5-155"><a href="#cb5-155" aria-hidden="true" tabindex="-1"></a>    <span class="co"># ein solverunabhaengiger Begriff und gehoert deshalb hierher.</span></span>
-<span id="cb5-156"><a href="#cb5-156" aria-hidden="true" tabindex="-1"></a>    schattenpreise: <span class="bu">dict</span>[<span class="bu">str</span>, <span class="bu">float</span>] <span class="op">=</span> Field(default_factory<span class="op">=</span><span class="bu">dict</span>)</span>
-<span id="cb5-157"><a href="#cb5-157" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb5-158"><a href="#cb5-158" aria-hidden="true" tabindex="-1"></a>    <span class="at">@property</span></span>
-<span id="cb5-159"><a href="#cb5-159" aria-hidden="true" tabindex="-1"></a>    <span class="kw">def</span> gap(<span class="va">self</span>) <span class="op">-&gt;</span> <span class="bu">float</span> <span class="op">|</span> <span class="va">None</span>:</span>
-<span id="cb5-160"><a href="#cb5-160" aria-hidden="true" tabindex="-1"></a>        <span class="co">&quot;&quot;&quot;Relativer Abstand zwischen gefundener Loesung und bewiesener Schranke.</span></span>
-<span id="cb5-161"><a href="#cb5-161" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb5-162"><a href="#cb5-162" aria-hidden="true" tabindex="-1"></a><span class="co">        Das ist die Zahl fuer den Bericht: keine Schaetzung, sondern eine</span></span>
-<span id="cb5-163"><a href="#cb5-163" aria-hidden="true" tabindex="-1"></a><span class="co">        Zusage - schlechter als das kann die Loesung nicht sein.</span></span>
-<span id="cb5-164"><a href="#cb5-164" aria-hidden="true" tabindex="-1"></a><span class="co">        &quot;&quot;&quot;</span></span>
-<span id="cb5-165"><a href="#cb5-165" aria-hidden="true" tabindex="-1"></a>        <span class="cf">if</span> <span class="va">self</span>.zielwert <span class="kw">is</span> <span class="va">None</span> <span class="kw">or</span> <span class="va">self</span>.schranke <span class="kw">is</span> <span class="va">None</span>:</span>
-<span id="cb5-166"><a href="#cb5-166" aria-hidden="true" tabindex="-1"></a>            <span class="cf">return</span> <span class="va">None</span></span>
-<span id="cb5-167"><a href="#cb5-167" aria-hidden="true" tabindex="-1"></a>        nenner <span class="op">=</span> <span class="bu">max</span>(<span class="bu">abs</span>(<span class="va">self</span>.zielwert), <span class="fl">1e-9</span>)</span>
-<span id="cb5-168"><a href="#cb5-168" aria-hidden="true" tabindex="-1"></a>        <span class="cf">return</span> <span class="bu">abs</span>(<span class="va">self</span>.zielwert <span class="op">-</span> <span class="va">self</span>.schranke) <span class="op">/</span> nenner</span>
-<span id="cb5-169"><a href="#cb5-169" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb5-170"><a href="#cb5-170" aria-hidden="true" tabindex="-1"></a>    <span class="kw">def</span> als_bericht(<span class="va">self</span>) <span class="op">-&gt;</span> <span class="bu">str</span>:</span>
-<span id="cb5-171"><a href="#cb5-171" aria-hidden="true" tabindex="-1"></a>        <span class="co">&quot;&quot;&quot;Eine Zeile fuers Betriebsprotokoll - siehe Betriebsueberwachung.py.&quot;&quot;&quot;</span></span>
-<span id="cb5-172"><a href="#cb5-172" aria-hidden="true" tabindex="-1"></a>        teile <span class="op">=</span> [<span class="ss">f&quot;Status: </span><span class="sc">{</span><span class="va">self</span><span class="sc">.</span>status<span class="sc">.</span>value<span class="sc">}</span><span class="ss">&quot;</span>]</span>
-<span id="cb5-173"><a href="#cb5-173" aria-hidden="true" tabindex="-1"></a>        <span class="cf">if</span> <span class="va">self</span>.zielwert <span class="kw">is</span> <span class="kw">not</span> <span class="va">None</span>:</span>
-<span id="cb5-174"><a href="#cb5-174" aria-hidden="true" tabindex="-1"></a>            teile.append(<span class="ss">f&quot;Zielwert: </span><span class="sc">{</span><span class="va">self</span><span class="sc">.</span>zielwert<span class="sc">:,.2f}</span><span class="ss">&quot;</span>)</span>
-<span id="cb5-175"><a href="#cb5-175" aria-hidden="true" tabindex="-1"></a>        <span class="cf">if</span> <span class="va">self</span>.gap <span class="kw">is</span> <span class="kw">not</span> <span class="va">None</span>:</span>
-<span id="cb5-176"><a href="#cb5-176" aria-hidden="true" tabindex="-1"></a>            teile.append(<span class="ss">f&quot;Gap: </span><span class="sc">{</span><span class="va">self</span><span class="sc">.</span>gap<span class="sc">:.2%}</span><span class="ss">&quot;</span>)</span>
-<span id="cb5-177"><a href="#cb5-177" aria-hidden="true" tabindex="-1"></a>        <span class="cf">if</span> <span class="va">self</span>.laufzeit <span class="kw">is</span> <span class="kw">not</span> <span class="va">None</span>:</span>
-<span id="cb5-178"><a href="#cb5-178" aria-hidden="true" tabindex="-1"></a>            teile.append(<span class="ss">f&quot;Zeit: </span><span class="sc">{</span><span class="va">self</span><span class="sc">.</span>laufzeit<span class="sc">:.2f}</span><span class="ss">s&quot;</span>)</span>
-<span id="cb5-179"><a href="#cb5-179" aria-hidden="true" tabindex="-1"></a>        <span class="cf">return</span> <span class="st">&quot; | &quot;</span>.join(teile)</span>
-<span id="cb5-180"><a href="#cb5-180" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb5-181"><a href="#cb5-181" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb5-182"><a href="#cb5-182" aria-hidden="true" tabindex="-1"></a><span class="co"># --- 3. Domaenenmodell: die Fakten, bevor ein Solver sie sieht ---------------</span></span>
-<span id="cb5-183"><a href="#cb5-183" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb5-184"><a href="#cb5-184" aria-hidden="true" tabindex="-1"></a><span class="kw">class</span> Produkt(BaseModel):</span>
-<span id="cb5-185"><a href="#cb5-185" aria-hidden="true" tabindex="-1"></a>    <span class="co">&quot;&quot;&quot;Ein Produkt mit Deckungsbeitrag und Ressourcenverbrauch.&quot;&quot;&quot;</span></span>
-<span id="cb5-186"><a href="#cb5-186" aria-hidden="true" tabindex="-1"></a>    name: <span class="bu">str</span> <span class="op">=</span> Field(min_length<span class="op">=</span><span class="dv">1</span>)</span>
-<span id="cb5-187"><a href="#cb5-187" aria-hidden="true" tabindex="-1"></a>    deckungsbeitrag: <span class="bu">float</span></span>
-<span id="cb5-188"><a href="#cb5-188" aria-hidden="true" tabindex="-1"></a>    verbrauch: <span class="bu">dict</span>[<span class="bu">str</span>, NichtNegativ]</span>
-<span id="cb5-189"><a href="#cb5-189" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb5-190"><a href="#cb5-190" aria-hidden="true" tabindex="-1"></a>    model_config <span class="op">=</span> {<span class="st">&quot;frozen&quot;</span>: <span class="va">True</span>}      <span class="co"># Stammdaten aendern sich nicht im Lauf</span></span>
-<span id="cb5-191"><a href="#cb5-191" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb5-192"><a href="#cb5-192" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb5-193"><a href="#cb5-193" aria-hidden="true" tabindex="-1"></a><span class="kw">class</span> Produktionsproblem(BaseModel):</span>
-<span id="cb5-194"><a href="#cb5-194" aria-hidden="true" tabindex="-1"></a>    <span class="co">&quot;&quot;&quot;Produktionsprogrammplanung - das Modell aus Kapitel Einfuehrung.</span></span>
-<span id="cb5-195"><a href="#cb5-195" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb5-196"><a href="#cb5-196" aria-hidden="true" tabindex="-1"></a><span class="co">    Die Pruefungen stehen hier und nicht im Solvercode. Damit gelten sie</span></span>
-<span id="cb5-197"><a href="#cb5-197" aria-hidden="true" tabindex="-1"></a><span class="co">    unabhaengig davon, mit welcher Bibliothek spaeter gerechnet wird - und sie</span></span>
-<span id="cb5-198"><a href="#cb5-198" aria-hidden="true" tabindex="-1"></a><span class="co">    schlagen beim EINLESEN zu, wo der Fehler noch zuzuordnen ist.</span></span>
-<span id="cb5-199"><a href="#cb5-199" aria-hidden="true" tabindex="-1"></a><span class="co">    &quot;&quot;&quot;</span></span>
-<span id="cb5-200"><a href="#cb5-200" aria-hidden="true" tabindex="-1"></a>    produkte: <span class="bu">list</span>[Produkt] <span class="op">=</span> Field(min_length<span class="op">=</span><span class="dv">1</span>)</span>
-<span id="cb5-201"><a href="#cb5-201" aria-hidden="true" tabindex="-1"></a>    kapazitaeten: <span class="bu">dict</span>[<span class="bu">str</span>, PositiveZahl]</span>
-<span id="cb5-202"><a href="#cb5-202" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb5-203"><a href="#cb5-203" aria-hidden="true" tabindex="-1"></a>    <span class="at">@model_validator</span>(mode<span class="op">=</span><span class="st">&quot;after&quot;</span>)</span>
-<span id="cb5-204"><a href="#cb5-204" aria-hidden="true" tabindex="-1"></a>    <span class="kw">def</span> pruefe_ressourcen(<span class="va">self</span>) <span class="op">-&gt;</span> <span class="st">&quot;Produktionsproblem&quot;</span>:</span>
-<span id="cb5-205"><a href="#cb5-205" aria-hidden="true" tabindex="-1"></a>        namen <span class="op">=</span> [p.name <span class="cf">for</span> p <span class="kw">in</span> <span class="va">self</span>.produkte]</span>
-<span id="cb5-206"><a href="#cb5-206" aria-hidden="true" tabindex="-1"></a>        <span class="cf">if</span> <span class="bu">len</span>(<span class="bu">set</span>(namen)) <span class="op">!=</span> <span class="bu">len</span>(namen):</span>
-<span id="cb5-207"><a href="#cb5-207" aria-hidden="true" tabindex="-1"></a>            doppelt <span class="op">=</span> <span class="bu">sorted</span>({n <span class="cf">for</span> n <span class="kw">in</span> namen <span class="cf">if</span> namen.count(n) <span class="op">&gt;</span> <span class="dv">1</span>})</span>
-<span id="cb5-208"><a href="#cb5-208" aria-hidden="true" tabindex="-1"></a>            <span class="cf">raise</span> <span class="pp">ValueError</span>(<span class="ss">f&quot;Produktnamen kommen mehrfach vor: </span><span class="sc">{</span>doppelt<span class="sc">}</span><span class="ss">&quot;</span>)</span>
-<span id="cb5-209"><a href="#cb5-209" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb5-210"><a href="#cb5-210" aria-hidden="true" tabindex="-1"></a>        <span class="cf">for</span> produkt <span class="kw">in</span> <span class="va">self</span>.produkte:</span>
-<span id="cb5-211"><a href="#cb5-211" aria-hidden="true" tabindex="-1"></a>            unbekannt <span class="op">=</span> <span class="bu">set</span>(produkt.verbrauch) <span class="op">-</span> <span class="bu">set</span>(<span class="va">self</span>.kapazitaeten)</span>
-<span id="cb5-212"><a href="#cb5-212" aria-hidden="true" tabindex="-1"></a>            <span class="cf">if</span> unbekannt:</span>
-<span id="cb5-213"><a href="#cb5-213" aria-hidden="true" tabindex="-1"></a>                <span class="cf">raise</span> <span class="pp">ValueError</span>(</span>
-<span id="cb5-214"><a href="#cb5-214" aria-hidden="true" tabindex="-1"></a>                    <span class="ss">f&quot;Produkt &#39;</span><span class="sc">{</span>produkt<span class="sc">.</span>name<span class="sc">}</span><span class="ss">&#39; verbraucht Ressourcen ohne &quot;</span></span>
-<span id="cb5-215"><a href="#cb5-215" aria-hidden="true" tabindex="-1"></a>                    <span class="ss">f&quot;Kapazitaetsangabe: </span><span class="sc">{</span><span class="bu">sorted</span>(unbekannt)<span class="sc">}</span><span class="ss">&quot;</span>)</span>
-<span id="cb5-216"><a href="#cb5-216" aria-hidden="true" tabindex="-1"></a>        <span class="cf">return</span> <span class="va">self</span></span>
-<span id="cb5-217"><a href="#cb5-217" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb5-218"><a href="#cb5-218" aria-hidden="true" tabindex="-1"></a>    <span class="at">@property</span></span>
-<span id="cb5-219"><a href="#cb5-219" aria-hidden="true" tabindex="-1"></a>    <span class="kw">def</span> ressourcen(<span class="va">self</span>) <span class="op">-&gt;</span> <span class="bu">list</span>[<span class="bu">str</span>]:</span>
-<span id="cb5-220"><a href="#cb5-220" aria-hidden="true" tabindex="-1"></a>        <span class="co">&quot;&quot;&quot;Feste Reihenfolge - siehe die Spaltenfalle in Kapitel Finanzdaten.&quot;&quot;&quot;</span></span>
-<span id="cb5-221"><a href="#cb5-221" aria-hidden="true" tabindex="-1"></a>        <span class="cf">return</span> <span class="bu">sorted</span>(<span class="va">self</span>.kapazitaeten)</span>
-<span id="cb5-222"><a href="#cb5-222" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb5-223"><a href="#cb5-223" aria-hidden="true" tabindex="-1"></a>    <span class="kw">def</span> verbrauchsmatrix(<span class="va">self</span>) <span class="op">-&gt;</span> np.ndarray:</span>
-<span id="cb5-224"><a href="#cb5-224" aria-hidden="true" tabindex="-1"></a>        <span class="co">&quot;&quot;&quot;Zeilen = Ressourcen, Spalten = Produkte (Matrixform, Kapitel Fundament).&quot;&quot;&quot;</span></span>
-<span id="cb5-225"><a href="#cb5-225" aria-hidden="true" tabindex="-1"></a>        <span class="cf">return</span> np.array([[p.verbrauch.get(r, <span class="fl">0.0</span>) <span class="cf">for</span> p <span class="kw">in</span> <span class="va">self</span>.produkte]</span>
-<span id="cb5-226"><a href="#cb5-226" aria-hidden="true" tabindex="-1"></a>                         <span class="cf">for</span> r <span class="kw">in</span> <span class="va">self</span>.ressourcen])</span>
-<span id="cb5-227"><a href="#cb5-227" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb5-228"><a href="#cb5-228" aria-hidden="true" tabindex="-1"></a>    <span class="kw">def</span> kapazitaetsvektor(<span class="va">self</span>) <span class="op">-&gt;</span> np.ndarray:</span>
-<span id="cb5-229"><a href="#cb5-229" aria-hidden="true" tabindex="-1"></a>        <span class="cf">return</span> np.array([<span class="va">self</span>.kapazitaeten[r] <span class="cf">for</span> r <span class="kw">in</span> <span class="va">self</span>.ressourcen])</span>
-<span id="cb5-230"><a href="#cb5-230" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb5-231"><a href="#cb5-231" aria-hidden="true" tabindex="-1"></a>    <span class="kw">def</span> deckungsbeitragsvektor(<span class="va">self</span>) <span class="op">-&gt;</span> np.ndarray:</span>
-<span id="cb5-232"><a href="#cb5-232" aria-hidden="true" tabindex="-1"></a>        <span class="cf">return</span> np.array([p.deckungsbeitrag <span class="cf">for</span> p <span class="kw">in</span> <span class="va">self</span>.produkte])</span>
-<span id="cb5-233"><a href="#cb5-233" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb5-234"><a href="#cb5-234" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb5-235"><a href="#cb5-235" aria-hidden="true" tabindex="-1"></a><span class="co"># --- 4. Abnahmepruefung: Loesung gegen Anforderung, ohne Solver --------------</span></span>
-<span id="cb5-236"><a href="#cb5-236" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb5-237"><a href="#cb5-237" aria-hidden="true" tabindex="-1"></a><span class="kw">def</span> pruefe_loesung(problem: Produktionsproblem, loesung: Loesung,</span>
-<span id="cb5-238"><a href="#cb5-238" aria-hidden="true" tabindex="-1"></a>                   ganzzahlig: Sequence[<span class="bu">str</span>] <span class="op">=</span> (),</span>
-<span id="cb5-239"><a href="#cb5-239" aria-hidden="true" tabindex="-1"></a>                   toleranz: <span class="bu">float</span> <span class="op">=</span> <span class="fl">1e-6</span>) <span class="op">-&gt;</span> <span class="bu">list</span>[<span class="bu">str</span>]:</span>
-<span id="cb5-240"><a href="#cb5-240" aria-hidden="true" tabindex="-1"></a>    <span class="co">&quot;&quot;&quot;Prueft eine Loesung gegen die Anforderungen - OHNE den Solver zu fragen.</span></span>
-<span id="cb5-241"><a href="#cb5-241" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb5-242"><a href="#cb5-242" aria-hidden="true" tabindex="-1"></a><span class="co">    Diese Funktion darf ausdruecklich KEIN Solverobjekt und keine</span></span>
-<span id="cb5-243"><a href="#cb5-243" aria-hidden="true" tabindex="-1"></a><span class="co">    Modellvariable benutzen. Eine Pruefung aus denselben Bausteinen wie das</span></span>
-<span id="cb5-244"><a href="#cb5-244" aria-hidden="true" tabindex="-1"></a><span class="co">    Modell prueft das Modell gegen sich selbst und findet nichts (siehe die</span></span>
-<span id="cb5-245"><a href="#cb5-245" aria-hidden="true" tabindex="-1"></a><span class="co">    Denkfehler in den Kapiteln Graphen und MILP).</span></span>
-<span id="cb5-246"><a href="#cb5-246" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb5-247"><a href="#cb5-247" aria-hidden="true" tabindex="-1"></a><span class="co">    Liefert eine Liste von Beanstandungen; leer heisst bestanden.</span></span>
-<span id="cb5-248"><a href="#cb5-248" aria-hidden="true" tabindex="-1"></a><span class="co">    &quot;&quot;&quot;</span></span>
-<span id="cb5-249"><a href="#cb5-249" aria-hidden="true" tabindex="-1"></a>    beanstandungen: <span class="bu">list</span>[<span class="bu">str</span>] <span class="op">=</span> []</span>
-<span id="cb5-250"><a href="#cb5-250" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb5-251"><a href="#cb5-251" aria-hidden="true" tabindex="-1"></a>    <span class="cf">if</span> <span class="kw">not</span> loesung.status.brauchbar:</span>
-<span id="cb5-252"><a href="#cb5-252" aria-hidden="true" tabindex="-1"></a>        <span class="cf">return</span> [<span class="ss">f&quot;Kein verwertbares Ergebnis (Status: </span><span class="sc">{</span>loesung<span class="sc">.</span>status<span class="sc">.</span>value<span class="sc">}</span><span class="ss">)&quot;</span>]</span>
-<span id="cb5-253"><a href="#cb5-253" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb5-254"><a href="#cb5-254" aria-hidden="true" tabindex="-1"></a>    fehlend <span class="op">=</span> [p.name <span class="cf">for</span> p <span class="kw">in</span> problem.produkte <span class="cf">if</span> p.name <span class="kw">not</span> <span class="kw">in</span> loesung.werte]</span>
-<span id="cb5-255"><a href="#cb5-255" aria-hidden="true" tabindex="-1"></a>    <span class="cf">if</span> fehlend:</span>
-<span id="cb5-256"><a href="#cb5-256" aria-hidden="true" tabindex="-1"></a>        <span class="cf">return</span> [<span class="ss">f&quot;Loesung enthaelt keine Werte fuer: </span><span class="sc">{</span>fehlend<span class="sc">}</span><span class="ss">&quot;</span>]</span>
-<span id="cb5-257"><a href="#cb5-257" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb5-258"><a href="#cb5-258" aria-hidden="true" tabindex="-1"></a>    mengen <span class="op">=</span> np.array([loesung.werte[p.name] <span class="cf">for</span> p <span class="kw">in</span> problem.produkte])</span>
-<span id="cb5-259"><a href="#cb5-259" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb5-260"><a href="#cb5-260" aria-hidden="true" tabindex="-1"></a>    <span class="cf">if</span> (mengen <span class="op">&lt;</span> <span class="op">-</span>toleranz).<span class="bu">any</span>():</span>
-<span id="cb5-261"><a href="#cb5-261" aria-hidden="true" tabindex="-1"></a>        negativ <span class="op">=</span> [p.name <span class="cf">for</span> p, m <span class="kw">in</span> <span class="bu">zip</span>(problem.produkte, mengen) <span class="cf">if</span> m <span class="op">&lt;</span> <span class="op">-</span>toleranz]</span>
-<span id="cb5-262"><a href="#cb5-262" aria-hidden="true" tabindex="-1"></a>        beanstandungen.append(<span class="ss">f&quot;negative Mengen bei: </span><span class="sc">{</span>negativ<span class="sc">}</span><span class="ss">&quot;</span>)</span>
-<span id="cb5-263"><a href="#cb5-263" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb5-264"><a href="#cb5-264" aria-hidden="true" tabindex="-1"></a>    verbrauch <span class="op">=</span> problem.verbrauchsmatrix() <span class="op">@</span> mengen</span>
-<span id="cb5-265"><a href="#cb5-265" aria-hidden="true" tabindex="-1"></a>    <span class="cf">for</span> ressource, ist, grenze <span class="kw">in</span> <span class="bu">zip</span>(problem.ressourcen, verbrauch,</span>
-<span id="cb5-266"><a href="#cb5-266" aria-hidden="true" tabindex="-1"></a>                                      problem.kapazitaetsvektor()):</span>
-<span id="cb5-267"><a href="#cb5-267" aria-hidden="true" tabindex="-1"></a>        <span class="cf">if</span> ist <span class="op">&gt;</span> grenze <span class="op">+</span> toleranz:</span>
-<span id="cb5-268"><a href="#cb5-268" aria-hidden="true" tabindex="-1"></a>            beanstandungen.append(</span>
-<span id="cb5-269"><a href="#cb5-269" aria-hidden="true" tabindex="-1"></a>                <span class="ss">f&quot;</span><span class="sc">{</span>ressource<span class="sc">}</span><span class="ss">: Verbrauch </span><span class="sc">{</span>ist<span class="sc">:,.3f}</span><span class="ss"> ueber Kapazitaet </span><span class="sc">{</span>grenze<span class="sc">:,.3f}</span><span class="ss">&quot;</span>)</span>
-<span id="cb5-270"><a href="#cb5-270" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb5-271"><a href="#cb5-271" aria-hidden="true" tabindex="-1"></a>    <span class="cf">for</span> name <span class="kw">in</span> ganzzahlig:</span>
-<span id="cb5-272"><a href="#cb5-272" aria-hidden="true" tabindex="-1"></a>        wert <span class="op">=</span> loesung.werte[name]</span>
-<span id="cb5-273"><a href="#cb5-273" aria-hidden="true" tabindex="-1"></a>        <span class="cf">if</span> <span class="bu">abs</span>(wert <span class="op">-</span> <span class="bu">round</span>(wert)) <span class="op">&gt;</span> toleranz:</span>
-<span id="cb5-274"><a href="#cb5-274" aria-hidden="true" tabindex="-1"></a>            beanstandungen.append(<span class="ss">f&quot;&#39;</span><span class="sc">{</span>name<span class="sc">}</span><span class="ss">&#39; = </span><span class="sc">{</span>wert<span class="sc">!r}</span><span class="ss"> ist nicht ganzzahlig&quot;</span>)</span>
-<span id="cb5-275"><a href="#cb5-275" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb5-276"><a href="#cb5-276" aria-hidden="true" tabindex="-1"></a>    <span class="cf">if</span> loesung.zielwert <span class="kw">is</span> <span class="kw">not</span> <span class="va">None</span>:</span>
-<span id="cb5-277"><a href="#cb5-277" aria-hidden="true" tabindex="-1"></a>        nachgerechnet <span class="op">=</span> <span class="bu">float</span>(problem.deckungsbeitragsvektor() <span class="op">@</span> mengen)</span>
-<span id="cb5-278"><a href="#cb5-278" aria-hidden="true" tabindex="-1"></a>        <span class="cf">if</span> <span class="bu">abs</span>(nachgerechnet <span class="op">-</span> loesung.zielwert) <span class="op">&gt;</span> toleranz <span class="op">*</span> <span class="bu">max</span>(<span class="fl">1.0</span>, <span class="bu">abs</span>(nachgerechnet)):</span>
-<span id="cb5-279"><a href="#cb5-279" aria-hidden="true" tabindex="-1"></a>            beanstandungen.append(</span>
-<span id="cb5-280"><a href="#cb5-280" aria-hidden="true" tabindex="-1"></a>                <span class="ss">f&quot;Zielwert </span><span class="sc">{</span>loesung<span class="sc">.</span>zielwert<span class="sc">:,.4f}</span><span class="ss"> passt nicht zu den Mengen &quot;</span></span>
-<span id="cb5-281"><a href="#cb5-281" aria-hidden="true" tabindex="-1"></a>                <span class="ss">f&quot;(nachgerechnet </span><span class="sc">{</span>nachgerechnet<span class="sc">:,.4f}</span><span class="ss">)&quot;</span>)</span>
-<span id="cb5-282"><a href="#cb5-282" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb5-283"><a href="#cb5-283" aria-hidden="true" tabindex="-1"></a>    <span class="cf">return</span> beanstandungen</span>
-<span id="cb5-284"><a href="#cb5-284" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb5-285"><a href="#cb5-285" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb5-286"><a href="#cb5-286" aria-hidden="true" tabindex="-1"></a><span class="co"># --- 5. Ein Modellbauer je Solver - austauschbar ----------------------------</span></span>
-<span id="cb5-287"><a href="#cb5-287" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb5-288"><a href="#cb5-288" aria-hidden="true" tabindex="-1"></a><span class="kw">def</span> loese_mit_glop(problem: Produktionsproblem) <span class="op">-&gt;</span> Loesung:</span>
-<span id="cb5-289"><a href="#cb5-289" aria-hidden="true" tabindex="-1"></a>    <span class="co">&quot;&quot;&quot;Modellbauer fuer OR-Tools GLOP (kontinuierlich).&quot;&quot;&quot;</span></span>
-<span id="cb5-290"><a href="#cb5-290" aria-hidden="true" tabindex="-1"></a>    <span class="im">import</span> time</span>
-<span id="cb5-291"><a href="#cb5-291" aria-hidden="true" tabindex="-1"></a>    <span class="im">from</span> ortools.linear_solver <span class="im">import</span> pywraplp</span>
-<span id="cb5-292"><a href="#cb5-292" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb5-293"><a href="#cb5-293" aria-hidden="true" tabindex="-1"></a>    solver <span class="op">=</span> pywraplp.Solver.CreateSolver(<span class="st">&quot;GLOP&quot;</span>)</span>
-<span id="cb5-294"><a href="#cb5-294" aria-hidden="true" tabindex="-1"></a>    menge <span class="op">=</span> {p.name: solver.NumVar(<span class="dv">0</span>, solver.infinity(), p.name)</span>
-<span id="cb5-295"><a href="#cb5-295" aria-hidden="true" tabindex="-1"></a>             <span class="cf">for</span> p <span class="kw">in</span> problem.produkte}</span>
-<span id="cb5-296"><a href="#cb5-296" aria-hidden="true" tabindex="-1"></a>    <span class="co"># Die Nebenbedingung wird gemerkt - ohne die Referenz gibt es spaeter</span></span>
-<span id="cb5-297"><a href="#cb5-297" aria-hidden="true" tabindex="-1"></a>    <span class="co"># keinen Schattenpreis (siehe Kapitel LP).</span></span>
-<span id="cb5-298"><a href="#cb5-298" aria-hidden="true" tabindex="-1"></a>    bedingung <span class="op">=</span> {}</span>
-<span id="cb5-299"><a href="#cb5-299" aria-hidden="true" tabindex="-1"></a>    <span class="cf">for</span> ressource <span class="kw">in</span> problem.ressourcen:</span>
-<span id="cb5-300"><a href="#cb5-300" aria-hidden="true" tabindex="-1"></a>        bedingung[ressource] <span class="op">=</span> solver.Add(</span>
-<span id="cb5-301"><a href="#cb5-301" aria-hidden="true" tabindex="-1"></a>            <span class="bu">sum</span>(menge[p.name] <span class="op">*</span> p.verbrauch.get(ressource, <span class="fl">0.0</span>)</span>
-<span id="cb5-302"><a href="#cb5-302" aria-hidden="true" tabindex="-1"></a>                <span class="cf">for</span> p <span class="kw">in</span> problem.produkte)</span>
-<span id="cb5-303"><a href="#cb5-303" aria-hidden="true" tabindex="-1"></a>            <span class="op">&lt;=</span> problem.kapazitaeten[ressource], name<span class="op">=</span>ressource)</span>
-<span id="cb5-304"><a href="#cb5-304" aria-hidden="true" tabindex="-1"></a>    solver.Maximize(<span class="bu">sum</span>(menge[p.name] <span class="op">*</span> p.deckungsbeitrag <span class="cf">for</span> p <span class="kw">in</span> problem.produkte))</span>
-<span id="cb5-305"><a href="#cb5-305" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb5-306"><a href="#cb5-306" aria-hidden="true" tabindex="-1"></a>    t0 <span class="op">=</span> time.perf_counter()</span>
-<span id="cb5-307"><a href="#cb5-307" aria-hidden="true" tabindex="-1"></a>    rohstatus <span class="op">=</span> solver.Solve()</span>
-<span id="cb5-308"><a href="#cb5-308" aria-hidden="true" tabindex="-1"></a>    laufzeit <span class="op">=</span> time.perf_counter() <span class="op">-</span> t0</span>
-<span id="cb5-309"><a href="#cb5-309" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb5-310"><a href="#cb5-310" aria-hidden="true" tabindex="-1"></a>    status <span class="op">=</span> status_von_pywraplp(rohstatus)</span>
-<span id="cb5-311"><a href="#cb5-311" aria-hidden="true" tabindex="-1"></a>    <span class="cf">if</span> <span class="kw">not</span> status.brauchbar:</span>
-<span id="cb5-312"><a href="#cb5-312" aria-hidden="true" tabindex="-1"></a>        <span class="cf">return</span> Loesung(status<span class="op">=</span>status, laufzeit<span class="op">=</span>laufzeit)</span>
-<span id="cb5-313"><a href="#cb5-313" aria-hidden="true" tabindex="-1"></a>    <span class="cf">return</span> Loesung(status<span class="op">=</span>status,</span>
-<span id="cb5-314"><a href="#cb5-314" aria-hidden="true" tabindex="-1"></a>                   werte<span class="op">=</span>{name: v.solution_value() <span class="cf">for</span> name, v <span class="kw">in</span> menge.items()},</span>
-<span id="cb5-315"><a href="#cb5-315" aria-hidden="true" tabindex="-1"></a>                   zielwert<span class="op">=</span>solver.Objective().Value(),</span>
-<span id="cb5-316"><a href="#cb5-316" aria-hidden="true" tabindex="-1"></a>                   schranke<span class="op">=</span>solver.Objective().Value(),</span>
-<span id="cb5-317"><a href="#cb5-317" aria-hidden="true" tabindex="-1"></a>                   schattenpreise<span class="op">=</span>{r: b.dual_value() <span class="cf">for</span> r, b <span class="kw">in</span> bedingung.items()},</span>
-<span id="cb5-318"><a href="#cb5-318" aria-hidden="true" tabindex="-1"></a>                   laufzeit<span class="op">=</span>laufzeit)</span>
-<span id="cb5-319"><a href="#cb5-319" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb5-320"><a href="#cb5-320" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb5-321"><a href="#cb5-321" aria-hidden="true" tabindex="-1"></a><span class="kw">def</span> loese_mit_scipy(problem: Produktionsproblem) <span class="op">-&gt;</span> Loesung:</span>
-<span id="cb5-322"><a href="#cb5-322" aria-hidden="true" tabindex="-1"></a>    <span class="co">&quot;&quot;&quot;Derselbe Fall mit scipy.optimize.linprog - anderer Solver, gleiche Loesung.</span></span>
-<span id="cb5-323"><a href="#cb5-323" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb5-324"><a href="#cb5-324" aria-hidden="true" tabindex="-1"></a><span class="co">    Beachten Sie, wie wenig hier steht: Die Daten kommen fertig geprueft aus</span></span>
-<span id="cb5-325"><a href="#cb5-325" aria-hidden="true" tabindex="-1"></a><span class="co">    dem Domaenenmodell, die Auswertung geht ans gemeinsame Loesung-Objekt.</span></span>
-<span id="cb5-326"><a href="#cb5-326" aria-hidden="true" tabindex="-1"></a><span class="co">    Genau das ist der Ertrag der Trennung.</span></span>
-<span id="cb5-327"><a href="#cb5-327" aria-hidden="true" tabindex="-1"></a><span class="co">    &quot;&quot;&quot;</span></span>
-<span id="cb5-328"><a href="#cb5-328" aria-hidden="true" tabindex="-1"></a>    <span class="im">import</span> time</span>
-<span id="cb5-329"><a href="#cb5-329" aria-hidden="true" tabindex="-1"></a>    <span class="im">from</span> scipy.optimize <span class="im">import</span> linprog</span>
-<span id="cb5-330"><a href="#cb5-330" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb5-331"><a href="#cb5-331" aria-hidden="true" tabindex="-1"></a>    t0 <span class="op">=</span> time.perf_counter()</span>
-<span id="cb5-332"><a href="#cb5-332" aria-hidden="true" tabindex="-1"></a>    ergebnis <span class="op">=</span> linprog(c<span class="op">=-</span>problem.deckungsbeitragsvektor(),      <span class="co"># linprog minimiert</span></span>
-<span id="cb5-333"><a href="#cb5-333" aria-hidden="true" tabindex="-1"></a>                       A_ub<span class="op">=</span>problem.verbrauchsmatrix(),</span>
-<span id="cb5-334"><a href="#cb5-334" aria-hidden="true" tabindex="-1"></a>                       b_ub<span class="op">=</span>problem.kapazitaetsvektor(),</span>
-<span id="cb5-335"><a href="#cb5-335" aria-hidden="true" tabindex="-1"></a>                       bounds<span class="op">=</span>(<span class="dv">0</span>, <span class="va">None</span>), method<span class="op">=</span><span class="st">&quot;highs&quot;</span>)</span>
-<span id="cb5-336"><a href="#cb5-336" aria-hidden="true" tabindex="-1"></a>    laufzeit <span class="op">=</span> time.perf_counter() <span class="op">-</span> t0</span>
-<span id="cb5-337"><a href="#cb5-337" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb5-338"><a href="#cb5-338" aria-hidden="true" tabindex="-1"></a>    status <span class="op">=</span> status_von_scipy(ergebnis)</span>
-<span id="cb5-339"><a href="#cb5-339" aria-hidden="true" tabindex="-1"></a>    <span class="cf">if</span> <span class="kw">not</span> status.brauchbar:</span>
-<span id="cb5-340"><a href="#cb5-340" aria-hidden="true" tabindex="-1"></a>        <span class="cf">return</span> Loesung(status<span class="op">=</span>status, laufzeit<span class="op">=</span>laufzeit)</span>
-<span id="cb5-341"><a href="#cb5-341" aria-hidden="true" tabindex="-1"></a>    <span class="co"># linprog rechnet minimierend mit negierten Kosten - die Dualwerte</span></span>
-<span id="cb5-342"><a href="#cb5-342" aria-hidden="true" tabindex="-1"></a>    <span class="co"># muessen entsprechend zurueckgedreht werden.</span></span>
-<span id="cb5-343"><a href="#cb5-343" aria-hidden="true" tabindex="-1"></a>    <span class="cf">return</span> Loesung(status<span class="op">=</span>status,</span>
-<span id="cb5-344"><a href="#cb5-344" aria-hidden="true" tabindex="-1"></a>                   werte<span class="op">=</span>{p.name: <span class="bu">float</span>(x)</span>
-<span id="cb5-345"><a href="#cb5-345" aria-hidden="true" tabindex="-1"></a>                          <span class="cf">for</span> p, x <span class="kw">in</span> <span class="bu">zip</span>(problem.produkte, ergebnis.x)},</span>
-<span id="cb5-346"><a href="#cb5-346" aria-hidden="true" tabindex="-1"></a>                   zielwert<span class="op">=</span><span class="bu">float</span>(<span class="op">-</span>ergebnis.fun),</span>
-<span id="cb5-347"><a href="#cb5-347" aria-hidden="true" tabindex="-1"></a>                   schranke<span class="op">=</span><span class="bu">float</span>(<span class="op">-</span>ergebnis.fun),</span>
-<span id="cb5-348"><a href="#cb5-348" aria-hidden="true" tabindex="-1"></a>                   schattenpreise<span class="op">=</span>{r: <span class="bu">float</span>(<span class="op">-</span>m) <span class="cf">for</span> r, m <span class="kw">in</span></span>
-<span id="cb5-349"><a href="#cb5-349" aria-hidden="true" tabindex="-1"></a>                                   <span class="bu">zip</span>(problem.ressourcen,</span>
-<span id="cb5-350"><a href="#cb5-350" aria-hidden="true" tabindex="-1"></a>                                       ergebnis.ineqlin.marginals)},</span>
-<span id="cb5-351"><a href="#cb5-351" aria-hidden="true" tabindex="-1"></a>                   laufzeit<span class="op">=</span>laufzeit)</span>
-<span id="cb5-352"><a href="#cb5-352" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb5-353"><a href="#cb5-353" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb5-354"><a href="#cb5-354" aria-hidden="true" tabindex="-1"></a><span class="co"># --- 6. Ein- und Ausgabe: Tabellen sind die Wirklichkeit ---------------------</span></span>
-<span id="cb5-355"><a href="#cb5-355" aria-hidden="true" tabindex="-1"></a><span class="co">#</span></span>
-<span id="cb5-356"><a href="#cb5-356" aria-hidden="true" tabindex="-1"></a><span class="co"># In den meisten Betrieben liegen die Zahlen in einer Tabellenkalkulation</span></span>
-<span id="cb5-357"><a href="#cb5-357" aria-hidden="true" tabindex="-1"></a><span class="co"># (Kapitel Einfuehrung). Diese beiden Funktionen sind die einzige Stelle im</span></span>
-<span id="cb5-358"><a href="#cb5-358" aria-hidden="true" tabindex="-1"></a><span class="co"># Modul, die das weiss - alles andere arbeitet mit dem Domaenenmodell.</span></span>
-<span id="cb5-359"><a href="#cb5-359" aria-hidden="true" tabindex="-1"></a><span class="co">#</span></span>
-<span id="cb5-360"><a href="#cb5-360" aria-hidden="true" tabindex="-1"></a><span class="co"># pandas und openpyxl werden bewusst erst hier importiert: Wer or_kern nur</span></span>
-<span id="cb5-361"><a href="#cb5-361" aria-hidden="true" tabindex="-1"></a><span class="co"># fuer Statusauswertung und Pruefung benutzt, soll sie nicht installieren</span></span>
-<span id="cb5-362"><a href="#cb5-362" aria-hidden="true" tabindex="-1"></a><span class="co"># muessen.</span></span>
-<span id="cb5-363"><a href="#cb5-363" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb5-364"><a href="#cb5-364" aria-hidden="true" tabindex="-1"></a>STAMMSPALTEN <span class="op">=</span> (<span class="st">&quot;Produkt&quot;</span>, <span class="st">&quot;Deckungsbeitrag&quot;</span>)</span>
-<span id="cb5-365"><a href="#cb5-365" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb5-366"><a href="#cb5-366" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb5-367"><a href="#cb5-367" aria-hidden="true" tabindex="-1"></a><span class="kw">def</span> lade_produktionsproblem(pfad: <span class="bu">str</span>, blatt_produkte: <span class="bu">str</span> <span class="op">=</span> <span class="st">&quot;Produkte&quot;</span>,</span>
-<span id="cb5-368"><a href="#cb5-368" aria-hidden="true" tabindex="-1"></a>                            blatt_kapazitaeten: <span class="bu">str</span> <span class="op">=</span> <span class="st">&quot;Kapazitaeten&quot;</span></span>
-<span id="cb5-369"><a href="#cb5-369" aria-hidden="true" tabindex="-1"></a>                            ) <span class="op">-&gt;</span> Produktionsproblem:</span>
-<span id="cb5-370"><a href="#cb5-370" aria-hidden="true" tabindex="-1"></a>    <span class="co">&quot;&quot;&quot;Liest eine Excel-Mappe und liefert ein geprueftes Domaenenmodell.</span></span>
-<span id="cb5-371"><a href="#cb5-371" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb5-372"><a href="#cb5-372" aria-hidden="true" tabindex="-1"></a><span class="co">    Alle Spalten ausser &#39;Produkt&#39; und &#39;Deckungsbeitrag&#39; gelten als</span></span>
-<span id="cb5-373"><a href="#cb5-373" aria-hidden="true" tabindex="-1"></a><span class="co">    Verbrauchsspalten - eine neue Ressource ist damit eine neue SPALTE in der</span></span>
-<span id="cb5-374"><a href="#cb5-374" aria-hidden="true" tabindex="-1"></a><span class="co">    Mappe und erfordert keine Codeaenderung.</span></span>
-<span id="cb5-375"><a href="#cb5-375" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb5-376"><a href="#cb5-376" aria-hidden="true" tabindex="-1"></a><span class="co">    Die eigentliche Pruefung passiert nicht hier, sondern im Konstruktor von</span></span>
-<span id="cb5-377"><a href="#cb5-377" aria-hidden="true" tabindex="-1"></a><span class="co">    Produktionsproblem. Diese Funktion uebersetzt nur Tabelle in Objekt; was</span></span>
-<span id="cb5-378"><a href="#cb5-378" aria-hidden="true" tabindex="-1"></a><span class="co">    ein gueltiges Problem ist, steht an genau einer Stelle.</span></span>
-<span id="cb5-379"><a href="#cb5-379" aria-hidden="true" tabindex="-1"></a><span class="co">    &quot;&quot;&quot;</span></span>
-<span id="cb5-380"><a href="#cb5-380" aria-hidden="true" tabindex="-1"></a>    <span class="im">import</span> pandas <span class="im">as</span> pd</span>
-<span id="cb5-381"><a href="#cb5-381" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb5-382"><a href="#cb5-382" aria-hidden="true" tabindex="-1"></a>    produkte_tabelle <span class="op">=</span> pd.read_excel(pfad, sheet_name<span class="op">=</span>blatt_produkte)</span>
-<span id="cb5-383"><a href="#cb5-383" aria-hidden="true" tabindex="-1"></a>    kapazitaeten_tabelle <span class="op">=</span> pd.read_excel(pfad, sheet_name<span class="op">=</span>blatt_kapazitaeten)</span>
-<span id="cb5-384"><a href="#cb5-384" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb5-385"><a href="#cb5-385" aria-hidden="true" tabindex="-1"></a>    fehlende <span class="op">=</span> [s <span class="cf">for</span> s <span class="kw">in</span> STAMMSPALTEN <span class="cf">if</span> s <span class="kw">not</span> <span class="kw">in</span> produkte_tabelle.columns]</span>
-<span id="cb5-386"><a href="#cb5-386" aria-hidden="true" tabindex="-1"></a>    <span class="cf">if</span> fehlende:</span>
-<span id="cb5-387"><a href="#cb5-387" aria-hidden="true" tabindex="-1"></a>        <span class="cf">raise</span> <span class="pp">ValueError</span>(<span class="ss">f&quot;Blatt &#39;</span><span class="sc">{</span>blatt_produkte<span class="sc">}</span><span class="ss">&#39;: Spalten fehlen: </span><span class="sc">{</span>fehlende<span class="sc">}</span><span class="ss">&quot;</span>)</span>
-<span id="cb5-388"><a href="#cb5-388" aria-hidden="true" tabindex="-1"></a>    <span class="cf">if</span> produkte_tabelle.isna().<span class="bu">any</span>().<span class="bu">any</span>():</span>
-<span id="cb5-389"><a href="#cb5-389" aria-hidden="true" tabindex="-1"></a>        zeilen <span class="op">=</span> produkte_tabelle[produkte_tabelle.isna().<span class="bu">any</span>(axis<span class="op">=</span><span class="dv">1</span>)].index.tolist()</span>
-<span id="cb5-390"><a href="#cb5-390" aria-hidden="true" tabindex="-1"></a>        <span class="cf">raise</span> <span class="pp">ValueError</span>(<span class="ss">f&quot;Blatt &#39;</span><span class="sc">{</span>blatt_produkte<span class="sc">}</span><span class="ss">&#39;: leere Zellen in Zeile(n) </span><span class="sc">{</span>zeilen<span class="sc">}</span><span class="ss">&quot;</span>)</span>
-<span id="cb5-391"><a href="#cb5-391" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb5-392"><a href="#cb5-392" aria-hidden="true" tabindex="-1"></a>    ressourcen <span class="op">=</span> [s <span class="cf">for</span> s <span class="kw">in</span> produkte_tabelle.columns <span class="cf">if</span> s <span class="kw">not</span> <span class="kw">in</span> STAMMSPALTEN]</span>
-<span id="cb5-393"><a href="#cb5-393" aria-hidden="true" tabindex="-1"></a>    produkte <span class="op">=</span> [</span>
-<span id="cb5-394"><a href="#cb5-394" aria-hidden="true" tabindex="-1"></a>        Produkt(name<span class="op">=</span><span class="bu">str</span>(zeile.Produkt),</span>
-<span id="cb5-395"><a href="#cb5-395" aria-hidden="true" tabindex="-1"></a>                deckungsbeitrag<span class="op">=</span><span class="bu">float</span>(zeile.Deckungsbeitrag),</span>
-<span id="cb5-396"><a href="#cb5-396" aria-hidden="true" tabindex="-1"></a>                verbrauch<span class="op">=</span>{r: <span class="bu">float</span>(<span class="bu">getattr</span>(zeile, r)) <span class="cf">for</span> r <span class="kw">in</span> ressourcen})</span>
-<span id="cb5-397"><a href="#cb5-397" aria-hidden="true" tabindex="-1"></a>        <span class="cf">for</span> zeile <span class="kw">in</span> produkte_tabelle.itertuples()</span>
-<span id="cb5-398"><a href="#cb5-398" aria-hidden="true" tabindex="-1"></a>    ]</span>
-<span id="cb5-399"><a href="#cb5-399" aria-hidden="true" tabindex="-1"></a>    kapazitaeten <span class="op">=</span> {<span class="bu">str</span>(z.Ressource): <span class="bu">float</span>(z.Verfuegbar)</span>
-<span id="cb5-400"><a href="#cb5-400" aria-hidden="true" tabindex="-1"></a>                    <span class="cf">for</span> z <span class="kw">in</span> kapazitaeten_tabelle.itertuples()}</span>
-<span id="cb5-401"><a href="#cb5-401" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb5-402"><a href="#cb5-402" aria-hidden="true" tabindex="-1"></a>    <span class="cf">return</span> Produktionsproblem(produkte<span class="op">=</span>produkte, kapazitaeten<span class="op">=</span>kapazitaeten)</span>
-<span id="cb5-403"><a href="#cb5-403" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb5-404"><a href="#cb5-404" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb5-405"><a href="#cb5-405" aria-hidden="true" tabindex="-1"></a><span class="kw">def</span> schreibe_ergebnis(pfad: <span class="bu">str</span>, problem: Produktionsproblem,</span>
-<span id="cb5-406"><a href="#cb5-406" aria-hidden="true" tabindex="-1"></a>                      loesung: Loesung) <span class="op">-&gt;</span> <span class="va">None</span>:</span>
-<span id="cb5-407"><a href="#cb5-407" aria-hidden="true" tabindex="-1"></a>    <span class="co">&quot;&quot;&quot;Schreibt Plan und Kennzahlen als zwei Blaetter zurueck nach Excel.</span></span>
-<span id="cb5-408"><a href="#cb5-408" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb5-409"><a href="#cb5-409" aria-hidden="true" tabindex="-1"></a><span class="co">    Die Fachabteilung bekommt das Ergebnis im Format, das sie ohnehin benutzt.</span></span>
-<span id="cb5-410"><a href="#cb5-410" aria-hidden="true" tabindex="-1"></a><span class="co">    Akzeptanz entscheidet ueber Projekterfolg (Kapitel Praxisfallen).</span></span>
-<span id="cb5-411"><a href="#cb5-411" aria-hidden="true" tabindex="-1"></a><span class="co">    &quot;&quot;&quot;</span></span>
-<span id="cb5-412"><a href="#cb5-412" aria-hidden="true" tabindex="-1"></a>    <span class="im">import</span> pandas <span class="im">as</span> pd</span>
-<span id="cb5-413"><a href="#cb5-413" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb5-414"><a href="#cb5-414" aria-hidden="true" tabindex="-1"></a>    <span class="cf">if</span> <span class="kw">not</span> loesung.status.brauchbar:</span>
-<span id="cb5-415"><a href="#cb5-415" aria-hidden="true" tabindex="-1"></a>        <span class="cf">raise</span> <span class="pp">ValueError</span>(<span class="ss">f&quot;Nichts zu schreiben - Status: </span><span class="sc">{</span>loesung<span class="sc">.</span>status<span class="sc">.</span>value<span class="sc">}</span><span class="ss">&quot;</span>)</span>
-<span id="cb5-416"><a href="#cb5-416" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb5-417"><a href="#cb5-417" aria-hidden="true" tabindex="-1"></a>    mengen <span class="op">=</span> np.array([loesung.werte[p.name] <span class="cf">for</span> p <span class="kw">in</span> problem.produkte])</span>
-<span id="cb5-418"><a href="#cb5-418" aria-hidden="true" tabindex="-1"></a>    plan <span class="op">=</span> pd.DataFrame({</span>
-<span id="cb5-419"><a href="#cb5-419" aria-hidden="true" tabindex="-1"></a>        <span class="st">&quot;Produkt&quot;</span>: [p.name <span class="cf">for</span> p <span class="kw">in</span> problem.produkte],</span>
-<span id="cb5-420"><a href="#cb5-420" aria-hidden="true" tabindex="-1"></a>        <span class="st">&quot;Menge&quot;</span>: mengen,</span>
-<span id="cb5-421"><a href="#cb5-421" aria-hidden="true" tabindex="-1"></a>        <span class="st">&quot;Deckungsbeitrag&quot;</span>: mengen <span class="op">*</span> problem.deckungsbeitragsvektor(),</span>
-<span id="cb5-422"><a href="#cb5-422" aria-hidden="true" tabindex="-1"></a>    })</span>
-<span id="cb5-423"><a href="#cb5-423" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb5-424"><a href="#cb5-424" aria-hidden="true" tabindex="-1"></a>    verbrauch <span class="op">=</span> problem.verbrauchsmatrix() <span class="op">@</span> mengen</span>
-<span id="cb5-425"><a href="#cb5-425" aria-hidden="true" tabindex="-1"></a>    kennzahlen: <span class="bu">dict</span>[<span class="bu">str</span>, <span class="bu">float</span> <span class="op">|</span> <span class="bu">str</span>] <span class="op">=</span> {</span>
-<span id="cb5-426"><a href="#cb5-426" aria-hidden="true" tabindex="-1"></a>        <span class="st">&quot;Status&quot;</span>: loesung.status.value,</span>
-<span id="cb5-427"><a href="#cb5-427" aria-hidden="true" tabindex="-1"></a>        <span class="st">&quot;Gesamtdeckungsbeitrag&quot;</span>: loesung.zielwert <span class="kw">or</span> <span class="fl">0.0</span>,</span>
-<span id="cb5-428"><a href="#cb5-428" aria-hidden="true" tabindex="-1"></a>    }</span>
-<span id="cb5-429"><a href="#cb5-429" aria-hidden="true" tabindex="-1"></a>    <span class="cf">for</span> ressource, ist, grenze <span class="kw">in</span> <span class="bu">zip</span>(problem.ressourcen, verbrauch,</span>
-<span id="cb5-430"><a href="#cb5-430" aria-hidden="true" tabindex="-1"></a>                                      problem.kapazitaetsvektor()):</span>
-<span id="cb5-431"><a href="#cb5-431" aria-hidden="true" tabindex="-1"></a>        kennzahlen[<span class="ss">f&quot;</span><span class="sc">{</span>ressource<span class="sc">}</span><span class="ss">: Verbrauch&quot;</span>] <span class="op">=</span> <span class="bu">float</span>(ist)</span>
-<span id="cb5-432"><a href="#cb5-432" aria-hidden="true" tabindex="-1"></a>        kennzahlen[<span class="ss">f&quot;</span><span class="sc">{</span>ressource<span class="sc">}</span><span class="ss">: Auslastung %&quot;</span>] <span class="op">=</span> <span class="bu">float</span>(<span class="fl">100.0</span> <span class="op">*</span> ist <span class="op">/</span> grenze)</span>
-<span id="cb5-433"><a href="#cb5-433" aria-hidden="true" tabindex="-1"></a>        <span class="cf">if</span> ressource <span class="kw">in</span> loesung.schattenpreise:</span>
-<span id="cb5-434"><a href="#cb5-434" aria-hidden="true" tabindex="-1"></a>            kennzahlen[<span class="ss">f&quot;</span><span class="sc">{</span>ressource<span class="sc">}</span><span class="ss">: Schattenpreis&quot;</span>] <span class="op">=</span> <span class="op">\</span></span>
-<span id="cb5-435"><a href="#cb5-435" aria-hidden="true" tabindex="-1"></a>                loesung.schattenpreise[ressource]</span>
-<span id="cb5-436"><a href="#cb5-436" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb5-437"><a href="#cb5-437" aria-hidden="true" tabindex="-1"></a>    kennzahlen_tabelle <span class="op">=</span> pd.DataFrame({</span>
-<span id="cb5-438"><a href="#cb5-438" aria-hidden="true" tabindex="-1"></a>        <span class="st">&quot;Kennzahl&quot;</span>: <span class="bu">list</span>(kennzahlen),</span>
-<span id="cb5-439"><a href="#cb5-439" aria-hidden="true" tabindex="-1"></a>        <span class="st">&quot;Wert&quot;</span>: [<span class="bu">round</span>(w, <span class="dv">2</span>) <span class="cf">if</span> <span class="bu">isinstance</span>(w, <span class="bu">float</span>) <span class="cf">else</span> w</span>
-<span id="cb5-440"><a href="#cb5-440" aria-hidden="true" tabindex="-1"></a>                 <span class="cf">for</span> w <span class="kw">in</span> kennzahlen.values()],</span>
-<span id="cb5-441"><a href="#cb5-441" aria-hidden="true" tabindex="-1"></a>    })</span>
-<span id="cb5-442"><a href="#cb5-442" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb5-443"><a href="#cb5-443" aria-hidden="true" tabindex="-1"></a>    <span class="cf">with</span> pd.ExcelWriter(pfad, engine<span class="op">=</span><span class="st">&quot;openpyxl&quot;</span>) <span class="im">as</span> mappe:</span>
-<span id="cb5-444"><a href="#cb5-444" aria-hidden="true" tabindex="-1"></a>        plan.<span class="bu">round</span>(<span class="dv">2</span>).to_excel(mappe, sheet_name<span class="op">=</span><span class="st">&quot;Plan&quot;</span>, index<span class="op">=</span><span class="va">False</span>)</span>
-<span id="cb5-445"><a href="#cb5-445" aria-hidden="true" tabindex="-1"></a>        kennzahlen_tabelle.to_excel(mappe, sheet_name<span class="op">=</span><span class="st">&quot;Kennzahlen&quot;</span>, index<span class="op">=</span><span class="va">False</span>)</span>
-<span id="cb5-446"><a href="#cb5-446" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb5-447"><a href="#cb5-447" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb5-448"><a href="#cb5-448" aria-hidden="true" tabindex="-1"></a><span class="cf">if</span> <span class="va">__name__</span> <span class="op">==</span> <span class="st">&quot;__main__&quot;</span>:</span>
-<span id="cb5-449"><a href="#cb5-449" aria-hidden="true" tabindex="-1"></a>    <span class="co"># Die Schreinerei aus Kapitel Einfuehrung - jetzt als Domaenenmodell.</span></span>
-<span id="cb5-450"><a href="#cb5-450" aria-hidden="true" tabindex="-1"></a>    schreinerei <span class="op">=</span> Produktionsproblem(</span>
-<span id="cb5-451"><a href="#cb5-451" aria-hidden="true" tabindex="-1"></a>        produkte<span class="op">=</span>[</span>
-<span id="cb5-452"><a href="#cb5-452" aria-hidden="true" tabindex="-1"></a>            Produkt(name<span class="op">=</span><span class="st">&quot;Tisch&quot;</span>, deckungsbeitrag<span class="op">=</span><span class="fl">240.0</span>,</span>
-<span id="cb5-453"><a href="#cb5-453" aria-hidden="true" tabindex="-1"></a>                    verbrauch<span class="op">=</span>{<span class="st">&quot;Montagestunden&quot;</span>: <span class="fl">3.0</span>, <span class="st">&quot;Plattenmaterial&quot;</span>: <span class="fl">6.0</span>}),</span>
-<span id="cb5-454"><a href="#cb5-454" aria-hidden="true" tabindex="-1"></a>            Produkt(name<span class="op">=</span><span class="st">&quot;Stuhl&quot;</span>, deckungsbeitrag<span class="op">=</span><span class="fl">60.0</span>,</span>
-<span id="cb5-455"><a href="#cb5-455" aria-hidden="true" tabindex="-1"></a>                    verbrauch<span class="op">=</span>{<span class="st">&quot;Montagestunden&quot;</span>: <span class="fl">1.0</span>, <span class="st">&quot;Plattenmaterial&quot;</span>: <span class="fl">1.0</span>}),</span>
-<span id="cb5-456"><a href="#cb5-456" aria-hidden="true" tabindex="-1"></a>        ],</span>
-<span id="cb5-457"><a href="#cb5-457" aria-hidden="true" tabindex="-1"></a>        kapazitaeten<span class="op">=</span>{<span class="st">&quot;Montagestunden&quot;</span>: <span class="fl">150.0</span>, <span class="st">&quot;Plattenmaterial&quot;</span>: <span class="fl">240.0</span>},</span>
-<span id="cb5-458"><a href="#cb5-458" aria-hidden="true" tabindex="-1"></a>    )</span>
-<span id="cb5-459"><a href="#cb5-459" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb5-460"><a href="#cb5-460" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;=&quot;</span> <span class="op">*</span> <span class="dv">78</span>)</span>
-<span id="cb5-461"><a href="#cb5-461" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;  DERSELBE FALL, ZWEI SOLVER, EIN AUSWERTUNGSCODE&quot;</span>)</span>
-<span id="cb5-462"><a href="#cb5-462" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;=&quot;</span> <span class="op">*</span> <span class="dv">78</span>)</span>
-<span id="cb5-463"><a href="#cb5-463" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb5-464"><a href="#cb5-464" aria-hidden="true" tabindex="-1"></a>    <span class="cf">for</span> name, bauer <span class="kw">in</span> [(<span class="st">&quot;OR-Tools GLOP&quot;</span>, loese_mit_glop),</span>
-<span id="cb5-465"><a href="#cb5-465" aria-hidden="true" tabindex="-1"></a>                        (<span class="st">&quot;scipy / HiGHS&quot;</span>, loese_mit_scipy)]:</span>
-<span id="cb5-466"><a href="#cb5-466" aria-hidden="true" tabindex="-1"></a>        loesung <span class="op">=</span> bauer(schreinerei)</span>
-<span id="cb5-467"><a href="#cb5-467" aria-hidden="true" tabindex="-1"></a>        beanstandungen <span class="op">=</span> pruefe_loesung(schreinerei, loesung)</span>
-<span id="cb5-468"><a href="#cb5-468" aria-hidden="true" tabindex="-1"></a>        <span class="bu">print</span>(<span class="ss">f&quot;</span><span class="ch">\n</span><span class="sc">{</span>name<span class="sc">}</span><span class="ss">&quot;</span>)</span>
-<span id="cb5-469"><a href="#cb5-469" aria-hidden="true" tabindex="-1"></a>        <span class="bu">print</span>(<span class="ss">f&quot;  </span><span class="sc">{</span>loesung<span class="sc">.</span>als_bericht()<span class="sc">}</span><span class="ss">&quot;</span>)</span>
-<span id="cb5-470"><a href="#cb5-470" aria-hidden="true" tabindex="-1"></a>        <span class="cf">for</span> produkt, menge <span class="kw">in</span> loesung.werte.items():</span>
-<span id="cb5-471"><a href="#cb5-471" aria-hidden="true" tabindex="-1"></a>            <span class="bu">print</span>(<span class="ss">f&quot;    </span><span class="sc">{</span>produkt<span class="sc">:&lt;10}</span><span class="ss"> </span><span class="sc">{</span>menge<span class="sc">:8.2f}</span><span class="ss">&quot;</span>)</span>
-<span id="cb5-472"><a href="#cb5-472" aria-hidden="true" tabindex="-1"></a>        <span class="bu">print</span>(<span class="ss">f&quot;  Abnahmepruefung: &quot;</span></span>
-<span id="cb5-473"><a href="#cb5-473" aria-hidden="true" tabindex="-1"></a>              <span class="ss">f&quot;</span><span class="sc">{</span><span class="st">&#39;bestanden&#39;</span> <span class="cf">if</span> <span class="kw">not</span> beanstandungen <span class="cf">else</span> beanstandungen<span class="sc">}</span><span class="ss">&quot;</span>)</span>
-<span id="cb5-474"><a href="#cb5-474" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb5-475"><a href="#cb5-475" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;</span><span class="ch">\n</span><span class="st">&quot;</span> <span class="op">+</span> <span class="st">&quot;=&quot;</span> <span class="op">*</span> <span class="dv">78</span>)</span>
-<span id="cb5-476"><a href="#cb5-476" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;  WAS DIE PRUEFUNGEN ABFANGEN&quot;</span>)</span>
-<span id="cb5-477"><a href="#cb5-477" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;=&quot;</span> <span class="op">*</span> <span class="dv">78</span>)</span>
-<span id="cb5-478"><a href="#cb5-478" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb5-479"><a href="#cb5-479" aria-hidden="true" tabindex="-1"></a>    faelle <span class="op">=</span> [</span>
-<span id="cb5-480"><a href="#cb5-480" aria-hidden="true" tabindex="-1"></a>        (<span class="st">&quot;Kapazitaet 0&quot;</span>, <span class="bu">dict</span>(</span>
-<span id="cb5-481"><a href="#cb5-481" aria-hidden="true" tabindex="-1"></a>            produkte<span class="op">=</span>schreinerei.produkte,</span>
-<span id="cb5-482"><a href="#cb5-482" aria-hidden="true" tabindex="-1"></a>            kapazitaeten<span class="op">=</span>{<span class="st">&quot;Montagestunden&quot;</span>: <span class="fl">0.0</span>, <span class="st">&quot;Plattenmaterial&quot;</span>: <span class="fl">240.0</span>})),</span>
-<span id="cb5-483"><a href="#cb5-483" aria-hidden="true" tabindex="-1"></a>        (<span class="st">&quot;Ressource ohne Kapazitaet&quot;</span>, <span class="bu">dict</span>(</span>
-<span id="cb5-484"><a href="#cb5-484" aria-hidden="true" tabindex="-1"></a>            produkte<span class="op">=</span>[Produkt(name<span class="op">=</span><span class="st">&quot;Regal&quot;</span>, deckungsbeitrag<span class="op">=</span><span class="fl">130.0</span>,</span>
-<span id="cb5-485"><a href="#cb5-485" aria-hidden="true" tabindex="-1"></a>                              verbrauch<span class="op">=</span>{<span class="st">&quot;Lackieren&quot;</span>: <span class="fl">2.0</span>})],</span>
-<span id="cb5-486"><a href="#cb5-486" aria-hidden="true" tabindex="-1"></a>            kapazitaeten<span class="op">=</span>{<span class="st">&quot;Montagestunden&quot;</span>: <span class="fl">150.0</span>})),</span>
-<span id="cb5-487"><a href="#cb5-487" aria-hidden="true" tabindex="-1"></a>        (<span class="st">&quot;doppelter Produktname&quot;</span>, <span class="bu">dict</span>(</span>
-<span id="cb5-488"><a href="#cb5-488" aria-hidden="true" tabindex="-1"></a>            produkte<span class="op">=</span>[schreinerei.produkte[<span class="dv">0</span>], schreinerei.produkte[<span class="dv">0</span>]],</span>
-<span id="cb5-489"><a href="#cb5-489" aria-hidden="true" tabindex="-1"></a>            kapazitaeten<span class="op">=</span>schreinerei.kapazitaeten)),</span>
-<span id="cb5-490"><a href="#cb5-490" aria-hidden="true" tabindex="-1"></a>    ]</span>
-<span id="cb5-491"><a href="#cb5-491" aria-hidden="true" tabindex="-1"></a>    <span class="cf">for</span> beschreibung, daten <span class="kw">in</span> faelle:</span>
-<span id="cb5-492"><a href="#cb5-492" aria-hidden="true" tabindex="-1"></a>        <span class="cf">try</span>:</span>
-<span id="cb5-493"><a href="#cb5-493" aria-hidden="true" tabindex="-1"></a>            Produktionsproblem(<span class="op">**</span>daten)</span>
-<span id="cb5-494"><a href="#cb5-494" aria-hidden="true" tabindex="-1"></a>            <span class="bu">print</span>(<span class="ss">f&quot;  </span><span class="sc">{</span>beschreibung<span class="sc">:&lt;28}</span><span class="ss"> NICHT erkannt (!)&quot;</span>)</span>
-<span id="cb5-495"><a href="#cb5-495" aria-hidden="true" tabindex="-1"></a>        <span class="cf">except</span> <span class="pp">Exception</span> <span class="im">as</span> fehler:</span>
-<span id="cb5-496"><a href="#cb5-496" aria-hidden="true" tabindex="-1"></a>            meldung <span class="op">=</span> <span class="bu">str</span>(fehler).splitlines()</span>
-<span id="cb5-497"><a href="#cb5-497" aria-hidden="true" tabindex="-1"></a>            kern <span class="op">=</span> <span class="bu">next</span>((z.strip() <span class="cf">for</span> z <span class="kw">in</span> meldung</span>
-<span id="cb5-498"><a href="#cb5-498" aria-hidden="true" tabindex="-1"></a>                         <span class="cf">if</span> <span class="st">&quot;Value error&quot;</span> <span class="kw">in</span> z <span class="kw">or</span> <span class="st">&quot;greater than&quot;</span> <span class="kw">in</span> z), meldung[<span class="op">-</span><span class="dv">1</span>])</span>
-<span id="cb5-499"><a href="#cb5-499" aria-hidden="true" tabindex="-1"></a>            <span class="bu">print</span>(<span class="ss">f&quot;  </span><span class="sc">{</span>beschreibung<span class="sc">:&lt;28}</span><span class="ss"> abgefangen: </span><span class="sc">{</span>kern[:<span class="dv">44</span>]<span class="sc">}</span><span class="ss">&quot;</span>)</span>
-<span id="cb5-500"><a href="#cb5-500" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb5-501"><a href="#cb5-501" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;</span><span class="ch">\n</span><span class="st">Alle drei scheitern beim EINLESEN - nicht erst beim Loesen und&quot;</span>)</span>
-<span id="cb5-502"><a href="#cb5-502" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;schon gar nicht erst im Bericht. Das ist der ganze Zweck der&quot;</span>)</span>
-<span id="cb5-503"><a href="#cb5-503" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;Domaenenschicht.&quot;</span>)</span>
-<span id="cb5-504"><a href="#cb5-504" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;=&quot;</span> <span class="op">*</span> <span class="dv">78</span>)</span></code></pre></div>
+<div class="sourceCode" id="cb7"><pre class="sourceCode python"><code class="sourceCode python"><span id="cb7-1"><a href="#cb7-1" aria-hidden="true" tabindex="-1"></a><span class="co">#!/usr/bin/env python3</span></span>
+<span id="cb7-2"><a href="#cb7-2" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb7-3"><a href="#cb7-3" aria-hidden="true" tabindex="-1"></a><span class="co"># or_kern.py</span></span>
+<span id="cb7-4"><a href="#cb7-4" aria-hidden="true" tabindex="-1"></a><span class="co">&quot;&quot;&quot;</span></span>
+<span id="cb7-5"><a href="#cb7-5" aria-hidden="true" tabindex="-1"></a><span class="co">Kapitel Praxisfallen: Der gemeinsame Unterbau fuer produktionsreife OR-Modelle.</span></span>
+<span id="cb7-6"><a href="#cb7-6" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb7-7"><a href="#cb7-7" aria-hidden="true" tabindex="-1"></a><span class="co">Alle Beispiele dieses Buchs loesen dieselben vier Aufgaben immer wieder:</span></span>
+<span id="cb7-8"><a href="#cb7-8" aria-hidden="true" tabindex="-1"></a><span class="co">Daten einlesen und pruefen, ein Modell bauen, den Solverstatus auswerten, die</span></span>
+<span id="cb7-9"><a href="#cb7-9" aria-hidden="true" tabindex="-1"></a><span class="co">Loesung gegen die Wirklichkeit kontrollieren. Dieses Modul zieht diese vier</span></span>
+<span id="cb7-10"><a href="#cb7-10" aria-hidden="true" tabindex="-1"></a><span class="co">Aufgaben aus den Einzelprogrammen heraus.</span></span>
+<span id="cb7-11"><a href="#cb7-11" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb7-12"><a href="#cb7-12" aria-hidden="true" tabindex="-1"></a><span class="co">    Rohdaten (Excel/CSV)</span></span>
+<span id="cb7-13"><a href="#cb7-13" aria-hidden="true" tabindex="-1"></a><span class="co">        -&gt; Domaenenmodell (Pydantic, geprueft)</span></span>
+<span id="cb7-14"><a href="#cb7-14" aria-hidden="true" tabindex="-1"></a><span class="co">            -&gt; Modellbauer (solverabhaengig)</span></span>
+<span id="cb7-15"><a href="#cb7-15" aria-hidden="true" tabindex="-1"></a><span class="co">                -&gt; Loesung (DTO, solverunabhaengig)</span></span>
+<span id="cb7-16"><a href="#cb7-16" aria-hidden="true" tabindex="-1"></a><span class="co">                    -&gt; Abnahmepruefung</span></span>
+<span id="cb7-17"><a href="#cb7-17" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb7-18"><a href="#cb7-18" aria-hidden="true" tabindex="-1"></a><span class="co">Der Sinn dieser Trennung: Die Domaenenschicht weiss nichts von Solvern, die</span></span>
+<span id="cb7-19"><a href="#cb7-19" aria-hidden="true" tabindex="-1"></a><span class="co">Loesungsschicht weiss nichts vom Modellaufbau. Wer den Solver wechselt, tauscht</span></span>
+<span id="cb7-20"><a href="#cb7-20" aria-hidden="true" tabindex="-1"></a><span class="co">genau EINEN Baustein aus - der Rest bleibt.</span></span>
+<span id="cb7-21"><a href="#cb7-21" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb7-22"><a href="#cb7-22" aria-hidden="true" tabindex="-1"></a><span class="co">WICHTIG ZUM IMPORT: Dieses Modul importiert von sich aus KEINE Solver-</span></span>
+<span id="cb7-23"><a href="#cb7-23" aria-hidden="true" tabindex="-1"></a><span class="co">bibliothek. Der Grund steht im Kapitel Oekosystem: ortools und highspy vertragen sich</span></span>
+<span id="cb7-24"><a href="#cb7-24" aria-hidden="true" tabindex="-1"></a><span class="co">nicht im selben Prozess. Die Statusuebersetzer laden ihre Bibliothek erst,</span></span>
+<span id="cb7-25"><a href="#cb7-25" aria-hidden="true" tabindex="-1"></a><span class="co">wenn sie aufgerufen werden - so bleibt or_kern.py mit jedem Solver benutzbar.</span></span>
+<span id="cb7-26"><a href="#cb7-26" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb7-27"><a href="#cb7-27" aria-hidden="true" tabindex="-1"></a><span class="co">Benoetigt: pydantic (v2), numpy; optional pandas und openpyxl fuer Excel.</span></span>
+<span id="cb7-28"><a href="#cb7-28" aria-hidden="true" tabindex="-1"></a><span class="co">&quot;&quot;&quot;</span></span>
+<span id="cb7-29"><a href="#cb7-29" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb7-30"><a href="#cb7-30" aria-hidden="true" tabindex="-1"></a><span class="im">from</span> __future__ <span class="im">import</span> annotations</span>
+<span id="cb7-31"><a href="#cb7-31" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb7-32"><a href="#cb7-32" aria-hidden="true" tabindex="-1"></a><span class="im">from</span> enum <span class="im">import</span> Enum</span>
+<span id="cb7-33"><a href="#cb7-33" aria-hidden="true" tabindex="-1"></a><span class="im">from</span> typing <span class="im">import</span> Annotated, Any, Sequence</span>
+<span id="cb7-34"><a href="#cb7-34" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb7-35"><a href="#cb7-35" aria-hidden="true" tabindex="-1"></a><span class="im">import</span> numpy <span class="im">as</span> np</span>
+<span id="cb7-36"><a href="#cb7-36" aria-hidden="true" tabindex="-1"></a><span class="im">from</span> pydantic <span class="im">import</span> BaseModel, Field, model_validator</span>
+<span id="cb7-37"><a href="#cb7-37" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb7-38"><a href="#cb7-38" aria-hidden="true" tabindex="-1"></a><span class="co"># Wiederverwendbare Feldtypen. Sie tragen die Pruefung im Typ, nicht im Code -</span></span>
+<span id="cb7-39"><a href="#cb7-39" aria-hidden="true" tabindex="-1"></a><span class="co"># damit gilt sie ueberall, wo der Typ verwendet wird.</span></span>
+<span id="cb7-40"><a href="#cb7-40" aria-hidden="true" tabindex="-1"></a>PositiveZahl <span class="op">=</span> Annotated[<span class="bu">float</span>, Field(gt<span class="op">=</span><span class="dv">0</span>)]</span>
+<span id="cb7-41"><a href="#cb7-41" aria-hidden="true" tabindex="-1"></a>NichtNegativ <span class="op">=</span> Annotated[<span class="bu">float</span>, Field(ge<span class="op">=</span><span class="dv">0</span>)]</span>
+<span id="cb7-42"><a href="#cb7-42" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb7-43"><a href="#cb7-43" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb7-44"><a href="#cb7-44" aria-hidden="true" tabindex="-1"></a><span class="co"># --- 1. Solverstatus: eine Sprache fuer fuenf Bibliotheken -------------------</span></span>
+<span id="cb7-45"><a href="#cb7-45" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb7-46"><a href="#cb7-46" aria-hidden="true" tabindex="-1"></a><span class="kw">class</span> SolverStatus(<span class="bu">str</span>, Enum):</span>
+<span id="cb7-47"><a href="#cb7-47" aria-hidden="true" tabindex="-1"></a>    <span class="co">&quot;&quot;&quot;Was ein Solverlauf ergeben hat - unabhaengig davon, wer gerechnet hat.</span></span>
+<span id="cb7-48"><a href="#cb7-48" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb7-49"><a href="#cb7-49" aria-hidden="true" tabindex="-1"></a><span class="co">    Die fuenf im Buch verwendeten Bibliotheken benennen dasselbe Ergebnis</span></span>
+<span id="cb7-50"><a href="#cb7-50" aria-hidden="true" tabindex="-1"></a><span class="co">    unterschiedlich: &#39;Optimal&#39;, &#39;OPTIMAL&#39;, 2, &#39;optimal&#39;. Wer darauf direkt</span></span>
+<span id="cb7-51"><a href="#cb7-51" aria-hidden="true" tabindex="-1"></a><span class="co">    prueft, bindet seinen Auswertungscode an eine Bibliothek.</span></span>
+<span id="cb7-52"><a href="#cb7-52" aria-hidden="true" tabindex="-1"></a><span class="co">    &quot;&quot;&quot;</span></span>
+<span id="cb7-53"><a href="#cb7-53" aria-hidden="true" tabindex="-1"></a>    OPTIMAL <span class="op">=</span> <span class="st">&quot;optimal&quot;</span>              <span class="co"># beweisbar bestmoeglich</span></span>
+<span id="cb7-54"><a href="#cb7-54" aria-hidden="true" tabindex="-1"></a>    ZULAESSIG <span class="op">=</span> <span class="st">&quot;zulaessig&quot;</span>          <span class="co"># brauchbare Loesung, Beweis fehlt</span></span>
+<span id="cb7-55"><a href="#cb7-55" aria-hidden="true" tabindex="-1"></a>    UNZULAESSIG <span class="op">=</span> <span class="st">&quot;unzulaessig&quot;</span>      <span class="co"># es gibt keine Loesung (Aussage ueber das Modell)</span></span>
+<span id="cb7-56"><a href="#cb7-56" aria-hidden="true" tabindex="-1"></a>    UNBESCHRAENKT <span class="op">=</span> <span class="st">&quot;unbeschraenkt&quot;</span>  <span class="co"># Ziel waechst ins Unendliche</span></span>
+<span id="cb7-57"><a href="#cb7-57" aria-hidden="true" tabindex="-1"></a>    ZEITLIMIT <span class="op">=</span> <span class="st">&quot;zeitlimit&quot;</span>          <span class="co"># abgebrochen, nichts Brauchbares gefunden</span></span>
+<span id="cb7-58"><a href="#cb7-58" aria-hidden="true" tabindex="-1"></a>    FEHLERHAFT <span class="op">=</span> <span class="st">&quot;fehlerhaft&quot;</span>        <span class="co"># das Modell ist kein gueltiges Modell</span></span>
+<span id="cb7-59"><a href="#cb7-59" aria-hidden="true" tabindex="-1"></a>    UNBEKANNT <span class="op">=</span> <span class="st">&quot;unbekannt&quot;</span>          <span class="co"># alles Uebrige</span></span>
+<span id="cb7-60"><a href="#cb7-60" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb7-61"><a href="#cb7-61" aria-hidden="true" tabindex="-1"></a>    <span class="at">@property</span></span>
+<span id="cb7-62"><a href="#cb7-62" aria-hidden="true" tabindex="-1"></a>    <span class="kw">def</span> brauchbar(<span class="va">self</span>) <span class="op">-&gt;</span> <span class="bu">bool</span>:</span>
+<span id="cb7-63"><a href="#cb7-63" aria-hidden="true" tabindex="-1"></a>        <span class="co">&quot;&quot;&quot;Habe ich etwas in der Hand, das ich ausfuehren kann?&quot;&quot;&quot;</span></span>
+<span id="cb7-64"><a href="#cb7-64" aria-hidden="true" tabindex="-1"></a>        <span class="cf">return</span> <span class="va">self</span> <span class="kw">in</span> (SolverStatus.OPTIMAL, SolverStatus.ZULAESSIG)</span>
+<span id="cb7-65"><a href="#cb7-65" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb7-66"><a href="#cb7-66" aria-hidden="true" tabindex="-1"></a>    <span class="at">@property</span></span>
+<span id="cb7-67"><a href="#cb7-67" aria-hidden="true" tabindex="-1"></a>    <span class="kw">def</span> modellfehler(<span class="va">self</span>) <span class="op">-&gt;</span> <span class="bu">bool</span>:</span>
+<span id="cb7-68"><a href="#cb7-68" aria-hidden="true" tabindex="-1"></a>        <span class="co">&quot;&quot;&quot;Liegt die Ursache im Modell (und nicht in der Rechenzeit)?&quot;&quot;&quot;</span></span>
+<span id="cb7-69"><a href="#cb7-69" aria-hidden="true" tabindex="-1"></a>        <span class="cf">return</span> <span class="va">self</span> <span class="kw">in</span> (SolverStatus.UNZULAESSIG, SolverStatus.UNBESCHRAENKT,</span>
+<span id="cb7-70"><a href="#cb7-70" aria-hidden="true" tabindex="-1"></a>                        SolverStatus.FEHLERHAFT)</span>
+<span id="cb7-71"><a href="#cb7-71" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb7-72"><a href="#cb7-72" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb7-73"><a href="#cb7-73" aria-hidden="true" tabindex="-1"></a><span class="kw">def</span> status_von_pywraplp(rohstatus: <span class="bu">int</span>) <span class="op">-&gt;</span> SolverStatus:</span>
+<span id="cb7-74"><a href="#cb7-74" aria-hidden="true" tabindex="-1"></a>    <span class="co">&quot;&quot;&quot;OR-Tools linear_solver (GLOP, SCIP, CBC).&quot;&quot;&quot;</span></span>
+<span id="cb7-75"><a href="#cb7-75" aria-hidden="true" tabindex="-1"></a>    <span class="im">from</span> ortools.linear_solver <span class="im">import</span> pywraplp</span>
+<span id="cb7-76"><a href="#cb7-76" aria-hidden="true" tabindex="-1"></a>    zuordnung <span class="op">=</span> {</span>
+<span id="cb7-77"><a href="#cb7-77" aria-hidden="true" tabindex="-1"></a>        pywraplp.Solver.OPTIMAL: SolverStatus.OPTIMAL,</span>
+<span id="cb7-78"><a href="#cb7-78" aria-hidden="true" tabindex="-1"></a>        pywraplp.Solver.FEASIBLE: SolverStatus.ZULAESSIG,</span>
+<span id="cb7-79"><a href="#cb7-79" aria-hidden="true" tabindex="-1"></a>        pywraplp.Solver.INFEASIBLE: SolverStatus.UNZULAESSIG,</span>
+<span id="cb7-80"><a href="#cb7-80" aria-hidden="true" tabindex="-1"></a>        pywraplp.Solver.UNBOUNDED: SolverStatus.UNBESCHRAENKT,</span>
+<span id="cb7-81"><a href="#cb7-81" aria-hidden="true" tabindex="-1"></a>        pywraplp.Solver.ABNORMAL: SolverStatus.FEHLERHAFT,</span>
+<span id="cb7-82"><a href="#cb7-82" aria-hidden="true" tabindex="-1"></a>        pywraplp.Solver.NOT_SOLVED: SolverStatus.ZEITLIMIT,</span>
+<span id="cb7-83"><a href="#cb7-83" aria-hidden="true" tabindex="-1"></a>    }</span>
+<span id="cb7-84"><a href="#cb7-84" aria-hidden="true" tabindex="-1"></a>    <span class="cf">return</span> zuordnung.get(rohstatus, SolverStatus.UNBEKANNT)</span>
+<span id="cb7-85"><a href="#cb7-85" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb7-86"><a href="#cb7-86" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb7-87"><a href="#cb7-87" aria-hidden="true" tabindex="-1"></a><span class="kw">def</span> status_von_cpsat(rohstatus: <span class="bu">int</span>) <span class="op">-&gt;</span> SolverStatus:</span>
+<span id="cb7-88"><a href="#cb7-88" aria-hidden="true" tabindex="-1"></a>    <span class="co">&quot;&quot;&quot;OR-Tools CP-SAT (siehe Kapitel CP-SAT, alle fuenf Faelle).&quot;&quot;&quot;</span></span>
+<span id="cb7-89"><a href="#cb7-89" aria-hidden="true" tabindex="-1"></a>    <span class="im">from</span> ortools.sat.python <span class="im">import</span> cp_model</span>
+<span id="cb7-90"><a href="#cb7-90" aria-hidden="true" tabindex="-1"></a>    zuordnung <span class="op">=</span> {</span>
+<span id="cb7-91"><a href="#cb7-91" aria-hidden="true" tabindex="-1"></a>        cp_model.OPTIMAL: SolverStatus.OPTIMAL,</span>
+<span id="cb7-92"><a href="#cb7-92" aria-hidden="true" tabindex="-1"></a>        cp_model.FEASIBLE: SolverStatus.ZULAESSIG,</span>
+<span id="cb7-93"><a href="#cb7-93" aria-hidden="true" tabindex="-1"></a>        cp_model.INFEASIBLE: SolverStatus.UNZULAESSIG,</span>
+<span id="cb7-94"><a href="#cb7-94" aria-hidden="true" tabindex="-1"></a>        cp_model.MODEL_INVALID: SolverStatus.FEHLERHAFT,</span>
+<span id="cb7-95"><a href="#cb7-95" aria-hidden="true" tabindex="-1"></a>        cp_model.UNKNOWN: SolverStatus.ZEITLIMIT,</span>
+<span id="cb7-96"><a href="#cb7-96" aria-hidden="true" tabindex="-1"></a>    }</span>
+<span id="cb7-97"><a href="#cb7-97" aria-hidden="true" tabindex="-1"></a>    <span class="cf">return</span> zuordnung.get(rohstatus, SolverStatus.UNBEKANNT)</span>
+<span id="cb7-98"><a href="#cb7-98" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb7-99"><a href="#cb7-99" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb7-100"><a href="#cb7-100" aria-hidden="true" tabindex="-1"></a><span class="kw">def</span> status_von_highs(statustext: <span class="bu">str</span>) <span class="op">-&gt;</span> SolverStatus:</span>
+<span id="cb7-101"><a href="#cb7-101" aria-hidden="true" tabindex="-1"></a>    <span class="co">&quot;&quot;&quot;HiGHS ueber highspy - hier kommt der Status als Text.&quot;&quot;&quot;</span></span>
+<span id="cb7-102"><a href="#cb7-102" aria-hidden="true" tabindex="-1"></a>    zuordnung <span class="op">=</span> {</span>
+<span id="cb7-103"><a href="#cb7-103" aria-hidden="true" tabindex="-1"></a>        <span class="st">&quot;Optimal&quot;</span>: SolverStatus.OPTIMAL,</span>
+<span id="cb7-104"><a href="#cb7-104" aria-hidden="true" tabindex="-1"></a>        <span class="st">&quot;Time limit reached&quot;</span>: SolverStatus.ZULAESSIG,   <span class="co"># meist mit Loesung</span></span>
+<span id="cb7-105"><a href="#cb7-105" aria-hidden="true" tabindex="-1"></a>        <span class="st">&quot;Solution limit reached&quot;</span>: SolverStatus.ZULAESSIG,</span>
+<span id="cb7-106"><a href="#cb7-106" aria-hidden="true" tabindex="-1"></a>        <span class="st">&quot;Infeasible&quot;</span>: SolverStatus.UNZULAESSIG,</span>
+<span id="cb7-107"><a href="#cb7-107" aria-hidden="true" tabindex="-1"></a>        <span class="st">&quot;Unbounded&quot;</span>: SolverStatus.UNBESCHRAENKT,</span>
+<span id="cb7-108"><a href="#cb7-108" aria-hidden="true" tabindex="-1"></a>        <span class="st">&quot;Primal infeasible or unbounded&quot;</span>: SolverStatus.UNZULAESSIG,</span>
+<span id="cb7-109"><a href="#cb7-109" aria-hidden="true" tabindex="-1"></a>        <span class="st">&quot;Model error&quot;</span>: SolverStatus.FEHLERHAFT,</span>
+<span id="cb7-110"><a href="#cb7-110" aria-hidden="true" tabindex="-1"></a>    }</span>
+<span id="cb7-111"><a href="#cb7-111" aria-hidden="true" tabindex="-1"></a>    <span class="cf">return</span> zuordnung.get(statustext, SolverStatus.UNBEKANNT)</span>
+<span id="cb7-112"><a href="#cb7-112" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb7-113"><a href="#cb7-113" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb7-114"><a href="#cb7-114" aria-hidden="true" tabindex="-1"></a><span class="kw">def</span> status_von_scipy(ergebnis: Any) <span class="op">-&gt;</span> SolverStatus:</span>
+<span id="cb7-115"><a href="#cb7-115" aria-hidden="true" tabindex="-1"></a>    <span class="co">&quot;&quot;&quot;scipy.optimize.linprog und milp liefern ein Ergebnisobjekt mit .status.&quot;&quot;&quot;</span></span>
+<span id="cb7-116"><a href="#cb7-116" aria-hidden="true" tabindex="-1"></a>    zuordnung <span class="op">=</span> {</span>
+<span id="cb7-117"><a href="#cb7-117" aria-hidden="true" tabindex="-1"></a>        <span class="dv">0</span>: SolverStatus.OPTIMAL,</span>
+<span id="cb7-118"><a href="#cb7-118" aria-hidden="true" tabindex="-1"></a>        <span class="dv">1</span>: SolverStatus.ZEITLIMIT,        <span class="co"># Iterations-/Zeitgrenze</span></span>
+<span id="cb7-119"><a href="#cb7-119" aria-hidden="true" tabindex="-1"></a>        <span class="dv">2</span>: SolverStatus.UNZULAESSIG,</span>
+<span id="cb7-120"><a href="#cb7-120" aria-hidden="true" tabindex="-1"></a>        <span class="dv">3</span>: SolverStatus.UNBESCHRAENKT,</span>
+<span id="cb7-121"><a href="#cb7-121" aria-hidden="true" tabindex="-1"></a>        <span class="dv">4</span>: SolverStatus.FEHLERHAFT,       <span class="co"># numerische Schwierigkeiten</span></span>
+<span id="cb7-122"><a href="#cb7-122" aria-hidden="true" tabindex="-1"></a>    }</span>
+<span id="cb7-123"><a href="#cb7-123" aria-hidden="true" tabindex="-1"></a>    <span class="cf">return</span> zuordnung.get(<span class="bu">int</span>(ergebnis.status), SolverStatus.UNBEKANNT)</span>
+<span id="cb7-124"><a href="#cb7-124" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb7-125"><a href="#cb7-125" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb7-126"><a href="#cb7-126" aria-hidden="true" tabindex="-1"></a><span class="kw">def</span> status_von_cvxpy(statustext: <span class="bu">str</span>) <span class="op">-&gt;</span> SolverStatus:</span>
+<span id="cb7-127"><a href="#cb7-127" aria-hidden="true" tabindex="-1"></a>    <span class="co">&quot;&quot;&quot;CVXPY - Statuszeichenketten wie &#39;optimal&#39; oder &#39;infeasible&#39;.&quot;&quot;&quot;</span></span>
+<span id="cb7-128"><a href="#cb7-128" aria-hidden="true" tabindex="-1"></a>    zuordnung <span class="op">=</span> {</span>
+<span id="cb7-129"><a href="#cb7-129" aria-hidden="true" tabindex="-1"></a>        <span class="st">&quot;optimal&quot;</span>: SolverStatus.OPTIMAL,</span>
+<span id="cb7-130"><a href="#cb7-130" aria-hidden="true" tabindex="-1"></a>        <span class="st">&quot;optimal_inaccurate&quot;</span>: SolverStatus.ZULAESSIG,</span>
+<span id="cb7-131"><a href="#cb7-131" aria-hidden="true" tabindex="-1"></a>        <span class="st">&quot;infeasible&quot;</span>: SolverStatus.UNZULAESSIG,</span>
+<span id="cb7-132"><a href="#cb7-132" aria-hidden="true" tabindex="-1"></a>        <span class="st">&quot;infeasible_inaccurate&quot;</span>: SolverStatus.UNZULAESSIG,</span>
+<span id="cb7-133"><a href="#cb7-133" aria-hidden="true" tabindex="-1"></a>        <span class="st">&quot;unbounded&quot;</span>: SolverStatus.UNBESCHRAENKT,</span>
+<span id="cb7-134"><a href="#cb7-134" aria-hidden="true" tabindex="-1"></a>        <span class="st">&quot;unbounded_inaccurate&quot;</span>: SolverStatus.UNBESCHRAENKT,</span>
+<span id="cb7-135"><a href="#cb7-135" aria-hidden="true" tabindex="-1"></a>    }</span>
+<span id="cb7-136"><a href="#cb7-136" aria-hidden="true" tabindex="-1"></a>    <span class="cf">return</span> zuordnung.get(statustext, SolverStatus.UNBEKANNT)</span>
+<span id="cb7-137"><a href="#cb7-137" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb7-138"><a href="#cb7-138" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb7-139"><a href="#cb7-139" aria-hidden="true" tabindex="-1"></a><span class="co"># --- 2. Die Loesung als solverunabhaengiges Datenobjekt ----------------------</span></span>
+<span id="cb7-140"><a href="#cb7-140" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb7-141"><a href="#cb7-141" aria-hidden="true" tabindex="-1"></a><span class="kw">class</span> Loesung(BaseModel):</span>
+<span id="cb7-142"><a href="#cb7-142" aria-hidden="true" tabindex="-1"></a>    <span class="co">&quot;&quot;&quot;Das Ergebnis eines Solverlaufs, so wie es weiterverarbeitet wird.</span></span>
+<span id="cb7-143"><a href="#cb7-143" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb7-144"><a href="#cb7-144" aria-hidden="true" tabindex="-1"></a><span class="co">    Bewusst OHNE Referenz auf Solver, Modell oder Variablen: Ein Bericht, ein</span></span>
+<span id="cb7-145"><a href="#cb7-145" aria-hidden="true" tabindex="-1"></a><span class="co">    Test oder eine Weiterverarbeitung soll nicht wissen muessen, womit</span></span>
+<span id="cb7-146"><a href="#cb7-146" aria-hidden="true" tabindex="-1"></a><span class="co">    gerechnet wurde.</span></span>
+<span id="cb7-147"><a href="#cb7-147" aria-hidden="true" tabindex="-1"></a><span class="co">    &quot;&quot;&quot;</span></span>
+<span id="cb7-148"><a href="#cb7-148" aria-hidden="true" tabindex="-1"></a>    status: SolverStatus</span>
+<span id="cb7-149"><a href="#cb7-149" aria-hidden="true" tabindex="-1"></a>    werte: <span class="bu">dict</span>[<span class="bu">str</span>, <span class="bu">float</span>] <span class="op">=</span> Field(default_factory<span class="op">=</span><span class="bu">dict</span>)</span>
+<span id="cb7-150"><a href="#cb7-150" aria-hidden="true" tabindex="-1"></a>    zielwert: <span class="bu">float</span> <span class="op">|</span> <span class="va">None</span> <span class="op">=</span> <span class="va">None</span></span>
+<span id="cb7-151"><a href="#cb7-151" aria-hidden="true" tabindex="-1"></a>    schranke: <span class="bu">float</span> <span class="op">|</span> <span class="va">None</span> <span class="op">=</span> <span class="va">None</span></span>
+<span id="cb7-152"><a href="#cb7-152" aria-hidden="true" tabindex="-1"></a>    laufzeit: <span class="bu">float</span> <span class="op">|</span> <span class="va">None</span> <span class="op">=</span> <span class="va">None</span></span>
+<span id="cb7-153"><a href="#cb7-153" aria-hidden="true" tabindex="-1"></a>    <span class="co"># Schattenpreise je Nebenbedingung, sofern der Solver sie liefert</span></span>
+<span id="cb7-154"><a href="#cb7-154" aria-hidden="true" tabindex="-1"></a>    <span class="co"># (nur bei kontinuierlichen Problemen, siehe Kapitel LP). Auch das ist</span></span>
+<span id="cb7-155"><a href="#cb7-155" aria-hidden="true" tabindex="-1"></a>    <span class="co"># ein solverunabhaengiger Begriff und gehoert deshalb hierher.</span></span>
+<span id="cb7-156"><a href="#cb7-156" aria-hidden="true" tabindex="-1"></a>    schattenpreise: <span class="bu">dict</span>[<span class="bu">str</span>, <span class="bu">float</span>] <span class="op">=</span> Field(default_factory<span class="op">=</span><span class="bu">dict</span>)</span>
+<span id="cb7-157"><a href="#cb7-157" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb7-158"><a href="#cb7-158" aria-hidden="true" tabindex="-1"></a>    <span class="at">@property</span></span>
+<span id="cb7-159"><a href="#cb7-159" aria-hidden="true" tabindex="-1"></a>    <span class="kw">def</span> gap(<span class="va">self</span>) <span class="op">-&gt;</span> <span class="bu">float</span> <span class="op">|</span> <span class="va">None</span>:</span>
+<span id="cb7-160"><a href="#cb7-160" aria-hidden="true" tabindex="-1"></a>        <span class="co">&quot;&quot;&quot;Relativer Abstand zwischen gefundener Loesung und bewiesener Schranke.</span></span>
+<span id="cb7-161"><a href="#cb7-161" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb7-162"><a href="#cb7-162" aria-hidden="true" tabindex="-1"></a><span class="co">        Das ist die Zahl fuer den Bericht: keine Schaetzung, sondern eine</span></span>
+<span id="cb7-163"><a href="#cb7-163" aria-hidden="true" tabindex="-1"></a><span class="co">        Zusage - schlechter als das kann die Loesung nicht sein.</span></span>
+<span id="cb7-164"><a href="#cb7-164" aria-hidden="true" tabindex="-1"></a><span class="co">        &quot;&quot;&quot;</span></span>
+<span id="cb7-165"><a href="#cb7-165" aria-hidden="true" tabindex="-1"></a>        <span class="cf">if</span> <span class="va">self</span>.zielwert <span class="kw">is</span> <span class="va">None</span> <span class="kw">or</span> <span class="va">self</span>.schranke <span class="kw">is</span> <span class="va">None</span>:</span>
+<span id="cb7-166"><a href="#cb7-166" aria-hidden="true" tabindex="-1"></a>            <span class="cf">return</span> <span class="va">None</span></span>
+<span id="cb7-167"><a href="#cb7-167" aria-hidden="true" tabindex="-1"></a>        nenner <span class="op">=</span> <span class="bu">max</span>(<span class="bu">abs</span>(<span class="va">self</span>.zielwert), <span class="fl">1e-9</span>)</span>
+<span id="cb7-168"><a href="#cb7-168" aria-hidden="true" tabindex="-1"></a>        <span class="cf">return</span> <span class="bu">abs</span>(<span class="va">self</span>.zielwert <span class="op">-</span> <span class="va">self</span>.schranke) <span class="op">/</span> nenner</span>
+<span id="cb7-169"><a href="#cb7-169" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb7-170"><a href="#cb7-170" aria-hidden="true" tabindex="-1"></a>    <span class="kw">def</span> als_bericht(<span class="va">self</span>) <span class="op">-&gt;</span> <span class="bu">str</span>:</span>
+<span id="cb7-171"><a href="#cb7-171" aria-hidden="true" tabindex="-1"></a>        <span class="co">&quot;&quot;&quot;Eine Zeile fuers Betriebsprotokoll - siehe Betriebsueberwachung.py.&quot;&quot;&quot;</span></span>
+<span id="cb7-172"><a href="#cb7-172" aria-hidden="true" tabindex="-1"></a>        teile <span class="op">=</span> [<span class="ss">f&quot;Status: </span><span class="sc">{</span><span class="va">self</span><span class="sc">.</span>status<span class="sc">.</span>value<span class="sc">}</span><span class="ss">&quot;</span>]</span>
+<span id="cb7-173"><a href="#cb7-173" aria-hidden="true" tabindex="-1"></a>        <span class="cf">if</span> <span class="va">self</span>.zielwert <span class="kw">is</span> <span class="kw">not</span> <span class="va">None</span>:</span>
+<span id="cb7-174"><a href="#cb7-174" aria-hidden="true" tabindex="-1"></a>            teile.append(<span class="ss">f&quot;Zielwert: </span><span class="sc">{</span><span class="va">self</span><span class="sc">.</span>zielwert<span class="sc">:,.2f}</span><span class="ss">&quot;</span>)</span>
+<span id="cb7-175"><a href="#cb7-175" aria-hidden="true" tabindex="-1"></a>        <span class="cf">if</span> <span class="va">self</span>.gap <span class="kw">is</span> <span class="kw">not</span> <span class="va">None</span>:</span>
+<span id="cb7-176"><a href="#cb7-176" aria-hidden="true" tabindex="-1"></a>            teile.append(<span class="ss">f&quot;Gap: </span><span class="sc">{</span><span class="va">self</span><span class="sc">.</span>gap<span class="sc">:.2%}</span><span class="ss">&quot;</span>)</span>
+<span id="cb7-177"><a href="#cb7-177" aria-hidden="true" tabindex="-1"></a>        <span class="cf">if</span> <span class="va">self</span>.laufzeit <span class="kw">is</span> <span class="kw">not</span> <span class="va">None</span>:</span>
+<span id="cb7-178"><a href="#cb7-178" aria-hidden="true" tabindex="-1"></a>            teile.append(<span class="ss">f&quot;Zeit: </span><span class="sc">{</span><span class="va">self</span><span class="sc">.</span>laufzeit<span class="sc">:.2f}</span><span class="ss">s&quot;</span>)</span>
+<span id="cb7-179"><a href="#cb7-179" aria-hidden="true" tabindex="-1"></a>        <span class="cf">return</span> <span class="st">&quot; | &quot;</span>.join(teile)</span>
+<span id="cb7-180"><a href="#cb7-180" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb7-181"><a href="#cb7-181" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb7-182"><a href="#cb7-182" aria-hidden="true" tabindex="-1"></a><span class="co"># --- 3. Domaenenmodell: die Fakten, bevor ein Solver sie sieht ---------------</span></span>
+<span id="cb7-183"><a href="#cb7-183" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb7-184"><a href="#cb7-184" aria-hidden="true" tabindex="-1"></a><span class="kw">class</span> Produkt(BaseModel):</span>
+<span id="cb7-185"><a href="#cb7-185" aria-hidden="true" tabindex="-1"></a>    <span class="co">&quot;&quot;&quot;Ein Produkt mit Deckungsbeitrag und Ressourcenverbrauch.&quot;&quot;&quot;</span></span>
+<span id="cb7-186"><a href="#cb7-186" aria-hidden="true" tabindex="-1"></a>    name: <span class="bu">str</span> <span class="op">=</span> Field(min_length<span class="op">=</span><span class="dv">1</span>)</span>
+<span id="cb7-187"><a href="#cb7-187" aria-hidden="true" tabindex="-1"></a>    deckungsbeitrag: <span class="bu">float</span></span>
+<span id="cb7-188"><a href="#cb7-188" aria-hidden="true" tabindex="-1"></a>    verbrauch: <span class="bu">dict</span>[<span class="bu">str</span>, NichtNegativ]</span>
+<span id="cb7-189"><a href="#cb7-189" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb7-190"><a href="#cb7-190" aria-hidden="true" tabindex="-1"></a>    model_config <span class="op">=</span> {<span class="st">&quot;frozen&quot;</span>: <span class="va">True</span>}      <span class="co"># Stammdaten aendern sich nicht im Lauf</span></span>
+<span id="cb7-191"><a href="#cb7-191" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb7-192"><a href="#cb7-192" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb7-193"><a href="#cb7-193" aria-hidden="true" tabindex="-1"></a><span class="kw">class</span> Produktionsproblem(BaseModel):</span>
+<span id="cb7-194"><a href="#cb7-194" aria-hidden="true" tabindex="-1"></a>    <span class="co">&quot;&quot;&quot;Produktionsprogrammplanung - das Modell aus Kapitel Einfuehrung.</span></span>
+<span id="cb7-195"><a href="#cb7-195" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb7-196"><a href="#cb7-196" aria-hidden="true" tabindex="-1"></a><span class="co">    Die Pruefungen stehen hier und nicht im Solvercode. Damit gelten sie</span></span>
+<span id="cb7-197"><a href="#cb7-197" aria-hidden="true" tabindex="-1"></a><span class="co">    unabhaengig davon, mit welcher Bibliothek spaeter gerechnet wird - und sie</span></span>
+<span id="cb7-198"><a href="#cb7-198" aria-hidden="true" tabindex="-1"></a><span class="co">    schlagen beim EINLESEN zu, wo der Fehler noch zuzuordnen ist.</span></span>
+<span id="cb7-199"><a href="#cb7-199" aria-hidden="true" tabindex="-1"></a><span class="co">    &quot;&quot;&quot;</span></span>
+<span id="cb7-200"><a href="#cb7-200" aria-hidden="true" tabindex="-1"></a>    produkte: <span class="bu">list</span>[Produkt] <span class="op">=</span> Field(min_length<span class="op">=</span><span class="dv">1</span>)</span>
+<span id="cb7-201"><a href="#cb7-201" aria-hidden="true" tabindex="-1"></a>    kapazitaeten: <span class="bu">dict</span>[<span class="bu">str</span>, PositiveZahl]</span>
+<span id="cb7-202"><a href="#cb7-202" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb7-203"><a href="#cb7-203" aria-hidden="true" tabindex="-1"></a>    <span class="at">@model_validator</span>(mode<span class="op">=</span><span class="st">&quot;after&quot;</span>)</span>
+<span id="cb7-204"><a href="#cb7-204" aria-hidden="true" tabindex="-1"></a>    <span class="kw">def</span> pruefe_ressourcen(<span class="va">self</span>) <span class="op">-&gt;</span> <span class="st">&quot;Produktionsproblem&quot;</span>:</span>
+<span id="cb7-205"><a href="#cb7-205" aria-hidden="true" tabindex="-1"></a>        namen <span class="op">=</span> [p.name <span class="cf">for</span> p <span class="kw">in</span> <span class="va">self</span>.produkte]</span>
+<span id="cb7-206"><a href="#cb7-206" aria-hidden="true" tabindex="-1"></a>        <span class="cf">if</span> <span class="bu">len</span>(<span class="bu">set</span>(namen)) <span class="op">!=</span> <span class="bu">len</span>(namen):</span>
+<span id="cb7-207"><a href="#cb7-207" aria-hidden="true" tabindex="-1"></a>            doppelt <span class="op">=</span> <span class="bu">sorted</span>({n <span class="cf">for</span> n <span class="kw">in</span> namen <span class="cf">if</span> namen.count(n) <span class="op">&gt;</span> <span class="dv">1</span>})</span>
+<span id="cb7-208"><a href="#cb7-208" aria-hidden="true" tabindex="-1"></a>            <span class="cf">raise</span> <span class="pp">ValueError</span>(<span class="ss">f&quot;Produktnamen kommen mehrfach vor: </span><span class="sc">{</span>doppelt<span class="sc">}</span><span class="ss">&quot;</span>)</span>
+<span id="cb7-209"><a href="#cb7-209" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb7-210"><a href="#cb7-210" aria-hidden="true" tabindex="-1"></a>        <span class="cf">for</span> produkt <span class="kw">in</span> <span class="va">self</span>.produkte:</span>
+<span id="cb7-211"><a href="#cb7-211" aria-hidden="true" tabindex="-1"></a>            unbekannt <span class="op">=</span> <span class="bu">set</span>(produkt.verbrauch) <span class="op">-</span> <span class="bu">set</span>(<span class="va">self</span>.kapazitaeten)</span>
+<span id="cb7-212"><a href="#cb7-212" aria-hidden="true" tabindex="-1"></a>            <span class="cf">if</span> unbekannt:</span>
+<span id="cb7-213"><a href="#cb7-213" aria-hidden="true" tabindex="-1"></a>                <span class="cf">raise</span> <span class="pp">ValueError</span>(</span>
+<span id="cb7-214"><a href="#cb7-214" aria-hidden="true" tabindex="-1"></a>                    <span class="ss">f&quot;Produkt &#39;</span><span class="sc">{</span>produkt<span class="sc">.</span>name<span class="sc">}</span><span class="ss">&#39; verbraucht Ressourcen ohne &quot;</span></span>
+<span id="cb7-215"><a href="#cb7-215" aria-hidden="true" tabindex="-1"></a>                    <span class="ss">f&quot;Kapazitaetsangabe: </span><span class="sc">{</span><span class="bu">sorted</span>(unbekannt)<span class="sc">}</span><span class="ss">&quot;</span>)</span>
+<span id="cb7-216"><a href="#cb7-216" aria-hidden="true" tabindex="-1"></a>        <span class="cf">return</span> <span class="va">self</span></span>
+<span id="cb7-217"><a href="#cb7-217" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb7-218"><a href="#cb7-218" aria-hidden="true" tabindex="-1"></a>    <span class="at">@property</span></span>
+<span id="cb7-219"><a href="#cb7-219" aria-hidden="true" tabindex="-1"></a>    <span class="kw">def</span> ressourcen(<span class="va">self</span>) <span class="op">-&gt;</span> <span class="bu">list</span>[<span class="bu">str</span>]:</span>
+<span id="cb7-220"><a href="#cb7-220" aria-hidden="true" tabindex="-1"></a>        <span class="co">&quot;&quot;&quot;Feste Reihenfolge - siehe die Spaltenfalle in Kapitel Finanzdaten.&quot;&quot;&quot;</span></span>
+<span id="cb7-221"><a href="#cb7-221" aria-hidden="true" tabindex="-1"></a>        <span class="cf">return</span> <span class="bu">sorted</span>(<span class="va">self</span>.kapazitaeten)</span>
+<span id="cb7-222"><a href="#cb7-222" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb7-223"><a href="#cb7-223" aria-hidden="true" tabindex="-1"></a>    <span class="kw">def</span> verbrauchsmatrix(<span class="va">self</span>) <span class="op">-&gt;</span> np.ndarray:</span>
+<span id="cb7-224"><a href="#cb7-224" aria-hidden="true" tabindex="-1"></a>        <span class="co">&quot;&quot;&quot;Zeilen = Ressourcen, Spalten = Produkte (Matrixform, Kapitel Fundament).&quot;&quot;&quot;</span></span>
+<span id="cb7-225"><a href="#cb7-225" aria-hidden="true" tabindex="-1"></a>        <span class="cf">return</span> np.array([[p.verbrauch.get(r, <span class="fl">0.0</span>) <span class="cf">for</span> p <span class="kw">in</span> <span class="va">self</span>.produkte]</span>
+<span id="cb7-226"><a href="#cb7-226" aria-hidden="true" tabindex="-1"></a>                         <span class="cf">for</span> r <span class="kw">in</span> <span class="va">self</span>.ressourcen])</span>
+<span id="cb7-227"><a href="#cb7-227" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb7-228"><a href="#cb7-228" aria-hidden="true" tabindex="-1"></a>    <span class="kw">def</span> kapazitaetsvektor(<span class="va">self</span>) <span class="op">-&gt;</span> np.ndarray:</span>
+<span id="cb7-229"><a href="#cb7-229" aria-hidden="true" tabindex="-1"></a>        <span class="cf">return</span> np.array([<span class="va">self</span>.kapazitaeten[r] <span class="cf">for</span> r <span class="kw">in</span> <span class="va">self</span>.ressourcen])</span>
+<span id="cb7-230"><a href="#cb7-230" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb7-231"><a href="#cb7-231" aria-hidden="true" tabindex="-1"></a>    <span class="kw">def</span> deckungsbeitragsvektor(<span class="va">self</span>) <span class="op">-&gt;</span> np.ndarray:</span>
+<span id="cb7-232"><a href="#cb7-232" aria-hidden="true" tabindex="-1"></a>        <span class="cf">return</span> np.array([p.deckungsbeitrag <span class="cf">for</span> p <span class="kw">in</span> <span class="va">self</span>.produkte])</span>
+<span id="cb7-233"><a href="#cb7-233" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb7-234"><a href="#cb7-234" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb7-235"><a href="#cb7-235" aria-hidden="true" tabindex="-1"></a><span class="co"># --- 4. Abnahmepruefung: Loesung gegen Anforderung, ohne Solver --------------</span></span>
+<span id="cb7-236"><a href="#cb7-236" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb7-237"><a href="#cb7-237" aria-hidden="true" tabindex="-1"></a><span class="kw">def</span> pruefe_loesung(problem: Produktionsproblem, loesung: Loesung,</span>
+<span id="cb7-238"><a href="#cb7-238" aria-hidden="true" tabindex="-1"></a>                   ganzzahlig: Sequence[<span class="bu">str</span>] <span class="op">=</span> (),</span>
+<span id="cb7-239"><a href="#cb7-239" aria-hidden="true" tabindex="-1"></a>                   toleranz: <span class="bu">float</span> <span class="op">=</span> <span class="fl">1e-6</span>) <span class="op">-&gt;</span> <span class="bu">list</span>[<span class="bu">str</span>]:</span>
+<span id="cb7-240"><a href="#cb7-240" aria-hidden="true" tabindex="-1"></a>    <span class="co">&quot;&quot;&quot;Prueft eine Loesung gegen die Anforderungen - OHNE den Solver zu fragen.</span></span>
+<span id="cb7-241"><a href="#cb7-241" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb7-242"><a href="#cb7-242" aria-hidden="true" tabindex="-1"></a><span class="co">    Diese Funktion darf ausdruecklich KEIN Solverobjekt und keine</span></span>
+<span id="cb7-243"><a href="#cb7-243" aria-hidden="true" tabindex="-1"></a><span class="co">    Modellvariable benutzen. Eine Pruefung aus denselben Bausteinen wie das</span></span>
+<span id="cb7-244"><a href="#cb7-244" aria-hidden="true" tabindex="-1"></a><span class="co">    Modell prueft das Modell gegen sich selbst und findet nichts (siehe die</span></span>
+<span id="cb7-245"><a href="#cb7-245" aria-hidden="true" tabindex="-1"></a><span class="co">    Denkfehler in den Kapiteln Graphen und MILP).</span></span>
+<span id="cb7-246"><a href="#cb7-246" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb7-247"><a href="#cb7-247" aria-hidden="true" tabindex="-1"></a><span class="co">    Liefert eine Liste von Beanstandungen; leer heisst bestanden.</span></span>
+<span id="cb7-248"><a href="#cb7-248" aria-hidden="true" tabindex="-1"></a><span class="co">    &quot;&quot;&quot;</span></span>
+<span id="cb7-249"><a href="#cb7-249" aria-hidden="true" tabindex="-1"></a>    beanstandungen: <span class="bu">list</span>[<span class="bu">str</span>] <span class="op">=</span> []</span>
+<span id="cb7-250"><a href="#cb7-250" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb7-251"><a href="#cb7-251" aria-hidden="true" tabindex="-1"></a>    <span class="cf">if</span> <span class="kw">not</span> loesung.status.brauchbar:</span>
+<span id="cb7-252"><a href="#cb7-252" aria-hidden="true" tabindex="-1"></a>        <span class="cf">return</span> [<span class="ss">f&quot;Kein verwertbares Ergebnis (Status: </span><span class="sc">{</span>loesung<span class="sc">.</span>status<span class="sc">.</span>value<span class="sc">}</span><span class="ss">)&quot;</span>]</span>
+<span id="cb7-253"><a href="#cb7-253" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb7-254"><a href="#cb7-254" aria-hidden="true" tabindex="-1"></a>    fehlend <span class="op">=</span> [p.name <span class="cf">for</span> p <span class="kw">in</span> problem.produkte <span class="cf">if</span> p.name <span class="kw">not</span> <span class="kw">in</span> loesung.werte]</span>
+<span id="cb7-255"><a href="#cb7-255" aria-hidden="true" tabindex="-1"></a>    <span class="cf">if</span> fehlend:</span>
+<span id="cb7-256"><a href="#cb7-256" aria-hidden="true" tabindex="-1"></a>        <span class="cf">return</span> [<span class="ss">f&quot;Loesung enthaelt keine Werte fuer: </span><span class="sc">{</span>fehlend<span class="sc">}</span><span class="ss">&quot;</span>]</span>
+<span id="cb7-257"><a href="#cb7-257" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb7-258"><a href="#cb7-258" aria-hidden="true" tabindex="-1"></a>    mengen <span class="op">=</span> np.array([loesung.werte[p.name] <span class="cf">for</span> p <span class="kw">in</span> problem.produkte])</span>
+<span id="cb7-259"><a href="#cb7-259" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb7-260"><a href="#cb7-260" aria-hidden="true" tabindex="-1"></a>    <span class="cf">if</span> (mengen <span class="op">&lt;</span> <span class="op">-</span>toleranz).<span class="bu">any</span>():</span>
+<span id="cb7-261"><a href="#cb7-261" aria-hidden="true" tabindex="-1"></a>        negativ <span class="op">=</span> [p.name <span class="cf">for</span> p, m <span class="kw">in</span> <span class="bu">zip</span>(problem.produkte, mengen) <span class="cf">if</span> m <span class="op">&lt;</span> <span class="op">-</span>toleranz]</span>
+<span id="cb7-262"><a href="#cb7-262" aria-hidden="true" tabindex="-1"></a>        beanstandungen.append(<span class="ss">f&quot;negative Mengen bei: </span><span class="sc">{</span>negativ<span class="sc">}</span><span class="ss">&quot;</span>)</span>
+<span id="cb7-263"><a href="#cb7-263" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb7-264"><a href="#cb7-264" aria-hidden="true" tabindex="-1"></a>    verbrauch <span class="op">=</span> problem.verbrauchsmatrix() <span class="op">@</span> mengen</span>
+<span id="cb7-265"><a href="#cb7-265" aria-hidden="true" tabindex="-1"></a>    <span class="cf">for</span> ressource, ist, grenze <span class="kw">in</span> <span class="bu">zip</span>(problem.ressourcen, verbrauch,</span>
+<span id="cb7-266"><a href="#cb7-266" aria-hidden="true" tabindex="-1"></a>                                      problem.kapazitaetsvektor()):</span>
+<span id="cb7-267"><a href="#cb7-267" aria-hidden="true" tabindex="-1"></a>        <span class="cf">if</span> ist <span class="op">&gt;</span> grenze <span class="op">+</span> toleranz:</span>
+<span id="cb7-268"><a href="#cb7-268" aria-hidden="true" tabindex="-1"></a>            beanstandungen.append(</span>
+<span id="cb7-269"><a href="#cb7-269" aria-hidden="true" tabindex="-1"></a>                <span class="ss">f&quot;</span><span class="sc">{</span>ressource<span class="sc">}</span><span class="ss">: Verbrauch </span><span class="sc">{</span>ist<span class="sc">:,.3f}</span><span class="ss"> ueber Kapazitaet </span><span class="sc">{</span>grenze<span class="sc">:,.3f}</span><span class="ss">&quot;</span>)</span>
+<span id="cb7-270"><a href="#cb7-270" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb7-271"><a href="#cb7-271" aria-hidden="true" tabindex="-1"></a>    <span class="cf">for</span> name <span class="kw">in</span> ganzzahlig:</span>
+<span id="cb7-272"><a href="#cb7-272" aria-hidden="true" tabindex="-1"></a>        wert <span class="op">=</span> loesung.werte[name]</span>
+<span id="cb7-273"><a href="#cb7-273" aria-hidden="true" tabindex="-1"></a>        <span class="cf">if</span> <span class="bu">abs</span>(wert <span class="op">-</span> <span class="bu">round</span>(wert)) <span class="op">&gt;</span> toleranz:</span>
+<span id="cb7-274"><a href="#cb7-274" aria-hidden="true" tabindex="-1"></a>            beanstandungen.append(<span class="ss">f&quot;&#39;</span><span class="sc">{</span>name<span class="sc">}</span><span class="ss">&#39; = </span><span class="sc">{</span>wert<span class="sc">!r}</span><span class="ss"> ist nicht ganzzahlig&quot;</span>)</span>
+<span id="cb7-275"><a href="#cb7-275" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb7-276"><a href="#cb7-276" aria-hidden="true" tabindex="-1"></a>    <span class="cf">if</span> loesung.zielwert <span class="kw">is</span> <span class="kw">not</span> <span class="va">None</span>:</span>
+<span id="cb7-277"><a href="#cb7-277" aria-hidden="true" tabindex="-1"></a>        nachgerechnet <span class="op">=</span> <span class="bu">float</span>(problem.deckungsbeitragsvektor() <span class="op">@</span> mengen)</span>
+<span id="cb7-278"><a href="#cb7-278" aria-hidden="true" tabindex="-1"></a>        <span class="cf">if</span> <span class="bu">abs</span>(nachgerechnet <span class="op">-</span> loesung.zielwert) <span class="op">&gt;</span> toleranz <span class="op">*</span> <span class="bu">max</span>(<span class="fl">1.0</span>, <span class="bu">abs</span>(nachgerechnet)):</span>
+<span id="cb7-279"><a href="#cb7-279" aria-hidden="true" tabindex="-1"></a>            beanstandungen.append(</span>
+<span id="cb7-280"><a href="#cb7-280" aria-hidden="true" tabindex="-1"></a>                <span class="ss">f&quot;Zielwert </span><span class="sc">{</span>loesung<span class="sc">.</span>zielwert<span class="sc">:,.4f}</span><span class="ss"> passt nicht zu den Mengen &quot;</span></span>
+<span id="cb7-281"><a href="#cb7-281" aria-hidden="true" tabindex="-1"></a>                <span class="ss">f&quot;(nachgerechnet </span><span class="sc">{</span>nachgerechnet<span class="sc">:,.4f}</span><span class="ss">)&quot;</span>)</span>
+<span id="cb7-282"><a href="#cb7-282" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb7-283"><a href="#cb7-283" aria-hidden="true" tabindex="-1"></a>    <span class="cf">return</span> beanstandungen</span>
+<span id="cb7-284"><a href="#cb7-284" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb7-285"><a href="#cb7-285" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb7-286"><a href="#cb7-286" aria-hidden="true" tabindex="-1"></a><span class="co"># --- 5. Ein Modellbauer je Solver - austauschbar ----------------------------</span></span>
+<span id="cb7-287"><a href="#cb7-287" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb7-288"><a href="#cb7-288" aria-hidden="true" tabindex="-1"></a><span class="kw">def</span> loese_mit_glop(problem: Produktionsproblem) <span class="op">-&gt;</span> Loesung:</span>
+<span id="cb7-289"><a href="#cb7-289" aria-hidden="true" tabindex="-1"></a>    <span class="co">&quot;&quot;&quot;Modellbauer fuer OR-Tools GLOP (kontinuierlich).&quot;&quot;&quot;</span></span>
+<span id="cb7-290"><a href="#cb7-290" aria-hidden="true" tabindex="-1"></a>    <span class="im">import</span> time</span>
+<span id="cb7-291"><a href="#cb7-291" aria-hidden="true" tabindex="-1"></a>    <span class="im">from</span> ortools.linear_solver <span class="im">import</span> pywraplp</span>
+<span id="cb7-292"><a href="#cb7-292" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb7-293"><a href="#cb7-293" aria-hidden="true" tabindex="-1"></a>    solver <span class="op">=</span> pywraplp.Solver.CreateSolver(<span class="st">&quot;GLOP&quot;</span>)</span>
+<span id="cb7-294"><a href="#cb7-294" aria-hidden="true" tabindex="-1"></a>    menge <span class="op">=</span> {p.name: solver.NumVar(<span class="dv">0</span>, solver.infinity(), p.name)</span>
+<span id="cb7-295"><a href="#cb7-295" aria-hidden="true" tabindex="-1"></a>             <span class="cf">for</span> p <span class="kw">in</span> problem.produkte}</span>
+<span id="cb7-296"><a href="#cb7-296" aria-hidden="true" tabindex="-1"></a>    <span class="co"># Die Nebenbedingung wird gemerkt - ohne die Referenz gibt es spaeter</span></span>
+<span id="cb7-297"><a href="#cb7-297" aria-hidden="true" tabindex="-1"></a>    <span class="co"># keinen Schattenpreis (siehe Kapitel LP).</span></span>
+<span id="cb7-298"><a href="#cb7-298" aria-hidden="true" tabindex="-1"></a>    bedingung <span class="op">=</span> {}</span>
+<span id="cb7-299"><a href="#cb7-299" aria-hidden="true" tabindex="-1"></a>    <span class="cf">for</span> ressource <span class="kw">in</span> problem.ressourcen:</span>
+<span id="cb7-300"><a href="#cb7-300" aria-hidden="true" tabindex="-1"></a>        bedingung[ressource] <span class="op">=</span> solver.Add(</span>
+<span id="cb7-301"><a href="#cb7-301" aria-hidden="true" tabindex="-1"></a>            <span class="bu">sum</span>(menge[p.name] <span class="op">*</span> p.verbrauch.get(ressource, <span class="fl">0.0</span>)</span>
+<span id="cb7-302"><a href="#cb7-302" aria-hidden="true" tabindex="-1"></a>                <span class="cf">for</span> p <span class="kw">in</span> problem.produkte)</span>
+<span id="cb7-303"><a href="#cb7-303" aria-hidden="true" tabindex="-1"></a>            <span class="op">&lt;=</span> problem.kapazitaeten[ressource], name<span class="op">=</span>ressource)</span>
+<span id="cb7-304"><a href="#cb7-304" aria-hidden="true" tabindex="-1"></a>    solver.Maximize(<span class="bu">sum</span>(menge[p.name] <span class="op">*</span> p.deckungsbeitrag <span class="cf">for</span> p <span class="kw">in</span> problem.produkte))</span>
+<span id="cb7-305"><a href="#cb7-305" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb7-306"><a href="#cb7-306" aria-hidden="true" tabindex="-1"></a>    t0 <span class="op">=</span> time.perf_counter()</span>
+<span id="cb7-307"><a href="#cb7-307" aria-hidden="true" tabindex="-1"></a>    rohstatus <span class="op">=</span> solver.Solve()</span>
+<span id="cb7-308"><a href="#cb7-308" aria-hidden="true" tabindex="-1"></a>    laufzeit <span class="op">=</span> time.perf_counter() <span class="op">-</span> t0</span>
+<span id="cb7-309"><a href="#cb7-309" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb7-310"><a href="#cb7-310" aria-hidden="true" tabindex="-1"></a>    status <span class="op">=</span> status_von_pywraplp(rohstatus)</span>
+<span id="cb7-311"><a href="#cb7-311" aria-hidden="true" tabindex="-1"></a>    <span class="cf">if</span> <span class="kw">not</span> status.brauchbar:</span>
+<span id="cb7-312"><a href="#cb7-312" aria-hidden="true" tabindex="-1"></a>        <span class="cf">return</span> Loesung(status<span class="op">=</span>status, laufzeit<span class="op">=</span>laufzeit)</span>
+<span id="cb7-313"><a href="#cb7-313" aria-hidden="true" tabindex="-1"></a>    <span class="cf">return</span> Loesung(status<span class="op">=</span>status,</span>
+<span id="cb7-314"><a href="#cb7-314" aria-hidden="true" tabindex="-1"></a>                   werte<span class="op">=</span>{name: v.solution_value() <span class="cf">for</span> name, v <span class="kw">in</span> menge.items()},</span>
+<span id="cb7-315"><a href="#cb7-315" aria-hidden="true" tabindex="-1"></a>                   zielwert<span class="op">=</span>solver.Objective().Value(),</span>
+<span id="cb7-316"><a href="#cb7-316" aria-hidden="true" tabindex="-1"></a>                   schranke<span class="op">=</span>solver.Objective().Value(),</span>
+<span id="cb7-317"><a href="#cb7-317" aria-hidden="true" tabindex="-1"></a>                   schattenpreise<span class="op">=</span>{r: b.dual_value() <span class="cf">for</span> r, b <span class="kw">in</span> bedingung.items()},</span>
+<span id="cb7-318"><a href="#cb7-318" aria-hidden="true" tabindex="-1"></a>                   laufzeit<span class="op">=</span>laufzeit)</span>
+<span id="cb7-319"><a href="#cb7-319" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb7-320"><a href="#cb7-320" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb7-321"><a href="#cb7-321" aria-hidden="true" tabindex="-1"></a><span class="kw">def</span> loese_mit_scipy(problem: Produktionsproblem) <span class="op">-&gt;</span> Loesung:</span>
+<span id="cb7-322"><a href="#cb7-322" aria-hidden="true" tabindex="-1"></a>    <span class="co">&quot;&quot;&quot;Derselbe Fall mit scipy.optimize.linprog - anderer Solver, gleiche Loesung.</span></span>
+<span id="cb7-323"><a href="#cb7-323" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb7-324"><a href="#cb7-324" aria-hidden="true" tabindex="-1"></a><span class="co">    Beachten Sie, wie wenig hier steht: Die Daten kommen fertig geprueft aus</span></span>
+<span id="cb7-325"><a href="#cb7-325" aria-hidden="true" tabindex="-1"></a><span class="co">    dem Domaenenmodell, die Auswertung geht ans gemeinsame Loesung-Objekt.</span></span>
+<span id="cb7-326"><a href="#cb7-326" aria-hidden="true" tabindex="-1"></a><span class="co">    Genau das ist der Ertrag der Trennung.</span></span>
+<span id="cb7-327"><a href="#cb7-327" aria-hidden="true" tabindex="-1"></a><span class="co">    &quot;&quot;&quot;</span></span>
+<span id="cb7-328"><a href="#cb7-328" aria-hidden="true" tabindex="-1"></a>    <span class="im">import</span> time</span>
+<span id="cb7-329"><a href="#cb7-329" aria-hidden="true" tabindex="-1"></a>    <span class="im">from</span> scipy.optimize <span class="im">import</span> linprog</span>
+<span id="cb7-330"><a href="#cb7-330" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb7-331"><a href="#cb7-331" aria-hidden="true" tabindex="-1"></a>    t0 <span class="op">=</span> time.perf_counter()</span>
+<span id="cb7-332"><a href="#cb7-332" aria-hidden="true" tabindex="-1"></a>    ergebnis <span class="op">=</span> linprog(c<span class="op">=-</span>problem.deckungsbeitragsvektor(),      <span class="co"># linprog minimiert</span></span>
+<span id="cb7-333"><a href="#cb7-333" aria-hidden="true" tabindex="-1"></a>                       A_ub<span class="op">=</span>problem.verbrauchsmatrix(),</span>
+<span id="cb7-334"><a href="#cb7-334" aria-hidden="true" tabindex="-1"></a>                       b_ub<span class="op">=</span>problem.kapazitaetsvektor(),</span>
+<span id="cb7-335"><a href="#cb7-335" aria-hidden="true" tabindex="-1"></a>                       bounds<span class="op">=</span>(<span class="dv">0</span>, <span class="va">None</span>), method<span class="op">=</span><span class="st">&quot;highs&quot;</span>)</span>
+<span id="cb7-336"><a href="#cb7-336" aria-hidden="true" tabindex="-1"></a>    laufzeit <span class="op">=</span> time.perf_counter() <span class="op">-</span> t0</span>
+<span id="cb7-337"><a href="#cb7-337" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb7-338"><a href="#cb7-338" aria-hidden="true" tabindex="-1"></a>    status <span class="op">=</span> status_von_scipy(ergebnis)</span>
+<span id="cb7-339"><a href="#cb7-339" aria-hidden="true" tabindex="-1"></a>    <span class="cf">if</span> <span class="kw">not</span> status.brauchbar:</span>
+<span id="cb7-340"><a href="#cb7-340" aria-hidden="true" tabindex="-1"></a>        <span class="cf">return</span> Loesung(status<span class="op">=</span>status, laufzeit<span class="op">=</span>laufzeit)</span>
+<span id="cb7-341"><a href="#cb7-341" aria-hidden="true" tabindex="-1"></a>    <span class="co"># linprog rechnet minimierend mit negierten Kosten - die Dualwerte</span></span>
+<span id="cb7-342"><a href="#cb7-342" aria-hidden="true" tabindex="-1"></a>    <span class="co"># muessen entsprechend zurueckgedreht werden.</span></span>
+<span id="cb7-343"><a href="#cb7-343" aria-hidden="true" tabindex="-1"></a>    <span class="cf">return</span> Loesung(status<span class="op">=</span>status,</span>
+<span id="cb7-344"><a href="#cb7-344" aria-hidden="true" tabindex="-1"></a>                   werte<span class="op">=</span>{p.name: <span class="bu">float</span>(x)</span>
+<span id="cb7-345"><a href="#cb7-345" aria-hidden="true" tabindex="-1"></a>                          <span class="cf">for</span> p, x <span class="kw">in</span> <span class="bu">zip</span>(problem.produkte, ergebnis.x)},</span>
+<span id="cb7-346"><a href="#cb7-346" aria-hidden="true" tabindex="-1"></a>                   zielwert<span class="op">=</span><span class="bu">float</span>(<span class="op">-</span>ergebnis.fun),</span>
+<span id="cb7-347"><a href="#cb7-347" aria-hidden="true" tabindex="-1"></a>                   schranke<span class="op">=</span><span class="bu">float</span>(<span class="op">-</span>ergebnis.fun),</span>
+<span id="cb7-348"><a href="#cb7-348" aria-hidden="true" tabindex="-1"></a>                   schattenpreise<span class="op">=</span>{r: <span class="bu">float</span>(<span class="op">-</span>m) <span class="cf">for</span> r, m <span class="kw">in</span></span>
+<span id="cb7-349"><a href="#cb7-349" aria-hidden="true" tabindex="-1"></a>                                   <span class="bu">zip</span>(problem.ressourcen,</span>
+<span id="cb7-350"><a href="#cb7-350" aria-hidden="true" tabindex="-1"></a>                                       ergebnis.ineqlin.marginals)},</span>
+<span id="cb7-351"><a href="#cb7-351" aria-hidden="true" tabindex="-1"></a>                   laufzeit<span class="op">=</span>laufzeit)</span>
+<span id="cb7-352"><a href="#cb7-352" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb7-353"><a href="#cb7-353" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb7-354"><a href="#cb7-354" aria-hidden="true" tabindex="-1"></a><span class="co"># --- 6. Ein- und Ausgabe: Tabellen sind die Wirklichkeit ---------------------</span></span>
+<span id="cb7-355"><a href="#cb7-355" aria-hidden="true" tabindex="-1"></a><span class="co">#</span></span>
+<span id="cb7-356"><a href="#cb7-356" aria-hidden="true" tabindex="-1"></a><span class="co"># In den meisten Betrieben liegen die Zahlen in einer Tabellenkalkulation</span></span>
+<span id="cb7-357"><a href="#cb7-357" aria-hidden="true" tabindex="-1"></a><span class="co"># (Kapitel Einfuehrung). Diese beiden Funktionen sind die einzige Stelle im</span></span>
+<span id="cb7-358"><a href="#cb7-358" aria-hidden="true" tabindex="-1"></a><span class="co"># Modul, die das weiss - alles andere arbeitet mit dem Domaenenmodell.</span></span>
+<span id="cb7-359"><a href="#cb7-359" aria-hidden="true" tabindex="-1"></a><span class="co">#</span></span>
+<span id="cb7-360"><a href="#cb7-360" aria-hidden="true" tabindex="-1"></a><span class="co"># pandas und openpyxl werden bewusst erst hier importiert: Wer or_kern nur</span></span>
+<span id="cb7-361"><a href="#cb7-361" aria-hidden="true" tabindex="-1"></a><span class="co"># fuer Statusauswertung und Pruefung benutzt, soll sie nicht installieren</span></span>
+<span id="cb7-362"><a href="#cb7-362" aria-hidden="true" tabindex="-1"></a><span class="co"># muessen.</span></span>
+<span id="cb7-363"><a href="#cb7-363" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb7-364"><a href="#cb7-364" aria-hidden="true" tabindex="-1"></a>STAMMSPALTEN <span class="op">=</span> (<span class="st">&quot;Produkt&quot;</span>, <span class="st">&quot;Deckungsbeitrag&quot;</span>)</span>
+<span id="cb7-365"><a href="#cb7-365" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb7-366"><a href="#cb7-366" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb7-367"><a href="#cb7-367" aria-hidden="true" tabindex="-1"></a><span class="kw">def</span> lade_produktionsproblem(pfad: <span class="bu">str</span>, blatt_produkte: <span class="bu">str</span> <span class="op">=</span> <span class="st">&quot;Produkte&quot;</span>,</span>
+<span id="cb7-368"><a href="#cb7-368" aria-hidden="true" tabindex="-1"></a>                            blatt_kapazitaeten: <span class="bu">str</span> <span class="op">=</span> <span class="st">&quot;Kapazitaeten&quot;</span></span>
+<span id="cb7-369"><a href="#cb7-369" aria-hidden="true" tabindex="-1"></a>                            ) <span class="op">-&gt;</span> Produktionsproblem:</span>
+<span id="cb7-370"><a href="#cb7-370" aria-hidden="true" tabindex="-1"></a>    <span class="co">&quot;&quot;&quot;Liest eine Excel-Mappe und liefert ein geprueftes Domaenenmodell.</span></span>
+<span id="cb7-371"><a href="#cb7-371" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb7-372"><a href="#cb7-372" aria-hidden="true" tabindex="-1"></a><span class="co">    Alle Spalten ausser &#39;Produkt&#39; und &#39;Deckungsbeitrag&#39; gelten als</span></span>
+<span id="cb7-373"><a href="#cb7-373" aria-hidden="true" tabindex="-1"></a><span class="co">    Verbrauchsspalten - eine neue Ressource ist damit eine neue SPALTE in der</span></span>
+<span id="cb7-374"><a href="#cb7-374" aria-hidden="true" tabindex="-1"></a><span class="co">    Mappe und erfordert keine Codeaenderung.</span></span>
+<span id="cb7-375"><a href="#cb7-375" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb7-376"><a href="#cb7-376" aria-hidden="true" tabindex="-1"></a><span class="co">    Die eigentliche Pruefung passiert nicht hier, sondern im Konstruktor von</span></span>
+<span id="cb7-377"><a href="#cb7-377" aria-hidden="true" tabindex="-1"></a><span class="co">    Produktionsproblem. Diese Funktion uebersetzt nur Tabelle in Objekt; was</span></span>
+<span id="cb7-378"><a href="#cb7-378" aria-hidden="true" tabindex="-1"></a><span class="co">    ein gueltiges Problem ist, steht an genau einer Stelle.</span></span>
+<span id="cb7-379"><a href="#cb7-379" aria-hidden="true" tabindex="-1"></a><span class="co">    &quot;&quot;&quot;</span></span>
+<span id="cb7-380"><a href="#cb7-380" aria-hidden="true" tabindex="-1"></a>    <span class="im">import</span> pandas <span class="im">as</span> pd</span>
+<span id="cb7-381"><a href="#cb7-381" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb7-382"><a href="#cb7-382" aria-hidden="true" tabindex="-1"></a>    produkte_tabelle <span class="op">=</span> pd.read_excel(pfad, sheet_name<span class="op">=</span>blatt_produkte)</span>
+<span id="cb7-383"><a href="#cb7-383" aria-hidden="true" tabindex="-1"></a>    kapazitaeten_tabelle <span class="op">=</span> pd.read_excel(pfad, sheet_name<span class="op">=</span>blatt_kapazitaeten)</span>
+<span id="cb7-384"><a href="#cb7-384" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb7-385"><a href="#cb7-385" aria-hidden="true" tabindex="-1"></a>    fehlende <span class="op">=</span> [s <span class="cf">for</span> s <span class="kw">in</span> STAMMSPALTEN <span class="cf">if</span> s <span class="kw">not</span> <span class="kw">in</span> produkte_tabelle.columns]</span>
+<span id="cb7-386"><a href="#cb7-386" aria-hidden="true" tabindex="-1"></a>    <span class="cf">if</span> fehlende:</span>
+<span id="cb7-387"><a href="#cb7-387" aria-hidden="true" tabindex="-1"></a>        <span class="cf">raise</span> <span class="pp">ValueError</span>(<span class="ss">f&quot;Blatt &#39;</span><span class="sc">{</span>blatt_produkte<span class="sc">}</span><span class="ss">&#39;: Spalten fehlen: </span><span class="sc">{</span>fehlende<span class="sc">}</span><span class="ss">&quot;</span>)</span>
+<span id="cb7-388"><a href="#cb7-388" aria-hidden="true" tabindex="-1"></a>    <span class="cf">if</span> produkte_tabelle.isna().<span class="bu">any</span>().<span class="bu">any</span>():</span>
+<span id="cb7-389"><a href="#cb7-389" aria-hidden="true" tabindex="-1"></a>        zeilen <span class="op">=</span> produkte_tabelle[produkte_tabelle.isna().<span class="bu">any</span>(axis<span class="op">=</span><span class="dv">1</span>)].index.tolist()</span>
+<span id="cb7-390"><a href="#cb7-390" aria-hidden="true" tabindex="-1"></a>        <span class="cf">raise</span> <span class="pp">ValueError</span>(<span class="ss">f&quot;Blatt &#39;</span><span class="sc">{</span>blatt_produkte<span class="sc">}</span><span class="ss">&#39;: leere Zellen in Zeile(n) </span><span class="sc">{</span>zeilen<span class="sc">}</span><span class="ss">&quot;</span>)</span>
+<span id="cb7-391"><a href="#cb7-391" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb7-392"><a href="#cb7-392" aria-hidden="true" tabindex="-1"></a>    ressourcen <span class="op">=</span> [s <span class="cf">for</span> s <span class="kw">in</span> produkte_tabelle.columns <span class="cf">if</span> s <span class="kw">not</span> <span class="kw">in</span> STAMMSPALTEN]</span>
+<span id="cb7-393"><a href="#cb7-393" aria-hidden="true" tabindex="-1"></a>    produkte <span class="op">=</span> [</span>
+<span id="cb7-394"><a href="#cb7-394" aria-hidden="true" tabindex="-1"></a>        Produkt(name<span class="op">=</span><span class="bu">str</span>(zeile.Produkt),</span>
+<span id="cb7-395"><a href="#cb7-395" aria-hidden="true" tabindex="-1"></a>                deckungsbeitrag<span class="op">=</span><span class="bu">float</span>(zeile.Deckungsbeitrag),</span>
+<span id="cb7-396"><a href="#cb7-396" aria-hidden="true" tabindex="-1"></a>                verbrauch<span class="op">=</span>{r: <span class="bu">float</span>(<span class="bu">getattr</span>(zeile, r)) <span class="cf">for</span> r <span class="kw">in</span> ressourcen})</span>
+<span id="cb7-397"><a href="#cb7-397" aria-hidden="true" tabindex="-1"></a>        <span class="cf">for</span> zeile <span class="kw">in</span> produkte_tabelle.itertuples()</span>
+<span id="cb7-398"><a href="#cb7-398" aria-hidden="true" tabindex="-1"></a>    ]</span>
+<span id="cb7-399"><a href="#cb7-399" aria-hidden="true" tabindex="-1"></a>    kapazitaeten <span class="op">=</span> {<span class="bu">str</span>(z.Ressource): <span class="bu">float</span>(z.Verfuegbar)</span>
+<span id="cb7-400"><a href="#cb7-400" aria-hidden="true" tabindex="-1"></a>                    <span class="cf">for</span> z <span class="kw">in</span> kapazitaeten_tabelle.itertuples()}</span>
+<span id="cb7-401"><a href="#cb7-401" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb7-402"><a href="#cb7-402" aria-hidden="true" tabindex="-1"></a>    <span class="cf">return</span> Produktionsproblem(produkte<span class="op">=</span>produkte, kapazitaeten<span class="op">=</span>kapazitaeten)</span>
+<span id="cb7-403"><a href="#cb7-403" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb7-404"><a href="#cb7-404" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb7-405"><a href="#cb7-405" aria-hidden="true" tabindex="-1"></a><span class="kw">def</span> schreibe_ergebnis(pfad: <span class="bu">str</span>, problem: Produktionsproblem,</span>
+<span id="cb7-406"><a href="#cb7-406" aria-hidden="true" tabindex="-1"></a>                      loesung: Loesung) <span class="op">-&gt;</span> <span class="va">None</span>:</span>
+<span id="cb7-407"><a href="#cb7-407" aria-hidden="true" tabindex="-1"></a>    <span class="co">&quot;&quot;&quot;Schreibt Plan und Kennzahlen als zwei Blaetter zurueck nach Excel.</span></span>
+<span id="cb7-408"><a href="#cb7-408" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb7-409"><a href="#cb7-409" aria-hidden="true" tabindex="-1"></a><span class="co">    Die Fachabteilung bekommt das Ergebnis im Format, das sie ohnehin benutzt.</span></span>
+<span id="cb7-410"><a href="#cb7-410" aria-hidden="true" tabindex="-1"></a><span class="co">    Akzeptanz entscheidet ueber Projekterfolg (Kapitel Praxisfallen).</span></span>
+<span id="cb7-411"><a href="#cb7-411" aria-hidden="true" tabindex="-1"></a><span class="co">    &quot;&quot;&quot;</span></span>
+<span id="cb7-412"><a href="#cb7-412" aria-hidden="true" tabindex="-1"></a>    <span class="im">import</span> pandas <span class="im">as</span> pd</span>
+<span id="cb7-413"><a href="#cb7-413" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb7-414"><a href="#cb7-414" aria-hidden="true" tabindex="-1"></a>    <span class="cf">if</span> <span class="kw">not</span> loesung.status.brauchbar:</span>
+<span id="cb7-415"><a href="#cb7-415" aria-hidden="true" tabindex="-1"></a>        <span class="cf">raise</span> <span class="pp">ValueError</span>(<span class="ss">f&quot;Nichts zu schreiben - Status: </span><span class="sc">{</span>loesung<span class="sc">.</span>status<span class="sc">.</span>value<span class="sc">}</span><span class="ss">&quot;</span>)</span>
+<span id="cb7-416"><a href="#cb7-416" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb7-417"><a href="#cb7-417" aria-hidden="true" tabindex="-1"></a>    mengen <span class="op">=</span> np.array([loesung.werte[p.name] <span class="cf">for</span> p <span class="kw">in</span> problem.produkte])</span>
+<span id="cb7-418"><a href="#cb7-418" aria-hidden="true" tabindex="-1"></a>    plan <span class="op">=</span> pd.DataFrame({</span>
+<span id="cb7-419"><a href="#cb7-419" aria-hidden="true" tabindex="-1"></a>        <span class="st">&quot;Produkt&quot;</span>: [p.name <span class="cf">for</span> p <span class="kw">in</span> problem.produkte],</span>
+<span id="cb7-420"><a href="#cb7-420" aria-hidden="true" tabindex="-1"></a>        <span class="st">&quot;Menge&quot;</span>: mengen,</span>
+<span id="cb7-421"><a href="#cb7-421" aria-hidden="true" tabindex="-1"></a>        <span class="st">&quot;Deckungsbeitrag&quot;</span>: mengen <span class="op">*</span> problem.deckungsbeitragsvektor(),</span>
+<span id="cb7-422"><a href="#cb7-422" aria-hidden="true" tabindex="-1"></a>    })</span>
+<span id="cb7-423"><a href="#cb7-423" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb7-424"><a href="#cb7-424" aria-hidden="true" tabindex="-1"></a>    verbrauch <span class="op">=</span> problem.verbrauchsmatrix() <span class="op">@</span> mengen</span>
+<span id="cb7-425"><a href="#cb7-425" aria-hidden="true" tabindex="-1"></a>    kennzahlen: <span class="bu">dict</span>[<span class="bu">str</span>, <span class="bu">float</span> <span class="op">|</span> <span class="bu">str</span>] <span class="op">=</span> {</span>
+<span id="cb7-426"><a href="#cb7-426" aria-hidden="true" tabindex="-1"></a>        <span class="st">&quot;Status&quot;</span>: loesung.status.value,</span>
+<span id="cb7-427"><a href="#cb7-427" aria-hidden="true" tabindex="-1"></a>        <span class="st">&quot;Gesamtdeckungsbeitrag&quot;</span>: loesung.zielwert <span class="kw">or</span> <span class="fl">0.0</span>,</span>
+<span id="cb7-428"><a href="#cb7-428" aria-hidden="true" tabindex="-1"></a>    }</span>
+<span id="cb7-429"><a href="#cb7-429" aria-hidden="true" tabindex="-1"></a>    <span class="cf">for</span> ressource, ist, grenze <span class="kw">in</span> <span class="bu">zip</span>(problem.ressourcen, verbrauch,</span>
+<span id="cb7-430"><a href="#cb7-430" aria-hidden="true" tabindex="-1"></a>                                      problem.kapazitaetsvektor()):</span>
+<span id="cb7-431"><a href="#cb7-431" aria-hidden="true" tabindex="-1"></a>        kennzahlen[<span class="ss">f&quot;</span><span class="sc">{</span>ressource<span class="sc">}</span><span class="ss">: Verbrauch&quot;</span>] <span class="op">=</span> <span class="bu">float</span>(ist)</span>
+<span id="cb7-432"><a href="#cb7-432" aria-hidden="true" tabindex="-1"></a>        kennzahlen[<span class="ss">f&quot;</span><span class="sc">{</span>ressource<span class="sc">}</span><span class="ss">: Auslastung %&quot;</span>] <span class="op">=</span> <span class="bu">float</span>(<span class="fl">100.0</span> <span class="op">*</span> ist <span class="op">/</span> grenze)</span>
+<span id="cb7-433"><a href="#cb7-433" aria-hidden="true" tabindex="-1"></a>        <span class="cf">if</span> ressource <span class="kw">in</span> loesung.schattenpreise:</span>
+<span id="cb7-434"><a href="#cb7-434" aria-hidden="true" tabindex="-1"></a>            kennzahlen[<span class="ss">f&quot;</span><span class="sc">{</span>ressource<span class="sc">}</span><span class="ss">: Schattenpreis&quot;</span>] <span class="op">=</span> <span class="op">\</span></span>
+<span id="cb7-435"><a href="#cb7-435" aria-hidden="true" tabindex="-1"></a>                loesung.schattenpreise[ressource]</span>
+<span id="cb7-436"><a href="#cb7-436" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb7-437"><a href="#cb7-437" aria-hidden="true" tabindex="-1"></a>    kennzahlen_tabelle <span class="op">=</span> pd.DataFrame({</span>
+<span id="cb7-438"><a href="#cb7-438" aria-hidden="true" tabindex="-1"></a>        <span class="st">&quot;Kennzahl&quot;</span>: <span class="bu">list</span>(kennzahlen),</span>
+<span id="cb7-439"><a href="#cb7-439" aria-hidden="true" tabindex="-1"></a>        <span class="st">&quot;Wert&quot;</span>: [<span class="bu">round</span>(w, <span class="dv">2</span>) <span class="cf">if</span> <span class="bu">isinstance</span>(w, <span class="bu">float</span>) <span class="cf">else</span> w</span>
+<span id="cb7-440"><a href="#cb7-440" aria-hidden="true" tabindex="-1"></a>                 <span class="cf">for</span> w <span class="kw">in</span> kennzahlen.values()],</span>
+<span id="cb7-441"><a href="#cb7-441" aria-hidden="true" tabindex="-1"></a>    })</span>
+<span id="cb7-442"><a href="#cb7-442" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb7-443"><a href="#cb7-443" aria-hidden="true" tabindex="-1"></a>    <span class="cf">with</span> pd.ExcelWriter(pfad, engine<span class="op">=</span><span class="st">&quot;openpyxl&quot;</span>) <span class="im">as</span> mappe:</span>
+<span id="cb7-444"><a href="#cb7-444" aria-hidden="true" tabindex="-1"></a>        plan.<span class="bu">round</span>(<span class="dv">2</span>).to_excel(mappe, sheet_name<span class="op">=</span><span class="st">&quot;Plan&quot;</span>, index<span class="op">=</span><span class="va">False</span>)</span>
+<span id="cb7-445"><a href="#cb7-445" aria-hidden="true" tabindex="-1"></a>        kennzahlen_tabelle.to_excel(mappe, sheet_name<span class="op">=</span><span class="st">&quot;Kennzahlen&quot;</span>, index<span class="op">=</span><span class="va">False</span>)</span>
+<span id="cb7-446"><a href="#cb7-446" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb7-447"><a href="#cb7-447" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb7-448"><a href="#cb7-448" aria-hidden="true" tabindex="-1"></a><span class="cf">if</span> <span class="va">__name__</span> <span class="op">==</span> <span class="st">&quot;__main__&quot;</span>:</span>
+<span id="cb7-449"><a href="#cb7-449" aria-hidden="true" tabindex="-1"></a>    <span class="co"># Die Schreinerei aus Kapitel Einfuehrung - jetzt als Domaenenmodell.</span></span>
+<span id="cb7-450"><a href="#cb7-450" aria-hidden="true" tabindex="-1"></a>    schreinerei <span class="op">=</span> Produktionsproblem(</span>
+<span id="cb7-451"><a href="#cb7-451" aria-hidden="true" tabindex="-1"></a>        produkte<span class="op">=</span>[</span>
+<span id="cb7-452"><a href="#cb7-452" aria-hidden="true" tabindex="-1"></a>            Produkt(name<span class="op">=</span><span class="st">&quot;Tisch&quot;</span>, deckungsbeitrag<span class="op">=</span><span class="fl">240.0</span>,</span>
+<span id="cb7-453"><a href="#cb7-453" aria-hidden="true" tabindex="-1"></a>                    verbrauch<span class="op">=</span>{<span class="st">&quot;Montagestunden&quot;</span>: <span class="fl">3.0</span>, <span class="st">&quot;Plattenmaterial&quot;</span>: <span class="fl">6.0</span>}),</span>
+<span id="cb7-454"><a href="#cb7-454" aria-hidden="true" tabindex="-1"></a>            Produkt(name<span class="op">=</span><span class="st">&quot;Stuhl&quot;</span>, deckungsbeitrag<span class="op">=</span><span class="fl">60.0</span>,</span>
+<span id="cb7-455"><a href="#cb7-455" aria-hidden="true" tabindex="-1"></a>                    verbrauch<span class="op">=</span>{<span class="st">&quot;Montagestunden&quot;</span>: <span class="fl">1.0</span>, <span class="st">&quot;Plattenmaterial&quot;</span>: <span class="fl">1.0</span>}),</span>
+<span id="cb7-456"><a href="#cb7-456" aria-hidden="true" tabindex="-1"></a>        ],</span>
+<span id="cb7-457"><a href="#cb7-457" aria-hidden="true" tabindex="-1"></a>        kapazitaeten<span class="op">=</span>{<span class="st">&quot;Montagestunden&quot;</span>: <span class="fl">150.0</span>, <span class="st">&quot;Plattenmaterial&quot;</span>: <span class="fl">240.0</span>},</span>
+<span id="cb7-458"><a href="#cb7-458" aria-hidden="true" tabindex="-1"></a>    )</span>
+<span id="cb7-459"><a href="#cb7-459" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb7-460"><a href="#cb7-460" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;=&quot;</span> <span class="op">*</span> <span class="dv">78</span>)</span>
+<span id="cb7-461"><a href="#cb7-461" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;  DERSELBE FALL, ZWEI SOLVER, EIN AUSWERTUNGSCODE&quot;</span>)</span>
+<span id="cb7-462"><a href="#cb7-462" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;=&quot;</span> <span class="op">*</span> <span class="dv">78</span>)</span>
+<span id="cb7-463"><a href="#cb7-463" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb7-464"><a href="#cb7-464" aria-hidden="true" tabindex="-1"></a>    <span class="cf">for</span> name, bauer <span class="kw">in</span> [(<span class="st">&quot;OR-Tools GLOP&quot;</span>, loese_mit_glop),</span>
+<span id="cb7-465"><a href="#cb7-465" aria-hidden="true" tabindex="-1"></a>                        (<span class="st">&quot;scipy / HiGHS&quot;</span>, loese_mit_scipy)]:</span>
+<span id="cb7-466"><a href="#cb7-466" aria-hidden="true" tabindex="-1"></a>        loesung <span class="op">=</span> bauer(schreinerei)</span>
+<span id="cb7-467"><a href="#cb7-467" aria-hidden="true" tabindex="-1"></a>        beanstandungen <span class="op">=</span> pruefe_loesung(schreinerei, loesung)</span>
+<span id="cb7-468"><a href="#cb7-468" aria-hidden="true" tabindex="-1"></a>        <span class="bu">print</span>(<span class="ss">f&quot;</span><span class="ch">\n</span><span class="sc">{</span>name<span class="sc">}</span><span class="ss">&quot;</span>)</span>
+<span id="cb7-469"><a href="#cb7-469" aria-hidden="true" tabindex="-1"></a>        <span class="bu">print</span>(<span class="ss">f&quot;  </span><span class="sc">{</span>loesung<span class="sc">.</span>als_bericht()<span class="sc">}</span><span class="ss">&quot;</span>)</span>
+<span id="cb7-470"><a href="#cb7-470" aria-hidden="true" tabindex="-1"></a>        <span class="cf">for</span> produkt, menge <span class="kw">in</span> loesung.werte.items():</span>
+<span id="cb7-471"><a href="#cb7-471" aria-hidden="true" tabindex="-1"></a>            <span class="bu">print</span>(<span class="ss">f&quot;    </span><span class="sc">{</span>produkt<span class="sc">:&lt;10}</span><span class="ss"> </span><span class="sc">{</span>menge<span class="sc">:8.2f}</span><span class="ss">&quot;</span>)</span>
+<span id="cb7-472"><a href="#cb7-472" aria-hidden="true" tabindex="-1"></a>        <span class="bu">print</span>(<span class="ss">f&quot;  Abnahmepruefung: &quot;</span></span>
+<span id="cb7-473"><a href="#cb7-473" aria-hidden="true" tabindex="-1"></a>              <span class="ss">f&quot;</span><span class="sc">{</span><span class="st">&#39;bestanden&#39;</span> <span class="cf">if</span> <span class="kw">not</span> beanstandungen <span class="cf">else</span> beanstandungen<span class="sc">}</span><span class="ss">&quot;</span>)</span>
+<span id="cb7-474"><a href="#cb7-474" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb7-475"><a href="#cb7-475" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;</span><span class="ch">\n</span><span class="st">&quot;</span> <span class="op">+</span> <span class="st">&quot;=&quot;</span> <span class="op">*</span> <span class="dv">78</span>)</span>
+<span id="cb7-476"><a href="#cb7-476" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;  WAS DIE PRUEFUNGEN ABFANGEN&quot;</span>)</span>
+<span id="cb7-477"><a href="#cb7-477" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;=&quot;</span> <span class="op">*</span> <span class="dv">78</span>)</span>
+<span id="cb7-478"><a href="#cb7-478" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb7-479"><a href="#cb7-479" aria-hidden="true" tabindex="-1"></a>    faelle <span class="op">=</span> [</span>
+<span id="cb7-480"><a href="#cb7-480" aria-hidden="true" tabindex="-1"></a>        (<span class="st">&quot;Kapazitaet 0&quot;</span>, <span class="bu">dict</span>(</span>
+<span id="cb7-481"><a href="#cb7-481" aria-hidden="true" tabindex="-1"></a>            produkte<span class="op">=</span>schreinerei.produkte,</span>
+<span id="cb7-482"><a href="#cb7-482" aria-hidden="true" tabindex="-1"></a>            kapazitaeten<span class="op">=</span>{<span class="st">&quot;Montagestunden&quot;</span>: <span class="fl">0.0</span>, <span class="st">&quot;Plattenmaterial&quot;</span>: <span class="fl">240.0</span>})),</span>
+<span id="cb7-483"><a href="#cb7-483" aria-hidden="true" tabindex="-1"></a>        (<span class="st">&quot;Ressource ohne Kapazitaet&quot;</span>, <span class="bu">dict</span>(</span>
+<span id="cb7-484"><a href="#cb7-484" aria-hidden="true" tabindex="-1"></a>            produkte<span class="op">=</span>[Produkt(name<span class="op">=</span><span class="st">&quot;Regal&quot;</span>, deckungsbeitrag<span class="op">=</span><span class="fl">130.0</span>,</span>
+<span id="cb7-485"><a href="#cb7-485" aria-hidden="true" tabindex="-1"></a>                              verbrauch<span class="op">=</span>{<span class="st">&quot;Lackieren&quot;</span>: <span class="fl">2.0</span>})],</span>
+<span id="cb7-486"><a href="#cb7-486" aria-hidden="true" tabindex="-1"></a>            kapazitaeten<span class="op">=</span>{<span class="st">&quot;Montagestunden&quot;</span>: <span class="fl">150.0</span>})),</span>
+<span id="cb7-487"><a href="#cb7-487" aria-hidden="true" tabindex="-1"></a>        (<span class="st">&quot;doppelter Produktname&quot;</span>, <span class="bu">dict</span>(</span>
+<span id="cb7-488"><a href="#cb7-488" aria-hidden="true" tabindex="-1"></a>            produkte<span class="op">=</span>[schreinerei.produkte[<span class="dv">0</span>], schreinerei.produkte[<span class="dv">0</span>]],</span>
+<span id="cb7-489"><a href="#cb7-489" aria-hidden="true" tabindex="-1"></a>            kapazitaeten<span class="op">=</span>schreinerei.kapazitaeten)),</span>
+<span id="cb7-490"><a href="#cb7-490" aria-hidden="true" tabindex="-1"></a>    ]</span>
+<span id="cb7-491"><a href="#cb7-491" aria-hidden="true" tabindex="-1"></a>    <span class="cf">for</span> beschreibung, daten <span class="kw">in</span> faelle:</span>
+<span id="cb7-492"><a href="#cb7-492" aria-hidden="true" tabindex="-1"></a>        <span class="cf">try</span>:</span>
+<span id="cb7-493"><a href="#cb7-493" aria-hidden="true" tabindex="-1"></a>            Produktionsproblem(<span class="op">**</span>daten)</span>
+<span id="cb7-494"><a href="#cb7-494" aria-hidden="true" tabindex="-1"></a>            <span class="bu">print</span>(<span class="ss">f&quot;  </span><span class="sc">{</span>beschreibung<span class="sc">:&lt;28}</span><span class="ss"> NICHT erkannt (!)&quot;</span>)</span>
+<span id="cb7-495"><a href="#cb7-495" aria-hidden="true" tabindex="-1"></a>        <span class="cf">except</span> <span class="pp">Exception</span> <span class="im">as</span> fehler:</span>
+<span id="cb7-496"><a href="#cb7-496" aria-hidden="true" tabindex="-1"></a>            meldung <span class="op">=</span> <span class="bu">str</span>(fehler).splitlines()</span>
+<span id="cb7-497"><a href="#cb7-497" aria-hidden="true" tabindex="-1"></a>            kern <span class="op">=</span> <span class="bu">next</span>((z.strip() <span class="cf">for</span> z <span class="kw">in</span> meldung</span>
+<span id="cb7-498"><a href="#cb7-498" aria-hidden="true" tabindex="-1"></a>                         <span class="cf">if</span> <span class="st">&quot;Value error&quot;</span> <span class="kw">in</span> z <span class="kw">or</span> <span class="st">&quot;greater than&quot;</span> <span class="kw">in</span> z), meldung[<span class="op">-</span><span class="dv">1</span>])</span>
+<span id="cb7-499"><a href="#cb7-499" aria-hidden="true" tabindex="-1"></a>            <span class="bu">print</span>(<span class="ss">f&quot;  </span><span class="sc">{</span>beschreibung<span class="sc">:&lt;28}</span><span class="ss"> abgefangen: </span><span class="sc">{</span>kern[:<span class="dv">44</span>]<span class="sc">}</span><span class="ss">&quot;</span>)</span>
+<span id="cb7-500"><a href="#cb7-500" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb7-501"><a href="#cb7-501" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;</span><span class="ch">\n</span><span class="st">Alle drei scheitern beim EINLESEN - nicht erst beim Loesen und&quot;</span>)</span>
+<span id="cb7-502"><a href="#cb7-502" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;schon gar nicht erst im Bericht. Das ist der ganze Zweck der&quot;</span>)</span>
+<span id="cb7-503"><a href="#cb7-503" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;Domaenenschicht.&quot;</span>)</span>
+<span id="cb7-504"><a href="#cb7-504" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;=&quot;</span> <span class="op">*</span> <span class="dv">78</span>)</span></code></pre></div>
 <p><strong>Erwartete Ausgabe:</strong></p>
 <pre><code>==============================================================================
   DERSELBE FALL, ZWEI SOLVER, EIN AUSWERTUNGSCODE
@@ -1230,7 +1664,7 @@ Domaenenschicht.
 <tr class="odd">
 <td><code>SolverStatus.modellfehler</code></td>
 <td>trennt Modell- von Zeitproblemen</td>
-<td>Genau die Unterscheidung, die <a href="cpsat.html#sec:cpsat-statusfaelle">Abschnitt 7.7</a> als häufigste Verwechslung benennt.</td>
+<td>Genau die Unterscheidung, die <a href="cpsat.html#sec:cpsat-statusfaelle">Abschnitt 7.8</a> als häufigste Verwechslung benennt.</td>
 </tr>
 <tr class="even">
 <td><code>model_validator(mode="after")</code></td>
@@ -1269,7 +1703,7 @@ Domaenenschicht.
 <p><strong>🎯 Merksatz</strong> Ein Fehler, der beim Einlesen auffliegt, kostet Minuten. Derselbe Fehler, der erst im Bericht auffällt, kostet Tage — und derselbe Fehler, der <strong>nie</strong> auffällt, kostet am meisten. Validierung ist deshalb keine Fleißarbeit, sondern die günstigste Stelle im ganzen Ablauf.</p>
 </blockquote>
 <hr />
-<h2 id="sec:praxisfallen-solverwechsel">22.6 Der Solverwechsel in der Praxis</h2>
+<h2 id="sec:praxisfallen-solverwechsel">22.7 Der Solverwechsel in der Praxis</h2>
 <p>Der vorige Abschnitt endet mit einer Behauptung: Ein Solverwechsel betreffe genau <strong>einen</strong> Baustein. Das ist die Art Satz, die in jedem Architekturvortrag vorkommt und die man deshalb nicht glauben sollte, bevor sie jemand vorgeführt hat.</p>
 <p>Also führen wir sie vor — und zwar am unbequemsten Paar, das dieses Buch zu bieten hat: <strong>CP-SAT gegen HiGHS</strong>. Die beiden sind grundverschieden. CP-SAT ist ein Constraint-Programming-Solver, der ausschließlich ganzzahlig rechnet und Restriktionen als Ausdrücke entgegennimmt. HiGHS ist ein klassischer Branch-and-Bound-Löser, der eine Koeffizientenmatrix erwartet. Und sie lassen sich nicht einmal gemeinsam importieren (<a href="oekosystem.html#kap-oekosystem">Kapitel 3</a>).</p>
 <p><strong>Die Aufgabe</strong> ist eine kapazitierte Standortplanung: Aus sechs möglichen Lagern sind diejenigen zu eröffnen, mit denen zwölf Kunden am günstigsten beliefert werden. Jeder Kunde wird von genau einem Lager bedient, jedes eröffnete Lager kostet eine Fixgebühr, und die Kapazität reicht je Lager für 174 der insgesamt 387 Paletten — es müssen also mindestens drei Lager öffnen.</p>
@@ -1314,330 +1748,334 @@ Domaenenschicht.
 <blockquote>
 <p><strong>📎 Warum zwei Prozesse?</strong></p>
 <p><code>ortools</code> und <code>highspy</code> bringen beide eine eigene HiGHS-Kopie mit und kollidieren beim gemeinsamen Import (<a href="oekosystem.html#kap-oekosystem">Kapitel 3</a>). Das Programm startet sich deshalb für jeden Solver selbst noch einmal als Kindprozess und lässt sich das Ergebnis als <strong>JSON</strong> zurückgeben:</p>
-<div class="sourceCode" id="cb7"><pre class="sourceCode python"><code class="sourceCode python"><span id="cb7-1"><a href="#cb7-1" aria-hidden="true" tabindex="-1"></a><span class="bu">print</span>(MODELLBAUER[sys.argv[<span class="dv">1</span>]](problem).model_dump_json())   <span class="co"># im Kindprozess</span></span>
-<span id="cb7-2"><a href="#cb7-2" aria-hidden="true" tabindex="-1"></a>Loesung.model_validate_json(...)                             <span class="co"># im Hauptprozess</span></span></code></pre></div>
+<div class="sourceCode" id="cb9"><pre class="sourceCode python"><code class="sourceCode python"><span id="cb9-1"><a href="#cb9-1" aria-hidden="true" tabindex="-1"></a><span class="bu">print</span>(MODELLBAUER[sys.argv[<span class="dv">1</span>]](problem).model_dump_json())   <span class="co"># im Kindprozess</span></span>
+<span id="cb9-2"><a href="#cb9-2" aria-hidden="true" tabindex="-1"></a>Loesung.model_validate_json(...)                             <span class="co"># im Hauptprozess</span></span></code></pre></div>
 <p>Das ist der zweite, weniger offensichtliche Ertrag des DTOs: Ein Lösungsobjekt ohne Solverbezug ist nicht nur eine Sprachregelung, sondern ein <strong>Datenformat</strong>. Es überlebt eine Prozessgrenze, passt in eine Warteschlange und lässt sich protokollieren. Ein <code>pywraplp.Solver</code>-Objekt kann das alles nicht.</p>
 </blockquote>
-<div class="sourceCode" id="cb8"><pre class="sourceCode python"><code class="sourceCode python"><span id="cb8-1"><a href="#cb8-1" aria-hidden="true" tabindex="-1"></a><span class="co">#!/usr/bin/env python3</span></span>
-<span id="cb8-2"><a href="#cb8-2" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb8-3"><a href="#cb8-3" aria-hidden="true" tabindex="-1"></a><span class="co"># Solverwechsel_CPSAT_HiGHS.py</span></span>
-<span id="cb8-4"><a href="#cb8-4" aria-hidden="true" tabindex="-1"></a><span class="co">&quot;&quot;&quot;</span></span>
-<span id="cb8-5"><a href="#cb8-5" aria-hidden="true" tabindex="-1"></a><span class="co">Kapitel Praxisfallen: Denselben Fall einmal mit CP-SAT und einmal mit HiGHS rechnen.</span></span>
-<span id="cb8-6"><a href="#cb8-6" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb8-7"><a href="#cb8-7" aria-hidden="true" tabindex="-1"></a><span class="co">Die Trennung aus or_kern.py behauptet, ein Solverwechsel koste genau EINEN</span></span>
-<span id="cb8-8"><a href="#cb8-8" aria-hidden="true" tabindex="-1"></a><span class="co">Baustein. Dieses Programm loest diese Behauptung ein. Aufgabe ist eine</span></span>
-<span id="cb8-9"><a href="#cb8-9" aria-hidden="true" tabindex="-1"></a><span class="co">Standortplanung: Welche Lager oeffnen wir, und wer beliefert welchen Kunden?</span></span>
-<span id="cb8-10"><a href="#cb8-10" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb8-11"><a href="#cb8-11" aria-hidden="true" tabindex="-1"></a><span class="co">    Standortproblem  (Pydantic, geprueft)   &lt;- gemeinsam</span></span>
-<span id="cb8-12"><a href="#cb8-12" aria-hidden="true" tabindex="-1"></a><span class="co">        baue_und_loese_mit_cpsat()          &lt;- der EINE Baustein</span></span>
-<span id="cb8-13"><a href="#cb8-13" aria-hidden="true" tabindex="-1"></a><span class="co">        baue_und_loese_mit_highs()          &lt;- ... in zwei Ausfuehrungen</span></span>
-<span id="cb8-14"><a href="#cb8-14" aria-hidden="true" tabindex="-1"></a><span class="co">    Loesung          (DTO)                  &lt;- gemeinsam</span></span>
-<span id="cb8-15"><a href="#cb8-15" aria-hidden="true" tabindex="-1"></a><span class="co">    pruefe_zuordnung()                      &lt;- gemeinsam</span></span>
-<span id="cb8-16"><a href="#cb8-16" aria-hidden="true" tabindex="-1"></a><span class="co">    berichte()                              &lt;- gemeinsam</span></span>
-<span id="cb8-17"><a href="#cb8-17" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb8-18"><a href="#cb8-18" aria-hidden="true" tabindex="-1"></a><span class="co">Die beiden Modellbauer sind 39 und 52 Zeilen lang - sie sind der gesamte</span></span>
-<span id="cb8-19"><a href="#cb8-19" aria-hidden="true" tabindex="-1"></a><span class="co">solverabhaengige Teil des Programms. Alles andere wird zweimal benutzt und</span></span>
-<span id="cb8-20"><a href="#cb8-20" aria-hidden="true" tabindex="-1"></a><span class="co">einmal geschrieben.</span></span>
-<span id="cb8-21"><a href="#cb8-21" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb8-22"><a href="#cb8-22" aria-hidden="true" tabindex="-1"></a><span class="co">WARUM ZWEI PROZESSE? ortools und highspy bringen beide eine eigene</span></span>
-<span id="cb8-23"><a href="#cb8-23" aria-hidden="true" tabindex="-1"></a><span class="co">HiGHS-Kopie mit und lassen sich auf vielen Systemen nicht gemeinsam</span></span>
-<span id="cb8-24"><a href="#cb8-24" aria-hidden="true" tabindex="-1"></a><span class="co">importieren (Kapitel Oekosystem). Das Hauptprogramm startet deshalb fuer jeden</span></span>
-<span id="cb8-25"><a href="#cb8-25" aria-hidden="true" tabindex="-1"></a><span class="co">Solver einen eigenen Python-Prozess und laesst sich die Loesung als JSON</span></span>
-<span id="cb8-26"><a href="#cb8-26" aria-hidden="true" tabindex="-1"></a><span class="co">zurueckgeben - das DTO ist nicht nur eine Sprachregelung, sondern ein</span></span>
-<span id="cb8-27"><a href="#cb8-27" aria-hidden="true" tabindex="-1"></a><span class="co">Datenformat, das eine Prozessgrenze ueberlebt.</span></span>
-<span id="cb8-28"><a href="#cb8-28" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb8-29"><a href="#cb8-29" aria-hidden="true" tabindex="-1"></a><span class="co">Aufruf:</span></span>
-<span id="cb8-30"><a href="#cb8-30" aria-hidden="true" tabindex="-1"></a><span class="co">    python3 Solverwechsel_CPSAT_HiGHS.py            # beide, mit Vergleich</span></span>
-<span id="cb8-31"><a href="#cb8-31" aria-hidden="true" tabindex="-1"></a><span class="co">    python3 Solverwechsel_CPSAT_HiGHS.py cpsat      # nur der Kindprozess</span></span>
-<span id="cb8-32"><a href="#cb8-32" aria-hidden="true" tabindex="-1"></a><span class="co">    python3 Solverwechsel_CPSAT_HiGHS.py highs</span></span>
-<span id="cb8-33"><a href="#cb8-33" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb8-34"><a href="#cb8-34" aria-hidden="true" tabindex="-1"></a><span class="co">Benoetigt: numpy, pydantic, ortools, highspy (jeweils im eigenen Prozess)</span></span>
-<span id="cb8-35"><a href="#cb8-35" aria-hidden="true" tabindex="-1"></a><span class="co">&quot;&quot;&quot;</span></span>
-<span id="cb8-36"><a href="#cb8-36" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb8-37"><a href="#cb8-37" aria-hidden="true" tabindex="-1"></a><span class="im">from</span> __future__ <span class="im">import</span> annotations</span>
-<span id="cb8-38"><a href="#cb8-38" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb8-39"><a href="#cb8-39" aria-hidden="true" tabindex="-1"></a><span class="im">import</span> subprocess</span>
-<span id="cb8-40"><a href="#cb8-40" aria-hidden="true" tabindex="-1"></a><span class="im">import</span> sys</span>
-<span id="cb8-41"><a href="#cb8-41" aria-hidden="true" tabindex="-1"></a><span class="im">import</span> time</span>
-<span id="cb8-42"><a href="#cb8-42" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb8-43"><a href="#cb8-43" aria-hidden="true" tabindex="-1"></a><span class="im">import</span> numpy <span class="im">as</span> np</span>
-<span id="cb8-44"><a href="#cb8-44" aria-hidden="true" tabindex="-1"></a><span class="im">from</span> pydantic <span class="im">import</span> BaseModel, Field, model_validator</span>
-<span id="cb8-45"><a href="#cb8-45" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb8-46"><a href="#cb8-46" aria-hidden="true" tabindex="-1"></a><span class="im">from</span> or_kern <span class="im">import</span> Loesung, SolverStatus, status_von_cpsat, status_von_highs</span>
-<span id="cb8-47"><a href="#cb8-47" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb8-48"><a href="#cb8-48" aria-hidden="true" tabindex="-1"></a>ZEITLIMIT <span class="op">=</span> <span class="fl">30.0</span></span>
-<span id="cb8-49"><a href="#cb8-49" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb8-50"><a href="#cb8-50" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb8-51"><a href="#cb8-51" aria-hidden="true" tabindex="-1"></a><span class="co"># --- 1. Domaenenmodell: dieselben Fakten fuer beide Solver -------------------</span></span>
-<span id="cb8-52"><a href="#cb8-52" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb8-53"><a href="#cb8-53" aria-hidden="true" tabindex="-1"></a><span class="kw">class</span> Standortproblem(BaseModel):</span>
-<span id="cb8-54"><a href="#cb8-54" aria-hidden="true" tabindex="-1"></a>    <span class="co">&quot;&quot;&quot;Kapazitierte Standortplanung mit Einzelbelieferung.</span></span>
-<span id="cb8-55"><a href="#cb8-55" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb8-56"><a href="#cb8-56" aria-hidden="true" tabindex="-1"></a><span class="co">    Nach dem Muster von Produktionsproblem in or_kern.py: Die Pruefungen</span></span>
-<span id="cb8-57"><a href="#cb8-57" aria-hidden="true" tabindex="-1"></a><span class="co">    stehen im Konstruktor, nicht im Solvercode - sie gelten damit fuer beide</span></span>
-<span id="cb8-58"><a href="#cb8-58" aria-hidden="true" tabindex="-1"></a><span class="co">    Solver, und sie schlagen beim Einlesen zu.</span></span>
-<span id="cb8-59"><a href="#cb8-59" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb8-60"><a href="#cb8-60" aria-hidden="true" tabindex="-1"></a><span class="co">    Alle Kosten sind ganzzahlig (Euro). Das ist keine Bequemlichkeit, sondern</span></span>
-<span id="cb8-61"><a href="#cb8-61" aria-hidden="true" tabindex="-1"></a><span class="co">    Voraussetzung: CP-SAT rechnet ausschliesslich ganzzahlig.</span></span>
-<span id="cb8-62"><a href="#cb8-62" aria-hidden="true" tabindex="-1"></a><span class="co">    &quot;&quot;&quot;</span></span>
-<span id="cb8-63"><a href="#cb8-63" aria-hidden="true" tabindex="-1"></a>    lager: <span class="bu">list</span>[<span class="bu">str</span>] <span class="op">=</span> Field(min_length<span class="op">=</span><span class="dv">1</span>)</span>
-<span id="cb8-64"><a href="#cb8-64" aria-hidden="true" tabindex="-1"></a>    kunden: <span class="bu">list</span>[<span class="bu">str</span>] <span class="op">=</span> Field(min_length<span class="op">=</span><span class="dv">1</span>)</span>
-<span id="cb8-65"><a href="#cb8-65" aria-hidden="true" tabindex="-1"></a>    fixkosten: <span class="bu">list</span>[<span class="bu">int</span>]        <span class="co"># je Lager, faellt bei Eroeffnung an</span></span>
-<span id="cb8-66"><a href="#cb8-66" aria-hidden="true" tabindex="-1"></a>    kapazitaet: <span class="bu">list</span>[<span class="bu">int</span>]       <span class="co"># je Lager, in Paletten</span></span>
-<span id="cb8-67"><a href="#cb8-67" aria-hidden="true" tabindex="-1"></a>    bedarf: <span class="bu">list</span>[<span class="bu">int</span>]           <span class="co"># je Kunde, in Paletten</span></span>
-<span id="cb8-68"><a href="#cb8-68" aria-hidden="true" tabindex="-1"></a>    transport: <span class="bu">list</span>[<span class="bu">list</span>[<span class="bu">int</span>]]  <span class="co"># [Lager][Kunde], Kosten der Belieferung</span></span>
-<span id="cb8-69"><a href="#cb8-69" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb8-70"><a href="#cb8-70" aria-hidden="true" tabindex="-1"></a>    <span class="at">@model_validator</span>(mode<span class="op">=</span><span class="st">&quot;after&quot;</span>)</span>
-<span id="cb8-71"><a href="#cb8-71" aria-hidden="true" tabindex="-1"></a>    <span class="kw">def</span> pruefe_masse(<span class="va">self</span>) <span class="op">-&gt;</span> <span class="st">&quot;Standortproblem&quot;</span>:</span>
-<span id="cb8-72"><a href="#cb8-72" aria-hidden="true" tabindex="-1"></a>        n, m <span class="op">=</span> <span class="bu">len</span>(<span class="va">self</span>.lager), <span class="bu">len</span>(<span class="va">self</span>.kunden)</span>
-<span id="cb8-73"><a href="#cb8-73" aria-hidden="true" tabindex="-1"></a>        <span class="cf">if</span> <span class="bu">len</span>(<span class="va">self</span>.fixkosten) <span class="op">!=</span> n <span class="kw">or</span> <span class="bu">len</span>(<span class="va">self</span>.kapazitaet) <span class="op">!=</span> n:</span>
-<span id="cb8-74"><a href="#cb8-74" aria-hidden="true" tabindex="-1"></a>            <span class="cf">raise</span> <span class="pp">ValueError</span>(<span class="ss">f&quot;fixkosten/kapazitaet muessen </span><span class="sc">{</span>n<span class="sc">}</span><span class="ss"> Eintraege haben&quot;</span>)</span>
-<span id="cb8-75"><a href="#cb8-75" aria-hidden="true" tabindex="-1"></a>        <span class="cf">if</span> <span class="bu">len</span>(<span class="va">self</span>.bedarf) <span class="op">!=</span> m:</span>
-<span id="cb8-76"><a href="#cb8-76" aria-hidden="true" tabindex="-1"></a>            <span class="cf">raise</span> <span class="pp">ValueError</span>(<span class="ss">f&quot;bedarf muss </span><span class="sc">{</span>m<span class="sc">}</span><span class="ss"> Eintraege haben&quot;</span>)</span>
-<span id="cb8-77"><a href="#cb8-77" aria-hidden="true" tabindex="-1"></a>        <span class="cf">if</span> <span class="bu">len</span>(<span class="va">self</span>.transport) <span class="op">!=</span> n <span class="kw">or</span> <span class="bu">any</span>(<span class="bu">len</span>(z) <span class="op">!=</span> m <span class="cf">for</span> z <span class="kw">in</span> <span class="va">self</span>.transport):</span>
-<span id="cb8-78"><a href="#cb8-78" aria-hidden="true" tabindex="-1"></a>            <span class="cf">raise</span> <span class="pp">ValueError</span>(<span class="ss">f&quot;transport muss </span><span class="sc">{</span>n<span class="sc">}</span><span class="ss"> x </span><span class="sc">{</span>m<span class="sc">}</span><span class="ss"> sein&quot;</span>)</span>
-<span id="cb8-79"><a href="#cb8-79" aria-hidden="true" tabindex="-1"></a>        <span class="cf">if</span> <span class="bu">sum</span>(<span class="va">self</span>.kapazitaet) <span class="op">&lt;</span> <span class="bu">sum</span>(<span class="va">self</span>.bedarf):</span>
-<span id="cb8-80"><a href="#cb8-80" aria-hidden="true" tabindex="-1"></a>            <span class="cf">raise</span> <span class="pp">ValueError</span>(<span class="ss">f&quot;Gesamtkapazitaet </span><span class="sc">{</span><span class="bu">sum</span>(<span class="va">self</span>.kapazitaet)<span class="sc">}</span><span class="ss"> deckt den &quot;</span></span>
-<span id="cb8-81"><a href="#cb8-81" aria-hidden="true" tabindex="-1"></a>                             <span class="ss">f&quot;Gesamtbedarf </span><span class="sc">{</span><span class="bu">sum</span>(<span class="va">self</span>.bedarf)<span class="sc">}</span><span class="ss"> nicht&quot;</span>)</span>
-<span id="cb8-82"><a href="#cb8-82" aria-hidden="true" tabindex="-1"></a>        <span class="cf">return</span> <span class="va">self</span></span>
-<span id="cb8-83"><a href="#cb8-83" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb8-84"><a href="#cb8-84" aria-hidden="true" tabindex="-1"></a>    <span class="kw">def</span> schluessel(<span class="va">self</span>, i: <span class="bu">int</span>, j: <span class="bu">int</span>) <span class="op">-&gt;</span> <span class="bu">str</span>:</span>
-<span id="cb8-85"><a href="#cb8-85" aria-hidden="true" tabindex="-1"></a>        <span class="co">&quot;&quot;&quot;Variablenname im Loesung-DTO - beide Modellbauer benutzen ihn.&quot;&quot;&quot;</span></span>
-<span id="cb8-86"><a href="#cb8-86" aria-hidden="true" tabindex="-1"></a>        <span class="cf">return</span> <span class="ss">f&quot;</span><span class="sc">{</span><span class="va">self</span><span class="sc">.</span>lager[i]<span class="sc">}</span><span class="ss">-&gt;</span><span class="sc">{</span><span class="va">self</span><span class="sc">.</span>kunden[j]<span class="sc">}</span><span class="ss">&quot;</span></span>
-<span id="cb8-87"><a href="#cb8-87" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb8-88"><a href="#cb8-88" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb8-89"><a href="#cb8-89" aria-hidden="true" tabindex="-1"></a><span class="kw">def</span> beispielproblem(saat: <span class="bu">int</span> <span class="op">=</span> <span class="dv">11</span>) <span class="op">-&gt;</span> Standortproblem:</span>
-<span id="cb8-90"><a href="#cb8-90" aria-hidden="true" tabindex="-1"></a>    <span class="co">&quot;&quot;&quot;Sechs moegliche Lager, zwoelf Kunden - klein genug fuer beide Solver.&quot;&quot;&quot;</span></span>
-<span id="cb8-91"><a href="#cb8-91" aria-hidden="true" tabindex="-1"></a>    rng <span class="op">=</span> np.random.default_rng(saat)</span>
-<span id="cb8-92"><a href="#cb8-92" aria-hidden="true" tabindex="-1"></a>    lager <span class="op">=</span> [<span class="ss">f&quot;Lager_</span><span class="sc">{</span>k<span class="sc">}</span><span class="ss">&quot;</span> <span class="cf">for</span> k <span class="kw">in</span> <span class="st">&quot;ABCDEF&quot;</span>]</span>
-<span id="cb8-93"><a href="#cb8-93" aria-hidden="true" tabindex="-1"></a>    kunden <span class="op">=</span> [<span class="ss">f&quot;Kunde_</span><span class="sc">{</span>k<span class="sc">:02d}</span><span class="ss">&quot;</span> <span class="cf">for</span> k <span class="kw">in</span> <span class="bu">range</span>(<span class="dv">1</span>, <span class="dv">13</span>)]</span>
-<span id="cb8-94"><a href="#cb8-94" aria-hidden="true" tabindex="-1"></a>    bedarf <span class="op">=</span> rng.integers(<span class="dv">10</span>, <span class="dv">60</span>, <span class="bu">len</span>(kunden))</span>
-<span id="cb8-95"><a href="#cb8-95" aria-hidden="true" tabindex="-1"></a>    <span class="cf">return</span> Standortproblem(</span>
-<span id="cb8-96"><a href="#cb8-96" aria-hidden="true" tabindex="-1"></a>        lager<span class="op">=</span>lager,</span>
-<span id="cb8-97"><a href="#cb8-97" aria-hidden="true" tabindex="-1"></a>        kunden<span class="op">=</span>kunden,</span>
-<span id="cb8-98"><a href="#cb8-98" aria-hidden="true" tabindex="-1"></a>        fixkosten<span class="op">=</span>rng.integers(<span class="dv">3000</span>, <span class="dv">9000</span>, <span class="bu">len</span>(lager)).tolist(),</span>
-<span id="cb8-99"><a href="#cb8-99" aria-hidden="true" tabindex="-1"></a>        kapazitaet<span class="op">=</span>[<span class="bu">int</span>(bedarf.<span class="bu">sum</span>() <span class="op">*</span> <span class="fl">0.45</span>)] <span class="op">*</span> <span class="bu">len</span>(lager),</span>
-<span id="cb8-100"><a href="#cb8-100" aria-hidden="true" tabindex="-1"></a>        bedarf<span class="op">=</span>bedarf.tolist(),</span>
-<span id="cb8-101"><a href="#cb8-101" aria-hidden="true" tabindex="-1"></a>        transport<span class="op">=</span>rng.integers(<span class="dv">200</span>, <span class="dv">1800</span>, (<span class="bu">len</span>(lager), <span class="bu">len</span>(kunden))).tolist(),</span>
-<span id="cb8-102"><a href="#cb8-102" aria-hidden="true" tabindex="-1"></a>    )</span>
-<span id="cb8-103"><a href="#cb8-103" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb8-104"><a href="#cb8-104" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb8-105"><a href="#cb8-105" aria-hidden="true" tabindex="-1"></a><span class="co"># --- 2. Der eine Baustein, der sich aendert: der Modellbauer -----------------</span></span>
-<span id="cb8-106"><a href="#cb8-106" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb8-107"><a href="#cb8-107" aria-hidden="true" tabindex="-1"></a><span class="kw">def</span> baue_und_loese_mit_cpsat(problem: Standortproblem) <span class="op">-&gt;</span> Loesung:</span>
-<span id="cb8-108"><a href="#cb8-108" aria-hidden="true" tabindex="-1"></a>    <span class="co">&quot;&quot;&quot;CP-SAT: Bool-Variablen, ganzzahlige Koeffizienten, Minimize.&quot;&quot;&quot;</span></span>
-<span id="cb8-109"><a href="#cb8-109" aria-hidden="true" tabindex="-1"></a>    <span class="im">from</span> ortools.sat.python <span class="im">import</span> cp_model</span>
-<span id="cb8-110"><a href="#cb8-110" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb8-111"><a href="#cb8-111" aria-hidden="true" tabindex="-1"></a>    n, m <span class="op">=</span> <span class="bu">len</span>(problem.lager), <span class="bu">len</span>(problem.kunden)</span>
-<span id="cb8-112"><a href="#cb8-112" aria-hidden="true" tabindex="-1"></a>    modell <span class="op">=</span> cp_model.CpModel()</span>
-<span id="cb8-113"><a href="#cb8-113" aria-hidden="true" tabindex="-1"></a>    y <span class="op">=</span> [modell.NewBoolVar(<span class="ss">f&quot;offen_</span><span class="sc">{</span>i<span class="sc">}</span><span class="ss">&quot;</span>) <span class="cf">for</span> i <span class="kw">in</span> <span class="bu">range</span>(n)]</span>
-<span id="cb8-114"><a href="#cb8-114" aria-hidden="true" tabindex="-1"></a>    x <span class="op">=</span> {(i, j): modell.NewBoolVar(<span class="ss">f&quot;liefert_</span><span class="sc">{</span>i<span class="sc">}</span><span class="ss">_</span><span class="sc">{</span>j<span class="sc">}</span><span class="ss">&quot;</span>)</span>
-<span id="cb8-115"><a href="#cb8-115" aria-hidden="true" tabindex="-1"></a>         <span class="cf">for</span> i <span class="kw">in</span> <span class="bu">range</span>(n) <span class="cf">for</span> j <span class="kw">in</span> <span class="bu">range</span>(m)}</span>
-<span id="cb8-116"><a href="#cb8-116" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb8-117"><a href="#cb8-117" aria-hidden="true" tabindex="-1"></a>    <span class="cf">for</span> j <span class="kw">in</span> <span class="bu">range</span>(m):                                   <span class="co"># jeder Kunde genau einmal</span></span>
-<span id="cb8-118"><a href="#cb8-118" aria-hidden="true" tabindex="-1"></a>        modell.AddExactlyOne(x[i, j] <span class="cf">for</span> i <span class="kw">in</span> <span class="bu">range</span>(n))</span>
-<span id="cb8-119"><a href="#cb8-119" aria-hidden="true" tabindex="-1"></a>    <span class="cf">for</span> i <span class="kw">in</span> <span class="bu">range</span>(n):</span>
-<span id="cb8-120"><a href="#cb8-120" aria-hidden="true" tabindex="-1"></a>        <span class="cf">for</span> j <span class="kw">in</span> <span class="bu">range</span>(m):                               <span class="co"># nur aus offenen Lagern</span></span>
-<span id="cb8-121"><a href="#cb8-121" aria-hidden="true" tabindex="-1"></a>            modell.AddImplication(x[i, j], y[i])</span>
-<span id="cb8-122"><a href="#cb8-122" aria-hidden="true" tabindex="-1"></a>        modell.Add(<span class="bu">sum</span>(problem.bedarf[j] <span class="op">*</span> x[i, j] <span class="cf">for</span> j <span class="kw">in</span> <span class="bu">range</span>(m))</span>
-<span id="cb8-123"><a href="#cb8-123" aria-hidden="true" tabindex="-1"></a>                   <span class="op">&lt;=</span> problem.kapazitaet[i] <span class="op">*</span> y[i])      <span class="co"># Kapazitaet</span></span>
-<span id="cb8-124"><a href="#cb8-124" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb8-125"><a href="#cb8-125" aria-hidden="true" tabindex="-1"></a>    modell.Minimize(</span>
-<span id="cb8-126"><a href="#cb8-126" aria-hidden="true" tabindex="-1"></a>        <span class="bu">sum</span>(problem.fixkosten[i] <span class="op">*</span> y[i] <span class="cf">for</span> i <span class="kw">in</span> <span class="bu">range</span>(n))</span>
-<span id="cb8-127"><a href="#cb8-127" aria-hidden="true" tabindex="-1"></a>        <span class="op">+</span> <span class="bu">sum</span>(problem.transport[i][j] <span class="op">*</span> x[i, j] <span class="cf">for</span> i <span class="kw">in</span> <span class="bu">range</span>(n) <span class="cf">for</span> j <span class="kw">in</span> <span class="bu">range</span>(m)))</span>
-<span id="cb8-128"><a href="#cb8-128" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb8-129"><a href="#cb8-129" aria-hidden="true" tabindex="-1"></a>    loeser <span class="op">=</span> cp_model.CpSolver()</span>
-<span id="cb8-130"><a href="#cb8-130" aria-hidden="true" tabindex="-1"></a>    loeser.parameters.max_time_in_seconds <span class="op">=</span> ZEITLIMIT</span>
-<span id="cb8-131"><a href="#cb8-131" aria-hidden="true" tabindex="-1"></a>    loeser.parameters.num_workers <span class="op">=</span> <span class="dv">1</span></span>
-<span id="cb8-132"><a href="#cb8-132" aria-hidden="true" tabindex="-1"></a>    loeser.parameters.random_seed <span class="op">=</span> <span class="dv">1</span></span>
-<span id="cb8-133"><a href="#cb8-133" aria-hidden="true" tabindex="-1"></a>    status <span class="op">=</span> status_von_cpsat(loeser.Solve(modell))</span>
-<span id="cb8-134"><a href="#cb8-134" aria-hidden="true" tabindex="-1"></a>    <span class="cf">if</span> <span class="kw">not</span> status.brauchbar:</span>
-<span id="cb8-135"><a href="#cb8-135" aria-hidden="true" tabindex="-1"></a>        <span class="cf">return</span> Loesung(status<span class="op">=</span>status, laufzeit<span class="op">=</span>loeser.WallTime())</span>
-<span id="cb8-136"><a href="#cb8-136" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb8-137"><a href="#cb8-137" aria-hidden="true" tabindex="-1"></a>    <span class="cf">return</span> Loesung(</span>
-<span id="cb8-138"><a href="#cb8-138" aria-hidden="true" tabindex="-1"></a>        status<span class="op">=</span>status,</span>
-<span id="cb8-139"><a href="#cb8-139" aria-hidden="true" tabindex="-1"></a>        werte<span class="op">=</span>{problem.schluessel(i, j): <span class="bu">float</span>(loeser.Value(x[i, j]))</span>
-<span id="cb8-140"><a href="#cb8-140" aria-hidden="true" tabindex="-1"></a>               <span class="cf">for</span> i <span class="kw">in</span> <span class="bu">range</span>(n) <span class="cf">for</span> j <span class="kw">in</span> <span class="bu">range</span>(m)},</span>
-<span id="cb8-141"><a href="#cb8-141" aria-hidden="true" tabindex="-1"></a>        zielwert<span class="op">=</span>loeser.ObjectiveValue(),</span>
-<span id="cb8-142"><a href="#cb8-142" aria-hidden="true" tabindex="-1"></a>        schranke<span class="op">=</span>loeser.BestObjectiveBound(),</span>
-<span id="cb8-143"><a href="#cb8-143" aria-hidden="true" tabindex="-1"></a>        laufzeit<span class="op">=</span>loeser.WallTime())</span>
-<span id="cb8-144"><a href="#cb8-144" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb8-145"><a href="#cb8-145" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb8-146"><a href="#cb8-146" aria-hidden="true" tabindex="-1"></a><span class="kw">def</span> baue_und_loese_mit_highs(problem: Standortproblem) <span class="op">-&gt;</span> Loesung:</span>
-<span id="cb8-147"><a href="#cb8-147" aria-hidden="true" tabindex="-1"></a>    <span class="co">&quot;&quot;&quot;HiGHS: dieselben Restriktionen als Ungleichungszeilen einer Matrix.&quot;&quot;&quot;</span></span>
-<span id="cb8-148"><a href="#cb8-148" aria-hidden="true" tabindex="-1"></a>    <span class="im">import</span> highspy</span>
-<span id="cb8-149"><a href="#cb8-149" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb8-150"><a href="#cb8-150" aria-hidden="true" tabindex="-1"></a>    n, m <span class="op">=</span> <span class="bu">len</span>(problem.lager), <span class="bu">len</span>(problem.kunden)</span>
-<span id="cb8-151"><a href="#cb8-151" aria-hidden="true" tabindex="-1"></a>    anzahl_x <span class="op">=</span> n <span class="op">*</span> m                                     <span class="co"># Spalten 0..n*m-1</span></span>
-<span id="cb8-152"><a href="#cb8-152" aria-hidden="true" tabindex="-1"></a>    spalte_y <span class="op">=</span> <span class="kw">lambda</span> i: anzahl_x <span class="op">+</span> i                    <span class="co"># danach die y_i  # noqa: E731</span></span>
-<span id="cb8-153"><a href="#cb8-153" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb8-154"><a href="#cb8-154" aria-hidden="true" tabindex="-1"></a>    modell <span class="op">=</span> highspy.Highs()</span>
-<span id="cb8-155"><a href="#cb8-155" aria-hidden="true" tabindex="-1"></a>    modell.setOptionValue(<span class="st">&quot;output_flag&quot;</span>, <span class="va">False</span>)</span>
-<span id="cb8-156"><a href="#cb8-156" aria-hidden="true" tabindex="-1"></a>    modell.setOptionValue(<span class="st">&quot;time_limit&quot;</span>, ZEITLIMIT)</span>
-<span id="cb8-157"><a href="#cb8-157" aria-hidden="true" tabindex="-1"></a>    modell.addVars(anzahl_x <span class="op">+</span> n, np.zeros(anzahl_x <span class="op">+</span> n), np.ones(anzahl_x <span class="op">+</span> n))</span>
-<span id="cb8-158"><a href="#cb8-158" aria-hidden="true" tabindex="-1"></a>    <span class="cf">for</span> spalte <span class="kw">in</span> <span class="bu">range</span>(anzahl_x <span class="op">+</span> n):</span>
-<span id="cb8-159"><a href="#cb8-159" aria-hidden="true" tabindex="-1"></a>        modell.changeColIntegrality(spalte, highspy.HighsVarType.kInteger)</span>
-<span id="cb8-160"><a href="#cb8-160" aria-hidden="true" tabindex="-1"></a>    <span class="cf">for</span> i <span class="kw">in</span> <span class="bu">range</span>(n):</span>
-<span id="cb8-161"><a href="#cb8-161" aria-hidden="true" tabindex="-1"></a>        modell.changeColCost(spalte_y(i), <span class="bu">float</span>(problem.fixkosten[i]))</span>
-<span id="cb8-162"><a href="#cb8-162" aria-hidden="true" tabindex="-1"></a>        <span class="cf">for</span> j <span class="kw">in</span> <span class="bu">range</span>(m):</span>
-<span id="cb8-163"><a href="#cb8-163" aria-hidden="true" tabindex="-1"></a>            modell.changeColCost(i <span class="op">*</span> m <span class="op">+</span> j, <span class="bu">float</span>(problem.transport[i][j]))</span>
-<span id="cb8-164"><a href="#cb8-164" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb8-165"><a href="#cb8-165" aria-hidden="true" tabindex="-1"></a>    <span class="cf">for</span> j <span class="kw">in</span> <span class="bu">range</span>(m):                                   <span class="co"># jeder Kunde genau einmal</span></span>
-<span id="cb8-166"><a href="#cb8-166" aria-hidden="true" tabindex="-1"></a>        index <span class="op">=</span> np.array([i <span class="op">*</span> m <span class="op">+</span> j <span class="cf">for</span> i <span class="kw">in</span> <span class="bu">range</span>(n)], dtype<span class="op">=</span>np.int32)</span>
-<span id="cb8-167"><a href="#cb8-167" aria-hidden="true" tabindex="-1"></a>        modell.addRow(<span class="fl">1.0</span>, <span class="fl">1.0</span>, n, index, np.ones(n))</span>
-<span id="cb8-168"><a href="#cb8-168" aria-hidden="true" tabindex="-1"></a>    <span class="cf">for</span> i <span class="kw">in</span> <span class="bu">range</span>(n):</span>
-<span id="cb8-169"><a href="#cb8-169" aria-hidden="true" tabindex="-1"></a>        <span class="cf">for</span> j <span class="kw">in</span> <span class="bu">range</span>(m):                               <span class="co"># x_ij - y_i &lt;= 0</span></span>
-<span id="cb8-170"><a href="#cb8-170" aria-hidden="true" tabindex="-1"></a>            modell.addRow(<span class="op">-</span>highspy.kHighsInf, <span class="fl">0.0</span>, <span class="dv">2</span>,</span>
-<span id="cb8-171"><a href="#cb8-171" aria-hidden="true" tabindex="-1"></a>                          np.array([i <span class="op">*</span> m <span class="op">+</span> j, spalte_y(i)], dtype<span class="op">=</span>np.int32),</span>
-<span id="cb8-172"><a href="#cb8-172" aria-hidden="true" tabindex="-1"></a>                          np.array([<span class="fl">1.0</span>, <span class="op">-</span><span class="fl">1.0</span>]))</span>
-<span id="cb8-173"><a href="#cb8-173" aria-hidden="true" tabindex="-1"></a>        index <span class="op">=</span> np.array([i <span class="op">*</span> m <span class="op">+</span> j <span class="cf">for</span> j <span class="kw">in</span> <span class="bu">range</span>(m)] <span class="op">+</span> [spalte_y(i)],</span>
-<span id="cb8-174"><a href="#cb8-174" aria-hidden="true" tabindex="-1"></a>                         dtype<span class="op">=</span>np.int32)                 <span class="co"># Kapazitaet</span></span>
-<span id="cb8-175"><a href="#cb8-175" aria-hidden="true" tabindex="-1"></a>        werte <span class="op">=</span> np.concatenate([np.array(problem.bedarf, dtype<span class="op">=</span><span class="bu">float</span>),</span>
-<span id="cb8-176"><a href="#cb8-176" aria-hidden="true" tabindex="-1"></a>                                [<span class="op">-</span><span class="bu">float</span>(problem.kapazitaet[i])]])</span>
-<span id="cb8-177"><a href="#cb8-177" aria-hidden="true" tabindex="-1"></a>        modell.addRow(<span class="op">-</span>highspy.kHighsInf, <span class="fl">0.0</span>, m <span class="op">+</span> <span class="dv">1</span>, index, werte)</span>
-<span id="cb8-178"><a href="#cb8-178" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb8-179"><a href="#cb8-179" aria-hidden="true" tabindex="-1"></a>    t0 <span class="op">=</span> time.perf_counter()</span>
-<span id="cb8-180"><a href="#cb8-180" aria-hidden="true" tabindex="-1"></a>    modell.run()</span>
-<span id="cb8-181"><a href="#cb8-181" aria-hidden="true" tabindex="-1"></a>    laufzeit <span class="op">=</span> time.perf_counter() <span class="op">-</span> t0</span>
-<span id="cb8-182"><a href="#cb8-182" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb8-183"><a href="#cb8-183" aria-hidden="true" tabindex="-1"></a>    status <span class="op">=</span> status_von_highs(modell.modelStatusToString(modell.getModelStatus()))</span>
-<span id="cb8-184"><a href="#cb8-184" aria-hidden="true" tabindex="-1"></a>    <span class="cf">if</span> <span class="kw">not</span> status.brauchbar:</span>
-<span id="cb8-185"><a href="#cb8-185" aria-hidden="true" tabindex="-1"></a>        <span class="cf">return</span> Loesung(status<span class="op">=</span>status, laufzeit<span class="op">=</span>laufzeit)</span>
-<span id="cb8-186"><a href="#cb8-186" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb8-187"><a href="#cb8-187" aria-hidden="true" tabindex="-1"></a>    loesungswerte <span class="op">=</span> modell.getSolution().col_value</span>
-<span id="cb8-188"><a href="#cb8-188" aria-hidden="true" tabindex="-1"></a>    info <span class="op">=</span> modell.getInfo()</span>
-<span id="cb8-189"><a href="#cb8-189" aria-hidden="true" tabindex="-1"></a>    <span class="cf">return</span> Loesung(</span>
-<span id="cb8-190"><a href="#cb8-190" aria-hidden="true" tabindex="-1"></a>        status<span class="op">=</span>status,</span>
-<span id="cb8-191"><a href="#cb8-191" aria-hidden="true" tabindex="-1"></a>        werte<span class="op">=</span>{problem.schluessel(i, j): <span class="bu">float</span>(loesungswerte[i <span class="op">*</span> m <span class="op">+</span> j])</span>
-<span id="cb8-192"><a href="#cb8-192" aria-hidden="true" tabindex="-1"></a>               <span class="cf">for</span> i <span class="kw">in</span> <span class="bu">range</span>(n) <span class="cf">for</span> j <span class="kw">in</span> <span class="bu">range</span>(m)},</span>
-<span id="cb8-193"><a href="#cb8-193" aria-hidden="true" tabindex="-1"></a>        zielwert<span class="op">=</span>info.objective_function_value,</span>
-<span id="cb8-194"><a href="#cb8-194" aria-hidden="true" tabindex="-1"></a>        schranke<span class="op">=</span>info.mip_dual_bound,</span>
-<span id="cb8-195"><a href="#cb8-195" aria-hidden="true" tabindex="-1"></a>        laufzeit<span class="op">=</span>laufzeit)</span>
-<span id="cb8-196"><a href="#cb8-196" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb8-197"><a href="#cb8-197" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb8-198"><a href="#cb8-198" aria-hidden="true" tabindex="-1"></a>MODELLBAUER <span class="op">=</span> {<span class="st">&quot;cpsat&quot;</span>: baue_und_loese_mit_cpsat, <span class="st">&quot;highs&quot;</span>: baue_und_loese_mit_highs}</span>
-<span id="cb8-199"><a href="#cb8-199" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb8-200"><a href="#cb8-200" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb8-201"><a href="#cb8-201" aria-hidden="true" tabindex="-1"></a><span class="co"># --- 3. Alles Weitere ist wieder gemeinsam -----------------------------------</span></span>
-<span id="cb8-202"><a href="#cb8-202" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb8-203"><a href="#cb8-203" aria-hidden="true" tabindex="-1"></a><span class="kw">def</span> pruefe_zuordnung(problem: Standortproblem, loesung: Loesung,</span>
-<span id="cb8-204"><a href="#cb8-204" aria-hidden="true" tabindex="-1"></a>                     toleranz: <span class="bu">float</span> <span class="op">=</span> <span class="fl">1e-6</span>) <span class="op">-&gt;</span> <span class="bu">list</span>[<span class="bu">str</span>]:</span>
-<span id="cb8-205"><a href="#cb8-205" aria-hidden="true" tabindex="-1"></a>    <span class="co">&quot;&quot;&quot;Prueft die Loesung gegen die Anforderung - ohne Solver, ohne Modell.&quot;&quot;&quot;</span></span>
-<span id="cb8-206"><a href="#cb8-206" aria-hidden="true" tabindex="-1"></a>    <span class="cf">if</span> <span class="kw">not</span> loesung.status.brauchbar:</span>
-<span id="cb8-207"><a href="#cb8-207" aria-hidden="true" tabindex="-1"></a>        <span class="cf">return</span> [<span class="ss">f&quot;kein verwertbares Ergebnis (</span><span class="sc">{</span>loesung<span class="sc">.</span>status<span class="sc">.</span>value<span class="sc">}</span><span class="ss">)&quot;</span>]</span>
-<span id="cb8-208"><a href="#cb8-208" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb8-209"><a href="#cb8-209" aria-hidden="true" tabindex="-1"></a>    n, m <span class="op">=</span> <span class="bu">len</span>(problem.lager), <span class="bu">len</span>(problem.kunden)</span>
-<span id="cb8-210"><a href="#cb8-210" aria-hidden="true" tabindex="-1"></a>    zuordnung <span class="op">=</span> np.array([[loesung.werte[problem.schluessel(i, j)]</span>
-<span id="cb8-211"><a href="#cb8-211" aria-hidden="true" tabindex="-1"></a>                           <span class="cf">for</span> j <span class="kw">in</span> <span class="bu">range</span>(m)] <span class="cf">for</span> i <span class="kw">in</span> <span class="bu">range</span>(n)])</span>
-<span id="cb8-212"><a href="#cb8-212" aria-hidden="true" tabindex="-1"></a>    beanstandungen: <span class="bu">list</span>[<span class="bu">str</span>] <span class="op">=</span> []</span>
-<span id="cb8-213"><a href="#cb8-213" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb8-214"><a href="#cb8-214" aria-hidden="true" tabindex="-1"></a>    <span class="cf">if</span> (np.<span class="bu">abs</span>(zuordnung <span class="op">-</span> np.<span class="bu">round</span>(zuordnung)) <span class="op">&gt;</span> toleranz).<span class="bu">any</span>():</span>
-<span id="cb8-215"><a href="#cb8-215" aria-hidden="true" tabindex="-1"></a>        beanstandungen.append(<span class="st">&quot;Zuordnungen sind nicht 0/1&quot;</span>)</span>
-<span id="cb8-216"><a href="#cb8-216" aria-hidden="true" tabindex="-1"></a>    zuordnung <span class="op">=</span> np.<span class="bu">round</span>(zuordnung)</span>
-<span id="cb8-217"><a href="#cb8-217" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb8-218"><a href="#cb8-218" aria-hidden="true" tabindex="-1"></a>    <span class="cf">for</span> j, kunde <span class="kw">in</span> <span class="bu">enumerate</span>(problem.kunden):</span>
-<span id="cb8-219"><a href="#cb8-219" aria-hidden="true" tabindex="-1"></a>        <span class="cf">if</span> <span class="bu">abs</span>(zuordnung[:, j].<span class="bu">sum</span>() <span class="op">-</span> <span class="fl">1.0</span>) <span class="op">&gt;</span> toleranz:</span>
-<span id="cb8-220"><a href="#cb8-220" aria-hidden="true" tabindex="-1"></a>            beanstandungen.append(<span class="ss">f&quot;</span><span class="sc">{</span>kunde<span class="sc">}</span><span class="ss"> wird </span><span class="sc">{</span>zuordnung[:, j]<span class="sc">.</span><span class="bu">sum</span>()<span class="sc">:.0f}</span><span class="ss">-mal beliefert&quot;</span>)</span>
-<span id="cb8-221"><a href="#cb8-221" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb8-222"><a href="#cb8-222" aria-hidden="true" tabindex="-1"></a>    beliefert <span class="op">=</span> zuordnung <span class="op">@</span> np.array(problem.bedarf, dtype<span class="op">=</span><span class="bu">float</span>)</span>
-<span id="cb8-223"><a href="#cb8-223" aria-hidden="true" tabindex="-1"></a>    <span class="cf">for</span> i, lagername <span class="kw">in</span> <span class="bu">enumerate</span>(problem.lager):</span>
-<span id="cb8-224"><a href="#cb8-224" aria-hidden="true" tabindex="-1"></a>        <span class="cf">if</span> beliefert[i] <span class="op">&gt;</span> problem.kapazitaet[i] <span class="op">+</span> toleranz:</span>
-<span id="cb8-225"><a href="#cb8-225" aria-hidden="true" tabindex="-1"></a>            beanstandungen.append(<span class="ss">f&quot;</span><span class="sc">{</span>lagername<span class="sc">}</span><span class="ss">: </span><span class="sc">{</span>beliefert[i]<span class="sc">:.0f}</span><span class="ss"> Paletten ueber &quot;</span></span>
-<span id="cb8-226"><a href="#cb8-226" aria-hidden="true" tabindex="-1"></a>                                  <span class="ss">f&quot;Kapazitaet </span><span class="sc">{</span>problem<span class="sc">.</span>kapazitaet[i]<span class="sc">}</span><span class="ss">&quot;</span>)</span>
-<span id="cb8-227"><a href="#cb8-227" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb8-228"><a href="#cb8-228" aria-hidden="true" tabindex="-1"></a>    <span class="cf">if</span> loesung.zielwert <span class="kw">is</span> <span class="kw">not</span> <span class="va">None</span>:</span>
-<span id="cb8-229"><a href="#cb8-229" aria-hidden="true" tabindex="-1"></a>        offen <span class="op">=</span> beliefert <span class="op">&gt;</span> toleranz</span>
-<span id="cb8-230"><a href="#cb8-230" aria-hidden="true" tabindex="-1"></a>        nachgerechnet <span class="op">=</span> (np.array(problem.fixkosten, dtype<span class="op">=</span><span class="bu">float</span>) <span class="op">@</span> offen</span>
-<span id="cb8-231"><a href="#cb8-231" aria-hidden="true" tabindex="-1"></a>                         <span class="op">+</span> (np.array(problem.transport, dtype<span class="op">=</span><span class="bu">float</span>) <span class="op">*</span> zuordnung).<span class="bu">sum</span>())</span>
-<span id="cb8-232"><a href="#cb8-232" aria-hidden="true" tabindex="-1"></a>        <span class="cf">if</span> <span class="bu">abs</span>(nachgerechnet <span class="op">-</span> loesung.zielwert) <span class="op">&gt;</span> <span class="fl">0.5</span>:</span>
-<span id="cb8-233"><a href="#cb8-233" aria-hidden="true" tabindex="-1"></a>            beanstandungen.append(<span class="ss">f&quot;Zielwert </span><span class="sc">{</span>loesung<span class="sc">.</span>zielwert<span class="sc">:,.0f}</span><span class="ss"> passt nicht zur &quot;</span></span>
-<span id="cb8-234"><a href="#cb8-234" aria-hidden="true" tabindex="-1"></a>                                  <span class="ss">f&quot;Zuordnung (nachgerechnet </span><span class="sc">{</span>nachgerechnet<span class="sc">:,.0f}</span><span class="ss">)&quot;</span>)</span>
-<span id="cb8-235"><a href="#cb8-235" aria-hidden="true" tabindex="-1"></a>    <span class="cf">return</span> beanstandungen</span>
-<span id="cb8-236"><a href="#cb8-236" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb8-237"><a href="#cb8-237" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb8-238"><a href="#cb8-238" aria-hidden="true" tabindex="-1"></a><span class="kw">def</span> geoeffnete_lager(problem: Standortproblem, loesung: Loesung) <span class="op">-&gt;</span> <span class="bu">list</span>[<span class="bu">str</span>]:</span>
-<span id="cb8-239"><a href="#cb8-239" aria-hidden="true" tabindex="-1"></a>    m <span class="op">=</span> <span class="bu">len</span>(problem.kunden)</span>
-<span id="cb8-240"><a href="#cb8-240" aria-hidden="true" tabindex="-1"></a>    <span class="cf">return</span> [name <span class="cf">for</span> i, name <span class="kw">in</span> <span class="bu">enumerate</span>(problem.lager)</span>
-<span id="cb8-241"><a href="#cb8-241" aria-hidden="true" tabindex="-1"></a>            <span class="cf">if</span> <span class="bu">any</span>(loesung.werte[problem.schluessel(i, j)] <span class="op">&gt;</span> <span class="fl">0.5</span> <span class="cf">for</span> j <span class="kw">in</span> <span class="bu">range</span>(m))]</span>
-<span id="cb8-242"><a href="#cb8-242" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb8-243"><a href="#cb8-243" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb8-244"><a href="#cb8-244" aria-hidden="true" tabindex="-1"></a><span class="kw">def</span> loese_in_eigenem_prozess(name: <span class="bu">str</span>) <span class="op">-&gt;</span> Loesung:</span>
-<span id="cb8-245"><a href="#cb8-245" aria-hidden="true" tabindex="-1"></a>    <span class="co">&quot;&quot;&quot;Startet dieses Programm noch einmal - mit genau einem Solverimport.&quot;&quot;&quot;</span></span>
-<span id="cb8-246"><a href="#cb8-246" aria-hidden="true" tabindex="-1"></a>    ergebnis <span class="op">=</span> subprocess.run([sys.executable, <span class="va">__file__</span>, name],</span>
-<span id="cb8-247"><a href="#cb8-247" aria-hidden="true" tabindex="-1"></a>                              capture_output<span class="op">=</span><span class="va">True</span>, text<span class="op">=</span><span class="va">True</span>, timeout<span class="op">=</span><span class="dv">300</span>)</span>
-<span id="cb8-248"><a href="#cb8-248" aria-hidden="true" tabindex="-1"></a>    <span class="cf">if</span> ergebnis.returncode <span class="op">!=</span> <span class="dv">0</span>:</span>
-<span id="cb8-249"><a href="#cb8-249" aria-hidden="true" tabindex="-1"></a>        <span class="cf">raise</span> <span class="pp">RuntimeError</span>(ergebnis.stderr.strip().splitlines()[<span class="op">-</span><span class="dv">1</span>])</span>
-<span id="cb8-250"><a href="#cb8-250" aria-hidden="true" tabindex="-1"></a>    <span class="co"># Das DTO als JSON - genau dafuer ist ein Datenobjekt ohne Solverbezug gut.</span></span>
-<span id="cb8-251"><a href="#cb8-251" aria-hidden="true" tabindex="-1"></a>    <span class="cf">return</span> Loesung.model_validate_json(ergebnis.stdout.strip().splitlines()[<span class="op">-</span><span class="dv">1</span>])</span>
-<span id="cb8-252"><a href="#cb8-252" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb8-253"><a href="#cb8-253" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb8-254"><a href="#cb8-254" aria-hidden="true" tabindex="-1"></a><span class="cf">if</span> <span class="va">__name__</span> <span class="op">==</span> <span class="st">&quot;__main__&quot;</span>:</span>
-<span id="cb8-255"><a href="#cb8-255" aria-hidden="true" tabindex="-1"></a>    problem <span class="op">=</span> beispielproblem()</span>
-<span id="cb8-256"><a href="#cb8-256" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb8-257"><a href="#cb8-257" aria-hidden="true" tabindex="-1"></a>    <span class="co"># --- Kindprozess: rechnen und das DTO als JSON ausgeben ---------------</span></span>
-<span id="cb8-258"><a href="#cb8-258" aria-hidden="true" tabindex="-1"></a>    <span class="cf">if</span> <span class="bu">len</span>(sys.argv) <span class="op">&gt;</span> <span class="dv">1</span>:</span>
-<span id="cb8-259"><a href="#cb8-259" aria-hidden="true" tabindex="-1"></a>        <span class="bu">print</span>(MODELLBAUER[sys.argv[<span class="dv">1</span>]](problem).model_dump_json())</span>
-<span id="cb8-260"><a href="#cb8-260" aria-hidden="true" tabindex="-1"></a>        sys.exit(<span class="dv">0</span>)</span>
-<span id="cb8-261"><a href="#cb8-261" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb8-262"><a href="#cb8-262" aria-hidden="true" tabindex="-1"></a>    <span class="co"># --- Hauptprozess: beide Solver anstossen und vergleichen -------------</span></span>
-<span id="cb8-263"><a href="#cb8-263" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;=&quot;</span> <span class="op">*</span> <span class="dv">82</span>)</span>
-<span id="cb8-264"><a href="#cb8-264" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;  DERSELBE FALL, ZWEI SOLVER - UND EIN AUSWERTUNGSCODE&quot;</span>)</span>
-<span id="cb8-265"><a href="#cb8-265" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;=&quot;</span> <span class="op">*</span> <span class="dv">82</span>)</span>
-<span id="cb8-266"><a href="#cb8-266" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;Standortplanung: </span><span class="sc">{</span><span class="bu">len</span>(problem.lager)<span class="sc">}</span><span class="ss"> moegliche Lager, &quot;</span></span>
-<span id="cb8-267"><a href="#cb8-267" aria-hidden="true" tabindex="-1"></a>          <span class="ss">f&quot;</span><span class="sc">{</span><span class="bu">len</span>(problem.kunden)<span class="sc">}</span><span class="ss"> Kunden, </span><span class="sc">{</span><span class="bu">sum</span>(problem.bedarf)<span class="sc">}</span><span class="ss"> Paletten Bedarf.&quot;</span>)</span>
-<span id="cb8-268"><a href="#cb8-268" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;Kapazitaet je Lager: </span><span class="sc">{</span>problem<span class="sc">.</span>kapazitaet[<span class="dv">0</span>]<span class="sc">}</span><span class="ss"> Paletten &quot;</span></span>
-<span id="cb8-269"><a href="#cb8-269" aria-hidden="true" tabindex="-1"></a>          <span class="ss">f&quot;-&gt; mindestens 3 Lager noetig.</span><span class="ch">\n</span><span class="ss">&quot;</span>)</span>
-<span id="cb8-270"><a href="#cb8-270" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb8-271"><a href="#cb8-271" aria-hidden="true" tabindex="-1"></a>    loesungen: <span class="bu">dict</span>[<span class="bu">str</span>, Loesung] <span class="op">=</span> {}</span>
-<span id="cb8-272"><a href="#cb8-272" aria-hidden="true" tabindex="-1"></a>    <span class="cf">for</span> name, beschriftung <span class="kw">in</span> [(<span class="st">&quot;cpsat&quot;</span>, <span class="st">&quot;OR-Tools CP-SAT&quot;</span>),</span>
-<span id="cb8-273"><a href="#cb8-273" aria-hidden="true" tabindex="-1"></a>                               (<span class="st">&quot;highs&quot;</span>, <span class="st">&quot;HiGHS (highspy)&quot;</span>)]:</span>
-<span id="cb8-274"><a href="#cb8-274" aria-hidden="true" tabindex="-1"></a>        loesung <span class="op">=</span> loesungen[name] <span class="op">=</span> loese_in_eigenem_prozess(name)</span>
-<span id="cb8-275"><a href="#cb8-275" aria-hidden="true" tabindex="-1"></a>        beanstandungen <span class="op">=</span> pruefe_zuordnung(problem, loesung)</span>
-<span id="cb8-276"><a href="#cb8-276" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb8-277"><a href="#cb8-277" aria-hidden="true" tabindex="-1"></a>        <span class="bu">print</span>(<span class="ss">f&quot;</span><span class="sc">{</span>beschriftung<span class="sc">}</span><span class="ss">&quot;</span>)</span>
-<span id="cb8-278"><a href="#cb8-278" aria-hidden="true" tabindex="-1"></a>        <span class="bu">print</span>(<span class="ss">f&quot;  </span><span class="sc">{</span>loesung<span class="sc">.</span>als_bericht()<span class="sc">}</span><span class="ss">&quot;</span>)</span>
-<span id="cb8-279"><a href="#cb8-279" aria-hidden="true" tabindex="-1"></a>        <span class="bu">print</span>(<span class="ss">f&quot;  eroeffnete Lager: </span><span class="sc">{</span><span class="st">&#39;, &#39;</span><span class="sc">.</span>join(geoeffnete_lager(problem, loesung))<span class="sc">}</span><span class="ss">&quot;</span>)</span>
-<span id="cb8-280"><a href="#cb8-280" aria-hidden="true" tabindex="-1"></a>        <span class="bu">print</span>(<span class="ss">f&quot;  Abnahmepruefung:  &quot;</span></span>
-<span id="cb8-281"><a href="#cb8-281" aria-hidden="true" tabindex="-1"></a>              <span class="ss">f&quot;</span><span class="sc">{</span><span class="st">&#39;bestanden&#39;</span> <span class="cf">if</span> <span class="kw">not</span> beanstandungen <span class="cf">else</span> beanstandungen<span class="sc">}</span><span class="ss">&quot;</span>)</span>
-<span id="cb8-282"><a href="#cb8-282" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb8-283"><a href="#cb8-283" aria-hidden="true" tabindex="-1"></a>    <span class="co"># --- Was der Vergleich zeigt -----------------------------------------</span></span>
-<span id="cb8-284"><a href="#cb8-284" aria-hidden="true" tabindex="-1"></a>    zielwerte <span class="op">=</span> [loesung.zielwert <span class="cf">for</span> loesung <span class="kw">in</span> loesungen.values()]</span>
-<span id="cb8-285"><a href="#cb8-285" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;-&quot;</span> <span class="op">*</span> <span class="dv">82</span>)</span>
-<span id="cb8-286"><a href="#cb8-286" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;Zielwertdifferenz: </span><span class="sc">{</span><span class="bu">abs</span>(zielwerte[<span class="dv">0</span>] <span class="op">-</span> zielwerte[<span class="dv">1</span>])<span class="sc">:.6f}</span><span class="ss"> EUR&quot;</span>)</span>
-<span id="cb8-287"><a href="#cb8-287" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb8-288"><a href="#cb8-288" aria-hidden="true" tabindex="-1"></a>    gleich_belegt <span class="op">=</span> <span class="bu">all</span>(</span>
-<span id="cb8-289"><a href="#cb8-289" aria-hidden="true" tabindex="-1"></a>        <span class="bu">round</span>(loesungen[<span class="st">&quot;cpsat&quot;</span>].werte[s]) <span class="op">==</span> <span class="bu">round</span>(loesungen[<span class="st">&quot;highs&quot;</span>].werte[s])</span>
-<span id="cb8-290"><a href="#cb8-290" aria-hidden="true" tabindex="-1"></a>        <span class="cf">for</span> s <span class="kw">in</span> loesungen[<span class="st">&quot;cpsat&quot;</span>].werte)</span>
-<span id="cb8-291"><a href="#cb8-291" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;Identische Zuordnung: </span><span class="sc">{</span><span class="st">&#39;ja&#39;</span> <span class="cf">if</span> gleich_belegt <span class="cf">else</span> <span class="st">&#39;nein&#39;</span><span class="sc">}</span><span class="ss">&quot;</span>)</span>
-<span id="cb8-292"><a href="#cb8-292" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb8-293"><a href="#cb8-293" aria-hidden="true" tabindex="-1"></a>    <span class="cf">assert</span> <span class="bu">abs</span>(zielwerte[<span class="dv">0</span>] <span class="op">-</span> zielwerte[<span class="dv">1</span>]) <span class="op">&lt;</span> <span class="fl">0.5</span>, <span class="st">&quot;Die Solver widersprechen sich!&quot;</span></span>
-<span id="cb8-294"><a href="#cb8-294" aria-hidden="true" tabindex="-1"></a>    <span class="cf">assert</span> <span class="bu">all</span>(l.status <span class="kw">is</span> SolverStatus.OPTIMAL <span class="cf">for</span> l <span class="kw">in</span> loesungen.values())</span>
-<span id="cb8-295"><a href="#cb8-295" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb8-296"><a href="#cb8-296" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;</span><span class="ch">\n</span><span class="st">&quot;</span> <span class="op">+</span> <span class="st">&quot;=&quot;</span> <span class="op">*</span> <span class="dv">82</span>)</span>
-<span id="cb8-297"><a href="#cb8-297" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;  WAS DER WECHSEL GEKOSTET HAT&quot;</span>)</span>
-<span id="cb8-298"><a href="#cb8-298" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;=&quot;</span> <span class="op">*</span> <span class="dv">82</span>)</span>
-<span id="cb8-299"><a href="#cb8-299" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;Ausgetauscht wurde EINE Funktion. Domaenenmodell, Abnahmepruefung und&quot;</span>)</span>
-<span id="cb8-300"><a href="#cb8-300" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;Bericht sind woertlich dieselben - sie sehen den Solver nie.&quot;</span>)</span>
-<span id="cb8-301"><a href="#cb8-301" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>()</span>
-<span id="cb8-302"><a href="#cb8-302" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;Nicht umsonst ist der Wechsel trotzdem:&quot;</span>)</span>
-<span id="cb8-303"><a href="#cb8-303" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;  * CP-SAT rechnet ausschliesslich GANZZAHLIG. Alle Kosten sind hier&quot;</span>)</span>
-<span id="cb8-304"><a href="#cb8-304" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;    deshalb int. Wer in Euro und Cent rechnet, skaliert vorher auf Cent -&quot;</span>)</span>
-<span id="cb8-305"><a href="#cb8-305" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;    und muss das im Bericht wieder zuruecknehmen.&quot;</span>)</span>
-<span id="cb8-306"><a href="#cb8-306" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;  * HiGHS braucht die Restriktionen als Matrixzeilen, CP-SAT nimmt sie&quot;</span>)</span>
-<span id="cb8-307"><a href="#cb8-307" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;    als Ausdruecke. Das ist der Grund, warum der HiGHS-Modellbauer&quot;</span>)</span>
-<span id="cb8-308"><a href="#cb8-308" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;    laenger ist, obwohl er dasselbe Modell beschreibt.&quot;</span>)</span>
-<span id="cb8-309"><a href="#cb8-309" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;  * Beide Bibliotheken bringen eine eigene HiGHS-Kopie mit und lassen&quot;</span>)</span>
-<span id="cb8-310"><a href="#cb8-310" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;    sich nicht gemeinsam importieren - daher die zwei Prozesse.&quot;</span>)</span>
-<span id="cb8-311"><a href="#cb8-311" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>()</span>
-<span id="cb8-312"><a href="#cb8-312" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;Der Ertrag: Beide beweisen denselben optimalen Zielwert, und die&quot;</span>)</span>
-<span id="cb8-313"><a href="#cb8-313" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;Entscheidung zwischen ihnen ist eine Frage der Laufzeit geworden -&quot;</span>)</span>
-<span id="cb8-314"><a href="#cb8-314" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;nicht eine Frage, wie viel Code man neu schreiben muss.&quot;</span>)</span>
-<span id="cb8-315"><a href="#cb8-315" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>()</span>
-<span id="cb8-316"><a href="#cb8-316" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;Verglichen wird deshalb der ZIELWERT, nicht der Plan: Gibt es mehrere&quot;</span>)</span>
-<span id="cb8-317"><a href="#cb8-317" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;gleich teure Loesungen, darf jeder Solver eine andere davon liefern.&quot;</span>)</span>
-<span id="cb8-318"><a href="#cb8-318" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;Hier stimmen sie zufaellig ueberein - darauf zu testen waere trotzdem&quot;</span>)</span>
-<span id="cb8-319"><a href="#cb8-319" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;ein unzuverlaessiger Test (siehe JobShop_Intervalle.py).&quot;</span>)</span>
-<span id="cb8-320"><a href="#cb8-320" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;=&quot;</span> <span class="op">*</span> <span class="dv">82</span>)</span></code></pre></div>
+<div class="sourceCode" id="cb10"><pre class="sourceCode python"><code class="sourceCode python"><span id="cb10-1"><a href="#cb10-1" aria-hidden="true" tabindex="-1"></a><span class="co">#!/usr/bin/env python3</span></span>
+<span id="cb10-2"><a href="#cb10-2" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb10-3"><a href="#cb10-3" aria-hidden="true" tabindex="-1"></a><span class="co"># Solverwechsel_CPSAT_HiGHS.py</span></span>
+<span id="cb10-4"><a href="#cb10-4" aria-hidden="true" tabindex="-1"></a><span class="co">&quot;&quot;&quot;</span></span>
+<span id="cb10-5"><a href="#cb10-5" aria-hidden="true" tabindex="-1"></a><span class="co">Kapitel Praxisfallen: Denselben Fall einmal mit CP-SAT und einmal mit HiGHS rechnen.</span></span>
+<span id="cb10-6"><a href="#cb10-6" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb10-7"><a href="#cb10-7" aria-hidden="true" tabindex="-1"></a><span class="co">Die Trennung aus or_kern.py behauptet, ein Solverwechsel koste genau EINEN</span></span>
+<span id="cb10-8"><a href="#cb10-8" aria-hidden="true" tabindex="-1"></a><span class="co">Baustein. Dieses Programm loest diese Behauptung ein. Aufgabe ist eine</span></span>
+<span id="cb10-9"><a href="#cb10-9" aria-hidden="true" tabindex="-1"></a><span class="co">Standortplanung: Welche Lager oeffnen wir, und wer beliefert welchen Kunden?</span></span>
+<span id="cb10-10"><a href="#cb10-10" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb10-11"><a href="#cb10-11" aria-hidden="true" tabindex="-1"></a><span class="co">    Standortproblem  (Pydantic, geprueft)   &lt;- gemeinsam</span></span>
+<span id="cb10-12"><a href="#cb10-12" aria-hidden="true" tabindex="-1"></a><span class="co">        baue_und_loese_mit_cpsat()          &lt;- der EINE Baustein</span></span>
+<span id="cb10-13"><a href="#cb10-13" aria-hidden="true" tabindex="-1"></a><span class="co">        baue_und_loese_mit_highs()          &lt;- ... in zwei Ausfuehrungen</span></span>
+<span id="cb10-14"><a href="#cb10-14" aria-hidden="true" tabindex="-1"></a><span class="co">    Loesung          (DTO)                  &lt;- gemeinsam</span></span>
+<span id="cb10-15"><a href="#cb10-15" aria-hidden="true" tabindex="-1"></a><span class="co">    pruefe_zuordnung()                      &lt;- gemeinsam</span></span>
+<span id="cb10-16"><a href="#cb10-16" aria-hidden="true" tabindex="-1"></a><span class="co">    berichte()                              &lt;- gemeinsam</span></span>
+<span id="cb10-17"><a href="#cb10-17" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb10-18"><a href="#cb10-18" aria-hidden="true" tabindex="-1"></a><span class="co">Die beiden Modellbauer sind 39 und 52 Zeilen lang - sie sind der gesamte</span></span>
+<span id="cb10-19"><a href="#cb10-19" aria-hidden="true" tabindex="-1"></a><span class="co">solverabhaengige Teil des Programms. Alles andere wird zweimal benutzt und</span></span>
+<span id="cb10-20"><a href="#cb10-20" aria-hidden="true" tabindex="-1"></a><span class="co">einmal geschrieben.</span></span>
+<span id="cb10-21"><a href="#cb10-21" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb10-22"><a href="#cb10-22" aria-hidden="true" tabindex="-1"></a><span class="co">WARUM ZWEI PROZESSE? ortools und highspy bringen beide eine eigene</span></span>
+<span id="cb10-23"><a href="#cb10-23" aria-hidden="true" tabindex="-1"></a><span class="co">HiGHS-Kopie mit und lassen sich auf vielen Systemen nicht gemeinsam</span></span>
+<span id="cb10-24"><a href="#cb10-24" aria-hidden="true" tabindex="-1"></a><span class="co">importieren (Kapitel Oekosystem). Das Hauptprogramm startet deshalb fuer jeden</span></span>
+<span id="cb10-25"><a href="#cb10-25" aria-hidden="true" tabindex="-1"></a><span class="co">Solver einen eigenen Python-Prozess und laesst sich die Loesung als JSON</span></span>
+<span id="cb10-26"><a href="#cb10-26" aria-hidden="true" tabindex="-1"></a><span class="co">zurueckgeben - das DTO ist nicht nur eine Sprachregelung, sondern ein</span></span>
+<span id="cb10-27"><a href="#cb10-27" aria-hidden="true" tabindex="-1"></a><span class="co">Datenformat, das eine Prozessgrenze ueberlebt.</span></span>
+<span id="cb10-28"><a href="#cb10-28" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb10-29"><a href="#cb10-29" aria-hidden="true" tabindex="-1"></a><span class="co">Aufruf:</span></span>
+<span id="cb10-30"><a href="#cb10-30" aria-hidden="true" tabindex="-1"></a><span class="co">    python3 Solverwechsel_CPSAT_HiGHS.py            # beide, mit Vergleich</span></span>
+<span id="cb10-31"><a href="#cb10-31" aria-hidden="true" tabindex="-1"></a><span class="co">    python3 Solverwechsel_CPSAT_HiGHS.py cpsat      # nur der Kindprozess</span></span>
+<span id="cb10-32"><a href="#cb10-32" aria-hidden="true" tabindex="-1"></a><span class="co">    python3 Solverwechsel_CPSAT_HiGHS.py highs</span></span>
+<span id="cb10-33"><a href="#cb10-33" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb10-34"><a href="#cb10-34" aria-hidden="true" tabindex="-1"></a><span class="co">Benoetigt: numpy, pydantic, ortools, highspy (jeweils im eigenen Prozess)</span></span>
+<span id="cb10-35"><a href="#cb10-35" aria-hidden="true" tabindex="-1"></a><span class="co">&quot;&quot;&quot;</span></span>
+<span id="cb10-36"><a href="#cb10-36" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb10-37"><a href="#cb10-37" aria-hidden="true" tabindex="-1"></a><span class="im">from</span> __future__ <span class="im">import</span> annotations</span>
+<span id="cb10-38"><a href="#cb10-38" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb10-39"><a href="#cb10-39" aria-hidden="true" tabindex="-1"></a><span class="im">import</span> multiprocessing</span>
+<span id="cb10-40"><a href="#cb10-40" aria-hidden="true" tabindex="-1"></a><span class="im">import</span> time</span>
+<span id="cb10-41"><a href="#cb10-41" aria-hidden="true" tabindex="-1"></a><span class="im">from</span> concurrent.futures <span class="im">import</span> ProcessPoolExecutor</span>
+<span id="cb10-42"><a href="#cb10-42" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb10-43"><a href="#cb10-43" aria-hidden="true" tabindex="-1"></a><span class="im">import</span> numpy <span class="im">as</span> np</span>
+<span id="cb10-44"><a href="#cb10-44" aria-hidden="true" tabindex="-1"></a><span class="im">from</span> pydantic <span class="im">import</span> BaseModel, Field, model_validator</span>
+<span id="cb10-45"><a href="#cb10-45" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb10-46"><a href="#cb10-46" aria-hidden="true" tabindex="-1"></a><span class="im">from</span> or_kern <span class="im">import</span> Loesung, SolverStatus, status_von_cpsat, status_von_highs</span>
+<span id="cb10-47"><a href="#cb10-47" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb10-48"><a href="#cb10-48" aria-hidden="true" tabindex="-1"></a>ZEITLIMIT <span class="op">=</span> <span class="fl">30.0</span></span>
+<span id="cb10-49"><a href="#cb10-49" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb10-50"><a href="#cb10-50" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb10-51"><a href="#cb10-51" aria-hidden="true" tabindex="-1"></a><span class="co"># --- 1. Domaenenmodell: dieselben Fakten fuer beide Solver -------------------</span></span>
+<span id="cb10-52"><a href="#cb10-52" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb10-53"><a href="#cb10-53" aria-hidden="true" tabindex="-1"></a><span class="kw">class</span> Standortproblem(BaseModel):</span>
+<span id="cb10-54"><a href="#cb10-54" aria-hidden="true" tabindex="-1"></a>    <span class="co">&quot;&quot;&quot;Kapazitierte Standortplanung mit Einzelbelieferung.</span></span>
+<span id="cb10-55"><a href="#cb10-55" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb10-56"><a href="#cb10-56" aria-hidden="true" tabindex="-1"></a><span class="co">    Nach dem Muster von Produktionsproblem in or_kern.py: Die Pruefungen</span></span>
+<span id="cb10-57"><a href="#cb10-57" aria-hidden="true" tabindex="-1"></a><span class="co">    stehen im Konstruktor, nicht im Solvercode - sie gelten damit fuer beide</span></span>
+<span id="cb10-58"><a href="#cb10-58" aria-hidden="true" tabindex="-1"></a><span class="co">    Solver, und sie schlagen beim Einlesen zu.</span></span>
+<span id="cb10-59"><a href="#cb10-59" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb10-60"><a href="#cb10-60" aria-hidden="true" tabindex="-1"></a><span class="co">    Alle Kosten sind ganzzahlig (Euro). Das ist keine Bequemlichkeit, sondern</span></span>
+<span id="cb10-61"><a href="#cb10-61" aria-hidden="true" tabindex="-1"></a><span class="co">    Voraussetzung: CP-SAT rechnet ausschliesslich ganzzahlig.</span></span>
+<span id="cb10-62"><a href="#cb10-62" aria-hidden="true" tabindex="-1"></a><span class="co">    &quot;&quot;&quot;</span></span>
+<span id="cb10-63"><a href="#cb10-63" aria-hidden="true" tabindex="-1"></a>    lager: <span class="bu">list</span>[<span class="bu">str</span>] <span class="op">=</span> Field(min_length<span class="op">=</span><span class="dv">1</span>)</span>
+<span id="cb10-64"><a href="#cb10-64" aria-hidden="true" tabindex="-1"></a>    kunden: <span class="bu">list</span>[<span class="bu">str</span>] <span class="op">=</span> Field(min_length<span class="op">=</span><span class="dv">1</span>)</span>
+<span id="cb10-65"><a href="#cb10-65" aria-hidden="true" tabindex="-1"></a>    fixkosten: <span class="bu">list</span>[<span class="bu">int</span>]        <span class="co"># je Lager, faellt bei Eroeffnung an</span></span>
+<span id="cb10-66"><a href="#cb10-66" aria-hidden="true" tabindex="-1"></a>    kapazitaet: <span class="bu">list</span>[<span class="bu">int</span>]       <span class="co"># je Lager, in Paletten</span></span>
+<span id="cb10-67"><a href="#cb10-67" aria-hidden="true" tabindex="-1"></a>    bedarf: <span class="bu">list</span>[<span class="bu">int</span>]           <span class="co"># je Kunde, in Paletten</span></span>
+<span id="cb10-68"><a href="#cb10-68" aria-hidden="true" tabindex="-1"></a>    transport: <span class="bu">list</span>[<span class="bu">list</span>[<span class="bu">int</span>]]  <span class="co"># [Lager][Kunde], Kosten der Belieferung</span></span>
+<span id="cb10-69"><a href="#cb10-69" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb10-70"><a href="#cb10-70" aria-hidden="true" tabindex="-1"></a>    <span class="at">@model_validator</span>(mode<span class="op">=</span><span class="st">&quot;after&quot;</span>)</span>
+<span id="cb10-71"><a href="#cb10-71" aria-hidden="true" tabindex="-1"></a>    <span class="kw">def</span> pruefe_masse(<span class="va">self</span>) <span class="op">-&gt;</span> <span class="st">&quot;Standortproblem&quot;</span>:</span>
+<span id="cb10-72"><a href="#cb10-72" aria-hidden="true" tabindex="-1"></a>        n, m <span class="op">=</span> <span class="bu">len</span>(<span class="va">self</span>.lager), <span class="bu">len</span>(<span class="va">self</span>.kunden)</span>
+<span id="cb10-73"><a href="#cb10-73" aria-hidden="true" tabindex="-1"></a>        <span class="cf">if</span> <span class="bu">len</span>(<span class="va">self</span>.fixkosten) <span class="op">!=</span> n <span class="kw">or</span> <span class="bu">len</span>(<span class="va">self</span>.kapazitaet) <span class="op">!=</span> n:</span>
+<span id="cb10-74"><a href="#cb10-74" aria-hidden="true" tabindex="-1"></a>            <span class="cf">raise</span> <span class="pp">ValueError</span>(<span class="ss">f&quot;fixkosten/kapazitaet muessen </span><span class="sc">{</span>n<span class="sc">}</span><span class="ss"> Eintraege haben&quot;</span>)</span>
+<span id="cb10-75"><a href="#cb10-75" aria-hidden="true" tabindex="-1"></a>        <span class="cf">if</span> <span class="bu">len</span>(<span class="va">self</span>.bedarf) <span class="op">!=</span> m:</span>
+<span id="cb10-76"><a href="#cb10-76" aria-hidden="true" tabindex="-1"></a>            <span class="cf">raise</span> <span class="pp">ValueError</span>(<span class="ss">f&quot;bedarf muss </span><span class="sc">{</span>m<span class="sc">}</span><span class="ss"> Eintraege haben&quot;</span>)</span>
+<span id="cb10-77"><a href="#cb10-77" aria-hidden="true" tabindex="-1"></a>        <span class="cf">if</span> <span class="bu">len</span>(<span class="va">self</span>.transport) <span class="op">!=</span> n <span class="kw">or</span> <span class="bu">any</span>(<span class="bu">len</span>(z) <span class="op">!=</span> m <span class="cf">for</span> z <span class="kw">in</span> <span class="va">self</span>.transport):</span>
+<span id="cb10-78"><a href="#cb10-78" aria-hidden="true" tabindex="-1"></a>            <span class="cf">raise</span> <span class="pp">ValueError</span>(<span class="ss">f&quot;transport muss </span><span class="sc">{</span>n<span class="sc">}</span><span class="ss"> x </span><span class="sc">{</span>m<span class="sc">}</span><span class="ss"> sein&quot;</span>)</span>
+<span id="cb10-79"><a href="#cb10-79" aria-hidden="true" tabindex="-1"></a>        <span class="cf">if</span> <span class="bu">sum</span>(<span class="va">self</span>.kapazitaet) <span class="op">&lt;</span> <span class="bu">sum</span>(<span class="va">self</span>.bedarf):</span>
+<span id="cb10-80"><a href="#cb10-80" aria-hidden="true" tabindex="-1"></a>            <span class="cf">raise</span> <span class="pp">ValueError</span>(<span class="ss">f&quot;Gesamtkapazitaet </span><span class="sc">{</span><span class="bu">sum</span>(<span class="va">self</span>.kapazitaet)<span class="sc">}</span><span class="ss"> deckt den &quot;</span></span>
+<span id="cb10-81"><a href="#cb10-81" aria-hidden="true" tabindex="-1"></a>                             <span class="ss">f&quot;Gesamtbedarf </span><span class="sc">{</span><span class="bu">sum</span>(<span class="va">self</span>.bedarf)<span class="sc">}</span><span class="ss"> nicht&quot;</span>)</span>
+<span id="cb10-82"><a href="#cb10-82" aria-hidden="true" tabindex="-1"></a>        <span class="cf">return</span> <span class="va">self</span></span>
+<span id="cb10-83"><a href="#cb10-83" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb10-84"><a href="#cb10-84" aria-hidden="true" tabindex="-1"></a>    <span class="kw">def</span> schluessel(<span class="va">self</span>, i: <span class="bu">int</span>, j: <span class="bu">int</span>) <span class="op">-&gt;</span> <span class="bu">str</span>:</span>
+<span id="cb10-85"><a href="#cb10-85" aria-hidden="true" tabindex="-1"></a>        <span class="co">&quot;&quot;&quot;Variablenname im Loesung-DTO - beide Modellbauer benutzen ihn.&quot;&quot;&quot;</span></span>
+<span id="cb10-86"><a href="#cb10-86" aria-hidden="true" tabindex="-1"></a>        <span class="cf">return</span> <span class="ss">f&quot;</span><span class="sc">{</span><span class="va">self</span><span class="sc">.</span>lager[i]<span class="sc">}</span><span class="ss">-&gt;</span><span class="sc">{</span><span class="va">self</span><span class="sc">.</span>kunden[j]<span class="sc">}</span><span class="ss">&quot;</span></span>
+<span id="cb10-87"><a href="#cb10-87" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb10-88"><a href="#cb10-88" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb10-89"><a href="#cb10-89" aria-hidden="true" tabindex="-1"></a><span class="kw">def</span> beispielproblem(saat: <span class="bu">int</span> <span class="op">=</span> <span class="dv">11</span>) <span class="op">-&gt;</span> Standortproblem:</span>
+<span id="cb10-90"><a href="#cb10-90" aria-hidden="true" tabindex="-1"></a>    <span class="co">&quot;&quot;&quot;Sechs moegliche Lager, zwoelf Kunden - klein genug fuer beide Solver.&quot;&quot;&quot;</span></span>
+<span id="cb10-91"><a href="#cb10-91" aria-hidden="true" tabindex="-1"></a>    rng <span class="op">=</span> np.random.default_rng(saat)</span>
+<span id="cb10-92"><a href="#cb10-92" aria-hidden="true" tabindex="-1"></a>    lager <span class="op">=</span> [<span class="ss">f&quot;Lager_</span><span class="sc">{</span>k<span class="sc">}</span><span class="ss">&quot;</span> <span class="cf">for</span> k <span class="kw">in</span> <span class="st">&quot;ABCDEF&quot;</span>]</span>
+<span id="cb10-93"><a href="#cb10-93" aria-hidden="true" tabindex="-1"></a>    kunden <span class="op">=</span> [<span class="ss">f&quot;Kunde_</span><span class="sc">{</span>k<span class="sc">:02d}</span><span class="ss">&quot;</span> <span class="cf">for</span> k <span class="kw">in</span> <span class="bu">range</span>(<span class="dv">1</span>, <span class="dv">13</span>)]</span>
+<span id="cb10-94"><a href="#cb10-94" aria-hidden="true" tabindex="-1"></a>    bedarf <span class="op">=</span> rng.integers(<span class="dv">10</span>, <span class="dv">60</span>, <span class="bu">len</span>(kunden))</span>
+<span id="cb10-95"><a href="#cb10-95" aria-hidden="true" tabindex="-1"></a>    <span class="cf">return</span> Standortproblem(</span>
+<span id="cb10-96"><a href="#cb10-96" aria-hidden="true" tabindex="-1"></a>        lager<span class="op">=</span>lager,</span>
+<span id="cb10-97"><a href="#cb10-97" aria-hidden="true" tabindex="-1"></a>        kunden<span class="op">=</span>kunden,</span>
+<span id="cb10-98"><a href="#cb10-98" aria-hidden="true" tabindex="-1"></a>        fixkosten<span class="op">=</span>rng.integers(<span class="dv">3000</span>, <span class="dv">9000</span>, <span class="bu">len</span>(lager)).tolist(),</span>
+<span id="cb10-99"><a href="#cb10-99" aria-hidden="true" tabindex="-1"></a>        kapazitaet<span class="op">=</span>[<span class="bu">int</span>(bedarf.<span class="bu">sum</span>() <span class="op">*</span> <span class="fl">0.45</span>)] <span class="op">*</span> <span class="bu">len</span>(lager),</span>
+<span id="cb10-100"><a href="#cb10-100" aria-hidden="true" tabindex="-1"></a>        bedarf<span class="op">=</span>bedarf.tolist(),</span>
+<span id="cb10-101"><a href="#cb10-101" aria-hidden="true" tabindex="-1"></a>        transport<span class="op">=</span>rng.integers(<span class="dv">200</span>, <span class="dv">1800</span>, (<span class="bu">len</span>(lager), <span class="bu">len</span>(kunden))).tolist(),</span>
+<span id="cb10-102"><a href="#cb10-102" aria-hidden="true" tabindex="-1"></a>    )</span>
+<span id="cb10-103"><a href="#cb10-103" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb10-104"><a href="#cb10-104" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb10-105"><a href="#cb10-105" aria-hidden="true" tabindex="-1"></a><span class="co"># --- 2. Der eine Baustein, der sich aendert: der Modellbauer -----------------</span></span>
+<span id="cb10-106"><a href="#cb10-106" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb10-107"><a href="#cb10-107" aria-hidden="true" tabindex="-1"></a><span class="kw">def</span> baue_und_loese_mit_cpsat(problem: Standortproblem) <span class="op">-&gt;</span> Loesung:</span>
+<span id="cb10-108"><a href="#cb10-108" aria-hidden="true" tabindex="-1"></a>    <span class="co">&quot;&quot;&quot;CP-SAT: Bool-Variablen, ganzzahlige Koeffizienten, Minimize.&quot;&quot;&quot;</span></span>
+<span id="cb10-109"><a href="#cb10-109" aria-hidden="true" tabindex="-1"></a>    <span class="im">from</span> ortools.sat.python <span class="im">import</span> cp_model</span>
+<span id="cb10-110"><a href="#cb10-110" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb10-111"><a href="#cb10-111" aria-hidden="true" tabindex="-1"></a>    n, m <span class="op">=</span> <span class="bu">len</span>(problem.lager), <span class="bu">len</span>(problem.kunden)</span>
+<span id="cb10-112"><a href="#cb10-112" aria-hidden="true" tabindex="-1"></a>    modell <span class="op">=</span> cp_model.CpModel()</span>
+<span id="cb10-113"><a href="#cb10-113" aria-hidden="true" tabindex="-1"></a>    y <span class="op">=</span> [modell.NewBoolVar(<span class="ss">f&quot;offen_</span><span class="sc">{</span>i<span class="sc">}</span><span class="ss">&quot;</span>) <span class="cf">for</span> i <span class="kw">in</span> <span class="bu">range</span>(n)]</span>
+<span id="cb10-114"><a href="#cb10-114" aria-hidden="true" tabindex="-1"></a>    x <span class="op">=</span> {(i, j): modell.NewBoolVar(<span class="ss">f&quot;liefert_</span><span class="sc">{</span>i<span class="sc">}</span><span class="ss">_</span><span class="sc">{</span>j<span class="sc">}</span><span class="ss">&quot;</span>)</span>
+<span id="cb10-115"><a href="#cb10-115" aria-hidden="true" tabindex="-1"></a>         <span class="cf">for</span> i <span class="kw">in</span> <span class="bu">range</span>(n) <span class="cf">for</span> j <span class="kw">in</span> <span class="bu">range</span>(m)}</span>
+<span id="cb10-116"><a href="#cb10-116" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb10-117"><a href="#cb10-117" aria-hidden="true" tabindex="-1"></a>    <span class="cf">for</span> j <span class="kw">in</span> <span class="bu">range</span>(m):                                   <span class="co"># jeder Kunde genau einmal</span></span>
+<span id="cb10-118"><a href="#cb10-118" aria-hidden="true" tabindex="-1"></a>        modell.AddExactlyOne(x[i, j] <span class="cf">for</span> i <span class="kw">in</span> <span class="bu">range</span>(n))</span>
+<span id="cb10-119"><a href="#cb10-119" aria-hidden="true" tabindex="-1"></a>    <span class="cf">for</span> i <span class="kw">in</span> <span class="bu">range</span>(n):</span>
+<span id="cb10-120"><a href="#cb10-120" aria-hidden="true" tabindex="-1"></a>        <span class="cf">for</span> j <span class="kw">in</span> <span class="bu">range</span>(m):                               <span class="co"># nur aus offenen Lagern</span></span>
+<span id="cb10-121"><a href="#cb10-121" aria-hidden="true" tabindex="-1"></a>            modell.AddImplication(x[i, j], y[i])</span>
+<span id="cb10-122"><a href="#cb10-122" aria-hidden="true" tabindex="-1"></a>        modell.Add(<span class="bu">sum</span>(problem.bedarf[j] <span class="op">*</span> x[i, j] <span class="cf">for</span> j <span class="kw">in</span> <span class="bu">range</span>(m))</span>
+<span id="cb10-123"><a href="#cb10-123" aria-hidden="true" tabindex="-1"></a>                   <span class="op">&lt;=</span> problem.kapazitaet[i] <span class="op">*</span> y[i])      <span class="co"># Kapazitaet</span></span>
+<span id="cb10-124"><a href="#cb10-124" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb10-125"><a href="#cb10-125" aria-hidden="true" tabindex="-1"></a>    modell.Minimize(</span>
+<span id="cb10-126"><a href="#cb10-126" aria-hidden="true" tabindex="-1"></a>        <span class="bu">sum</span>(problem.fixkosten[i] <span class="op">*</span> y[i] <span class="cf">for</span> i <span class="kw">in</span> <span class="bu">range</span>(n))</span>
+<span id="cb10-127"><a href="#cb10-127" aria-hidden="true" tabindex="-1"></a>        <span class="op">+</span> <span class="bu">sum</span>(problem.transport[i][j] <span class="op">*</span> x[i, j] <span class="cf">for</span> i <span class="kw">in</span> <span class="bu">range</span>(n) <span class="cf">for</span> j <span class="kw">in</span> <span class="bu">range</span>(m)))</span>
+<span id="cb10-128"><a href="#cb10-128" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb10-129"><a href="#cb10-129" aria-hidden="true" tabindex="-1"></a>    loeser <span class="op">=</span> cp_model.CpSolver()</span>
+<span id="cb10-130"><a href="#cb10-130" aria-hidden="true" tabindex="-1"></a>    loeser.parameters.max_time_in_seconds <span class="op">=</span> ZEITLIMIT</span>
+<span id="cb10-131"><a href="#cb10-131" aria-hidden="true" tabindex="-1"></a>    loeser.parameters.num_workers <span class="op">=</span> <span class="dv">1</span></span>
+<span id="cb10-132"><a href="#cb10-132" aria-hidden="true" tabindex="-1"></a>    loeser.parameters.random_seed <span class="op">=</span> <span class="dv">1</span></span>
+<span id="cb10-133"><a href="#cb10-133" aria-hidden="true" tabindex="-1"></a>    status <span class="op">=</span> status_von_cpsat(loeser.Solve(modell))</span>
+<span id="cb10-134"><a href="#cb10-134" aria-hidden="true" tabindex="-1"></a>    <span class="cf">if</span> <span class="kw">not</span> status.brauchbar:</span>
+<span id="cb10-135"><a href="#cb10-135" aria-hidden="true" tabindex="-1"></a>        <span class="cf">return</span> Loesung(status<span class="op">=</span>status, laufzeit<span class="op">=</span>loeser.WallTime())</span>
+<span id="cb10-136"><a href="#cb10-136" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb10-137"><a href="#cb10-137" aria-hidden="true" tabindex="-1"></a>    <span class="cf">return</span> Loesung(</span>
+<span id="cb10-138"><a href="#cb10-138" aria-hidden="true" tabindex="-1"></a>        status<span class="op">=</span>status,</span>
+<span id="cb10-139"><a href="#cb10-139" aria-hidden="true" tabindex="-1"></a>        werte<span class="op">=</span>{problem.schluessel(i, j): <span class="bu">float</span>(loeser.Value(x[i, j]))</span>
+<span id="cb10-140"><a href="#cb10-140" aria-hidden="true" tabindex="-1"></a>               <span class="cf">for</span> i <span class="kw">in</span> <span class="bu">range</span>(n) <span class="cf">for</span> j <span class="kw">in</span> <span class="bu">range</span>(m)},</span>
+<span id="cb10-141"><a href="#cb10-141" aria-hidden="true" tabindex="-1"></a>        zielwert<span class="op">=</span>loeser.ObjectiveValue(),</span>
+<span id="cb10-142"><a href="#cb10-142" aria-hidden="true" tabindex="-1"></a>        schranke<span class="op">=</span>loeser.BestObjectiveBound(),</span>
+<span id="cb10-143"><a href="#cb10-143" aria-hidden="true" tabindex="-1"></a>        laufzeit<span class="op">=</span>loeser.WallTime())</span>
+<span id="cb10-144"><a href="#cb10-144" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb10-145"><a href="#cb10-145" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb10-146"><a href="#cb10-146" aria-hidden="true" tabindex="-1"></a><span class="kw">def</span> baue_und_loese_mit_highs(problem: Standortproblem) <span class="op">-&gt;</span> Loesung:</span>
+<span id="cb10-147"><a href="#cb10-147" aria-hidden="true" tabindex="-1"></a>    <span class="co">&quot;&quot;&quot;HiGHS: dieselben Restriktionen als Ungleichungszeilen einer Matrix.&quot;&quot;&quot;</span></span>
+<span id="cb10-148"><a href="#cb10-148" aria-hidden="true" tabindex="-1"></a>    <span class="im">import</span> highspy</span>
+<span id="cb10-149"><a href="#cb10-149" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb10-150"><a href="#cb10-150" aria-hidden="true" tabindex="-1"></a>    n, m <span class="op">=</span> <span class="bu">len</span>(problem.lager), <span class="bu">len</span>(problem.kunden)</span>
+<span id="cb10-151"><a href="#cb10-151" aria-hidden="true" tabindex="-1"></a>    anzahl_x <span class="op">=</span> n <span class="op">*</span> m                                     <span class="co"># Spalten 0..n*m-1</span></span>
+<span id="cb10-152"><a href="#cb10-152" aria-hidden="true" tabindex="-1"></a>    spalte_y <span class="op">=</span> <span class="kw">lambda</span> i: anzahl_x <span class="op">+</span> i                    <span class="co"># danach die y_i  # noqa: E731</span></span>
+<span id="cb10-153"><a href="#cb10-153" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb10-154"><a href="#cb10-154" aria-hidden="true" tabindex="-1"></a>    modell <span class="op">=</span> highspy.Highs()</span>
+<span id="cb10-155"><a href="#cb10-155" aria-hidden="true" tabindex="-1"></a>    modell.setOptionValue(<span class="st">&quot;output_flag&quot;</span>, <span class="va">False</span>)</span>
+<span id="cb10-156"><a href="#cb10-156" aria-hidden="true" tabindex="-1"></a>    modell.setOptionValue(<span class="st">&quot;time_limit&quot;</span>, ZEITLIMIT)</span>
+<span id="cb10-157"><a href="#cb10-157" aria-hidden="true" tabindex="-1"></a>    modell.addVars(anzahl_x <span class="op">+</span> n, np.zeros(anzahl_x <span class="op">+</span> n), np.ones(anzahl_x <span class="op">+</span> n))</span>
+<span id="cb10-158"><a href="#cb10-158" aria-hidden="true" tabindex="-1"></a>    <span class="cf">for</span> spalte <span class="kw">in</span> <span class="bu">range</span>(anzahl_x <span class="op">+</span> n):</span>
+<span id="cb10-159"><a href="#cb10-159" aria-hidden="true" tabindex="-1"></a>        modell.changeColIntegrality(spalte, highspy.HighsVarType.kInteger)</span>
+<span id="cb10-160"><a href="#cb10-160" aria-hidden="true" tabindex="-1"></a>    <span class="cf">for</span> i <span class="kw">in</span> <span class="bu">range</span>(n):</span>
+<span id="cb10-161"><a href="#cb10-161" aria-hidden="true" tabindex="-1"></a>        modell.changeColCost(spalte_y(i), <span class="bu">float</span>(problem.fixkosten[i]))</span>
+<span id="cb10-162"><a href="#cb10-162" aria-hidden="true" tabindex="-1"></a>        <span class="cf">for</span> j <span class="kw">in</span> <span class="bu">range</span>(m):</span>
+<span id="cb10-163"><a href="#cb10-163" aria-hidden="true" tabindex="-1"></a>            modell.changeColCost(i <span class="op">*</span> m <span class="op">+</span> j, <span class="bu">float</span>(problem.transport[i][j]))</span>
+<span id="cb10-164"><a href="#cb10-164" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb10-165"><a href="#cb10-165" aria-hidden="true" tabindex="-1"></a>    <span class="cf">for</span> j <span class="kw">in</span> <span class="bu">range</span>(m):                                   <span class="co"># jeder Kunde genau einmal</span></span>
+<span id="cb10-166"><a href="#cb10-166" aria-hidden="true" tabindex="-1"></a>        index <span class="op">=</span> np.array([i <span class="op">*</span> m <span class="op">+</span> j <span class="cf">for</span> i <span class="kw">in</span> <span class="bu">range</span>(n)], dtype<span class="op">=</span>np.int32)</span>
+<span id="cb10-167"><a href="#cb10-167" aria-hidden="true" tabindex="-1"></a>        modell.addRow(<span class="fl">1.0</span>, <span class="fl">1.0</span>, n, index, np.ones(n))</span>
+<span id="cb10-168"><a href="#cb10-168" aria-hidden="true" tabindex="-1"></a>    <span class="cf">for</span> i <span class="kw">in</span> <span class="bu">range</span>(n):</span>
+<span id="cb10-169"><a href="#cb10-169" aria-hidden="true" tabindex="-1"></a>        <span class="cf">for</span> j <span class="kw">in</span> <span class="bu">range</span>(m):                               <span class="co"># x_ij - y_i &lt;= 0</span></span>
+<span id="cb10-170"><a href="#cb10-170" aria-hidden="true" tabindex="-1"></a>            modell.addRow(<span class="op">-</span>highspy.kHighsInf, <span class="fl">0.0</span>, <span class="dv">2</span>,</span>
+<span id="cb10-171"><a href="#cb10-171" aria-hidden="true" tabindex="-1"></a>                          np.array([i <span class="op">*</span> m <span class="op">+</span> j, spalte_y(i)], dtype<span class="op">=</span>np.int32),</span>
+<span id="cb10-172"><a href="#cb10-172" aria-hidden="true" tabindex="-1"></a>                          np.array([<span class="fl">1.0</span>, <span class="op">-</span><span class="fl">1.0</span>]))</span>
+<span id="cb10-173"><a href="#cb10-173" aria-hidden="true" tabindex="-1"></a>        index <span class="op">=</span> np.array([i <span class="op">*</span> m <span class="op">+</span> j <span class="cf">for</span> j <span class="kw">in</span> <span class="bu">range</span>(m)] <span class="op">+</span> [spalte_y(i)],</span>
+<span id="cb10-174"><a href="#cb10-174" aria-hidden="true" tabindex="-1"></a>                         dtype<span class="op">=</span>np.int32)                 <span class="co"># Kapazitaet</span></span>
+<span id="cb10-175"><a href="#cb10-175" aria-hidden="true" tabindex="-1"></a>        werte <span class="op">=</span> np.concatenate([np.array(problem.bedarf, dtype<span class="op">=</span><span class="bu">float</span>),</span>
+<span id="cb10-176"><a href="#cb10-176" aria-hidden="true" tabindex="-1"></a>                                [<span class="op">-</span><span class="bu">float</span>(problem.kapazitaet[i])]])</span>
+<span id="cb10-177"><a href="#cb10-177" aria-hidden="true" tabindex="-1"></a>        modell.addRow(<span class="op">-</span>highspy.kHighsInf, <span class="fl">0.0</span>, m <span class="op">+</span> <span class="dv">1</span>, index, werte)</span>
+<span id="cb10-178"><a href="#cb10-178" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb10-179"><a href="#cb10-179" aria-hidden="true" tabindex="-1"></a>    t0 <span class="op">=</span> time.perf_counter()</span>
+<span id="cb10-180"><a href="#cb10-180" aria-hidden="true" tabindex="-1"></a>    modell.run()</span>
+<span id="cb10-181"><a href="#cb10-181" aria-hidden="true" tabindex="-1"></a>    laufzeit <span class="op">=</span> time.perf_counter() <span class="op">-</span> t0</span>
+<span id="cb10-182"><a href="#cb10-182" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb10-183"><a href="#cb10-183" aria-hidden="true" tabindex="-1"></a>    status <span class="op">=</span> status_von_highs(modell.modelStatusToString(modell.getModelStatus()))</span>
+<span id="cb10-184"><a href="#cb10-184" aria-hidden="true" tabindex="-1"></a>    <span class="cf">if</span> <span class="kw">not</span> status.brauchbar:</span>
+<span id="cb10-185"><a href="#cb10-185" aria-hidden="true" tabindex="-1"></a>        <span class="cf">return</span> Loesung(status<span class="op">=</span>status, laufzeit<span class="op">=</span>laufzeit)</span>
+<span id="cb10-186"><a href="#cb10-186" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb10-187"><a href="#cb10-187" aria-hidden="true" tabindex="-1"></a>    loesungswerte <span class="op">=</span> modell.getSolution().col_value</span>
+<span id="cb10-188"><a href="#cb10-188" aria-hidden="true" tabindex="-1"></a>    info <span class="op">=</span> modell.getInfo()</span>
+<span id="cb10-189"><a href="#cb10-189" aria-hidden="true" tabindex="-1"></a>    <span class="cf">return</span> Loesung(</span>
+<span id="cb10-190"><a href="#cb10-190" aria-hidden="true" tabindex="-1"></a>        status<span class="op">=</span>status,</span>
+<span id="cb10-191"><a href="#cb10-191" aria-hidden="true" tabindex="-1"></a>        werte<span class="op">=</span>{problem.schluessel(i, j): <span class="bu">float</span>(loesungswerte[i <span class="op">*</span> m <span class="op">+</span> j])</span>
+<span id="cb10-192"><a href="#cb10-192" aria-hidden="true" tabindex="-1"></a>               <span class="cf">for</span> i <span class="kw">in</span> <span class="bu">range</span>(n) <span class="cf">for</span> j <span class="kw">in</span> <span class="bu">range</span>(m)},</span>
+<span id="cb10-193"><a href="#cb10-193" aria-hidden="true" tabindex="-1"></a>        zielwert<span class="op">=</span>info.objective_function_value,</span>
+<span id="cb10-194"><a href="#cb10-194" aria-hidden="true" tabindex="-1"></a>        schranke<span class="op">=</span>info.mip_dual_bound,</span>
+<span id="cb10-195"><a href="#cb10-195" aria-hidden="true" tabindex="-1"></a>        laufzeit<span class="op">=</span>laufzeit)</span>
+<span id="cb10-196"><a href="#cb10-196" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb10-197"><a href="#cb10-197" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb10-198"><a href="#cb10-198" aria-hidden="true" tabindex="-1"></a>MODELLBAUER <span class="op">=</span> {<span class="st">&quot;cpsat&quot;</span>: baue_und_loese_mit_cpsat, <span class="st">&quot;highs&quot;</span>: baue_und_loese_mit_highs}</span>
+<span id="cb10-199"><a href="#cb10-199" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb10-200"><a href="#cb10-200" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb10-201"><a href="#cb10-201" aria-hidden="true" tabindex="-1"></a><span class="co"># --- 3. Alles Weitere ist wieder gemeinsam -----------------------------------</span></span>
+<span id="cb10-202"><a href="#cb10-202" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb10-203"><a href="#cb10-203" aria-hidden="true" tabindex="-1"></a><span class="kw">def</span> pruefe_zuordnung(problem: Standortproblem, loesung: Loesung,</span>
+<span id="cb10-204"><a href="#cb10-204" aria-hidden="true" tabindex="-1"></a>                     toleranz: <span class="bu">float</span> <span class="op">=</span> <span class="fl">1e-6</span>) <span class="op">-&gt;</span> <span class="bu">list</span>[<span class="bu">str</span>]:</span>
+<span id="cb10-205"><a href="#cb10-205" aria-hidden="true" tabindex="-1"></a>    <span class="co">&quot;&quot;&quot;Prueft die Loesung gegen die Anforderung - ohne Solver, ohne Modell.&quot;&quot;&quot;</span></span>
+<span id="cb10-206"><a href="#cb10-206" aria-hidden="true" tabindex="-1"></a>    <span class="cf">if</span> <span class="kw">not</span> loesung.status.brauchbar:</span>
+<span id="cb10-207"><a href="#cb10-207" aria-hidden="true" tabindex="-1"></a>        <span class="cf">return</span> [<span class="ss">f&quot;kein verwertbares Ergebnis (</span><span class="sc">{</span>loesung<span class="sc">.</span>status<span class="sc">.</span>value<span class="sc">}</span><span class="ss">)&quot;</span>]</span>
+<span id="cb10-208"><a href="#cb10-208" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb10-209"><a href="#cb10-209" aria-hidden="true" tabindex="-1"></a>    n, m <span class="op">=</span> <span class="bu">len</span>(problem.lager), <span class="bu">len</span>(problem.kunden)</span>
+<span id="cb10-210"><a href="#cb10-210" aria-hidden="true" tabindex="-1"></a>    zuordnung <span class="op">=</span> np.array([[loesung.werte[problem.schluessel(i, j)]</span>
+<span id="cb10-211"><a href="#cb10-211" aria-hidden="true" tabindex="-1"></a>                           <span class="cf">for</span> j <span class="kw">in</span> <span class="bu">range</span>(m)] <span class="cf">for</span> i <span class="kw">in</span> <span class="bu">range</span>(n)])</span>
+<span id="cb10-212"><a href="#cb10-212" aria-hidden="true" tabindex="-1"></a>    beanstandungen: <span class="bu">list</span>[<span class="bu">str</span>] <span class="op">=</span> []</span>
+<span id="cb10-213"><a href="#cb10-213" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb10-214"><a href="#cb10-214" aria-hidden="true" tabindex="-1"></a>    <span class="cf">if</span> (np.<span class="bu">abs</span>(zuordnung <span class="op">-</span> np.<span class="bu">round</span>(zuordnung)) <span class="op">&gt;</span> toleranz).<span class="bu">any</span>():</span>
+<span id="cb10-215"><a href="#cb10-215" aria-hidden="true" tabindex="-1"></a>        beanstandungen.append(<span class="st">&quot;Zuordnungen sind nicht 0/1&quot;</span>)</span>
+<span id="cb10-216"><a href="#cb10-216" aria-hidden="true" tabindex="-1"></a>    zuordnung <span class="op">=</span> np.<span class="bu">round</span>(zuordnung)</span>
+<span id="cb10-217"><a href="#cb10-217" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb10-218"><a href="#cb10-218" aria-hidden="true" tabindex="-1"></a>    <span class="cf">for</span> j, kunde <span class="kw">in</span> <span class="bu">enumerate</span>(problem.kunden):</span>
+<span id="cb10-219"><a href="#cb10-219" aria-hidden="true" tabindex="-1"></a>        <span class="cf">if</span> <span class="bu">abs</span>(zuordnung[:, j].<span class="bu">sum</span>() <span class="op">-</span> <span class="fl">1.0</span>) <span class="op">&gt;</span> toleranz:</span>
+<span id="cb10-220"><a href="#cb10-220" aria-hidden="true" tabindex="-1"></a>            beanstandungen.append(<span class="ss">f&quot;</span><span class="sc">{</span>kunde<span class="sc">}</span><span class="ss"> wird </span><span class="sc">{</span>zuordnung[:, j]<span class="sc">.</span><span class="bu">sum</span>()<span class="sc">:.0f}</span><span class="ss">-mal beliefert&quot;</span>)</span>
+<span id="cb10-221"><a href="#cb10-221" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb10-222"><a href="#cb10-222" aria-hidden="true" tabindex="-1"></a>    beliefert <span class="op">=</span> zuordnung <span class="op">@</span> np.array(problem.bedarf, dtype<span class="op">=</span><span class="bu">float</span>)</span>
+<span id="cb10-223"><a href="#cb10-223" aria-hidden="true" tabindex="-1"></a>    <span class="cf">for</span> i, lagername <span class="kw">in</span> <span class="bu">enumerate</span>(problem.lager):</span>
+<span id="cb10-224"><a href="#cb10-224" aria-hidden="true" tabindex="-1"></a>        <span class="cf">if</span> beliefert[i] <span class="op">&gt;</span> problem.kapazitaet[i] <span class="op">+</span> toleranz:</span>
+<span id="cb10-225"><a href="#cb10-225" aria-hidden="true" tabindex="-1"></a>            beanstandungen.append(<span class="ss">f&quot;</span><span class="sc">{</span>lagername<span class="sc">}</span><span class="ss">: </span><span class="sc">{</span>beliefert[i]<span class="sc">:.0f}</span><span class="ss"> Paletten ueber &quot;</span></span>
+<span id="cb10-226"><a href="#cb10-226" aria-hidden="true" tabindex="-1"></a>                                  <span class="ss">f&quot;Kapazitaet </span><span class="sc">{</span>problem<span class="sc">.</span>kapazitaet[i]<span class="sc">}</span><span class="ss">&quot;</span>)</span>
+<span id="cb10-227"><a href="#cb10-227" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb10-228"><a href="#cb10-228" aria-hidden="true" tabindex="-1"></a>    <span class="cf">if</span> loesung.zielwert <span class="kw">is</span> <span class="kw">not</span> <span class="va">None</span>:</span>
+<span id="cb10-229"><a href="#cb10-229" aria-hidden="true" tabindex="-1"></a>        offen <span class="op">=</span> beliefert <span class="op">&gt;</span> toleranz</span>
+<span id="cb10-230"><a href="#cb10-230" aria-hidden="true" tabindex="-1"></a>        nachgerechnet <span class="op">=</span> (np.array(problem.fixkosten, dtype<span class="op">=</span><span class="bu">float</span>) <span class="op">@</span> offen</span>
+<span id="cb10-231"><a href="#cb10-231" aria-hidden="true" tabindex="-1"></a>                         <span class="op">+</span> (np.array(problem.transport, dtype<span class="op">=</span><span class="bu">float</span>) <span class="op">*</span> zuordnung).<span class="bu">sum</span>())</span>
+<span id="cb10-232"><a href="#cb10-232" aria-hidden="true" tabindex="-1"></a>        <span class="cf">if</span> <span class="bu">abs</span>(nachgerechnet <span class="op">-</span> loesung.zielwert) <span class="op">&gt;</span> <span class="fl">0.5</span>:</span>
+<span id="cb10-233"><a href="#cb10-233" aria-hidden="true" tabindex="-1"></a>            beanstandungen.append(<span class="ss">f&quot;Zielwert </span><span class="sc">{</span>loesung<span class="sc">.</span>zielwert<span class="sc">:,.0f}</span><span class="ss"> passt nicht zur &quot;</span></span>
+<span id="cb10-234"><a href="#cb10-234" aria-hidden="true" tabindex="-1"></a>                                  <span class="ss">f&quot;Zuordnung (nachgerechnet </span><span class="sc">{</span>nachgerechnet<span class="sc">:,.0f}</span><span class="ss">)&quot;</span>)</span>
+<span id="cb10-235"><a href="#cb10-235" aria-hidden="true" tabindex="-1"></a>    <span class="cf">return</span> beanstandungen</span>
+<span id="cb10-236"><a href="#cb10-236" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb10-237"><a href="#cb10-237" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb10-238"><a href="#cb10-238" aria-hidden="true" tabindex="-1"></a><span class="kw">def</span> geoeffnete_lager(problem: Standortproblem, loesung: Loesung) <span class="op">-&gt;</span> <span class="bu">list</span>[<span class="bu">str</span>]:</span>
+<span id="cb10-239"><a href="#cb10-239" aria-hidden="true" tabindex="-1"></a>    m <span class="op">=</span> <span class="bu">len</span>(problem.kunden)</span>
+<span id="cb10-240"><a href="#cb10-240" aria-hidden="true" tabindex="-1"></a>    <span class="cf">return</span> [name <span class="cf">for</span> i, name <span class="kw">in</span> <span class="bu">enumerate</span>(problem.lager)</span>
+<span id="cb10-241"><a href="#cb10-241" aria-hidden="true" tabindex="-1"></a>            <span class="cf">if</span> <span class="bu">any</span>(loesung.werte[problem.schluessel(i, j)] <span class="op">&gt;</span> <span class="fl">0.5</span> <span class="cf">for</span> j <span class="kw">in</span> <span class="bu">range</span>(m))]</span>
+<span id="cb10-242"><a href="#cb10-242" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb10-243"><a href="#cb10-243" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb10-244"><a href="#cb10-244" aria-hidden="true" tabindex="-1"></a><span class="kw">def</span> loese_in_eigenem_prozess(name: <span class="bu">str</span>, problem: Standortproblem) <span class="op">-&gt;</span> Loesung:</span>
+<span id="cb10-245"><a href="#cb10-245" aria-hidden="true" tabindex="-1"></a>    <span class="co">&quot;&quot;&quot;Laesst genau einen Modellbauer in einem frischen Prozess rechnen.</span></span>
+<span id="cb10-246"><a href="#cb10-246" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb10-247"><a href="#cb10-247" aria-hidden="true" tabindex="-1"></a><span class="co">    &#39;spawn&#39; statt des Linux-Standards &#39;fork&#39;: Der Kindprozess startet mit</span></span>
+<span id="cb10-248"><a href="#cb10-248" aria-hidden="true" tabindex="-1"></a><span class="co">    einem leeren Interpreter und importiert nur den Solver, den SEIN</span></span>
+<span id="cb10-249"><a href="#cb10-249" aria-hidden="true" tabindex="-1"></a><span class="co">    Modellbauer braucht. max_tasks_per_child=1 sorgt dafuer, dass der Pool</span></span>
+<span id="cb10-250"><a href="#cb10-250" aria-hidden="true" tabindex="-1"></a><span class="co">    seinen Arbeiter nicht wiederverwendet - sonst saessen beim zweiten Aufruf</span></span>
+<span id="cb10-251"><a href="#cb10-251" aria-hidden="true" tabindex="-1"></a><span class="co">    wieder beide Bibliotheken im selben Prozess.</span></span>
+<span id="cb10-252"><a href="#cb10-252" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb10-253"><a href="#cb10-253" aria-hidden="true" tabindex="-1"></a><span class="co">    Hin und zurueck wandert das Domaenenmodell bzw. das Loesungs-DTO. Beide</span></span>
+<span id="cb10-254"><a href="#cb10-254" aria-hidden="true" tabindex="-1"></a><span class="co">    kennen keinen Solver, sind also serialisierbar - genau dafuer sind sie da.</span></span>
+<span id="cb10-255"><a href="#cb10-255" aria-hidden="true" tabindex="-1"></a><span class="co">    &quot;&quot;&quot;</span></span>
+<span id="cb10-256"><a href="#cb10-256" aria-hidden="true" tabindex="-1"></a>    <span class="cf">with</span> ProcessPoolExecutor(</span>
+<span id="cb10-257"><a href="#cb10-257" aria-hidden="true" tabindex="-1"></a>            max_workers<span class="op">=</span><span class="dv">1</span>,</span>
+<span id="cb10-258"><a href="#cb10-258" aria-hidden="true" tabindex="-1"></a>            mp_context<span class="op">=</span>multiprocessing.get_context(<span class="st">&quot;spawn&quot;</span>),</span>
+<span id="cb10-259"><a href="#cb10-259" aria-hidden="true" tabindex="-1"></a>            max_tasks_per_child<span class="op">=</span><span class="dv">1</span>) <span class="im">as</span> pool:</span>
+<span id="cb10-260"><a href="#cb10-260" aria-hidden="true" tabindex="-1"></a>        <span class="cf">return</span> pool.submit(MODELLBAUER[name], problem).result(timeout<span class="op">=</span><span class="dv">300</span>)</span>
+<span id="cb10-261"><a href="#cb10-261" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb10-262"><a href="#cb10-262" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb10-263"><a href="#cb10-263" aria-hidden="true" tabindex="-1"></a><span class="cf">if</span> <span class="va">__name__</span> <span class="op">==</span> <span class="st">&quot;__main__&quot;</span>:</span>
+<span id="cb10-264"><a href="#cb10-264" aria-hidden="true" tabindex="-1"></a>    problem <span class="op">=</span> beispielproblem()</span>
+<span id="cb10-265"><a href="#cb10-265" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb10-266"><a href="#cb10-266" aria-hidden="true" tabindex="-1"></a>    <span class="co"># --- Beide Solver anstossen und vergleichen ---------------------------</span></span>
+<span id="cb10-267"><a href="#cb10-267" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;=&quot;</span> <span class="op">*</span> <span class="dv">82</span>)</span>
+<span id="cb10-268"><a href="#cb10-268" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;  DERSELBE FALL, ZWEI SOLVER - UND EIN AUSWERTUNGSCODE&quot;</span>)</span>
+<span id="cb10-269"><a href="#cb10-269" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;=&quot;</span> <span class="op">*</span> <span class="dv">82</span>)</span>
+<span id="cb10-270"><a href="#cb10-270" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;Standortplanung: </span><span class="sc">{</span><span class="bu">len</span>(problem.lager)<span class="sc">}</span><span class="ss"> moegliche Lager, &quot;</span></span>
+<span id="cb10-271"><a href="#cb10-271" aria-hidden="true" tabindex="-1"></a>          <span class="ss">f&quot;</span><span class="sc">{</span><span class="bu">len</span>(problem.kunden)<span class="sc">}</span><span class="ss"> Kunden, </span><span class="sc">{</span><span class="bu">sum</span>(problem.bedarf)<span class="sc">}</span><span class="ss"> Paletten Bedarf.&quot;</span>)</span>
+<span id="cb10-272"><a href="#cb10-272" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;Kapazitaet je Lager: </span><span class="sc">{</span>problem<span class="sc">.</span>kapazitaet[<span class="dv">0</span>]<span class="sc">}</span><span class="ss"> Paletten &quot;</span></span>
+<span id="cb10-273"><a href="#cb10-273" aria-hidden="true" tabindex="-1"></a>          <span class="ss">f&quot;-&gt; mindestens 3 Lager noetig.</span><span class="ch">\n</span><span class="ss">&quot;</span>)</span>
+<span id="cb10-274"><a href="#cb10-274" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb10-275"><a href="#cb10-275" aria-hidden="true" tabindex="-1"></a>    loesungen: <span class="bu">dict</span>[<span class="bu">str</span>, Loesung] <span class="op">=</span> {}</span>
+<span id="cb10-276"><a href="#cb10-276" aria-hidden="true" tabindex="-1"></a>    <span class="cf">for</span> name, beschriftung <span class="kw">in</span> [(<span class="st">&quot;cpsat&quot;</span>, <span class="st">&quot;OR-Tools CP-SAT&quot;</span>),</span>
+<span id="cb10-277"><a href="#cb10-277" aria-hidden="true" tabindex="-1"></a>                               (<span class="st">&quot;highs&quot;</span>, <span class="st">&quot;HiGHS (highspy)&quot;</span>)]:</span>
+<span id="cb10-278"><a href="#cb10-278" aria-hidden="true" tabindex="-1"></a>        loesung <span class="op">=</span> loesungen[name] <span class="op">=</span> loese_in_eigenem_prozess(name, problem)</span>
+<span id="cb10-279"><a href="#cb10-279" aria-hidden="true" tabindex="-1"></a>        beanstandungen <span class="op">=</span> pruefe_zuordnung(problem, loesung)</span>
+<span id="cb10-280"><a href="#cb10-280" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb10-281"><a href="#cb10-281" aria-hidden="true" tabindex="-1"></a>        <span class="bu">print</span>(<span class="ss">f&quot;</span><span class="sc">{</span>beschriftung<span class="sc">}</span><span class="ss">&quot;</span>)</span>
+<span id="cb10-282"><a href="#cb10-282" aria-hidden="true" tabindex="-1"></a>        <span class="bu">print</span>(<span class="ss">f&quot;  </span><span class="sc">{</span>loesung<span class="sc">.</span>als_bericht()<span class="sc">}</span><span class="ss">&quot;</span>)</span>
+<span id="cb10-283"><a href="#cb10-283" aria-hidden="true" tabindex="-1"></a>        <span class="bu">print</span>(<span class="ss">f&quot;  eroeffnete Lager: </span><span class="sc">{</span><span class="st">&#39;, &#39;</span><span class="sc">.</span>join(geoeffnete_lager(problem, loesung))<span class="sc">}</span><span class="ss">&quot;</span>)</span>
+<span id="cb10-284"><a href="#cb10-284" aria-hidden="true" tabindex="-1"></a>        <span class="bu">print</span>(<span class="ss">f&quot;  Abnahmepruefung:  &quot;</span></span>
+<span id="cb10-285"><a href="#cb10-285" aria-hidden="true" tabindex="-1"></a>              <span class="ss">f&quot;</span><span class="sc">{</span><span class="st">&#39;bestanden&#39;</span> <span class="cf">if</span> <span class="kw">not</span> beanstandungen <span class="cf">else</span> beanstandungen<span class="sc">}</span><span class="ss">&quot;</span>)</span>
+<span id="cb10-286"><a href="#cb10-286" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb10-287"><a href="#cb10-287" aria-hidden="true" tabindex="-1"></a>    <span class="co"># --- Was der Vergleich zeigt -----------------------------------------</span></span>
+<span id="cb10-288"><a href="#cb10-288" aria-hidden="true" tabindex="-1"></a>    zielwerte <span class="op">=</span> [loesung.zielwert <span class="cf">for</span> loesung <span class="kw">in</span> loesungen.values()]</span>
+<span id="cb10-289"><a href="#cb10-289" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;-&quot;</span> <span class="op">*</span> <span class="dv">82</span>)</span>
+<span id="cb10-290"><a href="#cb10-290" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;Zielwertdifferenz: </span><span class="sc">{</span><span class="bu">abs</span>(zielwerte[<span class="dv">0</span>] <span class="op">-</span> zielwerte[<span class="dv">1</span>])<span class="sc">:.6f}</span><span class="ss"> EUR&quot;</span>)</span>
+<span id="cb10-291"><a href="#cb10-291" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb10-292"><a href="#cb10-292" aria-hidden="true" tabindex="-1"></a>    gleich_belegt <span class="op">=</span> <span class="bu">all</span>(</span>
+<span id="cb10-293"><a href="#cb10-293" aria-hidden="true" tabindex="-1"></a>        <span class="bu">round</span>(loesungen[<span class="st">&quot;cpsat&quot;</span>].werte[s]) <span class="op">==</span> <span class="bu">round</span>(loesungen[<span class="st">&quot;highs&quot;</span>].werte[s])</span>
+<span id="cb10-294"><a href="#cb10-294" aria-hidden="true" tabindex="-1"></a>        <span class="cf">for</span> s <span class="kw">in</span> loesungen[<span class="st">&quot;cpsat&quot;</span>].werte)</span>
+<span id="cb10-295"><a href="#cb10-295" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;Identische Zuordnung: </span><span class="sc">{</span><span class="st">&#39;ja&#39;</span> <span class="cf">if</span> gleich_belegt <span class="cf">else</span> <span class="st">&#39;nein&#39;</span><span class="sc">}</span><span class="ss">&quot;</span>)</span>
+<span id="cb10-296"><a href="#cb10-296" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb10-297"><a href="#cb10-297" aria-hidden="true" tabindex="-1"></a>    <span class="cf">assert</span> <span class="bu">abs</span>(zielwerte[<span class="dv">0</span>] <span class="op">-</span> zielwerte[<span class="dv">1</span>]) <span class="op">&lt;</span> <span class="fl">0.5</span>, <span class="st">&quot;Die Solver widersprechen sich!&quot;</span></span>
+<span id="cb10-298"><a href="#cb10-298" aria-hidden="true" tabindex="-1"></a>    <span class="cf">assert</span> <span class="bu">all</span>(l.status <span class="kw">is</span> SolverStatus.OPTIMAL <span class="cf">for</span> l <span class="kw">in</span> loesungen.values())</span>
+<span id="cb10-299"><a href="#cb10-299" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb10-300"><a href="#cb10-300" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;</span><span class="ch">\n</span><span class="st">&quot;</span> <span class="op">+</span> <span class="st">&quot;=&quot;</span> <span class="op">*</span> <span class="dv">82</span>)</span>
+<span id="cb10-301"><a href="#cb10-301" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;  WAS DER WECHSEL GEKOSTET HAT&quot;</span>)</span>
+<span id="cb10-302"><a href="#cb10-302" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;=&quot;</span> <span class="op">*</span> <span class="dv">82</span>)</span>
+<span id="cb10-303"><a href="#cb10-303" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;Ausgetauscht wurde EINE Funktion. Domaenenmodell, Abnahmepruefung und&quot;</span>)</span>
+<span id="cb10-304"><a href="#cb10-304" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;Bericht sind woertlich dieselben - sie sehen den Solver nie.&quot;</span>)</span>
+<span id="cb10-305"><a href="#cb10-305" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>()</span>
+<span id="cb10-306"><a href="#cb10-306" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;Nicht umsonst ist der Wechsel trotzdem:&quot;</span>)</span>
+<span id="cb10-307"><a href="#cb10-307" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;  * CP-SAT rechnet ausschliesslich GANZZAHLIG. Alle Kosten sind hier&quot;</span>)</span>
+<span id="cb10-308"><a href="#cb10-308" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;    deshalb int. Wer in Euro und Cent rechnet, skaliert vorher auf Cent -&quot;</span>)</span>
+<span id="cb10-309"><a href="#cb10-309" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;    und muss das im Bericht wieder zuruecknehmen.&quot;</span>)</span>
+<span id="cb10-310"><a href="#cb10-310" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;  * HiGHS braucht die Restriktionen als Matrixzeilen, CP-SAT nimmt sie&quot;</span>)</span>
+<span id="cb10-311"><a href="#cb10-311" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;    als Ausdruecke. Das ist der Grund, warum der HiGHS-Modellbauer&quot;</span>)</span>
+<span id="cb10-312"><a href="#cb10-312" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;    laenger ist, obwohl er dasselbe Modell beschreibt.&quot;</span>)</span>
+<span id="cb10-313"><a href="#cb10-313" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;  * Beide Bibliotheken bringen eine eigene HiGHS-Kopie mit und lassen&quot;</span>)</span>
+<span id="cb10-314"><a href="#cb10-314" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;    sich nicht gemeinsam importieren - daher die zwei Prozesse.&quot;</span>)</span>
+<span id="cb10-315"><a href="#cb10-315" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>()</span>
+<span id="cb10-316"><a href="#cb10-316" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;Der Ertrag: Beide beweisen denselben optimalen Zielwert, und die&quot;</span>)</span>
+<span id="cb10-317"><a href="#cb10-317" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;Entscheidung zwischen ihnen ist eine Frage der Laufzeit geworden -&quot;</span>)</span>
+<span id="cb10-318"><a href="#cb10-318" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;nicht eine Frage, wie viel Code man neu schreiben muss.&quot;</span>)</span>
+<span id="cb10-319"><a href="#cb10-319" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>()</span>
+<span id="cb10-320"><a href="#cb10-320" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;Verglichen wird deshalb der ZIELWERT, nicht der Plan: Gibt es mehrere&quot;</span>)</span>
+<span id="cb10-321"><a href="#cb10-321" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;gleich teure Loesungen, darf jeder Solver eine andere davon liefern.&quot;</span>)</span>
+<span id="cb10-322"><a href="#cb10-322" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;Hier stimmen sie zufaellig ueberein - darauf zu testen waere trotzdem&quot;</span>)</span>
+<span id="cb10-323"><a href="#cb10-323" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;ein unzuverlaessiger Test (siehe JobShop_Intervalle.py).&quot;</span>)</span>
+<span id="cb10-324"><a href="#cb10-324" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;=&quot;</span> <span class="op">*</span> <span class="dv">82</span>)</span></code></pre></div>
 <p><strong>Erwartete Ausgabe</strong> (Laufzeiten hardwareabhängig):</p>
 <pre><code>==================================================================================
   DERSELBE FALL, ZWEI SOLVER - UND EIN AUSWERTUNGSCODE
@@ -1696,14 +2134,14 @@ ein unzuverlaessiger Test (siehe JobShop_Intervalle.py).
 <p><strong>🎯 Merksatz</strong> Die Frage „welcher Solver ist der beste?“ ist schlecht gestellt. Die gute Frage lautet: „Wie teuer ist es, den Solver zu wechseln?“ Wer sie mit <em>eine Funktion</em> beantworten kann, muss die erste Frage nie entscheiden — er misst.</p>
 </blockquote>
 <hr />
-<h2 id="sec:praxisfallen-eine-checkliste-vor-dem-produktivgang">22.7 Eine Checkliste vor dem Produktivgang</h2>
+<h2 id="sec:praxisfallen-eine-checkliste-vor-dem-produktivgang">22.8 Eine Checkliste vor dem Produktivgang</h2>
 <p>Arbeiten Sie diese Liste ab, bevor ein OR-System in Betrieb geht:</p>
 <p><strong>Modell</strong> - [ ] Alle Nebenbedingungen sind dokumentiert — mit fachlicher Begründung, nicht nur als Code. - [ ] Für jede harte Bedingung ist geprüft: Muss sie wirklich hart sein? - [ ] Es gibt eine Relaxationsstrategie für den Infeasible-Fall. - [ ] Big-M-Werte sind so klein wie möglich gewählt. - [ ] Die Zielfunktion ist in konsistenten Einheiten formuliert.</p>
 <p><strong>Daten</strong> - [ ] Spaltenreihenfolge und Datentypen werden nach jedem Import geprüft. - [ ] Fehlende Werte und Ausreißer haben eine definierte Behandlung. - [ ] Kovarianzmatrizen werden auf positive Definitheit geprüft. - [ ] Datenstände sind versioniert und reproduzierbar.</p>
 <p><strong>Validierung</strong> - [ ] Das Ergebnis wurde gegen eine unabhängige Rechnung geprüft (Handrechnung, zweiter Solver, Simulation). - [ ] Alle Nebenbedingungen werden nach dem Lösen per <code>assert</code> verifiziert. - [ ] Es gibt einen Vergleich gegen eine naive Referenzstrategie. - [ ] Bei Backtests: Lookahead-Selbsttest bestanden, Zahl der Versuche protokolliert.</p>
 <p><strong>Betrieb</strong> - [ ] Zeitlimit und akzeptierter Gap sind festgelegt und begründet. - [ ] Es gibt eine Fallback-Strategie und Alarmierung. - [ ] Jedes Ergebnis ist mit Snapshot-ID, Modellversion und Solver-Version protokolliert. - [ ] Die Ergebnisse sind erklärbar (Kostenzerlegung, Schattenpreise, Constraint-Trace).</p>
 <hr />
-<h2 id="sec:praxisfallen-weiterfuehrende-literatur-und-roadmap">22.8 Weiterführende Literatur und Roadmap</h2>
+<h2 id="sec:praxisfallen-weiterfuehrende-literatur-und-roadmap">22.9 Weiterführende Literatur und Roadmap</h2>
 <p><strong>Grundlagen und lineare/ganzzahlige Optimierung</strong> * Bertsimas &amp; Tsitsiklis: <em>Introduction to Linear Optimization</em> — Standardwerk zu Simplex, Dualität, Polyedertheorie. * Wolsey: <em>Integer Programming</em> — Branch-and-Cut, Schnittebenen, Formulierungsstärke.</p>
 <p><strong>Konvexe Optimierung</strong> * Boyd &amp; Vandenberghe: <em>Convex Optimization</em> — Pflichtlektüre; frei verfügbar. Die theoretische Basis von CVXPY.</p>
 <p><strong>Constraint Programming und Scheduling</strong> * Google OR-Tools Dokumentation und das CP-SAT-Primer von Laurent Perron.</p>
@@ -1753,22 +2191,23 @@ ein unzuverlaessiger Test (siehe JobShop_Intervalle.py).
 </tbody>
 </table>
 <hr />
-<h2 id="sec:praxisfallen-uebungsaufgaben">22.9 Übungsaufgaben</h2>
+<h2 id="sec:praxisfallen-uebungsaufgaben">22.10 Übungsaufgaben</h2>
 <blockquote>
 <p>Lösungen: <a href="anhang-loesungen.html#sec:loesungen-praxisfallen">Abschnitt A.22</a>.</p>
 </blockquote>
 <p><strong>Aufgabe 22.1 ⭐ — Hart oder weich, revisited.</strong> Nennen Sie für ein Vertretungsplanungssystem je zwei Bedingungen, die (a) zwingend hart bleiben müssen, (b) unbedingt weich sein sollten, (c) diskutabel sind. Begründen Sie.</p>
 <p><strong>Aufgabe 22.2 ⭐ — Zeitlimit wählen.</strong> Für welche Szenarien setzen Sie welches Zeitlimit und welchen Gap? (a) Taxi-Disposition in Echtzeit, (b) Wochendienstplan, freitags erstellt, (c) Jahresproduktionsplanung, (d) Portfolio-Rebalancing monatlich.</p>
-<p><strong>Aufgabe 22.3 ⭐⭐ — Relaxation einbauen.</strong> Nehmen Sie Ihr Modell aus Übung 6.7 (Wochendienstplan) und machen Sie es <code>INFEASIBLE</code>-sicher: Schlupfvariablen für unbesetzte Schichten, gestaffelte Strafen. Testen Sie mit einem bewusst überlasteten Szenario.</p>
+<p><strong>Aufgabe 22.3 ⭐⭐ — Relaxation einbauen.</strong> Nehmen Sie Ihr Modell aus der Aufgabe <em>Eigener Dienstplan</em> (<a href="cpsat.html#sec:cpsat-uebungsaufgaben">Abschnitt 7.9</a>) und machen Sie es <code>INFEASIBLE</code>-sicher: Schlupfvariablen für unbesetzte Schichten, gestaffelte Strafen. Testen Sie mit einem bewusst überlasteten Szenario.</p>
 <p><strong>Aufgabe 22.4 ⭐⭐ — Erklärbarkeit implementieren.</strong> Erweitern Sie ein beliebiges Modell aus dem Kurs um einen <code>erklaere(loesung)</code>-Report, der die drei Fragen aus <a href="#sec:praxisfallen-die-fuenf-typischen-praxisfallen">Abschnitt 22.3</a> beantwortet.</p>
-<p><strong>Aufgabe 22.5 ⭐⭐⭐ — Gap gegen Laufzeit.</strong> Nehmen Sie das MILP-Portfolio aus <a href="milp.html#kap-milp">Kapitel 6</a> und vergrößern Sie es auf 50 Anlagen. Messen Sie Laufzeit und Zielwert bei Gap-Vorgaben von 10 %, 5 %, 2 %, 1 %, 0,1 % und 0 %. Stellen Sie den Zusammenhang grafisch dar und leiten Sie eine Empfehlung ab.</p>
-<p><strong>Aufgabe 22.6 ⭐⭐⭐ — Post-Mortem schreiben.</strong> Suchen Sie sich einen der im Buch besprochenen Fehler aus (z. B. die Vorzeichenfalle in <a href="lp.html#sec:lp-die-vorzeichenfalle-bei-schattenpreisen">Abschnitt 5.7</a>, die ungültige Kovarianzmatrix in <a href="qp-nlp.html#kap-qp-nlp">Kapitel 11</a>, die Sektor-Positionsindizes in <a href="markowitz.html#kap-markowitz">Kapitel 19</a>, die vermischten Einheiten in <a href="cvar.html#sec:cvar-implementierung-cvar-portfolio-mit-reibung">Abschnitt 20.6</a> oder die Rebalancing-Termine in <a href="handelsmaschine.html#sec:handelsmaschine-rebalancing-termine-richtig-bestimmen">Abschnitt 21.4</a>) und schreiben Sie ein einseitiges Post-Mortem: Was war der Fehler? Warum fiel er nicht auf? Welche Prüfung hätte ihn gefunden? Welche Regel leiten Sie daraus für eigene Projekte ab?</p>
+<p><strong>Aufgabe 22.5 ⭐⭐ — Den Bericht in die Irre führen.</strong> <code>Constraint_Attribution.py</code> erzeugt seinen Bericht aus gerechneten Zahlen — richtig ist er deshalb noch nicht. (a) Setzen Sie den Deckungsbeitrag von <em>Deckel</em> von 9 € auf 20 €. Wie ändern sich Plan, Rangliste und Bericht? Welche Sätze bleiben wörtlich stehen, obwohl sie jetzt etwas anderes bedeuten? (b) Der Bericht nennt „Liefervertrag Träger” als teuerste Bindung. Formulieren Sie den Satz so um, dass ein Leser erkennt, <strong>worauf</strong> die Aussage beruht. (c) Welche Angabe müsste das Programm zusätzlich ausgeben, damit ein Empfänger die Belastbarkeit selbst einschätzen kann?</p>
+<p><strong>Aufgabe 22.6 ⭐⭐⭐ — Gap gegen Laufzeit.</strong> Nehmen Sie das MILP-Portfolio aus <a href="milp.html#kap-milp">Kapitel 6</a> und vergrößern Sie es auf 50 Anlagen. Messen Sie Laufzeit und Zielwert bei Gap-Vorgaben von 10 %, 5 %, 2 %, 1 %, 0,1 % und 0 %. Stellen Sie den Zusammenhang grafisch dar und leiten Sie eine Empfehlung ab.</p>
+<p><strong>Aufgabe 22.7 ⭐⭐⭐ — Post-Mortem schreiben.</strong> Suchen Sie sich einen der im Buch besprochenen Fehler aus (z. B. die Vorzeichenfalle in <a href="lp.html#sec:lp-die-vorzeichenfalle-bei-schattenpreisen">Abschnitt 5.7</a>, die ungültige Kovarianzmatrix in <a href="qp-nlp.html#kap-qp-nlp">Kapitel 11</a>, die Sektor-Positionsindizes in <a href="markowitz.html#kap-markowitz">Kapitel 19</a>, die vermischten Einheiten in <a href="cvar.html#sec:cvar-implementierung-cvar-portfolio-mit-reibung">Abschnitt 20.6</a> oder die Rebalancing-Termine in <a href="handelsmaschine.html#sec:handelsmaschine-rebalancing-termine-richtig-bestimmen">Abschnitt 21.4</a>) und schreiben Sie ein einseitiges Post-Mortem: Was war der Fehler? Warum fiel er nicht auf? Welche Prüfung hätte ihn gefunden? Welche Regel leiten Sie daraus für eigene Projekte ab?</p>
 <hr />
-<h2 id="sec:praxisfallen-denkfehler">22.10 Finde den Denkfehler</h2>
+<h2 id="sec:praxisfallen-denkfehler">22.11 Finde den Denkfehler</h2>
 <p>Falle 5 — die Laufzeitexplosion — zeigt sich im Betrieb selten als Absturz. Sie zeigt sich als <strong>gar nichts</strong>.</p>
 <div class="card card-denkfehler">
 <blockquote>
-<p><strong>🐛 Finde den Denkfehler 15.1: Das Modell, das seit einem Jahr nicht mehr optimiert</strong></p>
+<p><strong>🐛 Finde den Denkfehler: Das Modell, das seit einem Jahr nicht mehr optimiert</strong></p>
 <p>Ein Standortplanungsmodell geht 2024 in Betrieb. Es läuft jede Nacht, hat drei Sekunden Zeitbudget und liefert zuverlässig die Kosten des Tagesplans. Das Betriebsteam überwacht Abstürze und Laufzeitspitzen — beides tritt nie auf.</p>
 <p>Zwei Jahre später ist das Unternehmen von 15 auf 80 Lager gewachsen. Am Code hat niemand etwas geändert; es gab ja keinen Anlass. Das Protokoll sieht so aus:</p>
 <table>
@@ -1807,186 +2246,186 @@ ein unzuverlaessiger Test (siehe JobShop_Intervalle.py).
 <p><em>Auflösung: <a href="anhang-loesungen.html#sec:loesungen-praxisfallen">Abschnitt A.22</a>.</em></p>
 </blockquote>
 </div>
-<div class="sourceCode" id="cb10"><pre class="sourceCode python"><code class="sourceCode python"><span id="cb10-1"><a href="#cb10-1" aria-hidden="true" tabindex="-1"></a><span class="co">#!/usr/bin/env python3</span></span>
-<span id="cb10-2"><a href="#cb10-2" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb10-3"><a href="#cb10-3" aria-hidden="true" tabindex="-1"></a><span class="co"># Betriebsueberwachung.py</span></span>
-<span id="cb10-4"><a href="#cb10-4" aria-hidden="true" tabindex="-1"></a><span class="co">&quot;&quot;&quot;</span></span>
-<span id="cb10-5"><a href="#cb10-5" aria-hidden="true" tabindex="-1"></a><span class="co">Kapitel Praxisfallen: Das Modell, das still aufgehoert hat zu optimieren.</span></span>
-<span id="cb10-6"><a href="#cb10-6" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb10-7"><a href="#cb10-7" aria-hidden="true" tabindex="-1"></a><span class="co">Ein Optimierungsmodell geht in Betrieb und laeuft jede Nacht. Es liefert</span></span>
-<span id="cb10-8"><a href="#cb10-8" aria-hidden="true" tabindex="-1"></a><span class="co">zuverlaessig eine Zahl, die Job-Dauer bleibt konstant, es gibt keine</span></span>
-<span id="cb10-9"><a href="#cb10-9" aria-hidden="true" tabindex="-1"></a><span class="co">Fehlermeldung. Alles sieht gut aus.</span></span>
-<span id="cb10-10"><a href="#cb10-10" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb10-11"><a href="#cb10-11" aria-hidden="true" tabindex="-1"></a><span class="co">Waehrenddessen waechst das Unternehmen. Aus 15 Lagern werden 40, dann 80. Das</span></span>
-<span id="cb10-12"><a href="#cb10-12" aria-hidden="true" tabindex="-1"></a><span class="co">Zeitlimit von drei Sekunden - vor zwei Jahren grosszuegig bemessen - reicht</span></span>
-<span id="cb10-13"><a href="#cb10-13" aria-hidden="true" tabindex="-1"></a><span class="co">irgendwann nicht mehr. Der Solver bricht ab und liefert die beste Loesung, die</span></span>
-<span id="cb10-14"><a href="#cb10-14" aria-hidden="true" tabindex="-1"></a><span class="co">er bis dahin gefunden hat.</span></span>
-<span id="cb10-15"><a href="#cb10-15" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb10-16"><a href="#cb10-16" aria-hidden="true" tabindex="-1"></a><span class="co">Das ist nicht falsch. Es ist sogar richtig so. Aber es ist etwas anderes als</span></span>
-<span id="cb10-17"><a href="#cb10-17" aria-hidden="true" tabindex="-1"></a><span class="co">das, was das Modell einmal geleistet hat - und niemand merkt es, weil im</span></span>
-<span id="cb10-18"><a href="#cb10-18" aria-hidden="true" tabindex="-1"></a><span class="co">Protokoll nur die Kosten stehen.</span></span>
-<span id="cb10-19"><a href="#cb10-19" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb10-20"><a href="#cb10-20" aria-hidden="true" tabindex="-1"></a><span class="co">Dieses Programm zeigt die Verschlechterung und die Ueberwachung, die sie</span></span>
-<span id="cb10-21"><a href="#cb10-21" aria-hidden="true" tabindex="-1"></a><span class="co">sichtbar macht.</span></span>
-<span id="cb10-22"><a href="#cb10-22" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb10-23"><a href="#cb10-23" aria-hidden="true" tabindex="-1"></a><span class="co">WICHTIG: ortools wird hier nicht importiert (Konflikt mit highspy, siehe</span></span>
-<span id="cb10-24"><a href="#cb10-24" aria-hidden="true" tabindex="-1"></a><span class="co">Kapitel Oekosystem).</span></span>
-<span id="cb10-25"><a href="#cb10-25" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb10-26"><a href="#cb10-26" aria-hidden="true" tabindex="-1"></a><span class="co">Benoetigt: numpy, highspy</span></span>
-<span id="cb10-27"><a href="#cb10-27" aria-hidden="true" tabindex="-1"></a><span class="co">&quot;&quot;&quot;</span></span>
-<span id="cb10-28"><a href="#cb10-28" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb10-29"><a href="#cb10-29" aria-hidden="true" tabindex="-1"></a><span class="im">from</span> __future__ <span class="im">import</span> annotations</span>
-<span id="cb10-30"><a href="#cb10-30" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb10-31"><a href="#cb10-31" aria-hidden="true" tabindex="-1"></a><span class="im">import</span> time</span>
-<span id="cb10-32"><a href="#cb10-32" aria-hidden="true" tabindex="-1"></a><span class="im">from</span> dataclasses <span class="im">import</span> dataclass</span>
-<span id="cb10-33"><a href="#cb10-33" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb10-34"><a href="#cb10-34" aria-hidden="true" tabindex="-1"></a><span class="im">import</span> numpy <span class="im">as</span> np</span>
-<span id="cb10-35"><a href="#cb10-35" aria-hidden="true" tabindex="-1"></a><span class="im">import</span> highspy</span>
-<span id="cb10-36"><a href="#cb10-36" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb10-37"><a href="#cb10-37" aria-hidden="true" tabindex="-1"></a>ZEITLIMIT <span class="op">=</span> <span class="fl">3.0</span>                  <span class="co"># das Budget, das der Nachtjob hat</span></span>
-<span id="cb10-38"><a href="#cb10-38" aria-hidden="true" tabindex="-1"></a>GAP_WARNSCHWELLE <span class="op">=</span> <span class="fl">0.02</span>          <span class="co"># ab 2 % Gap wollen wir es wissen</span></span>
-<span id="cb10-39"><a href="#cb10-39" aria-hidden="true" tabindex="-1"></a>ZEITAUSLASTUNG_WARNSCHWELLE <span class="op">=</span> <span class="fl">0.9</span></span>
-<span id="cb10-40"><a href="#cb10-40" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb10-41"><a href="#cb10-41" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb10-42"><a href="#cb10-42" aria-hidden="true" tabindex="-1"></a><span class="at">@dataclass</span></span>
-<span id="cb10-43"><a href="#cb10-43" aria-hidden="true" tabindex="-1"></a><span class="kw">class</span> Laufprotokoll:</span>
-<span id="cb10-44"><a href="#cb10-44" aria-hidden="true" tabindex="-1"></a>    <span class="co">&quot;&quot;&quot;Was nach JEDEM Produktivlauf protokolliert gehoert.</span></span>
-<span id="cb10-45"><a href="#cb10-45" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb10-46"><a href="#cb10-46" aria-hidden="true" tabindex="-1"></a><span class="co">    Die meisten Systeme schreiben nur &#39;kosten&#39;. Genau deshalb faellt eine</span></span>
-<span id="cb10-47"><a href="#cb10-47" aria-hidden="true" tabindex="-1"></a><span class="co">    schleichende Verschlechterung ueber Monate nicht auf.</span></span>
-<span id="cb10-48"><a href="#cb10-48" aria-hidden="true" tabindex="-1"></a><span class="co">    &quot;&quot;&quot;</span></span>
-<span id="cb10-49"><a href="#cb10-49" aria-hidden="true" tabindex="-1"></a>    zeitpunkt: <span class="bu">str</span></span>
-<span id="cb10-50"><a href="#cb10-50" aria-hidden="true" tabindex="-1"></a>    lager: <span class="bu">int</span></span>
-<span id="cb10-51"><a href="#cb10-51" aria-hidden="true" tabindex="-1"></a>    kunden: <span class="bu">int</span></span>
-<span id="cb10-52"><a href="#cb10-52" aria-hidden="true" tabindex="-1"></a>    status: <span class="bu">str</span></span>
-<span id="cb10-53"><a href="#cb10-53" aria-hidden="true" tabindex="-1"></a>    kosten: <span class="bu">float</span></span>
-<span id="cb10-54"><a href="#cb10-54" aria-hidden="true" tabindex="-1"></a>    gap: <span class="bu">float</span></span>
-<span id="cb10-55"><a href="#cb10-55" aria-hidden="true" tabindex="-1"></a>    laufzeit: <span class="bu">float</span></span>
-<span id="cb10-56"><a href="#cb10-56" aria-hidden="true" tabindex="-1"></a>    knoten: <span class="bu">int</span></span>
-<span id="cb10-57"><a href="#cb10-57" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb10-58"><a href="#cb10-58" aria-hidden="true" tabindex="-1"></a>    <span class="at">@property</span></span>
-<span id="cb10-59"><a href="#cb10-59" aria-hidden="true" tabindex="-1"></a>    <span class="kw">def</span> warnungen(<span class="va">self</span>) <span class="op">-&gt;</span> <span class="bu">list</span>[<span class="bu">str</span>]:</span>
-<span id="cb10-60"><a href="#cb10-60" aria-hidden="true" tabindex="-1"></a>        meldungen <span class="op">=</span> []</span>
-<span id="cb10-61"><a href="#cb10-61" aria-hidden="true" tabindex="-1"></a>        <span class="cf">if</span> <span class="va">self</span>.status <span class="op">!=</span> <span class="st">&quot;Optimal&quot;</span>:</span>
-<span id="cb10-62"><a href="#cb10-62" aria-hidden="true" tabindex="-1"></a>            meldungen.append(<span class="ss">f&quot;nicht beweisbar optimal (</span><span class="sc">{</span><span class="va">self</span><span class="sc">.</span>status<span class="sc">}</span><span class="ss">)&quot;</span>)</span>
-<span id="cb10-63"><a href="#cb10-63" aria-hidden="true" tabindex="-1"></a>        <span class="cf">if</span> <span class="va">self</span>.gap <span class="op">&gt;</span> GAP_WARNSCHWELLE:</span>
-<span id="cb10-64"><a href="#cb10-64" aria-hidden="true" tabindex="-1"></a>            meldungen.append(<span class="ss">f&quot;Gap </span><span class="sc">{</span><span class="va">self</span><span class="sc">.</span>gap<span class="sc">:.1%}</span><span class="ss"> ueber Schwelle &quot;</span></span>
-<span id="cb10-65"><a href="#cb10-65" aria-hidden="true" tabindex="-1"></a>                             <span class="ss">f&quot;</span><span class="sc">{</span>GAP_WARNSCHWELLE<span class="sc">:.0%}</span><span class="ss">&quot;</span>)</span>
-<span id="cb10-66"><a href="#cb10-66" aria-hidden="true" tabindex="-1"></a>        <span class="cf">if</span> <span class="va">self</span>.laufzeit <span class="op">&gt;</span> ZEITAUSLASTUNG_WARNSCHWELLE <span class="op">*</span> ZEITLIMIT:</span>
-<span id="cb10-67"><a href="#cb10-67" aria-hidden="true" tabindex="-1"></a>            meldungen.append(<span class="ss">f&quot;Zeitbudget zu </span><span class="sc">{</span><span class="va">self</span><span class="sc">.</span>laufzeit <span class="op">/</span> ZEITLIMIT<span class="sc">:.0%}</span><span class="ss"> &quot;</span></span>
-<span id="cb10-68"><a href="#cb10-68" aria-hidden="true" tabindex="-1"></a>                             <span class="ss">f&quot;ausgeschoepft&quot;</span>)</span>
-<span id="cb10-69"><a href="#cb10-69" aria-hidden="true" tabindex="-1"></a>        <span class="cf">return</span> meldungen</span>
-<span id="cb10-70"><a href="#cb10-70" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb10-71"><a href="#cb10-71" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb10-72"><a href="#cb10-72" aria-hidden="true" tabindex="-1"></a><span class="kw">def</span> plane_netzwerk(n_lager: <span class="bu">int</span>, n_kunden: <span class="bu">int</span>, zeitlimit: <span class="bu">float</span>,</span>
-<span id="cb10-73"><a href="#cb10-73" aria-hidden="true" tabindex="-1"></a>                   saat: <span class="bu">int</span> <span class="op">=</span> <span class="dv">7</span>) <span class="op">-&gt;</span> <span class="bu">tuple</span>[<span class="bu">str</span>, <span class="bu">float</span>, <span class="bu">float</span>, <span class="bu">float</span>, <span class="bu">int</span>]:</span>
-<span id="cb10-74"><a href="#cb10-74" aria-hidden="true" tabindex="-1"></a>    <span class="co">&quot;&quot;&quot;Standortplanung wie in Kapitel MILP, nur mit wachsender Groesse.&quot;&quot;&quot;</span></span>
-<span id="cb10-75"><a href="#cb10-75" aria-hidden="true" tabindex="-1"></a>    rng <span class="op">=</span> np.random.default_rng(saat)</span>
-<span id="cb10-76"><a href="#cb10-76" aria-hidden="true" tabindex="-1"></a>    fixkosten <span class="op">=</span> rng.uniform(<span class="dv">3000</span>, <span class="dv">9000</span>, n_lager)</span>
-<span id="cb10-77"><a href="#cb10-77" aria-hidden="true" tabindex="-1"></a>    transport <span class="op">=</span> rng.uniform(<span class="dv">5</span>, <span class="dv">60</span>, (n_lager, n_kunden))</span>
-<span id="cb10-78"><a href="#cb10-78" aria-hidden="true" tabindex="-1"></a>    bedarf <span class="op">=</span> rng.uniform(<span class="dv">10</span>, <span class="dv">60</span>, n_kunden)</span>
-<span id="cb10-79"><a href="#cb10-79" aria-hidden="true" tabindex="-1"></a>    kapazitaet <span class="op">=</span> np.full(n_lager, bedarf.<span class="bu">sum</span>() <span class="op">*</span> <span class="fl">0.22</span>)</span>
-<span id="cb10-80"><a href="#cb10-80" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb10-81"><a href="#cb10-81" aria-hidden="true" tabindex="-1"></a>    modell <span class="op">=</span> highspy.Highs()</span>
-<span id="cb10-82"><a href="#cb10-82" aria-hidden="true" tabindex="-1"></a>    modell.setOptionValue(<span class="st">&quot;output_flag&quot;</span>, <span class="va">False</span>)</span>
-<span id="cb10-83"><a href="#cb10-83" aria-hidden="true" tabindex="-1"></a>    modell.setOptionValue(<span class="st">&quot;time_limit&quot;</span>, zeitlimit)</span>
-<span id="cb10-84"><a href="#cb10-84" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb10-85"><a href="#cb10-85" aria-hidden="true" tabindex="-1"></a>    anzahl_x <span class="op">=</span> n_lager <span class="op">*</span> n_kunden</span>
-<span id="cb10-86"><a href="#cb10-86" aria-hidden="true" tabindex="-1"></a>    unendlich <span class="op">=</span> highspy.kHighsInf</span>
-<span id="cb10-87"><a href="#cb10-87" aria-hidden="true" tabindex="-1"></a>    modell.addVars(anzahl_x, np.zeros(anzahl_x), np.full(anzahl_x, unendlich))</span>
-<span id="cb10-88"><a href="#cb10-88" aria-hidden="true" tabindex="-1"></a>    modell.addVars(n_lager, np.zeros(n_lager), np.ones(n_lager))</span>
-<span id="cb10-89"><a href="#cb10-89" aria-hidden="true" tabindex="-1"></a>    <span class="cf">for</span> i <span class="kw">in</span> <span class="bu">range</span>(n_lager):</span>
-<span id="cb10-90"><a href="#cb10-90" aria-hidden="true" tabindex="-1"></a>        modell.changeColIntegrality(anzahl_x <span class="op">+</span> i, highspy.HighsVarType.kInteger)</span>
-<span id="cb10-91"><a href="#cb10-91" aria-hidden="true" tabindex="-1"></a>        modell.changeColCost(anzahl_x <span class="op">+</span> i, fixkosten[i])</span>
-<span id="cb10-92"><a href="#cb10-92" aria-hidden="true" tabindex="-1"></a>        <span class="cf">for</span> j <span class="kw">in</span> <span class="bu">range</span>(n_kunden):</span>
-<span id="cb10-93"><a href="#cb10-93" aria-hidden="true" tabindex="-1"></a>            modell.changeColCost(i <span class="op">*</span> n_kunden <span class="op">+</span> j, transport[i, j])</span>
-<span id="cb10-94"><a href="#cb10-94" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb10-95"><a href="#cb10-95" aria-hidden="true" tabindex="-1"></a>    <span class="cf">for</span> j <span class="kw">in</span> <span class="bu">range</span>(n_kunden):</span>
-<span id="cb10-96"><a href="#cb10-96" aria-hidden="true" tabindex="-1"></a>        index <span class="op">=</span> np.array([i <span class="op">*</span> n_kunden <span class="op">+</span> j <span class="cf">for</span> i <span class="kw">in</span> <span class="bu">range</span>(n_lager)], dtype<span class="op">=</span>np.int32)</span>
-<span id="cb10-97"><a href="#cb10-97" aria-hidden="true" tabindex="-1"></a>        modell.addRow(bedarf[j], bedarf[j], <span class="bu">len</span>(index), index, np.ones(<span class="bu">len</span>(index)))</span>
-<span id="cb10-98"><a href="#cb10-98" aria-hidden="true" tabindex="-1"></a>    <span class="cf">for</span> i <span class="kw">in</span> <span class="bu">range</span>(n_lager):</span>
-<span id="cb10-99"><a href="#cb10-99" aria-hidden="true" tabindex="-1"></a>        index <span class="op">=</span> np.array([i <span class="op">*</span> n_kunden <span class="op">+</span> j <span class="cf">for</span> j <span class="kw">in</span> <span class="bu">range</span>(n_kunden)] <span class="op">+</span> [anzahl_x <span class="op">+</span> i],</span>
-<span id="cb10-100"><a href="#cb10-100" aria-hidden="true" tabindex="-1"></a>                         dtype<span class="op">=</span>np.int32)</span>
-<span id="cb10-101"><a href="#cb10-101" aria-hidden="true" tabindex="-1"></a>        werte <span class="op">=</span> np.concatenate([np.ones(n_kunden), [<span class="op">-</span>kapazitaet[i]]])</span>
-<span id="cb10-102"><a href="#cb10-102" aria-hidden="true" tabindex="-1"></a>        modell.addRow(<span class="op">-</span>unendlich, <span class="fl">0.0</span>, <span class="bu">len</span>(index), index, werte)</span>
-<span id="cb10-103"><a href="#cb10-103" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb10-104"><a href="#cb10-104" aria-hidden="true" tabindex="-1"></a>    t0 <span class="op">=</span> time.perf_counter()</span>
-<span id="cb10-105"><a href="#cb10-105" aria-hidden="true" tabindex="-1"></a>    modell.run()</span>
-<span id="cb10-106"><a href="#cb10-106" aria-hidden="true" tabindex="-1"></a>    laufzeit <span class="op">=</span> time.perf_counter() <span class="op">-</span> t0</span>
-<span id="cb10-107"><a href="#cb10-107" aria-hidden="true" tabindex="-1"></a>    info <span class="op">=</span> modell.getInfo()</span>
-<span id="cb10-108"><a href="#cb10-108" aria-hidden="true" tabindex="-1"></a>    <span class="cf">return</span> (modell.modelStatusToString(modell.getModelStatus()),</span>
-<span id="cb10-109"><a href="#cb10-109" aria-hidden="true" tabindex="-1"></a>            info.objective_function_value, info.mip_gap, laufzeit,</span>
-<span id="cb10-110"><a href="#cb10-110" aria-hidden="true" tabindex="-1"></a>            info.mip_node_count)</span>
-<span id="cb10-111"><a href="#cb10-111" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb10-112"><a href="#cb10-112" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb10-113"><a href="#cb10-113" aria-hidden="true" tabindex="-1"></a><span class="cf">if</span> <span class="va">__name__</span> <span class="op">==</span> <span class="st">&quot;__main__&quot;</span>:</span>
-<span id="cb10-114"><a href="#cb10-114" aria-hidden="true" tabindex="-1"></a>    <span class="co"># So ist das Unternehmen ueber zwei Jahre gewachsen.</span></span>
-<span id="cb10-115"><a href="#cb10-115" aria-hidden="true" tabindex="-1"></a>    entwicklung <span class="op">=</span> [(<span class="st">&quot;2024-Q1&quot;</span>, <span class="dv">15</span>, <span class="dv">40</span>), (<span class="st">&quot;2024-Q3&quot;</span>, <span class="dv">25</span>, <span class="dv">70</span>),</span>
-<span id="cb10-116"><a href="#cb10-116" aria-hidden="true" tabindex="-1"></a>                   (<span class="st">&quot;2025-Q1&quot;</span>, <span class="dv">40</span>, <span class="dv">110</span>), (<span class="st">&quot;2025-Q3&quot;</span>, <span class="dv">60</span>, <span class="dv">160</span>),</span>
-<span id="cb10-117"><a href="#cb10-117" aria-hidden="true" tabindex="-1"></a>                   (<span class="st">&quot;2026-Q1&quot;</span>, <span class="dv">80</span>, <span class="dv">220</span>)]</span>
-<span id="cb10-118"><a href="#cb10-118" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb10-119"><a href="#cb10-119" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;=&quot;</span> <span class="op">*</span> <span class="dv">84</span>)</span>
-<span id="cb10-120"><a href="#cb10-120" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;  WAS DAS PROTOKOLL ZEIGT - UND WAS ES ZEIGEN SOLLTE&quot;</span>)</span>
-<span id="cb10-121"><a href="#cb10-121" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;=&quot;</span> <span class="op">*</span> <span class="dv">84</span>)</span>
-<span id="cb10-122"><a href="#cb10-122" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;Derselbe Nachtjob, unveraendert, mit </span><span class="sc">{</span>ZEITLIMIT<span class="sc">:.0f}</span><span class="ss"> Sekunden Zeitlimit.</span><span class="ch">\n</span><span class="ss">&quot;</span>)</span>
-<span id="cb10-123"><a href="#cb10-123" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb10-124"><a href="#cb10-124" aria-hidden="true" tabindex="-1"></a>    protokolle <span class="op">=</span> []</span>
-<span id="cb10-125"><a href="#cb10-125" aria-hidden="true" tabindex="-1"></a>    <span class="cf">for</span> zeitpunkt, lager, kunden <span class="kw">in</span> entwicklung:</span>
-<span id="cb10-126"><a href="#cb10-126" aria-hidden="true" tabindex="-1"></a>        status, kosten, gap, laufzeit, knoten <span class="op">=</span> plane_netzwerk(</span>
-<span id="cb10-127"><a href="#cb10-127" aria-hidden="true" tabindex="-1"></a>            lager, kunden, ZEITLIMIT)</span>
-<span id="cb10-128"><a href="#cb10-128" aria-hidden="true" tabindex="-1"></a>        protokolle.append(Laufprotokoll(zeitpunkt, lager, kunden, status,</span>
-<span id="cb10-129"><a href="#cb10-129" aria-hidden="true" tabindex="-1"></a>                                        kosten, gap, laufzeit, knoten))</span>
-<span id="cb10-130"><a href="#cb10-130" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb10-131"><a href="#cb10-131" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;So sieht das ueblich gefuehrte Protokoll aus:</span><span class="ch">\n</span><span class="st">&quot;</span>)</span>
-<span id="cb10-132"><a href="#cb10-132" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;  </span><span class="sc">{</span><span class="st">&#39;Zeitpunkt&#39;</span><span class="sc">:&lt;10}</span><span class="ss"> </span><span class="sc">{</span><span class="st">&#39;Kosten&#39;</span><span class="sc">:&gt;12}</span><span class="ss">&quot;</span>)</span>
-<span id="cb10-133"><a href="#cb10-133" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;  &quot;</span> <span class="op">+</span> <span class="st">&quot;-&quot;</span> <span class="op">*</span> <span class="dv">24</span>)</span>
-<span id="cb10-134"><a href="#cb10-134" aria-hidden="true" tabindex="-1"></a>    <span class="cf">for</span> p <span class="kw">in</span> protokolle:</span>
-<span id="cb10-135"><a href="#cb10-135" aria-hidden="true" tabindex="-1"></a>        <span class="bu">print</span>(<span class="ss">f&quot;  </span><span class="sc">{</span>p<span class="sc">.</span>zeitpunkt<span class="sc">:&lt;10}</span><span class="ss"> </span><span class="sc">{</span>p<span class="sc">.</span>kosten<span class="sc">:&gt;12,.0f}</span><span class="ss">&quot;</span>)</span>
-<span id="cb10-136"><a href="#cb10-136" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;</span><span class="ch">\n</span><span class="st">  -&gt; Die Kosten steigen. Das Unternehmen waechst ja auch.&quot;</span>)</span>
-<span id="cb10-137"><a href="#cb10-137" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;     Nichts an dieser Tabelle deutet auf ein Problem hin.&quot;</span>)</span>
-<span id="cb10-138"><a href="#cb10-138" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb10-139"><a href="#cb10-139" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;</span><span class="ch">\n</span><span class="st">&quot;</span> <span class="op">+</span> <span class="st">&quot;-&quot;</span> <span class="op">*</span> <span class="dv">84</span>)</span>
-<span id="cb10-140"><a href="#cb10-140" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;So sieht ein vollstaendiges Protokoll aus:</span><span class="ch">\n</span><span class="st">&quot;</span>)</span>
-<span id="cb10-141"><a href="#cb10-141" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;  </span><span class="sc">{</span><span class="st">&#39;Zeitpunkt&#39;</span><span class="sc">:&lt;10}</span><span class="ss"> </span><span class="sc">{</span><span class="st">&#39;Groesse&#39;</span><span class="sc">:&gt;10}</span><span class="ss"> </span><span class="sc">{</span><span class="st">&#39;Status&#39;</span><span class="sc">:&gt;20}</span><span class="ss"> </span><span class="sc">{</span><span class="st">&#39;Kosten&#39;</span><span class="sc">:&gt;11}</span><span class="ss"> &quot;</span></span>
-<span id="cb10-142"><a href="#cb10-142" aria-hidden="true" tabindex="-1"></a>          <span class="ss">f&quot;</span><span class="sc">{</span><span class="st">&#39;Gap&#39;</span><span class="sc">:&gt;8}</span><span class="ss"> </span><span class="sc">{</span><span class="st">&#39;Zeit&#39;</span><span class="sc">:&gt;7}</span><span class="ss">&quot;</span>)</span>
-<span id="cb10-143"><a href="#cb10-143" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;  &quot;</span> <span class="op">+</span> <span class="st">&quot;-&quot;</span> <span class="op">*</span> <span class="dv">80</span>)</span>
-<span id="cb10-144"><a href="#cb10-144" aria-hidden="true" tabindex="-1"></a>    <span class="cf">for</span> p <span class="kw">in</span> protokolle:</span>
-<span id="cb10-145"><a href="#cb10-145" aria-hidden="true" tabindex="-1"></a>        groesse <span class="op">=</span> <span class="ss">f&quot;</span><span class="sc">{</span>p<span class="sc">.</span>lager<span class="sc">}</span><span class="ss">x</span><span class="sc">{</span>p<span class="sc">.</span>kunden<span class="sc">}</span><span class="ss">&quot;</span></span>
-<span id="cb10-146"><a href="#cb10-146" aria-hidden="true" tabindex="-1"></a>        <span class="bu">print</span>(<span class="ss">f&quot;  </span><span class="sc">{</span>p<span class="sc">.</span>zeitpunkt<span class="sc">:&lt;10}</span><span class="ss"> </span><span class="sc">{</span>groesse<span class="sc">:&gt;10}</span><span class="ss"> </span><span class="sc">{</span>p<span class="sc">.</span>status<span class="sc">:&gt;20}</span><span class="ss"> &quot;</span></span>
-<span id="cb10-147"><a href="#cb10-147" aria-hidden="true" tabindex="-1"></a>              <span class="ss">f&quot;</span><span class="sc">{</span>p<span class="sc">.</span>kosten<span class="sc">:&gt;11,.0f}</span><span class="ss"> </span><span class="sc">{</span>p<span class="sc">.</span>gap <span class="op">*</span> <span class="dv">100</span><span class="sc">:7.2f}</span><span class="ss"> % </span><span class="sc">{</span>p<span class="sc">.</span>laufzeit<span class="sc">:6.2f}</span><span class="ss">s&quot;</span>)</span>
-<span id="cb10-148"><a href="#cb10-148" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb10-149"><a href="#cb10-149" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;</span><span class="ch">\n</span><span class="st">&quot;</span> <span class="op">+</span> <span class="st">&quot;-&quot;</span> <span class="op">*</span> <span class="dv">84</span>)</span>
-<span id="cb10-150"><a href="#cb10-150" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;Und so sehen die Warnungen aus, die daraus folgen:</span><span class="ch">\n</span><span class="st">&quot;</span>)</span>
-<span id="cb10-151"><a href="#cb10-151" aria-hidden="true" tabindex="-1"></a>    <span class="cf">for</span> p <span class="kw">in</span> protokolle:</span>
-<span id="cb10-152"><a href="#cb10-152" aria-hidden="true" tabindex="-1"></a>        <span class="cf">if</span> p.warnungen:</span>
-<span id="cb10-153"><a href="#cb10-153" aria-hidden="true" tabindex="-1"></a>            <span class="bu">print</span>(<span class="ss">f&quot;  </span><span class="sc">{</span>p<span class="sc">.</span>zeitpunkt<span class="sc">}</span><span class="ss">:  &quot;</span> <span class="op">+</span> <span class="st">&quot;; &quot;</span>.join(p.warnungen))</span>
-<span id="cb10-154"><a href="#cb10-154" aria-hidden="true" tabindex="-1"></a>        <span class="cf">else</span>:</span>
-<span id="cb10-155"><a href="#cb10-155" aria-hidden="true" tabindex="-1"></a>            <span class="bu">print</span>(<span class="ss">f&quot;  </span><span class="sc">{</span>p<span class="sc">.</span>zeitpunkt<span class="sc">}</span><span class="ss">:  in Ordnung&quot;</span>)</span>
-<span id="cb10-156"><a href="#cb10-156" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb10-157"><a href="#cb10-157" aria-hidden="true" tabindex="-1"></a>    letzte <span class="op">=</span> protokolle[<span class="op">-</span><span class="dv">1</span>]</span>
-<span id="cb10-158"><a href="#cb10-158" aria-hidden="true" tabindex="-1"></a>    erste_warnung <span class="op">=</span> <span class="bu">next</span>(p <span class="cf">for</span> p <span class="kw">in</span> protokolle <span class="cf">if</span> p.warnungen)</span>
-<span id="cb10-159"><a href="#cb10-159" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb10-160"><a href="#cb10-160" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;</span><span class="ch">\n</span><span class="st">&quot;</span> <span class="op">+</span> <span class="st">&quot;=&quot;</span> <span class="op">*</span> <span class="dv">84</span>)</span>
-<span id="cb10-161"><a href="#cb10-161" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;  WAS DA PASSIERT IST&quot;</span>)</span>
-<span id="cb10-162"><a href="#cb10-162" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;=&quot;</span> <span class="op">*</span> <span class="dv">84</span>)</span>
-<span id="cb10-163"><a href="#cb10-163" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;Seit </span><span class="sc">{</span>erste_warnung<span class="sc">.</span>zeitpunkt<span class="sc">}</span><span class="ss"> erreicht der Job das Zeitlimit und liefert&quot;</span>)</span>
-<span id="cb10-164"><a href="#cb10-164" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;nicht mehr das Optimum, sondern die beste bis dahin gefundene Loesung.&quot;</span>)</span>
-<span id="cb10-165"><a href="#cb10-165" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;Im letzten Lauf betraegt der Abstand zum Bestmoeglichen &quot;</span></span>
-<span id="cb10-166"><a href="#cb10-166" aria-hidden="true" tabindex="-1"></a>          <span class="ss">f&quot;</span><span class="sc">{</span>letzte<span class="sc">.</span>gap<span class="sc">:.1%}</span><span class="ss">.&quot;</span>)</span>
-<span id="cb10-167"><a href="#cb10-167" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>()</span>
-<span id="cb10-168"><a href="#cb10-168" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;Der Job ist nicht abgestuerzt. Er hat keine Fehlermeldung erzeugt.&quot;</span>)</span>
-<span id="cb10-169"><a href="#cb10-169" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;Die Laufzeit ist sogar bemerkenswert STABIL geblieben - genau deshalb,&quot;</span>)</span>
-<span id="cb10-170"><a href="#cb10-170" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;weil das Zeitlimit greift. Ein Ueberwachungssystem, das auf Abstuerze&quot;</span>)</span>
-<span id="cb10-171"><a href="#cb10-171" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;und Laufzeitspitzen achtet, sieht hier nichts.&quot;</span>)</span>
-<span id="cb10-172"><a href="#cb10-172" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>()</span>
-<span id="cb10-173"><a href="#cb10-173" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;Drei Zahlen gehoeren deshalb in jedes Protokoll eines Optimierungsjobs:&quot;</span>)</span>
-<span id="cb10-174"><a href="#cb10-174" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;  * der STATUS   - &#39;Optimal&#39; oder etwas anderes?&quot;</span>)</span>
-<span id="cb10-175"><a href="#cb10-175" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;  * der GAP      - wie weit ist die Loesung vom Bestmoeglichen entfernt?&quot;</span>)</span>
-<span id="cb10-176"><a href="#cb10-176" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;  * die LAUFZEIT im Verhaeltnis zum Limit - wie nah am Anschlag?&quot;</span>)</span>
-<span id="cb10-177"><a href="#cb10-177" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>()</span>
-<span id="cb10-178"><a href="#cb10-178" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;Die dritte ist die frueheste Warnung: Sie steigt, lange bevor der Gap&quot;</span>)</span>
-<span id="cb10-179"><a href="#cb10-179" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;sichtbar wird, und gibt Zeit zum Handeln.&quot;</span>)</span>
-<span id="cb10-180"><a href="#cb10-180" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;=&quot;</span> <span class="op">*</span> <span class="dv">84</span>)</span></code></pre></div>
+<div class="sourceCode" id="cb12"><pre class="sourceCode python"><code class="sourceCode python"><span id="cb12-1"><a href="#cb12-1" aria-hidden="true" tabindex="-1"></a><span class="co">#!/usr/bin/env python3</span></span>
+<span id="cb12-2"><a href="#cb12-2" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb12-3"><a href="#cb12-3" aria-hidden="true" tabindex="-1"></a><span class="co"># Betriebsueberwachung.py</span></span>
+<span id="cb12-4"><a href="#cb12-4" aria-hidden="true" tabindex="-1"></a><span class="co">&quot;&quot;&quot;</span></span>
+<span id="cb12-5"><a href="#cb12-5" aria-hidden="true" tabindex="-1"></a><span class="co">Kapitel Praxisfallen: Das Modell, das still aufgehoert hat zu optimieren.</span></span>
+<span id="cb12-6"><a href="#cb12-6" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb12-7"><a href="#cb12-7" aria-hidden="true" tabindex="-1"></a><span class="co">Ein Optimierungsmodell geht in Betrieb und laeuft jede Nacht. Es liefert</span></span>
+<span id="cb12-8"><a href="#cb12-8" aria-hidden="true" tabindex="-1"></a><span class="co">zuverlaessig eine Zahl, die Job-Dauer bleibt konstant, es gibt keine</span></span>
+<span id="cb12-9"><a href="#cb12-9" aria-hidden="true" tabindex="-1"></a><span class="co">Fehlermeldung. Alles sieht gut aus.</span></span>
+<span id="cb12-10"><a href="#cb12-10" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb12-11"><a href="#cb12-11" aria-hidden="true" tabindex="-1"></a><span class="co">Waehrenddessen waechst das Unternehmen. Aus 15 Lagern werden 40, dann 80. Das</span></span>
+<span id="cb12-12"><a href="#cb12-12" aria-hidden="true" tabindex="-1"></a><span class="co">Zeitlimit von drei Sekunden - vor zwei Jahren grosszuegig bemessen - reicht</span></span>
+<span id="cb12-13"><a href="#cb12-13" aria-hidden="true" tabindex="-1"></a><span class="co">irgendwann nicht mehr. Der Solver bricht ab und liefert die beste Loesung, die</span></span>
+<span id="cb12-14"><a href="#cb12-14" aria-hidden="true" tabindex="-1"></a><span class="co">er bis dahin gefunden hat.</span></span>
+<span id="cb12-15"><a href="#cb12-15" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb12-16"><a href="#cb12-16" aria-hidden="true" tabindex="-1"></a><span class="co">Das ist nicht falsch. Es ist sogar richtig so. Aber es ist etwas anderes als</span></span>
+<span id="cb12-17"><a href="#cb12-17" aria-hidden="true" tabindex="-1"></a><span class="co">das, was das Modell einmal geleistet hat - und niemand merkt es, weil im</span></span>
+<span id="cb12-18"><a href="#cb12-18" aria-hidden="true" tabindex="-1"></a><span class="co">Protokoll nur die Kosten stehen.</span></span>
+<span id="cb12-19"><a href="#cb12-19" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb12-20"><a href="#cb12-20" aria-hidden="true" tabindex="-1"></a><span class="co">Dieses Programm zeigt die Verschlechterung und die Ueberwachung, die sie</span></span>
+<span id="cb12-21"><a href="#cb12-21" aria-hidden="true" tabindex="-1"></a><span class="co">sichtbar macht.</span></span>
+<span id="cb12-22"><a href="#cb12-22" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb12-23"><a href="#cb12-23" aria-hidden="true" tabindex="-1"></a><span class="co">WICHTIG: ortools wird hier nicht importiert (Konflikt mit highspy, siehe</span></span>
+<span id="cb12-24"><a href="#cb12-24" aria-hidden="true" tabindex="-1"></a><span class="co">Kapitel Oekosystem).</span></span>
+<span id="cb12-25"><a href="#cb12-25" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb12-26"><a href="#cb12-26" aria-hidden="true" tabindex="-1"></a><span class="co">Benoetigt: numpy, highspy</span></span>
+<span id="cb12-27"><a href="#cb12-27" aria-hidden="true" tabindex="-1"></a><span class="co">&quot;&quot;&quot;</span></span>
+<span id="cb12-28"><a href="#cb12-28" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb12-29"><a href="#cb12-29" aria-hidden="true" tabindex="-1"></a><span class="im">from</span> __future__ <span class="im">import</span> annotations</span>
+<span id="cb12-30"><a href="#cb12-30" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb12-31"><a href="#cb12-31" aria-hidden="true" tabindex="-1"></a><span class="im">import</span> time</span>
+<span id="cb12-32"><a href="#cb12-32" aria-hidden="true" tabindex="-1"></a><span class="im">from</span> dataclasses <span class="im">import</span> dataclass</span>
+<span id="cb12-33"><a href="#cb12-33" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb12-34"><a href="#cb12-34" aria-hidden="true" tabindex="-1"></a><span class="im">import</span> numpy <span class="im">as</span> np</span>
+<span id="cb12-35"><a href="#cb12-35" aria-hidden="true" tabindex="-1"></a><span class="im">import</span> highspy</span>
+<span id="cb12-36"><a href="#cb12-36" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb12-37"><a href="#cb12-37" aria-hidden="true" tabindex="-1"></a>ZEITLIMIT <span class="op">=</span> <span class="fl">3.0</span>                  <span class="co"># das Budget, das der Nachtjob hat</span></span>
+<span id="cb12-38"><a href="#cb12-38" aria-hidden="true" tabindex="-1"></a>GAP_WARNSCHWELLE <span class="op">=</span> <span class="fl">0.02</span>          <span class="co"># ab 2 % Gap wollen wir es wissen</span></span>
+<span id="cb12-39"><a href="#cb12-39" aria-hidden="true" tabindex="-1"></a>ZEITAUSLASTUNG_WARNSCHWELLE <span class="op">=</span> <span class="fl">0.9</span></span>
+<span id="cb12-40"><a href="#cb12-40" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb12-41"><a href="#cb12-41" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb12-42"><a href="#cb12-42" aria-hidden="true" tabindex="-1"></a><span class="at">@dataclass</span></span>
+<span id="cb12-43"><a href="#cb12-43" aria-hidden="true" tabindex="-1"></a><span class="kw">class</span> Laufprotokoll:</span>
+<span id="cb12-44"><a href="#cb12-44" aria-hidden="true" tabindex="-1"></a>    <span class="co">&quot;&quot;&quot;Was nach JEDEM Produktivlauf protokolliert gehoert.</span></span>
+<span id="cb12-45"><a href="#cb12-45" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb12-46"><a href="#cb12-46" aria-hidden="true" tabindex="-1"></a><span class="co">    Die meisten Systeme schreiben nur &#39;kosten&#39;. Genau deshalb faellt eine</span></span>
+<span id="cb12-47"><a href="#cb12-47" aria-hidden="true" tabindex="-1"></a><span class="co">    schleichende Verschlechterung ueber Monate nicht auf.</span></span>
+<span id="cb12-48"><a href="#cb12-48" aria-hidden="true" tabindex="-1"></a><span class="co">    &quot;&quot;&quot;</span></span>
+<span id="cb12-49"><a href="#cb12-49" aria-hidden="true" tabindex="-1"></a>    zeitpunkt: <span class="bu">str</span></span>
+<span id="cb12-50"><a href="#cb12-50" aria-hidden="true" tabindex="-1"></a>    lager: <span class="bu">int</span></span>
+<span id="cb12-51"><a href="#cb12-51" aria-hidden="true" tabindex="-1"></a>    kunden: <span class="bu">int</span></span>
+<span id="cb12-52"><a href="#cb12-52" aria-hidden="true" tabindex="-1"></a>    status: <span class="bu">str</span></span>
+<span id="cb12-53"><a href="#cb12-53" aria-hidden="true" tabindex="-1"></a>    kosten: <span class="bu">float</span></span>
+<span id="cb12-54"><a href="#cb12-54" aria-hidden="true" tabindex="-1"></a>    gap: <span class="bu">float</span></span>
+<span id="cb12-55"><a href="#cb12-55" aria-hidden="true" tabindex="-1"></a>    laufzeit: <span class="bu">float</span></span>
+<span id="cb12-56"><a href="#cb12-56" aria-hidden="true" tabindex="-1"></a>    knoten: <span class="bu">int</span></span>
+<span id="cb12-57"><a href="#cb12-57" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb12-58"><a href="#cb12-58" aria-hidden="true" tabindex="-1"></a>    <span class="at">@property</span></span>
+<span id="cb12-59"><a href="#cb12-59" aria-hidden="true" tabindex="-1"></a>    <span class="kw">def</span> warnungen(<span class="va">self</span>) <span class="op">-&gt;</span> <span class="bu">list</span>[<span class="bu">str</span>]:</span>
+<span id="cb12-60"><a href="#cb12-60" aria-hidden="true" tabindex="-1"></a>        meldungen <span class="op">=</span> []</span>
+<span id="cb12-61"><a href="#cb12-61" aria-hidden="true" tabindex="-1"></a>        <span class="cf">if</span> <span class="va">self</span>.status <span class="op">!=</span> <span class="st">&quot;Optimal&quot;</span>:</span>
+<span id="cb12-62"><a href="#cb12-62" aria-hidden="true" tabindex="-1"></a>            meldungen.append(<span class="ss">f&quot;nicht beweisbar optimal (</span><span class="sc">{</span><span class="va">self</span><span class="sc">.</span>status<span class="sc">}</span><span class="ss">)&quot;</span>)</span>
+<span id="cb12-63"><a href="#cb12-63" aria-hidden="true" tabindex="-1"></a>        <span class="cf">if</span> <span class="va">self</span>.gap <span class="op">&gt;</span> GAP_WARNSCHWELLE:</span>
+<span id="cb12-64"><a href="#cb12-64" aria-hidden="true" tabindex="-1"></a>            meldungen.append(<span class="ss">f&quot;Gap </span><span class="sc">{</span><span class="va">self</span><span class="sc">.</span>gap<span class="sc">:.1%}</span><span class="ss"> ueber Schwelle &quot;</span></span>
+<span id="cb12-65"><a href="#cb12-65" aria-hidden="true" tabindex="-1"></a>                             <span class="ss">f&quot;</span><span class="sc">{</span>GAP_WARNSCHWELLE<span class="sc">:.0%}</span><span class="ss">&quot;</span>)</span>
+<span id="cb12-66"><a href="#cb12-66" aria-hidden="true" tabindex="-1"></a>        <span class="cf">if</span> <span class="va">self</span>.laufzeit <span class="op">&gt;</span> ZEITAUSLASTUNG_WARNSCHWELLE <span class="op">*</span> ZEITLIMIT:</span>
+<span id="cb12-67"><a href="#cb12-67" aria-hidden="true" tabindex="-1"></a>            meldungen.append(<span class="ss">f&quot;Zeitbudget zu </span><span class="sc">{</span><span class="va">self</span><span class="sc">.</span>laufzeit <span class="op">/</span> ZEITLIMIT<span class="sc">:.0%}</span><span class="ss"> &quot;</span></span>
+<span id="cb12-68"><a href="#cb12-68" aria-hidden="true" tabindex="-1"></a>                             <span class="ss">f&quot;ausgeschoepft&quot;</span>)</span>
+<span id="cb12-69"><a href="#cb12-69" aria-hidden="true" tabindex="-1"></a>        <span class="cf">return</span> meldungen</span>
+<span id="cb12-70"><a href="#cb12-70" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb12-71"><a href="#cb12-71" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb12-72"><a href="#cb12-72" aria-hidden="true" tabindex="-1"></a><span class="kw">def</span> plane_netzwerk(n_lager: <span class="bu">int</span>, n_kunden: <span class="bu">int</span>, zeitlimit: <span class="bu">float</span>,</span>
+<span id="cb12-73"><a href="#cb12-73" aria-hidden="true" tabindex="-1"></a>                   saat: <span class="bu">int</span> <span class="op">=</span> <span class="dv">7</span>) <span class="op">-&gt;</span> <span class="bu">tuple</span>[<span class="bu">str</span>, <span class="bu">float</span>, <span class="bu">float</span>, <span class="bu">float</span>, <span class="bu">int</span>]:</span>
+<span id="cb12-74"><a href="#cb12-74" aria-hidden="true" tabindex="-1"></a>    <span class="co">&quot;&quot;&quot;Standortplanung wie in Kapitel MILP, nur mit wachsender Groesse.&quot;&quot;&quot;</span></span>
+<span id="cb12-75"><a href="#cb12-75" aria-hidden="true" tabindex="-1"></a>    rng <span class="op">=</span> np.random.default_rng(saat)</span>
+<span id="cb12-76"><a href="#cb12-76" aria-hidden="true" tabindex="-1"></a>    fixkosten <span class="op">=</span> rng.uniform(<span class="dv">3000</span>, <span class="dv">9000</span>, n_lager)</span>
+<span id="cb12-77"><a href="#cb12-77" aria-hidden="true" tabindex="-1"></a>    transport <span class="op">=</span> rng.uniform(<span class="dv">5</span>, <span class="dv">60</span>, (n_lager, n_kunden))</span>
+<span id="cb12-78"><a href="#cb12-78" aria-hidden="true" tabindex="-1"></a>    bedarf <span class="op">=</span> rng.uniform(<span class="dv">10</span>, <span class="dv">60</span>, n_kunden)</span>
+<span id="cb12-79"><a href="#cb12-79" aria-hidden="true" tabindex="-1"></a>    kapazitaet <span class="op">=</span> np.full(n_lager, bedarf.<span class="bu">sum</span>() <span class="op">*</span> <span class="fl">0.22</span>)</span>
+<span id="cb12-80"><a href="#cb12-80" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb12-81"><a href="#cb12-81" aria-hidden="true" tabindex="-1"></a>    modell <span class="op">=</span> highspy.Highs()</span>
+<span id="cb12-82"><a href="#cb12-82" aria-hidden="true" tabindex="-1"></a>    modell.setOptionValue(<span class="st">&quot;output_flag&quot;</span>, <span class="va">False</span>)</span>
+<span id="cb12-83"><a href="#cb12-83" aria-hidden="true" tabindex="-1"></a>    modell.setOptionValue(<span class="st">&quot;time_limit&quot;</span>, zeitlimit)</span>
+<span id="cb12-84"><a href="#cb12-84" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb12-85"><a href="#cb12-85" aria-hidden="true" tabindex="-1"></a>    anzahl_x <span class="op">=</span> n_lager <span class="op">*</span> n_kunden</span>
+<span id="cb12-86"><a href="#cb12-86" aria-hidden="true" tabindex="-1"></a>    unendlich <span class="op">=</span> highspy.kHighsInf</span>
+<span id="cb12-87"><a href="#cb12-87" aria-hidden="true" tabindex="-1"></a>    modell.addVars(anzahl_x, np.zeros(anzahl_x), np.full(anzahl_x, unendlich))</span>
+<span id="cb12-88"><a href="#cb12-88" aria-hidden="true" tabindex="-1"></a>    modell.addVars(n_lager, np.zeros(n_lager), np.ones(n_lager))</span>
+<span id="cb12-89"><a href="#cb12-89" aria-hidden="true" tabindex="-1"></a>    <span class="cf">for</span> i <span class="kw">in</span> <span class="bu">range</span>(n_lager):</span>
+<span id="cb12-90"><a href="#cb12-90" aria-hidden="true" tabindex="-1"></a>        modell.changeColIntegrality(anzahl_x <span class="op">+</span> i, highspy.HighsVarType.kInteger)</span>
+<span id="cb12-91"><a href="#cb12-91" aria-hidden="true" tabindex="-1"></a>        modell.changeColCost(anzahl_x <span class="op">+</span> i, fixkosten[i])</span>
+<span id="cb12-92"><a href="#cb12-92" aria-hidden="true" tabindex="-1"></a>        <span class="cf">for</span> j <span class="kw">in</span> <span class="bu">range</span>(n_kunden):</span>
+<span id="cb12-93"><a href="#cb12-93" aria-hidden="true" tabindex="-1"></a>            modell.changeColCost(i <span class="op">*</span> n_kunden <span class="op">+</span> j, transport[i, j])</span>
+<span id="cb12-94"><a href="#cb12-94" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb12-95"><a href="#cb12-95" aria-hidden="true" tabindex="-1"></a>    <span class="cf">for</span> j <span class="kw">in</span> <span class="bu">range</span>(n_kunden):</span>
+<span id="cb12-96"><a href="#cb12-96" aria-hidden="true" tabindex="-1"></a>        index <span class="op">=</span> np.array([i <span class="op">*</span> n_kunden <span class="op">+</span> j <span class="cf">for</span> i <span class="kw">in</span> <span class="bu">range</span>(n_lager)], dtype<span class="op">=</span>np.int32)</span>
+<span id="cb12-97"><a href="#cb12-97" aria-hidden="true" tabindex="-1"></a>        modell.addRow(bedarf[j], bedarf[j], <span class="bu">len</span>(index), index, np.ones(<span class="bu">len</span>(index)))</span>
+<span id="cb12-98"><a href="#cb12-98" aria-hidden="true" tabindex="-1"></a>    <span class="cf">for</span> i <span class="kw">in</span> <span class="bu">range</span>(n_lager):</span>
+<span id="cb12-99"><a href="#cb12-99" aria-hidden="true" tabindex="-1"></a>        index <span class="op">=</span> np.array([i <span class="op">*</span> n_kunden <span class="op">+</span> j <span class="cf">for</span> j <span class="kw">in</span> <span class="bu">range</span>(n_kunden)] <span class="op">+</span> [anzahl_x <span class="op">+</span> i],</span>
+<span id="cb12-100"><a href="#cb12-100" aria-hidden="true" tabindex="-1"></a>                         dtype<span class="op">=</span>np.int32)</span>
+<span id="cb12-101"><a href="#cb12-101" aria-hidden="true" tabindex="-1"></a>        werte <span class="op">=</span> np.concatenate([np.ones(n_kunden), [<span class="op">-</span>kapazitaet[i]]])</span>
+<span id="cb12-102"><a href="#cb12-102" aria-hidden="true" tabindex="-1"></a>        modell.addRow(<span class="op">-</span>unendlich, <span class="fl">0.0</span>, <span class="bu">len</span>(index), index, werte)</span>
+<span id="cb12-103"><a href="#cb12-103" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb12-104"><a href="#cb12-104" aria-hidden="true" tabindex="-1"></a>    t0 <span class="op">=</span> time.perf_counter()</span>
+<span id="cb12-105"><a href="#cb12-105" aria-hidden="true" tabindex="-1"></a>    modell.run()</span>
+<span id="cb12-106"><a href="#cb12-106" aria-hidden="true" tabindex="-1"></a>    laufzeit <span class="op">=</span> time.perf_counter() <span class="op">-</span> t0</span>
+<span id="cb12-107"><a href="#cb12-107" aria-hidden="true" tabindex="-1"></a>    info <span class="op">=</span> modell.getInfo()</span>
+<span id="cb12-108"><a href="#cb12-108" aria-hidden="true" tabindex="-1"></a>    <span class="cf">return</span> (modell.modelStatusToString(modell.getModelStatus()),</span>
+<span id="cb12-109"><a href="#cb12-109" aria-hidden="true" tabindex="-1"></a>            info.objective_function_value, info.mip_gap, laufzeit,</span>
+<span id="cb12-110"><a href="#cb12-110" aria-hidden="true" tabindex="-1"></a>            info.mip_node_count)</span>
+<span id="cb12-111"><a href="#cb12-111" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb12-112"><a href="#cb12-112" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb12-113"><a href="#cb12-113" aria-hidden="true" tabindex="-1"></a><span class="cf">if</span> <span class="va">__name__</span> <span class="op">==</span> <span class="st">&quot;__main__&quot;</span>:</span>
+<span id="cb12-114"><a href="#cb12-114" aria-hidden="true" tabindex="-1"></a>    <span class="co"># So ist das Unternehmen ueber zwei Jahre gewachsen.</span></span>
+<span id="cb12-115"><a href="#cb12-115" aria-hidden="true" tabindex="-1"></a>    entwicklung <span class="op">=</span> [(<span class="st">&quot;2024-Q1&quot;</span>, <span class="dv">15</span>, <span class="dv">40</span>), (<span class="st">&quot;2024-Q3&quot;</span>, <span class="dv">25</span>, <span class="dv">70</span>),</span>
+<span id="cb12-116"><a href="#cb12-116" aria-hidden="true" tabindex="-1"></a>                   (<span class="st">&quot;2025-Q1&quot;</span>, <span class="dv">40</span>, <span class="dv">110</span>), (<span class="st">&quot;2025-Q3&quot;</span>, <span class="dv">60</span>, <span class="dv">160</span>),</span>
+<span id="cb12-117"><a href="#cb12-117" aria-hidden="true" tabindex="-1"></a>                   (<span class="st">&quot;2026-Q1&quot;</span>, <span class="dv">80</span>, <span class="dv">220</span>)]</span>
+<span id="cb12-118"><a href="#cb12-118" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb12-119"><a href="#cb12-119" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;=&quot;</span> <span class="op">*</span> <span class="dv">84</span>)</span>
+<span id="cb12-120"><a href="#cb12-120" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;  WAS DAS PROTOKOLL ZEIGT - UND WAS ES ZEIGEN SOLLTE&quot;</span>)</span>
+<span id="cb12-121"><a href="#cb12-121" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;=&quot;</span> <span class="op">*</span> <span class="dv">84</span>)</span>
+<span id="cb12-122"><a href="#cb12-122" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;Derselbe Nachtjob, unveraendert, mit </span><span class="sc">{</span>ZEITLIMIT<span class="sc">:.0f}</span><span class="ss"> Sekunden Zeitlimit.</span><span class="ch">\n</span><span class="ss">&quot;</span>)</span>
+<span id="cb12-123"><a href="#cb12-123" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb12-124"><a href="#cb12-124" aria-hidden="true" tabindex="-1"></a>    protokolle <span class="op">=</span> []</span>
+<span id="cb12-125"><a href="#cb12-125" aria-hidden="true" tabindex="-1"></a>    <span class="cf">for</span> zeitpunkt, lager, kunden <span class="kw">in</span> entwicklung:</span>
+<span id="cb12-126"><a href="#cb12-126" aria-hidden="true" tabindex="-1"></a>        status, kosten, gap, laufzeit, knoten <span class="op">=</span> plane_netzwerk(</span>
+<span id="cb12-127"><a href="#cb12-127" aria-hidden="true" tabindex="-1"></a>            lager, kunden, ZEITLIMIT)</span>
+<span id="cb12-128"><a href="#cb12-128" aria-hidden="true" tabindex="-1"></a>        protokolle.append(Laufprotokoll(zeitpunkt, lager, kunden, status,</span>
+<span id="cb12-129"><a href="#cb12-129" aria-hidden="true" tabindex="-1"></a>                                        kosten, gap, laufzeit, knoten))</span>
+<span id="cb12-130"><a href="#cb12-130" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb12-131"><a href="#cb12-131" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;So sieht das ueblich gefuehrte Protokoll aus:</span><span class="ch">\n</span><span class="st">&quot;</span>)</span>
+<span id="cb12-132"><a href="#cb12-132" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;  </span><span class="sc">{</span><span class="st">&#39;Zeitpunkt&#39;</span><span class="sc">:&lt;10}</span><span class="ss"> </span><span class="sc">{</span><span class="st">&#39;Kosten&#39;</span><span class="sc">:&gt;12}</span><span class="ss">&quot;</span>)</span>
+<span id="cb12-133"><a href="#cb12-133" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;  &quot;</span> <span class="op">+</span> <span class="st">&quot;-&quot;</span> <span class="op">*</span> <span class="dv">24</span>)</span>
+<span id="cb12-134"><a href="#cb12-134" aria-hidden="true" tabindex="-1"></a>    <span class="cf">for</span> p <span class="kw">in</span> protokolle:</span>
+<span id="cb12-135"><a href="#cb12-135" aria-hidden="true" tabindex="-1"></a>        <span class="bu">print</span>(<span class="ss">f&quot;  </span><span class="sc">{</span>p<span class="sc">.</span>zeitpunkt<span class="sc">:&lt;10}</span><span class="ss"> </span><span class="sc">{</span>p<span class="sc">.</span>kosten<span class="sc">:&gt;12,.0f}</span><span class="ss">&quot;</span>)</span>
+<span id="cb12-136"><a href="#cb12-136" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;</span><span class="ch">\n</span><span class="st">  -&gt; Die Kosten steigen. Das Unternehmen waechst ja auch.&quot;</span>)</span>
+<span id="cb12-137"><a href="#cb12-137" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;     Nichts an dieser Tabelle deutet auf ein Problem hin.&quot;</span>)</span>
+<span id="cb12-138"><a href="#cb12-138" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb12-139"><a href="#cb12-139" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;</span><span class="ch">\n</span><span class="st">&quot;</span> <span class="op">+</span> <span class="st">&quot;-&quot;</span> <span class="op">*</span> <span class="dv">84</span>)</span>
+<span id="cb12-140"><a href="#cb12-140" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;So sieht ein vollstaendiges Protokoll aus:</span><span class="ch">\n</span><span class="st">&quot;</span>)</span>
+<span id="cb12-141"><a href="#cb12-141" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;  </span><span class="sc">{</span><span class="st">&#39;Zeitpunkt&#39;</span><span class="sc">:&lt;10}</span><span class="ss"> </span><span class="sc">{</span><span class="st">&#39;Groesse&#39;</span><span class="sc">:&gt;10}</span><span class="ss"> </span><span class="sc">{</span><span class="st">&#39;Status&#39;</span><span class="sc">:&gt;20}</span><span class="ss"> </span><span class="sc">{</span><span class="st">&#39;Kosten&#39;</span><span class="sc">:&gt;11}</span><span class="ss"> &quot;</span></span>
+<span id="cb12-142"><a href="#cb12-142" aria-hidden="true" tabindex="-1"></a>          <span class="ss">f&quot;</span><span class="sc">{</span><span class="st">&#39;Gap&#39;</span><span class="sc">:&gt;8}</span><span class="ss"> </span><span class="sc">{</span><span class="st">&#39;Zeit&#39;</span><span class="sc">:&gt;7}</span><span class="ss">&quot;</span>)</span>
+<span id="cb12-143"><a href="#cb12-143" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;  &quot;</span> <span class="op">+</span> <span class="st">&quot;-&quot;</span> <span class="op">*</span> <span class="dv">80</span>)</span>
+<span id="cb12-144"><a href="#cb12-144" aria-hidden="true" tabindex="-1"></a>    <span class="cf">for</span> p <span class="kw">in</span> protokolle:</span>
+<span id="cb12-145"><a href="#cb12-145" aria-hidden="true" tabindex="-1"></a>        groesse <span class="op">=</span> <span class="ss">f&quot;</span><span class="sc">{</span>p<span class="sc">.</span>lager<span class="sc">}</span><span class="ss">x</span><span class="sc">{</span>p<span class="sc">.</span>kunden<span class="sc">}</span><span class="ss">&quot;</span></span>
+<span id="cb12-146"><a href="#cb12-146" aria-hidden="true" tabindex="-1"></a>        <span class="bu">print</span>(<span class="ss">f&quot;  </span><span class="sc">{</span>p<span class="sc">.</span>zeitpunkt<span class="sc">:&lt;10}</span><span class="ss"> </span><span class="sc">{</span>groesse<span class="sc">:&gt;10}</span><span class="ss"> </span><span class="sc">{</span>p<span class="sc">.</span>status<span class="sc">:&gt;20}</span><span class="ss"> &quot;</span></span>
+<span id="cb12-147"><a href="#cb12-147" aria-hidden="true" tabindex="-1"></a>              <span class="ss">f&quot;</span><span class="sc">{</span>p<span class="sc">.</span>kosten<span class="sc">:&gt;11,.0f}</span><span class="ss"> </span><span class="sc">{</span>p<span class="sc">.</span>gap <span class="op">*</span> <span class="dv">100</span><span class="sc">:7.2f}</span><span class="ss"> % </span><span class="sc">{</span>p<span class="sc">.</span>laufzeit<span class="sc">:6.2f}</span><span class="ss">s&quot;</span>)</span>
+<span id="cb12-148"><a href="#cb12-148" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb12-149"><a href="#cb12-149" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;</span><span class="ch">\n</span><span class="st">&quot;</span> <span class="op">+</span> <span class="st">&quot;-&quot;</span> <span class="op">*</span> <span class="dv">84</span>)</span>
+<span id="cb12-150"><a href="#cb12-150" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;Und so sehen die Warnungen aus, die daraus folgen:</span><span class="ch">\n</span><span class="st">&quot;</span>)</span>
+<span id="cb12-151"><a href="#cb12-151" aria-hidden="true" tabindex="-1"></a>    <span class="cf">for</span> p <span class="kw">in</span> protokolle:</span>
+<span id="cb12-152"><a href="#cb12-152" aria-hidden="true" tabindex="-1"></a>        <span class="cf">if</span> p.warnungen:</span>
+<span id="cb12-153"><a href="#cb12-153" aria-hidden="true" tabindex="-1"></a>            <span class="bu">print</span>(<span class="ss">f&quot;  </span><span class="sc">{</span>p<span class="sc">.</span>zeitpunkt<span class="sc">}</span><span class="ss">:  &quot;</span> <span class="op">+</span> <span class="st">&quot;; &quot;</span>.join(p.warnungen))</span>
+<span id="cb12-154"><a href="#cb12-154" aria-hidden="true" tabindex="-1"></a>        <span class="cf">else</span>:</span>
+<span id="cb12-155"><a href="#cb12-155" aria-hidden="true" tabindex="-1"></a>            <span class="bu">print</span>(<span class="ss">f&quot;  </span><span class="sc">{</span>p<span class="sc">.</span>zeitpunkt<span class="sc">}</span><span class="ss">:  in Ordnung&quot;</span>)</span>
+<span id="cb12-156"><a href="#cb12-156" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb12-157"><a href="#cb12-157" aria-hidden="true" tabindex="-1"></a>    letzte <span class="op">=</span> protokolle[<span class="op">-</span><span class="dv">1</span>]</span>
+<span id="cb12-158"><a href="#cb12-158" aria-hidden="true" tabindex="-1"></a>    erste_warnung <span class="op">=</span> <span class="bu">next</span>(p <span class="cf">for</span> p <span class="kw">in</span> protokolle <span class="cf">if</span> p.warnungen)</span>
+<span id="cb12-159"><a href="#cb12-159" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb12-160"><a href="#cb12-160" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;</span><span class="ch">\n</span><span class="st">&quot;</span> <span class="op">+</span> <span class="st">&quot;=&quot;</span> <span class="op">*</span> <span class="dv">84</span>)</span>
+<span id="cb12-161"><a href="#cb12-161" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;  WAS DA PASSIERT IST&quot;</span>)</span>
+<span id="cb12-162"><a href="#cb12-162" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;=&quot;</span> <span class="op">*</span> <span class="dv">84</span>)</span>
+<span id="cb12-163"><a href="#cb12-163" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;Seit </span><span class="sc">{</span>erste_warnung<span class="sc">.</span>zeitpunkt<span class="sc">}</span><span class="ss"> erreicht der Job das Zeitlimit und liefert&quot;</span>)</span>
+<span id="cb12-164"><a href="#cb12-164" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;nicht mehr das Optimum, sondern die beste bis dahin gefundene Loesung.&quot;</span>)</span>
+<span id="cb12-165"><a href="#cb12-165" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="ss">f&quot;Im letzten Lauf betraegt der Abstand zum Bestmoeglichen &quot;</span></span>
+<span id="cb12-166"><a href="#cb12-166" aria-hidden="true" tabindex="-1"></a>          <span class="ss">f&quot;</span><span class="sc">{</span>letzte<span class="sc">.</span>gap<span class="sc">:.1%}</span><span class="ss">.&quot;</span>)</span>
+<span id="cb12-167"><a href="#cb12-167" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>()</span>
+<span id="cb12-168"><a href="#cb12-168" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;Der Job ist nicht abgestuerzt. Er hat keine Fehlermeldung erzeugt.&quot;</span>)</span>
+<span id="cb12-169"><a href="#cb12-169" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;Die Laufzeit ist sogar bemerkenswert STABIL geblieben - genau deshalb,&quot;</span>)</span>
+<span id="cb12-170"><a href="#cb12-170" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;weil das Zeitlimit greift. Ein Ueberwachungssystem, das auf Abstuerze&quot;</span>)</span>
+<span id="cb12-171"><a href="#cb12-171" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;und Laufzeitspitzen achtet, sieht hier nichts.&quot;</span>)</span>
+<span id="cb12-172"><a href="#cb12-172" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>()</span>
+<span id="cb12-173"><a href="#cb12-173" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;Drei Zahlen gehoeren deshalb in jedes Protokoll eines Optimierungsjobs:&quot;</span>)</span>
+<span id="cb12-174"><a href="#cb12-174" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;  * der STATUS   - &#39;Optimal&#39; oder etwas anderes?&quot;</span>)</span>
+<span id="cb12-175"><a href="#cb12-175" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;  * der GAP      - wie weit ist die Loesung vom Bestmoeglichen entfernt?&quot;</span>)</span>
+<span id="cb12-176"><a href="#cb12-176" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;  * die LAUFZEIT im Verhaeltnis zum Limit - wie nah am Anschlag?&quot;</span>)</span>
+<span id="cb12-177"><a href="#cb12-177" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>()</span>
+<span id="cb12-178"><a href="#cb12-178" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;Die dritte ist die frueheste Warnung: Sie steigt, lange bevor der Gap&quot;</span>)</span>
+<span id="cb12-179"><a href="#cb12-179" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;sichtbar wird, und gibt Zeit zum Handeln.&quot;</span>)</span>
+<span id="cb12-180"><a href="#cb12-180" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;=&quot;</span> <span class="op">*</span> <span class="dv">84</span>)</span></code></pre></div>
 <p><strong>Erwartete Ausgabe (Zeiten hardwareabhängig):</strong></p>
 <pre><code>====================================================================================
   WAS DAS PROTOKOLL ZEIGT - UND WAS ES ZEIGEN SOLLTE
@@ -2050,10 +2489,10 @@ sichtbar wird, und gibt Zeit zum Handeln.
 <p><strong>🎯 Merksatz</strong> Ein Optimierungsjob, der ein Zeitlimit hat, wird bei wachsenden Daten <strong>nicht langsamer</strong> — er wird <strong>schlechter</strong>. Genau deshalb greift die übliche Betriebsüberwachung nicht: Sie achtet auf Laufzeit und Abstürze, und beides bleibt unauffällig. Protokollieren Sie <strong>Status, Gap und Zeitausschöpfung</strong> bei jedem Lauf, oder Sie erfahren nie, wann Ihr Modell aufgehört hat zu optimieren.</p>
 </blockquote>
 <hr />
-<h2 id="sec:praxisfallen-quiz">22.11 Micro-Quiz</h2>
+<h2 id="sec:praxisfallen-quiz">22.12 Micro-Quiz</h2>
 <div class="card card-quiz">
 <blockquote>
-<p><strong>❓ Micro-Quiz 15: Drei Fragen zum Selbstcheck</strong></p>
+<p><strong>❓ Micro-Quiz 22: Drei Fragen zum Selbstcheck</strong></p>
 <p>Genau eine Antwort ist jeweils richtig. Auflösung in <a href="anhang-loesungen.html#quiz-loesung-praxisfallen">Anhang A</a>.</p>
 <p><strong>1. Ihr Nachtjob läuft seit Monaten konstant 3,0 Sekunden bei einem Zeitlimit von 3 Sekunden. Was schließen Sie daraus?</strong> (a) Das System ist bemerkenswert stabil. (b) Das Zeitlimit greift jedes Mal. Der Solver bricht ab, statt fertig zu werden — die konstante Laufzeit ist das Symptom, nicht die Beruhigung. (c) Der Rechner ist ausgelastet und sollte aufgerüstet werden.</p>
 <p><strong>2. Eine Prüffunktion soll kontrollieren, ob ein Tourenplan die Fahrzeugkapazitäten einhält. Woher nimmt sie die geladenen Mengen?</strong> (a) Aus der Ladungsdimension des Routing-Modells — dort stehen sie ja bereits. (b) Sie summiert die Bedarfe der Kunden aus dem <strong>ausgegebenen Tourenplan</strong> auf. Alles andere fragt das Modell, ob es sich an sich selbst hält. (c) Aus der Zielfunktion, sofern die Kapazität dort bepreist ist.</p>
@@ -2061,7 +2500,7 @@ sichtbar wird, und gibt Zeit zum Handeln.
 </blockquote>
 </div>
 <hr />
-<h2 id="sec:praxisfallen-selbsttest">22.12 Selbsttest</h2>
+<h2 id="sec:praxisfallen-selbsttest">22.13 Selbsttest</h2>
 <blockquote>
 <p>Antworten: <a href="anhang-loesungen.html#selbsttest-loesung-praxisfallen">Anhang A</a>.</p>
 </blockquote>
@@ -2071,12 +2510,18 @@ sichtbar wird, und gibt Zeit zum Handeln.
 <li>Warum ist ein MIP-Gap von 2 % in der Praxis meist ausreichend?</li>
 <li>Was ist das Snapshot-Prinzip und wozu dient es?</li>
 <li>Was ist der häufigste Grund, aus dem OR-Projekte scheitern?</li>
+<li>Eine Bedingung bindet, ihr Schattenpreis ist 0. Was heißt das — und was folgt daraus für eine Nachverhandlung?</li>
+<li>Warum kann die Rangfolge nach Schattenpreis eine andere sein als die Rangfolge nach tatsächlichem Nutzen einer Lockerung?</li>
 </ol>
 <hr />
-<h2 id="sec:praxisfallen-zusammenfassung">22.13 Zusammenfassung</h2>
+<h2 id="sec:praxisfallen-zusammenfassung">22.14 Zusammenfassung</h2>
 <ul>
 <li><strong>Infeasibility ist ein Entwurfsproblem, kein Solverproblem.</strong> Wer alles hart formuliert, erhält irgendwann eine Fehlermeldung statt eines Plans.</li>
 <li><strong>Erklärbarkeit entscheidet über Akzeptanz.</strong> Schattenpreise, Kostenzerlegung und Constraint-Traces sind keine Kür.</li>
+<li><strong>Bindend heißt nicht teuer.</strong> Eine Bedingung kann den Plan berühren und trotzdem 0,00 € kosten. Nur die kostenrelevanten lohnen eine Nachverhandlung.</li>
+<li><strong>Der Schattenpreis gilt für die nächste Einheit, nicht für die nächste Schicht.</strong> Hochgerechnet auf einen realistischen Schritt überschätzt er den Nutzen — im Beispiel um das Doppelte. Wer wissen will, was ein Hebel bringt, <strong>misst</strong> die Lockerung, statt zu multiplizieren; die beiden Ranglisten können sich dabei umdrehen.</li>
+<li><strong>Ein Wunsch kann unmöglich statt teuer sein</strong> — und dann ist die richtige Antwort nicht ein Preis, sondern die Liste der Bedingungen, die ihn gemeinsam blockieren.</li>
+<li><strong>Ein generierter Bericht macht ein Modell nicht richtiger, nur schwerer anzuzweifeln.</strong> Er erklärt das Modell, nicht die Wirklichkeit — deshalb gehört dazu, worauf er beruht.</li>
 <li><strong>Optimieren Sie nicht genauer als Ihre Daten.</strong> Ein Gap von 2 % ist bei ±10 % Datenunsicherheit irrelevant.</li>
 <li><strong>Der Optimierer schlägt vor, der Mensch entscheidet</strong> — jedenfalls anfangs.</li>
 <li><strong>Reproduzierbarkeit braucht Snapshots und Versionierung</strong>, nicht guten Willen.</li>
@@ -2088,7 +2533,7 @@ sichtbar wird, und gibt Zeit zum Handeln.
 
     </article>
     <button type="button" class="fortschritt-knopf" data-kapitel="praxisfallen.html"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg> <span>Als gelesen markieren</span></button>
-    <nav class="prev-next"><a class="prev-next-knopf prev-next-prev" href="handelsmaschine.html"><svg class="icon" aria-hidden="true"><use href="#icon-chevron-left"></use></svg><span><small>Zurück</small>Kapitel 21: Die vollständige quantitative Handelsmaschine</span></a><a class="prev-next-knopf prev-next-next" href="testing.html"><span><small>Weiter</small>Kapitel 23: Testen, Messen, Ausliefern</span><svg class="icon" aria-hidden="true"><use href="#icon-chevron-right"></use></svg></a></nav>
+    <nav class="prev-next"><a class="prev-next-knopf prev-next-prev" href="synthese-anwendungen.html"><svg class="icon" aria-hidden="true"><use href="#icon-chevron-left"></use></svg><span><small>Zurück</small>Synthese Teil IV</span></a><a class="prev-next-knopf prev-next-next" href="testing.html"><span><small>Weiter</small>Kapitel 23: Testen, Messen, Ausliefern</span><svg class="icon" aria-hidden="true"><use href="#icon-chevron-right"></use></svg></a></nav>
   </main>
 </div>
 <footer class="site-footer">
diff --git a/OR_HTML_04/prognose.html b/OR_HTML_04/prognose.html
index 1439c29..a6544da 100644
--- a/OR_HTML_04/prognose.html
+++ b/OR_HTML_04/prognose.html
@@ -94,10 +94,10 @@
 </header>
 <div class="site-body">
   <div class="sidebar-overlay" id="sidebar-overlay" hidden></div>
-  <nav class="sidebar" id="sidebar" aria-label="Kapitelnavigation"><div class="sidebar-inhalt"><details class="sidebar-gruppe"><summary>Einstieg</summary><ul><li data-kapitel="vorwort.html"><a href="vorwort.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Vorwort & Lesehilfe</span></a></li><li data-kapitel="notation.html"><a href="notation.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Notation & Abkürzungen</span></a></li></ul></details><details class="sidebar-gruppe"><summary>Teil I: Grundlagen des Operations Research</summary><ul><li data-kapitel="einfuehrung.html"><a href="einfuehrung.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 1: Einführung in Operations Research — Vom Ursprung zur mathematischen Entscheidungsfindung</span></a></li><li data-kapitel="fundament.html"><a href="fundament.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 2: Das mathematische Fundament — Vektoren, Matrizen, Konvexität</span></a></li><li data-kapitel="oekosystem.html"><a href="oekosystem.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 3: Das Python-Ökosystem für OR — Solver, Bindings und Modellierungsschichten</span></a></li><li data-kapitel="modellierung.html"><a href="modellierung.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 4: Vom Management-Wunsch zum Modell</span></a></li></ul></details><details class="sidebar-gruppe"><summary>Teil II: Die Kernverfahren der deterministischen Optimierung</summary><ul><li data-kapitel="lp.html"><a href="lp.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 5: Lineare Programmierung — Simplex, Dualität und Schattenpreise</span></a></li><li data-kapitel="milp.html"><a href="milp.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 6: Gemischt-ganzzahlige Optimierung — Diskrete Entscheidungen und Branch-and-Bound</span></a></li><li data-kapitel="cpsat.html"><a href="cpsat.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 7: Constraint Programming mit CP-SAT — Logik, Scheduling und Zuweisung</span></a></li><li data-kapitel="graphen.html"><a href="graphen.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 8: Graphen, Flüsse und Touren — Min-Cost-Flow, Matching und VRP</span></a></li><li data-kapitel="metaheuristiken.html"><a href="metaheuristiken.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 9: Metaheuristiken — wenn der exakte Solver aussteigt</span></a></li><li data-kapitel="dekomposition.html"><a href="dekomposition.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 10: Spaltengenerierung — das Modell umbauen statt die Lösung raten</span></a></li></ul></details><details class="sidebar-gruppe" open><summary>Teil III: Nichtlinearität, Unsicherheit und mehrperiodige Dynamik</summary><ul><li data-kapitel="qp-nlp.html"><a href="qp-nlp.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 11: Quadratische und nichtlineare Optimierung — KKT, Lagrange, Konvexität</span></a></li><li data-kapitel="unsicherheit.html"><a href="unsicherheit.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 12: Optimierung unter Unsicherheit — Monte-Carlo, Stochastik, Robustheit</span></a></li><li data-kapitel="dynamische-programmierung.html"><a href="dynamische-programmierung.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 13: Dynamische Programmierung — Die Bellman-Gleichung und Order-Execution</span></a></li><li data-kapitel="mehrziel.html"><a href="mehrziel.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 14: Mehrere Ziele — Pareto-Fronten statt Gewichte</span></a></li><li data-kapitel="prognose.html" class="aktiv"><a href="prognose.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 15: Predict-then-Optimize — die bessere Prognose, die schlechtere Entscheidung</span></a></li></ul></details><details class="sidebar-gruppe"><summary>Teil IV: Anwendungen — Energiewirtschaft und Finanzmärkte</summary><ul><li data-kapitel="bruecke.html"><a href="bruecke.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 16: Die Strukturbrücke — dieselbe Mathematik, zwei Welten</span></a></li><li data-kapitel="supplychain.html"><a href="supplychain.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 17: Supply-Chain und Energieeinsatz unter Unsicherheit</span></a></li><li data-kapitel="finanzdaten.html"><a href="finanzdaten.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 18: Finanzdaten-Modellierung — Renditen, Kovarianz und Shrinkage</span></a></li><li data-kapitel="markowitz.html"><a href="markowitz.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 19: Die moderne Portfoliotheorie nach Markowitz</span></a></li><li data-kapitel="cvar.html"><a href="cvar.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 20: Tail-Risiko, CVaR und Transaktionskosten</span></a></li><li data-kapitel="handelsmaschine.html"><a href="handelsmaschine.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 21: Die vollständige quantitative Handelsmaschine</span></a></li></ul></details><details class="sidebar-gruppe"><summary>Teil V: Praxis</summary><ul><li data-kapitel="praxisfallen.html"><a href="praxisfallen.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 22: Praxisfallen und der Weg zum produktiven Einsatz</span></a></li><li data-kapitel="testing.html"><a href="testing.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 23: Testen, Messen, Ausliefern</span></a></li><li data-kapitel="projektwerkstatt.html"><a href="projektwerkstatt.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Projektwerkstatt</span></a></li></ul></details><details class="sidebar-gruppe"><summary>Anhänge</summary><ul><li data-kapitel="anhang-loesungen.html"><a href="anhang-loesungen.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Anhang A: Lösungen zu allen Übungsaufgaben</span></a></li><li data-kapitel="anhang-modellierungsmuster.html"><a href="anhang-modellierungsmuster.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Anhang B: Katalog der Modellierungsmuster</span></a></li><li data-kapitel="anhang-fehlerdiagnose.html"><a href="anhang-fehlerdiagnose.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Anhang C: Fehlerdiagnose-Handbuch</span></a></li><li data-kapitel="anhang-spickzettel.html"><a href="anhang-spickzettel.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Anhang D: Spickzettel der Solver</span></a></li><li data-kapitel="anhang-glossar-literatur.html"><a href="anhang-glossar-literatur.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Anhang E: Glossar und Literatur</span></a></li></ul></details><ul class="sidebar-extra"><li><a href="programme.html"><svg class="icon" aria-hidden="true"><use href="#icon-book"></use></svg> Beispielprogramme</a></li><li><a href="stichwortverzeichnis.html"><svg class="icon" aria-hidden="true"><use href="#icon-search"></use></svg> Stichwortverzeichnis</a></li><li><a href="gesamtdokument.html"><svg class="icon" aria-hidden="true"><use href="#icon-external-link"></use></svg> Gesamtdokument (eine Seite)</a></li><li><a href="Operations_Research_mit_Python_Version_04.pdf" download><svg class="icon" aria-hidden="true"><use href="#icon-download"></use></svg> Download als PDF</a></li></ul></div></nav>
+  <nav class="sidebar" id="sidebar" aria-label="Kapitelnavigation"><div class="sidebar-inhalt"><details class="sidebar-gruppe"><summary>Einstieg</summary><ul><li data-kapitel="vorwort.html"><a href="vorwort.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Vorwort & Lesehilfe</span></a></li><li data-kapitel="notation.html"><a href="notation.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Notation & Abkürzungen</span></a></li></ul></details><details class="sidebar-gruppe"><summary>Teil I: Grundlagen des Operations Research</summary><ul><li data-kapitel="einfuehrung.html"><a href="einfuehrung.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 1: Einführung in Operations Research — Vom Ursprung zur mathematischen Entscheidungsfindung</span></a></li><li data-kapitel="fundament.html"><a href="fundament.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 2: Das mathematische Fundament — Vektoren, Matrizen, Konvexität</span></a></li><li data-kapitel="oekosystem.html"><a href="oekosystem.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 3: Das Python-Ökosystem für OR — Solver, Bindings und Modellierungsschichten</span></a></li><li data-kapitel="modellierung.html"><a href="modellierung.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 4: Vom Management-Wunsch zum Modell</span></a></li><li data-kapitel="synthese-grundlagen.html"><a href="synthese-grundlagen.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Synthese Teil I</span></a></li></ul></details><details class="sidebar-gruppe"><summary>Teil II: Die Kernverfahren der deterministischen Optimierung</summary><ul><li data-kapitel="lp.html"><a href="lp.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 5: Lineare Programmierung — Simplex, Dualität und Schattenpreise</span></a></li><li data-kapitel="milp.html"><a href="milp.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 6: Gemischt-ganzzahlige Optimierung — Diskrete Entscheidungen und Branch-and-Bound</span></a></li><li data-kapitel="cpsat.html"><a href="cpsat.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 7: Constraint Programming mit CP-SAT — Logik, Scheduling und Zuweisung</span></a></li><li data-kapitel="graphen.html"><a href="graphen.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 8: Graphen, Flüsse und Touren — Min-Cost-Flow, Matching und VRP</span></a></li><li data-kapitel="metaheuristiken.html"><a href="metaheuristiken.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 9: Metaheuristiken — wenn der exakte Solver aussteigt</span></a></li><li data-kapitel="dekomposition.html"><a href="dekomposition.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 10: Spaltengenerierung — das Modell umbauen statt die Lösung raten</span></a></li><li data-kapitel="synthese-kernverfahren.html"><a href="synthese-kernverfahren.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Synthese Teil II</span></a></li></ul></details><details class="sidebar-gruppe" open><summary>Teil III: Nichtlinearität, Unsicherheit und mehrperiodige Dynamik</summary><ul><li data-kapitel="qp-nlp.html"><a href="qp-nlp.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 11: Quadratische und nichtlineare Optimierung — KKT, Lagrange, Konvexität</span></a></li><li data-kapitel="unsicherheit.html"><a href="unsicherheit.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 12: Optimierung unter Unsicherheit — Monte-Carlo, Stochastik, Robustheit</span></a></li><li data-kapitel="dynamische-programmierung.html"><a href="dynamische-programmierung.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 13: Dynamische Programmierung — Die Bellman-Gleichung und Order-Execution</span></a></li><li data-kapitel="mehrziel.html"><a href="mehrziel.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 14: Mehrere Ziele — Pareto-Fronten statt Gewichte</span></a></li><li data-kapitel="prognose.html" class="aktiv"><a href="prognose.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 15: Predict-then-Optimize — die bessere Prognose, die schlechtere Entscheidung</span></a></li><li data-kapitel="synthese-nichtlinear.html"><a href="synthese-nichtlinear.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Synthese Teil III</span></a></li></ul></details><details class="sidebar-gruppe"><summary>Teil IV: Anwendungen — Energiewirtschaft und Finanzmärkte</summary><ul><li data-kapitel="bruecke.html"><a href="bruecke.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 16: Die Strukturbrücke — dieselbe Mathematik, zwei Welten</span></a></li><li data-kapitel="supplychain.html"><a href="supplychain.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 17: Supply-Chain und Energieeinsatz unter Unsicherheit</span></a></li><li data-kapitel="finanzdaten.html"><a href="finanzdaten.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 18: Finanzdaten-Modellierung — Renditen, Kovarianz und Shrinkage</span></a></li><li data-kapitel="markowitz.html"><a href="markowitz.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 19: Die moderne Portfoliotheorie nach Markowitz</span></a></li><li data-kapitel="cvar.html"><a href="cvar.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 20: Tail-Risiko, CVaR und Transaktionskosten</span></a></li><li data-kapitel="handelsmaschine.html"><a href="handelsmaschine.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 21: Die vollständige quantitative Handelsmaschine</span></a></li><li data-kapitel="synthese-anwendungen.html"><a href="synthese-anwendungen.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Synthese Teil IV</span></a></li></ul></details><details class="sidebar-gruppe"><summary>Teil V: Praxis</summary><ul><li data-kapitel="praxisfallen.html"><a href="praxisfallen.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 22: Praxisfallen und der Weg zum produktiven Einsatz</span></a></li><li data-kapitel="testing.html"><a href="testing.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 23: Testen, Messen, Ausliefern</span></a></li><li data-kapitel="synthese-praxis.html"><a href="synthese-praxis.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Synthese Teil V</span></a></li><li data-kapitel="projektwerkstatt.html"><a href="projektwerkstatt.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Projektwerkstatt</span></a></li></ul></details><details class="sidebar-gruppe"><summary>Anhänge</summary><ul><li data-kapitel="anhang-loesungen.html"><a href="anhang-loesungen.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Anhang A: Lösungen zu allen Übungsaufgaben</span></a></li><li data-kapitel="anhang-modellierungsmuster.html"><a href="anhang-modellierungsmuster.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Anhang B: Katalog der Modellierungsmuster</span></a></li><li data-kapitel="anhang-fehlerdiagnose.html"><a href="anhang-fehlerdiagnose.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Anhang C: Fehlerdiagnose-Handbuch</span></a></li><li data-kapitel="anhang-spickzettel.html"><a href="anhang-spickzettel.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Anhang D: Spickzettel der Solver</span></a></li><li data-kapitel="anhang-glossar-literatur.html"><a href="anhang-glossar-literatur.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Anhang E: Glossar und Literatur</span></a></li></ul></details><ul class="sidebar-extra"><li><a href="programme.html"><svg class="icon" aria-hidden="true"><use href="#icon-book"></use></svg> Beispielprogramme</a></li><li><a href="stichwortverzeichnis.html"><svg class="icon" aria-hidden="true"><use href="#icon-search"></use></svg> Stichwortverzeichnis</a></li><li><a href="gesamtdokument.html"><svg class="icon" aria-hidden="true"><use href="#icon-external-link"></use></svg> Gesamtdokument (eine Seite)</a></li><li><a href="Operations_Research_mit_Python_Version_04.pdf" download><svg class="icon" aria-hidden="true"><use href="#icon-download"></use></svg> Download als PDF</a></li></ul></div></nav>
   <main class="content">
     <nav class="breadcrumb" aria-label="Breadcrumb"><a href="index.html">Start</a> › <span>Teil III</span> › <span>Kapitel 15: Predict-then-Optimize — die bessere Prognose, die schlechtere Entscheidung</span></nav>
-    <nav class="prev-next"><a class="prev-next-knopf prev-next-prev" href="mehrziel.html"><svg class="icon" aria-hidden="true"><use href="#icon-chevron-left"></use></svg><span><small>Zurück</small>Kapitel 14: Mehrere Ziele — Pareto-Fronten statt Gewichte</span></a><a class="prev-next-knopf prev-next-next" href="bruecke.html"><span><small>Weiter</small>Kapitel 16: Die Strukturbrücke — dieselbe Mathematik, zwei Welten</span><svg class="icon" aria-hidden="true"><use href="#icon-chevron-right"></use></svg></a></nav>
+    <nav class="prev-next"><a class="prev-next-knopf prev-next-prev" href="mehrziel.html"><svg class="icon" aria-hidden="true"><use href="#icon-chevron-left"></use></svg><span><small>Zurück</small>Kapitel 14: Mehrere Ziele — Pareto-Fronten statt Gewichte</span></a><a class="prev-next-knopf prev-next-next" href="synthese-nichtlinear.html"><span><small>Weiter</small>Synthese Teil III</span><svg class="icon" aria-hidden="true"><use href="#icon-chevron-right"></use></svg></a></nav>
     <article>
     <h1 id="kap-prognose">Kapitel 15: Predict-then-Optimize — die bessere Prognose, die schlechtere Entscheidung</h1>
 <div class="card card-blick">
@@ -743,7 +743,7 @@ Kosten statt auf Fehler trainiert.
 
     </article>
     <button type="button" class="fortschritt-knopf" data-kapitel="prognose.html"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg> <span>Als gelesen markieren</span></button>
-    <nav class="prev-next"><a class="prev-next-knopf prev-next-prev" href="mehrziel.html"><svg class="icon" aria-hidden="true"><use href="#icon-chevron-left"></use></svg><span><small>Zurück</small>Kapitel 14: Mehrere Ziele — Pareto-Fronten statt Gewichte</span></a><a class="prev-next-knopf prev-next-next" href="bruecke.html"><span><small>Weiter</small>Kapitel 16: Die Strukturbrücke — dieselbe Mathematik, zwei Welten</span><svg class="icon" aria-hidden="true"><use href="#icon-chevron-right"></use></svg></a></nav>
+    <nav class="prev-next"><a class="prev-next-knopf prev-next-prev" href="mehrziel.html"><svg class="icon" aria-hidden="true"><use href="#icon-chevron-left"></use></svg><span><small>Zurück</small>Kapitel 14: Mehrere Ziele — Pareto-Fronten statt Gewichte</span></a><a class="prev-next-knopf prev-next-next" href="synthese-nichtlinear.html"><span><small>Weiter</small>Synthese Teil III</span><svg class="icon" aria-hidden="true"><use href="#icon-chevron-right"></use></svg></a></nav>
   </main>
 </div>
 <footer class="site-footer">
diff --git a/OR_HTML_04/programme.html b/OR_HTML_04/programme.html
index ce6247d..ece26a1 100644
--- a/OR_HTML_04/programme.html
+++ b/OR_HTML_04/programme.html
@@ -94,12 +94,12 @@
 </header>
 <div class="site-body">
   <div class="sidebar-overlay" id="sidebar-overlay" hidden></div>
-  <nav class="sidebar" id="sidebar" aria-label="Kapitelnavigation"><div class="sidebar-inhalt"><details class="sidebar-gruppe"><summary>Einstieg</summary><ul><li data-kapitel="vorwort.html"><a href="vorwort.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Vorwort & Lesehilfe</span></a></li><li data-kapitel="notation.html"><a href="notation.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Notation & Abkürzungen</span></a></li></ul></details><details class="sidebar-gruppe"><summary>Teil I: Grundlagen des Operations Research</summary><ul><li data-kapitel="einfuehrung.html"><a href="einfuehrung.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 1: Einführung in Operations Research — Vom Ursprung zur mathematischen Entscheidungsfindung</span></a></li><li data-kapitel="fundament.html"><a href="fundament.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 2: Das mathematische Fundament — Vektoren, Matrizen, Konvexität</span></a></li><li data-kapitel="oekosystem.html"><a href="oekosystem.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 3: Das Python-Ökosystem für OR — Solver, Bindings und Modellierungsschichten</span></a></li><li data-kapitel="modellierung.html"><a href="modellierung.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 4: Vom Management-Wunsch zum Modell</span></a></li></ul></details><details class="sidebar-gruppe"><summary>Teil II: Die Kernverfahren der deterministischen Optimierung</summary><ul><li data-kapitel="lp.html"><a href="lp.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 5: Lineare Programmierung — Simplex, Dualität und Schattenpreise</span></a></li><li data-kapitel="milp.html"><a href="milp.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 6: Gemischt-ganzzahlige Optimierung — Diskrete Entscheidungen und Branch-and-Bound</span></a></li><li data-kapitel="cpsat.html"><a href="cpsat.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 7: Constraint Programming mit CP-SAT — Logik, Scheduling und Zuweisung</span></a></li><li data-kapitel="graphen.html"><a href="graphen.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 8: Graphen, Flüsse und Touren — Min-Cost-Flow, Matching und VRP</span></a></li><li data-kapitel="metaheuristiken.html"><a href="metaheuristiken.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 9: Metaheuristiken — wenn der exakte Solver aussteigt</span></a></li><li data-kapitel="dekomposition.html"><a href="dekomposition.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 10: Spaltengenerierung — das Modell umbauen statt die Lösung raten</span></a></li></ul></details><details class="sidebar-gruppe"><summary>Teil III: Nichtlinearität, Unsicherheit und mehrperiodige Dynamik</summary><ul><li data-kapitel="qp-nlp.html"><a href="qp-nlp.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 11: Quadratische und nichtlineare Optimierung — KKT, Lagrange, Konvexität</span></a></li><li data-kapitel="unsicherheit.html"><a href="unsicherheit.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 12: Optimierung unter Unsicherheit — Monte-Carlo, Stochastik, Robustheit</span></a></li><li data-kapitel="dynamische-programmierung.html"><a href="dynamische-programmierung.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 13: Dynamische Programmierung — Die Bellman-Gleichung und Order-Execution</span></a></li><li data-kapitel="mehrziel.html"><a href="mehrziel.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 14: Mehrere Ziele — Pareto-Fronten statt Gewichte</span></a></li><li data-kapitel="prognose.html"><a href="prognose.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 15: Predict-then-Optimize — die bessere Prognose, die schlechtere Entscheidung</span></a></li></ul></details><details class="sidebar-gruppe"><summary>Teil IV: Anwendungen — Energiewirtschaft und Finanzmärkte</summary><ul><li data-kapitel="bruecke.html"><a href="bruecke.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 16: Die Strukturbrücke — dieselbe Mathematik, zwei Welten</span></a></li><li data-kapitel="supplychain.html"><a href="supplychain.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 17: Supply-Chain und Energieeinsatz unter Unsicherheit</span></a></li><li data-kapitel="finanzdaten.html"><a href="finanzdaten.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 18: Finanzdaten-Modellierung — Renditen, Kovarianz und Shrinkage</span></a></li><li data-kapitel="markowitz.html"><a href="markowitz.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 19: Die moderne Portfoliotheorie nach Markowitz</span></a></li><li data-kapitel="cvar.html"><a href="cvar.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 20: Tail-Risiko, CVaR und Transaktionskosten</span></a></li><li data-kapitel="handelsmaschine.html"><a href="handelsmaschine.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 21: Die vollständige quantitative Handelsmaschine</span></a></li></ul></details><details class="sidebar-gruppe"><summary>Teil V: Praxis</summary><ul><li data-kapitel="praxisfallen.html"><a href="praxisfallen.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 22: Praxisfallen und der Weg zum produktiven Einsatz</span></a></li><li data-kapitel="testing.html"><a href="testing.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 23: Testen, Messen, Ausliefern</span></a></li><li data-kapitel="projektwerkstatt.html"><a href="projektwerkstatt.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Projektwerkstatt</span></a></li></ul></details><details class="sidebar-gruppe"><summary>Anhänge</summary><ul><li data-kapitel="anhang-loesungen.html"><a href="anhang-loesungen.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Anhang A: Lösungen zu allen Übungsaufgaben</span></a></li><li data-kapitel="anhang-modellierungsmuster.html"><a href="anhang-modellierungsmuster.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Anhang B: Katalog der Modellierungsmuster</span></a></li><li data-kapitel="anhang-fehlerdiagnose.html"><a href="anhang-fehlerdiagnose.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Anhang C: Fehlerdiagnose-Handbuch</span></a></li><li data-kapitel="anhang-spickzettel.html"><a href="anhang-spickzettel.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Anhang D: Spickzettel der Solver</span></a></li><li data-kapitel="anhang-glossar-literatur.html"><a href="anhang-glossar-literatur.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Anhang E: Glossar und Literatur</span></a></li></ul></details><ul class="sidebar-extra"><li><a href="programme.html"><svg class="icon" aria-hidden="true"><use href="#icon-book"></use></svg> Beispielprogramme</a></li><li><a href="stichwortverzeichnis.html"><svg class="icon" aria-hidden="true"><use href="#icon-search"></use></svg> Stichwortverzeichnis</a></li><li><a href="gesamtdokument.html"><svg class="icon" aria-hidden="true"><use href="#icon-external-link"></use></svg> Gesamtdokument (eine Seite)</a></li><li><a href="Operations_Research_mit_Python_Version_04.pdf" download><svg class="icon" aria-hidden="true"><use href="#icon-download"></use></svg> Download als PDF</a></li></ul></div></nav>
+  <nav class="sidebar" id="sidebar" aria-label="Kapitelnavigation"><div class="sidebar-inhalt"><details class="sidebar-gruppe"><summary>Einstieg</summary><ul><li data-kapitel="vorwort.html"><a href="vorwort.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Vorwort & Lesehilfe</span></a></li><li data-kapitel="notation.html"><a href="notation.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Notation & Abkürzungen</span></a></li></ul></details><details class="sidebar-gruppe"><summary>Teil I: Grundlagen des Operations Research</summary><ul><li data-kapitel="einfuehrung.html"><a href="einfuehrung.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 1: Einführung in Operations Research — Vom Ursprung zur mathematischen Entscheidungsfindung</span></a></li><li data-kapitel="fundament.html"><a href="fundament.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 2: Das mathematische Fundament — Vektoren, Matrizen, Konvexität</span></a></li><li data-kapitel="oekosystem.html"><a href="oekosystem.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 3: Das Python-Ökosystem für OR — Solver, Bindings und Modellierungsschichten</span></a></li><li data-kapitel="modellierung.html"><a href="modellierung.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 4: Vom Management-Wunsch zum Modell</span></a></li><li data-kapitel="synthese-grundlagen.html"><a href="synthese-grundlagen.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Synthese Teil I</span></a></li></ul></details><details class="sidebar-gruppe"><summary>Teil II: Die Kernverfahren der deterministischen Optimierung</summary><ul><li data-kapitel="lp.html"><a href="lp.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 5: Lineare Programmierung — Simplex, Dualität und Schattenpreise</span></a></li><li data-kapitel="milp.html"><a href="milp.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 6: Gemischt-ganzzahlige Optimierung — Diskrete Entscheidungen und Branch-and-Bound</span></a></li><li data-kapitel="cpsat.html"><a href="cpsat.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 7: Constraint Programming mit CP-SAT — Logik, Scheduling und Zuweisung</span></a></li><li data-kapitel="graphen.html"><a href="graphen.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 8: Graphen, Flüsse und Touren — Min-Cost-Flow, Matching und VRP</span></a></li><li data-kapitel="metaheuristiken.html"><a href="metaheuristiken.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 9: Metaheuristiken — wenn der exakte Solver aussteigt</span></a></li><li data-kapitel="dekomposition.html"><a href="dekomposition.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 10: Spaltengenerierung — das Modell umbauen statt die Lösung raten</span></a></li><li data-kapitel="synthese-kernverfahren.html"><a href="synthese-kernverfahren.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Synthese Teil II</span></a></li></ul></details><details class="sidebar-gruppe"><summary>Teil III: Nichtlinearität, Unsicherheit und mehrperiodige Dynamik</summary><ul><li data-kapitel="qp-nlp.html"><a href="qp-nlp.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 11: Quadratische und nichtlineare Optimierung — KKT, Lagrange, Konvexität</span></a></li><li data-kapitel="unsicherheit.html"><a href="unsicherheit.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 12: Optimierung unter Unsicherheit — Monte-Carlo, Stochastik, Robustheit</span></a></li><li data-kapitel="dynamische-programmierung.html"><a href="dynamische-programmierung.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 13: Dynamische Programmierung — Die Bellman-Gleichung und Order-Execution</span></a></li><li data-kapitel="mehrziel.html"><a href="mehrziel.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 14: Mehrere Ziele — Pareto-Fronten statt Gewichte</span></a></li><li data-kapitel="prognose.html"><a href="prognose.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 15: Predict-then-Optimize — die bessere Prognose, die schlechtere Entscheidung</span></a></li><li data-kapitel="synthese-nichtlinear.html"><a href="synthese-nichtlinear.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Synthese Teil III</span></a></li></ul></details><details class="sidebar-gruppe"><summary>Teil IV: Anwendungen — Energiewirtschaft und Finanzmärkte</summary><ul><li data-kapitel="bruecke.html"><a href="bruecke.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 16: Die Strukturbrücke — dieselbe Mathematik, zwei Welten</span></a></li><li data-kapitel="supplychain.html"><a href="supplychain.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 17: Supply-Chain und Energieeinsatz unter Unsicherheit</span></a></li><li data-kapitel="finanzdaten.html"><a href="finanzdaten.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 18: Finanzdaten-Modellierung — Renditen, Kovarianz und Shrinkage</span></a></li><li data-kapitel="markowitz.html"><a href="markowitz.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 19: Die moderne Portfoliotheorie nach Markowitz</span></a></li><li data-kapitel="cvar.html"><a href="cvar.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 20: Tail-Risiko, CVaR und Transaktionskosten</span></a></li><li data-kapitel="handelsmaschine.html"><a href="handelsmaschine.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 21: Die vollständige quantitative Handelsmaschine</span></a></li><li data-kapitel="synthese-anwendungen.html"><a href="synthese-anwendungen.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Synthese Teil IV</span></a></li></ul></details><details class="sidebar-gruppe"><summary>Teil V: Praxis</summary><ul><li data-kapitel="praxisfallen.html"><a href="praxisfallen.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 22: Praxisfallen und der Weg zum produktiven Einsatz</span></a></li><li data-kapitel="testing.html"><a href="testing.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 23: Testen, Messen, Ausliefern</span></a></li><li data-kapitel="synthese-praxis.html"><a href="synthese-praxis.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Synthese Teil V</span></a></li><li data-kapitel="projektwerkstatt.html"><a href="projektwerkstatt.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Projektwerkstatt</span></a></li></ul></details><details class="sidebar-gruppe"><summary>Anhänge</summary><ul><li data-kapitel="anhang-loesungen.html"><a href="anhang-loesungen.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Anhang A: Lösungen zu allen Übungsaufgaben</span></a></li><li data-kapitel="anhang-modellierungsmuster.html"><a href="anhang-modellierungsmuster.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Anhang B: Katalog der Modellierungsmuster</span></a></li><li data-kapitel="anhang-fehlerdiagnose.html"><a href="anhang-fehlerdiagnose.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Anhang C: Fehlerdiagnose-Handbuch</span></a></li><li data-kapitel="anhang-spickzettel.html"><a href="anhang-spickzettel.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Anhang D: Spickzettel der Solver</span></a></li><li data-kapitel="anhang-glossar-literatur.html"><a href="anhang-glossar-literatur.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Anhang E: Glossar und Literatur</span></a></li></ul></details><ul class="sidebar-extra"><li><a href="programme.html"><svg class="icon" aria-hidden="true"><use href="#icon-book"></use></svg> Beispielprogramme</a></li><li><a href="stichwortverzeichnis.html"><svg class="icon" aria-hidden="true"><use href="#icon-search"></use></svg> Stichwortverzeichnis</a></li><li><a href="gesamtdokument.html"><svg class="icon" aria-hidden="true"><use href="#icon-external-link"></use></svg> Gesamtdokument (eine Seite)</a></li><li><a href="Operations_Research_mit_Python_Version_04.pdf" download><svg class="icon" aria-hidden="true"><use href="#icon-download"></use></svg> Download als PDF</a></li></ul></div></nav>
   <main class="content">
     
     <nav class="prev-next"><span class="prev-next-leer"></span><span class="prev-next-leer"></span></nav>
     <article>
-    <h1>Beispielprogramme</h1><p>Alle 74 im Buch abgedruckten Programme, gruppiert nach Kapitel, zum direkten Herunterladen.</p><section class="programmgruppe"><h2><a href="einfuehrung.html">Kapitel 1: Einführung in Operations Research — Vom Ursprung zur mathematischen Entscheidungsfindung</a></h2><ul class="programmliste"><li><code>Bot_Allokation.py</code> <a class="download-link" href="programme/Bot_Allokation.py" download><svg class="icon" aria-hidden="true"><use href="#icon-download"></use></svg> Herunterladen</a></li><li><code>Brute_Force_Vergleich.py</code> <a class="download-link" href="programme/Brute_Force_Vergleich.py" download><svg class="icon" aria-hidden="true"><use href="#icon-download"></use></svg> Herunterladen</a></li><li><code>Bausteine_Vorlage.py</code> <a class="download-link" href="programme/Bausteine_Vorlage.py" download><svg class="icon" aria-hidden="true"><use href="#icon-download"></use></svg> Herunterladen</a></li><li><code>Excel_Bruecke.py</code> <a class="download-link" href="programme/Excel_Bruecke.py" download><svg class="icon" aria-hidden="true"><use href="#icon-download"></use></svg> Herunterladen</a></li></ul></section><section class="programmgruppe"><h2><a href="fundament.html">Kapitel 2: Das mathematische Fundament — Vektoren, Matrizen, Konvexität</a></h2><ul class="programmliste"><li><code>Matrixform.py</code> <a class="download-link" href="programme/Matrixform.py" download><svg class="icon" aria-hidden="true"><use href="#icon-download"></use></svg> Herunterladen</a></li><li><code>Visualisierung_Loesungsraum.py</code> <a class="download-link" href="programme/Visualisierung_Loesungsraum.py" download><svg class="icon" aria-hidden="true"><use href="#icon-download"></use></svg> Herunterladen</a></li><li><code>Konvexitaet_Demo.py</code> <a class="download-link" href="programme/Konvexitaet_Demo.py" download><svg class="icon" aria-hidden="true"><use href="#icon-download"></use></svg> Herunterladen</a></li><li><code>Skalierung_Kondition.py</code> <a class="download-link" href="programme/Skalierung_Kondition.py" download><svg class="icon" aria-hidden="true"><use href="#icon-download"></use></svg> Herunterladen</a></li></ul></section><section class="programmgruppe"><h2><a href="oekosystem.html">Kapitel 3: Das Python-Ökosystem für OR — Solver, Bindings und Modellierungsschichten</a></h2><ul class="programmliste"><li><code>Ein_System_Vier_Ansaetze.py</code> <a class="download-link" href="programme/Ein_System_Vier_Ansaetze.py" download><svg class="icon" aria-hidden="true"><use href="#icon-download"></use></svg> Herunterladen</a></li><li><code>Solver_Wahl.py</code> <a class="download-link" href="programme/Solver_Wahl.py" download><svg class="icon" aria-hidden="true"><use href="#icon-download"></use></svg> Herunterladen</a></li><li><code>Modellierungsschichten.py</code> <a class="download-link" href="programme/Modellierungsschichten.py" download><svg class="icon" aria-hidden="true"><use href="#icon-download"></use></svg> Herunterladen</a></li><li><code>Vektorisierte_Modellgenerierung.py</code> <a class="download-link" href="programme/Vektorisierte_Modellgenerierung.py" download><svg class="icon" aria-hidden="true"><use href="#icon-download"></use></svg> Herunterladen</a></li></ul></section><section class="programmgruppe"><h2><a href="modellierung.html">Kapitel 4: Vom Management-Wunsch zum Modell</a></h2><ul class="programmliste"><li><code>Vom_Wunsch_zum_Modell.py</code> <a class="download-link" href="programme/Vom_Wunsch_zum_Modell.py" download><svg class="icon" aria-hidden="true"><use href="#icon-download"></use></svg> Herunterladen</a></li></ul></section><section class="programmgruppe"><h2><a href="lp.html">Kapitel 5: Lineare Programmierung — Simplex, Dualität und Schattenpreise</a></h2><ul class="programmliste"><li><code>Simplex_Tableau_LP.py</code> <a class="download-link" href="programme/Simplex_Tableau_LP.py" download><svg class="icon" aria-hidden="true"><use href="#icon-download"></use></svg> Herunterladen</a></li><li><code>Sensitivitaetsanalyse.py</code> <a class="download-link" href="programme/Sensitivitaetsanalyse.py" download><svg class="icon" aria-hidden="true"><use href="#icon-download"></use></svg> Herunterladen</a></li><li><code>Dualitaet_Nachweis.py</code> <a class="download-link" href="programme/Dualitaet_Nachweis.py" download><svg class="icon" aria-hidden="true"><use href="#icon-download"></use></svg> Herunterladen</a></li><li><code>Toleranzen_und_Entartung.py</code> <a class="download-link" href="programme/Toleranzen_und_Entartung.py" download><svg class="icon" aria-hidden="true"><use href="#icon-download"></use></svg> Herunterladen</a></li></ul></section><section class="programmgruppe"><h2><a href="milp.html">Kapitel 6: Gemischt-ganzzahlige Optimierung — Diskrete Entscheidungen und Branch-and-Bound</a></h2><ul class="programmliste"><li><code>Runden_Gegenbeispiel.py</code> <a class="download-link" href="programme/Runden_Gegenbeispiel.py" download><svg class="icon" aria-hidden="true"><use href="#icon-download"></use></svg> Herunterladen</a></li><li><code>Rucksack.py</code> <a class="download-link" href="programme/Rucksack.py" download><svg class="icon" aria-hidden="true"><use href="#icon-download"></use></svg> Herunterladen</a></li><li><code>MILP_Portfolio_Fixgebuehren.py</code> <a class="download-link" href="programme/MILP_Portfolio_Fixgebuehren.py" download><svg class="icon" aria-hidden="true"><use href="#icon-download"></use></svg> Herunterladen</a></li><li><code>Solverstatus_und_Gap.py</code> <a class="download-link" href="programme/Solverstatus_und_Gap.py" download><svg class="icon" aria-hidden="true"><use href="#icon-download"></use></svg> Herunterladen</a></li><li><code>Warmstart_Effekt.py</code> <a class="download-link" href="programme/Warmstart_Effekt.py" download><svg class="icon" aria-hidden="true"><use href="#icon-download"></use></svg> Herunterladen</a></li><li><code>Big_M_Falle.py</code> <a class="download-link" href="programme/Big_M_Falle.py" download><svg class="icon" aria-hidden="true"><use href="#icon-download"></use></svg> Herunterladen</a></li></ul></section><section class="programmgruppe"><h2><a href="cpsat.html">Kapitel 7: Constraint Programming mit CP-SAT — Logik, Scheduling und Zuweisung</a></h2><ul class="programmliste"><li><code>Propagation_Demo.py</code> <a class="download-link" href="programme/Propagation_Demo.py" download><svg class="icon" aria-hidden="true"><use href="#icon-download"></use></svg> Herunterladen</a></li><li><code>CP_SAT_Vertretungssystem.py</code> <a class="download-link" href="programme/CP_SAT_Vertretungssystem.py" download><svg class="icon" aria-hidden="true"><use href="#icon-download"></use></svg> Herunterladen</a></li><li><code>JobShop_Intervalle.py</code> <a class="download-link" href="programme/JobShop_Intervalle.py" download><svg class="icon" aria-hidden="true"><use href="#icon-download"></use></svg> Herunterladen</a></li><li><code>CP_SAT_Statusfaelle.py</code> <a class="download-link" href="programme/CP_SAT_Statusfaelle.py" download><svg class="icon" aria-hidden="true"><use href="#icon-download"></use></svg> Herunterladen</a></li><li><code>Strafgewichte.py</code> <a class="download-link" href="programme/Strafgewichte.py" download><svg class="icon" aria-hidden="true"><use href="#icon-download"></use></svg> Herunterladen</a></li></ul></section><section class="programmgruppe"><h2><a href="graphen.html">Kapitel 8: Graphen, Flüsse und Touren — Min-Cost-Flow, Matching und VRP</a></h2><ul class="programmliste"><li><code>Min_Cost_Flow.py</code> <a class="download-link" href="programme/Min_Cost_Flow.py" download><svg class="icon" aria-hidden="true"><use href="#icon-download"></use></svg> Herunterladen</a></li><li><code>Zuordnung_Ungarisch.py</code> <a class="download-link" href="programme/Zuordnung_Ungarisch.py" download><svg class="icon" aria-hidden="true"><use href="#icon-download"></use></svg> Herunterladen</a></li><li><code>VRP_Flotten_Routing.py</code> <a class="download-link" href="programme/VRP_Flotten_Routing.py" download><svg class="icon" aria-hidden="true"><use href="#icon-download"></use></svg> Herunterladen</a></li><li><code>VRP_Kapazitaetsfalle.py</code> <a class="download-link" href="programme/VRP_Kapazitaetsfalle.py" download><svg class="icon" aria-hidden="true"><use href="#icon-download"></use></svg> Herunterladen</a></li></ul></section><section class="programmgruppe"><h2><a href="metaheuristiken.html">Kapitel 9: Metaheuristiken — wenn der exakte Solver aussteigt</a></h2><ul class="programmliste"><li><code>Simulated_Annealing.py</code> <a class="download-link" href="programme/Simulated_Annealing.py" download><svg class="icon" aria-hidden="true"><use href="#icon-download"></use></svg> Herunterladen</a></li><li><code>Metaheuristik_vs_Exakt.py</code> <a class="download-link" href="programme/Metaheuristik_vs_Exakt.py" download><svg class="icon" aria-hidden="true"><use href="#icon-download"></use></svg> Herunterladen</a></li><li><code>Large_Neighborhood_Search.py</code> <a class="download-link" href="programme/Large_Neighborhood_Search.py" download><svg class="icon" aria-hidden="true"><use href="#icon-download"></use></svg> Herunterladen</a></li></ul></section><section class="programmgruppe"><h2><a href="dekomposition.html">Kapitel 10: Spaltengenerierung — das Modell umbauen statt die Lösung raten</a></h2><ul class="programmliste"><li><code>Spaltengenerierung.py</code> <a class="download-link" href="programme/Spaltengenerierung.py" download><svg class="icon" aria-hidden="true"><use href="#icon-download"></use></svg> Herunterladen</a></li></ul></section><section class="programmgruppe"><h2><a href="qp-nlp.html">Kapitel 11: Quadratische und nichtlineare Optimierung — KKT, Lagrange, Konvexität</a></h2><ul class="programmliste"><li><code>QP_Grundlagen.py</code> <a class="download-link" href="programme/QP_Grundlagen.py" download><svg class="icon" aria-hidden="true"><use href="#icon-download"></use></svg> Herunterladen</a></li><li><code>KKT_Nachweis.py</code> <a class="download-link" href="programme/KKT_Nachweis.py" download><svg class="icon" aria-hidden="true"><use href="#icon-download"></use></svg> Herunterladen</a></li><li><code>Entropie_Maximierte_Allokation.py</code> <a class="download-link" href="programme/Entropie_Maximierte_Allokation.py" download><svg class="icon" aria-hidden="true"><use href="#icon-download"></use></svg> Herunterladen</a></li><li><code>Lokale_Optima_Multistart.py</code> <a class="download-link" href="programme/Lokale_Optima_Multistart.py" download><svg class="icon" aria-hidden="true"><use href="#icon-download"></use></svg> Herunterladen</a></li></ul></section><section class="programmgruppe"><h2><a href="unsicherheit.html">Kapitel 12: Optimierung unter Unsicherheit — Monte-Carlo, Stochastik, Robustheit</a></h2><ul class="programmliste"><li><code>Fluch_des_Durchschnitts.py</code> <a class="download-link" href="programme/Fluch_des_Durchschnitts.py" download><svg class="icon" aria-hidden="true"><use href="#icon-download"></use></svg> Herunterladen</a></li><li><code>Monte_Carlo.py</code> <a class="download-link" href="programme/Monte_Carlo.py" download><svg class="icon" aria-hidden="true"><use href="#icon-download"></use></svg> Herunterladen</a></li><li><code>Stochastische_Optimierung.py</code> <a class="download-link" href="programme/Stochastische_Optimierung.py" download><svg class="icon" aria-hidden="true"><use href="#icon-download"></use></svg> Herunterladen</a></li><li><code>Robuste_Optimierung.py</code> <a class="download-link" href="programme/Robuste_Optimierung.py" download><svg class="icon" aria-hidden="true"><use href="#icon-download"></use></svg> Herunterladen</a></li><li><code>Chance_Constraints.py</code> <a class="download-link" href="programme/Chance_Constraints.py" download><svg class="icon" aria-hidden="true"><use href="#icon-download"></use></svg> Herunterladen</a></li></ul></section><section class="programmgruppe"><h2><a href="dynamische-programmierung.html">Kapitel 13: Dynamische Programmierung — Die Bellman-Gleichung und Order-Execution</a></h2><ul class="programmliste"><li><code>Bellman_Minimalbeispiel.py</code> <a class="download-link" href="programme/Bellman_Minimalbeispiel.py" download><svg class="icon" aria-hidden="true"><use href="#icon-download"></use></svg> Herunterladen</a></li><li><code>Mehrperiodige_Order_Execution.py</code> <a class="download-link" href="programme/Mehrperiodige_Order_Execution.py" download><svg class="icon" aria-hidden="true"><use href="#icon-download"></use></svg> Herunterladen</a></li></ul></section><section class="programmgruppe"><h2><a href="mehrziel.html">Kapitel 14: Mehrere Ziele — Pareto-Fronten statt Gewichte</a></h2><ul class="programmliste"><li><code>Mehrziel_Pareto.py</code> <a class="download-link" href="programme/Mehrziel_Pareto.py" download><svg class="icon" aria-hidden="true"><use href="#icon-download"></use></svg> Herunterladen</a></li></ul></section><section class="programmgruppe"><h2><a href="prognose.html">Kapitel 15: Predict-then-Optimize — die bessere Prognose, die schlechtere Entscheidung</a></h2><ul class="programmliste"><li><code>Predict_then_Optimize.py</code> <a class="download-link" href="programme/Predict_then_Optimize.py" download><svg class="icon" aria-hidden="true"><use href="#icon-download"></use></svg> Herunterladen</a></li></ul></section><section class="programmgruppe"><h2><a href="bruecke.html">Kapitel 16: Die Strukturbrücke — dieselbe Mathematik, zwei Welten</a></h2><ul class="programmliste"><li><code>Strukturbruecke.py</code> <a class="download-link" href="programme/Strukturbruecke.py" download><svg class="icon" aria-hidden="true"><use href="#icon-download"></use></svg> Herunterladen</a></li></ul></section><section class="programmgruppe"><h2><a href="supplychain.html">Kapitel 17: Supply-Chain und Energieeinsatz unter Unsicherheit</a></h2><ul class="programmliste"><li><code>Kraftwerkseinsatz.py</code> <a class="download-link" href="programme/Kraftwerkseinsatz.py" download><svg class="icon" aria-hidden="true"><use href="#icon-download"></use></svg> Herunterladen</a></li></ul></section><section class="programmgruppe"><h2><a href="finanzdaten.html">Kapitel 18: Finanzdaten-Modellierung — Renditen, Kovarianz und Shrinkage</a></h2><ul class="programmliste"><li><code>Renditen_Vergleich.py</code> <a class="download-link" href="programme/Renditen_Vergleich.py" download><svg class="icon" aria-hidden="true"><use href="#icon-download"></use></svg> Herunterladen</a></li><li><code>Schaetzrauschen_Demo.py</code> <a class="download-link" href="programme/Schaetzrauschen_Demo.py" download><svg class="icon" aria-hidden="true"><use href="#icon-download"></use></svg> Herunterladen</a></li><li><code>Finanzdaten_Ledoit_Wolf.py</code> <a class="download-link" href="programme/Finanzdaten_Ledoit_Wolf.py" download><svg class="icon" aria-hidden="true"><use href="#icon-download"></use></svg> Herunterladen</a></li><li><code>Kovarianz_Falle.py</code> <a class="download-link" href="programme/Kovarianz_Falle.py" download><svg class="icon" aria-hidden="true"><use href="#icon-download"></use></svg> Herunterladen</a></li></ul></section><section class="programmgruppe"><h2><a href="markowitz.html">Kapitel 19: Die moderne Portfoliotheorie nach Markowitz</a></h2><ul class="programmliste"><li><code>Diversifikation_Demo.py</code> <a class="download-link" href="programme/Diversifikation_Demo.py" download><svg class="icon" aria-hidden="true"><use href="#icon-download"></use></svg> Herunterladen</a></li><li><code>Markowitz_CVXPY.py</code> <a class="download-link" href="programme/Markowitz_CVXPY.py" download><svg class="icon" aria-hidden="true"><use href="#icon-download"></use></svg> Herunterladen</a></li><li><code>Renditeschaetzung_Falle.py</code> <a class="download-link" href="programme/Renditeschaetzung_Falle.py" download><svg class="icon" aria-hidden="true"><use href="#icon-download"></use></svg> Herunterladen</a></li></ul></section><section class="programmgruppe"><h2><a href="cvar.html">Kapitel 20: Tail-Risiko, CVaR und Transaktionskosten</a></h2><ul class="programmliste"><li><code>VaR_CVaR_Demo.py</code> <a class="download-link" href="programme/VaR_CVaR_Demo.py" download><svg class="icon" aria-hidden="true"><use href="#icon-download"></use></svg> Herunterladen</a></li><li><code>CVaR_Portfolio.py</code> <a class="download-link" href="programme/CVaR_Portfolio.py" download><svg class="icon" aria-hidden="true"><use href="#icon-download"></use></svg> Herunterladen</a></li></ul></section><section class="programmgruppe"><h2><a href="handelsmaschine.html">Kapitel 21: Die vollständige quantitative Handelsmaschine</a></h2><ul class="programmliste"><li><code>QuantitativeTradingEngine.py</code> <a class="download-link" href="programme/QuantitativeTradingEngine.py" download><svg class="icon" aria-hidden="true"><use href="#icon-download"></use></svg> Herunterladen</a></li><li><code>Backtest_Fallen.py</code> <a class="download-link" href="programme/Backtest_Fallen.py" download><svg class="icon" aria-hidden="true"><use href="#icon-download"></use></svg> Herunterladen</a></li><li><code>Data_Snooping.py</code> <a class="download-link" href="programme/Data_Snooping.py" download><svg class="icon" aria-hidden="true"><use href="#icon-download"></use></svg> Herunterladen</a></li></ul></section><section class="programmgruppe"><h2><a href="praxisfallen.html">Kapitel 22: Praxisfallen und der Weg zum produktiven Einsatz</a></h2><ul class="programmliste"><li><code>Infeasibility_Diagnose.py</code> <a class="download-link" href="programme/Infeasibility_Diagnose.py" download><svg class="icon" aria-hidden="true"><use href="#icon-download"></use></svg> Herunterladen</a></li><li><code>Erklaerbarkeit.py</code> <a class="download-link" href="programme/Erklaerbarkeit.py" download><svg class="icon" aria-hidden="true"><use href="#icon-download"></use></svg> Herunterladen</a></li><li><code>Betriebsueberwachung.py</code> <a class="download-link" href="programme/Betriebsueberwachung.py" download><svg class="icon" aria-hidden="true"><use href="#icon-download"></use></svg> Herunterladen</a></li><li><code>or_kern.py</code> <a class="download-link" href="programme/or_kern.py" download><svg class="icon" aria-hidden="true"><use href="#icon-download"></use></svg> Herunterladen</a></li><li><code>Solverwechsel_CPSAT_HiGHS.py</code> <a class="download-link" href="programme/Solverwechsel_CPSAT_HiGHS.py" download><svg class="icon" aria-hidden="true"><use href="#icon-download"></use></svg> Herunterladen</a></li></ul></section><section class="programmgruppe"><h2><a href="testing.html">Kapitel 23: Testen, Messen, Ausliefern</a></h2><ul class="programmliste"><li><code>test_or_kern.py</code> <a class="download-link" href="programme/test_or_kern.py" download><svg class="icon" aria-hidden="true"><use href="#icon-download"></use></svg> Herunterladen</a></li><li><code>Mutationstest.py</code> <a class="download-link" href="programme/Mutationstest.py" download><svg class="icon" aria-hidden="true"><use href="#icon-download"></use></svg> Herunterladen</a></li><li><code>Benchmark_Skalierung.py</code> <a class="download-link" href="programme/Benchmark_Skalierung.py" download><svg class="icon" aria-hidden="true"><use href="#icon-download"></use></svg> Herunterladen</a></li><li><code>Optimierungsdienst.py</code> <a class="download-link" href="programme/Optimierungsdienst.py" download><svg class="icon" aria-hidden="true"><use href="#icon-download"></use></svg> Herunterladen</a></li></ul></section>
+    <h1>Beispielprogramme</h1><p>Alle 76 im Buch abgedruckten Programme, gruppiert nach Kapitel, zum direkten Herunterladen.</p><section class="programmgruppe"><h2><a href="einfuehrung.html">Kapitel 1: Einführung in Operations Research — Vom Ursprung zur mathematischen Entscheidungsfindung</a></h2><ul class="programmliste"><li><code>Bot_Allokation.py</code> <a class="download-link" href="programme/Bot_Allokation.py" download><svg class="icon" aria-hidden="true"><use href="#icon-download"></use></svg> Herunterladen</a></li><li><code>Brute_Force_Vergleich.py</code> <a class="download-link" href="programme/Brute_Force_Vergleich.py" download><svg class="icon" aria-hidden="true"><use href="#icon-download"></use></svg> Herunterladen</a></li><li><code>Bausteine_Vorlage.py</code> <a class="download-link" href="programme/Bausteine_Vorlage.py" download><svg class="icon" aria-hidden="true"><use href="#icon-download"></use></svg> Herunterladen</a></li><li><code>Excel_Bruecke.py</code> <a class="download-link" href="programme/Excel_Bruecke.py" download><svg class="icon" aria-hidden="true"><use href="#icon-download"></use></svg> Herunterladen</a></li></ul></section><section class="programmgruppe"><h2><a href="fundament.html">Kapitel 2: Das mathematische Fundament — Vektoren, Matrizen, Konvexität</a></h2><ul class="programmliste"><li><code>Matrixform.py</code> <a class="download-link" href="programme/Matrixform.py" download><svg class="icon" aria-hidden="true"><use href="#icon-download"></use></svg> Herunterladen</a></li><li><code>Visualisierung_Loesungsraum.py</code> <a class="download-link" href="programme/Visualisierung_Loesungsraum.py" download><svg class="icon" aria-hidden="true"><use href="#icon-download"></use></svg> Herunterladen</a></li><li><code>Konvexitaet_Demo.py</code> <a class="download-link" href="programme/Konvexitaet_Demo.py" download><svg class="icon" aria-hidden="true"><use href="#icon-download"></use></svg> Herunterladen</a></li><li><code>Skalierung_Kondition.py</code> <a class="download-link" href="programme/Skalierung_Kondition.py" download><svg class="icon" aria-hidden="true"><use href="#icon-download"></use></svg> Herunterladen</a></li></ul></section><section class="programmgruppe"><h2><a href="oekosystem.html">Kapitel 3: Das Python-Ökosystem für OR — Solver, Bindings und Modellierungsschichten</a></h2><ul class="programmliste"><li><code>Ein_System_Vier_Ansaetze.py</code> <a class="download-link" href="programme/Ein_System_Vier_Ansaetze.py" download><svg class="icon" aria-hidden="true"><use href="#icon-download"></use></svg> Herunterladen</a></li><li><code>Solver_Wahl.py</code> <a class="download-link" href="programme/Solver_Wahl.py" download><svg class="icon" aria-hidden="true"><use href="#icon-download"></use></svg> Herunterladen</a></li><li><code>Modellierungsschichten.py</code> <a class="download-link" href="programme/Modellierungsschichten.py" download><svg class="icon" aria-hidden="true"><use href="#icon-download"></use></svg> Herunterladen</a></li><li><code>Vektorisierte_Modellgenerierung.py</code> <a class="download-link" href="programme/Vektorisierte_Modellgenerierung.py" download><svg class="icon" aria-hidden="true"><use href="#icon-download"></use></svg> Herunterladen</a></li></ul></section><section class="programmgruppe"><h2><a href="modellierung.html">Kapitel 4: Vom Management-Wunsch zum Modell</a></h2><ul class="programmliste"><li><code>Vom_Wunsch_zum_Modell.py</code> <a class="download-link" href="programme/Vom_Wunsch_zum_Modell.py" download><svg class="icon" aria-hidden="true"><use href="#icon-download"></use></svg> Herunterladen</a></li></ul></section><section class="programmgruppe"><h2><a href="lp.html">Kapitel 5: Lineare Programmierung — Simplex, Dualität und Schattenpreise</a></h2><ul class="programmliste"><li><code>Simplex_Tableau_LP.py</code> <a class="download-link" href="programme/Simplex_Tableau_LP.py" download><svg class="icon" aria-hidden="true"><use href="#icon-download"></use></svg> Herunterladen</a></li><li><code>Sensitivitaetsanalyse.py</code> <a class="download-link" href="programme/Sensitivitaetsanalyse.py" download><svg class="icon" aria-hidden="true"><use href="#icon-download"></use></svg> Herunterladen</a></li><li><code>Dualitaet_Nachweis.py</code> <a class="download-link" href="programme/Dualitaet_Nachweis.py" download><svg class="icon" aria-hidden="true"><use href="#icon-download"></use></svg> Herunterladen</a></li><li><code>Toleranzen_und_Entartung.py</code> <a class="download-link" href="programme/Toleranzen_und_Entartung.py" download><svg class="icon" aria-hidden="true"><use href="#icon-download"></use></svg> Herunterladen</a></li></ul></section><section class="programmgruppe"><h2><a href="milp.html">Kapitel 6: Gemischt-ganzzahlige Optimierung — Diskrete Entscheidungen und Branch-and-Bound</a></h2><ul class="programmliste"><li><code>Runden_Gegenbeispiel.py</code> <a class="download-link" href="programme/Runden_Gegenbeispiel.py" download><svg class="icon" aria-hidden="true"><use href="#icon-download"></use></svg> Herunterladen</a></li><li><code>Rucksack.py</code> <a class="download-link" href="programme/Rucksack.py" download><svg class="icon" aria-hidden="true"><use href="#icon-download"></use></svg> Herunterladen</a></li><li><code>MILP_Portfolio_Fixgebuehren.py</code> <a class="download-link" href="programme/MILP_Portfolio_Fixgebuehren.py" download><svg class="icon" aria-hidden="true"><use href="#icon-download"></use></svg> Herunterladen</a></li><li><code>Solverstatus_und_Gap.py</code> <a class="download-link" href="programme/Solverstatus_und_Gap.py" download><svg class="icon" aria-hidden="true"><use href="#icon-download"></use></svg> Herunterladen</a></li><li><code>Warmstart_Effekt.py</code> <a class="download-link" href="programme/Warmstart_Effekt.py" download><svg class="icon" aria-hidden="true"><use href="#icon-download"></use></svg> Herunterladen</a></li><li><code>Big_M_Falle.py</code> <a class="download-link" href="programme/Big_M_Falle.py" download><svg class="icon" aria-hidden="true"><use href="#icon-download"></use></svg> Herunterladen</a></li></ul></section><section class="programmgruppe"><h2><a href="cpsat.html">Kapitel 7: Constraint Programming mit CP-SAT — Logik, Scheduling und Zuweisung</a></h2><ul class="programmliste"><li><code>Propagation_Demo.py</code> <a class="download-link" href="programme/Propagation_Demo.py" download><svg class="icon" aria-hidden="true"><use href="#icon-download"></use></svg> Herunterladen</a></li><li><code>CP_SAT_Vertretungssystem.py</code> <a class="download-link" href="programme/CP_SAT_Vertretungssystem.py" download><svg class="icon" aria-hidden="true"><use href="#icon-download"></use></svg> Herunterladen</a></li><li><code>JobShop_Intervalle.py</code> <a class="download-link" href="programme/JobShop_Intervalle.py" download><svg class="icon" aria-hidden="true"><use href="#icon-download"></use></svg> Herunterladen</a></li><li><code>Parallele_Suche.py</code> <a class="download-link" href="programme/Parallele_Suche.py" download><svg class="icon" aria-hidden="true"><use href="#icon-download"></use></svg> Herunterladen</a></li><li><code>CP_SAT_Statusfaelle.py</code> <a class="download-link" href="programme/CP_SAT_Statusfaelle.py" download><svg class="icon" aria-hidden="true"><use href="#icon-download"></use></svg> Herunterladen</a></li><li><code>Strafgewichte.py</code> <a class="download-link" href="programme/Strafgewichte.py" download><svg class="icon" aria-hidden="true"><use href="#icon-download"></use></svg> Herunterladen</a></li></ul></section><section class="programmgruppe"><h2><a href="graphen.html">Kapitel 8: Graphen, Flüsse und Touren — Min-Cost-Flow, Matching und VRP</a></h2><ul class="programmliste"><li><code>Min_Cost_Flow.py</code> <a class="download-link" href="programme/Min_Cost_Flow.py" download><svg class="icon" aria-hidden="true"><use href="#icon-download"></use></svg> Herunterladen</a></li><li><code>Zuordnung_Ungarisch.py</code> <a class="download-link" href="programme/Zuordnung_Ungarisch.py" download><svg class="icon" aria-hidden="true"><use href="#icon-download"></use></svg> Herunterladen</a></li><li><code>VRP_Flotten_Routing.py</code> <a class="download-link" href="programme/VRP_Flotten_Routing.py" download><svg class="icon" aria-hidden="true"><use href="#icon-download"></use></svg> Herunterladen</a></li><li><code>VRP_Kapazitaetsfalle.py</code> <a class="download-link" href="programme/VRP_Kapazitaetsfalle.py" download><svg class="icon" aria-hidden="true"><use href="#icon-download"></use></svg> Herunterladen</a></li></ul></section><section class="programmgruppe"><h2><a href="metaheuristiken.html">Kapitel 9: Metaheuristiken — wenn der exakte Solver aussteigt</a></h2><ul class="programmliste"><li><code>Simulated_Annealing.py</code> <a class="download-link" href="programme/Simulated_Annealing.py" download><svg class="icon" aria-hidden="true"><use href="#icon-download"></use></svg> Herunterladen</a></li><li><code>Metaheuristik_vs_Exakt.py</code> <a class="download-link" href="programme/Metaheuristik_vs_Exakt.py" download><svg class="icon" aria-hidden="true"><use href="#icon-download"></use></svg> Herunterladen</a></li><li><code>Large_Neighborhood_Search.py</code> <a class="download-link" href="programme/Large_Neighborhood_Search.py" download><svg class="icon" aria-hidden="true"><use href="#icon-download"></use></svg> Herunterladen</a></li></ul></section><section class="programmgruppe"><h2><a href="dekomposition.html">Kapitel 10: Spaltengenerierung — das Modell umbauen statt die Lösung raten</a></h2><ul class="programmliste"><li><code>Spaltengenerierung.py</code> <a class="download-link" href="programme/Spaltengenerierung.py" download><svg class="icon" aria-hidden="true"><use href="#icon-download"></use></svg> Herunterladen</a></li></ul></section><section class="programmgruppe"><h2><a href="qp-nlp.html">Kapitel 11: Quadratische und nichtlineare Optimierung — KKT, Lagrange, Konvexität</a></h2><ul class="programmliste"><li><code>QP_Grundlagen.py</code> <a class="download-link" href="programme/QP_Grundlagen.py" download><svg class="icon" aria-hidden="true"><use href="#icon-download"></use></svg> Herunterladen</a></li><li><code>KKT_Nachweis.py</code> <a class="download-link" href="programme/KKT_Nachweis.py" download><svg class="icon" aria-hidden="true"><use href="#icon-download"></use></svg> Herunterladen</a></li><li><code>Entropie_Maximierte_Allokation.py</code> <a class="download-link" href="programme/Entropie_Maximierte_Allokation.py" download><svg class="icon" aria-hidden="true"><use href="#icon-download"></use></svg> Herunterladen</a></li><li><code>Lokale_Optima_Multistart.py</code> <a class="download-link" href="programme/Lokale_Optima_Multistart.py" download><svg class="icon" aria-hidden="true"><use href="#icon-download"></use></svg> Herunterladen</a></li></ul></section><section class="programmgruppe"><h2><a href="unsicherheit.html">Kapitel 12: Optimierung unter Unsicherheit — Monte-Carlo, Stochastik, Robustheit</a></h2><ul class="programmliste"><li><code>Fluch_des_Durchschnitts.py</code> <a class="download-link" href="programme/Fluch_des_Durchschnitts.py" download><svg class="icon" aria-hidden="true"><use href="#icon-download"></use></svg> Herunterladen</a></li><li><code>Monte_Carlo.py</code> <a class="download-link" href="programme/Monte_Carlo.py" download><svg class="icon" aria-hidden="true"><use href="#icon-download"></use></svg> Herunterladen</a></li><li><code>Stochastische_Optimierung.py</code> <a class="download-link" href="programme/Stochastische_Optimierung.py" download><svg class="icon" aria-hidden="true"><use href="#icon-download"></use></svg> Herunterladen</a></li><li><code>Robuste_Optimierung.py</code> <a class="download-link" href="programme/Robuste_Optimierung.py" download><svg class="icon" aria-hidden="true"><use href="#icon-download"></use></svg> Herunterladen</a></li><li><code>Chance_Constraints.py</code> <a class="download-link" href="programme/Chance_Constraints.py" download><svg class="icon" aria-hidden="true"><use href="#icon-download"></use></svg> Herunterladen</a></li></ul></section><section class="programmgruppe"><h2><a href="dynamische-programmierung.html">Kapitel 13: Dynamische Programmierung — Die Bellman-Gleichung und Order-Execution</a></h2><ul class="programmliste"><li><code>Bellman_Minimalbeispiel.py</code> <a class="download-link" href="programme/Bellman_Minimalbeispiel.py" download><svg class="icon" aria-hidden="true"><use href="#icon-download"></use></svg> Herunterladen</a></li><li><code>Mehrperiodige_Order_Execution.py</code> <a class="download-link" href="programme/Mehrperiodige_Order_Execution.py" download><svg class="icon" aria-hidden="true"><use href="#icon-download"></use></svg> Herunterladen</a></li></ul></section><section class="programmgruppe"><h2><a href="mehrziel.html">Kapitel 14: Mehrere Ziele — Pareto-Fronten statt Gewichte</a></h2><ul class="programmliste"><li><code>Mehrziel_Pareto.py</code> <a class="download-link" href="programme/Mehrziel_Pareto.py" download><svg class="icon" aria-hidden="true"><use href="#icon-download"></use></svg> Herunterladen</a></li></ul></section><section class="programmgruppe"><h2><a href="prognose.html">Kapitel 15: Predict-then-Optimize — die bessere Prognose, die schlechtere Entscheidung</a></h2><ul class="programmliste"><li><code>Predict_then_Optimize.py</code> <a class="download-link" href="programme/Predict_then_Optimize.py" download><svg class="icon" aria-hidden="true"><use href="#icon-download"></use></svg> Herunterladen</a></li></ul></section><section class="programmgruppe"><h2><a href="bruecke.html">Kapitel 16: Die Strukturbrücke — dieselbe Mathematik, zwei Welten</a></h2><ul class="programmliste"><li><code>Strukturbruecke.py</code> <a class="download-link" href="programme/Strukturbruecke.py" download><svg class="icon" aria-hidden="true"><use href="#icon-download"></use></svg> Herunterladen</a></li></ul></section><section class="programmgruppe"><h2><a href="supplychain.html">Kapitel 17: Supply-Chain und Energieeinsatz unter Unsicherheit</a></h2><ul class="programmliste"><li><code>Kraftwerkseinsatz.py</code> <a class="download-link" href="programme/Kraftwerkseinsatz.py" download><svg class="icon" aria-hidden="true"><use href="#icon-download"></use></svg> Herunterladen</a></li></ul></section><section class="programmgruppe"><h2><a href="finanzdaten.html">Kapitel 18: Finanzdaten-Modellierung — Renditen, Kovarianz und Shrinkage</a></h2><ul class="programmliste"><li><code>Renditen_Vergleich.py</code> <a class="download-link" href="programme/Renditen_Vergleich.py" download><svg class="icon" aria-hidden="true"><use href="#icon-download"></use></svg> Herunterladen</a></li><li><code>Schaetzrauschen_Demo.py</code> <a class="download-link" href="programme/Schaetzrauschen_Demo.py" download><svg class="icon" aria-hidden="true"><use href="#icon-download"></use></svg> Herunterladen</a></li><li><code>Finanzdaten_Ledoit_Wolf.py</code> <a class="download-link" href="programme/Finanzdaten_Ledoit_Wolf.py" download><svg class="icon" aria-hidden="true"><use href="#icon-download"></use></svg> Herunterladen</a></li><li><code>Kovarianz_Falle.py</code> <a class="download-link" href="programme/Kovarianz_Falle.py" download><svg class="icon" aria-hidden="true"><use href="#icon-download"></use></svg> Herunterladen</a></li></ul></section><section class="programmgruppe"><h2><a href="markowitz.html">Kapitel 19: Die moderne Portfoliotheorie nach Markowitz</a></h2><ul class="programmliste"><li><code>Diversifikation_Demo.py</code> <a class="download-link" href="programme/Diversifikation_Demo.py" download><svg class="icon" aria-hidden="true"><use href="#icon-download"></use></svg> Herunterladen</a></li><li><code>Markowitz_CVXPY.py</code> <a class="download-link" href="programme/Markowitz_CVXPY.py" download><svg class="icon" aria-hidden="true"><use href="#icon-download"></use></svg> Herunterladen</a></li><li><code>Renditeschaetzung_Falle.py</code> <a class="download-link" href="programme/Renditeschaetzung_Falle.py" download><svg class="icon" aria-hidden="true"><use href="#icon-download"></use></svg> Herunterladen</a></li></ul></section><section class="programmgruppe"><h2><a href="cvar.html">Kapitel 20: Tail-Risiko, CVaR und Transaktionskosten</a></h2><ul class="programmliste"><li><code>VaR_CVaR_Demo.py</code> <a class="download-link" href="programme/VaR_CVaR_Demo.py" download><svg class="icon" aria-hidden="true"><use href="#icon-download"></use></svg> Herunterladen</a></li><li><code>CVaR_Portfolio.py</code> <a class="download-link" href="programme/CVaR_Portfolio.py" download><svg class="icon" aria-hidden="true"><use href="#icon-download"></use></svg> Herunterladen</a></li></ul></section><section class="programmgruppe"><h2><a href="handelsmaschine.html">Kapitel 21: Die vollständige quantitative Handelsmaschine</a></h2><ul class="programmliste"><li><code>QuantitativeTradingEngine.py</code> <a class="download-link" href="programme/QuantitativeTradingEngine.py" download><svg class="icon" aria-hidden="true"><use href="#icon-download"></use></svg> Herunterladen</a></li><li><code>Backtest_Fallen.py</code> <a class="download-link" href="programme/Backtest_Fallen.py" download><svg class="icon" aria-hidden="true"><use href="#icon-download"></use></svg> Herunterladen</a></li><li><code>Data_Snooping.py</code> <a class="download-link" href="programme/Data_Snooping.py" download><svg class="icon" aria-hidden="true"><use href="#icon-download"></use></svg> Herunterladen</a></li></ul></section><section class="programmgruppe"><h2><a href="praxisfallen.html">Kapitel 22: Praxisfallen und der Weg zum produktiven Einsatz</a></h2><ul class="programmliste"><li><code>Infeasibility_Diagnose.py</code> <a class="download-link" href="programme/Infeasibility_Diagnose.py" download><svg class="icon" aria-hidden="true"><use href="#icon-download"></use></svg> Herunterladen</a></li><li><code>Erklaerbarkeit.py</code> <a class="download-link" href="programme/Erklaerbarkeit.py" download><svg class="icon" aria-hidden="true"><use href="#icon-download"></use></svg> Herunterladen</a></li><li><code>Constraint_Attribution.py</code> <a class="download-link" href="programme/Constraint_Attribution.py" download><svg class="icon" aria-hidden="true"><use href="#icon-download"></use></svg> Herunterladen</a></li><li><code>Betriebsueberwachung.py</code> <a class="download-link" href="programme/Betriebsueberwachung.py" download><svg class="icon" aria-hidden="true"><use href="#icon-download"></use></svg> Herunterladen</a></li><li><code>or_kern.py</code> <a class="download-link" href="programme/or_kern.py" download><svg class="icon" aria-hidden="true"><use href="#icon-download"></use></svg> Herunterladen</a></li><li><code>Solverwechsel_CPSAT_HiGHS.py</code> <a class="download-link" href="programme/Solverwechsel_CPSAT_HiGHS.py" download><svg class="icon" aria-hidden="true"><use href="#icon-download"></use></svg> Herunterladen</a></li></ul></section><section class="programmgruppe"><h2><a href="testing.html">Kapitel 23: Testen, Messen, Ausliefern</a></h2><ul class="programmliste"><li><code>test_or_kern.py</code> <a class="download-link" href="programme/test_or_kern.py" download><svg class="icon" aria-hidden="true"><use href="#icon-download"></use></svg> Herunterladen</a></li><li><code>Mutationstest.py</code> <a class="download-link" href="programme/Mutationstest.py" download><svg class="icon" aria-hidden="true"><use href="#icon-download"></use></svg> Herunterladen</a></li><li><code>Benchmark_Skalierung.py</code> <a class="download-link" href="programme/Benchmark_Skalierung.py" download><svg class="icon" aria-hidden="true"><use href="#icon-download"></use></svg> Herunterladen</a></li><li><code>Optimierungsdienst.py</code> <a class="download-link" href="programme/Optimierungsdienst.py" download><svg class="icon" aria-hidden="true"><use href="#icon-download"></use></svg> Herunterladen</a></li></ul></section>
     </article>
     
     <nav class="prev-next"><span class="prev-next-leer"></span><span class="prev-next-leer"></span></nav>
diff --git a/OR_HTML_04/programme/Benchmark_Skalierung.py b/OR_HTML_04/programme/Benchmark_Skalierung.py
index 731b813..0e0275b 100644
--- a/OR_HTML_04/programme/Benchmark_Skalierung.py
+++ b/OR_HTML_04/programme/Benchmark_Skalierung.py
@@ -33,113 +33,124 @@ Benoetigt: numpy; in den Kindprozessen scipy, highspy, ortools, cvxpy
 
 from __future__ import annotations
 
-import json
-import subprocess
-import sys
-import textwrap
+import multiprocessing
+import resource
+import time
+from concurrent.futures import ProcessPoolExecutor
+
+import numpy as np
 
 GROESSEN = [(10, 10), (32, 32), (100, 100)]   # (Lager, Kunden) -> 100 / 1.024 / 10.000 Variablen
 
 
-# Jeder Eintrag ist ein eigenstaendiges Programm: Instanz aufbauen, loesen,
-# Ergebnis als JSON ausgeben. Die Instanz wird in jedem Kindprozess aus
-# derselben Saat neu erzeugt - so reist nichts ueber die Prozessgrenze,
-# was das Ergebnis verfaelschen koennte.
-VORSPANN = """
-import json, time, resource
-import numpy as np
+# Instanz und Speichermessung stehen als gewoehnliche Funktionen hier - nicht
+# in einem String, den ein Kindprozess ausfuehrt. Jede Messfunktion baut die
+# Instanz aus derselben Saat neu auf, damit ueber die Prozessgrenze nichts
+# reist, was das Ergebnis verfaelschen koennte.
 
-def instanz(m, n):
+def instanz(m: int, n: int):
     rng = np.random.default_rng(20)
     kosten = rng.integers(5, 95, (m, n)).astype(float)
     angebot = rng.integers(50, 150, m).astype(float)
     bedarf = angebot.sum() * rng.dirichlet(np.ones(n))
     return kosten, angebot, bedarf
 
-def speicher_mb():
-    # ru_maxrss ist unter Linux in Kilobyte
+
+def speicher_mb() -> float:
+    # ru_maxrss ist unter Linux in Kilobyte. Gemessen wird der Kindprozess -
+    # deshalb muss jede Messung einen eigenen bekommen.
     return resource.getrusage(resource.RUSAGE_SELF).ru_maxrss / 1024
 
-M, N = {m}, {n}
-kosten, angebot, bedarf = instanz(M, N)
-"""
 
-ANSAETZE = {
-    "scipy.linprog": """
-        from scipy.optimize import linprog
-        t0 = time.perf_counter()
-        c = kosten.reshape(-1)
-        A_ub = np.zeros((M, M * N)); A_eq = np.zeros((N, M * N))
-        for i in range(M):
-            A_ub[i, i * N:(i + 1) * N] = 1.0
-        for j in range(N):
-            A_eq[j, j::N] = 1.0
-        aufbau = time.perf_counter() - t0
-        t0 = time.perf_counter()
-        r = linprog(c=c, A_ub=A_ub, b_ub=angebot, A_eq=A_eq, b_eq=bedarf,
-                    bounds=(0, None), method="highs")
-        loesen = time.perf_counter() - t0
-        ausgabe = (float(r.fun), aufbau, loesen, speicher_mb())
-    """,
-
-    "highspy": """
-        import highspy
-        t0 = time.perf_counter()
-        h = highspy.Highs(); h.setOptionValue("output_flag", False)
-        h.addVars(M * N, np.zeros(M * N), np.full(M * N, highspy.kHighsInf))
-        for k in range(M * N):
-            h.changeColCost(k, float(kosten.reshape(-1)[k]))
-        for i in range(M):
-            idx = np.arange(i * N, (i + 1) * N, dtype=np.int32)
-            h.addRow(-highspy.kHighsInf, float(angebot[i]), N, idx, np.ones(N))
-        for j in range(N):
-            idx = np.arange(j, M * N, N, dtype=np.int32)
-            h.addRow(float(bedarf[j]), float(bedarf[j]), M, idx, np.ones(M))
-        aufbau = time.perf_counter() - t0
-        t0 = time.perf_counter(); h.run(); loesen = time.perf_counter() - t0
-        ausgabe = (h.getInfo().objective_function_value, aufbau, loesen, speicher_mb())
-    """,
-
-    "ortools/GLOP": """
-        from ortools.linear_solver import pywraplp
-        t0 = time.perf_counter()
-        s = pywraplp.Solver.CreateSolver("GLOP")
-        x = [[s.NumVar(0, s.infinity(), f"x{i}_{j}") for j in range(N)]
-             for i in range(M)]
-        for i in range(M):
-            s.Add(sum(x[i]) <= float(angebot[i]))
-        for j in range(N):
-            s.Add(sum(x[i][j] for i in range(M)) == float(bedarf[j]))
-        s.Minimize(sum(float(kosten[i, j]) * x[i][j]
-                       for i in range(M) for j in range(N)))
-        aufbau = time.perf_counter() - t0
-        t0 = time.perf_counter(); s.Solve(); loesen = time.perf_counter() - t0
-        ausgabe = (s.Objective().Value(), aufbau, loesen, speicher_mb())
-    """,
-
-    "cvxpy": """
-        import cvxpy as cp
-        t0 = time.perf_counter()
-        x = cp.Variable((M, N), nonneg=True)
-        problem = cp.Problem(cp.Minimize(cp.sum(cp.multiply(kosten, x))),
-                             [cp.sum(x, axis=1) <= angebot,
-                              cp.sum(x, axis=0) == bedarf])
-        aufbau = time.perf_counter() - t0
-        t0 = time.perf_counter(); problem.solve(); loesen = time.perf_counter() - t0
-        ausgabe = (float(problem.value), aufbau, loesen, speicher_mb())
-    """,
-}
+def messe_scipy(m: int, n: int):
+    from scipy.optimize import linprog
+    kosten, angebot, bedarf = instanz(m, n)
+    t0 = time.perf_counter()
+    c = kosten.reshape(-1)
+    A_ub = np.zeros((m, m * n)); A_eq = np.zeros((n, m * n))
+    for i in range(m):
+        A_ub[i, i * n:(i + 1) * n] = 1.0
+    for j in range(n):
+        A_eq[j, j::n] = 1.0
+    aufbau = time.perf_counter() - t0
+    t0 = time.perf_counter()
+    r = linprog(c=c, A_ub=A_ub, b_ub=angebot, A_eq=A_eq, b_eq=bedarf,
+                bounds=(0, None), method="highs")
+    loesen = time.perf_counter() - t0
+    return float(r.fun), aufbau, loesen, speicher_mb()
 
 
-def messe(name: str, quelltext: str, m: int, n: int):
-    """Fuehrt einen Ansatz in einem eigenen Prozess aus."""
-    programm = (VORSPANN.format(m=m, n=n) + textwrap.dedent(quelltext)
-                + "\nprint(json.dumps(ausgabe))\n")
-    ergebnis = subprocess.run([sys.executable, "-c", programm],
-                              capture_output=True, text=True, timeout=600)
-    if ergebnis.returncode != 0:
-        return None, ergebnis.stderr.strip().splitlines()[-1][:60]
-    return json.loads(ergebnis.stdout.strip().splitlines()[-1]), None
+def messe_highspy(m: int, n: int):
+    import highspy
+    kosten, angebot, bedarf = instanz(m, n)
+    t0 = time.perf_counter()
+    h = highspy.Highs(); h.setOptionValue("output_flag", False)
+    h.addVars(m * n, np.zeros(m * n), np.full(m * n, highspy.kHighsInf))
+    for k in range(m * n):
+        h.changeColCost(k, float(kosten.reshape(-1)[k]))
+    for i in range(m):
+        idx = np.arange(i * n, (i + 1) * n, dtype=np.int32)
+        h.addRow(-highspy.kHighsInf, float(angebot[i]), n, idx, np.ones(n))
+    for j in range(n):
+        idx = np.arange(j, m * n, n, dtype=np.int32)
+        h.addRow(float(bedarf[j]), float(bedarf[j]), m, idx, np.ones(m))
+    aufbau = time.perf_counter() - t0
+    t0 = time.perf_counter(); h.run(); loesen = time.perf_counter() - t0
+    return h.getInfo().objective_function_value, aufbau, loesen, speicher_mb()
+
+
+def messe_ortools(m: int, n: int):
+    from ortools.linear_solver import pywraplp
+    kosten, angebot, bedarf = instanz(m, n)
+    t0 = time.perf_counter()
+    s = pywraplp.Solver.CreateSolver("GLOP")
+    x = [[s.NumVar(0, s.infinity(), f"x{i}_{j}") for j in range(n)]
+         for i in range(m)]
+    for i in range(m):
+        s.Add(sum(x[i]) <= float(angebot[i]))
+    for j in range(n):
+        s.Add(sum(x[i][j] for i in range(m)) == float(bedarf[j]))
+    s.Minimize(sum(float(kosten[i, j]) * x[i][j]
+                   for i in range(m) for j in range(n)))
+    aufbau = time.perf_counter() - t0
+    t0 = time.perf_counter(); s.Solve(); loesen = time.perf_counter() - t0
+    return s.Objective().Value(), aufbau, loesen, speicher_mb()
+
+
+def messe_cvxpy(m: int, n: int):
+    import cvxpy as cp
+    kosten, angebot, bedarf = instanz(m, n)
+    t0 = time.perf_counter()
+    x = cp.Variable((m, n), nonneg=True)
+    problem = cp.Problem(cp.Minimize(cp.sum(cp.multiply(kosten, x))),
+                         [cp.sum(x, axis=1) <= angebot,
+                          cp.sum(x, axis=0) == bedarf])
+    aufbau = time.perf_counter() - t0
+    t0 = time.perf_counter(); problem.solve(); loesen = time.perf_counter() - t0
+    return float(problem.value), aufbau, loesen, speicher_mb()
+
+
+ANSAETZE = {"scipy.linprog": messe_scipy, "highspy": messe_highspy,
+            "ortools/GLOP": messe_ortools, "cvxpy": messe_cvxpy}
+
+
+def messe(funktion, m: int, n: int):
+    """Fuehrt eine Messfunktion in einem FRISCHEN Prozess aus.
+
+    'spawn' und max_tasks_per_child=1 zusammen garantieren, was Regel 1
+    verlangt: Jede Messung sieht einen leeren Interpreter. Ohne das
+    zweite wuerde der Pool seinen Arbeiter wiederverwenden - dann waere
+    der Speicherwert der zweiten Bibliothek um die erste zu hoch, und
+    ortools und highspy saessen im selben Prozess.
+    """
+    with ProcessPoolExecutor(
+            max_workers=1,
+            mp_context=multiprocessing.get_context("spawn"),
+            max_tasks_per_child=1) as pool:
+        try:
+            return pool.submit(funktion, m, n).result(timeout=600), None
+        except Exception as fehler:
+            return None, str(fehler).strip().splitlines()[-1][:60]
 
 
 if __name__ == "__main__":
@@ -157,8 +168,8 @@ if __name__ == "__main__":
               f"{'Loesen':>9} {'Anteil':>8} {'Speicher':>10}")
         print("  " + "-" * 72)
         zielwerte = {}
-        for name, quelltext in ANSAETZE.items():
-            werte, fehler = messe(name, quelltext, m, n)
+        for name, funktion in ANSAETZE.items():
+            werte, fehler = messe(funktion, m, n)
             if werte is None:
                 print(f"  {name:<16} nicht verfuegbar: {fehler}")
                 continue
diff --git a/OR_HTML_04/programme/Constraint_Attribution.py b/OR_HTML_04/programme/Constraint_Attribution.py
new file mode 100644
index 0000000..c5a9ab7
--- /dev/null
+++ b/OR_HTML_04/programme/Constraint_Attribution.py
@@ -0,0 +1,305 @@
+#!/usr/bin/env python3
+
+# Constraint_Attribution.py
+"""
+Kapitel Praxisfallen: Welche Bedingung kostet wie viel - und was sagt man
+dem Management?
+
+Zwischen den beiden bekannten Faellen klafft eine Luecke:
+
+  * Erklaerbarkeit.py beantwortet "warum diese eine Zuweisung?"
+  * Konfliktsuche.py (Anhang Fehlerdiagnose) beantwortet "warum geht es gar
+    nicht?"
+
+Der haeufigste Fall in der Praxis liegt dazwischen: Das Modell rechnet, der
+Plan ist zulaessig - und trotzdem unbefriedigend. Niemand weiss, WORAN es
+liegt. Genau das beantwortet Constraint Attribution.
+
+Gerechnet wird auf derselben Fabrik wie in Konfliktsuche.py, nur nach der
+Reparatur: Dort war die Lackierkapazitaet von 150 Stunden der Kern des
+Widerspruchs (2*40 + 3*30 = 170 > 150). Eine zweite Schicht hat sie auf 210
+gebracht, und der Mindestumsatz wurde auf 10.000 EUR gesenkt. Jetzt ist das
+Modell loesbar - und die Frage lautet nicht mehr "warum nicht?", sondern
+"was kostet uns was?".
+
+Gezeigt werden vier Dinge:
+  1. Welche Bedingungen binden - und dass "bindend" nicht "teuer" heisst.
+  2. Dass der Schattenpreis eine MOMENTAUFNAHME ist: hochgerechnet auf eine
+     realistische Sonderschicht verspricht er hier das Doppelte des
+     tatsaechlichen Nutzens.
+  3. Dass ein Wunsch aus dem Vertrieb nicht teuer, sondern unmoeglich sein
+     kann - und welche Bedingungen ihn gemeinsam blockieren.
+  4. Wie aus alledem ein Bericht in Alltagssprache wird.
+
+Benoetigt: numpy, scipy
+"""
+
+from __future__ import annotations
+
+import textwrap
+
+import numpy as np
+from scipy.optimize import linprog
+
+PRODUKTE = ["Rahmen", "Gehaeuse", "Deckel", "Traeger", "Halter"]
+DECKUNGSBEITRAG = np.array([35.0, 28.0, 9.0, 22.0, 6.0])   # EUR je Stueck
+
+# Dieselben Bedingungen wie in Konfliktsuche.py, mit den beiden Reparaturen.
+# Der sprechende Name ist keine Kosmetik: Ohne ihn ist kein Bericht moeglich,
+# der jemandem ausserhalb der Modellierung etwas sagt.
+BEDINGUNGEN: list[tuple[str, list[float], str, float]] = [
+    ("Kapazitaet Montage",       [3, 2, 1, 4, 2],      "<=",   400),
+    ("Kapazitaet Lackieren",     [2, 3, 0, 1, 0],      "<=",   210),
+    ("Kapazitaet Pruefung",      [1, 1, 1, 1, 1],      "<=",   300),
+    ("Liefervertrag Rahmen",     [1, 0, 0, 0, 0],      ">=",    40),
+    ("Liefervertrag Gehaeuse",   [0, 1, 0, 0, 0],      ">=",    30),
+    ("Liefervertrag Deckel",     [0, 0, 1, 0, 0],      ">=",    20),
+    ("Liefervertrag Traeger",    [0, 0, 0, 1, 0],      ">=",    25),
+    ("Marktgrenze Rahmen",       [1, 0, 0, 0, 0],      "<=",   120),
+    ("Marktgrenze Gehaeuse",     [0, 1, 0, 0, 0],      "<=",    90),
+    ("Marktgrenze Deckel",       [0, 0, 1, 0, 0],      "<=",   150),
+    ("Marktgrenze Halter",       [0, 0, 0, 0, 1],      "<=",   200),
+    ("Mindestumsatz",            [90, 70, 30, 60, 20], ">=", 10000),
+    ("Sortimentsbreite",         [0, 0, 1, 1, 1],      ">=",   100),
+    ("Lackierbudget Schicht 2",  [0, 1, 0, 1, 0],      "<=",    55),
+]
+
+# Was liesse sich im Ernstfall wirklich bewegen - und um wie viel? Nicht "eine
+# Einheit", sondern der Schritt, den ein Planer tatsaechlich gehen kann: eine
+# Sonderschicht, ein nachverhandelter Vertrag. Genau an dieser Groesse
+# scheitert das blosse Hochrechnen des Schattenpreises.
+STELLSCHRAUBEN: dict[str, tuple[float, str]] = {
+    "Kapazitaet Montage":      (+50, "eine Sonderschicht Montage"),
+    "Kapazitaet Lackieren":    (+30, "eine Sonderschicht Lackieren"),
+    "Kapazitaet Pruefung":     (+50, "eine Sonderschicht Pruefung"),
+    "Lackierbudget Schicht 2": (+10, "10 Stunden mehr Budget in Schicht 2"),
+    "Liefervertrag Traeger":   (-10, "10 Stueck weniger Abnahmepflicht Traeger"),
+    "Liefervertrag Gehaeuse":  (-10, "10 Stueck weniger Abnahmepflicht Gehaeuse"),
+}
+
+WUNSCH_MENGE = 55.0      # der Vertrieb haette gern mehr Rahmen
+WUNSCH_PRODUKT = "Rahmen"
+
+
+def loese(bedingungen: list[tuple[str, list[float], str, float]]):
+    """Maximiert den Deckungsbeitrag. linprog minimiert, daher das Vorzeichen."""
+    matrix, rechte_seite = [], []
+    for _, koeffizienten, richtung, grenze in bedingungen:
+        zeile = np.array(koeffizienten, dtype=float)
+        matrix.append(zeile if richtung == "<=" else -zeile)
+        rechte_seite.append(grenze if richtung == "<=" else -grenze)
+    return linprog(-DECKUNGSBEITRAG,
+                   A_ub=np.array(matrix), b_ub=np.array(rechte_seite),
+                   bounds=[(0, None)] * len(PRODUKTE), method="highs")
+
+
+def geaendert(name: str, delta: float,
+              basis=None) -> list[tuple[str, list[float], str, float]]:
+    """Dieselben Bedingungen, eine davon um delta verschoben."""
+    return [(n, k, r, g + delta if n == name else g)
+            for n, k, r, g in (basis or BEDINGUNGEN)]
+
+
+def auswertung(ergebnis, bedingungen=None):
+    """Schlupf und Schattenpreis je Bedingung."""
+    x = ergebnis.x
+    dual = ergebnis.ineqlin.marginals
+    zeilen = []
+    for i, (name, koeff, richtung, grenze) in enumerate(bedingungen or BEDINGUNGEN):
+        links = float(np.array(koeff, dtype=float) @ x)
+        schlupf = (grenze - links) if richtung == "<=" else (links - grenze)
+        zeilen.append((name, links, richtung, grenze, schlupf, abs(dual[i])))
+    return zeilen
+
+
+def blockierer(bedingungen, zusatz) -> list[str]:
+    """Welche Bedingungen verhindern 'zusatz' - einzeln weggelassen.
+
+    Dasselbe Vorgehen wie der Deletion Filter in Konfliktsuche.py, nur mit
+    umgekehrtem Vorzeichen: Dort wird gesucht, was den Widerspruch AUSMACHT,
+    hier, was einen Wunsch VERHINDERT. Wird das Modell ohne eine Bedingung
+    loesbar, gehoert sie zum Konflikt.
+    """
+    gefunden = []
+    for i, (name, _, _, _) in enumerate(bedingungen):
+        rest = [c for j, c in enumerate(bedingungen) if j != i] + [zusatz]
+        if loese(rest).success:
+            gefunden.append(name)
+    return gefunden
+
+
+def euro(betrag: float) -> str:
+    return f"{betrag:,.2f} EUR"
+
+
+if __name__ == "__main__":
+    basis = loese(BEDINGUNGEN)
+    db_basis = -basis.fun
+    plan = dict(zip(PRODUKTE, basis.x))
+
+    print("=" * 78)
+    print("  CONSTRAINT ATTRIBUTION: Was kostet uns welche Bedingung?")
+    print("=" * 78)
+    print(f"Status: {basis.message.split('(')[0].strip()}")
+    print(f"Deckungsbeitrag des Plans: {euro(db_basis)}\n")
+    print("  " + "  ".join(f"{p}: {m:.1f}" for p, m in plan.items()))
+
+    # --- 1. Wer begrenzt den Plan? -----------------------------------------
+    print("\n" + "=" * 78)
+    print("  (1) Welche Bedingungen binden - und was kostet die naechste Einheit?")
+    print("=" * 78)
+    print(f"{'Bedingung':<24} {'genutzt':>9} {'Grenze':>7} {'Schlupf':>8} "
+          f"{'Schattenpreis':>11}")
+    print("-" * 78)
+    bindend = []
+    for name, links, richtung, grenze, schlupf, dual in auswertung(basis):
+        marke = ""
+        if abs(schlupf) < 1e-6:
+            bindend.append((name, dual))
+            marke = "  <-- bindend"
+        print(f"{name:<24} {links:>9.1f} {grenze:>7.0f} {schlupf:>8.1f} "
+              f"{dual:>11.2f}{marke}")
+
+    ohne_preis = [n for n, d in bindend if d < 1e-9]
+    print(f"\n  {len(bindend)} Bedingungen binden. Aber: "
+          f"{', '.join(ohne_preis)} bindet")
+    print("  mit einem Schattenpreis von 0,00 EUR - sie beruehrt den Plan, ohne ihn")
+    print("  zu verteuern. Bindend und kostenrelevant sind zwei verschiedene Dinge.")
+
+    # --- 2. Der Schattenpreis als Momentaufnahme ---------------------------
+    print("\n" + "=" * 78)
+    print("  (2) Was der Schattenpreis verschweigt")
+    print("=" * 78)
+    print("Der Schattenpreis gilt fuer die NAECHSTE Einheit. Ein Planer kauft aber")
+    print("keine Einheit, sondern eine ganze Schicht. Beides gegenuebergestellt:\n")
+    preise = {name: dual for name, *_, dual in auswertung(basis)}
+    print(f"{'Stellschraube':<24} {'Preis':>9} {'Schritt':>7} "
+          f"{'hochgerechnet':>13} {'gemessen':>9} {'Abw.':>9}")
+    print("-" * 78)
+    wirkung = {}
+    for name, (delta, _) in STELLSCHRAUBEN.items():
+        ergebnis = loese(geaendert(name, delta))
+        echt = (-ergebnis.fun) - db_basis if ergebnis.success else 0.0
+        linear = preise[name] * abs(delta)
+        wirkung[name] = echt
+        print(f"{name:<24} {preise[name]:>9.2f} {delta:>+7.0f} "
+              f"{linear:>13.2f} {echt:>9.2f} {echt - linear:>+9.2f}")
+
+    # Wo endet der Gueltigkeitsbereich? Schrittweise nachfahren.
+    abweichler = max(STELLSCHRAUBEN,
+                     key=lambda n: preise[n] * abs(STELLSCHRAUBEN[n][0]) - wirkung[n])
+    delta_max = STELLSCHRAUBEN[abweichler][0]
+    grenze_gueltig = 0.0
+    schritt = delta_max / 60.0
+    vorher = db_basis
+    for i in range(1, 61):
+        d = schritt * i
+        e = loese(geaendert(abweichler, d))
+        db = -e.fun if e.success else vorher
+        if db - vorher > 1e-9:
+            grenze_gueltig = d
+        vorher = db
+    print(f"\n  '{abweichler}': hochgerechnet "
+          f"{preise[abweichler] * abs(delta_max):.2f} EUR, tatsaechlich "
+          f"{wirkung[abweichler]:.2f} EUR.")
+    print(f"  Der Preis von {preise[abweichler]:.2f} EUR gilt nur bis "
+          f"+{grenze_gueltig:.0f} Stunden. Jede weitere Stunde")
+    print("  dieser Sonderschicht bringt exakt nichts - der Engpass ist dann ein anderer.")
+
+    nach_preis = sorted(STELLSCHRAUBEN, key=lambda n: -preise[n])[0]
+    nach_wirkung = max(wirkung, key=wirkung.get)
+    print(f"\n  Und die Ranglisten drehen sich: Nach Schattenpreis fuehrt")
+    print(f"  '{nach_preis}' ({preise[nach_preis]:.2f} EUR je Einheit),")
+    print(f"  nach tatsaechlicher Wirkung '{nach_wirkung}' "
+          f"({wirkung[nach_wirkung]:.2f} EUR).")
+    print("  Der Schattenpreis sagt, was eine Einheit wert ist - nicht, wie viele")
+    print("  Einheiten zu haben sind.")
+
+    # --- 3. Der Wunsch aus dem Vertrieb ------------------------------------
+    print("\n" + "=" * 78)
+    print(f"  (3) Was-waere-wenn: mindestens {WUNSCH_MENGE:.0f} "
+          f"{WUNSCH_PRODUKT} statt {plan[WUNSCH_PRODUKT]:.1f}")
+    print("=" * 78)
+    wunsch = (f"Wunsch Vertrieb {WUNSCH_PRODUKT}",
+              [1 if p == WUNSCH_PRODUKT else 0 for p in PRODUKTE], ">=", WUNSCH_MENGE)
+    mit_wunsch = loese(BEDINGUNGEN + [wunsch])
+    schuldige: list[str] = []
+    engpass = noetig = None
+    wunsch_gratis = False
+
+    if mit_wunsch.success:
+        print(f"Erfuellbar, kostet {euro(db_basis - (-mit_wunsch.fun))}.")
+    else:
+        schuldige = blockierer(BEDINGUNGEN, wunsch)
+        print("Der Wunsch ist nicht teuer - er ist UNMOEGLICH.\n")
+        print(f"Blockiert wird er von {len(schuldige)} Bedingungen gemeinsam. "
+              f"Faellt eine davon")
+        print("weg, ist er erfuellbar; keine allein ist 'der' Grund:")
+        for name in schuldige:
+            e = loese([c for c in BEDINGUNGEN if c[0] != name] + [wunsch])
+            print(f"   ohne '{name}': moeglich, Deckungsbeitrag {euro(-e.fun)}")
+
+        engpass = next((n for n in schuldige if n in STELLSCHRAUBEN), schuldige[0])
+        for schritt in range(1, 61):
+            if loese(geaendert(engpass, schritt) + [wunsch]).success:
+                noetig = schritt
+                break
+        if noetig is not None:
+            e = loese(geaendert(engpass, noetig) + [wunsch])
+            ohne = loese(geaendert(engpass, noetig))
+            wunsch_gratis = abs((-e.fun) - (-ohne.fun)) < 1e-6
+            print(f"\n   Mit +{noetig} bei '{engpass}' wird der Wunsch erfuellbar:")
+            print(f"   Deckungsbeitrag {euro(-e.fun)} "
+                  f"({-e.fun - db_basis:+,.2f} gegenueber heute).")
+            if wunsch_gratis:
+                print(f"   Und ohne den Wunsch ergaebe dieselbe Lockerung "
+                      f"{euro(-ohne.fun)} bei")
+                print(f"   {ohne.x[PRODUKTE.index(WUNSCH_PRODUKT)]:.0f} "
+                      f"{WUNSCH_PRODUKT} - der Wunsch kostet also NICHTS.")
+                print("   Er war nie das Problem. Der Engpass war es.")
+
+    # --- 4. Der Bericht ----------------------------------------------------
+    # Aus denselben Zahlen, die oben in Tabellen stehen, wird hier Prosa. Kein
+    # Satz enthaelt eine Zahl, die nicht vorher gerechnet wurde - das ist der
+    # ganze Trick und zugleich die Bedingung dafuer, dass der Bericht nicht
+    # irgendwann leise falsch wird.
+    print("\n" + "=" * 78)
+    print("  (4) Und so steht es in der Vorlage fuer die Abteilungsleiterrunde")
+    print("=" * 78)
+
+    teuerste = sorted(((n, d) for n, d in bindend if d > 0), key=lambda t: -t[1])
+    gross = STELLSCHRAUBEN[nach_wirkung][1]
+    klein = STELLSCHRAUBEN[abweichler][1]
+
+    absaetze = [
+        f"Der Plan bringt {euro(db_basis)} Deckungsbeitrag. Begrenzt wird er von "
+        f"{len(bindend)} Bedingungen, von denen {len(teuerste)} tatsaechlich Geld "
+        f"kosten; \"{ohne_preis[0]}\" beruehrt den Plan, ohne ihn zu verteuern.",
+
+        f"Teuerste Bindung ist \"{teuerste[0][0]}\" mit "
+        f"{teuerste[0][1]:.2f} EUR je Einheit, gefolgt von \"{teuerste[1][0]}\" "
+        f"mit {teuerste[1][1]:.2f} EUR.",
+
+        f"Die groesste einzelne Verbesserung bringt {gross}: "
+        f"{euro(wirkung[nach_wirkung])} mehr Deckungsbeitrag. {klein[0].upper()}{klein[1:]} "
+        f"dagegen bringt nur {euro(wirkung[abweichler])} statt der rechnerischen "
+        f"{euro(preise[abweichler] * abs(delta_max))} - ab +{grenze_gueltig:.0f} "
+        f"Stunden begrenzt uns etwas anderes. Wer die ganze Schicht bezahlt, "
+        f"bezahlt die zweite Haelfte umsonst.",
+    ]
+
+    if schuldige and noetig is not None:
+        namen = ", ".join(f'"{s}"' for s in schuldige)
+        satz = (f"Zum Wunsch des Vertriebs ({WUNSCH_MENGE:.0f} {WUNSCH_PRODUKT} statt "
+                f"{plan[WUNSCH_PRODUKT]:.1f}): Er ist mit der heutigen Ausstattung "
+                f"nicht erfuellbar - nicht aus Kostengruenden, sondern weil {namen} "
+                f"ihn gemeinsam blockieren. Mit +{noetig} Stunden bei "
+                f'"{engpass}" wird er moeglich')
+        satz += (", und er kostet dann nichts: Der Plan waehlt diese Menge von "
+                 "sich aus." if wunsch_gratis else ".")
+        absaetze.append(satz)
+
+    for absatz in absaetze:
+        print()
+        print(textwrap.fill(absatz, width=76))
+    print("\n" + "=" * 78)
diff --git a/OR_HTML_04/programme/Ein_System_Vier_Ansaetze.py b/OR_HTML_04/programme/Ein_System_Vier_Ansaetze.py
index cccb1c5..34bc3e2 100644
--- a/OR_HTML_04/programme/Ein_System_Vier_Ansaetze.py
+++ b/OR_HTML_04/programme/Ein_System_Vier_Ansaetze.py
@@ -8,85 +8,104 @@ Kapitel Oekosystem: Dasselbe LP in vier Bibliotheken.
           2*x1 + 3*x2 + x3 <= 50
           x >= 0
 
-Deckt scipy.optimize, highspy, CVXPY und OR-Tools/GLOP ab, mit Kreuzvergleich am Ende.
+Deckt scipy.optimize, highspy, CVXPY und OR-Tools/GLOP ab, mit Kreuzvergleich
+am Ende.
 
-WICHTIG: Jeder Solver läuft in einem EIGENEN Prozess, weil sich ortools und
+WICHTIG: Jeder Solver laeuft in einem EIGENEN Prozess, weil sich ortools und
 highspy auf vielen Systemen nicht gemeinsam importieren lassen (beide bringen
 eine eigene HiGHS-Kopie mit -> Symbolkonflikt).
+
+Die Isolation besorgt ein ProcessPoolExecutor. Drei Einstellungen ergeben
+zusammen die Garantie:
+
+  mp_context "spawn"     Der Kindprozess startet mit einem FRISCHEN
+                         Interpreter, statt den Speicher des Elternprozesses
+                         zu erben. Was hier schon importiert ist, ist dort
+                         nicht importiert. Mit dem Standard "fork" auf Linux
+                         waere das nicht so.
+  max_tasks_per_child=1  Jede Aufgabe bekommt einen NEUEN Prozess. Ohne das
+                         wuerde der Pool seinen Arbeiter wiederverwenden - und
+                         beim zweiten Solver waere der Konflikt zurueck.
+  max_workers=1          Haelt die vier Laeufe nacheinander. Nicht aus
+                         Vorsicht, sondern damit die gemessenen Zeiten
+                         vergleichbar bleiben.
+
+Jeder Solver steht in einer eigenen Funktion mit LOKALEM Import. Das ist der
+Unterschied zu einem Codestring, den man an 'python -c' uebergibt: Die
+Funktion laesst sich einzeln aufrufen, testen und vom Editor pruefen - ein
+String nicht.
+
+Benoetigt: scipy, highspy, cvxpy, ortools
 """
 
-import json
-import subprocess
-import sys
-import textwrap
+import multiprocessing
 import time
+from concurrent.futures import ProcessPoolExecutor
 
 ERWARTET = 530.0            # Ergebnis der Handrechnung zum Produktionsprogramm
 
-# Jeder Eintrag ist ein eigenständiges Miniprogramm, das sein Ergebnis als
-# JSON auf stdout ausgibt. So bleibt jeder Import in seinem eigenen Prozess.
-ANSAETZE: dict[str, str] = {
+# Die Instanz - einmal notiert, von allen vier Funktionen benutzt.
+ZIEL = [10.0, 15.0, 25.0]
+MATRIX = [[1, 1, 2], [2, 3, 1]]
+KAPAZITAET = [40.0, 50.0]
 
-    "scipy.optimize.linprog": """
-        from scipy.optimize import linprog
-        res = linprog(c=[-10.0, -15.0, -25.0],           # linprog MINIMIERT -> negieren
-                      A_ub=[[1, 1, 2], [2, 3, 1]], b_ub=[40, 50],
-                      bounds=[(0, None)] * 3, method="highs")
-        ausgabe = (-res.fun, list(res.x))
-    """,
 
-    "highspy (natives HiGHS)": """
-        import numpy as np, highspy
-        h = highspy.Highs()
-        h.setOptionValue("output_flag", False)
-        h.addVars(3, np.zeros(3), np.full(3, highspy.kHighsInf))
-        h.changeObjectiveSense(highspy.ObjSense.kMaximize)
-        for j, wert in enumerate([10.0, 15.0, 25.0]):
-            h.changeColCost(j, wert)
-        # CSR-Format: starts[i] = Beginn von Zeile i in indices/values
-        h.addRows(2, np.full(2, -highspy.kHighsInf), np.array([40.0, 50.0]), 6,
-                  np.array([0, 3], dtype=np.int32),
-                  np.array([0, 1, 2, 0, 1, 2], dtype=np.int32),
-                  np.array([1.0, 1.0, 2.0, 2.0, 3.0, 1.0]))
-        h.run()
-        ausgabe = (h.getInfo().objective_function_value,
-                   list(h.getSolution().col_value[:3]))
-    """,
+def loese_mit_scipy() -> tuple[float, list[float]]:
+    from scipy.optimize import linprog
+    ergebnis = linprog(c=[-w for w in ZIEL],          # linprog MINIMIERT -> negieren
+                       A_ub=MATRIX, b_ub=KAPAZITAET,
+                       bounds=[(0, None)] * 3, method="highs")
+    return -ergebnis.fun, list(ergebnis.x)
 
-    "cvxpy": """
-        import numpy as np, cvxpy as cp
-        x = cp.Variable(3, nonneg=True)
-        problem = cp.Problem(cp.Maximize(np.array([10.0, 15.0, 25.0]) @ x),
-                             [np.array([[1, 1, 2], [2, 3, 1]]) @ x <= np.array([40, 50])])
-        problem.solve()
-        ausgabe = (float(problem.value), [float(v) for v in x.value])
-    """,
 
-    "ortools / GLOP": """
-        from ortools.linear_solver import pywraplp
-        s = pywraplp.Solver.CreateSolver("GLOP")
-        x = [s.NumVar(0, s.infinity(), f"x{j+1}") for j in range(3)]
-        A = [[1, 1, 2], [2, 3, 1]]
-        for i, kap in enumerate([40, 50]):
-            s.Add(sum(A[i][j] * x[j] for j in range(3)) <= kap)
-        s.Maximize(10 * x[0] + 15 * x[1] + 25 * x[2])
-        s.Solve()
-        ausgabe = (s.Objective().Value(), [v.solution_value() for v in x])
-    """,
+def loese_mit_highspy() -> tuple[float, list[float]]:
+    import highspy
+    import numpy as np
+    h = highspy.Highs()
+    h.setOptionValue("output_flag", False)
+    h.addVars(3, np.zeros(3), np.full(3, highspy.kHighsInf))
+    h.changeObjectiveSense(highspy.ObjSense.kMaximize)
+    for j, wert in enumerate(ZIEL):
+        h.changeColCost(j, wert)
+    # CSR-Format: starts[i] = Beginn von Zeile i in indices/values
+    h.addRows(2, np.full(2, -highspy.kHighsInf), np.array(KAPAZITAET), 6,
+              np.array([0, 3], dtype=np.int32),
+              np.array([0, 1, 2, 0, 1, 2], dtype=np.int32),
+              np.array([float(w) for zeile in MATRIX for w in zeile]))
+    h.run()
+    return (h.getInfo().objective_function_value,
+            list(h.getSolution().col_value[:3]))
+
+
+def loese_mit_cvxpy() -> tuple[float, list[float]]:
+    import cvxpy as cp
+    import numpy as np
+    x = cp.Variable(3, nonneg=True)
+    problem = cp.Problem(cp.Maximize(np.array(ZIEL) @ x),
+                         [np.array(MATRIX) @ x <= np.array(KAPAZITAET)])
+    problem.solve()
+    return float(problem.value), [float(v) for v in x.value]
+
+
+def loese_mit_ortools() -> tuple[float, list[float]]:
+    from ortools.linear_solver import pywraplp
+    s = pywraplp.Solver.CreateSolver("GLOP")
+    x = [s.NumVar(0, s.infinity(), f"x{j+1}") for j in range(3)]
+    for i, kapazitaet in enumerate(KAPAZITAET):
+        s.Add(sum(MATRIX[i][j] * x[j] for j in range(3)) <= kapazitaet)
+    s.Maximize(sum(ZIEL[j] * x[j] for j in range(3)))
+    s.Solve()
+    return s.Objective().Value(), [v.solution_value() for v in x]
+
+
+ANSAETZE = {
+    "scipy.optimize.linprog": loese_mit_scipy,
+    "highspy (natives HiGHS)": loese_mit_highspy,
+    "cvxpy": loese_mit_cvxpy,
+    "ortools / GLOP": loese_mit_ortools,
 }
 
 
-def fuehre_in_eigenem_prozess_aus(quelltext: str) -> tuple[float, list[float]]:
-    """Startet den Codeschnipsel als separaten Python-Prozess und liest das Ergebnis."""
-    programm = textwrap.dedent(quelltext) + "\nimport json; print(json.dumps(ausgabe))\n"
-    ergebnis = subprocess.run([sys.executable, "-c", programm],
-                              capture_output=True, text=True, timeout=120)
-    if ergebnis.returncode != 0:
-        raise RuntimeError(ergebnis.stderr.strip().splitlines()[-1])
-    wert, loesung = json.loads(ergebnis.stdout.strip().splitlines()[-1])
-    return wert, loesung
-
-
 if __name__ == "__main__":
     print("=" * 78)
     print("  EIN SYSTEM - VIER ANSAETZE (je eigener Prozess)")
@@ -95,17 +114,23 @@ if __name__ == "__main__":
     print("-" * 78)
 
     werte = []
-    for name, quelltext in ANSAETZE.items():
-        t0 = time.perf_counter()
-        try:
-            wert, x = fuehre_in_eigenem_prozess_aus(quelltext)
-        except RuntimeError as fehler:
-            print(f"{name:<26} nicht verfuegbar: {fehler[:40]}")
-            continue
-        dauer = time.perf_counter() - t0
-        werte.append(wert)
-        print(f"{name:<26} {wert:>10.2f} {x[0]:>7.2f} {x[1]:>7.2f} {x[2]:>7.2f} "
-              f"{dauer:>8.2f} s")
+    # Ein Pool, vier Aufgaben, vier frische Prozesse. Der Kontext muss
+    # "spawn" sein - siehe Modulkommentar.
+    with ProcessPoolExecutor(
+            max_workers=1,
+            mp_context=multiprocessing.get_context("spawn"),
+            max_tasks_per_child=1) as pool:
+        for name, funktion in ANSAETZE.items():
+            beginn = time.perf_counter()
+            try:
+                wert, x = pool.submit(funktion).result(timeout=120)
+            except Exception as fehler:                     # Bibliothek fehlt o. Ae.
+                print(f"{name:<26} nicht verfuegbar: {str(fehler)[:40]}")
+                continue
+            dauer = time.perf_counter() - beginn
+            werte.append(wert)
+            print(f"{name:<26} {wert:>10.2f} {x[0]:>7.2f} {x[1]:>7.2f} {x[2]:>7.2f} "
+                  f"{dauer:>8.2f} s")
 
     print("-" * 78)
     spanne = max(werte) - min(werte)
@@ -115,6 +140,6 @@ if __name__ == "__main__":
     assert spanne < 1e-6, "Die Bibliotheken widersprechen sich!"
     assert abs(werte[0] - ERWARTET) < 1e-6, "Ergebnis weicht von der Handrechnung ab!"
     print("Alle Wege fuehren zum selben, von Hand bestaetigten Optimum.")
-    print("(Die Zeiten enthalten den Prozessstart und den Import - sie messen")
-    print(" NICHT die reine Solverleistung, siehe Uebung 3.5.)")
+    print("(Die Zeiten enthalten Prozessstart und Import - sie messen NICHT die")
+    print(" reine Solverleistung. Die Uebungsaufgabe 'Laufzeitvergleich' trennt beides.)")
     print("=" * 78)
diff --git a/OR_HTML_04/programme/Kovarianz_Falle.py b/OR_HTML_04/programme/Kovarianz_Falle.py
index 7f5bbb1..8cb4af9 100644
--- a/OR_HTML_04/programme/Kovarianz_Falle.py
+++ b/OR_HTML_04/programme/Kovarianz_Falle.py
@@ -55,7 +55,8 @@ def minimales_risiko(kovarianz: np.ndarray) -> tuple[np.ndarray, float]:
     exakt positiv semidefinit ist - rechne trotzdem.' Das ist hier bewusst so
     gewaehlt, denn genau diese Eigenschaft wollen wir vorfuehren. Im
     Produktivbetrieb waere die DCP-Fehlermeldung das Warnsignal, dem man
-    nachgehen muss (siehe Denkfehler 8.1).
+    nachgehen muss (siehe den Denkfehler im Kapitel Quadratische und
+    nichtlineare Optimierung).
     """
     gewichte = cp.Variable(ANZAHL_ANLAGEN)
     problem = cp.Problem(cp.Minimize(cp.quad_form(gewichte, cp.psd_wrap(kovarianz))),
diff --git a/OR_HTML_04/programme/Parallele_Suche.py b/OR_HTML_04/programme/Parallele_Suche.py
new file mode 100644
index 0000000..a23ed10
--- /dev/null
+++ b/OR_HTML_04/programme/Parallele_Suche.py
@@ -0,0 +1,195 @@
+#!/usr/bin/env python3
+
+# Parallele_Suche.py
+"""
+Kapitel CP-SAT: Was mehrere Arbeiter wirklich bringen - und was sie kosten.
+
+Das Buch setzt an mehreren Stellen 'num_workers = 1', damit die abgedruckte
+Ausgabe reproduzierbar ist. Behauptet wird dabei zweierlei: dass parallele
+Suche schneller ist, und dass sie von Lauf zu Lauf verschiedene, gleich gute
+Loesungen findet. Beides wird hier gemessen statt geglaubt.
+
+Gerechnet wird auf einem Job-Shop wie in JobShop_Intervalle.py, nur gross
+genug, dass die Suche wirklich arbeitet: 12 Auftraege auf 10 Maschinen,
+jeder Auftrag besucht jede Maschine.
+
+Zwei Messungen:
+  1. Dieselbe Aufgabe mit 1, 2, 4 und 8 Arbeitern - Laufzeit und Ergebnis.
+  2. Dieselbe Konfiguration mehrfach, bei FESTEM random_seed - wie oft kommt
+     derselbe Plan heraus?
+
+Die zweite ist die wichtigere: Sie entscheidet, wie man Tests schreibt.
+
+Achtung, Laufzeiten sind hardwareabhaengig. Die ZAHL der verschiedenen
+Plaene ist es auch - und genau das ist die Aussage.
+
+Benoetigt: numpy, ortools
+"""
+
+from __future__ import annotations
+
+import collections
+import time
+
+import numpy as np
+from ortools.sat.python import cp_model
+
+AUFTRAEGE = 12
+MASCHINEN = 10
+INSTANZ_SEED = 20260908
+SOLVER_SEED = 1          # bleibt ueber ALLE Laeufe gleich - das ist der Punkt
+ARBEITERZAHLEN = (1, 2, 4, 8)
+WIEDERHOLUNGEN = 4
+ZEITLIMIT = 120.0
+
+
+def baue_instanz() -> list[list[tuple[int, int]]]:
+    """Klassischer Job-Shop: Jeder Auftrag besucht jede Maschine genau einmal,
+    in einer eigenen zufaelligen Reihenfolge."""
+    rng = np.random.default_rng(INSTANZ_SEED)
+    return [[(int(m), int(rng.integers(2, 20))) for m in rng.permutation(MASCHINEN)]
+            for _ in range(AUFTRAEGE)]
+
+
+def loese(auftraege, arbeiter: int):
+    """Minimiert den Makespan. Gibt Status, Zielwert, Laufzeit und den Plan
+    zurueck - den Plan als Tupel aller Startzeiten, damit sich zwei Laeufe
+    vergleichen lassen."""
+    horizont = sum(dauer for auftrag in auftraege for _, dauer in auftrag)
+    modell = cp_model.CpModel()
+    Gang = collections.namedtuple("Gang", "start ende intervall")
+    plaene: dict[tuple[int, int], Gang] = {}
+    je_maschine = collections.defaultdict(list)
+
+    for a, auftrag in enumerate(auftraege):
+        for g, (maschine, dauer) in enumerate(auftrag):
+            start = modell.NewIntVar(0, horizont, f"start_{a}_{g}")
+            ende = modell.NewIntVar(0, horizont, f"ende_{a}_{g}")
+            intervall = modell.NewIntervalVar(start, dauer, ende, f"iv_{a}_{g}")
+            plaene[a, g] = Gang(start, ende, intervall)
+            je_maschine[maschine].append(intervall)
+
+    for maschine in range(MASCHINEN):
+        modell.AddNoOverlap(je_maschine[maschine])
+    for a, auftrag in enumerate(auftraege):
+        for g in range(len(auftrag) - 1):
+            modell.Add(plaene[a, g + 1].start >= plaene[a, g].ende)
+
+    makespan = modell.NewIntVar(0, horizont, "makespan")
+    modell.AddMaxEquality(
+        makespan, [plaene[a, len(auftrag) - 1].ende
+                   for a, auftrag in enumerate(auftraege)])
+    modell.Minimize(makespan)
+
+    loeser = cp_model.CpSolver()
+    loeser.parameters.num_workers = arbeiter
+    loeser.parameters.random_seed = SOLVER_SEED
+    loeser.parameters.max_time_in_seconds = ZEITLIMIT
+
+    beginn = time.perf_counter()
+    status = loeser.Solve(modell)
+    dauer = time.perf_counter() - beginn
+
+    if status not in (cp_model.OPTIMAL, cp_model.FEASIBLE):
+        return loeser.StatusName(status), None, dauer, None
+    plan = tuple(loeser.Value(plaene[a, g].start)
+                 for a, auftrag in enumerate(auftraege)
+                 for g in range(len(auftrag)))
+    return loeser.StatusName(status), int(loeser.ObjectiveValue()), dauer, plan
+
+
+if __name__ == "__main__":
+    auftraege = baue_instanz()
+    gaenge = sum(len(a) for a in auftraege)
+
+    print("=" * 78)
+    print("  WAS MEHRERE ARBEITER WIRKLICH BRINGEN")
+    print("=" * 78)
+    print(f"Job-Shop: {AUFTRAEGE} Auftraege, {MASCHINEN} Maschinen, "
+          f"{gaenge} Arbeitsgaenge.")
+    print(f"random_seed = {SOLVER_SEED} in JEDEM Lauf, "
+          f"{WIEDERHOLUNGEN} Wiederholungen je Arbeiterzahl.\n")
+
+    # Jede Konfiguration mehrfach - ein einzelner Zeitwert sagt nichts.
+    ergebnisse: dict[int, list[tuple]] = {}
+    for arbeiter in ARBEITERZAHLEN:
+        ergebnisse[arbeiter] = [loese(auftraege, arbeiter)
+                                for _ in range(WIEDERHOLUNGEN)]
+
+    print("=" * 78)
+    print("  (1) Laufzeit: was die Arbeiter bringen")
+    print("=" * 78)
+    print(f"{'Arbeiter':>9} {'Status':>9} {'Makespan':>9} "
+          f"{'schnellste':>11} {'langsamste':>11} {'Beschleunigung':>15}")
+    print("-" * 78)
+    basis_zeit = min(d for _, _, d, _ in ergebnisse[1])
+    for arbeiter in ARBEITERZAHLEN:
+        laeufe = ergebnisse[arbeiter]
+        zeiten = [d for _, _, d, _ in laeufe]
+        ziele = {o for _, o, _, _ in laeufe}
+        status = {s for s, _, _, _ in laeufe}
+        print(f"{arbeiter:>9} {'/'.join(sorted(status)):>9} "
+              f"{'/'.join(str(z) for z in sorted(ziele)):>9} "
+              f"{min(zeiten):>10.2f}s {max(zeiten):>10.2f}s "
+              f"{basis_zeit / min(zeiten):>14.1f}x")
+
+    beste = min(ARBEITERZAHLEN, key=lambda w: min(d for _, _, d, _ in ergebnisse[w]))
+    faktor = basis_zeit / min(d for _, _, d, _ in ergebnisse[beste])
+    print(f"\n  Am schnellsten sind {beste} Arbeiter: Faktor {faktor:.1f} gegenueber")
+    print(f"  einem einzigen - also MEHR, als {beste} Kerne hergeben sollten.")
+    print(f"  Das ist kein Messfehler. CP-SAT laesst nicht {beste}-mal dieselbe Suche")
+    print("  laufen, sondern verschiedene Strategien nebeneinander, die einander")
+    print("  ihre Schranken zurufen. Der zweite Arbeiter ist deshalb nicht der")
+    print("  'zweite Kern', sondern ein anderes Verfahren.")
+    letzte = ARBEITERZAHLEN[-1]
+    if beste != letzte:
+        zeit_letzte = min(d for _, _, d, _ in ergebnisse[letzte])
+        print(f"\n  Und mehr ist nicht immer besser: {letzte} Arbeiter brauchen "
+              f"{zeit_letzte:.2f}s")
+        print(f"  gegenueber {min(d for _, _, d, _ in ergebnisse[beste]):.2f}s bei "
+              f"{beste}. Ab einer gewissen Zahl kosten Abstimmung")
+        print("  und Speicherbandbreite mehr, als ein weiterer Suchstrang einbringt.")
+
+    print("\n" + "=" * 78)
+    print("  (2) Reproduzierbarkeit: derselbe Seed, derselbe Plan?")
+    print("=" * 78)
+    print(f"{'Arbeiter':>9} {'Laeufe':>7} {'verschiedene Plaene':>21} "
+          f"{'Makespan':>10}")
+    print("-" * 78)
+    for arbeiter in ARBEITERZAHLEN:
+        plaene = {p for _, _, _, p in ergebnisse[arbeiter] if p is not None}
+        ziele = {o for _, o, _, _ in ergebnisse[arbeiter]}
+        print(f"{arbeiter:>9} {WIEDERHOLUNGEN:>7} {len(plaene):>21} "
+              f"{'/'.join(str(z) for z in sorted(ziele)):>10}")
+
+    einer = len({p for _, _, _, p in ergebnisse[1]})
+    # Ab welcher Arbeiterzahl bricht die Reproduzierbarkeit? Das ist die
+    # eigentliche Zahl - nicht, was acht Arbeiter anrichten.
+    ab = next((w for w in ARBEITERZAHLEN
+               if len({p for _, _, _, p in ergebnisse[w]}) > 1), None)
+    print(f"\n  Mit einem Arbeiter: {einer} Plan aus {WIEDERHOLUNGEN} Laeufen.")
+    if ab is not None:
+        viele = len({p for _, _, _, p in ergebnisse[ab]})
+        print(f"  Schon mit {ab} Arbeitern: {viele} verschiedene Plaene aus "
+              f"{WIEDERHOLUNGEN} Laeufen -")
+        print("  bei identischem random_seed und identischem Zielwert.")
+        print(f"  Es braucht also keine acht Arbeiter, um die Reproduzierbarkeit")
+        print(f"  zu verlieren. {ab} genuegen.")
+    print("\n  Der Seed allein macht einen Lauf also NICHT reproduzierbar. Er legt")
+    print("  fest, wie ein einzelner Suchstrang wuerfelt - nicht, welcher von")
+    print("  mehreren zuerst fertig wird. Das entscheidet die Uhr.")
+
+    print("\n" + "=" * 78)
+    print("  (3) Was daraus fuer Tests folgt")
+    print("=" * 78)
+    print("  Ein Test der Form  assert plan == erwarteter_plan  besteht mal und")
+    print("  scheitert mal, ohne dass sich am Code etwas geaendert haette.")
+    print("  Zu pruefen sind stattdessen:")
+    print("    * der ZIELWERT (hier in allen Laeufen gleich),")
+    print("    * die Einhaltung aller Regeln (Abnahmepruefung, Kapitel Praxisfallen),")
+    print("    * und der Status - nicht die Gestalt der Loesung.")
+    print("\n  Wer doch einen bestimmten Plan braucht - fuer eine abgedruckte")
+    print("  Ausgabe, fuer einen Regressionstest -, setzt num_workers = 1.")
+    print(f"  Das kostet hier den Faktor {faktor:.1f} an Laufzeit und ist genau")
+    print("  deshalb eine Entscheidung fuer den Test, nicht fuer den Betrieb.")
+    print("=" * 78)
diff --git a/OR_HTML_04/programme/Solverwechsel_CPSAT_HiGHS.py b/OR_HTML_04/programme/Solverwechsel_CPSAT_HiGHS.py
index 0738ddf..7a294ae 100644
--- a/OR_HTML_04/programme/Solverwechsel_CPSAT_HiGHS.py
+++ b/OR_HTML_04/programme/Solverwechsel_CPSAT_HiGHS.py
@@ -36,9 +36,9 @@ Benoetigt: numpy, pydantic, ortools, highspy (jeweils im eigenen Prozess)
 
 from __future__ import annotations
 
-import subprocess
-import sys
+import multiprocessing
 import time
+from concurrent.futures import ProcessPoolExecutor
 
 import numpy as np
 from pydantic import BaseModel, Field, model_validator
@@ -241,25 +241,29 @@ def geoeffnete_lager(problem: Standortproblem, loesung: Loesung) -> list[str]:
             if any(loesung.werte[problem.schluessel(i, j)] > 0.5 for j in range(m))]
 
 
-def loese_in_eigenem_prozess(name: str) -> Loesung:
-    """Startet dieses Programm noch einmal - mit genau einem Solverimport."""
-    ergebnis = subprocess.run([sys.executable, __file__, name],
-                              capture_output=True, text=True, timeout=300)
-    if ergebnis.returncode != 0:
-        raise RuntimeError(ergebnis.stderr.strip().splitlines()[-1])
-    # Das DTO als JSON - genau dafuer ist ein Datenobjekt ohne Solverbezug gut.
-    return Loesung.model_validate_json(ergebnis.stdout.strip().splitlines()[-1])
+def loese_in_eigenem_prozess(name: str, problem: Standortproblem) -> Loesung:
+    """Laesst genau einen Modellbauer in einem frischen Prozess rechnen.
+
+    'spawn' statt des Linux-Standards 'fork': Der Kindprozess startet mit
+    einem leeren Interpreter und importiert nur den Solver, den SEIN
+    Modellbauer braucht. max_tasks_per_child=1 sorgt dafuer, dass der Pool
+    seinen Arbeiter nicht wiederverwendet - sonst saessen beim zweiten Aufruf
+    wieder beide Bibliotheken im selben Prozess.
+
+    Hin und zurueck wandert das Domaenenmodell bzw. das Loesungs-DTO. Beide
+    kennen keinen Solver, sind also serialisierbar - genau dafuer sind sie da.
+    """
+    with ProcessPoolExecutor(
+            max_workers=1,
+            mp_context=multiprocessing.get_context("spawn"),
+            max_tasks_per_child=1) as pool:
+        return pool.submit(MODELLBAUER[name], problem).result(timeout=300)
 
 
 if __name__ == "__main__":
     problem = beispielproblem()
 
-    # --- Kindprozess: rechnen und das DTO als JSON ausgeben ---------------
-    if len(sys.argv) > 1:
-        print(MODELLBAUER[sys.argv[1]](problem).model_dump_json())
-        sys.exit(0)
-
-    # --- Hauptprozess: beide Solver anstossen und vergleichen -------------
+    # --- Beide Solver anstossen und vergleichen ---------------------------
     print("=" * 82)
     print("  DERSELBE FALL, ZWEI SOLVER - UND EIN AUSWERTUNGSCODE")
     print("=" * 82)
@@ -271,7 +275,7 @@ if __name__ == "__main__":
     loesungen: dict[str, Loesung] = {}
     for name, beschriftung in [("cpsat", "OR-Tools CP-SAT"),
                                ("highs", "HiGHS (highspy)")]:
-        loesung = loesungen[name] = loese_in_eigenem_prozess(name)
+        loesung = loesungen[name] = loese_in_eigenem_prozess(name, problem)
         beanstandungen = pruefe_zuordnung(problem, loesung)
 
         print(f"{beschriftung}")
diff --git a/OR_HTML_04/programme/Warmstart_Effekt.py b/OR_HTML_04/programme/Warmstart_Effekt.py
index ca1d586..6c08303 100644
--- a/OR_HTML_04/programme/Warmstart_Effekt.py
+++ b/OR_HTML_04/programme/Warmstart_Effekt.py
@@ -83,7 +83,8 @@ def loese(dauer: np.ndarray, n_maschinen: int, zeitlimit: float,
 
     loeser = cp_model.CpSolver()
     loeser.parameters.max_time_in_seconds = zeitlimit
-    # Ein Arbeiter und fester Startwert, damit die Messung reproduzierbar ist.
+    # Ein Arbeiter und fester Startwert, damit die Messung reproduzierbar ist -
+    # der Seed allein genuegt dafuer NICHT (Kapitel Constraint Programming).
     # Im Produktivbetrieb laesst man beides auf den Standardwerten.
     loeser.parameters.num_workers = 1
     loeser.parameters.random_seed = 1
diff --git a/OR_HTML_04/projektwerkstatt.html b/OR_HTML_04/projektwerkstatt.html
index b5dc034..0b86d50 100644
--- a/OR_HTML_04/projektwerkstatt.html
+++ b/OR_HTML_04/projektwerkstatt.html
@@ -94,10 +94,10 @@
 </header>
 <div class="site-body">
   <div class="sidebar-overlay" id="sidebar-overlay" hidden></div>
-  <nav class="sidebar" id="sidebar" aria-label="Kapitelnavigation"><div class="sidebar-inhalt"><details class="sidebar-gruppe"><summary>Einstieg</summary><ul><li data-kapitel="vorwort.html"><a href="vorwort.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Vorwort & Lesehilfe</span></a></li><li data-kapitel="notation.html"><a href="notation.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Notation & Abkürzungen</span></a></li></ul></details><details class="sidebar-gruppe"><summary>Teil I: Grundlagen des Operations Research</summary><ul><li data-kapitel="einfuehrung.html"><a href="einfuehrung.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 1: Einführung in Operations Research — Vom Ursprung zur mathematischen Entscheidungsfindung</span></a></li><li data-kapitel="fundament.html"><a href="fundament.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 2: Das mathematische Fundament — Vektoren, Matrizen, Konvexität</span></a></li><li data-kapitel="oekosystem.html"><a href="oekosystem.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 3: Das Python-Ökosystem für OR — Solver, Bindings und Modellierungsschichten</span></a></li><li data-kapitel="modellierung.html"><a href="modellierung.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 4: Vom Management-Wunsch zum Modell</span></a></li></ul></details><details class="sidebar-gruppe"><summary>Teil II: Die Kernverfahren der deterministischen Optimierung</summary><ul><li data-kapitel="lp.html"><a href="lp.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 5: Lineare Programmierung — Simplex, Dualität und Schattenpreise</span></a></li><li data-kapitel="milp.html"><a href="milp.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 6: Gemischt-ganzzahlige Optimierung — Diskrete Entscheidungen und Branch-and-Bound</span></a></li><li data-kapitel="cpsat.html"><a href="cpsat.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 7: Constraint Programming mit CP-SAT — Logik, Scheduling und Zuweisung</span></a></li><li data-kapitel="graphen.html"><a href="graphen.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 8: Graphen, Flüsse und Touren — Min-Cost-Flow, Matching und VRP</span></a></li><li data-kapitel="metaheuristiken.html"><a href="metaheuristiken.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 9: Metaheuristiken — wenn der exakte Solver aussteigt</span></a></li><li data-kapitel="dekomposition.html"><a href="dekomposition.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 10: Spaltengenerierung — das Modell umbauen statt die Lösung raten</span></a></li></ul></details><details class="sidebar-gruppe"><summary>Teil III: Nichtlinearität, Unsicherheit und mehrperiodige Dynamik</summary><ul><li data-kapitel="qp-nlp.html"><a href="qp-nlp.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 11: Quadratische und nichtlineare Optimierung — KKT, Lagrange, Konvexität</span></a></li><li data-kapitel="unsicherheit.html"><a href="unsicherheit.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 12: Optimierung unter Unsicherheit — Monte-Carlo, Stochastik, Robustheit</span></a></li><li data-kapitel="dynamische-programmierung.html"><a href="dynamische-programmierung.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 13: Dynamische Programmierung — Die Bellman-Gleichung und Order-Execution</span></a></li><li data-kapitel="mehrziel.html"><a href="mehrziel.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 14: Mehrere Ziele — Pareto-Fronten statt Gewichte</span></a></li><li data-kapitel="prognose.html"><a href="prognose.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 15: Predict-then-Optimize — die bessere Prognose, die schlechtere Entscheidung</span></a></li></ul></details><details class="sidebar-gruppe"><summary>Teil IV: Anwendungen — Energiewirtschaft und Finanzmärkte</summary><ul><li data-kapitel="bruecke.html"><a href="bruecke.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 16: Die Strukturbrücke — dieselbe Mathematik, zwei Welten</span></a></li><li data-kapitel="supplychain.html"><a href="supplychain.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 17: Supply-Chain und Energieeinsatz unter Unsicherheit</span></a></li><li data-kapitel="finanzdaten.html"><a href="finanzdaten.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 18: Finanzdaten-Modellierung — Renditen, Kovarianz und Shrinkage</span></a></li><li data-kapitel="markowitz.html"><a href="markowitz.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 19: Die moderne Portfoliotheorie nach Markowitz</span></a></li><li data-kapitel="cvar.html"><a href="cvar.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 20: Tail-Risiko, CVaR und Transaktionskosten</span></a></li><li data-kapitel="handelsmaschine.html"><a href="handelsmaschine.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 21: Die vollständige quantitative Handelsmaschine</span></a></li></ul></details><details class="sidebar-gruppe" open><summary>Teil V: Praxis</summary><ul><li data-kapitel="praxisfallen.html"><a href="praxisfallen.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 22: Praxisfallen und der Weg zum produktiven Einsatz</span></a></li><li data-kapitel="testing.html"><a href="testing.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 23: Testen, Messen, Ausliefern</span></a></li><li data-kapitel="projektwerkstatt.html" class="aktiv"><a href="projektwerkstatt.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Projektwerkstatt</span></a></li></ul></details><details class="sidebar-gruppe"><summary>Anhänge</summary><ul><li data-kapitel="anhang-loesungen.html"><a href="anhang-loesungen.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Anhang A: Lösungen zu allen Übungsaufgaben</span></a></li><li data-kapitel="anhang-modellierungsmuster.html"><a href="anhang-modellierungsmuster.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Anhang B: Katalog der Modellierungsmuster</span></a></li><li data-kapitel="anhang-fehlerdiagnose.html"><a href="anhang-fehlerdiagnose.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Anhang C: Fehlerdiagnose-Handbuch</span></a></li><li data-kapitel="anhang-spickzettel.html"><a href="anhang-spickzettel.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Anhang D: Spickzettel der Solver</span></a></li><li data-kapitel="anhang-glossar-literatur.html"><a href="anhang-glossar-literatur.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Anhang E: Glossar und Literatur</span></a></li></ul></details><ul class="sidebar-extra"><li><a href="programme.html"><svg class="icon" aria-hidden="true"><use href="#icon-book"></use></svg> Beispielprogramme</a></li><li><a href="stichwortverzeichnis.html"><svg class="icon" aria-hidden="true"><use href="#icon-search"></use></svg> Stichwortverzeichnis</a></li><li><a href="gesamtdokument.html"><svg class="icon" aria-hidden="true"><use href="#icon-external-link"></use></svg> Gesamtdokument (eine Seite)</a></li><li><a href="Operations_Research_mit_Python_Version_04.pdf" download><svg class="icon" aria-hidden="true"><use href="#icon-download"></use></svg> Download als PDF</a></li></ul></div></nav>
+  <nav class="sidebar" id="sidebar" aria-label="Kapitelnavigation"><div class="sidebar-inhalt"><details class="sidebar-gruppe"><summary>Einstieg</summary><ul><li data-kapitel="vorwort.html"><a href="vorwort.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Vorwort & Lesehilfe</span></a></li><li data-kapitel="notation.html"><a href="notation.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Notation & Abkürzungen</span></a></li></ul></details><details class="sidebar-gruppe"><summary>Teil I: Grundlagen des Operations Research</summary><ul><li data-kapitel="einfuehrung.html"><a href="einfuehrung.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 1: Einführung in Operations Research — Vom Ursprung zur mathematischen Entscheidungsfindung</span></a></li><li data-kapitel="fundament.html"><a href="fundament.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 2: Das mathematische Fundament — Vektoren, Matrizen, Konvexität</span></a></li><li data-kapitel="oekosystem.html"><a href="oekosystem.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 3: Das Python-Ökosystem für OR — Solver, Bindings und Modellierungsschichten</span></a></li><li data-kapitel="modellierung.html"><a href="modellierung.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 4: Vom Management-Wunsch zum Modell</span></a></li><li data-kapitel="synthese-grundlagen.html"><a href="synthese-grundlagen.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Synthese Teil I</span></a></li></ul></details><details class="sidebar-gruppe"><summary>Teil II: Die Kernverfahren der deterministischen Optimierung</summary><ul><li data-kapitel="lp.html"><a href="lp.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 5: Lineare Programmierung — Simplex, Dualität und Schattenpreise</span></a></li><li data-kapitel="milp.html"><a href="milp.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 6: Gemischt-ganzzahlige Optimierung — Diskrete Entscheidungen und Branch-and-Bound</span></a></li><li data-kapitel="cpsat.html"><a href="cpsat.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 7: Constraint Programming mit CP-SAT — Logik, Scheduling und Zuweisung</span></a></li><li data-kapitel="graphen.html"><a href="graphen.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 8: Graphen, Flüsse und Touren — Min-Cost-Flow, Matching und VRP</span></a></li><li data-kapitel="metaheuristiken.html"><a href="metaheuristiken.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 9: Metaheuristiken — wenn der exakte Solver aussteigt</span></a></li><li data-kapitel="dekomposition.html"><a href="dekomposition.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 10: Spaltengenerierung — das Modell umbauen statt die Lösung raten</span></a></li><li data-kapitel="synthese-kernverfahren.html"><a href="synthese-kernverfahren.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Synthese Teil II</span></a></li></ul></details><details class="sidebar-gruppe"><summary>Teil III: Nichtlinearität, Unsicherheit und mehrperiodige Dynamik</summary><ul><li data-kapitel="qp-nlp.html"><a href="qp-nlp.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 11: Quadratische und nichtlineare Optimierung — KKT, Lagrange, Konvexität</span></a></li><li data-kapitel="unsicherheit.html"><a href="unsicherheit.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 12: Optimierung unter Unsicherheit — Monte-Carlo, Stochastik, Robustheit</span></a></li><li data-kapitel="dynamische-programmierung.html"><a href="dynamische-programmierung.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 13: Dynamische Programmierung — Die Bellman-Gleichung und Order-Execution</span></a></li><li data-kapitel="mehrziel.html"><a href="mehrziel.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 14: Mehrere Ziele — Pareto-Fronten statt Gewichte</span></a></li><li data-kapitel="prognose.html"><a href="prognose.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 15: Predict-then-Optimize — die bessere Prognose, die schlechtere Entscheidung</span></a></li><li data-kapitel="synthese-nichtlinear.html"><a href="synthese-nichtlinear.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Synthese Teil III</span></a></li></ul></details><details class="sidebar-gruppe"><summary>Teil IV: Anwendungen — Energiewirtschaft und Finanzmärkte</summary><ul><li data-kapitel="bruecke.html"><a href="bruecke.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 16: Die Strukturbrücke — dieselbe Mathematik, zwei Welten</span></a></li><li data-kapitel="supplychain.html"><a href="supplychain.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 17: Supply-Chain und Energieeinsatz unter Unsicherheit</span></a></li><li data-kapitel="finanzdaten.html"><a href="finanzdaten.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 18: Finanzdaten-Modellierung — Renditen, Kovarianz und Shrinkage</span></a></li><li data-kapitel="markowitz.html"><a href="markowitz.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 19: Die moderne Portfoliotheorie nach Markowitz</span></a></li><li data-kapitel="cvar.html"><a href="cvar.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 20: Tail-Risiko, CVaR und Transaktionskosten</span></a></li><li data-kapitel="handelsmaschine.html"><a href="handelsmaschine.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 21: Die vollständige quantitative Handelsmaschine</span></a></li><li data-kapitel="synthese-anwendungen.html"><a href="synthese-anwendungen.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Synthese Teil IV</span></a></li></ul></details><details class="sidebar-gruppe" open><summary>Teil V: Praxis</summary><ul><li data-kapitel="praxisfallen.html"><a href="praxisfallen.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 22: Praxisfallen und der Weg zum produktiven Einsatz</span></a></li><li data-kapitel="testing.html"><a href="testing.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 23: Testen, Messen, Ausliefern</span></a></li><li data-kapitel="synthese-praxis.html"><a href="synthese-praxis.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Synthese Teil V</span></a></li><li data-kapitel="projektwerkstatt.html" class="aktiv"><a href="projektwerkstatt.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Projektwerkstatt</span></a></li></ul></details><details class="sidebar-gruppe"><summary>Anhänge</summary><ul><li data-kapitel="anhang-loesungen.html"><a href="anhang-loesungen.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Anhang A: Lösungen zu allen Übungsaufgaben</span></a></li><li data-kapitel="anhang-modellierungsmuster.html"><a href="anhang-modellierungsmuster.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Anhang B: Katalog der Modellierungsmuster</span></a></li><li data-kapitel="anhang-fehlerdiagnose.html"><a href="anhang-fehlerdiagnose.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Anhang C: Fehlerdiagnose-Handbuch</span></a></li><li data-kapitel="anhang-spickzettel.html"><a href="anhang-spickzettel.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Anhang D: Spickzettel der Solver</span></a></li><li data-kapitel="anhang-glossar-literatur.html"><a href="anhang-glossar-literatur.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Anhang E: Glossar und Literatur</span></a></li></ul></details><ul class="sidebar-extra"><li><a href="programme.html"><svg class="icon" aria-hidden="true"><use href="#icon-book"></use></svg> Beispielprogramme</a></li><li><a href="stichwortverzeichnis.html"><svg class="icon" aria-hidden="true"><use href="#icon-search"></use></svg> Stichwortverzeichnis</a></li><li><a href="gesamtdokument.html"><svg class="icon" aria-hidden="true"><use href="#icon-external-link"></use></svg> Gesamtdokument (eine Seite)</a></li><li><a href="Operations_Research_mit_Python_Version_04.pdf" download><svg class="icon" aria-hidden="true"><use href="#icon-download"></use></svg> Download als PDF</a></li></ul></div></nav>
   <main class="content">
     <nav class="breadcrumb" aria-label="Breadcrumb"><a href="index.html">Start</a> › <span>Teil V</span> › <span>Projektwerkstatt</span></nav>
-    <nav class="prev-next"><a class="prev-next-knopf prev-next-prev" href="testing.html"><svg class="icon" aria-hidden="true"><use href="#icon-chevron-left"></use></svg><span><small>Zurück</small>Kapitel 23: Testen, Messen, Ausliefern</span></a><a class="prev-next-knopf prev-next-next" href="anhang-loesungen.html"><span><small>Weiter</small>Anhang A: Lösungen zu allen Übungsaufgaben</span><svg class="icon" aria-hidden="true"><use href="#icon-chevron-right"></use></svg></a></nav>
+    <nav class="prev-next"><a class="prev-next-knopf prev-next-prev" href="synthese-praxis.html"><svg class="icon" aria-hidden="true"><use href="#icon-chevron-left"></use></svg><span><small>Zurück</small>Synthese Teil V</span></a><a class="prev-next-knopf prev-next-next" href="anhang-loesungen.html"><span><small>Weiter</small>Anhang A: Lösungen zu allen Übungsaufgaben</span><svg class="icon" aria-hidden="true"><use href="#icon-chevron-right"></use></svg></a></nav>
     <article>
     <h1 id="projektwerkstatt-elf-eigene-anwendungen">Projektwerkstatt — elf eigene Anwendungen</h1>
 <div class="card card-blick">
@@ -337,7 +337,7 @@
 
     </article>
     
-    <nav class="prev-next"><a class="prev-next-knopf prev-next-prev" href="testing.html"><svg class="icon" aria-hidden="true"><use href="#icon-chevron-left"></use></svg><span><small>Zurück</small>Kapitel 23: Testen, Messen, Ausliefern</span></a><a class="prev-next-knopf prev-next-next" href="anhang-loesungen.html"><span><small>Weiter</small>Anhang A: Lösungen zu allen Übungsaufgaben</span><svg class="icon" aria-hidden="true"><use href="#icon-chevron-right"></use></svg></a></nav>
+    <nav class="prev-next"><a class="prev-next-knopf prev-next-prev" href="synthese-praxis.html"><svg class="icon" aria-hidden="true"><use href="#icon-chevron-left"></use></svg><span><small>Zurück</small>Synthese Teil V</span></a><a class="prev-next-knopf prev-next-next" href="anhang-loesungen.html"><span><small>Weiter</small>Anhang A: Lösungen zu allen Übungsaufgaben</span><svg class="icon" aria-hidden="true"><use href="#icon-chevron-right"></use></svg></a></nav>
   </main>
 </div>
 <footer class="site-footer">
diff --git a/OR_HTML_04/qp-nlp.html b/OR_HTML_04/qp-nlp.html
index 3df372f..8a4c527 100644
--- a/OR_HTML_04/qp-nlp.html
+++ b/OR_HTML_04/qp-nlp.html
@@ -94,14 +94,14 @@
 </header>
 <div class="site-body">
   <div class="sidebar-overlay" id="sidebar-overlay" hidden></div>
-  <nav class="sidebar" id="sidebar" aria-label="Kapitelnavigation"><div class="sidebar-inhalt"><details class="sidebar-gruppe"><summary>Einstieg</summary><ul><li data-kapitel="vorwort.html"><a href="vorwort.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Vorwort & Lesehilfe</span></a></li><li data-kapitel="notation.html"><a href="notation.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Notation & Abkürzungen</span></a></li></ul></details><details class="sidebar-gruppe"><summary>Teil I: Grundlagen des Operations Research</summary><ul><li data-kapitel="einfuehrung.html"><a href="einfuehrung.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 1: Einführung in Operations Research — Vom Ursprung zur mathematischen Entscheidungsfindung</span></a></li><li data-kapitel="fundament.html"><a href="fundament.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 2: Das mathematische Fundament — Vektoren, Matrizen, Konvexität</span></a></li><li data-kapitel="oekosystem.html"><a href="oekosystem.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 3: Das Python-Ökosystem für OR — Solver, Bindings und Modellierungsschichten</span></a></li><li data-kapitel="modellierung.html"><a href="modellierung.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 4: Vom Management-Wunsch zum Modell</span></a></li></ul></details><details class="sidebar-gruppe"><summary>Teil II: Die Kernverfahren der deterministischen Optimierung</summary><ul><li data-kapitel="lp.html"><a href="lp.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 5: Lineare Programmierung — Simplex, Dualität und Schattenpreise</span></a></li><li data-kapitel="milp.html"><a href="milp.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 6: Gemischt-ganzzahlige Optimierung — Diskrete Entscheidungen und Branch-and-Bound</span></a></li><li data-kapitel="cpsat.html"><a href="cpsat.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 7: Constraint Programming mit CP-SAT — Logik, Scheduling und Zuweisung</span></a></li><li data-kapitel="graphen.html"><a href="graphen.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 8: Graphen, Flüsse und Touren — Min-Cost-Flow, Matching und VRP</span></a></li><li data-kapitel="metaheuristiken.html"><a href="metaheuristiken.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 9: Metaheuristiken — wenn der exakte Solver aussteigt</span></a></li><li data-kapitel="dekomposition.html"><a href="dekomposition.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 10: Spaltengenerierung — das Modell umbauen statt die Lösung raten</span></a></li></ul></details><details class="sidebar-gruppe" open><summary>Teil III: Nichtlinearität, Unsicherheit und mehrperiodige Dynamik</summary><ul><li data-kapitel="qp-nlp.html" class="aktiv"><a href="qp-nlp.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 11: Quadratische und nichtlineare Optimierung — KKT, Lagrange, Konvexität</span></a></li><li data-kapitel="unsicherheit.html"><a href="unsicherheit.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 12: Optimierung unter Unsicherheit — Monte-Carlo, Stochastik, Robustheit</span></a></li><li data-kapitel="dynamische-programmierung.html"><a href="dynamische-programmierung.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 13: Dynamische Programmierung — Die Bellman-Gleichung und Order-Execution</span></a></li><li data-kapitel="mehrziel.html"><a href="mehrziel.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 14: Mehrere Ziele — Pareto-Fronten statt Gewichte</span></a></li><li data-kapitel="prognose.html"><a href="prognose.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 15: Predict-then-Optimize — die bessere Prognose, die schlechtere Entscheidung</span></a></li></ul></details><details class="sidebar-gruppe"><summary>Teil IV: Anwendungen — Energiewirtschaft und Finanzmärkte</summary><ul><li data-kapitel="bruecke.html"><a href="bruecke.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 16: Die Strukturbrücke — dieselbe Mathematik, zwei Welten</span></a></li><li data-kapitel="supplychain.html"><a href="supplychain.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 17: Supply-Chain und Energieeinsatz unter Unsicherheit</span></a></li><li data-kapitel="finanzdaten.html"><a href="finanzdaten.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 18: Finanzdaten-Modellierung — Renditen, Kovarianz und Shrinkage</span></a></li><li data-kapitel="markowitz.html"><a href="markowitz.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 19: Die moderne Portfoliotheorie nach Markowitz</span></a></li><li data-kapitel="cvar.html"><a href="cvar.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 20: Tail-Risiko, CVaR und Transaktionskosten</span></a></li><li data-kapitel="handelsmaschine.html"><a href="handelsmaschine.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 21: Die vollständige quantitative Handelsmaschine</span></a></li></ul></details><details class="sidebar-gruppe"><summary>Teil V: Praxis</summary><ul><li data-kapitel="praxisfallen.html"><a href="praxisfallen.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 22: Praxisfallen und der Weg zum produktiven Einsatz</span></a></li><li data-kapitel="testing.html"><a href="testing.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 23: Testen, Messen, Ausliefern</span></a></li><li data-kapitel="projektwerkstatt.html"><a href="projektwerkstatt.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Projektwerkstatt</span></a></li></ul></details><details class="sidebar-gruppe"><summary>Anhänge</summary><ul><li data-kapitel="anhang-loesungen.html"><a href="anhang-loesungen.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Anhang A: Lösungen zu allen Übungsaufgaben</span></a></li><li data-kapitel="anhang-modellierungsmuster.html"><a href="anhang-modellierungsmuster.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Anhang B: Katalog der Modellierungsmuster</span></a></li><li data-kapitel="anhang-fehlerdiagnose.html"><a href="anhang-fehlerdiagnose.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Anhang C: Fehlerdiagnose-Handbuch</span></a></li><li data-kapitel="anhang-spickzettel.html"><a href="anhang-spickzettel.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Anhang D: Spickzettel der Solver</span></a></li><li data-kapitel="anhang-glossar-literatur.html"><a href="anhang-glossar-literatur.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Anhang E: Glossar und Literatur</span></a></li></ul></details><ul class="sidebar-extra"><li><a href="programme.html"><svg class="icon" aria-hidden="true"><use href="#icon-book"></use></svg> Beispielprogramme</a></li><li><a href="stichwortverzeichnis.html"><svg class="icon" aria-hidden="true"><use href="#icon-search"></use></svg> Stichwortverzeichnis</a></li><li><a href="gesamtdokument.html"><svg class="icon" aria-hidden="true"><use href="#icon-external-link"></use></svg> Gesamtdokument (eine Seite)</a></li><li><a href="Operations_Research_mit_Python_Version_04.pdf" download><svg class="icon" aria-hidden="true"><use href="#icon-download"></use></svg> Download als PDF</a></li></ul></div></nav>
+  <nav class="sidebar" id="sidebar" aria-label="Kapitelnavigation"><div class="sidebar-inhalt"><details class="sidebar-gruppe"><summary>Einstieg</summary><ul><li data-kapitel="vorwort.html"><a href="vorwort.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Vorwort & Lesehilfe</span></a></li><li data-kapitel="notation.html"><a href="notation.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Notation & Abkürzungen</span></a></li></ul></details><details class="sidebar-gruppe"><summary>Teil I: Grundlagen des Operations Research</summary><ul><li data-kapitel="einfuehrung.html"><a href="einfuehrung.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 1: Einführung in Operations Research — Vom Ursprung zur mathematischen Entscheidungsfindung</span></a></li><li data-kapitel="fundament.html"><a href="fundament.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 2: Das mathematische Fundament — Vektoren, Matrizen, Konvexität</span></a></li><li data-kapitel="oekosystem.html"><a href="oekosystem.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 3: Das Python-Ökosystem für OR — Solver, Bindings und Modellierungsschichten</span></a></li><li data-kapitel="modellierung.html"><a href="modellierung.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 4: Vom Management-Wunsch zum Modell</span></a></li><li data-kapitel="synthese-grundlagen.html"><a href="synthese-grundlagen.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Synthese Teil I</span></a></li></ul></details><details class="sidebar-gruppe"><summary>Teil II: Die Kernverfahren der deterministischen Optimierung</summary><ul><li data-kapitel="lp.html"><a href="lp.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 5: Lineare Programmierung — Simplex, Dualität und Schattenpreise</span></a></li><li data-kapitel="milp.html"><a href="milp.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 6: Gemischt-ganzzahlige Optimierung — Diskrete Entscheidungen und Branch-and-Bound</span></a></li><li data-kapitel="cpsat.html"><a href="cpsat.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 7: Constraint Programming mit CP-SAT — Logik, Scheduling und Zuweisung</span></a></li><li data-kapitel="graphen.html"><a href="graphen.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 8: Graphen, Flüsse und Touren — Min-Cost-Flow, Matching und VRP</span></a></li><li data-kapitel="metaheuristiken.html"><a href="metaheuristiken.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 9: Metaheuristiken — wenn der exakte Solver aussteigt</span></a></li><li data-kapitel="dekomposition.html"><a href="dekomposition.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 10: Spaltengenerierung — das Modell umbauen statt die Lösung raten</span></a></li><li data-kapitel="synthese-kernverfahren.html"><a href="synthese-kernverfahren.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Synthese Teil II</span></a></li></ul></details><details class="sidebar-gruppe" open><summary>Teil III: Nichtlinearität, Unsicherheit und mehrperiodige Dynamik</summary><ul><li data-kapitel="qp-nlp.html" class="aktiv"><a href="qp-nlp.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 11: Quadratische und nichtlineare Optimierung — KKT, Lagrange, Konvexität</span></a></li><li data-kapitel="unsicherheit.html"><a href="unsicherheit.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 12: Optimierung unter Unsicherheit — Monte-Carlo, Stochastik, Robustheit</span></a></li><li data-kapitel="dynamische-programmierung.html"><a href="dynamische-programmierung.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 13: Dynamische Programmierung — Die Bellman-Gleichung und Order-Execution</span></a></li><li data-kapitel="mehrziel.html"><a href="mehrziel.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 14: Mehrere Ziele — Pareto-Fronten statt Gewichte</span></a></li><li data-kapitel="prognose.html"><a href="prognose.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 15: Predict-then-Optimize — die bessere Prognose, die schlechtere Entscheidung</span></a></li><li data-kapitel="synthese-nichtlinear.html"><a href="synthese-nichtlinear.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Synthese Teil III</span></a></li></ul></details><details class="sidebar-gruppe"><summary>Teil IV: Anwendungen — Energiewirtschaft und Finanzmärkte</summary><ul><li data-kapitel="bruecke.html"><a href="bruecke.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 16: Die Strukturbrücke — dieselbe Mathematik, zwei Welten</span></a></li><li data-kapitel="supplychain.html"><a href="supplychain.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 17: Supply-Chain und Energieeinsatz unter Unsicherheit</span></a></li><li data-kapitel="finanzdaten.html"><a href="finanzdaten.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 18: Finanzdaten-Modellierung — Renditen, Kovarianz und Shrinkage</span></a></li><li data-kapitel="markowitz.html"><a href="markowitz.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 19: Die moderne Portfoliotheorie nach Markowitz</span></a></li><li data-kapitel="cvar.html"><a href="cvar.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 20: Tail-Risiko, CVaR und Transaktionskosten</span></a></li><li data-kapitel="handelsmaschine.html"><a href="handelsmaschine.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 21: Die vollständige quantitative Handelsmaschine</span></a></li><li data-kapitel="synthese-anwendungen.html"><a href="synthese-anwendungen.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Synthese Teil IV</span></a></li></ul></details><details class="sidebar-gruppe"><summary>Teil V: Praxis</summary><ul><li data-kapitel="praxisfallen.html"><a href="praxisfallen.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 22: Praxisfallen und der Weg zum produktiven Einsatz</span></a></li><li data-kapitel="testing.html"><a href="testing.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 23: Testen, Messen, Ausliefern</span></a></li><li data-kapitel="synthese-praxis.html"><a href="synthese-praxis.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Synthese Teil V</span></a></li><li data-kapitel="projektwerkstatt.html"><a href="projektwerkstatt.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Projektwerkstatt</span></a></li></ul></details><details class="sidebar-gruppe"><summary>Anhänge</summary><ul><li data-kapitel="anhang-loesungen.html"><a href="anhang-loesungen.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Anhang A: Lösungen zu allen Übungsaufgaben</span></a></li><li data-kapitel="anhang-modellierungsmuster.html"><a href="anhang-modellierungsmuster.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Anhang B: Katalog der Modellierungsmuster</span></a></li><li data-kapitel="anhang-fehlerdiagnose.html"><a href="anhang-fehlerdiagnose.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Anhang C: Fehlerdiagnose-Handbuch</span></a></li><li data-kapitel="anhang-spickzettel.html"><a href="anhang-spickzettel.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Anhang D: Spickzettel der Solver</span></a></li><li data-kapitel="anhang-glossar-literatur.html"><a href="anhang-glossar-literatur.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Anhang E: Glossar und Literatur</span></a></li></ul></details><ul class="sidebar-extra"><li><a href="programme.html"><svg class="icon" aria-hidden="true"><use href="#icon-book"></use></svg> Beispielprogramme</a></li><li><a href="stichwortverzeichnis.html"><svg class="icon" aria-hidden="true"><use href="#icon-search"></use></svg> Stichwortverzeichnis</a></li><li><a href="gesamtdokument.html"><svg class="icon" aria-hidden="true"><use href="#icon-external-link"></use></svg> Gesamtdokument (eine Seite)</a></li><li><a href="Operations_Research_mit_Python_Version_04.pdf" download><svg class="icon" aria-hidden="true"><use href="#icon-download"></use></svg> Download als PDF</a></li></ul></div></nav>
   <main class="content">
     <nav class="breadcrumb" aria-label="Breadcrumb"><a href="index.html">Start</a> › <span>Teil III</span> › <span>Kapitel 11: Quadratische und nichtlineare Optimierung — KKT, Lagrange, Konvexität</span></nav>
-    <nav class="prev-next"><a class="prev-next-knopf prev-next-prev" href="dekomposition.html"><svg class="icon" aria-hidden="true"><use href="#icon-chevron-left"></use></svg><span><small>Zurück</small>Kapitel 10: Spaltengenerierung — das Modell umbauen statt die Lösung raten</span></a><a class="prev-next-knopf prev-next-next" href="unsicherheit.html"><span><small>Weiter</small>Kapitel 12: Optimierung unter Unsicherheit — Monte-Carlo, Stochastik, Robustheit</span><svg class="icon" aria-hidden="true"><use href="#icon-chevron-right"></use></svg></a></nav>
+    <nav class="prev-next"><a class="prev-next-knopf prev-next-prev" href="synthese-kernverfahren.html"><svg class="icon" aria-hidden="true"><use href="#icon-chevron-left"></use></svg><span><small>Zurück</small>Synthese Teil II</span></a><a class="prev-next-knopf prev-next-next" href="unsicherheit.html"><span><small>Weiter</small>Kapitel 12: Optimierung unter Unsicherheit — Monte-Carlo, Stochastik, Robustheit</span><svg class="icon" aria-hidden="true"><use href="#icon-chevron-right"></use></svg></a></nav>
     <article>
     <h1 id="teil-nichtlinear">Teil III: Nichtlinearität, Unsicherheit und mehrperiodige Dynamik</h1>
 <p><a href="lp.html#teil-kernverfahren">Teil II</a> ging von festen Daten und linearen Zusammenhängen aus. Beides gilt in der Praxis oft nicht: Risiko wächst <strong>quadratisch</strong> mit dem Einsatz, Nachfrage ist erst morgen bekannt, und eine Entscheidung heute verändert, welche Möglichkeiten übermorgen noch offenstehen.</p>
-<p>Die drei Kapitel dieses Teils behandeln genau diese drei Abweichungen. Welches Werkzeug Sie brauchen, hängt davon ab, <strong>welche</strong> davon bei Ihnen vorliegt:</p>
+<p>Drei Kapitel dieses Teils behandeln genau diese drei Abweichungen. Welches Werkzeug Sie brauchen, hängt davon ab, <strong>welche</strong> davon bei Ihnen vorliegt:</p>
 <figure>
 <img src="bilder_04/teil3_solverwahl.svg" alt="Entscheidungsdiagramm: Welches Werkzeug passt zu meinem Problem? (Teil III)" />
 <figcaption aria-hidden="true">Entscheidungsdiagramm: Welches Werkzeug passt zu meinem Problem? (Teil III)</figcaption>
@@ -110,6 +110,7 @@
 <p><strong>🎯 Merksatz zum Diagramm</strong> Die erste Frage trennt zwei Welten, die man nicht vermischen darf. Ist die <strong>Nichtlinearität</strong> das Problem, geht es um Konvexität — und damit darum, ob Sie eine Optimalitätsgarantie bekommen oder nur ein lokales Optimum. Ist die <strong>Unsicherheit</strong> das Problem, geht es um etwas ganz anderes: Nicht der Solver ist die Schwierigkeit, sondern die Frage, was „optimal“ überhaupt heißen soll, wenn man die Daten nicht kennt.</p>
 <p>Der häufigste Fehler an dieser Stelle ist, Unsicherheit durch <strong>Mittelwerte</strong> zu ersetzen und dann deterministisch zu rechnen. Warum das systematisch danebengeht, zeigt <a href="unsicherheit.html#kap-unsicherheit">Kapitel 12</a> unter dem Namen <em>Fluch des Durchschnitts</em>.</p>
 </blockquote>
+<p>Zwei weitere Kapitel schließen sich an, weil sie dieselbe Voraussetzung aufgeben, nur an einer anderen Stelle: <a href="mehrziel.html#kap-mehrziel">Kapitel 14</a> gibt das <strong>eine Ziel</strong> auf, <a href="prognose.html#kap-prognose">Kapitel 15</a> die Annahme, die <strong>Eingabedaten</strong> seien gegeben statt selbst geschätzt. Was dieser Teil insgesamt leistet, fasst die Synthese an seinem Ende zusammen.</p>
 <hr />
 <h1 id="kap-qp-nlp">Kapitel 11: Quadratische und nichtlineare Optimierung — KKT, Lagrange, Konvexität</h1>
 <div class="card card-blick">
@@ -783,7 +784,7 @@ US-Treasuries        3.0 %        7.0 %   0.45 %
 <li><strong>Multistart.</strong> Zehn Startpunkte, und die Spannweite der Ergebnisse wird gemessen. Sind alle gleich, ist das ein starkes Indiz für Konvexität. Weichen sie ab, wissen Sie sofort, dass Sie einem lokalen Optimum aufsitzen. Diese fünf Zeilen sollten in jedem SLSQP-Projekt stehen.</li>
 <li><strong>Analytischer Gradient.</strong> <code>jac=gradient</code> spart nicht nur Zeit — die numerische Approximation von Ableitungen ist bei Termen wie <span class="math inline">\ln w</span> nahe null numerisch heikel.</li>
 </ol>
-<p><strong>Zur Skalierung:</strong> Mit <span class="math inline">\alpha = 1</span> ist der Ertragsterm (<span class="math inline">\approx 0{,}1</span>) zehnmal größer als der Varianzterm (<span class="math inline">\approx 0{,}01</span>). Das Modell ist also stark renditegetrieben. Übung 8.5 lässt Sie diese Balance untersuchen — sie ist eine fachliche Entscheidung, keine technische.</p>
+<p><strong>Zur Skalierung:</strong> Mit <span class="math inline">\alpha = 1</span> ist der Ertragsterm (<span class="math inline">\approx 0{,}1</span>) zehnmal größer als der Varianzterm (<span class="math inline">\approx 0{,}01</span>). Das Modell ist also stark renditegetrieben. Die Aufgabe <em>Effekt der Gewichtung untersuchen</em> (<a href="#sec:qp-nlp-uebungsaufgaben">Abschnitt 11.7</a>) lässt Sie diese Balance untersuchen — sie ist eine fachliche Entscheidung, keine technische.</p>
 </blockquote>
 <hr />
 <h2 id="sec:qp-nlp-nichtkonvex">11.6 Jenseits der Konvexität: lokale Optima, Multistart und MINLP</h2>
@@ -1225,7 +1226,7 @@ Drei Konsequenzen fuer die Praxis:
 <h2 id="sec:qp-nlp-denkfehler">11.8 Finde den Denkfehler</h2>
 <div class="card card-denkfehler">
 <blockquote>
-<p><strong>🐛 Finde den Denkfehler 8.1: Die Kovarianzmatrix aus dem Controlling</strong></p>
+<p><strong>🐛 Finde den Denkfehler: Die Kovarianzmatrix aus dem Controlling</strong></p>
 <p>Ein Analyst soll das Risiko eines Portfolios aus drei Anlagen minimieren. Die Korrelationen hat er aus drei verschiedenen Quartalsberichten zusammengetragen — jede für sich plausibel:</p>
 <ul>
 <li>A und B laufen stark gleich: <span class="math inline">\rho_{AB} = 0{,}9</span></li>
@@ -1264,7 +1265,7 @@ The objective is not DCP. Its following subexpressions are not: QuadForm(...)</c
 <h2 id="sec:qp-nlp-quiz">11.9 Micro-Quiz</h2>
 <div class="card card-quiz">
 <blockquote>
-<p><strong>❓ Micro-Quiz 8: Drei Fragen zum Selbstcheck</strong></p>
+<p><strong>❓ Micro-Quiz 11: Drei Fragen zum Selbstcheck</strong></p>
 <p>Genau eine Antwort ist jeweils richtig. Auflösung in <a href="anhang-loesungen.html#quiz-loesung-qp-nlp">Anhang A</a>.</p>
 <p><strong>1. CVXPY lehnt Ihr Modell mit <code>DCPError: Problem does not follow DCP rules</code> ab. Was ist die richtige Reaktion?</strong> (a) Auf <code>scipy.optimize.minimize</code> ausweichen, das die Formulierung akzeptiert. (b) Die Meldung ernst nehmen: CVXPY sagt, dass es für diese Formulierung <strong>keine Optimalitätsgarantie</strong> geben kann. Entweder das Problem konvex umformulieren — oder bewusst auf ein lokales Verfahren mit Multistart wechseln. (c) Die Toleranzen lockern.</p>
 <p><strong>2. <code>scipy.optimize.minimize</code> meldet für ein Modell mit Mengenrabatten <code>success: True</code>. Was wissen Sie damit über die gefundene Lösung?</strong> (a) Sie ist optimal. (b) Sie ist ein lokales Minimum — es geht von dort in keine Richtung mehr bergab. Ob es anderswo ein besseres gibt, ist damit offen. (c) Sie ist zulässig, aber möglicherweise nicht einmal ein lokales Minimum.</p>
@@ -1299,7 +1300,7 @@ The objective is not DCP. Its following subexpressions are not: QuadForm(...)</c
 
     </article>
     <button type="button" class="fortschritt-knopf" data-kapitel="qp-nlp.html"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg> <span>Als gelesen markieren</span></button>
-    <nav class="prev-next"><a class="prev-next-knopf prev-next-prev" href="dekomposition.html"><svg class="icon" aria-hidden="true"><use href="#icon-chevron-left"></use></svg><span><small>Zurück</small>Kapitel 10: Spaltengenerierung — das Modell umbauen statt die Lösung raten</span></a><a class="prev-next-knopf prev-next-next" href="unsicherheit.html"><span><small>Weiter</small>Kapitel 12: Optimierung unter Unsicherheit — Monte-Carlo, Stochastik, Robustheit</span><svg class="icon" aria-hidden="true"><use href="#icon-chevron-right"></use></svg></a></nav>
+    <nav class="prev-next"><a class="prev-next-knopf prev-next-prev" href="synthese-kernverfahren.html"><svg class="icon" aria-hidden="true"><use href="#icon-chevron-left"></use></svg><span><small>Zurück</small>Synthese Teil II</span></a><a class="prev-next-knopf prev-next-next" href="unsicherheit.html"><span><small>Weiter</small>Kapitel 12: Optimierung unter Unsicherheit — Monte-Carlo, Stochastik, Robustheit</span><svg class="icon" aria-hidden="true"><use href="#icon-chevron-right"></use></svg></a></nav>
   </main>
 </div>
 <footer class="site-footer">
diff --git a/OR_HTML_04/stichwortverzeichnis.html b/OR_HTML_04/stichwortverzeichnis.html
index cd998b8..71d12db 100644
--- a/OR_HTML_04/stichwortverzeichnis.html
+++ b/OR_HTML_04/stichwortverzeichnis.html
@@ -94,12 +94,12 @@
 </header>
 <div class="site-body">
   <div class="sidebar-overlay" id="sidebar-overlay" hidden></div>
-  <nav class="sidebar" id="sidebar" aria-label="Kapitelnavigation"><div class="sidebar-inhalt"><details class="sidebar-gruppe"><summary>Einstieg</summary><ul><li data-kapitel="vorwort.html"><a href="vorwort.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Vorwort & Lesehilfe</span></a></li><li data-kapitel="notation.html"><a href="notation.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Notation & Abkürzungen</span></a></li></ul></details><details class="sidebar-gruppe"><summary>Teil I: Grundlagen des Operations Research</summary><ul><li data-kapitel="einfuehrung.html"><a href="einfuehrung.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 1: Einführung in Operations Research — Vom Ursprung zur mathematischen Entscheidungsfindung</span></a></li><li data-kapitel="fundament.html"><a href="fundament.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 2: Das mathematische Fundament — Vektoren, Matrizen, Konvexität</span></a></li><li data-kapitel="oekosystem.html"><a href="oekosystem.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 3: Das Python-Ökosystem für OR — Solver, Bindings und Modellierungsschichten</span></a></li><li data-kapitel="modellierung.html"><a href="modellierung.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 4: Vom Management-Wunsch zum Modell</span></a></li></ul></details><details class="sidebar-gruppe"><summary>Teil II: Die Kernverfahren der deterministischen Optimierung</summary><ul><li data-kapitel="lp.html"><a href="lp.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 5: Lineare Programmierung — Simplex, Dualität und Schattenpreise</span></a></li><li data-kapitel="milp.html"><a href="milp.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 6: Gemischt-ganzzahlige Optimierung — Diskrete Entscheidungen und Branch-and-Bound</span></a></li><li data-kapitel="cpsat.html"><a href="cpsat.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 7: Constraint Programming mit CP-SAT — Logik, Scheduling und Zuweisung</span></a></li><li data-kapitel="graphen.html"><a href="graphen.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 8: Graphen, Flüsse und Touren — Min-Cost-Flow, Matching und VRP</span></a></li><li data-kapitel="metaheuristiken.html"><a href="metaheuristiken.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 9: Metaheuristiken — wenn der exakte Solver aussteigt</span></a></li><li data-kapitel="dekomposition.html"><a href="dekomposition.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 10: Spaltengenerierung — das Modell umbauen statt die Lösung raten</span></a></li></ul></details><details class="sidebar-gruppe"><summary>Teil III: Nichtlinearität, Unsicherheit und mehrperiodige Dynamik</summary><ul><li data-kapitel="qp-nlp.html"><a href="qp-nlp.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 11: Quadratische und nichtlineare Optimierung — KKT, Lagrange, Konvexität</span></a></li><li data-kapitel="unsicherheit.html"><a href="unsicherheit.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 12: Optimierung unter Unsicherheit — Monte-Carlo, Stochastik, Robustheit</span></a></li><li data-kapitel="dynamische-programmierung.html"><a href="dynamische-programmierung.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 13: Dynamische Programmierung — Die Bellman-Gleichung und Order-Execution</span></a></li><li data-kapitel="mehrziel.html"><a href="mehrziel.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 14: Mehrere Ziele — Pareto-Fronten statt Gewichte</span></a></li><li data-kapitel="prognose.html"><a href="prognose.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 15: Predict-then-Optimize — die bessere Prognose, die schlechtere Entscheidung</span></a></li></ul></details><details class="sidebar-gruppe"><summary>Teil IV: Anwendungen — Energiewirtschaft und Finanzmärkte</summary><ul><li data-kapitel="bruecke.html"><a href="bruecke.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 16: Die Strukturbrücke — dieselbe Mathematik, zwei Welten</span></a></li><li data-kapitel="supplychain.html"><a href="supplychain.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 17: Supply-Chain und Energieeinsatz unter Unsicherheit</span></a></li><li data-kapitel="finanzdaten.html"><a href="finanzdaten.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 18: Finanzdaten-Modellierung — Renditen, Kovarianz und Shrinkage</span></a></li><li data-kapitel="markowitz.html"><a href="markowitz.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 19: Die moderne Portfoliotheorie nach Markowitz</span></a></li><li data-kapitel="cvar.html"><a href="cvar.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 20: Tail-Risiko, CVaR und Transaktionskosten</span></a></li><li data-kapitel="handelsmaschine.html"><a href="handelsmaschine.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 21: Die vollständige quantitative Handelsmaschine</span></a></li></ul></details><details class="sidebar-gruppe"><summary>Teil V: Praxis</summary><ul><li data-kapitel="praxisfallen.html"><a href="praxisfallen.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 22: Praxisfallen und der Weg zum produktiven Einsatz</span></a></li><li data-kapitel="testing.html"><a href="testing.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 23: Testen, Messen, Ausliefern</span></a></li><li data-kapitel="projektwerkstatt.html"><a href="projektwerkstatt.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Projektwerkstatt</span></a></li></ul></details><details class="sidebar-gruppe"><summary>Anhänge</summary><ul><li data-kapitel="anhang-loesungen.html"><a href="anhang-loesungen.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Anhang A: Lösungen zu allen Übungsaufgaben</span></a></li><li data-kapitel="anhang-modellierungsmuster.html"><a href="anhang-modellierungsmuster.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Anhang B: Katalog der Modellierungsmuster</span></a></li><li data-kapitel="anhang-fehlerdiagnose.html"><a href="anhang-fehlerdiagnose.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Anhang C: Fehlerdiagnose-Handbuch</span></a></li><li data-kapitel="anhang-spickzettel.html"><a href="anhang-spickzettel.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Anhang D: Spickzettel der Solver</span></a></li><li data-kapitel="anhang-glossar-literatur.html"><a href="anhang-glossar-literatur.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Anhang E: Glossar und Literatur</span></a></li></ul></details><ul class="sidebar-extra"><li><a href="programme.html"><svg class="icon" aria-hidden="true"><use href="#icon-book"></use></svg> Beispielprogramme</a></li><li><a href="stichwortverzeichnis.html"><svg class="icon" aria-hidden="true"><use href="#icon-search"></use></svg> Stichwortverzeichnis</a></li><li><a href="gesamtdokument.html"><svg class="icon" aria-hidden="true"><use href="#icon-external-link"></use></svg> Gesamtdokument (eine Seite)</a></li><li><a href="Operations_Research_mit_Python_Version_04.pdf" download><svg class="icon" aria-hidden="true"><use href="#icon-download"></use></svg> Download als PDF</a></li></ul></div></nav>
+  <nav class="sidebar" id="sidebar" aria-label="Kapitelnavigation"><div class="sidebar-inhalt"><details class="sidebar-gruppe"><summary>Einstieg</summary><ul><li data-kapitel="vorwort.html"><a href="vorwort.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Vorwort & Lesehilfe</span></a></li><li data-kapitel="notation.html"><a href="notation.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Notation & Abkürzungen</span></a></li></ul></details><details class="sidebar-gruppe"><summary>Teil I: Grundlagen des Operations Research</summary><ul><li data-kapitel="einfuehrung.html"><a href="einfuehrung.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 1: Einführung in Operations Research — Vom Ursprung zur mathematischen Entscheidungsfindung</span></a></li><li data-kapitel="fundament.html"><a href="fundament.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 2: Das mathematische Fundament — Vektoren, Matrizen, Konvexität</span></a></li><li data-kapitel="oekosystem.html"><a href="oekosystem.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 3: Das Python-Ökosystem für OR — Solver, Bindings und Modellierungsschichten</span></a></li><li data-kapitel="modellierung.html"><a href="modellierung.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 4: Vom Management-Wunsch zum Modell</span></a></li><li data-kapitel="synthese-grundlagen.html"><a href="synthese-grundlagen.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Synthese Teil I</span></a></li></ul></details><details class="sidebar-gruppe"><summary>Teil II: Die Kernverfahren der deterministischen Optimierung</summary><ul><li data-kapitel="lp.html"><a href="lp.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 5: Lineare Programmierung — Simplex, Dualität und Schattenpreise</span></a></li><li data-kapitel="milp.html"><a href="milp.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 6: Gemischt-ganzzahlige Optimierung — Diskrete Entscheidungen und Branch-and-Bound</span></a></li><li data-kapitel="cpsat.html"><a href="cpsat.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 7: Constraint Programming mit CP-SAT — Logik, Scheduling und Zuweisung</span></a></li><li data-kapitel="graphen.html"><a href="graphen.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 8: Graphen, Flüsse und Touren — Min-Cost-Flow, Matching und VRP</span></a></li><li data-kapitel="metaheuristiken.html"><a href="metaheuristiken.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 9: Metaheuristiken — wenn der exakte Solver aussteigt</span></a></li><li data-kapitel="dekomposition.html"><a href="dekomposition.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 10: Spaltengenerierung — das Modell umbauen statt die Lösung raten</span></a></li><li data-kapitel="synthese-kernverfahren.html"><a href="synthese-kernverfahren.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Synthese Teil II</span></a></li></ul></details><details class="sidebar-gruppe"><summary>Teil III: Nichtlinearität, Unsicherheit und mehrperiodige Dynamik</summary><ul><li data-kapitel="qp-nlp.html"><a href="qp-nlp.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 11: Quadratische und nichtlineare Optimierung — KKT, Lagrange, Konvexität</span></a></li><li data-kapitel="unsicherheit.html"><a href="unsicherheit.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 12: Optimierung unter Unsicherheit — Monte-Carlo, Stochastik, Robustheit</span></a></li><li data-kapitel="dynamische-programmierung.html"><a href="dynamische-programmierung.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 13: Dynamische Programmierung — Die Bellman-Gleichung und Order-Execution</span></a></li><li data-kapitel="mehrziel.html"><a href="mehrziel.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 14: Mehrere Ziele — Pareto-Fronten statt Gewichte</span></a></li><li data-kapitel="prognose.html"><a href="prognose.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 15: Predict-then-Optimize — die bessere Prognose, die schlechtere Entscheidung</span></a></li><li data-kapitel="synthese-nichtlinear.html"><a href="synthese-nichtlinear.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Synthese Teil III</span></a></li></ul></details><details class="sidebar-gruppe"><summary>Teil IV: Anwendungen — Energiewirtschaft und Finanzmärkte</summary><ul><li data-kapitel="bruecke.html"><a href="bruecke.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 16: Die Strukturbrücke — dieselbe Mathematik, zwei Welten</span></a></li><li data-kapitel="supplychain.html"><a href="supplychain.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 17: Supply-Chain und Energieeinsatz unter Unsicherheit</span></a></li><li data-kapitel="finanzdaten.html"><a href="finanzdaten.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 18: Finanzdaten-Modellierung — Renditen, Kovarianz und Shrinkage</span></a></li><li data-kapitel="markowitz.html"><a href="markowitz.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 19: Die moderne Portfoliotheorie nach Markowitz</span></a></li><li data-kapitel="cvar.html"><a href="cvar.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 20: Tail-Risiko, CVaR und Transaktionskosten</span></a></li><li data-kapitel="handelsmaschine.html"><a href="handelsmaschine.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 21: Die vollständige quantitative Handelsmaschine</span></a></li><li data-kapitel="synthese-anwendungen.html"><a href="synthese-anwendungen.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Synthese Teil IV</span></a></li></ul></details><details class="sidebar-gruppe"><summary>Teil V: Praxis</summary><ul><li data-kapitel="praxisfallen.html"><a href="praxisfallen.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 22: Praxisfallen und der Weg zum produktiven Einsatz</span></a></li><li data-kapitel="testing.html"><a href="testing.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 23: Testen, Messen, Ausliefern</span></a></li><li data-kapitel="synthese-praxis.html"><a href="synthese-praxis.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Synthese Teil V</span></a></li><li data-kapitel="projektwerkstatt.html"><a href="projektwerkstatt.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Projektwerkstatt</span></a></li></ul></details><details class="sidebar-gruppe"><summary>Anhänge</summary><ul><li data-kapitel="anhang-loesungen.html"><a href="anhang-loesungen.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Anhang A: Lösungen zu allen Übungsaufgaben</span></a></li><li data-kapitel="anhang-modellierungsmuster.html"><a href="anhang-modellierungsmuster.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Anhang B: Katalog der Modellierungsmuster</span></a></li><li data-kapitel="anhang-fehlerdiagnose.html"><a href="anhang-fehlerdiagnose.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Anhang C: Fehlerdiagnose-Handbuch</span></a></li><li data-kapitel="anhang-spickzettel.html"><a href="anhang-spickzettel.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Anhang D: Spickzettel der Solver</span></a></li><li data-kapitel="anhang-glossar-literatur.html"><a href="anhang-glossar-literatur.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Anhang E: Glossar und Literatur</span></a></li></ul></details><ul class="sidebar-extra"><li><a href="programme.html"><svg class="icon" aria-hidden="true"><use href="#icon-book"></use></svg> Beispielprogramme</a></li><li><a href="stichwortverzeichnis.html"><svg class="icon" aria-hidden="true"><use href="#icon-search"></use></svg> Stichwortverzeichnis</a></li><li><a href="gesamtdokument.html"><svg class="icon" aria-hidden="true"><use href="#icon-external-link"></use></svg> Gesamtdokument (eine Seite)</a></li><li><a href="Operations_Research_mit_Python_Version_04.pdf" download><svg class="icon" aria-hidden="true"><use href="#icon-download"></use></svg> Download als PDF</a></li></ul></div></nav>
   <main class="content">
     
     <nav class="prev-next"><span class="prev-next-leer"></span><span class="prev-next-leer"></span></nav>
     <article>
-    <h1>Stichwortverzeichnis</h1><p>218 Fachbegriffe. Ein Klick führt zum jeweiligen Kapitel/Abschnitt (statt einer im Web bedeutungslosen Seitenzahl wie im gedruckten Register).</p><nav class="register-sprungleiste"><a href="#buchstabe-A">A</a> <a href="#buchstabe-B">B</a> <a href="#buchstabe-C">C</a> <a href="#buchstabe-D">D</a> <a href="#buchstabe-E">E</a> <a href="#buchstabe-F">F</a> <a href="#buchstabe-G">G</a> <a href="#buchstabe-H">H</a> <a href="#buchstabe-I">I</a> <a href="#buchstabe-J">J</a> <a href="#buchstabe-K">K</a> <a href="#buchstabe-L">L</a> <a href="#buchstabe-M">M</a> <a href="#buchstabe-N">N</a> <a href="#buchstabe-O">O</a> <a href="#buchstabe-P">P</a> <a href="#buchstabe-Q">Q</a> <a href="#buchstabe-R">R</a> <a href="#buchstabe-S">S</a> <a href="#buchstabe-T">T</a> <a href="#buchstabe-U">U</a> <a href="#buchstabe-V">V</a> <a href="#buchstabe-W">W</a> <a href="#buchstabe-Z">Z</a></nav><h2 class="register-buchstabe" id="buchstabe-A">A</h2><div class="register-eintrag"><span class="register-begriff">Absolutbetrag (Modellierungsmuster)</span> — <a href="anhang-modellierungsmuster.html#anhang-modellierungsmuster">Anhang B: Katalog der Modellierungsmuster</a></div><div class="register-eintrag"><span class="register-begriff">Adjusted Close</span> — <a href="finanzdaten.html#sec:finanzdaten-diskrete-und-logarithmische-renditen">Kapitel 18: Finanzdaten-Modellierung — Renditen, Kovarianz und Shrinkage</a></div><div class="register-eintrag"><span class="register-begriff">Aktivierungsschalter (Modellierungsmuster)</span> — <a href="anhang-modellierungsmuster.html#anhang-modellierungsmuster">Anhang B: Katalog der Modellierungsmuster</a></div><div class="register-eintrag"><span class="register-begriff">Almgren-Chriss-Modell</span> — <a href="anhang-glossar-literatur.html#anhang-glossar-literatur">Anhang E: Glossar und Literatur</a>, <a href="dynamische-programmierung.html#sec:dynamische-programmierung-das-almgren-chriss-problem-optimale-orderausfuehrung">Kapitel 13: Dynamische Programmierung — Die Bellman-Gleichung und Order-Execution</a></div><div class="register-eintrag"><span class="register-begriff">Alternativoptima</span> — <a href="anhang-glossar-literatur.html#anhang-glossar-literatur">Anhang E: Glossar und Literatur</a></div><div class="register-eintrag"><span class="register-begriff">Approximate Dynamic Programming</span> — <a href="praxisfallen.html#sec:praxisfallen-weiterfuehrende-literatur-und-roadmap">Kapitel 22: Praxisfallen und der Weg zum produktiven Einsatz</a></div><h2 class="register-buchstabe" id="buchstabe-B">B</h2><div class="register-eintrag"><span class="register-begriff">Bedingte Kopplung (Konjunktion)</span> — <a href="anhang-modellierungsmuster.html#anhang-modellierungsmuster">Anhang B: Katalog der Modellierungsmuster</a></div><div class="register-eintrag"><span class="register-begriff">Bellman, Richard</span> — <a href="dynamische-programmierung.html#sec:dynamische-programmierung-das-bellmansche-optimalitaetsprinzip">Kapitel 13: Dynamische Programmierung — Die Bellman-Gleichung und Order-Execution</a></div><div class="register-eintrag"><span class="register-begriff">Bellman-Gleichung</span> — <a href="anhang-glossar-literatur.html#anhang-glossar-literatur">Anhang E: Glossar und Literatur</a>, <a href="dynamische-programmierung.html#sec:dynamische-programmierung-der-fluch-der-dimensionalitaet">Kapitel 13: Dynamische Programmierung — Die Bellman-Gleichung und Order-Execution</a></div><div class="register-eintrag"><span class="register-begriff">Benders-Zerlegung</span> — <a href="praxisfallen.html#sec:praxisfallen-weiterfuehrende-literatur-und-roadmap">Kapitel 22: Praxisfallen und der Weg zum produktiven Einsatz</a></div><div class="register-eintrag"><span class="register-begriff">Big-M-Methode</span> — <a href="anhang-glossar-literatur.html#anhang-glossar-literatur">Anhang E: Glossar und Literatur</a>, <a href="milp.html#sec:milp-modellierungstricks-big-m-und-logische-bedingungen">Kapitel 6: Gemischt-ganzzahlige Optimierung — Diskrete Entscheidungen und Branch-and-Bound</a></div><div class="register-eintrag"><span class="register-begriff">Binärvariable</span> — <a href="anhang-glossar-literatur.html#anhang-glossar-literatur">Anhang E: Glossar und Literatur</a></div><div class="register-eintrag"><span class="register-begriff">Bipartites Matching</span> — <a href="anhang-glossar-literatur.html#anhang-glossar-literatur">Anhang E: Glossar und Literatur</a>, <a href="graphen.html#sec:graphen-bipartites-matching-das-zuordnungsproblem">Kapitel 8: Graphen, Flüsse und Touren — Min-Cost-Flow, Matching und VRP</a></div><div class="register-eintrag"><span class="register-begriff">Black-Box-Effekt</span> — <a href="praxisfallen.html#sec:praxisfallen-die-fuenf-typischen-praxisfallen">Kapitel 22: Praxisfallen und der Weg zum produktiven Einsatz</a></div><div class="register-eintrag"><span class="register-begriff">Branch-and-Bound</span> — <a href="anhang-glossar-literatur.html#anhang-glossar-literatur">Anhang E: Glossar und Literatur</a>, <a href="milp.html#sec:milp-branch-and-bound">Kapitel 6: Gemischt-ganzzahlige Optimierung — Diskrete Entscheidungen und Branch-and-Bound</a><ul class="register-unter"><li>Bounding und Pruning — <a href="milp.html#sec:milp-branch-and-bound">Kapitel 6: Gemischt-ganzzahlige Optimierung — Diskrete Entscheidungen und Branch-and-Bound</a></li><li>Branching — <a href="milp.html#sec:milp-branch-and-bound">Kapitel 6: Gemischt-ganzzahlige Optimierung — Diskrete Entscheidungen und Branch-and-Bound</a></li><li>Incumbent — <a href="milp.html#sec:milp-branch-and-bound">Kapitel 6: Gemischt-ganzzahlige Optimierung — Diskrete Entscheidungen und Branch-and-Bound</a></li></ul></div><div class="register-eintrag"><span class="register-begriff">Branch-and-Cut</span> — <a href="milp.html#sec:milp-branch-and-bound">Kapitel 6: Gemischt-ganzzahlige Optimierung — Diskrete Entscheidungen und Branch-and-Bound</a>, <a href="oekosystem.html#sec:oekosystem-die-zwei-schichten-architektur">Kapitel 3: Das Python-Ökosystem für OR — Solver, Bindings und Modellierungsschichten</a></div><div class="register-eintrag"><span class="register-begriff">Brute Force</span> — <a href="einfuehrung.html#sec:einfuehrung-was-ist-operations-research-wirklich">Kapitel 1: Einführung in Operations Research — Vom Ursprung zur mathematischen Entscheidungsfindung</a></div><div class="register-eintrag"><span class="register-begriff">Budgeted Uncertainty</span> — <a href="anhang-glossar-literatur.html#anhang-glossar-literatur">Anhang E: Glossar und Literatur</a>, <a href="unsicherheit.html#sec:unsicherheit-robuste-optimierung-gegen-den-worst-case">Kapitel 12: Optimierung unter Unsicherheit — Monte-Carlo, Stochastik, Robustheit</a></div><div class="register-eintrag"><span class="register-begriff">Budgetlimit</span> — <a href="anhang-modellierungsmuster.html#anhang-modellierungsmuster">Anhang B: Katalog der Modellierungsmuster</a></div><h2 class="register-buchstabe" id="buchstabe-C">C</h2><div class="register-eintrag"><span class="register-begriff">Calmar Ratio</span> — <a href="anhang-glossar-literatur.html#anhang-glossar-literatur">Anhang E: Glossar und Literatur</a></div><div class="register-eintrag"><span class="register-begriff">CDCL</span> — <a href="cpsat.html#sec:cpsat-ein-anderes-denkmodell">Kapitel 7: Constraint Programming mit CP-SAT — Logik, Scheduling und Zuweisung</a>, <a href="oekosystem.html#sec:oekosystem-die-zwei-schichten-architektur">Kapitel 3: Das Python-Ökosystem für OR — Solver, Bindings und Modellierungsschichten</a><ul class="register-unter"><li>Conflict Learning — <a href="anhang-glossar-literatur.html#anhang-glossar-literatur">Anhang E: Glossar und Literatur</a>, <a href="cpsat.html#sec:cpsat-zusammenfassung">Kapitel 7: Constraint Programming mit CP-SAT — Logik, Scheduling und Zuweisung</a></li></ul></div><div class="register-eintrag"><span class="register-begriff">Chance Constraint</span> — <a href="unsicherheit.html#sec:unsicherheit-chance-constraints">Kapitel 12: Optimierung unter Unsicherheit — Monte-Carlo, Stochastik, Robustheit</a></div><div class="register-eintrag"><span class="register-begriff">Column Generation</span> — <a href="metaheuristiken.html#sec:metaheuristiken-abgrenzung">Kapitel 9: Metaheuristiken — wenn der exakte Solver aussteigt</a>, <a href="praxisfallen.html#sec:praxisfallen-weiterfuehrende-literatur-und-roadmap">Kapitel 22: Praxisfallen und der Weg zum produktiven Einsatz</a></div><div class="register-eintrag"><span class="register-begriff">Conditional Value at Risk (CVaR)</span> — <a href="anhang-glossar-literatur.html#anhang-glossar-literatur">Anhang E: Glossar und Literatur</a>, <a href="cvar.html#sec:cvar-value-at-risk-und-conditional-value">Kapitel 20: Tail-Risiko, CVaR und Transaktionskosten</a></div><div class="register-eintrag"><span class="register-begriff">Constraint Programming (CP)</span> — <a href="anhang-glossar-literatur.html#anhang-glossar-literatur">Anhang E: Glossar und Literatur</a>, <a href="cpsat.html#sec:cpsat-ein-anderes-denkmodell">Kapitel 7: Constraint Programming mit CP-SAT — Logik, Scheduling und Zuweisung</a></div><div class="register-eintrag"><span class="register-begriff">Constraint Propagation</span> — <a href="anhang-glossar-literatur.html#anhang-glossar-literatur">Anhang E: Glossar und Literatur</a>, <a href="cpsat.html#sec:cpsat-lernziele">Kapitel 7: Constraint Programming mit CP-SAT — Logik, Scheduling und Zuweisung</a></div><div class="register-eintrag"><span class="register-begriff">Constraint-Trace</span> — <a href="praxisfallen.html#sec:praxisfallen-die-fuenf-typischen-praxisfallen">Kapitel 22: Praxisfallen und der Weg zum produktiven Einsatz</a></div><div class="register-eintrag"><span class="register-begriff">CP-SAT</span> — <a href="anhang-glossar-literatur.html#anhang-glossar-literatur">Anhang E: Glossar und Literatur</a></div><div class="register-eintrag"><span class="register-begriff">CP-SAT-Solver</span> — <a href="cpsat.html#sec:cpsat-ein-anderes-denkmodell">Kapitel 7: Constraint Programming mit CP-SAT — Logik, Scheduling und Zuweisung</a></div><div class="register-eintrag"><span class="register-begriff">CSR-Format</span> — <a href="oekosystem.html#sec:oekosystem-ein-system-vier-programmieransaetze">Kapitel 3: Das Python-Ökosystem für OR — Solver, Bindings und Modellierungsschichten</a></div><div class="register-eintrag"><span class="register-begriff">CVRPTW</span> — <a href="graphen.html#sec:graphen-das-vehicle-routing-problem-mit-zeitfenstern">Kapitel 8: Graphen, Flüsse und Touren — Min-Cost-Flow, Matching und VRP</a></div><div class="register-eintrag"><span class="register-begriff">CVXPY</span> — <a href="anhang-glossar-literatur.html#anhang-glossar-literatur">Anhang E: Glossar und Literatur</a>, <a href="oekosystem.html#sec:oekosystem-die-zwei-schichten-architektur">Kapitel 3: Das Python-Ökosystem für OR — Solver, Bindings und Modellierungsschichten</a>, <a href="qp-nlp.html#sec:qp-nlp-nichtlineare-optimierung-mit-scipy-optimize-minimize">Kapitel 11: Quadratische und nichtlineare Optimierung — KKT, Lagrange, Konvexität</a></div><h2 class="register-buchstabe" id="buchstabe-D">D</h2><div class="register-eintrag"><span class="register-begriff">Dantzig, George</span> — <a href="einfuehrung.html#sec:einfuehrung-historischer-kontext-und-evolution">Kapitel 1: Einführung in Operations Research — Vom Ursprung zur mathematischen Entscheidungsfindung</a>, <a href="lp.html#sec:lp-der-simplex-algorithmus-schritt-fuer-schritt">Kapitel 5: Lineare Programmierung — Simplex, Dualität und Schattenpreise</a></div><div class="register-eintrag"><span class="register-begriff">Data Snooping</span> — <a href="handelsmaschine.html#sec:handelsmaschine-die-fuenf-selbsttaeuschungen-des-backtestens">Kapitel 21: Die vollständige quantitative Handelsmaschine</a></div><div class="register-eintrag"><span class="register-begriff">DCPError</span> — <a href="anhang-fehlerdiagnose.html#anhang-fehlerdiagnose">Anhang C: Fehlerdiagnose-Handbuch</a></div><div class="register-eintrag"><span class="register-begriff">Deletion Filter</span> — <a href="anhang-fehlerdiagnose.html#anhang-fehlerdiagnose">Anhang C: Fehlerdiagnose-Handbuch</a></div><div class="register-eintrag"><span class="register-begriff">Diskrete Rendite</span> — <a href="finanzdaten.html#sec:finanzdaten-diskrete-und-logarithmische-renditen">Kapitel 18: Finanzdaten-Modellierung — Renditen, Kovarianz und Shrinkage</a></div><div class="register-eintrag"><span class="register-begriff">Diversifikation</span> — <a href="markowitz.html#sec:markowitz-warum-diversifikation-funktioniert">Kapitel 19: Die moderne Portfoliotheorie nach Markowitz</a></div><div class="register-eintrag"><span class="register-begriff">Dual Simplex</span> — <a href="oekosystem.html#sec:oekosystem-die-zwei-schichten-architektur">Kapitel 3: Das Python-Ökosystem für OR — Solver, Bindings und Modellierungsschichten</a></div><div class="register-eintrag"><span class="register-begriff">Duales Problem</span> — <a href="lp.html#sec:lp-dualitaet-und-schattenpreise">Kapitel 5: Lineare Programmierung — Simplex, Dualität und Schattenpreise</a></div><div class="register-eintrag"><span class="register-begriff">Dualitätstheorie</span> — <a href="anhang-glossar-literatur.html#anhang-glossar-literatur">Anhang E: Glossar und Literatur</a></div><div class="register-eintrag"><span class="register-begriff">Dynamische Programmierung</span> — <a href="anhang-glossar-literatur.html#anhang-glossar-literatur">Anhang E: Glossar und Literatur</a>, <a href="dynamische-programmierung.html#sec:dynamische-programmierung-das-bellmansche-optimalitaetsprinzip">Kapitel 13: Dynamische Programmierung — Die Bellman-Gleichung und Order-Execution</a><ul class="register-unter"><li>Approximate Dynamic Programming — <a href="dynamische-programmierung.html#sec:dynamische-programmierung-der-fluch-der-dimensionalitaet">Kapitel 13: Dynamische Programmierung — Die Bellman-Gleichung und Order-Execution</a></li></ul></div><h2 class="register-buchstabe" id="buchstabe-E">E</h2><div class="register-eintrag"><span class="register-begriff">Ecke (Extrempunkt)</span> — <a href="fundament.html#sec:fundament-der-zulaessige-loesungsraum-und-das-polyeder">Kapitel 2: Das mathematische Fundament — Vektoren, Matrizen, Konvexität</a></div><div class="register-eintrag"><span class="register-begriff">Effizienzgrenze</span> — <a href="anhang-glossar-literatur.html#anhang-glossar-literatur">Anhang E: Glossar und Literatur</a>, <a href="markowitz.html#sec:markowitz-das-mean-variance-modell">Kapitel 19: Die moderne Portfoliotheorie nach Markowitz</a></div><div class="register-eintrag"><span class="register-begriff">Entartung</span> — <a href="lp.html#sec:lp-entartung">Kapitel 5: Lineare Programmierung — Simplex, Dualität und Schattenpreise</a><ul class="register-unter"><li>und Dualwerte — <a href="anhang-fehlerdiagnose.html#anhang-fehlerdiagnose">Anhang C: Fehlerdiagnose-Handbuch</a></li></ul></div><div class="register-eintrag"><span class="register-begriff">Entscheidungsvariable</span> — <a href="anhang-glossar-literatur.html#anhang-glossar-literatur">Anhang E: Glossar und Literatur</a>, <a href="einfuehrung.html#sec:einfuehrung-die-vier-universellen-bausteine-jedes-or">Kapitel 1: Einführung in Operations Research — Vom Ursprung zur mathematischen Entscheidungsfindung</a></div><div class="register-eintrag"><span class="register-begriff">Entscheidungsvektor</span> — <a href="fundament.html#sec:fundament-warum-ueberhaupt-vektoren-und-matrizen">Kapitel 2: Das mathematische Fundament — Vektoren, Matrizen, Konvexität</a></div><div class="register-eintrag"><span class="register-begriff">Entweder-Oder-Bedingung</span> — <a href="anhang-modellierungsmuster.html#anhang-modellierungsmuster">Anhang B: Katalog der Modellierungsmuster</a></div><div class="register-eintrag"><span class="register-begriff">Error-Maximizer-Effekt</span> — <a href="anhang-glossar-literatur.html#anhang-glossar-literatur">Anhang E: Glossar und Literatur</a>, <a href="finanzdaten.html#sec:finanzdaten-lernziele">Kapitel 18: Finanzdaten-Modellierung — Renditen, Kovarianz und Shrinkage</a></div><div class="register-eintrag"><span class="register-begriff">EVPI</span> — <a href="anhang-glossar-literatur.html#anhang-glossar-literatur">Anhang E: Glossar und Literatur</a>, <a href="unsicherheit.html#sec:unsicherheit-zweistufige-stochastische-programmierung">Kapitel 12: Optimierung unter Unsicherheit — Monte-Carlo, Stochastik, Robustheit</a></div><div class="register-eintrag"><span class="register-begriff">Exklusiv-Oder</span> — <a href="anhang-modellierungsmuster.html#anhang-modellierungsmuster">Anhang B: Katalog der Modellierungsmuster</a></div><div class="register-eintrag"><span class="register-begriff">Expected Shortfall</span> — <a href="cvar.html#sec:cvar-value-at-risk-und-conditional-value">Kapitel 20: Tail-Risiko, CVaR und Transaktionskosten</a></div><div class="register-eintrag"><span class="register-begriff">Explainable OR</span> — <a href="anhang-glossar-literatur.html#anhang-glossar-literatur">Anhang E: Glossar und Literatur</a></div><h2 class="register-buchstabe" id="buchstabe-F">F</h2><div class="register-eintrag"><span class="register-begriff">Fallback-Strategie</span> — <a href="praxisfallen.html#sec:praxisfallen-architektur-einer-produktionsreifen-or-plattform">Kapitel 22: Praxisfallen und der Weg zum produktiven Einsatz</a></div><div class="register-eintrag"><span class="register-begriff">Falsche Dualwerte (Fehlerbild)</span> — <a href="anhang-fehlerdiagnose.html#anhang-fehlerdiagnose">Anhang C: Fehlerdiagnose-Handbuch</a></div><div class="register-eintrag"><span class="register-begriff">Fat Tails</span> — <a href="anhang-glossar-literatur.html#anhang-glossar-literatur">Anhang E: Glossar und Literatur</a>, <a href="cvar.html#sec:cvar-die-zwei-schwaechen-des-markowitz-modells">Kapitel 20: Tail-Risiko, CVaR und Transaktionskosten</a></div><div class="register-eintrag"><span class="register-begriff">Fluch der Dimensionalität</span> — <a href="anhang-glossar-literatur.html#anhang-glossar-literatur">Anhang E: Glossar und Literatur</a>, <a href="dynamische-programmierung.html#sec:dynamische-programmierung-der-fluch-der-dimensionalitaet">Kapitel 13: Dynamische Programmierung — Die Bellman-Gleichung und Order-Execution</a></div><div class="register-eintrag"><span class="register-begriff">Fluch des Durchschnitts</span> — <a href="unsicherheit.html#sec:unsicherheit-lernziele">Kapitel 12: Optimierung unter Unsicherheit — Monte-Carlo, Stochastik, Robustheit</a></div><div class="register-eintrag"><span class="register-begriff">Flusserhaltung</span> — <a href="anhang-glossar-literatur.html#anhang-glossar-literatur">Anhang E: Glossar und Literatur</a>, <a href="anhang-modellierungsmuster.html#anhang-modellierungsmuster">Anhang B: Katalog der Modellierungsmuster</a>, <a href="graphen.html#sec:graphen-lernziele">Kapitel 8: Graphen, Flüsse und Touren — Min-Cost-Flow, Matching und VRP</a></div><div class="register-eintrag"><span class="register-begriff">Fundamentalsatz der linearen Optimierung</span> — <a href="anhang-glossar-literatur.html#anhang-glossar-literatur">Anhang E: Glossar und Literatur</a>, <a href="fundament.html#sec:fundament-der-zulaessige-loesungsraum-und-das-polyeder">Kapitel 2: Das mathematische Fundament — Vektoren, Matrizen, Konvexität</a></div><h2 class="register-buchstabe" id="buchstabe-G">G</h2><div class="register-eintrag"><span class="register-begriff">Genetischer Algorithmus</span> — <a href="metaheuristiken.html#sec:metaheuristiken-abgrenzung">Kapitel 9: Metaheuristiken — wenn der exakte Solver aussteigt</a></div><div class="register-eintrag"><span class="register-begriff">Gestaffelte Preise (stückweise linear)</span> — <a href="anhang-modellierungsmuster.html#anhang-modellierungsmuster">Anhang B: Katalog der Modellierungsmuster</a></div><div class="register-eintrag"><span class="register-begriff">Gini-Koeffizient</span> — <a href="projektwerkstatt.html">Projektwerkstatt</a></div><div class="register-eintrag"><span class="register-begriff">Gleitendes Fenster</span> — <a href="anhang-modellierungsmuster.html#anhang-modellierungsmuster">Anhang B: Katalog der Modellierungsmuster</a></div><div class="register-eintrag"><span class="register-begriff">Globale Constraints</span> — <a href="anhang-glossar-literatur.html#anhang-glossar-literatur">Anhang E: Glossar und Literatur</a>, <a href="cpsat.html#sec:cpsat-globale-constraints-die-bausteine-von-cp">Kapitel 7: Constraint Programming mit CP-SAT — Logik, Scheduling und Zuweisung</a><ul class="register-unter"><li>AddAllDifferent — <a href="cpsat.html#sec:cpsat-zusammenfassung">Kapitel 7: Constraint Programming mit CP-SAT — Logik, Scheduling und Zuweisung</a></li><li>AddCumulative — <a href="cpsat.html#sec:cpsat-zusammenfassung">Kapitel 7: Constraint Programming mit CP-SAT — Logik, Scheduling und Zuweisung</a></li><li>AddNoOverlap — <a href="cpsat.html#sec:cpsat-zusammenfassung">Kapitel 7: Constraint Programming mit CP-SAT — Logik, Scheduling und Zuweisung</a></li></ul></div><div class="register-eintrag"><span class="register-begriff">Globales Minimum</span> — <a href="fundament.html#sec:fundament-konvexitaet-die-grenze-zwischen-leicht-und">Kapitel 2: Das mathematische Fundament — Vektoren, Matrizen, Konvexität</a></div><div class="register-eintrag"><span class="register-begriff">GMV (Global Minimum Variance)</span> — <a href="anhang-glossar-literatur.html#anhang-glossar-literatur">Anhang E: Glossar und Literatur</a>, <a href="markowitz.html#sec:markowitz-zusammenfassung">Kapitel 19: Die moderne Portfoliotheorie nach Markowitz</a></div><div class="register-eintrag"><span class="register-begriff">Goldene Regel des Backtestens</span> — <a href="handelsmaschine.html#sec:handelsmaschine-zusammenfassung">Kapitel 21: Die vollständige quantitative Handelsmaschine</a></div><div class="register-eintrag"><span class="register-begriff">Gradient</span> — <a href="qp-nlp.html#sec:qp-nlp-lernziele">Kapitel 11: Quadratische und nichtlineare Optimierung — KKT, Lagrange, Konvexität</a></div><div class="register-eintrag"><span class="register-begriff">Gurobi</span> — <a href="milp.html#sec:milp-branch-and-bound">Kapitel 6: Gemischt-ganzzahlige Optimierung — Diskrete Entscheidungen und Branch-and-Bound</a></div><h2 class="register-buchstabe" id="buchstabe-H">H</h2><div class="register-eintrag"><span class="register-begriff">Herfindahl-Index</span> — <a href="projektwerkstatt.html">Projektwerkstatt</a></div><div class="register-eintrag"><span class="register-begriff">Hierarchische Relaxation</span> — <a href="praxisfallen.html#sec:praxisfallen-die-fuenf-typischen-praxisfallen">Kapitel 22: Praxisfallen und der Weg zum produktiven Einsatz</a></div><div class="register-eintrag"><span class="register-begriff">HiGHS</span> — <a href="anhang-glossar-literatur.html#anhang-glossar-literatur">Anhang E: Glossar und Literatur</a>, <a href="milp.html#sec:milp-branch-and-bound">Kapitel 6: Gemischt-ganzzahlige Optimierung — Diskrete Entscheidungen und Branch-and-Bound</a></div><h2 class="register-buchstabe" id="buchstabe-I">I</h2><div class="register-eintrag"><span class="register-begriff">IIS (Irreducible Infeasible Subset)</span> — <a href="anhang-fehlerdiagnose.html#anhang-fehlerdiagnose">Anhang C: Fehlerdiagnose-Handbuch</a></div><div class="register-eintrag"><span class="register-begriff">Implikation (Modellierungsmuster)</span> — <a href="anhang-modellierungsmuster.html#anhang-modellierungsmuster">Anhang B: Katalog der Modellierungsmuster</a></div><div class="register-eintrag"><span class="register-begriff">Importfehler (ortools und highspy)</span> — <a href="anhang-fehlerdiagnose.html#anhang-fehlerdiagnose">Anhang C: Fehlerdiagnose-Handbuch</a></div><div class="register-eintrag"><span class="register-begriff">Infeasibility</span> — <a href="anhang-fehlerdiagnose.html#anhang-fehlerdiagnose">Anhang C: Fehlerdiagnose-Handbuch</a>, <a href="anhang-glossar-literatur.html#anhang-glossar-literatur">Anhang E: Glossar und Literatur</a>, <a href="einfuehrung.html#sec:einfuehrung-die-vier-universellen-bausteine-jedes-or">Kapitel 1: Einführung in Operations Research — Vom Ursprung zur mathematischen Entscheidungsfindung</a></div><div class="register-eintrag"><span class="register-begriff">Instabile Lösung (Fehlerbild)</span> — <a href="anhang-fehlerdiagnose.html#anhang-fehlerdiagnose">Anhang C: Fehlerdiagnose-Handbuch</a></div><div class="register-eintrag"><span class="register-begriff">Interior-Point-Verfahren</span> — <a href="oekosystem.html#sec:oekosystem-die-zwei-schichten-architektur">Kapitel 3: Das Python-Ökosystem für OR — Solver, Bindings und Modellierungsschichten</a></div><div class="register-eintrag"><span class="register-begriff">Intervallvariable</span> — <a href="anhang-glossar-literatur.html#anhang-glossar-literatur">Anhang E: Glossar und Literatur</a>, <a href="cpsat.html#sec:cpsat-lernziele">Kapitel 7: Constraint Programming mit CP-SAT — Logik, Scheduling und Zuweisung</a></div><h2 class="register-buchstabe" id="buchstabe-J">J</h2><div class="register-eintrag"><span class="register-begriff">Jensensche Ungleichung</span> — <a href="anhang-glossar-literatur.html#anhang-glossar-literatur">Anhang E: Glossar und Literatur</a>, <a href="unsicherheit.html#sec:unsicherheit-der-fluch-des-durchschnitts">Kapitel 12: Optimierung unter Unsicherheit — Monte-Carlo, Stochastik, Robustheit</a></div><div class="register-eintrag"><span class="register-begriff">Job-Shop-Scheduling</span> — <a href="cpsat.html#sec:cpsat-intervallvariablen-job-shop-scheduling">Kapitel 7: Constraint Programming mit CP-SAT — Logik, Scheduling und Zuweisung</a></div><h2 class="register-buchstabe" id="buchstabe-K">K</h2><div class="register-eintrag"><span class="register-begriff">Kanonische Standardform</span> — <a href="anhang-glossar-literatur.html#anhang-glossar-literatur">Anhang E: Glossar und Literatur</a></div><div class="register-eintrag"><span class="register-begriff">Kapazitätsvektor</span> — <a href="fundament.html#sec:fundament-warum-ueberhaupt-vektoren-und-matrizen">Kapitel 2: Das mathematische Fundament — Vektoren, Matrizen, Konvexität</a></div><div class="register-eintrag"><span class="register-begriff">Kardinalitätsbeschränkung</span> — <a href="anhang-glossar-literatur.html#anhang-glossar-literatur">Anhang E: Glossar und Literatur</a>, <a href="anhang-modellierungsmuster.html#anhang-modellierungsmuster">Anhang B: Katalog der Modellierungsmuster</a>, <a href="milp.html#sec:milp-praxisfall-portfolio-mit-ordergebuehren-und-kardinalitaetsgrenze">Kapitel 6: Gemischt-ganzzahlige Optimierung — Diskrete Entscheidungen und Branch-and-Bound</a></div><div class="register-eintrag"><span class="register-begriff">KKT-Bedingungen</span> — <a href="anhang-glossar-literatur.html#anhang-glossar-literatur">Anhang E: Glossar und Literatur</a>, <a href="qp-nlp.html#sec:qp-nlp-die-karush-kuhn-tucker-bedingungen">Kapitel 11: Quadratische und nichtlineare Optimierung — KKT, Lagrange, Konvexität</a></div><div class="register-eintrag"><span class="register-begriff">Kohärentes Risikomaß</span> — <a href="anhang-glossar-literatur.html#anhang-glossar-literatur">Anhang E: Glossar und Literatur</a></div><div class="register-eintrag"><span class="register-begriff">Kombinatorische Explosion</span> — <a href="anhang-glossar-literatur.html#anhang-glossar-literatur">Anhang E: Glossar und Literatur</a>, <a href="einfuehrung.html#sec:einfuehrung-zusammenfassung">Kapitel 1: Einführung in Operations Research — Vom Ursprung zur mathematischen Entscheidungsfindung</a></div><div class="register-eintrag"><span class="register-begriff">Komplementärer Schlupf</span> — <a href="anhang-glossar-literatur.html#anhang-glossar-literatur">Anhang E: Glossar und Literatur</a>, <a href="lp.html#sec:lp-dualitaet-und-schattenpreise">Kapitel 5: Lineare Programmierung — Simplex, Dualität und Schattenpreise</a>, <a href="qp-nlp.html#sec:qp-nlp-die-karush-kuhn-tucker-bedingungen">Kapitel 11: Quadratische und nichtlineare Optimierung — KKT, Lagrange, Konvexität</a></div><div class="register-eintrag"><span class="register-begriff">Konditionszahl</span> — <a href="anhang-fehlerdiagnose.html#anhang-fehlerdiagnose">Anhang C: Fehlerdiagnose-Handbuch</a>, <a href="anhang-glossar-literatur.html#anhang-glossar-literatur">Anhang E: Glossar und Literatur</a>, <a href="fundament.html#sec:fundament-kondition">Kapitel 2: Das mathematische Fundament — Vektoren, Matrizen, Konvexität</a></div><div class="register-eintrag"><span class="register-begriff">Konische Optimierung (SOCP, SDP)</span> — <a href="praxisfallen.html#sec:praxisfallen-weiterfuehrende-literatur-und-roadmap">Kapitel 22: Praxisfallen und der Weg zum produktiven Einsatz</a>, <a href="unsicherheit.html#sec:unsicherheit-chance-constraints">Kapitel 12: Optimierung unter Unsicherheit — Monte-Carlo, Stochastik, Robustheit</a></div><div class="register-eintrag"><span class="register-begriff">Konvexität</span> — <a href="anhang-glossar-literatur.html#anhang-glossar-literatur">Anhang E: Glossar und Literatur</a>, <a href="fundament.html#sec:fundament-konvexitaet-die-grenze-zwischen-leicht-und">Kapitel 2: Das mathematische Fundament — Vektoren, Matrizen, Konvexität</a>, <a href="qp-nlp.html#sec:qp-nlp-lernziele">Kapitel 11: Quadratische und nichtlineare Optimierung — KKT, Lagrange, Konvexität</a><ul class="register-unter"><li>Funktion — <a href="fundament.html#sec:fundament-konvexitaet-die-grenze-zwischen-leicht-und">Kapitel 2: Das mathematische Fundament — Vektoren, Matrizen, Konvexität</a></li><li>Menge — <a href="fundament.html#sec:fundament-konvexitaet-die-grenze-zwischen-leicht-und">Kapitel 2: Das mathematische Fundament — Vektoren, Matrizen, Konvexität</a></li><li>streng konvex — <a href="qp-nlp.html#sec:qp-nlp-lernziele">Kapitel 11: Quadratische und nichtlineare Optimierung — KKT, Lagrange, Konvexität</a></li></ul></div><div class="register-eintrag"><span class="register-begriff">Korn-Transformation</span> — <a href="anhang-glossar-literatur.html#anhang-glossar-literatur">Anhang E: Glossar und Literatur</a>, <a href="markowitz.html#sec:markowitz-lernziele">Kapitel 19: Die moderne Portfoliotheorie nach Markowitz</a></div><div class="register-eintrag"><span class="register-begriff">Kostenzerlegung</span> — <a href="praxisfallen.html#sec:praxisfallen-die-fuenf-typischen-praxisfallen">Kapitel 22: Praxisfallen und der Weg zum produktiven Einsatz</a></div><div class="register-eintrag"><span class="register-begriff">Kovarianzmatrix</span> — <a href="anhang-glossar-literatur.html#anhang-glossar-literatur">Anhang E: Glossar und Literatur</a>, <a href="qp-nlp.html#sec:qp-nlp-lernziele">Kapitel 11: Quadratische und nichtlineare Optimierung — KKT, Lagrange, Konvexität</a></div><div class="register-eintrag"><span class="register-begriff">Kumulative Ressource</span> — <a href="anhang-modellierungsmuster.html#anhang-modellierungsmuster">Anhang B: Katalog der Modellierungsmuster</a></div><h2 class="register-buchstabe" id="buchstabe-L">L</h2><div class="register-eintrag"><span class="register-begriff">Lagrange-Funktion</span> — <a href="qp-nlp.html#sec:qp-nlp-die-karush-kuhn-tucker-bedingungen">Kapitel 11: Quadratische und nichtlineare Optimierung — KKT, Lagrange, Konvexität</a></div><div class="register-eintrag"><span class="register-begriff">Lagrange-Multiplikator</span> — <a href="anhang-glossar-literatur.html#anhang-glossar-literatur">Anhang E: Glossar und Literatur</a></div><div class="register-eintrag"><span class="register-begriff">Large Neighborhood Search</span> — <a href="metaheuristiken.html#sec:metaheuristiken-lns">Kapitel 9: Metaheuristiken — wenn der exakte Solver aussteigt</a></div><div class="register-eintrag"><span class="register-begriff">Laufzeitexplosion (Fehlerbild)</span> — <a href="anhang-fehlerdiagnose.html#anhang-fehlerdiagnose">Anhang C: Fehlerdiagnose-Handbuch</a></div><div class="register-eintrag"><span class="register-begriff">Ledoit-Wolf-Shrinkage</span> — <a href="anhang-glossar-literatur.html#anhang-glossar-literatur">Anhang E: Glossar und Literatur</a>, <a href="finanzdaten.html#sec:finanzdaten-ledoit-wolf-shrinkage">Kapitel 18: Finanzdaten-Modellierung — Renditen, Kovarianz und Shrinkage</a></div><div class="register-eintrag"><span class="register-begriff">Lexikografische Optimierung</span> — <a href="anhang-modellierungsmuster.html#anhang-modellierungsmuster">Anhang B: Katalog der Modellierungsmuster</a>, <a href="mehrziel.html#sec:mehrziel-epsilon">Kapitel 14: Mehrere Ziele — Pareto-Fronten statt Gewichte</a></div><div class="register-eintrag"><span class="register-begriff">Lineare Programmierung (LP)</span> — <a href="anhang-glossar-literatur.html#anhang-glossar-literatur">Anhang E: Glossar und Literatur</a></div><div class="register-eintrag"><span class="register-begriff">Linopy</span> — <a href="oekosystem.html#sec:oekosystem-pyomo-linopy">Kapitel 3: Das Python-Ökosystem für OR — Solver, Bindings und Modellierungsschichten</a></div><div class="register-eintrag"><span class="register-begriff">linprog</span> — <a href="lp.html#sec:lp-die-vorzeichenfalle-bei-schattenpreisen">Kapitel 5: Lineare Programmierung — Simplex, Dualität und Schattenpreise</a></div><div class="register-eintrag"><span class="register-begriff">Logarithmische Rendite</span> — <a href="anhang-glossar-literatur.html#anhang-glossar-literatur">Anhang E: Glossar und Literatur</a>, <a href="finanzdaten.html#sec:finanzdaten-diskrete-und-logarithmische-renditen">Kapitel 18: Finanzdaten-Modellierung — Renditen, Kovarianz und Shrinkage</a></div><div class="register-eintrag"><span class="register-begriff">Lokales Minimum</span> — <a href="fundament.html#sec:fundament-konvexitaet-die-grenze-zwischen-leicht-und">Kapitel 2: Das mathematische Fundament — Vektoren, Matrizen, Konvexität</a></div><div class="register-eintrag"><span class="register-begriff">Lookahead-Bias</span> — <a href="anhang-glossar-literatur.html#anhang-glossar-literatur">Anhang E: Glossar und Literatur</a>, <a href="handelsmaschine.html#sec:handelsmaschine-lernziele">Kapitel 21: Die vollständige quantitative Handelsmaschine</a></div><div class="register-eintrag"><span class="register-begriff">LP-Relaxation</span> — <a href="milp.html#sec:milp-branch-and-bound">Kapitel 6: Gemischt-ganzzahlige Optimierung — Diskrete Entscheidungen und Branch-and-Bound</a></div><h2 class="register-buchstabe" id="buchstabe-M">M</h2><div class="register-eintrag"><span class="register-begriff">Makespan</span> — <a href="cpsat.html#sec:cpsat-intervallvariablen-job-shop-scheduling">Kapitel 7: Constraint Programming mit CP-SAT — Logik, Scheduling und Zuweisung</a></div><div class="register-eintrag"><span class="register-begriff">Marchenko-Pastur-Gesetz</span> — <a href="finanzdaten.html#sec:finanzdaten-das-schaetzfehler-problem">Kapitel 18: Finanzdaten-Modellierung — Renditen, Kovarianz und Shrinkage</a></div><div class="register-eintrag"><span class="register-begriff">Markowitz-Modell (Mean-Variance)</span> — <a href="anhang-glossar-literatur.html#anhang-glossar-literatur">Anhang E: Glossar und Literatur</a>, <a href="markowitz.html#sec:markowitz-lernziele">Kapitel 19: Die moderne Portfoliotheorie nach Markowitz</a></div><div class="register-eintrag"><span class="register-begriff">Marktauswirkung</span> — <a href="anhang-glossar-literatur.html#anhang-glossar-literatur">Anhang E: Glossar und Literatur</a>, <a href="dynamische-programmierung.html#sec:dynamische-programmierung-das-almgren-chriss-problem-optimale-orderausfuehrung">Kapitel 13: Dynamische Programmierung — Die Bellman-Gleichung und Order-Execution</a></div><div class="register-eintrag"><span class="register-begriff">Matrix-Vektor-Produkt</span> — <a href="fundament.html#sec:fundament-warum-ueberhaupt-vektoren-und-matrizen">Kapitel 2: Das mathematische Fundament — Vektoren, Matrizen, Konvexität</a></div><div class="register-eintrag"><span class="register-begriff">Matrixform</span> — <a href="fundament.html#sec:fundament-zusammenfassung">Kapitel 2: Das mathematische Fundament — Vektoren, Matrizen, Konvexität</a></div><div class="register-eintrag"><span class="register-begriff">Maximin-Fairness</span> — <a href="anhang-modellierungsmuster.html#anhang-modellierungsmuster">Anhang B: Katalog der Modellierungsmuster</a></div><div class="register-eintrag"><span class="register-begriff">Maximum Drawdown</span> — <a href="anhang-glossar-literatur.html#anhang-glossar-literatur">Anhang E: Glossar und Literatur</a></div><div class="register-eintrag"><span class="register-begriff">Mensch in der Schleife</span> — <a href="praxisfallen.html#sec:praxisfallen-architektur-einer-produktionsreifen-or-plattform">Kapitel 22: Praxisfallen und der Weg zum produktiven Einsatz</a></div><div class="register-eintrag"><span class="register-begriff">Metaheuristik</span> — <a href="metaheuristiken.html#sec:metaheuristiken-aufgabe">Kapitel 9: Metaheuristiken — wenn der exakte Solver aussteigt</a></div><div class="register-eintrag"><span class="register-begriff">MILP</span> — <a href="anhang-glossar-literatur.html#anhang-glossar-literatur">Anhang E: Glossar und Literatur</a>, <a href="milp.html#sec:milp-warum-runden-fundamental-scheitert">Kapitel 6: Gemischt-ganzzahlige Optimierung — Diskrete Entscheidungen und Branch-and-Bound</a></div><div class="register-eintrag"><span class="register-begriff">Min-Cost-Flow</span> — <a href="anhang-glossar-literatur.html#anhang-glossar-literatur">Anhang E: Glossar und Literatur</a>, <a href="graphen.html#sec:graphen-graphen-als-modellsprache">Kapitel 8: Graphen, Flüsse und Touren — Min-Cost-Flow, Matching und VRP</a></div><div class="register-eintrag"><span class="register-begriff">Mindestabnahmemenge</span> — <a href="anhang-modellierungsmuster.html#anhang-modellierungsmuster">Anhang B: Katalog der Modellierungsmuster</a></div><div class="register-eintrag"><span class="register-begriff">MINLP</span> — <a href="qp-nlp.html#sec:qp-nlp-nichtkonvex">Kapitel 11: Quadratische und nichtlineare Optimierung — KKT, Lagrange, Konvexität</a></div><div class="register-eintrag"><span class="register-begriff">MIP-Gap</span> — <a href="anhang-glossar-literatur.html#anhang-glossar-literatur">Anhang E: Glossar und Literatur</a>, <a href="milp.html#sec:milp-gap">Kapitel 6: Gemischt-ganzzahlige Optimierung — Diskrete Entscheidungen und Branch-and-Bound</a>, <a href="milp.html#sec:milp-beispiel-das-rucksackproblem">Kapitel 6: Gemischt-ganzzahlige Optimierung — Diskrete Entscheidungen und Branch-and-Bound</a></div><div class="register-eintrag"><span class="register-begriff">Monte-Carlo-Simulation</span> — <a href="anhang-glossar-literatur.html#anhang-glossar-literatur">Anhang E: Glossar und Literatur</a>, <a href="unsicherheit.html#sec:unsicherheit-monte-carlo-simulation">Kapitel 12: Optimierung unter Unsicherheit — Monte-Carlo, Stochastik, Robustheit</a></div><div class="register-eintrag"><span class="register-begriff">MTZ-Formulierung</span> — <a href="anhang-glossar-literatur.html#anhang-glossar-literatur">Anhang E: Glossar und Literatur</a>, <a href="anhang-modellierungsmuster.html#anhang-modellierungsmuster">Anhang B: Katalog der Modellierungsmuster</a>, <a href="graphen.html#sec:graphen-das-vehicle-routing-problem-mit-zeitfenstern">Kapitel 8: Graphen, Flüsse und Touren — Min-Cost-Flow, Matching und VRP</a></div><div class="register-eintrag"><span class="register-begriff">Multi-Objective Optimization</span> — <a href="praxisfallen.html#sec:praxisfallen-weiterfuehrende-literatur-und-roadmap">Kapitel 22: Praxisfallen und der Weg zum produktiven Einsatz</a></div><h2 class="register-buchstabe" id="buchstabe-N">N</h2><div class="register-eintrag"><span class="register-begriff">Nebenbedingung</span> — <a href="anhang-glossar-literatur.html#anhang-glossar-literatur">Anhang E: Glossar und Literatur</a>, <a href="einfuehrung.html#sec:einfuehrung-die-vier-universellen-bausteine-jedes-or">Kapitel 1: Einführung in Operations Research — Vom Ursprung zur mathematischen Entscheidungsfindung</a><ul class="register-unter"><li>hart — <a href="einfuehrung.html#sec:einfuehrung-die-vier-universellen-bausteine-jedes-or">Kapitel 1: Einführung in Operations Research — Vom Ursprung zur mathematischen Entscheidungsfindung</a></li><li>weich — <a href="einfuehrung.html#sec:einfuehrung-die-vier-universellen-bausteine-jedes-or">Kapitel 1: Einführung in Operations Research — Vom Ursprung zur mathematischen Entscheidungsfindung</a></li></ul></div><div class="register-eintrag"><span class="register-begriff">Newsvendor-Problem</span> — <a href="unsicherheit.html#sec:unsicherheit-schnellstart">Kapitel 12: Optimierung unter Unsicherheit — Monte-Carlo, Stochastik, Robustheit</a></div><div class="register-eintrag"><span class="register-begriff">Nichtlineare Programmierung (NLP)</span> — <a href="anhang-glossar-literatur.html#anhang-glossar-literatur">Anhang E: Glossar und Literatur</a></div><div class="register-eintrag"><span class="register-begriff">Nichtüberlappung</span> — <a href="anhang-modellierungsmuster.html#anhang-modellierungsmuster">Anhang B: Katalog der Modellierungsmuster</a></div><div class="register-eintrag"><span class="register-begriff">NP-schwer</span> — <a href="milp.html#sec:milp-branch-and-bound">Kapitel 6: Gemischt-ganzzahlige Optimierung — Diskrete Entscheidungen und Branch-and-Bound</a></div><h2 class="register-buchstabe" id="buchstabe-O">O</h2><div class="register-eintrag"><span class="register-begriff">Operations Research</span> — <a href="anhang-glossar-literatur.html#anhang-glossar-literatur">Anhang E: Glossar und Literatur</a>, <a href="einfuehrung.html#sec:einfuehrung-was-ist-operations-research-wirklich">Kapitel 1: Einführung in Operations Research — Vom Ursprung zur mathematischen Entscheidungsfindung</a></div><div class="register-eintrag"><span class="register-begriff">Optimalitätsprinzip</span> — <a href="anhang-glossar-literatur.html#anhang-glossar-literatur">Anhang E: Glossar und Literatur</a>, <a href="dynamische-programmierung.html#sec:dynamische-programmierung-lernziele">Kapitel 13: Dynamische Programmierung — Die Bellman-Gleichung und Order-Execution</a></div><div class="register-eintrag"><span class="register-begriff">OR-Tools</span> — <a href="einfuehrung.html#sec:einfuehrung-lernziele">Kapitel 1: Einführung in Operations Research — Vom Ursprung zur mathematischen Entscheidungsfindung</a></div><div class="register-eintrag"><span class="register-begriff">Overfitting</span> — <a href="handelsmaschine.html#sec:handelsmaschine-die-fuenf-selbsttaeuschungen-des-backtestens">Kapitel 21: Die vollständige quantitative Handelsmaschine</a></div><h2 class="register-buchstabe" id="buchstabe-P">P</h2><div class="register-eintrag"><span class="register-begriff">Parameter (Modell)</span> — <a href="einfuehrung.html#sec:einfuehrung-die-vier-universellen-bausteine-jedes-or">Kapitel 1: Einführung in Operations Research — Vom Ursprung zur mathematischen Entscheidungsfindung</a></div><div class="register-eintrag"><span class="register-begriff">Pareto-Front</span> — <a href="mehrziel.html#sec:mehrziel-dominanz">Kapitel 14: Mehrere Ziele — Pareto-Fronten statt Gewichte</a></div><div class="register-eintrag"><span class="register-begriff">Pivotisierung</span> — <a href="anhang-glossar-literatur.html#anhang-glossar-literatur">Anhang E: Glossar und Literatur</a></div><div class="register-eintrag"><span class="register-begriff">Polars</span> — <a href="oekosystem.html#sec:oekosystem-vektorisierung">Kapitel 3: Das Python-Ökosystem für OR — Solver, Bindings und Modellierungsschichten</a></div><div class="register-eintrag"><span class="register-begriff">Polyeder</span> — <a href="anhang-glossar-literatur.html#anhang-glossar-literatur">Anhang E: Glossar und Literatur</a>, <a href="fundament.html#sec:fundament-der-zulaessige-loesungsraum-und-das-polyeder">Kapitel 2: Das mathematische Fundament — Vektoren, Matrizen, Konvexität</a></div><div class="register-eintrag"><span class="register-begriff">Positiv (semi-)definit</span> — <a href="anhang-glossar-literatur.html#anhang-glossar-literatur">Anhang E: Glossar und Literatur</a></div><div class="register-eintrag"><span class="register-begriff">Präskriptive Analytik</span> — <a href="anhang-glossar-literatur.html#anhang-glossar-literatur">Anhang E: Glossar und Literatur</a>, <a href="einfuehrung.html#sec:einfuehrung-was-ist-operations-research-wirklich">Kapitel 1: Einführung in Operations Research — Vom Ursprung zur mathematischen Entscheidungsfindung</a></div><div class="register-eintrag"><span class="register-begriff">Predict-then-Optimize</span> — <a href="prognose.html#sec:prognose-naht">Kapitel 15: Predict-then-Optimize — die bessere Prognose, die schlechtere Entscheidung</a></div><div class="register-eintrag"><span class="register-begriff">Primales Problem</span> — <a href="lp.html#sec:lp-dualitaet-und-schattenpreise">Kapitel 5: Lineare Programmierung — Simplex, Dualität und Schattenpreise</a></div><div class="register-eintrag"><span class="register-begriff">Pyomo</span> — <a href="oekosystem.html#sec:oekosystem-pyomo-linopy">Kapitel 3: Das Python-Ökosystem für OR — Solver, Bindings und Modellierungsschichten</a></div><h2 class="register-buchstabe" id="buchstabe-Q">Q</h2><div class="register-eintrag"><span class="register-begriff">Q-Learning</span> — <a href="dynamische-programmierung.html#sec:dynamische-programmierung-der-fluch-der-dimensionalitaet">Kapitel 13: Dynamische Programmierung — Die Bellman-Gleichung und Order-Execution</a></div><div class="register-eintrag"><span class="register-begriff">Quadratische Programmierung (QP)</span> — <a href="anhang-glossar-literatur.html#anhang-glossar-literatur">Anhang E: Glossar und Literatur</a>, <a href="qp-nlp.html#sec:qp-nlp-das-quadratische-programm-qp">Kapitel 11: Quadratische und nichtlineare Optimierung — KKT, Lagrange, Konvexität</a></div><h2 class="register-buchstabe" id="buchstabe-R">R</h2><div class="register-eintrag"><span class="register-begriff">Rebalancing</span> — <a href="anhang-glossar-literatur.html#anhang-glossar-literatur">Anhang E: Glossar und Literatur</a></div><div class="register-eintrag"><span class="register-begriff">Regime-Shift</span> — <a href="anhang-glossar-literatur.html#anhang-glossar-literatur">Anhang E: Glossar und Literatur</a></div><div class="register-eintrag"><span class="register-begriff">Reinforcement Learning</span> — <a href="dynamische-programmierung.html#sec:dynamische-programmierung-der-fluch-der-dimensionalitaet">Kapitel 13: Dynamische Programmierung — Die Bellman-Gleichung und Order-Execution</a></div><div class="register-eintrag"><span class="register-begriff">Relaxation</span> — <a href="anhang-glossar-literatur.html#anhang-glossar-literatur">Anhang E: Glossar und Literatur</a></div><div class="register-eintrag"><span class="register-begriff">Robuste Optimierung</span> — <a href="anhang-glossar-literatur.html#anhang-glossar-literatur">Anhang E: Glossar und Literatur</a>, <a href="unsicherheit.html#sec:unsicherheit-robuste-optimierung-gegen-den-worst-case">Kapitel 12: Optimierung unter Unsicherheit — Monte-Carlo, Stochastik, Robustheit</a><ul class="register-unter"><li>Worst-Case-Abzug — <a href="anhang-modellierungsmuster.html#anhang-modellierungsmuster">Anhang B: Katalog der Modellierungsmuster</a></li></ul></div><div class="register-eintrag"><span class="register-begriff">Rockafellar-Uryasev-Theorem</span> — <a href="anhang-glossar-literatur.html#anhang-glossar-literatur">Anhang E: Glossar und Literatur</a>, <a href="cvar.html#sec:cvar-value-at-risk-und-conditional-value">Kapitel 20: Tail-Risiko, CVaR und Transaktionskosten</a></div><div class="register-eintrag"><span class="register-begriff">Routing-Bibliothek</span> — <a href="graphen.html#sec:graphen-zusammenfassung">Kapitel 8: Graphen, Flüsse und Touren — Min-Cost-Flow, Matching und VRP</a></div><div class="register-eintrag"><span class="register-begriff">Rucksackproblem</span> — <a href="anhang-modellierungsmuster.html#anhang-modellierungsmuster">Anhang B: Katalog der Modellierungsmuster</a>, <a href="milp.html#sec:milp-beispiel-das-rucksackproblem">Kapitel 6: Gemischt-ganzzahlige Optimierung — Diskrete Entscheidungen und Branch-and-Bound</a></div><div class="register-eintrag"><span class="register-begriff">Rückwärtsinduktion</span> — <a href="dynamische-programmierung.html#sec:dynamische-programmierung-lernziele">Kapitel 13: Dynamische Programmierung — Die Bellman-Gleichung und Order-Execution</a></div><div class="register-eintrag"><span class="register-begriff">Ruiz-Equilibrierung</span> — <a href="fundament.html#sec:fundament-kondition">Kapitel 2: Das mathematische Fundament — Vektoren, Matrizen, Konvexität</a></div><div class="register-eintrag"><span class="register-begriff">Rüstzeit</span> — <a href="anhang-modellierungsmuster.html#anhang-modellierungsmuster">Anhang B: Katalog der Modellierungsmuster</a></div><h2 class="register-buchstabe" id="buchstabe-S">S</h2><div class="register-eintrag"><span class="register-begriff">SAT (Boolean Satisfiability)</span> — <a href="cpsat.html#sec:cpsat-ein-anderes-denkmodell">Kapitel 7: Constraint Programming mit CP-SAT — Logik, Scheduling und Zuweisung</a></div><div class="register-eintrag"><span class="register-begriff">Satz von Birkhoff und von Neumann</span> — <a href="graphen.html#sec:graphen-bipartites-matching-das-zuordnungsproblem">Kapitel 8: Graphen, Flüsse und Touren — Min-Cost-Flow, Matching und VRP</a></div><div class="register-eintrag"><span class="register-begriff">Schattenpreis</span> — <a href="anhang-glossar-literatur.html#anhang-glossar-literatur">Anhang E: Glossar und Literatur</a>, <a href="lp.html#sec:lp-lernziele">Kapitel 5: Lineare Programmierung — Simplex, Dualität und Schattenpreise</a>, <a href="lp.html#sec:lp-schnellstart">Kapitel 5: Lineare Programmierung — Simplex, Dualität und Schattenpreise</a><ul class="register-unter"><li>Vorzeichenfalle — <a href="lp.html#sec:lp-die-vorzeichenfalle-bei-schattenpreisen">Kapitel 5: Lineare Programmierung — Simplex, Dualität und Schattenpreise</a></li></ul></div><div class="register-eintrag"><span class="register-begriff">Schätzfehler</span> — <a href="anhang-glossar-literatur.html#anhang-glossar-literatur">Anhang E: Glossar und Literatur</a></div><div class="register-eintrag"><span class="register-begriff">Schlupfvariable</span> — <a href="anhang-glossar-literatur.html#anhang-glossar-literatur">Anhang E: Glossar und Literatur</a>, <a href="lp.html#sec:lp-die-standardform-und-schlupfvariablen">Kapitel 5: Lineare Programmierung — Simplex, Dualität und Schattenpreise</a><ul class="register-unter"><li>gegen Unlösbarkeit — <a href="anhang-modellierungsmuster.html#anhang-modellierungsmuster">Anhang B: Katalog der Modellierungsmuster</a></li></ul></div><div class="register-eintrag"><span class="register-begriff">Schnittebenen</span> — <a href="anhang-glossar-literatur.html#anhang-glossar-literatur">Anhang E: Glossar und Literatur</a>, <a href="milp.html#sec:milp-branch-and-bound">Kapitel 6: Gemischt-ganzzahlige Optimierung — Diskrete Entscheidungen und Branch-and-Bound</a><ul class="register-unter"><li>Gomory-Cuts — <a href="milp.html#sec:milp-branch-and-bound">Kapitel 6: Gemischt-ganzzahlige Optimierung — Diskrete Entscheidungen und Branch-and-Bound</a></li></ul></div><div class="register-eintrag"><span class="register-begriff">SCIP</span> — <a href="milp.html#sec:milp-branch-and-bound">Kapitel 6: Gemischt-ganzzahlige Optimierung — Diskrete Entscheidungen und Branch-and-Bound</a></div><div class="register-eintrag"><span class="register-begriff">Semikontinuierliche Variable</span> — <a href="anhang-modellierungsmuster.html#anhang-modellierungsmuster">Anhang B: Katalog der Modellierungsmuster</a>, <a href="milp.html#sec:milp-modellierungstricks-big-m-und-logische-bedingungen">Kapitel 6: Gemischt-ganzzahlige Optimierung — Diskrete Entscheidungen und Branch-and-Bound</a></div><div class="register-eintrag"><span class="register-begriff">Sensitivitätsanalyse</span> — <a href="anhang-glossar-literatur.html#anhang-glossar-literatur">Anhang E: Glossar und Literatur</a>, <a href="lp.html#sec:lp-praxisfall-sensitivitaetsanalyse-mit-korrekten-schattenpreisen">Kapitel 5: Lineare Programmierung — Simplex, Dualität und Schattenpreise</a></div><div class="register-eintrag"><span class="register-begriff">Shannon-Entropie</span> — <a href="qp-nlp.html#sec:qp-nlp-nichtlineare-optimierung-mit-scipy-optimize-minimize">Kapitel 11: Quadratische und nichtlineare Optimierung — KKT, Lagrange, Konvexität</a></div><div class="register-eintrag"><span class="register-begriff">Sharpe-Ratio</span> — <a href="anhang-glossar-literatur.html#anhang-glossar-literatur">Anhang E: Glossar und Literatur</a>, <a href="markowitz.html#sec:markowitz-das-mean-variance-modell">Kapitel 19: Die moderne Portfoliotheorie nach Markowitz</a></div><div class="register-eintrag"><span class="register-begriff">Simplex-Algorithmus</span> — <a href="anhang-glossar-literatur.html#anhang-glossar-literatur">Anhang E: Glossar und Literatur</a>, <a href="einfuehrung.html#sec:einfuehrung-historischer-kontext-und-evolution">Kapitel 1: Einführung in Operations Research — Vom Ursprung zur mathematischen Entscheidungsfindung</a>, <a href="lp.html#sec:lp-der-simplex-algorithmus-schritt-fuer-schritt">Kapitel 5: Lineare Programmierung — Simplex, Dualität und Schattenpreise</a><ul class="register-unter"><li>Dantzig-Regel — <a href="lp.html#sec:lp-der-simplex-algorithmus-schritt-fuer-schritt">Kapitel 5: Lineare Programmierung — Simplex, Dualität und Schattenpreise</a></li><li>Pivotspalte — <a href="lp.html#sec:lp-der-simplex-algorithmus-schritt-fuer-schritt">Kapitel 5: Lineare Programmierung — Simplex, Dualität und Schattenpreise</a></li><li>Pivotzeile — <a href="lp.html#sec:lp-der-simplex-algorithmus-schritt-fuer-schritt">Kapitel 5: Lineare Programmierung — Simplex, Dualität und Schattenpreise</a></li></ul></div><div class="register-eintrag"><span class="register-begriff">Simulated Annealing</span> — <a href="metaheuristiken.html#sec:metaheuristiken-annealing">Kapitel 9: Metaheuristiken — wenn der exakte Solver aussteigt</a></div><div class="register-eintrag"><span class="register-begriff">Skalarisierung</span> — <a href="mehrziel.html#sec:mehrziel-skalarisierung">Kapitel 14: Mehrere Ziele — Pareto-Fronten statt Gewichte</a></div><div class="register-eintrag"><span class="register-begriff">Skalarprodukt</span> — <a href="fundament.html#sec:fundament-warum-ueberhaupt-vektoren-und-matrizen">Kapitel 2: Das mathematische Fundament — Vektoren, Matrizen, Konvexität</a></div><div class="register-eintrag"><span class="register-begriff">SLSQP</span> — <a href="anhang-glossar-literatur.html#anhang-glossar-literatur">Anhang E: Glossar und Literatur</a>, <a href="qp-nlp.html#sec:qp-nlp-nichtlineare-optimierung-mit-scipy-optimize-minimize">Kapitel 11: Quadratische und nichtlineare Optimierung — KKT, Lagrange, Konvexität</a></div><div class="register-eintrag"><span class="register-begriff">Snapshot-Prinzip</span> — <a href="praxisfallen.html#sec:praxisfallen-architektur-einer-produktionsreifen-or-plattform">Kapitel 22: Praxisfallen und der Weg zum produktiven Einsatz</a></div><div class="register-eintrag"><span class="register-begriff">Starker Dualitätssatz</span> — <a href="lp.html#sec:lp-dualitaet-und-schattenpreise">Kapitel 5: Lineare Programmierung — Simplex, Dualität und Schattenpreise</a></div><div class="register-eintrag"><span class="register-begriff">Stichproben-Kovarianzmatrix</span> — <a href="finanzdaten.html#sec:finanzdaten-das-schaetzfehler-problem">Kapitel 18: Finanzdaten-Modellierung — Renditen, Kovarianz und Shrinkage</a></div><div class="register-eintrag"><span class="register-begriff">Stochastische Programmierung</span> — <a href="unsicherheit.html#sec:unsicherheit-zweistufige-stochastische-programmierung">Kapitel 12: Optimierung unter Unsicherheit — Monte-Carlo, Stochastik, Robustheit</a></div><div class="register-eintrag"><span class="register-begriff">Strafkosten</span> — <a href="einfuehrung.html#sec:einfuehrung-die-vier-universellen-bausteine-jedes-or">Kapitel 1: Einführung in Operations Research — Vom Ursprung zur mathematischen Entscheidungsfindung</a></div><div class="register-eintrag"><span class="register-begriff">Subadditivität</span> — <a href="anhang-glossar-literatur.html#anhang-glossar-literatur">Anhang E: Glossar und Literatur</a>, <a href="cvar.html#sec:cvar-value-at-risk-und-conditional-value">Kapitel 20: Tail-Risiko, CVaR und Transaktionskosten</a></div><div class="register-eintrag"><span class="register-begriff">Subtour</span> — <a href="graphen.html#sec:graphen-das-vehicle-routing-problem-mit-zeitfenstern">Kapitel 8: Graphen, Flüsse und Touren — Min-Cost-Flow, Matching und VRP</a><ul class="register-unter"><li>Eliminierung — <a href="anhang-modellierungsmuster.html#anhang-modellierungsmuster">Anhang B: Katalog der Modellierungsmuster</a></li></ul></div><div class="register-eintrag"><span class="register-begriff">Survivorship-Bias</span> — <a href="anhang-glossar-literatur.html#anhang-glossar-literatur">Anhang E: Glossar und Literatur</a>, <a href="handelsmaschine.html#sec:handelsmaschine-die-fuenf-selbsttaeuschungen-des-backtestens">Kapitel 21: Die vollständige quantitative Handelsmaschine</a></div><div class="register-eintrag"><span class="register-begriff">Symmetriebrechung</span> — <a href="anhang-glossar-literatur.html#anhang-glossar-literatur">Anhang E: Glossar und Literatur</a>, <a href="anhang-modellierungsmuster.html#anhang-modellierungsmuster">Anhang B: Katalog der Modellierungsmuster</a></div><h2 class="register-buchstabe" id="buchstabe-T">T</h2><div class="register-eintrag"><span class="register-begriff">Tabu-Suche</span> — <a href="metaheuristiken.html#sec:metaheuristiken-abgrenzung">Kapitel 9: Metaheuristiken — wenn der exakte Solver aussteigt</a></div><div class="register-eintrag"><span class="register-begriff">Tangentialportfolio</span> — <a href="markowitz.html#sec:markowitz-das-mean-variance-modell">Kapitel 19: Die moderne Portfoliotheorie nach Markowitz</a></div><div class="register-eintrag"><span class="register-begriff">Technologiematrix</span> — <a href="fundament.html#sec:fundament-warum-ueberhaupt-vektoren-und-matrizen">Kapitel 2: Das mathematische Fundament — Vektoren, Matrizen, Konvexität</a></div><div class="register-eintrag"><span class="register-begriff">Totale Unimodularität</span> — <a href="anhang-glossar-literatur.html#anhang-glossar-literatur">Anhang E: Glossar und Literatur</a>, <a href="graphen.html#sec:graphen-lernziele">Kapitel 8: Graphen, Flüsse und Touren — Min-Cost-Flow, Matching und VRP</a></div><div class="register-eintrag"><span class="register-begriff">Transaktionskosten</span> — <a href="anhang-glossar-literatur.html#anhang-glossar-literatur">Anhang E: Glossar und Literatur</a></div><div class="register-eintrag"><span class="register-begriff">Trickle Flow</span> — <a href="anhang-loesungen.html#sec:loesungen-milp">Anhang A: Lösungen zu allen Übungsaufgaben</a></div><div class="register-eintrag"><span class="register-begriff">TSP (Traveling Salesperson Problem)</span> — <a href="graphen.html#sec:graphen-das-vehicle-routing-problem-mit-zeitfenstern">Kapitel 8: Graphen, Flüsse und Touren — Min-Cost-Flow, Matching und VRP</a></div><div class="register-eintrag"><span class="register-begriff">Turnover (Umschlag)</span> — <a href="anhang-glossar-literatur.html#anhang-glossar-literatur">Anhang E: Glossar und Literatur</a>, <a href="cvar.html#sec:cvar-transaktionskosten-ueber-die-l-1-norm">Kapitel 20: Tail-Risiko, CVaR und Transaktionskosten</a></div><div class="register-eintrag"><span class="register-begriff">TWAP</span> — <a href="dynamische-programmierung.html#sec:dynamische-programmierung-das-almgren-chriss-problem-optimale-orderausfuehrung">Kapitel 13: Dynamische Programmierung — Die Bellman-Gleichung und Order-Execution</a></div><h2 class="register-buchstabe" id="buchstabe-U">U</h2><div class="register-eintrag"><span class="register-begriff">Umrüstkosten (Modellierungsmuster)</span> — <a href="anhang-modellierungsmuster.html#anhang-modellierungsmuster">Anhang B: Katalog der Modellierungsmuster</a></div><div class="register-eintrag"><span class="register-begriff">Unbounded (Fehlerbild)</span> — <a href="anhang-fehlerdiagnose.html#anhang-fehlerdiagnose">Anhang C: Fehlerdiagnose-Handbuch</a></div><div class="register-eintrag"><span class="register-begriff">Ungarischer Algorithmus</span> — <a href="graphen.html#sec:graphen-zusammenfassung">Kapitel 8: Graphen, Flüsse und Touren — Min-Cost-Flow, Matching und VRP</a></div><div class="register-eintrag"><span class="register-begriff">Unsicherheitsmenge</span> — <a href="anhang-glossar-literatur.html#anhang-glossar-literatur">Anhang E: Glossar und Literatur</a></div><div class="register-eintrag"><span class="register-begriff">Unsinniges Ergebnis (Fehlerbild)</span> — <a href="anhang-fehlerdiagnose.html#anhang-fehlerdiagnose">Anhang C: Fehlerdiagnose-Handbuch</a></div><h2 class="register-buchstabe" id="buchstabe-V">V</h2><div class="register-eintrag"><span class="register-begriff">Value at Risk (VaR)</span> — <a href="anhang-glossar-literatur.html#anhang-glossar-literatur">Anhang E: Glossar und Literatur</a>, <a href="cvar.html#sec:cvar-value-at-risk-und-conditional-value">Kapitel 20: Tail-Risiko, CVaR und Transaktionskosten</a></div><div class="register-eintrag"><span class="register-begriff">Vehicle Routing Problem (VRP)</span> — <a href="anhang-glossar-literatur.html#anhang-glossar-literatur">Anhang E: Glossar und Literatur</a></div><div class="register-eintrag"><span class="register-begriff">Verdächtig guter Backtest (Fehlerbild)</span> — <a href="anhang-fehlerdiagnose.html#anhang-fehlerdiagnose">Anhang C: Fehlerdiagnose-Handbuch</a></div><div class="register-eintrag"><span class="register-begriff">Verhältnis-Bedingung</span> — <a href="anhang-modellierungsmuster.html#anhang-modellierungsmuster">Anhang B: Katalog der Modellierungsmuster</a></div><div class="register-eintrag"><span class="register-begriff">Vertauschte Spalten (Fehlerbild)</span> — <a href="anhang-fehlerdiagnose.html#anhang-fehlerdiagnose">Anhang C: Fehlerdiagnose-Handbuch</a></div><div class="register-eintrag"><span class="register-begriff">Volatilität</span> — <a href="anhang-glossar-literatur.html#anhang-glossar-literatur">Anhang E: Glossar und Literatur</a></div><div class="register-eintrag"><span class="register-begriff">Vorrangbeziehung</span> — <a href="anhang-modellierungsmuster.html#anhang-modellierungsmuster">Anhang B: Katalog der Modellierungsmuster</a></div><h2 class="register-buchstabe" id="buchstabe-W">W</h2><div class="register-eintrag"><span class="register-begriff">Walk-Forward-Backtest</span> — <a href="anhang-glossar-literatur.html#anhang-glossar-literatur">Anhang E: Glossar und Literatur</a>, <a href="handelsmaschine.html#sec:handelsmaschine-lernziele">Kapitel 21: Die vollständige quantitative Handelsmaschine</a></div><div class="register-eintrag"><span class="register-begriff">Warm-Start</span> — <a href="milp.html#sec:milp-gap">Kapitel 6: Gemischt-ganzzahlige Optimierung — Diskrete Entscheidungen und Branch-and-Bound</a></div><div class="register-eintrag"><span class="register-begriff">Weiche Grenze mit Strafkosten</span> — <a href="anhang-modellierungsmuster.html#anhang-modellierungsmuster">Anhang B: Katalog der Modellierungsmuster</a></div><div class="register-eintrag"><span class="register-begriff">Widersprüchliche Solver (Fehlerbild)</span> — <a href="anhang-fehlerdiagnose.html#anhang-fehlerdiagnose">Anhang C: Fehlerdiagnose-Handbuch</a></div><div class="register-eintrag"><span class="register-begriff">Wurzel-Zeit-Regel</span> — <a href="anhang-glossar-literatur.html#anhang-glossar-literatur">Anhang E: Glossar und Literatur</a></div><h2 class="register-buchstabe" id="buchstabe-Z">Z</h2><div class="register-eintrag"><span class="register-begriff">Zielfunktion</span> — <a href="anhang-glossar-literatur.html#anhang-glossar-literatur">Anhang E: Glossar und Literatur</a>, <a href="einfuehrung.html#sec:einfuehrung-die-vier-universellen-bausteine-jedes-or">Kapitel 1: Einführung in Operations Research — Vom Ursprung zur mathematischen Entscheidungsfindung</a></div><div class="register-eintrag"><span class="register-begriff">Zufallsmatrizentheorie</span> — <a href="finanzdaten.html#sec:finanzdaten-das-schaetzfehler-problem">Kapitel 18: Finanzdaten-Modellierung — Renditen, Kovarianz und Shrinkage</a></div><div class="register-eintrag"><span class="register-begriff">Zulässiger Bereich</span> — <a href="anhang-glossar-literatur.html#anhang-glossar-literatur">Anhang E: Glossar und Literatur</a>, <a href="fundament.html#sec:fundament-der-zulaessige-loesungsraum-und-das-polyeder">Kapitel 2: Das mathematische Fundament — Vektoren, Matrizen, Konvexität</a></div><div class="register-eintrag"><span class="register-begriff">Zuordnungsproblem (1:1)</span> — <a href="anhang-modellierungsmuster.html#anhang-modellierungsmuster">Anhang B: Katalog der Modellierungsmuster</a></div><div class="register-eintrag"><span class="register-begriff">Zustandslosigkeit (OR-Plattform)</span> — <a href="praxisfallen.html#sec:praxisfallen-architektur-einer-produktionsreifen-or-plattform">Kapitel 22: Praxisfallen und der Weg zum produktiven Einsatz</a></div><div class="register-eintrag"><span class="register-begriff">Zustandsraum</span> — <a href="dynamische-programmierung.html#sec:dynamische-programmierung-der-fluch-der-dimensionalitaet">Kapitel 13: Dynamische Programmierung — Die Bellman-Gleichung und Order-Execution</a></div><div class="register-eintrag"><span class="register-begriff">Zwei-Phasen-Simplex-Methode</span> — <a href="anhang-loesungen.html#sec:loesungen-lp">Anhang A: Lösungen zu allen Übungsaufgaben</a></div><div class="register-eintrag"><span class="register-begriff">Zweischichtige Architektur</span> — <a href="oekosystem.html#sec:oekosystem-die-zwei-schichten-architektur">Kapitel 3: Das Python-Ökosystem für OR — Solver, Bindings und Modellierungsschichten</a></div>
+    <h1>Stichwortverzeichnis</h1><p>219 Fachbegriffe. Ein Klick führt zum jeweiligen Kapitel/Abschnitt (statt einer im Web bedeutungslosen Seitenzahl wie im gedruckten Register).</p><nav class="register-sprungleiste"><a href="#buchstabe-A">A</a> <a href="#buchstabe-B">B</a> <a href="#buchstabe-C">C</a> <a href="#buchstabe-D">D</a> <a href="#buchstabe-E">E</a> <a href="#buchstabe-F">F</a> <a href="#buchstabe-G">G</a> <a href="#buchstabe-H">H</a> <a href="#buchstabe-I">I</a> <a href="#buchstabe-J">J</a> <a href="#buchstabe-K">K</a> <a href="#buchstabe-L">L</a> <a href="#buchstabe-M">M</a> <a href="#buchstabe-N">N</a> <a href="#buchstabe-O">O</a> <a href="#buchstabe-P">P</a> <a href="#buchstabe-Q">Q</a> <a href="#buchstabe-R">R</a> <a href="#buchstabe-S">S</a> <a href="#buchstabe-T">T</a> <a href="#buchstabe-U">U</a> <a href="#buchstabe-V">V</a> <a href="#buchstabe-W">W</a> <a href="#buchstabe-Z">Z</a></nav><h2 class="register-buchstabe" id="buchstabe-A">A</h2><div class="register-eintrag"><span class="register-begriff">Absolutbetrag (Modellierungsmuster)</span> — <a href="anhang-modellierungsmuster.html#anhang-modellierungsmuster">Anhang B: Katalog der Modellierungsmuster</a></div><div class="register-eintrag"><span class="register-begriff">Adjusted Close</span> — <a href="finanzdaten.html#sec:finanzdaten-diskrete-und-logarithmische-renditen">Kapitel 18: Finanzdaten-Modellierung — Renditen, Kovarianz und Shrinkage</a></div><div class="register-eintrag"><span class="register-begriff">Aktivierungsschalter (Modellierungsmuster)</span> — <a href="anhang-modellierungsmuster.html#anhang-modellierungsmuster">Anhang B: Katalog der Modellierungsmuster</a></div><div class="register-eintrag"><span class="register-begriff">Almgren-Chriss-Modell</span> — <a href="anhang-glossar-literatur.html#anhang-glossar-literatur">Anhang E: Glossar und Literatur</a>, <a href="dynamische-programmierung.html#sec:dynamische-programmierung-das-almgren-chriss-problem-optimale-orderausfuehrung">Kapitel 13: Dynamische Programmierung — Die Bellman-Gleichung und Order-Execution</a></div><div class="register-eintrag"><span class="register-begriff">Alternativoptima</span> — <a href="anhang-glossar-literatur.html#anhang-glossar-literatur">Anhang E: Glossar und Literatur</a></div><div class="register-eintrag"><span class="register-begriff">Approximate Dynamic Programming</span> — <a href="praxisfallen.html#sec:praxisfallen-weiterfuehrende-literatur-und-roadmap">Kapitel 22: Praxisfallen und der Weg zum produktiven Einsatz</a></div><h2 class="register-buchstabe" id="buchstabe-B">B</h2><div class="register-eintrag"><span class="register-begriff">Bedingte Kopplung (Konjunktion)</span> — <a href="anhang-modellierungsmuster.html#anhang-modellierungsmuster">Anhang B: Katalog der Modellierungsmuster</a></div><div class="register-eintrag"><span class="register-begriff">Bellman, Richard</span> — <a href="dynamische-programmierung.html#sec:dynamische-programmierung-das-bellmansche-optimalitaetsprinzip">Kapitel 13: Dynamische Programmierung — Die Bellman-Gleichung und Order-Execution</a></div><div class="register-eintrag"><span class="register-begriff">Bellman-Gleichung</span> — <a href="anhang-glossar-literatur.html#anhang-glossar-literatur">Anhang E: Glossar und Literatur</a>, <a href="dynamische-programmierung.html#sec:dynamische-programmierung-der-fluch-der-dimensionalitaet">Kapitel 13: Dynamische Programmierung — Die Bellman-Gleichung und Order-Execution</a></div><div class="register-eintrag"><span class="register-begriff">Benders-Zerlegung</span> — <a href="praxisfallen.html#sec:praxisfallen-weiterfuehrende-literatur-und-roadmap">Kapitel 22: Praxisfallen und der Weg zum produktiven Einsatz</a></div><div class="register-eintrag"><span class="register-begriff">Big-M-Methode</span> — <a href="anhang-glossar-literatur.html#anhang-glossar-literatur">Anhang E: Glossar und Literatur</a>, <a href="milp.html#sec:milp-modellierungstricks-big-m-und-logische-bedingungen">Kapitel 6: Gemischt-ganzzahlige Optimierung — Diskrete Entscheidungen und Branch-and-Bound</a></div><div class="register-eintrag"><span class="register-begriff">Binärvariable</span> — <a href="anhang-glossar-literatur.html#anhang-glossar-literatur">Anhang E: Glossar und Literatur</a></div><div class="register-eintrag"><span class="register-begriff">Bipartites Matching</span> — <a href="anhang-glossar-literatur.html#anhang-glossar-literatur">Anhang E: Glossar und Literatur</a>, <a href="graphen.html#sec:graphen-bipartites-matching-das-zuordnungsproblem">Kapitel 8: Graphen, Flüsse und Touren — Min-Cost-Flow, Matching und VRP</a></div><div class="register-eintrag"><span class="register-begriff">Black-Box-Effekt</span> — <a href="praxisfallen.html#sec:praxisfallen-die-fuenf-typischen-praxisfallen">Kapitel 22: Praxisfallen und der Weg zum produktiven Einsatz</a></div><div class="register-eintrag"><span class="register-begriff">Branch-and-Bound</span> — <a href="anhang-glossar-literatur.html#anhang-glossar-literatur">Anhang E: Glossar und Literatur</a>, <a href="milp.html#sec:milp-branch-and-bound">Kapitel 6: Gemischt-ganzzahlige Optimierung — Diskrete Entscheidungen und Branch-and-Bound</a><ul class="register-unter"><li>Bounding und Pruning — <a href="milp.html#sec:milp-branch-and-bound">Kapitel 6: Gemischt-ganzzahlige Optimierung — Diskrete Entscheidungen und Branch-and-Bound</a></li><li>Branching — <a href="milp.html#sec:milp-branch-and-bound">Kapitel 6: Gemischt-ganzzahlige Optimierung — Diskrete Entscheidungen und Branch-and-Bound</a></li><li>Incumbent — <a href="milp.html#sec:milp-branch-and-bound">Kapitel 6: Gemischt-ganzzahlige Optimierung — Diskrete Entscheidungen und Branch-and-Bound</a></li></ul></div><div class="register-eintrag"><span class="register-begriff">Branch-and-Cut</span> — <a href="milp.html#sec:milp-branch-and-bound">Kapitel 6: Gemischt-ganzzahlige Optimierung — Diskrete Entscheidungen und Branch-and-Bound</a>, <a href="oekosystem.html#sec:oekosystem-die-zwei-schichten-architektur">Kapitel 3: Das Python-Ökosystem für OR — Solver, Bindings und Modellierungsschichten</a></div><div class="register-eintrag"><span class="register-begriff">Brute Force</span> — <a href="einfuehrung.html#sec:einfuehrung-was-ist-operations-research-wirklich">Kapitel 1: Einführung in Operations Research — Vom Ursprung zur mathematischen Entscheidungsfindung</a></div><div class="register-eintrag"><span class="register-begriff">Budgeted Uncertainty</span> — <a href="anhang-glossar-literatur.html#anhang-glossar-literatur">Anhang E: Glossar und Literatur</a>, <a href="unsicherheit.html#sec:unsicherheit-robuste-optimierung-gegen-den-worst-case">Kapitel 12: Optimierung unter Unsicherheit — Monte-Carlo, Stochastik, Robustheit</a></div><div class="register-eintrag"><span class="register-begriff">Budgetlimit</span> — <a href="anhang-modellierungsmuster.html#anhang-modellierungsmuster">Anhang B: Katalog der Modellierungsmuster</a></div><h2 class="register-buchstabe" id="buchstabe-C">C</h2><div class="register-eintrag"><span class="register-begriff">Calmar Ratio</span> — <a href="anhang-glossar-literatur.html#anhang-glossar-literatur">Anhang E: Glossar und Literatur</a></div><div class="register-eintrag"><span class="register-begriff">CDCL</span> — <a href="cpsat.html#sec:cpsat-ein-anderes-denkmodell">Kapitel 7: Constraint Programming mit CP-SAT — Logik, Scheduling und Zuweisung</a>, <a href="oekosystem.html#sec:oekosystem-die-zwei-schichten-architektur">Kapitel 3: Das Python-Ökosystem für OR — Solver, Bindings und Modellierungsschichten</a><ul class="register-unter"><li>Conflict Learning — <a href="anhang-glossar-literatur.html#anhang-glossar-literatur">Anhang E: Glossar und Literatur</a>, <a href="cpsat.html#sec:cpsat-zusammenfassung">Kapitel 7: Constraint Programming mit CP-SAT — Logik, Scheduling und Zuweisung</a></li></ul></div><div class="register-eintrag"><span class="register-begriff">Chance Constraint</span> — <a href="unsicherheit.html#sec:unsicherheit-chance-constraints">Kapitel 12: Optimierung unter Unsicherheit — Monte-Carlo, Stochastik, Robustheit</a></div><div class="register-eintrag"><span class="register-begriff">Column Generation</span> — <a href="metaheuristiken.html#sec:metaheuristiken-abgrenzung">Kapitel 9: Metaheuristiken — wenn der exakte Solver aussteigt</a>, <a href="praxisfallen.html#sec:praxisfallen-weiterfuehrende-literatur-und-roadmap">Kapitel 22: Praxisfallen und der Weg zum produktiven Einsatz</a></div><div class="register-eintrag"><span class="register-begriff">Conditional Value at Risk (CVaR)</span> — <a href="anhang-glossar-literatur.html#anhang-glossar-literatur">Anhang E: Glossar und Literatur</a>, <a href="cvar.html#sec:cvar-value-at-risk-und-conditional-value">Kapitel 20: Tail-Risiko, CVaR und Transaktionskosten</a></div><div class="register-eintrag"><span class="register-begriff">Constraint Attribution</span> — <a href="praxisfallen.html#sec:praxisfallen-attribution">Kapitel 22: Praxisfallen und der Weg zum produktiven Einsatz</a></div><div class="register-eintrag"><span class="register-begriff">Constraint Programming (CP)</span> — <a href="anhang-glossar-literatur.html#anhang-glossar-literatur">Anhang E: Glossar und Literatur</a>, <a href="cpsat.html#sec:cpsat-ein-anderes-denkmodell">Kapitel 7: Constraint Programming mit CP-SAT — Logik, Scheduling und Zuweisung</a></div><div class="register-eintrag"><span class="register-begriff">Constraint Propagation</span> — <a href="anhang-glossar-literatur.html#anhang-glossar-literatur">Anhang E: Glossar und Literatur</a>, <a href="cpsat.html#sec:cpsat-lernziele">Kapitel 7: Constraint Programming mit CP-SAT — Logik, Scheduling und Zuweisung</a></div><div class="register-eintrag"><span class="register-begriff">Constraint-Trace</span> — <a href="praxisfallen.html#sec:praxisfallen-die-fuenf-typischen-praxisfallen">Kapitel 22: Praxisfallen und der Weg zum produktiven Einsatz</a></div><div class="register-eintrag"><span class="register-begriff">CP-SAT</span> — <a href="anhang-glossar-literatur.html#anhang-glossar-literatur">Anhang E: Glossar und Literatur</a></div><div class="register-eintrag"><span class="register-begriff">CP-SAT-Solver</span> — <a href="cpsat.html#sec:cpsat-ein-anderes-denkmodell">Kapitel 7: Constraint Programming mit CP-SAT — Logik, Scheduling und Zuweisung</a></div><div class="register-eintrag"><span class="register-begriff">CSR-Format</span> — <a href="oekosystem.html#sec:oekosystem-ein-system-vier-programmieransaetze">Kapitel 3: Das Python-Ökosystem für OR — Solver, Bindings und Modellierungsschichten</a></div><div class="register-eintrag"><span class="register-begriff">CVRPTW</span> — <a href="graphen.html#sec:graphen-das-vehicle-routing-problem-mit-zeitfenstern">Kapitel 8: Graphen, Flüsse und Touren — Min-Cost-Flow, Matching und VRP</a></div><div class="register-eintrag"><span class="register-begriff">CVXPY</span> — <a href="anhang-glossar-literatur.html#anhang-glossar-literatur">Anhang E: Glossar und Literatur</a>, <a href="oekosystem.html#sec:oekosystem-die-zwei-schichten-architektur">Kapitel 3: Das Python-Ökosystem für OR — Solver, Bindings und Modellierungsschichten</a>, <a href="qp-nlp.html#sec:qp-nlp-nichtlineare-optimierung-mit-scipy-optimize-minimize">Kapitel 11: Quadratische und nichtlineare Optimierung — KKT, Lagrange, Konvexität</a></div><h2 class="register-buchstabe" id="buchstabe-D">D</h2><div class="register-eintrag"><span class="register-begriff">Dantzig, George</span> — <a href="einfuehrung.html#sec:einfuehrung-historischer-kontext-und-evolution">Kapitel 1: Einführung in Operations Research — Vom Ursprung zur mathematischen Entscheidungsfindung</a>, <a href="lp.html#sec:lp-der-simplex-algorithmus-schritt-fuer-schritt">Kapitel 5: Lineare Programmierung — Simplex, Dualität und Schattenpreise</a></div><div class="register-eintrag"><span class="register-begriff">Data Snooping</span> — <a href="handelsmaschine.html#sec:handelsmaschine-die-fuenf-selbsttaeuschungen-des-backtestens">Kapitel 21: Die vollständige quantitative Handelsmaschine</a></div><div class="register-eintrag"><span class="register-begriff">DCPError</span> — <a href="anhang-fehlerdiagnose.html#anhang-fehlerdiagnose">Anhang C: Fehlerdiagnose-Handbuch</a></div><div class="register-eintrag"><span class="register-begriff">Deletion Filter</span> — <a href="anhang-fehlerdiagnose.html#anhang-fehlerdiagnose">Anhang C: Fehlerdiagnose-Handbuch</a></div><div class="register-eintrag"><span class="register-begriff">Diskrete Rendite</span> — <a href="finanzdaten.html#sec:finanzdaten-diskrete-und-logarithmische-renditen">Kapitel 18: Finanzdaten-Modellierung — Renditen, Kovarianz und Shrinkage</a></div><div class="register-eintrag"><span class="register-begriff">Diversifikation</span> — <a href="markowitz.html#sec:markowitz-warum-diversifikation-funktioniert">Kapitel 19: Die moderne Portfoliotheorie nach Markowitz</a></div><div class="register-eintrag"><span class="register-begriff">Dual Simplex</span> — <a href="oekosystem.html#sec:oekosystem-die-zwei-schichten-architektur">Kapitel 3: Das Python-Ökosystem für OR — Solver, Bindings und Modellierungsschichten</a></div><div class="register-eintrag"><span class="register-begriff">Duales Problem</span> — <a href="lp.html#sec:lp-dualitaet-und-schattenpreise">Kapitel 5: Lineare Programmierung — Simplex, Dualität und Schattenpreise</a></div><div class="register-eintrag"><span class="register-begriff">Dualitätstheorie</span> — <a href="anhang-glossar-literatur.html#anhang-glossar-literatur">Anhang E: Glossar und Literatur</a></div><div class="register-eintrag"><span class="register-begriff">Dynamische Programmierung</span> — <a href="anhang-glossar-literatur.html#anhang-glossar-literatur">Anhang E: Glossar und Literatur</a>, <a href="dynamische-programmierung.html#sec:dynamische-programmierung-das-bellmansche-optimalitaetsprinzip">Kapitel 13: Dynamische Programmierung — Die Bellman-Gleichung und Order-Execution</a><ul class="register-unter"><li>Approximate Dynamic Programming — <a href="dynamische-programmierung.html#sec:dynamische-programmierung-der-fluch-der-dimensionalitaet">Kapitel 13: Dynamische Programmierung — Die Bellman-Gleichung und Order-Execution</a></li></ul></div><h2 class="register-buchstabe" id="buchstabe-E">E</h2><div class="register-eintrag"><span class="register-begriff">Ecke (Extrempunkt)</span> — <a href="fundament.html#sec:fundament-der-zulaessige-loesungsraum-und-das-polyeder">Kapitel 2: Das mathematische Fundament — Vektoren, Matrizen, Konvexität</a></div><div class="register-eintrag"><span class="register-begriff">Effizienzgrenze</span> — <a href="anhang-glossar-literatur.html#anhang-glossar-literatur">Anhang E: Glossar und Literatur</a>, <a href="markowitz.html#sec:markowitz-das-mean-variance-modell">Kapitel 19: Die moderne Portfoliotheorie nach Markowitz</a></div><div class="register-eintrag"><span class="register-begriff">Entartung</span> — <a href="lp.html#sec:lp-entartung">Kapitel 5: Lineare Programmierung — Simplex, Dualität und Schattenpreise</a><ul class="register-unter"><li>und Dualwerte — <a href="anhang-fehlerdiagnose.html#anhang-fehlerdiagnose">Anhang C: Fehlerdiagnose-Handbuch</a></li></ul></div><div class="register-eintrag"><span class="register-begriff">Entscheidungsvariable</span> — <a href="anhang-glossar-literatur.html#anhang-glossar-literatur">Anhang E: Glossar und Literatur</a>, <a href="einfuehrung.html#sec:einfuehrung-die-vier-universellen-bausteine-jedes-or">Kapitel 1: Einführung in Operations Research — Vom Ursprung zur mathematischen Entscheidungsfindung</a></div><div class="register-eintrag"><span class="register-begriff">Entscheidungsvektor</span> — <a href="fundament.html#sec:fundament-warum-ueberhaupt-vektoren-und-matrizen">Kapitel 2: Das mathematische Fundament — Vektoren, Matrizen, Konvexität</a></div><div class="register-eintrag"><span class="register-begriff">Entweder-Oder-Bedingung</span> — <a href="anhang-modellierungsmuster.html#anhang-modellierungsmuster">Anhang B: Katalog der Modellierungsmuster</a></div><div class="register-eintrag"><span class="register-begriff">Error-Maximizer-Effekt</span> — <a href="anhang-glossar-literatur.html#anhang-glossar-literatur">Anhang E: Glossar und Literatur</a>, <a href="finanzdaten.html#sec:finanzdaten-lernziele">Kapitel 18: Finanzdaten-Modellierung — Renditen, Kovarianz und Shrinkage</a></div><div class="register-eintrag"><span class="register-begriff">EVPI</span> — <a href="anhang-glossar-literatur.html#anhang-glossar-literatur">Anhang E: Glossar und Literatur</a>, <a href="unsicherheit.html#sec:unsicherheit-zweistufige-stochastische-programmierung">Kapitel 12: Optimierung unter Unsicherheit — Monte-Carlo, Stochastik, Robustheit</a></div><div class="register-eintrag"><span class="register-begriff">Exklusiv-Oder</span> — <a href="anhang-modellierungsmuster.html#anhang-modellierungsmuster">Anhang B: Katalog der Modellierungsmuster</a></div><div class="register-eintrag"><span class="register-begriff">Expected Shortfall</span> — <a href="cvar.html#sec:cvar-value-at-risk-und-conditional-value">Kapitel 20: Tail-Risiko, CVaR und Transaktionskosten</a></div><div class="register-eintrag"><span class="register-begriff">Explainable OR</span> — <a href="anhang-glossar-literatur.html#anhang-glossar-literatur">Anhang E: Glossar und Literatur</a></div><h2 class="register-buchstabe" id="buchstabe-F">F</h2><div class="register-eintrag"><span class="register-begriff">Fallback-Strategie</span> — <a href="praxisfallen.html#sec:praxisfallen-architektur-einer-produktionsreifen-or-plattform">Kapitel 22: Praxisfallen und der Weg zum produktiven Einsatz</a></div><div class="register-eintrag"><span class="register-begriff">Falsche Dualwerte (Fehlerbild)</span> — <a href="anhang-fehlerdiagnose.html#anhang-fehlerdiagnose">Anhang C: Fehlerdiagnose-Handbuch</a></div><div class="register-eintrag"><span class="register-begriff">Fat Tails</span> — <a href="anhang-glossar-literatur.html#anhang-glossar-literatur">Anhang E: Glossar und Literatur</a>, <a href="cvar.html#sec:cvar-die-zwei-schwaechen-des-markowitz-modells">Kapitel 20: Tail-Risiko, CVaR und Transaktionskosten</a></div><div class="register-eintrag"><span class="register-begriff">Fluch der Dimensionalität</span> — <a href="anhang-glossar-literatur.html#anhang-glossar-literatur">Anhang E: Glossar und Literatur</a>, <a href="dynamische-programmierung.html#sec:dynamische-programmierung-der-fluch-der-dimensionalitaet">Kapitel 13: Dynamische Programmierung — Die Bellman-Gleichung und Order-Execution</a></div><div class="register-eintrag"><span class="register-begriff">Fluch des Durchschnitts</span> — <a href="unsicherheit.html#sec:unsicherheit-lernziele">Kapitel 12: Optimierung unter Unsicherheit — Monte-Carlo, Stochastik, Robustheit</a></div><div class="register-eintrag"><span class="register-begriff">Flusserhaltung</span> — <a href="anhang-glossar-literatur.html#anhang-glossar-literatur">Anhang E: Glossar und Literatur</a>, <a href="anhang-modellierungsmuster.html#anhang-modellierungsmuster">Anhang B: Katalog der Modellierungsmuster</a>, <a href="graphen.html#sec:graphen-lernziele">Kapitel 8: Graphen, Flüsse und Touren — Min-Cost-Flow, Matching und VRP</a></div><div class="register-eintrag"><span class="register-begriff">Fundamentalsatz der linearen Optimierung</span> — <a href="anhang-glossar-literatur.html#anhang-glossar-literatur">Anhang E: Glossar und Literatur</a>, <a href="fundament.html#sec:fundament-der-zulaessige-loesungsraum-und-das-polyeder">Kapitel 2: Das mathematische Fundament — Vektoren, Matrizen, Konvexität</a></div><h2 class="register-buchstabe" id="buchstabe-G">G</h2><div class="register-eintrag"><span class="register-begriff">Genetischer Algorithmus</span> — <a href="metaheuristiken.html#sec:metaheuristiken-abgrenzung">Kapitel 9: Metaheuristiken — wenn der exakte Solver aussteigt</a></div><div class="register-eintrag"><span class="register-begriff">Gestaffelte Preise (stückweise linear)</span> — <a href="anhang-modellierungsmuster.html#anhang-modellierungsmuster">Anhang B: Katalog der Modellierungsmuster</a></div><div class="register-eintrag"><span class="register-begriff">Gini-Koeffizient</span> — <a href="projektwerkstatt.html">Projektwerkstatt</a></div><div class="register-eintrag"><span class="register-begriff">Gleitendes Fenster</span> — <a href="anhang-modellierungsmuster.html#anhang-modellierungsmuster">Anhang B: Katalog der Modellierungsmuster</a></div><div class="register-eintrag"><span class="register-begriff">Globale Constraints</span> — <a href="anhang-glossar-literatur.html#anhang-glossar-literatur">Anhang E: Glossar und Literatur</a>, <a href="cpsat.html#sec:cpsat-globale-constraints-die-bausteine-von-cp">Kapitel 7: Constraint Programming mit CP-SAT — Logik, Scheduling und Zuweisung</a><ul class="register-unter"><li>AddAllDifferent — <a href="cpsat.html#sec:cpsat-zusammenfassung">Kapitel 7: Constraint Programming mit CP-SAT — Logik, Scheduling und Zuweisung</a></li><li>AddCumulative — <a href="cpsat.html#sec:cpsat-zusammenfassung">Kapitel 7: Constraint Programming mit CP-SAT — Logik, Scheduling und Zuweisung</a></li><li>AddNoOverlap — <a href="cpsat.html#sec:cpsat-zusammenfassung">Kapitel 7: Constraint Programming mit CP-SAT — Logik, Scheduling und Zuweisung</a></li></ul></div><div class="register-eintrag"><span class="register-begriff">Globales Minimum</span> — <a href="fundament.html#sec:fundament-konvexitaet-die-grenze-zwischen-leicht-und">Kapitel 2: Das mathematische Fundament — Vektoren, Matrizen, Konvexität</a></div><div class="register-eintrag"><span class="register-begriff">GMV (Global Minimum Variance)</span> — <a href="anhang-glossar-literatur.html#anhang-glossar-literatur">Anhang E: Glossar und Literatur</a>, <a href="markowitz.html#sec:markowitz-zusammenfassung">Kapitel 19: Die moderne Portfoliotheorie nach Markowitz</a></div><div class="register-eintrag"><span class="register-begriff">Goldene Regel des Backtestens</span> — <a href="handelsmaschine.html#sec:handelsmaschine-zusammenfassung">Kapitel 21: Die vollständige quantitative Handelsmaschine</a></div><div class="register-eintrag"><span class="register-begriff">Gradient</span> — <a href="qp-nlp.html#sec:qp-nlp-lernziele">Kapitel 11: Quadratische und nichtlineare Optimierung — KKT, Lagrange, Konvexität</a></div><div class="register-eintrag"><span class="register-begriff">Gurobi</span> — <a href="milp.html#sec:milp-branch-and-bound">Kapitel 6: Gemischt-ganzzahlige Optimierung — Diskrete Entscheidungen und Branch-and-Bound</a></div><h2 class="register-buchstabe" id="buchstabe-H">H</h2><div class="register-eintrag"><span class="register-begriff">Herfindahl-Index</span> — <a href="projektwerkstatt.html">Projektwerkstatt</a></div><div class="register-eintrag"><span class="register-begriff">Hierarchische Relaxation</span> — <a href="praxisfallen.html#sec:praxisfallen-die-fuenf-typischen-praxisfallen">Kapitel 22: Praxisfallen und der Weg zum produktiven Einsatz</a></div><div class="register-eintrag"><span class="register-begriff">HiGHS</span> — <a href="anhang-glossar-literatur.html#anhang-glossar-literatur">Anhang E: Glossar und Literatur</a>, <a href="milp.html#sec:milp-branch-and-bound">Kapitel 6: Gemischt-ganzzahlige Optimierung — Diskrete Entscheidungen und Branch-and-Bound</a></div><h2 class="register-buchstabe" id="buchstabe-I">I</h2><div class="register-eintrag"><span class="register-begriff">IIS (Irreducible Infeasible Subset)</span> — <a href="anhang-fehlerdiagnose.html#anhang-fehlerdiagnose">Anhang C: Fehlerdiagnose-Handbuch</a></div><div class="register-eintrag"><span class="register-begriff">Implikation (Modellierungsmuster)</span> — <a href="anhang-modellierungsmuster.html#anhang-modellierungsmuster">Anhang B: Katalog der Modellierungsmuster</a></div><div class="register-eintrag"><span class="register-begriff">Importfehler (ortools und highspy)</span> — <a href="anhang-fehlerdiagnose.html#anhang-fehlerdiagnose">Anhang C: Fehlerdiagnose-Handbuch</a></div><div class="register-eintrag"><span class="register-begriff">Infeasibility</span> — <a href="anhang-fehlerdiagnose.html#anhang-fehlerdiagnose">Anhang C: Fehlerdiagnose-Handbuch</a>, <a href="anhang-glossar-literatur.html#anhang-glossar-literatur">Anhang E: Glossar und Literatur</a>, <a href="einfuehrung.html#sec:einfuehrung-die-vier-universellen-bausteine-jedes-or">Kapitel 1: Einführung in Operations Research — Vom Ursprung zur mathematischen Entscheidungsfindung</a></div><div class="register-eintrag"><span class="register-begriff">Instabile Lösung (Fehlerbild)</span> — <a href="anhang-fehlerdiagnose.html#anhang-fehlerdiagnose">Anhang C: Fehlerdiagnose-Handbuch</a></div><div class="register-eintrag"><span class="register-begriff">Interior-Point-Verfahren</span> — <a href="oekosystem.html#sec:oekosystem-die-zwei-schichten-architektur">Kapitel 3: Das Python-Ökosystem für OR — Solver, Bindings und Modellierungsschichten</a></div><div class="register-eintrag"><span class="register-begriff">Intervallvariable</span> — <a href="anhang-glossar-literatur.html#anhang-glossar-literatur">Anhang E: Glossar und Literatur</a>, <a href="cpsat.html#sec:cpsat-lernziele">Kapitel 7: Constraint Programming mit CP-SAT — Logik, Scheduling und Zuweisung</a></div><h2 class="register-buchstabe" id="buchstabe-J">J</h2><div class="register-eintrag"><span class="register-begriff">Jensensche Ungleichung</span> — <a href="anhang-glossar-literatur.html#anhang-glossar-literatur">Anhang E: Glossar und Literatur</a>, <a href="unsicherheit.html#sec:unsicherheit-der-fluch-des-durchschnitts">Kapitel 12: Optimierung unter Unsicherheit — Monte-Carlo, Stochastik, Robustheit</a></div><div class="register-eintrag"><span class="register-begriff">Job-Shop-Scheduling</span> — <a href="cpsat.html#sec:cpsat-intervallvariablen-job-shop-scheduling">Kapitel 7: Constraint Programming mit CP-SAT — Logik, Scheduling und Zuweisung</a></div><h2 class="register-buchstabe" id="buchstabe-K">K</h2><div class="register-eintrag"><span class="register-begriff">Kanonische Standardform</span> — <a href="anhang-glossar-literatur.html#anhang-glossar-literatur">Anhang E: Glossar und Literatur</a></div><div class="register-eintrag"><span class="register-begriff">Kapazitätsvektor</span> — <a href="fundament.html#sec:fundament-warum-ueberhaupt-vektoren-und-matrizen">Kapitel 2: Das mathematische Fundament — Vektoren, Matrizen, Konvexität</a></div><div class="register-eintrag"><span class="register-begriff">Kardinalitätsbeschränkung</span> — <a href="anhang-glossar-literatur.html#anhang-glossar-literatur">Anhang E: Glossar und Literatur</a>, <a href="anhang-modellierungsmuster.html#anhang-modellierungsmuster">Anhang B: Katalog der Modellierungsmuster</a>, <a href="milp.html#sec:milp-praxisfall-portfolio-mit-ordergebuehren-und-kardinalitaetsgrenze">Kapitel 6: Gemischt-ganzzahlige Optimierung — Diskrete Entscheidungen und Branch-and-Bound</a></div><div class="register-eintrag"><span class="register-begriff">KKT-Bedingungen</span> — <a href="anhang-glossar-literatur.html#anhang-glossar-literatur">Anhang E: Glossar und Literatur</a>, <a href="qp-nlp.html#sec:qp-nlp-die-karush-kuhn-tucker-bedingungen">Kapitel 11: Quadratische und nichtlineare Optimierung — KKT, Lagrange, Konvexität</a></div><div class="register-eintrag"><span class="register-begriff">Kohärentes Risikomaß</span> — <a href="anhang-glossar-literatur.html#anhang-glossar-literatur">Anhang E: Glossar und Literatur</a></div><div class="register-eintrag"><span class="register-begriff">Kombinatorische Explosion</span> — <a href="anhang-glossar-literatur.html#anhang-glossar-literatur">Anhang E: Glossar und Literatur</a>, <a href="einfuehrung.html#sec:einfuehrung-zusammenfassung">Kapitel 1: Einführung in Operations Research — Vom Ursprung zur mathematischen Entscheidungsfindung</a></div><div class="register-eintrag"><span class="register-begriff">Komplementärer Schlupf</span> — <a href="anhang-glossar-literatur.html#anhang-glossar-literatur">Anhang E: Glossar und Literatur</a>, <a href="lp.html#sec:lp-dualitaet-und-schattenpreise">Kapitel 5: Lineare Programmierung — Simplex, Dualität und Schattenpreise</a>, <a href="qp-nlp.html#sec:qp-nlp-die-karush-kuhn-tucker-bedingungen">Kapitel 11: Quadratische und nichtlineare Optimierung — KKT, Lagrange, Konvexität</a></div><div class="register-eintrag"><span class="register-begriff">Konditionszahl</span> — <a href="anhang-fehlerdiagnose.html#anhang-fehlerdiagnose">Anhang C: Fehlerdiagnose-Handbuch</a>, <a href="anhang-glossar-literatur.html#anhang-glossar-literatur">Anhang E: Glossar und Literatur</a>, <a href="fundament.html#sec:fundament-kondition">Kapitel 2: Das mathematische Fundament — Vektoren, Matrizen, Konvexität</a></div><div class="register-eintrag"><span class="register-begriff">Konische Optimierung (SOCP, SDP)</span> — <a href="praxisfallen.html#sec:praxisfallen-weiterfuehrende-literatur-und-roadmap">Kapitel 22: Praxisfallen und der Weg zum produktiven Einsatz</a>, <a href="unsicherheit.html#sec:unsicherheit-chance-constraints">Kapitel 12: Optimierung unter Unsicherheit — Monte-Carlo, Stochastik, Robustheit</a></div><div class="register-eintrag"><span class="register-begriff">Konvexität</span> — <a href="anhang-glossar-literatur.html#anhang-glossar-literatur">Anhang E: Glossar und Literatur</a>, <a href="fundament.html#sec:fundament-konvexitaet-die-grenze-zwischen-leicht-und">Kapitel 2: Das mathematische Fundament — Vektoren, Matrizen, Konvexität</a>, <a href="qp-nlp.html#sec:qp-nlp-lernziele">Kapitel 11: Quadratische und nichtlineare Optimierung — KKT, Lagrange, Konvexität</a><ul class="register-unter"><li>Funktion — <a href="fundament.html#sec:fundament-konvexitaet-die-grenze-zwischen-leicht-und">Kapitel 2: Das mathematische Fundament — Vektoren, Matrizen, Konvexität</a></li><li>Menge — <a href="fundament.html#sec:fundament-konvexitaet-die-grenze-zwischen-leicht-und">Kapitel 2: Das mathematische Fundament — Vektoren, Matrizen, Konvexität</a></li><li>streng konvex — <a href="qp-nlp.html#sec:qp-nlp-lernziele">Kapitel 11: Quadratische und nichtlineare Optimierung — KKT, Lagrange, Konvexität</a></li></ul></div><div class="register-eintrag"><span class="register-begriff">Korn-Transformation</span> — <a href="anhang-glossar-literatur.html#anhang-glossar-literatur">Anhang E: Glossar und Literatur</a>, <a href="markowitz.html#sec:markowitz-lernziele">Kapitel 19: Die moderne Portfoliotheorie nach Markowitz</a></div><div class="register-eintrag"><span class="register-begriff">Kostenzerlegung</span> — <a href="praxisfallen.html#sec:praxisfallen-die-fuenf-typischen-praxisfallen">Kapitel 22: Praxisfallen und der Weg zum produktiven Einsatz</a></div><div class="register-eintrag"><span class="register-begriff">Kovarianzmatrix</span> — <a href="anhang-glossar-literatur.html#anhang-glossar-literatur">Anhang E: Glossar und Literatur</a>, <a href="qp-nlp.html#sec:qp-nlp-lernziele">Kapitel 11: Quadratische und nichtlineare Optimierung — KKT, Lagrange, Konvexität</a></div><div class="register-eintrag"><span class="register-begriff">Kumulative Ressource</span> — <a href="anhang-modellierungsmuster.html#anhang-modellierungsmuster">Anhang B: Katalog der Modellierungsmuster</a></div><h2 class="register-buchstabe" id="buchstabe-L">L</h2><div class="register-eintrag"><span class="register-begriff">Lagrange-Funktion</span> — <a href="qp-nlp.html#sec:qp-nlp-die-karush-kuhn-tucker-bedingungen">Kapitel 11: Quadratische und nichtlineare Optimierung — KKT, Lagrange, Konvexität</a></div><div class="register-eintrag"><span class="register-begriff">Lagrange-Multiplikator</span> — <a href="anhang-glossar-literatur.html#anhang-glossar-literatur">Anhang E: Glossar und Literatur</a></div><div class="register-eintrag"><span class="register-begriff">Large Neighborhood Search</span> — <a href="metaheuristiken.html#sec:metaheuristiken-lns">Kapitel 9: Metaheuristiken — wenn der exakte Solver aussteigt</a></div><div class="register-eintrag"><span class="register-begriff">Laufzeitexplosion (Fehlerbild)</span> — <a href="anhang-fehlerdiagnose.html#anhang-fehlerdiagnose">Anhang C: Fehlerdiagnose-Handbuch</a></div><div class="register-eintrag"><span class="register-begriff">Ledoit-Wolf-Shrinkage</span> — <a href="anhang-glossar-literatur.html#anhang-glossar-literatur">Anhang E: Glossar und Literatur</a>, <a href="finanzdaten.html#sec:finanzdaten-ledoit-wolf-shrinkage">Kapitel 18: Finanzdaten-Modellierung — Renditen, Kovarianz und Shrinkage</a></div><div class="register-eintrag"><span class="register-begriff">Lexikografische Optimierung</span> — <a href="anhang-modellierungsmuster.html#anhang-modellierungsmuster">Anhang B: Katalog der Modellierungsmuster</a>, <a href="mehrziel.html#sec:mehrziel-epsilon">Kapitel 14: Mehrere Ziele — Pareto-Fronten statt Gewichte</a></div><div class="register-eintrag"><span class="register-begriff">Lineare Programmierung (LP)</span> — <a href="anhang-glossar-literatur.html#anhang-glossar-literatur">Anhang E: Glossar und Literatur</a></div><div class="register-eintrag"><span class="register-begriff">Linopy</span> — <a href="oekosystem.html#sec:oekosystem-pyomo-linopy">Kapitel 3: Das Python-Ökosystem für OR — Solver, Bindings und Modellierungsschichten</a></div><div class="register-eintrag"><span class="register-begriff">linprog</span> — <a href="lp.html#sec:lp-die-vorzeichenfalle-bei-schattenpreisen">Kapitel 5: Lineare Programmierung — Simplex, Dualität und Schattenpreise</a></div><div class="register-eintrag"><span class="register-begriff">Logarithmische Rendite</span> — <a href="anhang-glossar-literatur.html#anhang-glossar-literatur">Anhang E: Glossar und Literatur</a>, <a href="finanzdaten.html#sec:finanzdaten-diskrete-und-logarithmische-renditen">Kapitel 18: Finanzdaten-Modellierung — Renditen, Kovarianz und Shrinkage</a></div><div class="register-eintrag"><span class="register-begriff">Lokales Minimum</span> — <a href="fundament.html#sec:fundament-konvexitaet-die-grenze-zwischen-leicht-und">Kapitel 2: Das mathematische Fundament — Vektoren, Matrizen, Konvexität</a></div><div class="register-eintrag"><span class="register-begriff">Lookahead-Bias</span> — <a href="anhang-glossar-literatur.html#anhang-glossar-literatur">Anhang E: Glossar und Literatur</a>, <a href="handelsmaschine.html#sec:handelsmaschine-lernziele">Kapitel 21: Die vollständige quantitative Handelsmaschine</a></div><div class="register-eintrag"><span class="register-begriff">LP-Relaxation</span> — <a href="milp.html#sec:milp-branch-and-bound">Kapitel 6: Gemischt-ganzzahlige Optimierung — Diskrete Entscheidungen und Branch-and-Bound</a></div><h2 class="register-buchstabe" id="buchstabe-M">M</h2><div class="register-eintrag"><span class="register-begriff">Makespan</span> — <a href="cpsat.html#sec:cpsat-intervallvariablen-job-shop-scheduling">Kapitel 7: Constraint Programming mit CP-SAT — Logik, Scheduling und Zuweisung</a></div><div class="register-eintrag"><span class="register-begriff">Marchenko-Pastur-Gesetz</span> — <a href="finanzdaten.html#sec:finanzdaten-das-schaetzfehler-problem">Kapitel 18: Finanzdaten-Modellierung — Renditen, Kovarianz und Shrinkage</a></div><div class="register-eintrag"><span class="register-begriff">Markowitz-Modell (Mean-Variance)</span> — <a href="anhang-glossar-literatur.html#anhang-glossar-literatur">Anhang E: Glossar und Literatur</a>, <a href="markowitz.html#sec:markowitz-lernziele">Kapitel 19: Die moderne Portfoliotheorie nach Markowitz</a></div><div class="register-eintrag"><span class="register-begriff">Marktauswirkung</span> — <a href="anhang-glossar-literatur.html#anhang-glossar-literatur">Anhang E: Glossar und Literatur</a>, <a href="dynamische-programmierung.html#sec:dynamische-programmierung-das-almgren-chriss-problem-optimale-orderausfuehrung">Kapitel 13: Dynamische Programmierung — Die Bellman-Gleichung und Order-Execution</a></div><div class="register-eintrag"><span class="register-begriff">Matrix-Vektor-Produkt</span> — <a href="fundament.html#sec:fundament-warum-ueberhaupt-vektoren-und-matrizen">Kapitel 2: Das mathematische Fundament — Vektoren, Matrizen, Konvexität</a></div><div class="register-eintrag"><span class="register-begriff">Matrixform</span> — <a href="fundament.html#sec:fundament-zusammenfassung">Kapitel 2: Das mathematische Fundament — Vektoren, Matrizen, Konvexität</a></div><div class="register-eintrag"><span class="register-begriff">Maximin-Fairness</span> — <a href="anhang-modellierungsmuster.html#anhang-modellierungsmuster">Anhang B: Katalog der Modellierungsmuster</a></div><div class="register-eintrag"><span class="register-begriff">Maximum Drawdown</span> — <a href="anhang-glossar-literatur.html#anhang-glossar-literatur">Anhang E: Glossar und Literatur</a></div><div class="register-eintrag"><span class="register-begriff">Mensch in der Schleife</span> — <a href="praxisfallen.html#sec:praxisfallen-architektur-einer-produktionsreifen-or-plattform">Kapitel 22: Praxisfallen und der Weg zum produktiven Einsatz</a></div><div class="register-eintrag"><span class="register-begriff">Metaheuristik</span> — <a href="metaheuristiken.html#sec:metaheuristiken-aufgabe">Kapitel 9: Metaheuristiken — wenn der exakte Solver aussteigt</a></div><div class="register-eintrag"><span class="register-begriff">MILP</span> — <a href="anhang-glossar-literatur.html#anhang-glossar-literatur">Anhang E: Glossar und Literatur</a>, <a href="milp.html#sec:milp-warum-runden-fundamental-scheitert">Kapitel 6: Gemischt-ganzzahlige Optimierung — Diskrete Entscheidungen und Branch-and-Bound</a></div><div class="register-eintrag"><span class="register-begriff">Min-Cost-Flow</span> — <a href="anhang-glossar-literatur.html#anhang-glossar-literatur">Anhang E: Glossar und Literatur</a>, <a href="graphen.html#sec:graphen-graphen-als-modellsprache">Kapitel 8: Graphen, Flüsse und Touren — Min-Cost-Flow, Matching und VRP</a></div><div class="register-eintrag"><span class="register-begriff">Mindestabnahmemenge</span> — <a href="anhang-modellierungsmuster.html#anhang-modellierungsmuster">Anhang B: Katalog der Modellierungsmuster</a></div><div class="register-eintrag"><span class="register-begriff">MINLP</span> — <a href="qp-nlp.html#sec:qp-nlp-nichtkonvex">Kapitel 11: Quadratische und nichtlineare Optimierung — KKT, Lagrange, Konvexität</a></div><div class="register-eintrag"><span class="register-begriff">MIP-Gap</span> — <a href="anhang-glossar-literatur.html#anhang-glossar-literatur">Anhang E: Glossar und Literatur</a>, <a href="milp.html#sec:milp-beispiel-das-rucksackproblem">Kapitel 6: Gemischt-ganzzahlige Optimierung — Diskrete Entscheidungen und Branch-and-Bound</a>, <a href="milp.html#sec:milp-gap">Kapitel 6: Gemischt-ganzzahlige Optimierung — Diskrete Entscheidungen und Branch-and-Bound</a></div><div class="register-eintrag"><span class="register-begriff">Monte-Carlo-Simulation</span> — <a href="anhang-glossar-literatur.html#anhang-glossar-literatur">Anhang E: Glossar und Literatur</a>, <a href="unsicherheit.html#sec:unsicherheit-monte-carlo-simulation">Kapitel 12: Optimierung unter Unsicherheit — Monte-Carlo, Stochastik, Robustheit</a></div><div class="register-eintrag"><span class="register-begriff">MTZ-Formulierung</span> — <a href="anhang-glossar-literatur.html#anhang-glossar-literatur">Anhang E: Glossar und Literatur</a>, <a href="anhang-modellierungsmuster.html#anhang-modellierungsmuster">Anhang B: Katalog der Modellierungsmuster</a>, <a href="graphen.html#sec:graphen-das-vehicle-routing-problem-mit-zeitfenstern">Kapitel 8: Graphen, Flüsse und Touren — Min-Cost-Flow, Matching und VRP</a></div><div class="register-eintrag"><span class="register-begriff">Multi-Objective Optimization</span> — <a href="praxisfallen.html#sec:praxisfallen-weiterfuehrende-literatur-und-roadmap">Kapitel 22: Praxisfallen und der Weg zum produktiven Einsatz</a></div><h2 class="register-buchstabe" id="buchstabe-N">N</h2><div class="register-eintrag"><span class="register-begriff">Nebenbedingung</span> — <a href="anhang-glossar-literatur.html#anhang-glossar-literatur">Anhang E: Glossar und Literatur</a>, <a href="einfuehrung.html#sec:einfuehrung-die-vier-universellen-bausteine-jedes-or">Kapitel 1: Einführung in Operations Research — Vom Ursprung zur mathematischen Entscheidungsfindung</a><ul class="register-unter"><li>hart — <a href="einfuehrung.html#sec:einfuehrung-die-vier-universellen-bausteine-jedes-or">Kapitel 1: Einführung in Operations Research — Vom Ursprung zur mathematischen Entscheidungsfindung</a></li><li>weich — <a href="einfuehrung.html#sec:einfuehrung-die-vier-universellen-bausteine-jedes-or">Kapitel 1: Einführung in Operations Research — Vom Ursprung zur mathematischen Entscheidungsfindung</a></li></ul></div><div class="register-eintrag"><span class="register-begriff">Newsvendor-Problem</span> — <a href="unsicherheit.html#sec:unsicherheit-schnellstart">Kapitel 12: Optimierung unter Unsicherheit — Monte-Carlo, Stochastik, Robustheit</a></div><div class="register-eintrag"><span class="register-begriff">Nichtlineare Programmierung (NLP)</span> — <a href="anhang-glossar-literatur.html#anhang-glossar-literatur">Anhang E: Glossar und Literatur</a></div><div class="register-eintrag"><span class="register-begriff">Nichtüberlappung</span> — <a href="anhang-modellierungsmuster.html#anhang-modellierungsmuster">Anhang B: Katalog der Modellierungsmuster</a></div><div class="register-eintrag"><span class="register-begriff">NP-schwer</span> — <a href="milp.html#sec:milp-branch-and-bound">Kapitel 6: Gemischt-ganzzahlige Optimierung — Diskrete Entscheidungen und Branch-and-Bound</a></div><h2 class="register-buchstabe" id="buchstabe-O">O</h2><div class="register-eintrag"><span class="register-begriff">Operations Research</span> — <a href="anhang-glossar-literatur.html#anhang-glossar-literatur">Anhang E: Glossar und Literatur</a>, <a href="einfuehrung.html#sec:einfuehrung-was-ist-operations-research-wirklich">Kapitel 1: Einführung in Operations Research — Vom Ursprung zur mathematischen Entscheidungsfindung</a></div><div class="register-eintrag"><span class="register-begriff">Optimalitätsprinzip</span> — <a href="anhang-glossar-literatur.html#anhang-glossar-literatur">Anhang E: Glossar und Literatur</a>, <a href="dynamische-programmierung.html#sec:dynamische-programmierung-lernziele">Kapitel 13: Dynamische Programmierung — Die Bellman-Gleichung und Order-Execution</a></div><div class="register-eintrag"><span class="register-begriff">OR-Tools</span> — <a href="einfuehrung.html#sec:einfuehrung-lernziele">Kapitel 1: Einführung in Operations Research — Vom Ursprung zur mathematischen Entscheidungsfindung</a></div><div class="register-eintrag"><span class="register-begriff">Overfitting</span> — <a href="handelsmaschine.html#sec:handelsmaschine-die-fuenf-selbsttaeuschungen-des-backtestens">Kapitel 21: Die vollständige quantitative Handelsmaschine</a></div><h2 class="register-buchstabe" id="buchstabe-P">P</h2><div class="register-eintrag"><span class="register-begriff">Parameter (Modell)</span> — <a href="einfuehrung.html#sec:einfuehrung-die-vier-universellen-bausteine-jedes-or">Kapitel 1: Einführung in Operations Research — Vom Ursprung zur mathematischen Entscheidungsfindung</a></div><div class="register-eintrag"><span class="register-begriff">Pareto-Front</span> — <a href="mehrziel.html#sec:mehrziel-dominanz">Kapitel 14: Mehrere Ziele — Pareto-Fronten statt Gewichte</a></div><div class="register-eintrag"><span class="register-begriff">Pivotisierung</span> — <a href="anhang-glossar-literatur.html#anhang-glossar-literatur">Anhang E: Glossar und Literatur</a></div><div class="register-eintrag"><span class="register-begriff">Polars</span> — <a href="oekosystem.html#sec:oekosystem-vektorisierung">Kapitel 3: Das Python-Ökosystem für OR — Solver, Bindings und Modellierungsschichten</a></div><div class="register-eintrag"><span class="register-begriff">Polyeder</span> — <a href="anhang-glossar-literatur.html#anhang-glossar-literatur">Anhang E: Glossar und Literatur</a>, <a href="fundament.html#sec:fundament-der-zulaessige-loesungsraum-und-das-polyeder">Kapitel 2: Das mathematische Fundament — Vektoren, Matrizen, Konvexität</a></div><div class="register-eintrag"><span class="register-begriff">Positiv (semi-)definit</span> — <a href="anhang-glossar-literatur.html#anhang-glossar-literatur">Anhang E: Glossar und Literatur</a></div><div class="register-eintrag"><span class="register-begriff">Präskriptive Analytik</span> — <a href="anhang-glossar-literatur.html#anhang-glossar-literatur">Anhang E: Glossar und Literatur</a>, <a href="einfuehrung.html#sec:einfuehrung-was-ist-operations-research-wirklich">Kapitel 1: Einführung in Operations Research — Vom Ursprung zur mathematischen Entscheidungsfindung</a></div><div class="register-eintrag"><span class="register-begriff">Predict-then-Optimize</span> — <a href="prognose.html#sec:prognose-naht">Kapitel 15: Predict-then-Optimize — die bessere Prognose, die schlechtere Entscheidung</a></div><div class="register-eintrag"><span class="register-begriff">Primales Problem</span> — <a href="lp.html#sec:lp-dualitaet-und-schattenpreise">Kapitel 5: Lineare Programmierung — Simplex, Dualität und Schattenpreise</a></div><div class="register-eintrag"><span class="register-begriff">Pyomo</span> — <a href="oekosystem.html#sec:oekosystem-pyomo-linopy">Kapitel 3: Das Python-Ökosystem für OR — Solver, Bindings und Modellierungsschichten</a></div><h2 class="register-buchstabe" id="buchstabe-Q">Q</h2><div class="register-eintrag"><span class="register-begriff">Q-Learning</span> — <a href="dynamische-programmierung.html#sec:dynamische-programmierung-der-fluch-der-dimensionalitaet">Kapitel 13: Dynamische Programmierung — Die Bellman-Gleichung und Order-Execution</a></div><div class="register-eintrag"><span class="register-begriff">Quadratische Programmierung (QP)</span> — <a href="anhang-glossar-literatur.html#anhang-glossar-literatur">Anhang E: Glossar und Literatur</a>, <a href="qp-nlp.html#sec:qp-nlp-das-quadratische-programm-qp">Kapitel 11: Quadratische und nichtlineare Optimierung — KKT, Lagrange, Konvexität</a></div><h2 class="register-buchstabe" id="buchstabe-R">R</h2><div class="register-eintrag"><span class="register-begriff">Rebalancing</span> — <a href="anhang-glossar-literatur.html#anhang-glossar-literatur">Anhang E: Glossar und Literatur</a></div><div class="register-eintrag"><span class="register-begriff">Regime-Shift</span> — <a href="anhang-glossar-literatur.html#anhang-glossar-literatur">Anhang E: Glossar und Literatur</a></div><div class="register-eintrag"><span class="register-begriff">Reinforcement Learning</span> — <a href="dynamische-programmierung.html#sec:dynamische-programmierung-der-fluch-der-dimensionalitaet">Kapitel 13: Dynamische Programmierung — Die Bellman-Gleichung und Order-Execution</a></div><div class="register-eintrag"><span class="register-begriff">Relaxation</span> — <a href="anhang-glossar-literatur.html#anhang-glossar-literatur">Anhang E: Glossar und Literatur</a></div><div class="register-eintrag"><span class="register-begriff">Robuste Optimierung</span> — <a href="anhang-glossar-literatur.html#anhang-glossar-literatur">Anhang E: Glossar und Literatur</a>, <a href="unsicherheit.html#sec:unsicherheit-robuste-optimierung-gegen-den-worst-case">Kapitel 12: Optimierung unter Unsicherheit — Monte-Carlo, Stochastik, Robustheit</a><ul class="register-unter"><li>Worst-Case-Abzug — <a href="anhang-modellierungsmuster.html#anhang-modellierungsmuster">Anhang B: Katalog der Modellierungsmuster</a></li></ul></div><div class="register-eintrag"><span class="register-begriff">Rockafellar-Uryasev-Theorem</span> — <a href="anhang-glossar-literatur.html#anhang-glossar-literatur">Anhang E: Glossar und Literatur</a>, <a href="cvar.html#sec:cvar-value-at-risk-und-conditional-value">Kapitel 20: Tail-Risiko, CVaR und Transaktionskosten</a></div><div class="register-eintrag"><span class="register-begriff">Routing-Bibliothek</span> — <a href="graphen.html#sec:graphen-zusammenfassung">Kapitel 8: Graphen, Flüsse und Touren — Min-Cost-Flow, Matching und VRP</a></div><div class="register-eintrag"><span class="register-begriff">Rucksackproblem</span> — <a href="anhang-modellierungsmuster.html#anhang-modellierungsmuster">Anhang B: Katalog der Modellierungsmuster</a>, <a href="milp.html#sec:milp-beispiel-das-rucksackproblem">Kapitel 6: Gemischt-ganzzahlige Optimierung — Diskrete Entscheidungen und Branch-and-Bound</a></div><div class="register-eintrag"><span class="register-begriff">Rückwärtsinduktion</span> — <a href="dynamische-programmierung.html#sec:dynamische-programmierung-lernziele">Kapitel 13: Dynamische Programmierung — Die Bellman-Gleichung und Order-Execution</a></div><div class="register-eintrag"><span class="register-begriff">Ruiz-Equilibrierung</span> — <a href="fundament.html#sec:fundament-kondition">Kapitel 2: Das mathematische Fundament — Vektoren, Matrizen, Konvexität</a></div><div class="register-eintrag"><span class="register-begriff">Rüstzeit</span> — <a href="anhang-modellierungsmuster.html#anhang-modellierungsmuster">Anhang B: Katalog der Modellierungsmuster</a></div><h2 class="register-buchstabe" id="buchstabe-S">S</h2><div class="register-eintrag"><span class="register-begriff">SAT (Boolean Satisfiability)</span> — <a href="cpsat.html#sec:cpsat-ein-anderes-denkmodell">Kapitel 7: Constraint Programming mit CP-SAT — Logik, Scheduling und Zuweisung</a></div><div class="register-eintrag"><span class="register-begriff">Satz von Birkhoff und von Neumann</span> — <a href="graphen.html#sec:graphen-bipartites-matching-das-zuordnungsproblem">Kapitel 8: Graphen, Flüsse und Touren — Min-Cost-Flow, Matching und VRP</a></div><div class="register-eintrag"><span class="register-begriff">Schattenpreis</span> — <a href="anhang-glossar-literatur.html#anhang-glossar-literatur">Anhang E: Glossar und Literatur</a>, <a href="lp.html#sec:lp-schnellstart">Kapitel 5: Lineare Programmierung — Simplex, Dualität und Schattenpreise</a>, <a href="lp.html#sec:lp-lernziele">Kapitel 5: Lineare Programmierung — Simplex, Dualität und Schattenpreise</a><ul class="register-unter"><li>Vorzeichenfalle — <a href="lp.html#sec:lp-die-vorzeichenfalle-bei-schattenpreisen">Kapitel 5: Lineare Programmierung — Simplex, Dualität und Schattenpreise</a></li></ul></div><div class="register-eintrag"><span class="register-begriff">Schätzfehler</span> — <a href="anhang-glossar-literatur.html#anhang-glossar-literatur">Anhang E: Glossar und Literatur</a></div><div class="register-eintrag"><span class="register-begriff">Schlupfvariable</span> — <a href="anhang-glossar-literatur.html#anhang-glossar-literatur">Anhang E: Glossar und Literatur</a>, <a href="lp.html#sec:lp-die-standardform-und-schlupfvariablen">Kapitel 5: Lineare Programmierung — Simplex, Dualität und Schattenpreise</a><ul class="register-unter"><li>gegen Unlösbarkeit — <a href="anhang-modellierungsmuster.html#anhang-modellierungsmuster">Anhang B: Katalog der Modellierungsmuster</a></li></ul></div><div class="register-eintrag"><span class="register-begriff">Schnittebenen</span> — <a href="anhang-glossar-literatur.html#anhang-glossar-literatur">Anhang E: Glossar und Literatur</a>, <a href="milp.html#sec:milp-branch-and-bound">Kapitel 6: Gemischt-ganzzahlige Optimierung — Diskrete Entscheidungen und Branch-and-Bound</a><ul class="register-unter"><li>Gomory-Cuts — <a href="milp.html#sec:milp-branch-and-bound">Kapitel 6: Gemischt-ganzzahlige Optimierung — Diskrete Entscheidungen und Branch-and-Bound</a></li></ul></div><div class="register-eintrag"><span class="register-begriff">SCIP</span> — <a href="milp.html#sec:milp-branch-and-bound">Kapitel 6: Gemischt-ganzzahlige Optimierung — Diskrete Entscheidungen und Branch-and-Bound</a></div><div class="register-eintrag"><span class="register-begriff">Semikontinuierliche Variable</span> — <a href="anhang-modellierungsmuster.html#anhang-modellierungsmuster">Anhang B: Katalog der Modellierungsmuster</a>, <a href="milp.html#sec:milp-modellierungstricks-big-m-und-logische-bedingungen">Kapitel 6: Gemischt-ganzzahlige Optimierung — Diskrete Entscheidungen und Branch-and-Bound</a></div><div class="register-eintrag"><span class="register-begriff">Sensitivitätsanalyse</span> — <a href="anhang-glossar-literatur.html#anhang-glossar-literatur">Anhang E: Glossar und Literatur</a>, <a href="lp.html#sec:lp-praxisfall-sensitivitaetsanalyse-mit-korrekten-schattenpreisen">Kapitel 5: Lineare Programmierung — Simplex, Dualität und Schattenpreise</a></div><div class="register-eintrag"><span class="register-begriff">Shannon-Entropie</span> — <a href="qp-nlp.html#sec:qp-nlp-nichtlineare-optimierung-mit-scipy-optimize-minimize">Kapitel 11: Quadratische und nichtlineare Optimierung — KKT, Lagrange, Konvexität</a></div><div class="register-eintrag"><span class="register-begriff">Sharpe-Ratio</span> — <a href="anhang-glossar-literatur.html#anhang-glossar-literatur">Anhang E: Glossar und Literatur</a>, <a href="markowitz.html#sec:markowitz-das-mean-variance-modell">Kapitel 19: Die moderne Portfoliotheorie nach Markowitz</a></div><div class="register-eintrag"><span class="register-begriff">Simplex-Algorithmus</span> — <a href="anhang-glossar-literatur.html#anhang-glossar-literatur">Anhang E: Glossar und Literatur</a>, <a href="einfuehrung.html#sec:einfuehrung-historischer-kontext-und-evolution">Kapitel 1: Einführung in Operations Research — Vom Ursprung zur mathematischen Entscheidungsfindung</a>, <a href="lp.html#sec:lp-der-simplex-algorithmus-schritt-fuer-schritt">Kapitel 5: Lineare Programmierung — Simplex, Dualität und Schattenpreise</a><ul class="register-unter"><li>Dantzig-Regel — <a href="lp.html#sec:lp-der-simplex-algorithmus-schritt-fuer-schritt">Kapitel 5: Lineare Programmierung — Simplex, Dualität und Schattenpreise</a></li><li>Pivotspalte — <a href="lp.html#sec:lp-der-simplex-algorithmus-schritt-fuer-schritt">Kapitel 5: Lineare Programmierung — Simplex, Dualität und Schattenpreise</a></li><li>Pivotzeile — <a href="lp.html#sec:lp-der-simplex-algorithmus-schritt-fuer-schritt">Kapitel 5: Lineare Programmierung — Simplex, Dualität und Schattenpreise</a></li></ul></div><div class="register-eintrag"><span class="register-begriff">Simulated Annealing</span> — <a href="metaheuristiken.html#sec:metaheuristiken-annealing">Kapitel 9: Metaheuristiken — wenn der exakte Solver aussteigt</a></div><div class="register-eintrag"><span class="register-begriff">Skalarisierung</span> — <a href="mehrziel.html#sec:mehrziel-skalarisierung">Kapitel 14: Mehrere Ziele — Pareto-Fronten statt Gewichte</a></div><div class="register-eintrag"><span class="register-begriff">Skalarprodukt</span> — <a href="fundament.html#sec:fundament-warum-ueberhaupt-vektoren-und-matrizen">Kapitel 2: Das mathematische Fundament — Vektoren, Matrizen, Konvexität</a></div><div class="register-eintrag"><span class="register-begriff">SLSQP</span> — <a href="anhang-glossar-literatur.html#anhang-glossar-literatur">Anhang E: Glossar und Literatur</a>, <a href="qp-nlp.html#sec:qp-nlp-nichtlineare-optimierung-mit-scipy-optimize-minimize">Kapitel 11: Quadratische und nichtlineare Optimierung — KKT, Lagrange, Konvexität</a></div><div class="register-eintrag"><span class="register-begriff">Snapshot-Prinzip</span> — <a href="praxisfallen.html#sec:praxisfallen-architektur-einer-produktionsreifen-or-plattform">Kapitel 22: Praxisfallen und der Weg zum produktiven Einsatz</a></div><div class="register-eintrag"><span class="register-begriff">Starker Dualitätssatz</span> — <a href="lp.html#sec:lp-dualitaet-und-schattenpreise">Kapitel 5: Lineare Programmierung — Simplex, Dualität und Schattenpreise</a></div><div class="register-eintrag"><span class="register-begriff">Stichproben-Kovarianzmatrix</span> — <a href="finanzdaten.html#sec:finanzdaten-das-schaetzfehler-problem">Kapitel 18: Finanzdaten-Modellierung — Renditen, Kovarianz und Shrinkage</a></div><div class="register-eintrag"><span class="register-begriff">Stochastische Programmierung</span> — <a href="unsicherheit.html#sec:unsicherheit-zweistufige-stochastische-programmierung">Kapitel 12: Optimierung unter Unsicherheit — Monte-Carlo, Stochastik, Robustheit</a></div><div class="register-eintrag"><span class="register-begriff">Strafkosten</span> — <a href="einfuehrung.html#sec:einfuehrung-die-vier-universellen-bausteine-jedes-or">Kapitel 1: Einführung in Operations Research — Vom Ursprung zur mathematischen Entscheidungsfindung</a></div><div class="register-eintrag"><span class="register-begriff">Subadditivität</span> — <a href="anhang-glossar-literatur.html#anhang-glossar-literatur">Anhang E: Glossar und Literatur</a>, <a href="cvar.html#sec:cvar-value-at-risk-und-conditional-value">Kapitel 20: Tail-Risiko, CVaR und Transaktionskosten</a></div><div class="register-eintrag"><span class="register-begriff">Subtour</span> — <a href="graphen.html#sec:graphen-das-vehicle-routing-problem-mit-zeitfenstern">Kapitel 8: Graphen, Flüsse und Touren — Min-Cost-Flow, Matching und VRP</a><ul class="register-unter"><li>Eliminierung — <a href="anhang-modellierungsmuster.html#anhang-modellierungsmuster">Anhang B: Katalog der Modellierungsmuster</a></li></ul></div><div class="register-eintrag"><span class="register-begriff">Survivorship-Bias</span> — <a href="anhang-glossar-literatur.html#anhang-glossar-literatur">Anhang E: Glossar und Literatur</a>, <a href="handelsmaschine.html#sec:handelsmaschine-die-fuenf-selbsttaeuschungen-des-backtestens">Kapitel 21: Die vollständige quantitative Handelsmaschine</a></div><div class="register-eintrag"><span class="register-begriff">Symmetriebrechung</span> — <a href="anhang-glossar-literatur.html#anhang-glossar-literatur">Anhang E: Glossar und Literatur</a>, <a href="anhang-modellierungsmuster.html#anhang-modellierungsmuster">Anhang B: Katalog der Modellierungsmuster</a></div><h2 class="register-buchstabe" id="buchstabe-T">T</h2><div class="register-eintrag"><span class="register-begriff">Tabu-Suche</span> — <a href="metaheuristiken.html#sec:metaheuristiken-abgrenzung">Kapitel 9: Metaheuristiken — wenn der exakte Solver aussteigt</a></div><div class="register-eintrag"><span class="register-begriff">Tangentialportfolio</span> — <a href="markowitz.html#sec:markowitz-das-mean-variance-modell">Kapitel 19: Die moderne Portfoliotheorie nach Markowitz</a></div><div class="register-eintrag"><span class="register-begriff">Technologiematrix</span> — <a href="fundament.html#sec:fundament-warum-ueberhaupt-vektoren-und-matrizen">Kapitel 2: Das mathematische Fundament — Vektoren, Matrizen, Konvexität</a></div><div class="register-eintrag"><span class="register-begriff">Totale Unimodularität</span> — <a href="anhang-glossar-literatur.html#anhang-glossar-literatur">Anhang E: Glossar und Literatur</a>, <a href="graphen.html#sec:graphen-lernziele">Kapitel 8: Graphen, Flüsse und Touren — Min-Cost-Flow, Matching und VRP</a></div><div class="register-eintrag"><span class="register-begriff">Transaktionskosten</span> — <a href="anhang-glossar-literatur.html#anhang-glossar-literatur">Anhang E: Glossar und Literatur</a></div><div class="register-eintrag"><span class="register-begriff">Trickle Flow</span> — <a href="anhang-loesungen.html#sec:loesungen-milp">Anhang A: Lösungen zu allen Übungsaufgaben</a></div><div class="register-eintrag"><span class="register-begriff">TSP (Traveling Salesperson Problem)</span> — <a href="graphen.html#sec:graphen-das-vehicle-routing-problem-mit-zeitfenstern">Kapitel 8: Graphen, Flüsse und Touren — Min-Cost-Flow, Matching und VRP</a></div><div class="register-eintrag"><span class="register-begriff">Turnover (Umschlag)</span> — <a href="anhang-glossar-literatur.html#anhang-glossar-literatur">Anhang E: Glossar und Literatur</a>, <a href="cvar.html#sec:cvar-transaktionskosten-ueber-die-l-1-norm">Kapitel 20: Tail-Risiko, CVaR und Transaktionskosten</a></div><div class="register-eintrag"><span class="register-begriff">TWAP</span> — <a href="dynamische-programmierung.html#sec:dynamische-programmierung-das-almgren-chriss-problem-optimale-orderausfuehrung">Kapitel 13: Dynamische Programmierung — Die Bellman-Gleichung und Order-Execution</a></div><h2 class="register-buchstabe" id="buchstabe-U">U</h2><div class="register-eintrag"><span class="register-begriff">Umrüstkosten (Modellierungsmuster)</span> — <a href="anhang-modellierungsmuster.html#anhang-modellierungsmuster">Anhang B: Katalog der Modellierungsmuster</a></div><div class="register-eintrag"><span class="register-begriff">Unbounded (Fehlerbild)</span> — <a href="anhang-fehlerdiagnose.html#anhang-fehlerdiagnose">Anhang C: Fehlerdiagnose-Handbuch</a></div><div class="register-eintrag"><span class="register-begriff">Ungarischer Algorithmus</span> — <a href="graphen.html#sec:graphen-zusammenfassung">Kapitel 8: Graphen, Flüsse und Touren — Min-Cost-Flow, Matching und VRP</a></div><div class="register-eintrag"><span class="register-begriff">Unsicherheitsmenge</span> — <a href="anhang-glossar-literatur.html#anhang-glossar-literatur">Anhang E: Glossar und Literatur</a></div><div class="register-eintrag"><span class="register-begriff">Unsinniges Ergebnis (Fehlerbild)</span> — <a href="anhang-fehlerdiagnose.html#anhang-fehlerdiagnose">Anhang C: Fehlerdiagnose-Handbuch</a></div><h2 class="register-buchstabe" id="buchstabe-V">V</h2><div class="register-eintrag"><span class="register-begriff">Value at Risk (VaR)</span> — <a href="anhang-glossar-literatur.html#anhang-glossar-literatur">Anhang E: Glossar und Literatur</a>, <a href="cvar.html#sec:cvar-value-at-risk-und-conditional-value">Kapitel 20: Tail-Risiko, CVaR und Transaktionskosten</a></div><div class="register-eintrag"><span class="register-begriff">Vehicle Routing Problem (VRP)</span> — <a href="anhang-glossar-literatur.html#anhang-glossar-literatur">Anhang E: Glossar und Literatur</a></div><div class="register-eintrag"><span class="register-begriff">Verdächtig guter Backtest (Fehlerbild)</span> — <a href="anhang-fehlerdiagnose.html#anhang-fehlerdiagnose">Anhang C: Fehlerdiagnose-Handbuch</a></div><div class="register-eintrag"><span class="register-begriff">Verhältnis-Bedingung</span> — <a href="anhang-modellierungsmuster.html#anhang-modellierungsmuster">Anhang B: Katalog der Modellierungsmuster</a></div><div class="register-eintrag"><span class="register-begriff">Vertauschte Spalten (Fehlerbild)</span> — <a href="anhang-fehlerdiagnose.html#anhang-fehlerdiagnose">Anhang C: Fehlerdiagnose-Handbuch</a></div><div class="register-eintrag"><span class="register-begriff">Volatilität</span> — <a href="anhang-glossar-literatur.html#anhang-glossar-literatur">Anhang E: Glossar und Literatur</a></div><div class="register-eintrag"><span class="register-begriff">Vorrangbeziehung</span> — <a href="anhang-modellierungsmuster.html#anhang-modellierungsmuster">Anhang B: Katalog der Modellierungsmuster</a></div><h2 class="register-buchstabe" id="buchstabe-W">W</h2><div class="register-eintrag"><span class="register-begriff">Walk-Forward-Backtest</span> — <a href="anhang-glossar-literatur.html#anhang-glossar-literatur">Anhang E: Glossar und Literatur</a>, <a href="handelsmaschine.html#sec:handelsmaschine-lernziele">Kapitel 21: Die vollständige quantitative Handelsmaschine</a></div><div class="register-eintrag"><span class="register-begriff">Warm-Start</span> — <a href="milp.html#sec:milp-gap">Kapitel 6: Gemischt-ganzzahlige Optimierung — Diskrete Entscheidungen und Branch-and-Bound</a></div><div class="register-eintrag"><span class="register-begriff">Weiche Grenze mit Strafkosten</span> — <a href="anhang-modellierungsmuster.html#anhang-modellierungsmuster">Anhang B: Katalog der Modellierungsmuster</a></div><div class="register-eintrag"><span class="register-begriff">Widersprüchliche Solver (Fehlerbild)</span> — <a href="anhang-fehlerdiagnose.html#anhang-fehlerdiagnose">Anhang C: Fehlerdiagnose-Handbuch</a></div><div class="register-eintrag"><span class="register-begriff">Wurzel-Zeit-Regel</span> — <a href="anhang-glossar-literatur.html#anhang-glossar-literatur">Anhang E: Glossar und Literatur</a></div><h2 class="register-buchstabe" id="buchstabe-Z">Z</h2><div class="register-eintrag"><span class="register-begriff">Zielfunktion</span> — <a href="anhang-glossar-literatur.html#anhang-glossar-literatur">Anhang E: Glossar und Literatur</a>, <a href="einfuehrung.html#sec:einfuehrung-die-vier-universellen-bausteine-jedes-or">Kapitel 1: Einführung in Operations Research — Vom Ursprung zur mathematischen Entscheidungsfindung</a></div><div class="register-eintrag"><span class="register-begriff">Zufallsmatrizentheorie</span> — <a href="finanzdaten.html#sec:finanzdaten-das-schaetzfehler-problem">Kapitel 18: Finanzdaten-Modellierung — Renditen, Kovarianz und Shrinkage</a></div><div class="register-eintrag"><span class="register-begriff">Zulässiger Bereich</span> — <a href="anhang-glossar-literatur.html#anhang-glossar-literatur">Anhang E: Glossar und Literatur</a>, <a href="fundament.html#sec:fundament-der-zulaessige-loesungsraum-und-das-polyeder">Kapitel 2: Das mathematische Fundament — Vektoren, Matrizen, Konvexität</a></div><div class="register-eintrag"><span class="register-begriff">Zuordnungsproblem (1:1)</span> — <a href="anhang-modellierungsmuster.html#anhang-modellierungsmuster">Anhang B: Katalog der Modellierungsmuster</a></div><div class="register-eintrag"><span class="register-begriff">Zustandslosigkeit (OR-Plattform)</span> — <a href="praxisfallen.html#sec:praxisfallen-architektur-einer-produktionsreifen-or-plattform">Kapitel 22: Praxisfallen und der Weg zum produktiven Einsatz</a></div><div class="register-eintrag"><span class="register-begriff">Zustandsraum</span> — <a href="dynamische-programmierung.html#sec:dynamische-programmierung-der-fluch-der-dimensionalitaet">Kapitel 13: Dynamische Programmierung — Die Bellman-Gleichung und Order-Execution</a></div><div class="register-eintrag"><span class="register-begriff">Zwei-Phasen-Simplex-Methode</span> — <a href="anhang-loesungen.html#sec:loesungen-lp">Anhang A: Lösungen zu allen Übungsaufgaben</a></div><div class="register-eintrag"><span class="register-begriff">Zweischichtige Architektur</span> — <a href="oekosystem.html#sec:oekosystem-die-zwei-schichten-architektur">Kapitel 3: Das Python-Ökosystem für OR — Solver, Bindings und Modellierungsschichten</a></div>
     </article>
     
     <nav class="prev-next"><span class="prev-next-leer"></span><span class="prev-next-leer"></span></nav>
diff --git a/OR_HTML_04/supplychain.html b/OR_HTML_04/supplychain.html
index 8e740e3..c6b3550 100644
--- a/OR_HTML_04/supplychain.html
+++ b/OR_HTML_04/supplychain.html
@@ -94,7 +94,7 @@
 </header>
 <div class="site-body">
   <div class="sidebar-overlay" id="sidebar-overlay" hidden></div>
-  <nav class="sidebar" id="sidebar" aria-label="Kapitelnavigation"><div class="sidebar-inhalt"><details class="sidebar-gruppe"><summary>Einstieg</summary><ul><li data-kapitel="vorwort.html"><a href="vorwort.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Vorwort & Lesehilfe</span></a></li><li data-kapitel="notation.html"><a href="notation.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Notation & Abkürzungen</span></a></li></ul></details><details class="sidebar-gruppe"><summary>Teil I: Grundlagen des Operations Research</summary><ul><li data-kapitel="einfuehrung.html"><a href="einfuehrung.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 1: Einführung in Operations Research — Vom Ursprung zur mathematischen Entscheidungsfindung</span></a></li><li data-kapitel="fundament.html"><a href="fundament.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 2: Das mathematische Fundament — Vektoren, Matrizen, Konvexität</span></a></li><li data-kapitel="oekosystem.html"><a href="oekosystem.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 3: Das Python-Ökosystem für OR — Solver, Bindings und Modellierungsschichten</span></a></li><li data-kapitel="modellierung.html"><a href="modellierung.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 4: Vom Management-Wunsch zum Modell</span></a></li></ul></details><details class="sidebar-gruppe"><summary>Teil II: Die Kernverfahren der deterministischen Optimierung</summary><ul><li data-kapitel="lp.html"><a href="lp.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 5: Lineare Programmierung — Simplex, Dualität und Schattenpreise</span></a></li><li data-kapitel="milp.html"><a href="milp.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 6: Gemischt-ganzzahlige Optimierung — Diskrete Entscheidungen und Branch-and-Bound</span></a></li><li data-kapitel="cpsat.html"><a href="cpsat.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 7: Constraint Programming mit CP-SAT — Logik, Scheduling und Zuweisung</span></a></li><li data-kapitel="graphen.html"><a href="graphen.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 8: Graphen, Flüsse und Touren — Min-Cost-Flow, Matching und VRP</span></a></li><li data-kapitel="metaheuristiken.html"><a href="metaheuristiken.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 9: Metaheuristiken — wenn der exakte Solver aussteigt</span></a></li><li data-kapitel="dekomposition.html"><a href="dekomposition.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 10: Spaltengenerierung — das Modell umbauen statt die Lösung raten</span></a></li></ul></details><details class="sidebar-gruppe"><summary>Teil III: Nichtlinearität, Unsicherheit und mehrperiodige Dynamik</summary><ul><li data-kapitel="qp-nlp.html"><a href="qp-nlp.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 11: Quadratische und nichtlineare Optimierung — KKT, Lagrange, Konvexität</span></a></li><li data-kapitel="unsicherheit.html"><a href="unsicherheit.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 12: Optimierung unter Unsicherheit — Monte-Carlo, Stochastik, Robustheit</span></a></li><li data-kapitel="dynamische-programmierung.html"><a href="dynamische-programmierung.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 13: Dynamische Programmierung — Die Bellman-Gleichung und Order-Execution</span></a></li><li data-kapitel="mehrziel.html"><a href="mehrziel.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 14: Mehrere Ziele — Pareto-Fronten statt Gewichte</span></a></li><li data-kapitel="prognose.html"><a href="prognose.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 15: Predict-then-Optimize — die bessere Prognose, die schlechtere Entscheidung</span></a></li></ul></details><details class="sidebar-gruppe" open><summary>Teil IV: Anwendungen — Energiewirtschaft und Finanzmärkte</summary><ul><li data-kapitel="bruecke.html"><a href="bruecke.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 16: Die Strukturbrücke — dieselbe Mathematik, zwei Welten</span></a></li><li data-kapitel="supplychain.html" class="aktiv"><a href="supplychain.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 17: Supply-Chain und Energieeinsatz unter Unsicherheit</span></a></li><li data-kapitel="finanzdaten.html"><a href="finanzdaten.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 18: Finanzdaten-Modellierung — Renditen, Kovarianz und Shrinkage</span></a></li><li data-kapitel="markowitz.html"><a href="markowitz.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 19: Die moderne Portfoliotheorie nach Markowitz</span></a></li><li data-kapitel="cvar.html"><a href="cvar.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 20: Tail-Risiko, CVaR und Transaktionskosten</span></a></li><li data-kapitel="handelsmaschine.html"><a href="handelsmaschine.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 21: Die vollständige quantitative Handelsmaschine</span></a></li></ul></details><details class="sidebar-gruppe"><summary>Teil V: Praxis</summary><ul><li data-kapitel="praxisfallen.html"><a href="praxisfallen.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 22: Praxisfallen und der Weg zum produktiven Einsatz</span></a></li><li data-kapitel="testing.html"><a href="testing.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 23: Testen, Messen, Ausliefern</span></a></li><li data-kapitel="projektwerkstatt.html"><a href="projektwerkstatt.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Projektwerkstatt</span></a></li></ul></details><details class="sidebar-gruppe"><summary>Anhänge</summary><ul><li data-kapitel="anhang-loesungen.html"><a href="anhang-loesungen.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Anhang A: Lösungen zu allen Übungsaufgaben</span></a></li><li data-kapitel="anhang-modellierungsmuster.html"><a href="anhang-modellierungsmuster.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Anhang B: Katalog der Modellierungsmuster</span></a></li><li data-kapitel="anhang-fehlerdiagnose.html"><a href="anhang-fehlerdiagnose.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Anhang C: Fehlerdiagnose-Handbuch</span></a></li><li data-kapitel="anhang-spickzettel.html"><a href="anhang-spickzettel.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Anhang D: Spickzettel der Solver</span></a></li><li data-kapitel="anhang-glossar-literatur.html"><a href="anhang-glossar-literatur.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Anhang E: Glossar und Literatur</span></a></li></ul></details><ul class="sidebar-extra"><li><a href="programme.html"><svg class="icon" aria-hidden="true"><use href="#icon-book"></use></svg> Beispielprogramme</a></li><li><a href="stichwortverzeichnis.html"><svg class="icon" aria-hidden="true"><use href="#icon-search"></use></svg> Stichwortverzeichnis</a></li><li><a href="gesamtdokument.html"><svg class="icon" aria-hidden="true"><use href="#icon-external-link"></use></svg> Gesamtdokument (eine Seite)</a></li><li><a href="Operations_Research_mit_Python_Version_04.pdf" download><svg class="icon" aria-hidden="true"><use href="#icon-download"></use></svg> Download als PDF</a></li></ul></div></nav>
+  <nav class="sidebar" id="sidebar" aria-label="Kapitelnavigation"><div class="sidebar-inhalt"><details class="sidebar-gruppe"><summary>Einstieg</summary><ul><li data-kapitel="vorwort.html"><a href="vorwort.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Vorwort & Lesehilfe</span></a></li><li data-kapitel="notation.html"><a href="notation.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Notation & Abkürzungen</span></a></li></ul></details><details class="sidebar-gruppe"><summary>Teil I: Grundlagen des Operations Research</summary><ul><li data-kapitel="einfuehrung.html"><a href="einfuehrung.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 1: Einführung in Operations Research — Vom Ursprung zur mathematischen Entscheidungsfindung</span></a></li><li data-kapitel="fundament.html"><a href="fundament.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 2: Das mathematische Fundament — Vektoren, Matrizen, Konvexität</span></a></li><li data-kapitel="oekosystem.html"><a href="oekosystem.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 3: Das Python-Ökosystem für OR — Solver, Bindings und Modellierungsschichten</span></a></li><li data-kapitel="modellierung.html"><a href="modellierung.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 4: Vom Management-Wunsch zum Modell</span></a></li><li data-kapitel="synthese-grundlagen.html"><a href="synthese-grundlagen.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Synthese Teil I</span></a></li></ul></details><details class="sidebar-gruppe"><summary>Teil II: Die Kernverfahren der deterministischen Optimierung</summary><ul><li data-kapitel="lp.html"><a href="lp.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 5: Lineare Programmierung — Simplex, Dualität und Schattenpreise</span></a></li><li data-kapitel="milp.html"><a href="milp.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 6: Gemischt-ganzzahlige Optimierung — Diskrete Entscheidungen und Branch-and-Bound</span></a></li><li data-kapitel="cpsat.html"><a href="cpsat.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 7: Constraint Programming mit CP-SAT — Logik, Scheduling und Zuweisung</span></a></li><li data-kapitel="graphen.html"><a href="graphen.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 8: Graphen, Flüsse und Touren — Min-Cost-Flow, Matching und VRP</span></a></li><li data-kapitel="metaheuristiken.html"><a href="metaheuristiken.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 9: Metaheuristiken — wenn der exakte Solver aussteigt</span></a></li><li data-kapitel="dekomposition.html"><a href="dekomposition.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 10: Spaltengenerierung — das Modell umbauen statt die Lösung raten</span></a></li><li data-kapitel="synthese-kernverfahren.html"><a href="synthese-kernverfahren.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Synthese Teil II</span></a></li></ul></details><details class="sidebar-gruppe"><summary>Teil III: Nichtlinearität, Unsicherheit und mehrperiodige Dynamik</summary><ul><li data-kapitel="qp-nlp.html"><a href="qp-nlp.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 11: Quadratische und nichtlineare Optimierung — KKT, Lagrange, Konvexität</span></a></li><li data-kapitel="unsicherheit.html"><a href="unsicherheit.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 12: Optimierung unter Unsicherheit — Monte-Carlo, Stochastik, Robustheit</span></a></li><li data-kapitel="dynamische-programmierung.html"><a href="dynamische-programmierung.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 13: Dynamische Programmierung — Die Bellman-Gleichung und Order-Execution</span></a></li><li data-kapitel="mehrziel.html"><a href="mehrziel.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 14: Mehrere Ziele — Pareto-Fronten statt Gewichte</span></a></li><li data-kapitel="prognose.html"><a href="prognose.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 15: Predict-then-Optimize — die bessere Prognose, die schlechtere Entscheidung</span></a></li><li data-kapitel="synthese-nichtlinear.html"><a href="synthese-nichtlinear.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Synthese Teil III</span></a></li></ul></details><details class="sidebar-gruppe" open><summary>Teil IV: Anwendungen — Energiewirtschaft und Finanzmärkte</summary><ul><li data-kapitel="bruecke.html"><a href="bruecke.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 16: Die Strukturbrücke — dieselbe Mathematik, zwei Welten</span></a></li><li data-kapitel="supplychain.html" class="aktiv"><a href="supplychain.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 17: Supply-Chain und Energieeinsatz unter Unsicherheit</span></a></li><li data-kapitel="finanzdaten.html"><a href="finanzdaten.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 18: Finanzdaten-Modellierung — Renditen, Kovarianz und Shrinkage</span></a></li><li data-kapitel="markowitz.html"><a href="markowitz.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 19: Die moderne Portfoliotheorie nach Markowitz</span></a></li><li data-kapitel="cvar.html"><a href="cvar.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 20: Tail-Risiko, CVaR und Transaktionskosten</span></a></li><li data-kapitel="handelsmaschine.html"><a href="handelsmaschine.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 21: Die vollständige quantitative Handelsmaschine</span></a></li><li data-kapitel="synthese-anwendungen.html"><a href="synthese-anwendungen.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Synthese Teil IV</span></a></li></ul></details><details class="sidebar-gruppe"><summary>Teil V: Praxis</summary><ul><li data-kapitel="praxisfallen.html"><a href="praxisfallen.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 22: Praxisfallen und der Weg zum produktiven Einsatz</span></a></li><li data-kapitel="testing.html"><a href="testing.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 23: Testen, Messen, Ausliefern</span></a></li><li data-kapitel="synthese-praxis.html"><a href="synthese-praxis.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Synthese Teil V</span></a></li><li data-kapitel="projektwerkstatt.html"><a href="projektwerkstatt.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Projektwerkstatt</span></a></li></ul></details><details class="sidebar-gruppe"><summary>Anhänge</summary><ul><li data-kapitel="anhang-loesungen.html"><a href="anhang-loesungen.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Anhang A: Lösungen zu allen Übungsaufgaben</span></a></li><li data-kapitel="anhang-modellierungsmuster.html"><a href="anhang-modellierungsmuster.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Anhang B: Katalog der Modellierungsmuster</span></a></li><li data-kapitel="anhang-fehlerdiagnose.html"><a href="anhang-fehlerdiagnose.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Anhang C: Fehlerdiagnose-Handbuch</span></a></li><li data-kapitel="anhang-spickzettel.html"><a href="anhang-spickzettel.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Anhang D: Spickzettel der Solver</span></a></li><li data-kapitel="anhang-glossar-literatur.html"><a href="anhang-glossar-literatur.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Anhang E: Glossar und Literatur</span></a></li></ul></details><ul class="sidebar-extra"><li><a href="programme.html"><svg class="icon" aria-hidden="true"><use href="#icon-book"></use></svg> Beispielprogramme</a></li><li><a href="stichwortverzeichnis.html"><svg class="icon" aria-hidden="true"><use href="#icon-search"></use></svg> Stichwortverzeichnis</a></li><li><a href="gesamtdokument.html"><svg class="icon" aria-hidden="true"><use href="#icon-external-link"></use></svg> Gesamtdokument (eine Seite)</a></li><li><a href="Operations_Research_mit_Python_Version_04.pdf" download><svg class="icon" aria-hidden="true"><use href="#icon-download"></use></svg> Download als PDF</a></li></ul></div></nav>
   <main class="content">
     <nav class="breadcrumb" aria-label="Breadcrumb"><a href="index.html">Start</a> › <span>Teil IV</span> › <span>Kapitel 17: Supply-Chain und Energieeinsatz unter Unsicherheit</span></nav>
     <nav class="prev-next"><a class="prev-next-knopf prev-next-prev" href="bruecke.html"><svg class="icon" aria-hidden="true"><use href="#icon-chevron-left"></use></svg><span><small>Zurück</small>Kapitel 16: Die Strukturbrücke — dieselbe Mathematik, zwei Welten</span></a><a class="prev-next-knopf prev-next-next" href="finanzdaten.html"><span><small>Weiter</small>Kapitel 18: Finanzdaten-Modellierung — Renditen, Kovarianz und Shrinkage</span><svg class="icon" aria-hidden="true"><use href="#icon-chevron-right"></use></svg></a></nav>
@@ -772,6 +772,16 @@ Was Versorgungssicherheit kostet
 </tbody>
 </table>
 <p>Der Erwartungswert-Plan kostet in der Wirklichkeit <strong>149 % mehr</strong>, und sein schlimmster Tag ist sechsmal so teuer.</p>
+<p><strong>Wofür genau?</strong> Die Summendifferenz von 523 514 € sagt noch nicht, wo sie entsteht. Zerlegt man sie nach Kostenarten, wird aus dem Befund eine Aussage, die man vorlegen kann:</p>
+<figure>
+<img src="bilder_04/kap_supplychain_wirkung.svg" alt="Abb. 17.1: Wofür der Erwartungswert-Plan 149 % mehr bezahlt" />
+<figcaption aria-hidden="true">Abb. 17.1: Wofür der Erwartungswert-Plan 149 % mehr bezahlt</figcaption>
+</figure>
+<p>Drei Dinge stehen darin, die die Tabelle nicht zeigt. Die <strong>Anfahrkosten sind in beiden Plänen gleich</strong> (58 000 €) — der Erwartungswert-Plan spart also nicht dort, wo man es vermuten würde. Er spart <strong>12 725 € Brennstoff</strong>, weil er weniger Blockstunden vorhält. Und er bezahlt dafür <strong>536 239 € Lastabwurf</strong>: das <strong>42-fache</strong> seiner Ersparnis.</p>
+<p>Genau diese Gegenüberstellung ist es, die eine Investitionsentscheidung trägt. „149 % mehr” ist eine Zahl, über die man streiten kann; „wir sparen 12 725 € und riskieren dafür 536 239 €” ist eine, über die man entscheidet.</p>
+<blockquote>
+<p><strong>📌 Zum Diagramm</strong> Es wird von <code>bilder_04/erzeuge_wirkung.py</code> erzeugt, das die Instanz aus <code>Kraftwerkseinsatz.py</code> <strong>erneut rechnet</strong> statt Zahlen zu übernehmen — und dabei die beiden abgedruckten Summen exakt reproduziert. Die Trennung von Brennstoff- und Abwurfkosten ist der einzige Zusatz; das Buchprogramm braucht sie nicht.</p>
+</blockquote>
 <p>Der Unterschied zwischen den beiden Plänen ist dabei erstaunlich klein:</p>
 <pre><code>Erwartungswert   111111122222222211111111  (33 Blockstunden)
 zweistufig       111111222222222222222111  (39 Blockstunden)</code></pre>
diff --git a/OR_HTML_04/synthese-anwendungen.html b/OR_HTML_04/synthese-anwendungen.html
new file mode 100644
index 0000000..62679d4
--- /dev/null
+++ b/OR_HTML_04/synthese-anwendungen.html
@@ -0,0 +1,213 @@
+<!doctype html>
+<html lang="de">
+<head>
+<meta charset="utf-8" />
+<meta name="viewport" content="width=device-width, initial-scale=1" />
+<title>Synthese Teil IV · Optimierte Entscheidungsfindung mit Python</title>
+  <script>
+  (function () {
+    try {
+      var t = localStorage.getItem("or-theme");
+      if (t) document.documentElement.setAttribute("data-theme", t);
+    } catch (e) {}
+  })();
+  </script>
+<link rel="stylesheet" href="assets/highlight.css" />
+  <link rel="stylesheet" href="katex/katex.min.css" />
+  <script defer="" src="katex/katex.min.js"></script>
+  <script>document.addEventListener("DOMContentLoaded", function () {
+ var mathElements = document.getElementsByClassName("math");
+ var macros = [];
+ for (var i = 0; i < mathElements.length; i++) {
+  var texText = mathElements[i].firstChild;
+  if (mathElements[i].tagName == "SPAN") {
+   katex.render(texText.data, mathElements[i], {
+    displayMode: mathElements[i].classList.contains('display'),
+    throwOnError: false,
+    macros: macros,
+    fleqn: false
+   });
+}}
+ // Der Browser springt zu einem #anker in der URL schon beim ersten Rendern
+ // an, BEVOR die KaTeX-Formeln oben im Text ihre finale Hoehe bekommen -
+ // durch den Reflow landet der Anker danach zu weit unten. Nach dem
+ // Formel-Rendering hier erneut zum Anker springen, das behebt es.
+ if (location.hash) {
+  var ziel = document.getElementById(decodeURIComponent(location.hash.slice(1)));
+  if (ziel) ziel.scrollIntoView({behavior: "instant", block: "start"});
+ }
+});
+  </script>
+<link rel="stylesheet" href="assets/site.css" />
+</head>
+<body>
+<svg style="display:none" aria-hidden="true"><symbol id="icon-menu" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round">
+    <line x1="3" y1="6" x2="21" y2="6"/><line x1="3" y1="12" x2="21" y2="12"/><line x1="3" y1="18" x2="21" y2="18"/>
+  </symbol>
+  <symbol id="icon-search" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round">
+    <circle cx="11" cy="11" r="7"/><line x1="21" y1="21" x2="16.2" y2="16.2"/>
+  </symbol>
+  <symbol id="icon-sun" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round">
+    <circle cx="12" cy="12" r="4.5"/>
+    <line x1="12" y1="1.5" x2="12" y2="4"/><line x1="12" y1="20" x2="12" y2="22.5"/>
+    <line x1="1.5" y1="12" x2="4" y2="12"/><line x1="20" y1="12" x2="22.5" y2="12"/>
+    <line x1="4.5" y1="4.5" x2="6.2" y2="6.2"/><line x1="17.8" y1="17.8" x2="19.5" y2="19.5"/>
+    <line x1="19.5" y1="4.5" x2="17.8" y2="6.2"/><line x1="6.2" y1="17.8" x2="4.5" y2="19.5"/>
+  </symbol>
+  <symbol id="icon-moon" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round">
+    <path d="M20 14.5A8.5 8.5 0 1 1 9.5 4a6.8 6.8 0 0 0 10.5 10.5z"/>
+  </symbol>
+  <symbol id="icon-chevron-left" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round">
+    <polyline points="15 4 7 12 15 20"/>
+  </symbol>
+  <symbol id="icon-chevron-right" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round">
+    <polyline points="9 4 17 12 9 20"/>
+  </symbol>
+  <symbol id="icon-check" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round">
+    <polyline points="4 13 9.5 18.5 20 6"/>
+  </symbol>
+  <symbol id="icon-external-link" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round">
+    <path d="M18 13.5V19a1.5 1.5 0 0 1-1.5 1.5H5A1.5 1.5 0 0 1 3.5 19V7A1.5 1.5 0 0 1 5 5.5h5.5"/>
+    <polyline points="14.5 3.5 20.5 3.5 20.5 9.5"/><line x1="11" y1="13" x2="20" y2="4"/>
+  </symbol>
+  <symbol id="icon-book" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round">
+    <path d="M4 5.5A2 2 0 0 1 6 4h6v16H6a2 2 0 0 0-2 1.5z"/>
+    <path d="M20 5.5A2 2 0 0 0 18 4h-6v16h6a2 2 0 0 1 2 1.5z"/>
+  </symbol>
+  <symbol id="icon-copy" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round">
+    <rect x="9" y="9" width="13" height="13" rx="2"/><path d="M5 15H4a2 2 0 0 1-2-2V4a2 2 0 0 1 2-2h9a2 2 0 0 1 2 2v1"/>
+  </symbol>
+  <symbol id="icon-download" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round">
+    <path d="M12 3v12"/><polyline points="7 10 12 15 17 10"/><path d="M4 19.5h16"/>
+  </symbol></svg>
+<header class="site-header">
+  <button type="button" class="icon-btn" id="sidebar-toggle" aria-label="Menü öffnen"><svg class="icon" aria-hidden="true"><use href="#icon-menu"></use></svg></button>
+  <a class="brand" href="index.html"><svg class="icon" aria-hidden="true"><use href="#icon-book"></use></svg> <span>Optimierte Entscheidungsfindung mit Python</span></a>
+  <div class="site-search">
+    <input id="suche-eingabe" type="search" placeholder="Suchen …" aria-label="Suche" autocomplete="off" />
+    <svg class="icon such-icon" aria-hidden="true"><use href="#icon-search"></use></svg>
+    <div id="suche-ergebnisse" class="suche-ergebnisse" hidden></div>
+  </div>
+  <button type="button" class="icon-btn" id="theme-toggle" aria-label="Darstellung umschalten">
+    <svg class="icon icon-sun" aria-hidden="true"><use href="#icon-sun"></use></svg><svg class="icon icon-moon" aria-hidden="true"><use href="#icon-moon"></use></svg>
+  </button>
+</header>
+<div class="site-body">
+  <div class="sidebar-overlay" id="sidebar-overlay" hidden></div>
+  <nav class="sidebar" id="sidebar" aria-label="Kapitelnavigation"><div class="sidebar-inhalt"><details class="sidebar-gruppe"><summary>Einstieg</summary><ul><li data-kapitel="vorwort.html"><a href="vorwort.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Vorwort & Lesehilfe</span></a></li><li data-kapitel="notation.html"><a href="notation.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Notation & Abkürzungen</span></a></li></ul></details><details class="sidebar-gruppe"><summary>Teil I: Grundlagen des Operations Research</summary><ul><li data-kapitel="einfuehrung.html"><a href="einfuehrung.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 1: Einführung in Operations Research — Vom Ursprung zur mathematischen Entscheidungsfindung</span></a></li><li data-kapitel="fundament.html"><a href="fundament.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 2: Das mathematische Fundament — Vektoren, Matrizen, Konvexität</span></a></li><li data-kapitel="oekosystem.html"><a href="oekosystem.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 3: Das Python-Ökosystem für OR — Solver, Bindings und Modellierungsschichten</span></a></li><li data-kapitel="modellierung.html"><a href="modellierung.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 4: Vom Management-Wunsch zum Modell</span></a></li><li data-kapitel="synthese-grundlagen.html"><a href="synthese-grundlagen.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Synthese Teil I</span></a></li></ul></details><details class="sidebar-gruppe"><summary>Teil II: Die Kernverfahren der deterministischen Optimierung</summary><ul><li data-kapitel="lp.html"><a href="lp.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 5: Lineare Programmierung — Simplex, Dualität und Schattenpreise</span></a></li><li data-kapitel="milp.html"><a href="milp.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 6: Gemischt-ganzzahlige Optimierung — Diskrete Entscheidungen und Branch-and-Bound</span></a></li><li data-kapitel="cpsat.html"><a href="cpsat.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 7: Constraint Programming mit CP-SAT — Logik, Scheduling und Zuweisung</span></a></li><li data-kapitel="graphen.html"><a href="graphen.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 8: Graphen, Flüsse und Touren — Min-Cost-Flow, Matching und VRP</span></a></li><li data-kapitel="metaheuristiken.html"><a href="metaheuristiken.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 9: Metaheuristiken — wenn der exakte Solver aussteigt</span></a></li><li data-kapitel="dekomposition.html"><a href="dekomposition.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 10: Spaltengenerierung — das Modell umbauen statt die Lösung raten</span></a></li><li data-kapitel="synthese-kernverfahren.html"><a href="synthese-kernverfahren.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Synthese Teil II</span></a></li></ul></details><details class="sidebar-gruppe"><summary>Teil III: Nichtlinearität, Unsicherheit und mehrperiodige Dynamik</summary><ul><li data-kapitel="qp-nlp.html"><a href="qp-nlp.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 11: Quadratische und nichtlineare Optimierung — KKT, Lagrange, Konvexität</span></a></li><li data-kapitel="unsicherheit.html"><a href="unsicherheit.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 12: Optimierung unter Unsicherheit — Monte-Carlo, Stochastik, Robustheit</span></a></li><li data-kapitel="dynamische-programmierung.html"><a href="dynamische-programmierung.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 13: Dynamische Programmierung — Die Bellman-Gleichung und Order-Execution</span></a></li><li data-kapitel="mehrziel.html"><a href="mehrziel.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 14: Mehrere Ziele — Pareto-Fronten statt Gewichte</span></a></li><li data-kapitel="prognose.html"><a href="prognose.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 15: Predict-then-Optimize — die bessere Prognose, die schlechtere Entscheidung</span></a></li><li data-kapitel="synthese-nichtlinear.html"><a href="synthese-nichtlinear.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Synthese Teil III</span></a></li></ul></details><details class="sidebar-gruppe" open><summary>Teil IV: Anwendungen — Energiewirtschaft und Finanzmärkte</summary><ul><li data-kapitel="bruecke.html"><a href="bruecke.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 16: Die Strukturbrücke — dieselbe Mathematik, zwei Welten</span></a></li><li data-kapitel="supplychain.html"><a href="supplychain.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 17: Supply-Chain und Energieeinsatz unter Unsicherheit</span></a></li><li data-kapitel="finanzdaten.html"><a href="finanzdaten.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 18: Finanzdaten-Modellierung — Renditen, Kovarianz und Shrinkage</span></a></li><li data-kapitel="markowitz.html"><a href="markowitz.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 19: Die moderne Portfoliotheorie nach Markowitz</span></a></li><li data-kapitel="cvar.html"><a href="cvar.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 20: Tail-Risiko, CVaR und Transaktionskosten</span></a></li><li data-kapitel="handelsmaschine.html"><a href="handelsmaschine.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 21: Die vollständige quantitative Handelsmaschine</span></a></li><li data-kapitel="synthese-anwendungen.html" class="aktiv"><a href="synthese-anwendungen.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Synthese Teil IV</span></a></li></ul></details><details class="sidebar-gruppe"><summary>Teil V: Praxis</summary><ul><li data-kapitel="praxisfallen.html"><a href="praxisfallen.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 22: Praxisfallen und der Weg zum produktiven Einsatz</span></a></li><li data-kapitel="testing.html"><a href="testing.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 23: Testen, Messen, Ausliefern</span></a></li><li data-kapitel="synthese-praxis.html"><a href="synthese-praxis.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Synthese Teil V</span></a></li><li data-kapitel="projektwerkstatt.html"><a href="projektwerkstatt.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Projektwerkstatt</span></a></li></ul></details><details class="sidebar-gruppe"><summary>Anhänge</summary><ul><li data-kapitel="anhang-loesungen.html"><a href="anhang-loesungen.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Anhang A: Lösungen zu allen Übungsaufgaben</span></a></li><li data-kapitel="anhang-modellierungsmuster.html"><a href="anhang-modellierungsmuster.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Anhang B: Katalog der Modellierungsmuster</span></a></li><li data-kapitel="anhang-fehlerdiagnose.html"><a href="anhang-fehlerdiagnose.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Anhang C: Fehlerdiagnose-Handbuch</span></a></li><li data-kapitel="anhang-spickzettel.html"><a href="anhang-spickzettel.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Anhang D: Spickzettel der Solver</span></a></li><li data-kapitel="anhang-glossar-literatur.html"><a href="anhang-glossar-literatur.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Anhang E: Glossar und Literatur</span></a></li></ul></details><ul class="sidebar-extra"><li><a href="programme.html"><svg class="icon" aria-hidden="true"><use href="#icon-book"></use></svg> Beispielprogramme</a></li><li><a href="stichwortverzeichnis.html"><svg class="icon" aria-hidden="true"><use href="#icon-search"></use></svg> Stichwortverzeichnis</a></li><li><a href="gesamtdokument.html"><svg class="icon" aria-hidden="true"><use href="#icon-external-link"></use></svg> Gesamtdokument (eine Seite)</a></li><li><a href="Operations_Research_mit_Python_Version_04.pdf" download><svg class="icon" aria-hidden="true"><use href="#icon-download"></use></svg> Download als PDF</a></li></ul></div></nav>
+  <main class="content">
+    <nav class="breadcrumb" aria-label="Breadcrumb"><a href="index.html">Start</a> › <span>Teil IV</span> › <span>Synthese Teil IV</span></nav>
+    <nav class="prev-next"><a class="prev-next-knopf prev-next-prev" href="handelsmaschine.html"><svg class="icon" aria-hidden="true"><use href="#icon-chevron-left"></use></svg><span><small>Zurück</small>Kapitel 21: Die vollständige quantitative Handelsmaschine</span></a><a class="prev-next-knopf prev-next-next" href="praxisfallen.html"><span><small>Weiter</small>Kapitel 22: Praxisfallen und der Weg zum produktiven Einsatz</span><svg class="icon" aria-hidden="true"><use href="#icon-chevron-right"></use></svg></a></nav>
+    <article>
+    <h1 id="synthese-teil-iv-zwei-domänen-dieselbe-mathematik">Synthese Teil IV — Zwei Domänen, dieselbe Mathematik</h1>
+<p>Sechs Kapitel, zwei Branchen, die sich für unvergleichbar halten. Die Werkstatt plant Maschinen, das Depot plant Titel — und beide lösen dasselbe Problem: <strong>knappe Mittel auf konkurrierende Verwendungen verteilen, unter Unsicherheit.</strong></p>
+<h2 id="dieselbe-struktur-andere-namen">Dieselbe Struktur, andere Namen</h2>
+<table>
+<colgroup>
+<col style="width: 33%" />
+<col style="width: 33%" />
+<col style="width: 33%" />
+</colgroup>
+<thead>
+<tr class="header">
+<th>Werkstatt und Kraftwerk</th>
+<th>Depot und Handel</th>
+<th>Was mathematisch dahintersteht</th>
+</tr>
+</thead>
+<tbody>
+<tr class="odd">
+<td>Produkt, Maschinenstunde</td>
+<td>Titel, Kapital</td>
+<td>Entscheidungsvariable</td>
+</tr>
+<tr class="even">
+<td>Deckungsbeitrag</td>
+<td>erwartete Rendite</td>
+<td>linearer Zielterm</td>
+</tr>
+<tr class="odd">
+<td>Kapazität, Liefervertrag</td>
+<td>Positionsgrenze, Sektorlimit</td>
+<td>Nebenbedingung</td>
+</tr>
+<tr class="even">
+<td>Rüstkosten, Anfahrkosten</td>
+<td>Transaktionskosten</td>
+<td>Fixkosten mit Binärvariable (B1)</td>
+</tr>
+<tr class="odd">
+<td>Lastabwurf, Konventionalstrafe</td>
+<td>Tail-Verlust</td>
+<td>Straf- bzw. Risikoterm</td>
+</tr>
+<tr class="even">
+<td>Wind- und Nachfrageszenarien</td>
+<td>Renditeszenarien</td>
+<td>Szenariomenge</td>
+</tr>
+</tbody>
+</table>
+<p><strong>Und wo die Analogie endet</strong>, benennt <a href="bruecke.html#kap-bruecke">Kapitel 16</a> an drei Stellen ausdrücklich — das ist der wertvollere Teil. Eine Analogie, die man nicht begrenzen kann, ist keine Erkenntnis, sondern eine Redewendung.</p>
+<h2 id="was-dieser-teil-gemessen-hat">Was dieser Teil gemessen hat</h2>
+<table>
+<colgroup>
+<col style="width: 33%" />
+<col style="width: 33%" />
+<col style="width: 33%" />
+</colgroup>
+<thead>
+<tr class="header">
+<th>Behauptung</th>
+<th>Gemessen</th>
+<th>Wo</th>
+</tr>
+</thead>
+<tbody>
+<tr class="odd">
+<td>„Planen mit der Prognose ist gut genug.”</td>
+<td>Der Erwartungswert-Plan kostet <strong>149 % mehr</strong> (874 870 € statt 351 356 €) und wirft in <strong>28 von 40</strong> Szenarien Last ab</td>
+<td><a href="supplychain.html#kap-supplychain">Kapitel 17</a></td>
+</tr>
+<tr class="even">
+<td>„Dann sparen wir eben beim Brennstoff.”</td>
+<td>Genau das tut er: 12 725 € gespart, <strong>536 239 €</strong> Lastabwurf bezahlt — das 42-fache. Die Anfahrkosten sind in beiden Plänen gleich</td>
+<td><a href="supplychain.html#kap-supplychain">Kapitel 17</a></td>
+</tr>
+<tr class="odd">
+<td>„Der VaR sagt, wie riskant es ist.”</td>
+<td>VaR <strong>1,86 %</strong>, CVaR <strong>2,99 %</strong> — und der schlechteste Tag der Stichprobe (<strong>−23,0 %</strong>) ändert am VaR <strong>nichts</strong></td>
+<td><a href="cvar.html#kap-cvar">Kapitel 20</a></td>
+</tr>
+<tr class="even">
+<td>„Die Kovarianzmatrix ist eine Eingabe wie jede andere.”</td>
+<td>Aus kurzen Reihen geschätzt ist sie schlecht konditioniert; die Optimierung setzt dann auf Schätzrauschen</td>
+<td><a href="finanzdaten.html#kap-finanzdaten">Kapitel 18</a></td>
+</tr>
+</tbody>
+</table>
+<h2 id="drei-fehler-die-dieser-teil-verhindert">Drei Fehler, die dieser Teil verhindert</h2>
+<ol type="1">
+<li><strong>Bei Markowitz einsteigen.</strong> Wer <a href="finanzdaten.html#kap-finanzdaten">Kapitel 18</a> überspringt, optimiert seine eigenen Schätzfehler und wundert sich über Gewichte, die niemand halten würde.</li>
+<li><strong>Den VaR für ein Risikomaß halten.</strong> Er sagt, <strong>ob</strong> die Schwelle gerissen wird, nicht <strong>wie schlimm</strong> es dahinter aussieht — und er ist nicht kohärent. Optimiert wird der CVaR.</li>
+<li><strong>Trägheit unterschätzen.</strong> Im Kraftwerkspark ist nicht die Prognosegüte das Problem, sondern dass sich ein Block mit acht Stunden Mindestlaufzeit um 18 Uhr nicht mehr herbeirufen lässt. Dieselbe Trägheit heißt im Depot Transaktionskosten.</li>
+</ol>
+<h2 id="wenn-sie-nur-eines-mitnehmen">Wenn Sie nur eines mitnehmen</h2>
+<blockquote>
+<p><strong>🎯</strong> Wer die Struktur erkennt, kann sein Werkzeug mitnehmen, wenn er die Branche wechselt. Wer nur die Bibliothek kennt, fängt jedes Mal von vorn an — und wer die Grenzen der Analogie nicht kennt, überträgt irgendwann auch das, was nicht überträgt.</p>
+</blockquote>
+
+    </article>
+    
+    <nav class="prev-next"><a class="prev-next-knopf prev-next-prev" href="handelsmaschine.html"><svg class="icon" aria-hidden="true"><use href="#icon-chevron-left"></use></svg><span><small>Zurück</small>Kapitel 21: Die vollständige quantitative Handelsmaschine</span></a><a class="prev-next-knopf prev-next-next" href="praxisfallen.html"><span><small>Weiter</small>Kapitel 22: Praxisfallen und der Weg zum produktiven Einsatz</span><svg class="icon" aria-hidden="true"><use href="#icon-chevron-right"></use></svg></a></nav>
+  </main>
+</div>
+<footer class="site-footer">
+  <p>© Dieter Schlüter · <a href="gesamtdokument.html">Gesamtdokument</a> ·
+  <a href="programme.html">Beispielprogramme</a></p>
+</footer>
+<script defer src="assets/search-index.js"></script>
+<script defer src="assets/programme.js"></script>
+<script defer src="assets/site.js"></script>
+</body>
+</html>
diff --git a/OR_HTML_04/synthese-grundlagen.html b/OR_HTML_04/synthese-grundlagen.html
new file mode 100644
index 0000000..68b539a
--- /dev/null
+++ b/OR_HTML_04/synthese-grundlagen.html
@@ -0,0 +1,167 @@
+<!doctype html>
+<html lang="de">
+<head>
+<meta charset="utf-8" />
+<meta name="viewport" content="width=device-width, initial-scale=1" />
+<title>Synthese Teil I · Optimierte Entscheidungsfindung mit Python</title>
+  <script>
+  (function () {
+    try {
+      var t = localStorage.getItem("or-theme");
+      if (t) document.documentElement.setAttribute("data-theme", t);
+    } catch (e) {}
+  })();
+  </script>
+<link rel="stylesheet" href="assets/highlight.css" />
+  <link rel="stylesheet" href="katex/katex.min.css" />
+  <script defer="" src="katex/katex.min.js"></script>
+  <script>document.addEventListener("DOMContentLoaded", function () {
+ var mathElements = document.getElementsByClassName("math");
+ var macros = [];
+ for (var i = 0; i < mathElements.length; i++) {
+  var texText = mathElements[i].firstChild;
+  if (mathElements[i].tagName == "SPAN") {
+   katex.render(texText.data, mathElements[i], {
+    displayMode: mathElements[i].classList.contains('display'),
+    throwOnError: false,
+    macros: macros,
+    fleqn: false
+   });
+}}
+ // Der Browser springt zu einem #anker in der URL schon beim ersten Rendern
+ // an, BEVOR die KaTeX-Formeln oben im Text ihre finale Hoehe bekommen -
+ // durch den Reflow landet der Anker danach zu weit unten. Nach dem
+ // Formel-Rendering hier erneut zum Anker springen, das behebt es.
+ if (location.hash) {
+  var ziel = document.getElementById(decodeURIComponent(location.hash.slice(1)));
+  if (ziel) ziel.scrollIntoView({behavior: "instant", block: "start"});
+ }
+});
+  </script>
+<link rel="stylesheet" href="assets/site.css" />
+</head>
+<body>
+<svg style="display:none" aria-hidden="true"><symbol id="icon-menu" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round">
+    <line x1="3" y1="6" x2="21" y2="6"/><line x1="3" y1="12" x2="21" y2="12"/><line x1="3" y1="18" x2="21" y2="18"/>
+  </symbol>
+  <symbol id="icon-search" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round">
+    <circle cx="11" cy="11" r="7"/><line x1="21" y1="21" x2="16.2" y2="16.2"/>
+  </symbol>
+  <symbol id="icon-sun" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round">
+    <circle cx="12" cy="12" r="4.5"/>
+    <line x1="12" y1="1.5" x2="12" y2="4"/><line x1="12" y1="20" x2="12" y2="22.5"/>
+    <line x1="1.5" y1="12" x2="4" y2="12"/><line x1="20" y1="12" x2="22.5" y2="12"/>
+    <line x1="4.5" y1="4.5" x2="6.2" y2="6.2"/><line x1="17.8" y1="17.8" x2="19.5" y2="19.5"/>
+    <line x1="19.5" y1="4.5" x2="17.8" y2="6.2"/><line x1="6.2" y1="17.8" x2="4.5" y2="19.5"/>
+  </symbol>
+  <symbol id="icon-moon" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round">
+    <path d="M20 14.5A8.5 8.5 0 1 1 9.5 4a6.8 6.8 0 0 0 10.5 10.5z"/>
+  </symbol>
+  <symbol id="icon-chevron-left" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round">
+    <polyline points="15 4 7 12 15 20"/>
+  </symbol>
+  <symbol id="icon-chevron-right" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round">
+    <polyline points="9 4 17 12 9 20"/>
+  </symbol>
+  <symbol id="icon-check" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round">
+    <polyline points="4 13 9.5 18.5 20 6"/>
+  </symbol>
+  <symbol id="icon-external-link" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round">
+    <path d="M18 13.5V19a1.5 1.5 0 0 1-1.5 1.5H5A1.5 1.5 0 0 1 3.5 19V7A1.5 1.5 0 0 1 5 5.5h5.5"/>
+    <polyline points="14.5 3.5 20.5 3.5 20.5 9.5"/><line x1="11" y1="13" x2="20" y2="4"/>
+  </symbol>
+  <symbol id="icon-book" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round">
+    <path d="M4 5.5A2 2 0 0 1 6 4h6v16H6a2 2 0 0 0-2 1.5z"/>
+    <path d="M20 5.5A2 2 0 0 0 18 4h-6v16h6a2 2 0 0 1 2 1.5z"/>
+  </symbol>
+  <symbol id="icon-copy" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round">
+    <rect x="9" y="9" width="13" height="13" rx="2"/><path d="M5 15H4a2 2 0 0 1-2-2V4a2 2 0 0 1 2-2h9a2 2 0 0 1 2 2v1"/>
+  </symbol>
+  <symbol id="icon-download" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round">
+    <path d="M12 3v12"/><polyline points="7 10 12 15 17 10"/><path d="M4 19.5h16"/>
+  </symbol></svg>
+<header class="site-header">
+  <button type="button" class="icon-btn" id="sidebar-toggle" aria-label="Menü öffnen"><svg class="icon" aria-hidden="true"><use href="#icon-menu"></use></svg></button>
+  <a class="brand" href="index.html"><svg class="icon" aria-hidden="true"><use href="#icon-book"></use></svg> <span>Optimierte Entscheidungsfindung mit Python</span></a>
+  <div class="site-search">
+    <input id="suche-eingabe" type="search" placeholder="Suchen …" aria-label="Suche" autocomplete="off" />
+    <svg class="icon such-icon" aria-hidden="true"><use href="#icon-search"></use></svg>
+    <div id="suche-ergebnisse" class="suche-ergebnisse" hidden></div>
+  </div>
+  <button type="button" class="icon-btn" id="theme-toggle" aria-label="Darstellung umschalten">
+    <svg class="icon icon-sun" aria-hidden="true"><use href="#icon-sun"></use></svg><svg class="icon icon-moon" aria-hidden="true"><use href="#icon-moon"></use></svg>
+  </button>
+</header>
+<div class="site-body">
+  <div class="sidebar-overlay" id="sidebar-overlay" hidden></div>
+  <nav class="sidebar" id="sidebar" aria-label="Kapitelnavigation"><div class="sidebar-inhalt"><details class="sidebar-gruppe"><summary>Einstieg</summary><ul><li data-kapitel="vorwort.html"><a href="vorwort.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Vorwort & Lesehilfe</span></a></li><li data-kapitel="notation.html"><a href="notation.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Notation & Abkürzungen</span></a></li></ul></details><details class="sidebar-gruppe" open><summary>Teil I: Grundlagen des Operations Research</summary><ul><li data-kapitel="einfuehrung.html"><a href="einfuehrung.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 1: Einführung in Operations Research — Vom Ursprung zur mathematischen Entscheidungsfindung</span></a></li><li data-kapitel="fundament.html"><a href="fundament.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 2: Das mathematische Fundament — Vektoren, Matrizen, Konvexität</span></a></li><li data-kapitel="oekosystem.html"><a href="oekosystem.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 3: Das Python-Ökosystem für OR — Solver, Bindings und Modellierungsschichten</span></a></li><li data-kapitel="modellierung.html"><a href="modellierung.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 4: Vom Management-Wunsch zum Modell</span></a></li><li data-kapitel="synthese-grundlagen.html" class="aktiv"><a href="synthese-grundlagen.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Synthese Teil I</span></a></li></ul></details><details class="sidebar-gruppe"><summary>Teil II: Die Kernverfahren der deterministischen Optimierung</summary><ul><li data-kapitel="lp.html"><a href="lp.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 5: Lineare Programmierung — Simplex, Dualität und Schattenpreise</span></a></li><li data-kapitel="milp.html"><a href="milp.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 6: Gemischt-ganzzahlige Optimierung — Diskrete Entscheidungen und Branch-and-Bound</span></a></li><li data-kapitel="cpsat.html"><a href="cpsat.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 7: Constraint Programming mit CP-SAT — Logik, Scheduling und Zuweisung</span></a></li><li data-kapitel="graphen.html"><a href="graphen.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 8: Graphen, Flüsse und Touren — Min-Cost-Flow, Matching und VRP</span></a></li><li data-kapitel="metaheuristiken.html"><a href="metaheuristiken.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 9: Metaheuristiken — wenn der exakte Solver aussteigt</span></a></li><li data-kapitel="dekomposition.html"><a href="dekomposition.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 10: Spaltengenerierung — das Modell umbauen statt die Lösung raten</span></a></li><li data-kapitel="synthese-kernverfahren.html"><a href="synthese-kernverfahren.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Synthese Teil II</span></a></li></ul></details><details class="sidebar-gruppe"><summary>Teil III: Nichtlinearität, Unsicherheit und mehrperiodige Dynamik</summary><ul><li data-kapitel="qp-nlp.html"><a href="qp-nlp.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 11: Quadratische und nichtlineare Optimierung — KKT, Lagrange, Konvexität</span></a></li><li data-kapitel="unsicherheit.html"><a href="unsicherheit.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 12: Optimierung unter Unsicherheit — Monte-Carlo, Stochastik, Robustheit</span></a></li><li data-kapitel="dynamische-programmierung.html"><a href="dynamische-programmierung.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 13: Dynamische Programmierung — Die Bellman-Gleichung und Order-Execution</span></a></li><li data-kapitel="mehrziel.html"><a href="mehrziel.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 14: Mehrere Ziele — Pareto-Fronten statt Gewichte</span></a></li><li data-kapitel="prognose.html"><a href="prognose.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 15: Predict-then-Optimize — die bessere Prognose, die schlechtere Entscheidung</span></a></li><li data-kapitel="synthese-nichtlinear.html"><a href="synthese-nichtlinear.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Synthese Teil III</span></a></li></ul></details><details class="sidebar-gruppe"><summary>Teil IV: Anwendungen — Energiewirtschaft und Finanzmärkte</summary><ul><li data-kapitel="bruecke.html"><a href="bruecke.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 16: Die Strukturbrücke — dieselbe Mathematik, zwei Welten</span></a></li><li data-kapitel="supplychain.html"><a href="supplychain.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 17: Supply-Chain und Energieeinsatz unter Unsicherheit</span></a></li><li data-kapitel="finanzdaten.html"><a href="finanzdaten.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 18: Finanzdaten-Modellierung — Renditen, Kovarianz und Shrinkage</span></a></li><li data-kapitel="markowitz.html"><a href="markowitz.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 19: Die moderne Portfoliotheorie nach Markowitz</span></a></li><li data-kapitel="cvar.html"><a href="cvar.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 20: Tail-Risiko, CVaR und Transaktionskosten</span></a></li><li data-kapitel="handelsmaschine.html"><a href="handelsmaschine.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 21: Die vollständige quantitative Handelsmaschine</span></a></li><li data-kapitel="synthese-anwendungen.html"><a href="synthese-anwendungen.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Synthese Teil IV</span></a></li></ul></details><details class="sidebar-gruppe"><summary>Teil V: Praxis</summary><ul><li data-kapitel="praxisfallen.html"><a href="praxisfallen.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 22: Praxisfallen und der Weg zum produktiven Einsatz</span></a></li><li data-kapitel="testing.html"><a href="testing.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 23: Testen, Messen, Ausliefern</span></a></li><li data-kapitel="synthese-praxis.html"><a href="synthese-praxis.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Synthese Teil V</span></a></li><li data-kapitel="projektwerkstatt.html"><a href="projektwerkstatt.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Projektwerkstatt</span></a></li></ul></details><details class="sidebar-gruppe"><summary>Anhänge</summary><ul><li data-kapitel="anhang-loesungen.html"><a href="anhang-loesungen.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Anhang A: Lösungen zu allen Übungsaufgaben</span></a></li><li data-kapitel="anhang-modellierungsmuster.html"><a href="anhang-modellierungsmuster.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Anhang B: Katalog der Modellierungsmuster</span></a></li><li data-kapitel="anhang-fehlerdiagnose.html"><a href="anhang-fehlerdiagnose.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Anhang C: Fehlerdiagnose-Handbuch</span></a></li><li data-kapitel="anhang-spickzettel.html"><a href="anhang-spickzettel.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Anhang D: Spickzettel der Solver</span></a></li><li data-kapitel="anhang-glossar-literatur.html"><a href="anhang-glossar-literatur.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Anhang E: Glossar und Literatur</span></a></li></ul></details><ul class="sidebar-extra"><li><a href="programme.html"><svg class="icon" aria-hidden="true"><use href="#icon-book"></use></svg> Beispielprogramme</a></li><li><a href="stichwortverzeichnis.html"><svg class="icon" aria-hidden="true"><use href="#icon-search"></use></svg> Stichwortverzeichnis</a></li><li><a href="gesamtdokument.html"><svg class="icon" aria-hidden="true"><use href="#icon-external-link"></use></svg> Gesamtdokument (eine Seite)</a></li><li><a href="Operations_Research_mit_Python_Version_04.pdf" download><svg class="icon" aria-hidden="true"><use href="#icon-download"></use></svg> Download als PDF</a></li></ul></div></nav>
+  <main class="content">
+    <nav class="breadcrumb" aria-label="Breadcrumb"><a href="index.html">Start</a> › <span>Teil I</span> › <span>Synthese Teil I</span></nav>
+    <nav class="prev-next"><a class="prev-next-knopf prev-next-prev" href="modellierung.html"><svg class="icon" aria-hidden="true"><use href="#icon-chevron-left"></use></svg><span><small>Zurück</small>Kapitel 4: Vom Management-Wunsch zum Modell</span></a><a class="prev-next-knopf prev-next-next" href="lp.html"><span><small>Weiter</small>Kapitel 5: Lineare Programmierung — Simplex, Dualität und Schattenpreise</span><svg class="icon" aria-hidden="true"><use href="#icon-chevron-right"></use></svg></a></nav>
+    <article>
+    <h1 id="synthese-teil-i-grundlagen-auf-einen-blick">Synthese Teil I — Grundlagen auf einen Blick</h1>
+<p>Vier Kapitel, eine Frage: <strong>Was muss vorliegen, bevor ein Solver überhaupt sinnvoll gestartet werden kann?</strong> Die Antwort ist unbequem, weil das meiste davon nichts mit Programmieren zu tun hat.</p>
+<h2 id="was-welches-kapitel-klärt">Was welches Kapitel klärt</h2>
+<table>
+<colgroup>
+<col style="width: 33%" />
+<col style="width: 33%" />
+<col style="width: 33%" />
+</colgroup>
+<thead>
+<tr class="header">
+<th>Frage</th>
+<th>Kapitel</th>
+<th>Was Sie danach können</th>
+</tr>
+</thead>
+<tbody>
+<tr class="odd">
+<td>Was ist überhaupt ein Optimierungsmodell?</td>
+<td><a href="einfuehrung.html#kap-einfuehrung">Kapitel 1</a></td>
+<td>Die vier Bausteine benennen — Variablen, Zielfunktion, Nebenbedingungen, Daten — und sie in einem fremden Problem wiedererkennen</td>
+</tr>
+<tr class="even">
+<td>Warum rechnet der Solver falsch, obwohl das Modell stimmt?</td>
+<td><a href="fundament.html#kap-fundament">Kapitel 2</a></td>
+<td>Konvexität beurteilen, den zulässigen Bereich als Polyeder sehen, schlechte Konditionierung erkennen und beheben</td>
+</tr>
+<tr class="odd">
+<td>Welche Bibliothek, und warum vertragen sie sich nicht?</td>
+<td><a href="oekosystem.html#kap-oekosystem">Kapitel 3</a></td>
+<td>Solver, Bindings und Modellierungsschichten unterscheiden — und den HiGHS-Symbolkonflikt zwischen <code>ortools</code> und <code>highspy</code> umgehen</td>
+</tr>
+<tr class="even">
+<td>Wie wird aus einem Satz ein Modell?</td>
+<td><a href="modellierung.html#kap-modellierung">Kapitel 4</a></td>
+<td>Die vier Fragen stellen, harte von weichen Regeln trennen, einen Besprechungssatz übersetzen (<a href="modellierung.html#sec:modellierung-glossar">Abschnitt 4.6</a>)</td>
+</tr>
+</tbody>
+</table>
+<h2 id="die-reihenfolge-ist-die-aussage">Die Reihenfolge ist die Aussage</h2>
+<p>Dieser Teil steht bewusst <strong>vor</strong> den Verfahren. Die drei häufigsten Gründe, aus denen ein OR-Projekt scheitert, liegen alle hier — und keiner davon ist ein Solverproblem:</p>
+<ol type="1">
+<li><strong>Die falsche Zielgröße.</strong> Sie ist die folgenreichste Entscheidung des ganzen Projekts, und sie wird meist in den ersten zehn Minuten nebenbei getroffen. Auslastung ist ein Ergebnis, kein Ziel; „Umsatz” wird gesagt, wenn „Deckungsbeitrag” gemeint ist.</li>
+<li><strong>Zu viele harte Regeln.</strong> Jede unnötig harte Bedingung ist eine Zeitbombe: Irgendwann ist sie nicht erfüllbar, und das System antwortet gar nicht mehr. Hart ist nur, was rechtlich oder physikalisch unmöglich ist.</li>
+<li><strong>Ein Satz, der mehrere Lesarten hat.</strong> „Stammkunden dürfen wir nicht verlieren” lässt sich auf mindestens drei Arten modellieren, und keine ist aus dem Satz ableitbar. Die Wahl trifft man — im Zweifel unbewusst.</li>
+</ol>
+<h2 id="wenn-sie-nur-eines-mitnehmen">Wenn Sie nur eines mitnehmen</h2>
+<blockquote>
+<p><strong>🎯</strong> Ein Modell rechnet aus, was <strong>aufgeschrieben</strong> wurde, nicht was gemeint war. Die Arbeit, die darüber entscheidet, ob am Ende etwas Brauchbares herauskommt, findet vor der ersten Zeile Code statt — und sie besteht aus Fragen an andere Menschen, nicht aus Mathematik.</p>
+</blockquote>
+<p><strong>Vor <a href="lp.html#teil-kernverfahren">Teil II</a></strong> sollten Sie an einem eigenen Beispiel die vier Fragen aus <a href="modellierung.html#sec:modellierung-vier-fragen">Abschnitt 4.3</a> durchgespielt haben. Ohne das bleiben die Verfahren Technik ohne Anwendung.</p>
+
+    </article>
+    
+    <nav class="prev-next"><a class="prev-next-knopf prev-next-prev" href="modellierung.html"><svg class="icon" aria-hidden="true"><use href="#icon-chevron-left"></use></svg><span><small>Zurück</small>Kapitel 4: Vom Management-Wunsch zum Modell</span></a><a class="prev-next-knopf prev-next-next" href="lp.html"><span><small>Weiter</small>Kapitel 5: Lineare Programmierung — Simplex, Dualität und Schattenpreise</span><svg class="icon" aria-hidden="true"><use href="#icon-chevron-right"></use></svg></a></nav>
+  </main>
+</div>
+<footer class="site-footer">
+  <p>© Dieter Schlüter · <a href="gesamtdokument.html">Gesamtdokument</a> ·
+  <a href="programme.html">Beispielprogramme</a></p>
+</footer>
+<script defer src="assets/search-index.js"></script>
+<script defer src="assets/programme.js"></script>
+<script defer src="assets/site.js"></script>
+</body>
+</html>
diff --git a/OR_HTML_04/synthese-kernverfahren.html b/OR_HTML_04/synthese-kernverfahren.html
new file mode 100644
index 0000000..0b88707
--- /dev/null
+++ b/OR_HTML_04/synthese-kernverfahren.html
@@ -0,0 +1,234 @@
+<!doctype html>
+<html lang="de">
+<head>
+<meta charset="utf-8" />
+<meta name="viewport" content="width=device-width, initial-scale=1" />
+<title>Synthese Teil II · Optimierte Entscheidungsfindung mit Python</title>
+  <script>
+  (function () {
+    try {
+      var t = localStorage.getItem("or-theme");
+      if (t) document.documentElement.setAttribute("data-theme", t);
+    } catch (e) {}
+  })();
+  </script>
+<link rel="stylesheet" href="assets/highlight.css" />
+  <link rel="stylesheet" href="katex/katex.min.css" />
+  <script defer="" src="katex/katex.min.js"></script>
+  <script>document.addEventListener("DOMContentLoaded", function () {
+ var mathElements = document.getElementsByClassName("math");
+ var macros = [];
+ for (var i = 0; i < mathElements.length; i++) {
+  var texText = mathElements[i].firstChild;
+  if (mathElements[i].tagName == "SPAN") {
+   katex.render(texText.data, mathElements[i], {
+    displayMode: mathElements[i].classList.contains('display'),
+    throwOnError: false,
+    macros: macros,
+    fleqn: false
+   });
+}}
+ // Der Browser springt zu einem #anker in der URL schon beim ersten Rendern
+ // an, BEVOR die KaTeX-Formeln oben im Text ihre finale Hoehe bekommen -
+ // durch den Reflow landet der Anker danach zu weit unten. Nach dem
+ // Formel-Rendering hier erneut zum Anker springen, das behebt es.
+ if (location.hash) {
+  var ziel = document.getElementById(decodeURIComponent(location.hash.slice(1)));
+  if (ziel) ziel.scrollIntoView({behavior: "instant", block: "start"});
+ }
+});
+  </script>
+<link rel="stylesheet" href="assets/site.css" />
+</head>
+<body>
+<svg style="display:none" aria-hidden="true"><symbol id="icon-menu" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round">
+    <line x1="3" y1="6" x2="21" y2="6"/><line x1="3" y1="12" x2="21" y2="12"/><line x1="3" y1="18" x2="21" y2="18"/>
+  </symbol>
+  <symbol id="icon-search" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round">
+    <circle cx="11" cy="11" r="7"/><line x1="21" y1="21" x2="16.2" y2="16.2"/>
+  </symbol>
+  <symbol id="icon-sun" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round">
+    <circle cx="12" cy="12" r="4.5"/>
+    <line x1="12" y1="1.5" x2="12" y2="4"/><line x1="12" y1="20" x2="12" y2="22.5"/>
+    <line x1="1.5" y1="12" x2="4" y2="12"/><line x1="20" y1="12" x2="22.5" y2="12"/>
+    <line x1="4.5" y1="4.5" x2="6.2" y2="6.2"/><line x1="17.8" y1="17.8" x2="19.5" y2="19.5"/>
+    <line x1="19.5" y1="4.5" x2="17.8" y2="6.2"/><line x1="6.2" y1="17.8" x2="4.5" y2="19.5"/>
+  </symbol>
+  <symbol id="icon-moon" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round">
+    <path d="M20 14.5A8.5 8.5 0 1 1 9.5 4a6.8 6.8 0 0 0 10.5 10.5z"/>
+  </symbol>
+  <symbol id="icon-chevron-left" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round">
+    <polyline points="15 4 7 12 15 20"/>
+  </symbol>
+  <symbol id="icon-chevron-right" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round">
+    <polyline points="9 4 17 12 9 20"/>
+  </symbol>
+  <symbol id="icon-check" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round">
+    <polyline points="4 13 9.5 18.5 20 6"/>
+  </symbol>
+  <symbol id="icon-external-link" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round">
+    <path d="M18 13.5V19a1.5 1.5 0 0 1-1.5 1.5H5A1.5 1.5 0 0 1 3.5 19V7A1.5 1.5 0 0 1 5 5.5h5.5"/>
+    <polyline points="14.5 3.5 20.5 3.5 20.5 9.5"/><line x1="11" y1="13" x2="20" y2="4"/>
+  </symbol>
+  <symbol id="icon-book" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round">
+    <path d="M4 5.5A2 2 0 0 1 6 4h6v16H6a2 2 0 0 0-2 1.5z"/>
+    <path d="M20 5.5A2 2 0 0 0 18 4h-6v16h6a2 2 0 0 1 2 1.5z"/>
+  </symbol>
+  <symbol id="icon-copy" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round">
+    <rect x="9" y="9" width="13" height="13" rx="2"/><path d="M5 15H4a2 2 0 0 1-2-2V4a2 2 0 0 1 2-2h9a2 2 0 0 1 2 2v1"/>
+  </symbol>
+  <symbol id="icon-download" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round">
+    <path d="M12 3v12"/><polyline points="7 10 12 15 17 10"/><path d="M4 19.5h16"/>
+  </symbol></svg>
+<header class="site-header">
+  <button type="button" class="icon-btn" id="sidebar-toggle" aria-label="Menü öffnen"><svg class="icon" aria-hidden="true"><use href="#icon-menu"></use></svg></button>
+  <a class="brand" href="index.html"><svg class="icon" aria-hidden="true"><use href="#icon-book"></use></svg> <span>Optimierte Entscheidungsfindung mit Python</span></a>
+  <div class="site-search">
+    <input id="suche-eingabe" type="search" placeholder="Suchen …" aria-label="Suche" autocomplete="off" />
+    <svg class="icon such-icon" aria-hidden="true"><use href="#icon-search"></use></svg>
+    <div id="suche-ergebnisse" class="suche-ergebnisse" hidden></div>
+  </div>
+  <button type="button" class="icon-btn" id="theme-toggle" aria-label="Darstellung umschalten">
+    <svg class="icon icon-sun" aria-hidden="true"><use href="#icon-sun"></use></svg><svg class="icon icon-moon" aria-hidden="true"><use href="#icon-moon"></use></svg>
+  </button>
+</header>
+<div class="site-body">
+  <div class="sidebar-overlay" id="sidebar-overlay" hidden></div>
+  <nav class="sidebar" id="sidebar" aria-label="Kapitelnavigation"><div class="sidebar-inhalt"><details class="sidebar-gruppe"><summary>Einstieg</summary><ul><li data-kapitel="vorwort.html"><a href="vorwort.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Vorwort & Lesehilfe</span></a></li><li data-kapitel="notation.html"><a href="notation.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Notation & Abkürzungen</span></a></li></ul></details><details class="sidebar-gruppe"><summary>Teil I: Grundlagen des Operations Research</summary><ul><li data-kapitel="einfuehrung.html"><a href="einfuehrung.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 1: Einführung in Operations Research — Vom Ursprung zur mathematischen Entscheidungsfindung</span></a></li><li data-kapitel="fundament.html"><a href="fundament.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 2: Das mathematische Fundament — Vektoren, Matrizen, Konvexität</span></a></li><li data-kapitel="oekosystem.html"><a href="oekosystem.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 3: Das Python-Ökosystem für OR — Solver, Bindings und Modellierungsschichten</span></a></li><li data-kapitel="modellierung.html"><a href="modellierung.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 4: Vom Management-Wunsch zum Modell</span></a></li><li data-kapitel="synthese-grundlagen.html"><a href="synthese-grundlagen.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Synthese Teil I</span></a></li></ul></details><details class="sidebar-gruppe" open><summary>Teil II: Die Kernverfahren der deterministischen Optimierung</summary><ul><li data-kapitel="lp.html"><a href="lp.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 5: Lineare Programmierung — Simplex, Dualität und Schattenpreise</span></a></li><li data-kapitel="milp.html"><a href="milp.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 6: Gemischt-ganzzahlige Optimierung — Diskrete Entscheidungen und Branch-and-Bound</span></a></li><li data-kapitel="cpsat.html"><a href="cpsat.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 7: Constraint Programming mit CP-SAT — Logik, Scheduling und Zuweisung</span></a></li><li data-kapitel="graphen.html"><a href="graphen.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 8: Graphen, Flüsse und Touren — Min-Cost-Flow, Matching und VRP</span></a></li><li data-kapitel="metaheuristiken.html"><a href="metaheuristiken.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 9: Metaheuristiken — wenn der exakte Solver aussteigt</span></a></li><li data-kapitel="dekomposition.html"><a href="dekomposition.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 10: Spaltengenerierung — das Modell umbauen statt die Lösung raten</span></a></li><li data-kapitel="synthese-kernverfahren.html" class="aktiv"><a href="synthese-kernverfahren.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Synthese Teil II</span></a></li></ul></details><details class="sidebar-gruppe"><summary>Teil III: Nichtlinearität, Unsicherheit und mehrperiodige Dynamik</summary><ul><li data-kapitel="qp-nlp.html"><a href="qp-nlp.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 11: Quadratische und nichtlineare Optimierung — KKT, Lagrange, Konvexität</span></a></li><li data-kapitel="unsicherheit.html"><a href="unsicherheit.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 12: Optimierung unter Unsicherheit — Monte-Carlo, Stochastik, Robustheit</span></a></li><li data-kapitel="dynamische-programmierung.html"><a href="dynamische-programmierung.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 13: Dynamische Programmierung — Die Bellman-Gleichung und Order-Execution</span></a></li><li data-kapitel="mehrziel.html"><a href="mehrziel.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 14: Mehrere Ziele — Pareto-Fronten statt Gewichte</span></a></li><li data-kapitel="prognose.html"><a href="prognose.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 15: Predict-then-Optimize — die bessere Prognose, die schlechtere Entscheidung</span></a></li><li data-kapitel="synthese-nichtlinear.html"><a href="synthese-nichtlinear.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Synthese Teil III</span></a></li></ul></details><details class="sidebar-gruppe"><summary>Teil IV: Anwendungen — Energiewirtschaft und Finanzmärkte</summary><ul><li data-kapitel="bruecke.html"><a href="bruecke.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 16: Die Strukturbrücke — dieselbe Mathematik, zwei Welten</span></a></li><li data-kapitel="supplychain.html"><a href="supplychain.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 17: Supply-Chain und Energieeinsatz unter Unsicherheit</span></a></li><li data-kapitel="finanzdaten.html"><a href="finanzdaten.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 18: Finanzdaten-Modellierung — Renditen, Kovarianz und Shrinkage</span></a></li><li data-kapitel="markowitz.html"><a href="markowitz.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 19: Die moderne Portfoliotheorie nach Markowitz</span></a></li><li data-kapitel="cvar.html"><a href="cvar.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 20: Tail-Risiko, CVaR und Transaktionskosten</span></a></li><li data-kapitel="handelsmaschine.html"><a href="handelsmaschine.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 21: Die vollständige quantitative Handelsmaschine</span></a></li><li data-kapitel="synthese-anwendungen.html"><a href="synthese-anwendungen.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Synthese Teil IV</span></a></li></ul></details><details class="sidebar-gruppe"><summary>Teil V: Praxis</summary><ul><li data-kapitel="praxisfallen.html"><a href="praxisfallen.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 22: Praxisfallen und der Weg zum produktiven Einsatz</span></a></li><li data-kapitel="testing.html"><a href="testing.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 23: Testen, Messen, Ausliefern</span></a></li><li data-kapitel="synthese-praxis.html"><a href="synthese-praxis.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Synthese Teil V</span></a></li><li data-kapitel="projektwerkstatt.html"><a href="projektwerkstatt.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Projektwerkstatt</span></a></li></ul></details><details class="sidebar-gruppe"><summary>Anhänge</summary><ul><li data-kapitel="anhang-loesungen.html"><a href="anhang-loesungen.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Anhang A: Lösungen zu allen Übungsaufgaben</span></a></li><li data-kapitel="anhang-modellierungsmuster.html"><a href="anhang-modellierungsmuster.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Anhang B: Katalog der Modellierungsmuster</span></a></li><li data-kapitel="anhang-fehlerdiagnose.html"><a href="anhang-fehlerdiagnose.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Anhang C: Fehlerdiagnose-Handbuch</span></a></li><li data-kapitel="anhang-spickzettel.html"><a href="anhang-spickzettel.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Anhang D: Spickzettel der Solver</span></a></li><li data-kapitel="anhang-glossar-literatur.html"><a href="anhang-glossar-literatur.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Anhang E: Glossar und Literatur</span></a></li></ul></details><ul class="sidebar-extra"><li><a href="programme.html"><svg class="icon" aria-hidden="true"><use href="#icon-book"></use></svg> Beispielprogramme</a></li><li><a href="stichwortverzeichnis.html"><svg class="icon" aria-hidden="true"><use href="#icon-search"></use></svg> Stichwortverzeichnis</a></li><li><a href="gesamtdokument.html"><svg class="icon" aria-hidden="true"><use href="#icon-external-link"></use></svg> Gesamtdokument (eine Seite)</a></li><li><a href="Operations_Research_mit_Python_Version_04.pdf" download><svg class="icon" aria-hidden="true"><use href="#icon-download"></use></svg> Download als PDF</a></li></ul></div></nav>
+  <main class="content">
+    <nav class="breadcrumb" aria-label="Breadcrumb"><a href="index.html">Start</a> › <span>Teil II</span> › <span>Synthese Teil II</span></nav>
+    <nav class="prev-next"><a class="prev-next-knopf prev-next-prev" href="dekomposition.html"><svg class="icon" aria-hidden="true"><use href="#icon-chevron-left"></use></svg><span><small>Zurück</small>Kapitel 10: Spaltengenerierung — das Modell umbauen statt die Lösung raten</span></a><a class="prev-next-knopf prev-next-next" href="qp-nlp.html"><span><small>Weiter</small>Kapitel 11: Quadratische und nichtlineare Optimierung — KKT, Lagrange, Konvexität</span><svg class="icon" aria-hidden="true"><use href="#icon-chevron-right"></use></svg></a></nav>
+    <article>
+    <h1 id="synthese-teil-ii-die-kernverfahren-nebeneinander">Synthese Teil II — Die Kernverfahren nebeneinander</h1>
+<p>Sechs Kapitel, sechs Werkzeuge. Jedes einzelne wurde im Zusammenhang gezeigt; hier stehen sie zum ersten Mal <strong>nebeneinander</strong>, mit der Frage, die vor jedem Projekt zu beantworten ist: Welches nehme ich, und was bekomme ich dafür?</p>
+<h2 id="die-entscheidungsmatrix">Die Entscheidungsmatrix</h2>
+<table>
+<colgroup>
+<col style="width: 20%" />
+<col style="width: 20%" />
+<col style="width: 20%" />
+<col style="width: 20%" />
+<col style="width: 20%" />
+</colgroup>
+<thead>
+<tr class="header">
+<th>Verfahren</th>
+<th>Wofür es gebaut ist</th>
+<th>Was Sie bekommen</th>
+<th>Wo es aufhört</th>
+<th>Kapitel</th>
+</tr>
+</thead>
+<tbody>
+<tr class="odd">
+<td><strong>LP</strong></td>
+<td>teilbare Mengen, lineare Zusammenhänge</td>
+<td>beweisbares Optimum <strong>plus Schattenpreise</strong></td>
+<td>sobald etwas ganzzahlig sein muss</td>
+<td><a href="lp.html#kap-lp">Kapitel 5</a></td>
+</tr>
+<tr class="even">
+<td><strong>MILP</strong></td>
+<td>Ja/Nein-Entscheidungen, Fixkosten, Logik</td>
+<td>beweisbares Optimum, Gap als Fortschrittsmaß</td>
+<td>Laufzeit wächst mit der Zahl der Binärvariablen</td>
+<td><a href="milp.html#kap-milp">Kapitel 6</a></td>
+</tr>
+<tr class="odd">
+<td><strong>CP-SAT</strong></td>
+<td>Zuweisung, Reihenfolge, Kalender, harte Logik</td>
+<td>beweisbares Optimum, sehr ausdrucksstarke Bedingungen</td>
+<td>keine Schattenpreise, keine stetigen Größen</td>
+<td><a href="cpsat.html#kap-cpsat">Kapitel 7</a></td>
+</tr>
+<tr class="even">
+<td><strong>Graphenalgorithmen</strong></td>
+<td>Flüsse, Zuordnung, Touren</td>
+<td>oft <strong>polynomiell</strong> statt exponentiell</td>
+<td>nur, wenn die Struktur wirklich passt</td>
+<td><a href="graphen.html#kap-graphen">Kapitel 8</a></td>
+</tr>
+<tr class="odd">
+<td><strong>Metaheuristiken</strong></td>
+<td>wenn der exakte Solver aussteigt</td>
+<td>eine gute Lösung in <strong>fester Zeit</strong></td>
+<td>keine Garantie, kein Beweis, keine Schranke</td>
+<td><a href="metaheuristiken.html#kap-metaheuristiken">Kapitel 9</a></td>
+</tr>
+<tr class="even">
+<td><strong>Spaltengenerierung</strong></td>
+<td>Modelle mit astronomisch vielen Variablen</td>
+<td>beweisbares Optimum über nie erzeugte Spalten</td>
+<td>lohnt nur bei bestimmter Instanzstruktur</td>
+<td><a href="dekomposition.html#kap-dekomposition">Kapitel 10</a></td>
+</tr>
+</tbody>
+</table>
+<p><strong>Die Spalte, die am meisten wert ist, ist die vierte.</strong> Ein Verfahren zu kennen heißt zu wissen, wo es aufhört — nicht, wofür es gedacht ist.</p>
+<h2 id="was-dieser-teil-gemessen-hat">Was dieser Teil gemessen hat</h2>
+<table>
+<colgroup>
+<col style="width: 33%" />
+<col style="width: 33%" />
+<col style="width: 33%" />
+</colgroup>
+<thead>
+<tr class="header">
+<th>Behauptung</th>
+<th>Gemessen</th>
+<th>Wo</th>
+</tr>
+</thead>
+<tbody>
+<tr class="odd">
+<td>„Der exakte Solver ist immer besser.”</td>
+<td>Bei 500 Aufträgen liefert CP-SAT eine Lösung, die <strong>5,2 % schlechter</strong> ist als die Faustregel eines Meisters</td>
+<td><a href="metaheuristiken.html#kap-metaheuristiken">Kapitel 9</a></td>
+</tr>
+<tr class="even">
+<td>„Metaheuristiken sind ungenau.”</td>
+<td>Faustregel 2 497 → Annealing 2 343 → Annealing plus LNS <strong>2 289</strong> Minuten Rüstzeit; untere Schranke 1 768</td>
+<td><a href="metaheuristiken.html#kap-metaheuristiken">Kapitel 9</a></td>
+</tr>
+<tr class="odd">
+<td>„Man muss alle Variablen aufschreiben.”</td>
+<td>28 erzeugte Muster von <strong>46 408</strong> möglichen — und die Lösung ist beweisbar optimal</td>
+<td><a href="dekomposition.html#kap-dekomposition">Kapitel 10</a></td>
+</tr>
+<tr class="even">
+<td>„Dekomposition lohnt sich immer.”</td>
+<td>Bei drei Stücken je Rolle <strong>11 %</strong> Ersparnis, bei sechs <strong>nichts</strong></td>
+<td><a href="dekomposition.html#kap-dekomposition">Kapitel 10</a></td>
+</tr>
+<tr class="odd">
+<td>„Mit Seed ist der Lauf reproduzierbar.”</td>
+<td>Schon <strong>zwei</strong> Arbeiter liefern bei identischem Seed drei verschiedene Pläne zum selben Zielwert</td>
+<td><a href="cpsat.html#sec:cpsat-parallele-suche">Abschnitt 7.7</a></td>
+</tr>
+</tbody>
+</table>
+<h2 id="drei-fehler-die-dieser-teil-verhindert">Drei Fehler, die dieser Teil verhindert</h2>
+<ol type="1">
+<li><strong>Runden.</strong> Die LP-Lösung ist keine Näherung der ganzzahligen Lösung — sie kann beliebig weit danebenliegen, und gerundet sogar unzulässig werden.</li>
+<li><strong>Ein zu großes Big-M.</strong> Es macht das Modell nicht falsch, sondern die Suche langsam und die Schranken wertlos. So klein wie zulässig, nie „sicherheitshalber groß”.</li>
+<li><strong>Zu früh heuristisch werden.</strong> Der Umschlagpunkt, ab dem eine Metaheuristik den exakten Solver schlägt, ist eine Eigenschaft <strong>des Problems</strong> und lässt sich messen. Wer ihn nicht misst, verzichtet auf Optimalitätsgarantien, die er hätte haben können.</li>
+</ol>
+<h2 id="wenn-sie-nur-eines-mitnehmen">Wenn Sie nur eines mitnehmen</h2>
+<blockquote>
+<p><strong>🎯</strong> Die Frage lautet nie „welcher Solver ist der beste”, sondern „welche Garantie brauche ich, und was bin ich bereit, dafür an Laufzeit zu zahlen”. Ein Verfahren ohne Schranke liefert eine Lösung; ein Verfahren mit Schranke liefert die Erlaubnis, aufzuhören.</p>
+</blockquote>
+
+    </article>
+    
+    <nav class="prev-next"><a class="prev-next-knopf prev-next-prev" href="dekomposition.html"><svg class="icon" aria-hidden="true"><use href="#icon-chevron-left"></use></svg><span><small>Zurück</small>Kapitel 10: Spaltengenerierung — das Modell umbauen statt die Lösung raten</span></a><a class="prev-next-knopf prev-next-next" href="qp-nlp.html"><span><small>Weiter</small>Kapitel 11: Quadratische und nichtlineare Optimierung — KKT, Lagrange, Konvexität</span><svg class="icon" aria-hidden="true"><use href="#icon-chevron-right"></use></svg></a></nav>
+  </main>
+</div>
+<footer class="site-footer">
+  <p>© Dieter Schlüter · <a href="gesamtdokument.html">Gesamtdokument</a> ·
+  <a href="programme.html">Beispielprogramme</a></p>
+</footer>
+<script defer src="assets/search-index.js"></script>
+<script defer src="assets/programme.js"></script>
+<script defer src="assets/site.js"></script>
+</body>
+</html>
diff --git a/OR_HTML_04/synthese-nichtlinear.html b/OR_HTML_04/synthese-nichtlinear.html
new file mode 100644
index 0000000..3afef95
--- /dev/null
+++ b/OR_HTML_04/synthese-nichtlinear.html
@@ -0,0 +1,215 @@
+<!doctype html>
+<html lang="de">
+<head>
+<meta charset="utf-8" />
+<meta name="viewport" content="width=device-width, initial-scale=1" />
+<title>Synthese Teil III · Optimierte Entscheidungsfindung mit Python</title>
+  <script>
+  (function () {
+    try {
+      var t = localStorage.getItem("or-theme");
+      if (t) document.documentElement.setAttribute("data-theme", t);
+    } catch (e) {}
+  })();
+  </script>
+<link rel="stylesheet" href="assets/highlight.css" />
+  <link rel="stylesheet" href="katex/katex.min.css" />
+  <script defer="" src="katex/katex.min.js"></script>
+  <script>document.addEventListener("DOMContentLoaded", function () {
+ var mathElements = document.getElementsByClassName("math");
+ var macros = [];
+ for (var i = 0; i < mathElements.length; i++) {
+  var texText = mathElements[i].firstChild;
+  if (mathElements[i].tagName == "SPAN") {
+   katex.render(texText.data, mathElements[i], {
+    displayMode: mathElements[i].classList.contains('display'),
+    throwOnError: false,
+    macros: macros,
+    fleqn: false
+   });
+}}
+ // Der Browser springt zu einem #anker in der URL schon beim ersten Rendern
+ // an, BEVOR die KaTeX-Formeln oben im Text ihre finale Hoehe bekommen -
+ // durch den Reflow landet der Anker danach zu weit unten. Nach dem
+ // Formel-Rendering hier erneut zum Anker springen, das behebt es.
+ if (location.hash) {
+  var ziel = document.getElementById(decodeURIComponent(location.hash.slice(1)));
+  if (ziel) ziel.scrollIntoView({behavior: "instant", block: "start"});
+ }
+});
+  </script>
+<link rel="stylesheet" href="assets/site.css" />
+</head>
+<body>
+<svg style="display:none" aria-hidden="true"><symbol id="icon-menu" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round">
+    <line x1="3" y1="6" x2="21" y2="6"/><line x1="3" y1="12" x2="21" y2="12"/><line x1="3" y1="18" x2="21" y2="18"/>
+  </symbol>
+  <symbol id="icon-search" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round">
+    <circle cx="11" cy="11" r="7"/><line x1="21" y1="21" x2="16.2" y2="16.2"/>
+  </symbol>
+  <symbol id="icon-sun" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round">
+    <circle cx="12" cy="12" r="4.5"/>
+    <line x1="12" y1="1.5" x2="12" y2="4"/><line x1="12" y1="20" x2="12" y2="22.5"/>
+    <line x1="1.5" y1="12" x2="4" y2="12"/><line x1="20" y1="12" x2="22.5" y2="12"/>
+    <line x1="4.5" y1="4.5" x2="6.2" y2="6.2"/><line x1="17.8" y1="17.8" x2="19.5" y2="19.5"/>
+    <line x1="19.5" y1="4.5" x2="17.8" y2="6.2"/><line x1="6.2" y1="17.8" x2="4.5" y2="19.5"/>
+  </symbol>
+  <symbol id="icon-moon" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round">
+    <path d="M20 14.5A8.5 8.5 0 1 1 9.5 4a6.8 6.8 0 0 0 10.5 10.5z"/>
+  </symbol>
+  <symbol id="icon-chevron-left" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round">
+    <polyline points="15 4 7 12 15 20"/>
+  </symbol>
+  <symbol id="icon-chevron-right" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round">
+    <polyline points="9 4 17 12 9 20"/>
+  </symbol>
+  <symbol id="icon-check" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round">
+    <polyline points="4 13 9.5 18.5 20 6"/>
+  </symbol>
+  <symbol id="icon-external-link" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round">
+    <path d="M18 13.5V19a1.5 1.5 0 0 1-1.5 1.5H5A1.5 1.5 0 0 1 3.5 19V7A1.5 1.5 0 0 1 5 5.5h5.5"/>
+    <polyline points="14.5 3.5 20.5 3.5 20.5 9.5"/><line x1="11" y1="13" x2="20" y2="4"/>
+  </symbol>
+  <symbol id="icon-book" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round">
+    <path d="M4 5.5A2 2 0 0 1 6 4h6v16H6a2 2 0 0 0-2 1.5z"/>
+    <path d="M20 5.5A2 2 0 0 0 18 4h-6v16h6a2 2 0 0 1 2 1.5z"/>
+  </symbol>
+  <symbol id="icon-copy" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round">
+    <rect x="9" y="9" width="13" height="13" rx="2"/><path d="M5 15H4a2 2 0 0 1-2-2V4a2 2 0 0 1 2-2h9a2 2 0 0 1 2 2v1"/>
+  </symbol>
+  <symbol id="icon-download" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round">
+    <path d="M12 3v12"/><polyline points="7 10 12 15 17 10"/><path d="M4 19.5h16"/>
+  </symbol></svg>
+<header class="site-header">
+  <button type="button" class="icon-btn" id="sidebar-toggle" aria-label="Menü öffnen"><svg class="icon" aria-hidden="true"><use href="#icon-menu"></use></svg></button>
+  <a class="brand" href="index.html"><svg class="icon" aria-hidden="true"><use href="#icon-book"></use></svg> <span>Optimierte Entscheidungsfindung mit Python</span></a>
+  <div class="site-search">
+    <input id="suche-eingabe" type="search" placeholder="Suchen …" aria-label="Suche" autocomplete="off" />
+    <svg class="icon such-icon" aria-hidden="true"><use href="#icon-search"></use></svg>
+    <div id="suche-ergebnisse" class="suche-ergebnisse" hidden></div>
+  </div>
+  <button type="button" class="icon-btn" id="theme-toggle" aria-label="Darstellung umschalten">
+    <svg class="icon icon-sun" aria-hidden="true"><use href="#icon-sun"></use></svg><svg class="icon icon-moon" aria-hidden="true"><use href="#icon-moon"></use></svg>
+  </button>
+</header>
+<div class="site-body">
+  <div class="sidebar-overlay" id="sidebar-overlay" hidden></div>
+  <nav class="sidebar" id="sidebar" aria-label="Kapitelnavigation"><div class="sidebar-inhalt"><details class="sidebar-gruppe"><summary>Einstieg</summary><ul><li data-kapitel="vorwort.html"><a href="vorwort.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Vorwort & Lesehilfe</span></a></li><li data-kapitel="notation.html"><a href="notation.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Notation & Abkürzungen</span></a></li></ul></details><details class="sidebar-gruppe"><summary>Teil I: Grundlagen des Operations Research</summary><ul><li data-kapitel="einfuehrung.html"><a href="einfuehrung.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 1: Einführung in Operations Research — Vom Ursprung zur mathematischen Entscheidungsfindung</span></a></li><li data-kapitel="fundament.html"><a href="fundament.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 2: Das mathematische Fundament — Vektoren, Matrizen, Konvexität</span></a></li><li data-kapitel="oekosystem.html"><a href="oekosystem.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 3: Das Python-Ökosystem für OR — Solver, Bindings und Modellierungsschichten</span></a></li><li data-kapitel="modellierung.html"><a href="modellierung.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 4: Vom Management-Wunsch zum Modell</span></a></li><li data-kapitel="synthese-grundlagen.html"><a href="synthese-grundlagen.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Synthese Teil I</span></a></li></ul></details><details class="sidebar-gruppe"><summary>Teil II: Die Kernverfahren der deterministischen Optimierung</summary><ul><li data-kapitel="lp.html"><a href="lp.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 5: Lineare Programmierung — Simplex, Dualität und Schattenpreise</span></a></li><li data-kapitel="milp.html"><a href="milp.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 6: Gemischt-ganzzahlige Optimierung — Diskrete Entscheidungen und Branch-and-Bound</span></a></li><li data-kapitel="cpsat.html"><a href="cpsat.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 7: Constraint Programming mit CP-SAT — Logik, Scheduling und Zuweisung</span></a></li><li data-kapitel="graphen.html"><a href="graphen.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 8: Graphen, Flüsse und Touren — Min-Cost-Flow, Matching und VRP</span></a></li><li data-kapitel="metaheuristiken.html"><a href="metaheuristiken.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 9: Metaheuristiken — wenn der exakte Solver aussteigt</span></a></li><li data-kapitel="dekomposition.html"><a href="dekomposition.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 10: Spaltengenerierung — das Modell umbauen statt die Lösung raten</span></a></li><li data-kapitel="synthese-kernverfahren.html"><a href="synthese-kernverfahren.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Synthese Teil II</span></a></li></ul></details><details class="sidebar-gruppe" open><summary>Teil III: Nichtlinearität, Unsicherheit und mehrperiodige Dynamik</summary><ul><li data-kapitel="qp-nlp.html"><a href="qp-nlp.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 11: Quadratische und nichtlineare Optimierung — KKT, Lagrange, Konvexität</span></a></li><li data-kapitel="unsicherheit.html"><a href="unsicherheit.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 12: Optimierung unter Unsicherheit — Monte-Carlo, Stochastik, Robustheit</span></a></li><li data-kapitel="dynamische-programmierung.html"><a href="dynamische-programmierung.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 13: Dynamische Programmierung — Die Bellman-Gleichung und Order-Execution</span></a></li><li data-kapitel="mehrziel.html"><a href="mehrziel.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 14: Mehrere Ziele — Pareto-Fronten statt Gewichte</span></a></li><li data-kapitel="prognose.html"><a href="prognose.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 15: Predict-then-Optimize — die bessere Prognose, die schlechtere Entscheidung</span></a></li><li data-kapitel="synthese-nichtlinear.html" class="aktiv"><a href="synthese-nichtlinear.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Synthese Teil III</span></a></li></ul></details><details class="sidebar-gruppe"><summary>Teil IV: Anwendungen — Energiewirtschaft und Finanzmärkte</summary><ul><li data-kapitel="bruecke.html"><a href="bruecke.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 16: Die Strukturbrücke — dieselbe Mathematik, zwei Welten</span></a></li><li data-kapitel="supplychain.html"><a href="supplychain.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 17: Supply-Chain und Energieeinsatz unter Unsicherheit</span></a></li><li data-kapitel="finanzdaten.html"><a href="finanzdaten.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 18: Finanzdaten-Modellierung — Renditen, Kovarianz und Shrinkage</span></a></li><li data-kapitel="markowitz.html"><a href="markowitz.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 19: Die moderne Portfoliotheorie nach Markowitz</span></a></li><li data-kapitel="cvar.html"><a href="cvar.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 20: Tail-Risiko, CVaR und Transaktionskosten</span></a></li><li data-kapitel="handelsmaschine.html"><a href="handelsmaschine.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 21: Die vollständige quantitative Handelsmaschine</span></a></li><li data-kapitel="synthese-anwendungen.html"><a href="synthese-anwendungen.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Synthese Teil IV</span></a></li></ul></details><details class="sidebar-gruppe"><summary>Teil V: Praxis</summary><ul><li data-kapitel="praxisfallen.html"><a href="praxisfallen.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 22: Praxisfallen und der Weg zum produktiven Einsatz</span></a></li><li data-kapitel="testing.html"><a href="testing.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 23: Testen, Messen, Ausliefern</span></a></li><li data-kapitel="synthese-praxis.html"><a href="synthese-praxis.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Synthese Teil V</span></a></li><li data-kapitel="projektwerkstatt.html"><a href="projektwerkstatt.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Projektwerkstatt</span></a></li></ul></details><details class="sidebar-gruppe"><summary>Anhänge</summary><ul><li data-kapitel="anhang-loesungen.html"><a href="anhang-loesungen.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Anhang A: Lösungen zu allen Übungsaufgaben</span></a></li><li data-kapitel="anhang-modellierungsmuster.html"><a href="anhang-modellierungsmuster.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Anhang B: Katalog der Modellierungsmuster</span></a></li><li data-kapitel="anhang-fehlerdiagnose.html"><a href="anhang-fehlerdiagnose.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Anhang C: Fehlerdiagnose-Handbuch</span></a></li><li data-kapitel="anhang-spickzettel.html"><a href="anhang-spickzettel.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Anhang D: Spickzettel der Solver</span></a></li><li data-kapitel="anhang-glossar-literatur.html"><a href="anhang-glossar-literatur.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Anhang E: Glossar und Literatur</span></a></li></ul></details><ul class="sidebar-extra"><li><a href="programme.html"><svg class="icon" aria-hidden="true"><use href="#icon-book"></use></svg> Beispielprogramme</a></li><li><a href="stichwortverzeichnis.html"><svg class="icon" aria-hidden="true"><use href="#icon-search"></use></svg> Stichwortverzeichnis</a></li><li><a href="gesamtdokument.html"><svg class="icon" aria-hidden="true"><use href="#icon-external-link"></use></svg> Gesamtdokument (eine Seite)</a></li><li><a href="Operations_Research_mit_Python_Version_04.pdf" download><svg class="icon" aria-hidden="true"><use href="#icon-download"></use></svg> Download als PDF</a></li></ul></div></nav>
+  <main class="content">
+    <nav class="breadcrumb" aria-label="Breadcrumb"><a href="index.html">Start</a> › <span>Teil III</span> › <span>Synthese Teil III</span></nav>
+    <nav class="prev-next"><a class="prev-next-knopf prev-next-prev" href="prognose.html"><svg class="icon" aria-hidden="true"><use href="#icon-chevron-left"></use></svg><span><small>Zurück</small>Kapitel 15: Predict-then-Optimize — die bessere Prognose, die schlechtere Entscheidung</span></a><a class="prev-next-knopf prev-next-next" href="bruecke.html"><span><small>Weiter</small>Kapitel 16: Die Strukturbrücke — dieselbe Mathematik, zwei Welten</span><svg class="icon" aria-hidden="true"><use href="#icon-chevron-right"></use></svg></a></nav>
+    <article>
+    <h1 id="synthese-teil-iii-wenn-die-idealwelt-nicht-gilt">Synthese Teil III — Wenn die Idealwelt nicht gilt</h1>
+<p><a href="lp.html#teil-kernverfahren">Teil II</a> setzte voraus: feste Daten, lineare Zusammenhänge, ein Ziel, eine Periode. Dieser Teil nimmt jede dieser vier Voraussetzungen einzeln weg. Die Tabelle ordnet die Kapitel danach, <strong>welche</strong> Voraussetzung bei Ihnen verletzt ist.</p>
+<h2 id="welche-annahme-fällt-weg">Welche Annahme fällt weg?</h2>
+<table>
+<colgroup>
+<col style="width: 25%" />
+<col style="width: 25%" />
+<col style="width: 25%" />
+<col style="width: 25%" />
+</colgroup>
+<thead>
+<tr class="header">
+<th>Was nicht gilt</th>
+<th>Woran Sie es merken</th>
+<th>Werkzeug</th>
+<th>Kapitel</th>
+</tr>
+</thead>
+<tbody>
+<tr class="odd">
+<td><strong>Linearität</strong></td>
+<td>Risiko wächst quadratisch, Kosten degressiv, Sättigung</td>
+<td>QP, konvexe Optimierung, KKT</td>
+<td><a href="qp-nlp.html#kap-qp-nlp">Kapitel 11</a></td>
+</tr>
+<tr class="even">
+<td><strong>Feste Daten</strong></td>
+<td>Nachfrage, Wind, Rendite stehen erst morgen fest</td>
+<td>Monte-Carlo, Zweistufigkeit, Robustheit, Chance Constraints</td>
+<td><a href="unsicherheit.html#kap-unsicherheit">Kapitel 12</a></td>
+</tr>
+<tr class="odd">
+<td><strong>Eine Periode</strong></td>
+<td>die Entscheidung heute verändert, was übermorgen möglich ist</td>
+<td>Bellman-Gleichung, Rückwärtsinduktion</td>
+<td><a href="dynamische-programmierung.html#kap-dynamische-programmierung">Kapitel 13</a></td>
+</tr>
+<tr class="even">
+<td><strong>Ein Ziel</strong></td>
+<td>zwei Kennzahlen sollen gleichzeitig stimmen</td>
+<td>Pareto-Front, ε-Constraint</td>
+<td><a href="mehrziel.html#kap-mehrziel">Kapitel 14</a></td>
+</tr>
+<tr class="odd">
+<td><strong>Daten sind gegeben</strong></td>
+<td>die Eingabe ist selbst eine Prognose</td>
+<td>Predict-then-Optimize, entscheidungsorientiertes Lernen</td>
+<td><a href="prognose.html#kap-prognose">Kapitel 15</a></td>
+</tr>
+</tbody>
+</table>
+<p>Die letzte Zeile ist die unbequemste: Dort ist nicht das Modell unsicher, sondern seine <strong>Eingabe</strong> — und die kommt aus einem zweiten Modell, das nach anderen Kriterien gebaut wurde.</p>
+<h2 id="was-dieser-teil-gemessen-hat">Was dieser Teil gemessen hat</h2>
+<table>
+<colgroup>
+<col style="width: 33%" />
+<col style="width: 33%" />
+<col style="width: 33%" />
+</colgroup>
+<thead>
+<tr class="header">
+<th>Behauptung</th>
+<th>Gemessen</th>
+<th>Wo</th>
+</tr>
+</thead>
+<tbody>
+<tr class="odd">
+<td>„Mit dem Mittelwert zu rechnen ist eine brauchbare Näherung.”</td>
+<td>Der Mittelwertplan hält seine Zusage in <strong>50,08 %</strong> der Fälle — per Definition</td>
+<td><a href="unsicherheit.html#sec:unsicherheit-chance-constraints">Abschnitt 12.7</a></td>
+</tr>
+<tr class="even">
+<td>„Versorgungssicherheit kostet linear.”</td>
+<td>56 289 € je Prozentpunkt auf dem Weg zu 80 %, <strong>253 848 €</strong> zwischen 95 und 99 % — das 4,5-fache</td>
+<td><a href="unsicherheit.html#sec:unsicherheit-chance-constraints">Abschnitt 12.7</a></td>
+</tr>
+<tr class="odd">
+<td>„Eine Zusage aus dem Modell hält.”</td>
+<td>Der 95-%-Plan hält <strong>87,44 %</strong>, sobald die Testverteilung einen Fall enthält, in dem alles zugleich ausfällt</td>
+<td><a href="unsicherheit.html#sec:unsicherheit-chance-constraints">Abschnitt 12.7</a></td>
+</tr>
+<tr class="even">
+<td>„Die bessere Prognose führt zur besseren Entscheidung.”</td>
+<td>Das Modell mit dem <strong>schlechteren</strong> MSE trifft die günstigere Entscheidung</td>
+<td><a href="prognose.html#kap-prognose">Kapitel 15</a></td>
+</tr>
+</tbody>
+</table>
+<h2 id="drei-fehler-die-dieser-teil-verhindert">Drei Fehler, die dieser Teil verhindert</h2>
+<ol type="1">
+<li><strong>Unsicherheit durch Mittelwerte ersetzen.</strong> Der Durchschnittskunde kauft nie. Bei asymmetrischen Kosten liegt das Optimum systematisch neben dem Mittelwert, und eine Terminzusage ist ein <strong>Quantil</strong>, kein Erwartungswert.</li>
+<li><strong>Konvexität voraussetzen, ohne sie zu prüfen.</strong> Ohne sie gibt es keine Optimalitätsgarantie, sondern nur ein lokales Ergebnis — und der Solver sagt das nicht von selbst.</li>
+<li><strong>Zwei Ziele mit einem Gewicht verrechnen, bevor die Front bekannt ist.</strong> Ein Gewicht ist eine Antwort auf eine Frage, die noch niemand gestellt hat. Die Pareto-Front stellt sie zuerst.</li>
+</ol>
+<h2 id="wenn-sie-nur-eines-mitnehmen">Wenn Sie nur eines mitnehmen</h2>
+<blockquote>
+<p><strong>🎯</strong> Jede der vier Annahmen lässt sich einzeln aufgeben — aber jede kostet etwas Bestimmtes: Linearität kostet die Optimalitätsgarantie, feste Daten kosten Rechenzeit oder Vorsicht, eine Periode kostet Zustandsraum, ein Ziel kostet eine Entscheidung, die nicht der Modellierer treffen darf. Wer weiß, <strong>welche</strong> Annahme bei ihm fällt, weiß auch, welchen Preis er zahlt.</p>
+</blockquote>
+
+    </article>
+    
+    <nav class="prev-next"><a class="prev-next-knopf prev-next-prev" href="prognose.html"><svg class="icon" aria-hidden="true"><use href="#icon-chevron-left"></use></svg><span><small>Zurück</small>Kapitel 15: Predict-then-Optimize — die bessere Prognose, die schlechtere Entscheidung</span></a><a class="prev-next-knopf prev-next-next" href="bruecke.html"><span><small>Weiter</small>Kapitel 16: Die Strukturbrücke — dieselbe Mathematik, zwei Welten</span><svg class="icon" aria-hidden="true"><use href="#icon-chevron-right"></use></svg></a></nav>
+  </main>
+</div>
+<footer class="site-footer">
+  <p>© Dieter Schlüter · <a href="gesamtdokument.html">Gesamtdokument</a> ·
+  <a href="programme.html">Beispielprogramme</a></p>
+</footer>
+<script defer src="assets/search-index.js"></script>
+<script defer src="assets/programme.js"></script>
+<script defer src="assets/site.js"></script>
+</body>
+</html>
diff --git a/OR_HTML_04/synthese-praxis.html b/OR_HTML_04/synthese-praxis.html
new file mode 100644
index 0000000..04ed126
--- /dev/null
+++ b/OR_HTML_04/synthese-praxis.html
@@ -0,0 +1,213 @@
+<!doctype html>
+<html lang="de">
+<head>
+<meta charset="utf-8" />
+<meta name="viewport" content="width=device-width, initial-scale=1" />
+<title>Synthese Teil V · Optimierte Entscheidungsfindung mit Python</title>
+  <script>
+  (function () {
+    try {
+      var t = localStorage.getItem("or-theme");
+      if (t) document.documentElement.setAttribute("data-theme", t);
+    } catch (e) {}
+  })();
+  </script>
+<link rel="stylesheet" href="assets/highlight.css" />
+  <link rel="stylesheet" href="katex/katex.min.css" />
+  <script defer="" src="katex/katex.min.js"></script>
+  <script>document.addEventListener("DOMContentLoaded", function () {
+ var mathElements = document.getElementsByClassName("math");
+ var macros = [];
+ for (var i = 0; i < mathElements.length; i++) {
+  var texText = mathElements[i].firstChild;
+  if (mathElements[i].tagName == "SPAN") {
+   katex.render(texText.data, mathElements[i], {
+    displayMode: mathElements[i].classList.contains('display'),
+    throwOnError: false,
+    macros: macros,
+    fleqn: false
+   });
+}}
+ // Der Browser springt zu einem #anker in der URL schon beim ersten Rendern
+ // an, BEVOR die KaTeX-Formeln oben im Text ihre finale Hoehe bekommen -
+ // durch den Reflow landet der Anker danach zu weit unten. Nach dem
+ // Formel-Rendering hier erneut zum Anker springen, das behebt es.
+ if (location.hash) {
+  var ziel = document.getElementById(decodeURIComponent(location.hash.slice(1)));
+  if (ziel) ziel.scrollIntoView({behavior: "instant", block: "start"});
+ }
+});
+  </script>
+<link rel="stylesheet" href="assets/site.css" />
+</head>
+<body>
+<svg style="display:none" aria-hidden="true"><symbol id="icon-menu" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round">
+    <line x1="3" y1="6" x2="21" y2="6"/><line x1="3" y1="12" x2="21" y2="12"/><line x1="3" y1="18" x2="21" y2="18"/>
+  </symbol>
+  <symbol id="icon-search" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round">
+    <circle cx="11" cy="11" r="7"/><line x1="21" y1="21" x2="16.2" y2="16.2"/>
+  </symbol>
+  <symbol id="icon-sun" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round">
+    <circle cx="12" cy="12" r="4.5"/>
+    <line x1="12" y1="1.5" x2="12" y2="4"/><line x1="12" y1="20" x2="12" y2="22.5"/>
+    <line x1="1.5" y1="12" x2="4" y2="12"/><line x1="20" y1="12" x2="22.5" y2="12"/>
+    <line x1="4.5" y1="4.5" x2="6.2" y2="6.2"/><line x1="17.8" y1="17.8" x2="19.5" y2="19.5"/>
+    <line x1="19.5" y1="4.5" x2="17.8" y2="6.2"/><line x1="6.2" y1="17.8" x2="4.5" y2="19.5"/>
+  </symbol>
+  <symbol id="icon-moon" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round">
+    <path d="M20 14.5A8.5 8.5 0 1 1 9.5 4a6.8 6.8 0 0 0 10.5 10.5z"/>
+  </symbol>
+  <symbol id="icon-chevron-left" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round">
+    <polyline points="15 4 7 12 15 20"/>
+  </symbol>
+  <symbol id="icon-chevron-right" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round">
+    <polyline points="9 4 17 12 9 20"/>
+  </symbol>
+  <symbol id="icon-check" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round">
+    <polyline points="4 13 9.5 18.5 20 6"/>
+  </symbol>
+  <symbol id="icon-external-link" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round">
+    <path d="M18 13.5V19a1.5 1.5 0 0 1-1.5 1.5H5A1.5 1.5 0 0 1 3.5 19V7A1.5 1.5 0 0 1 5 5.5h5.5"/>
+    <polyline points="14.5 3.5 20.5 3.5 20.5 9.5"/><line x1="11" y1="13" x2="20" y2="4"/>
+  </symbol>
+  <symbol id="icon-book" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round">
+    <path d="M4 5.5A2 2 0 0 1 6 4h6v16H6a2 2 0 0 0-2 1.5z"/>
+    <path d="M20 5.5A2 2 0 0 0 18 4h-6v16h6a2 2 0 0 1 2 1.5z"/>
+  </symbol>
+  <symbol id="icon-copy" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round">
+    <rect x="9" y="9" width="13" height="13" rx="2"/><path d="M5 15H4a2 2 0 0 1-2-2V4a2 2 0 0 1 2-2h9a2 2 0 0 1 2 2v1"/>
+  </symbol>
+  <symbol id="icon-download" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round">
+    <path d="M12 3v12"/><polyline points="7 10 12 15 17 10"/><path d="M4 19.5h16"/>
+  </symbol></svg>
+<header class="site-header">
+  <button type="button" class="icon-btn" id="sidebar-toggle" aria-label="Menü öffnen"><svg class="icon" aria-hidden="true"><use href="#icon-menu"></use></svg></button>
+  <a class="brand" href="index.html"><svg class="icon" aria-hidden="true"><use href="#icon-book"></use></svg> <span>Optimierte Entscheidungsfindung mit Python</span></a>
+  <div class="site-search">
+    <input id="suche-eingabe" type="search" placeholder="Suchen …" aria-label="Suche" autocomplete="off" />
+    <svg class="icon such-icon" aria-hidden="true"><use href="#icon-search"></use></svg>
+    <div id="suche-ergebnisse" class="suche-ergebnisse" hidden></div>
+  </div>
+  <button type="button" class="icon-btn" id="theme-toggle" aria-label="Darstellung umschalten">
+    <svg class="icon icon-sun" aria-hidden="true"><use href="#icon-sun"></use></svg><svg class="icon icon-moon" aria-hidden="true"><use href="#icon-moon"></use></svg>
+  </button>
+</header>
+<div class="site-body">
+  <div class="sidebar-overlay" id="sidebar-overlay" hidden></div>
+  <nav class="sidebar" id="sidebar" aria-label="Kapitelnavigation"><div class="sidebar-inhalt"><details class="sidebar-gruppe"><summary>Einstieg</summary><ul><li data-kapitel="vorwort.html"><a href="vorwort.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Vorwort & Lesehilfe</span></a></li><li data-kapitel="notation.html"><a href="notation.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Notation & Abkürzungen</span></a></li></ul></details><details class="sidebar-gruppe"><summary>Teil I: Grundlagen des Operations Research</summary><ul><li data-kapitel="einfuehrung.html"><a href="einfuehrung.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 1: Einführung in Operations Research — Vom Ursprung zur mathematischen Entscheidungsfindung</span></a></li><li data-kapitel="fundament.html"><a href="fundament.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 2: Das mathematische Fundament — Vektoren, Matrizen, Konvexität</span></a></li><li data-kapitel="oekosystem.html"><a href="oekosystem.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 3: Das Python-Ökosystem für OR — Solver, Bindings und Modellierungsschichten</span></a></li><li data-kapitel="modellierung.html"><a href="modellierung.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 4: Vom Management-Wunsch zum Modell</span></a></li><li data-kapitel="synthese-grundlagen.html"><a href="synthese-grundlagen.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Synthese Teil I</span></a></li></ul></details><details class="sidebar-gruppe"><summary>Teil II: Die Kernverfahren der deterministischen Optimierung</summary><ul><li data-kapitel="lp.html"><a href="lp.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 5: Lineare Programmierung — Simplex, Dualität und Schattenpreise</span></a></li><li data-kapitel="milp.html"><a href="milp.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 6: Gemischt-ganzzahlige Optimierung — Diskrete Entscheidungen und Branch-and-Bound</span></a></li><li data-kapitel="cpsat.html"><a href="cpsat.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 7: Constraint Programming mit CP-SAT — Logik, Scheduling und Zuweisung</span></a></li><li data-kapitel="graphen.html"><a href="graphen.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 8: Graphen, Flüsse und Touren — Min-Cost-Flow, Matching und VRP</span></a></li><li data-kapitel="metaheuristiken.html"><a href="metaheuristiken.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 9: Metaheuristiken — wenn der exakte Solver aussteigt</span></a></li><li data-kapitel="dekomposition.html"><a href="dekomposition.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 10: Spaltengenerierung — das Modell umbauen statt die Lösung raten</span></a></li><li data-kapitel="synthese-kernverfahren.html"><a href="synthese-kernverfahren.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Synthese Teil II</span></a></li></ul></details><details class="sidebar-gruppe"><summary>Teil III: Nichtlinearität, Unsicherheit und mehrperiodige Dynamik</summary><ul><li data-kapitel="qp-nlp.html"><a href="qp-nlp.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 11: Quadratische und nichtlineare Optimierung — KKT, Lagrange, Konvexität</span></a></li><li data-kapitel="unsicherheit.html"><a href="unsicherheit.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 12: Optimierung unter Unsicherheit — Monte-Carlo, Stochastik, Robustheit</span></a></li><li data-kapitel="dynamische-programmierung.html"><a href="dynamische-programmierung.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 13: Dynamische Programmierung — Die Bellman-Gleichung und Order-Execution</span></a></li><li data-kapitel="mehrziel.html"><a href="mehrziel.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 14: Mehrere Ziele — Pareto-Fronten statt Gewichte</span></a></li><li data-kapitel="prognose.html"><a href="prognose.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 15: Predict-then-Optimize — die bessere Prognose, die schlechtere Entscheidung</span></a></li><li data-kapitel="synthese-nichtlinear.html"><a href="synthese-nichtlinear.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Synthese Teil III</span></a></li></ul></details><details class="sidebar-gruppe"><summary>Teil IV: Anwendungen — Energiewirtschaft und Finanzmärkte</summary><ul><li data-kapitel="bruecke.html"><a href="bruecke.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 16: Die Strukturbrücke — dieselbe Mathematik, zwei Welten</span></a></li><li data-kapitel="supplychain.html"><a href="supplychain.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 17: Supply-Chain und Energieeinsatz unter Unsicherheit</span></a></li><li data-kapitel="finanzdaten.html"><a href="finanzdaten.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 18: Finanzdaten-Modellierung — Renditen, Kovarianz und Shrinkage</span></a></li><li data-kapitel="markowitz.html"><a href="markowitz.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 19: Die moderne Portfoliotheorie nach Markowitz</span></a></li><li data-kapitel="cvar.html"><a href="cvar.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 20: Tail-Risiko, CVaR und Transaktionskosten</span></a></li><li data-kapitel="handelsmaschine.html"><a href="handelsmaschine.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 21: Die vollständige quantitative Handelsmaschine</span></a></li><li data-kapitel="synthese-anwendungen.html"><a href="synthese-anwendungen.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Synthese Teil IV</span></a></li></ul></details><details class="sidebar-gruppe" open><summary>Teil V: Praxis</summary><ul><li data-kapitel="praxisfallen.html"><a href="praxisfallen.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 22: Praxisfallen und der Weg zum produktiven Einsatz</span></a></li><li data-kapitel="testing.html"><a href="testing.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 23: Testen, Messen, Ausliefern</span></a></li><li data-kapitel="synthese-praxis.html" class="aktiv"><a href="synthese-praxis.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Synthese Teil V</span></a></li><li data-kapitel="projektwerkstatt.html"><a href="projektwerkstatt.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Projektwerkstatt</span></a></li></ul></details><details class="sidebar-gruppe"><summary>Anhänge</summary><ul><li data-kapitel="anhang-loesungen.html"><a href="anhang-loesungen.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Anhang A: Lösungen zu allen Übungsaufgaben</span></a></li><li data-kapitel="anhang-modellierungsmuster.html"><a href="anhang-modellierungsmuster.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Anhang B: Katalog der Modellierungsmuster</span></a></li><li data-kapitel="anhang-fehlerdiagnose.html"><a href="anhang-fehlerdiagnose.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Anhang C: Fehlerdiagnose-Handbuch</span></a></li><li data-kapitel="anhang-spickzettel.html"><a href="anhang-spickzettel.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Anhang D: Spickzettel der Solver</span></a></li><li data-kapitel="anhang-glossar-literatur.html"><a href="anhang-glossar-literatur.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Anhang E: Glossar und Literatur</span></a></li></ul></details><ul class="sidebar-extra"><li><a href="programme.html"><svg class="icon" aria-hidden="true"><use href="#icon-book"></use></svg> Beispielprogramme</a></li><li><a href="stichwortverzeichnis.html"><svg class="icon" aria-hidden="true"><use href="#icon-search"></use></svg> Stichwortverzeichnis</a></li><li><a href="gesamtdokument.html"><svg class="icon" aria-hidden="true"><use href="#icon-external-link"></use></svg> Gesamtdokument (eine Seite)</a></li><li><a href="Operations_Research_mit_Python_Version_04.pdf" download><svg class="icon" aria-hidden="true"><use href="#icon-download"></use></svg> Download als PDF</a></li></ul></div></nav>
+  <main class="content">
+    <nav class="breadcrumb" aria-label="Breadcrumb"><a href="index.html">Start</a> › <span>Teil V</span> › <span>Synthese Teil V</span></nav>
+    <nav class="prev-next"><a class="prev-next-knopf prev-next-prev" href="testing.html"><svg class="icon" aria-hidden="true"><use href="#icon-chevron-left"></use></svg><span><small>Zurück</small>Kapitel 23: Testen, Messen, Ausliefern</span></a><a class="prev-next-knopf prev-next-next" href="projektwerkstatt.html"><span><small>Weiter</small>Projektwerkstatt</span><svg class="icon" aria-hidden="true"><use href="#icon-chevron-right"></use></svg></a></nav>
+    <article>
+    <h1 id="synthese-teil-v-vom-rechnenden-modell-zum-benutzten-system">Synthese Teil V — Vom rechnenden Modell zum benutzten System</h1>
+<p>Zwei Kapitel, ein Übergang: Das Modell rechnet — und muss jetzt jemand anderem übergeben werden. Was dabei schiefgeht, hat selten mit Mathematik zu tun.</p>
+<h2 id="was-schiefgeht-und-was-dagegen-hilft">Was schiefgeht, und was dagegen hilft</h2>
+<table>
+<colgroup>
+<col style="width: 33%" />
+<col style="width: 33%" />
+<col style="width: 33%" />
+</colgroup>
+<thead>
+<tr class="header">
+<th>Was in Produktion passiert</th>
+<th>Gegenmittel</th>
+<th>Wo</th>
+</tr>
+</thead>
+<tbody>
+<tr class="odd">
+<td><code>INFEASIBLE</code> um 3 Uhr nachts, niemand weiß warum</td>
+<td>Relaxation mit gestaffelten Strafkosten (B18); Deletion Filter für die Diagnose</td>
+<td><a href="praxisfallen.html#kap-praxisfallen">Kapitel 22</a>, <a href="anhang-fehlerdiagnose.html#anhang-fehlerdiagnose">Anhang C</a></td>
+</tr>
+<tr class="even">
+<td>Der Disponent lehnt den Plan ab, weil er ihn nicht versteht</td>
+<td>Constraint-Trace für die einzelne Zuweisung; Kostenzurechnung für den ganzen Plan</td>
+<td><a href="praxisfallen.html#kap-praxisfallen">Kapitel 22</a>, <a href="praxisfallen.html#sec:praxisfallen-attribution">Abschnitt 22.4</a></td>
+</tr>
+<tr class="odd">
+<td>Der Solver läuft ins Zeitlimit und keiner merkt es</td>
+<td>Status, Gap und Zeitausschöpfung protokollieren — konstante Laufzeit ist ein Warnsignal</td>
+<td><a href="praxisfallen.html#kap-praxisfallen">Kapitel 22</a></td>
+</tr>
+<tr class="even">
+<td>Ein Test wird grundlos mal rot, mal grün</td>
+<td>auf Zielwert und Regeln prüfen, nicht auf die Gestalt der Lösung; <code>num_workers = 1</code> <strong>und</strong> Seed</td>
+<td><a href="cpsat.html#sec:cpsat-parallele-suche">Abschnitt 7.7</a>, <a href="testing.html#kap-testing">Kapitel 23</a></td>
+</tr>
+<tr class="odd">
+<td>Ein Ergebnis lässt sich später nicht mehr nachvollziehen</td>
+<td>Snapshot-Prinzip: unveränderlicher Datenstand mit ID je Lauf</td>
+<td><a href="praxisfallen.html#kap-praxisfallen">Kapitel 22</a></td>
+</tr>
+<tr class="even">
+<td>Das Modell prüft sich selbst</td>
+<td>Abnahmeprüfung als eigener Baustein, ohne Solver und ohne Modellvariable</td>
+<td><a href="praxisfallen.html#sec:praxisfallen-or-kern">Abschnitt 22.6</a></td>
+</tr>
+</tbody>
+</table>
+<h2 id="was-dieser-teil-gemessen-hat">Was dieser Teil gemessen hat</h2>
+<table>
+<colgroup>
+<col style="width: 33%" />
+<col style="width: 33%" />
+<col style="width: 33%" />
+</colgroup>
+<thead>
+<tr class="header">
+<th>Behauptung</th>
+<th>Gemessen</th>
+<th>Wo</th>
+</tr>
+</thead>
+<tbody>
+<tr class="odd">
+<td>„Der Solver nennt schon den Grund für <code>INFEASIBLE</code>.”</td>
+<td>Er nennt gar nichts. Der Deletion Filter findet einen kleinsten Konflikt — dieses Modell enthält <strong>neun</strong> verschiedene, und welchen man sieht, steuert die Prüfreihenfolge</td>
+<td><a href="anhang-fehlerdiagnose.html#anhang-fehlerdiagnose">Anhang C</a></td>
+</tr>
+<tr class="even">
+<td>„Bindende Bedingungen sind die teuren.”</td>
+<td>Von fünf bindenden Bedingungen kostet eine <strong>0,00 €</strong></td>
+<td><a href="praxisfallen.html#sec:praxisfallen-attribution">Abschnitt 22.4</a></td>
+</tr>
+<tr class="odd">
+<td>„Der Schattenpreis sagt, was der Hebel bringt.”</td>
+<td>Hochgerechnet 120 €, gemessen <strong>60 €</strong> — er gilt nur bis +15 Stunden. Die Ranglisten nach Preis und nach Wirkung drehen sich um</td>
+<td><a href="praxisfallen.html#sec:praxisfallen-attribution">Abschnitt 22.4</a></td>
+</tr>
+<tr class="even">
+<td>„Mehr Arbeiter sind proportional schneller.”</td>
+<td><strong>12,3-fach</strong> bei acht Arbeitern — überlinear, weil verschiedene Strategien statt derselben Suche laufen</td>
+<td><a href="cpsat.html#sec:cpsat-parallele-suche">Abschnitt 7.7</a></td>
+</tr>
+</tbody>
+</table>
+<h2 id="drei-fehler-die-dieser-teil-verhindert">Drei Fehler, die dieser Teil verhindert</h2>
+<ol type="1">
+<li><strong>Alles hart formulieren.</strong> Wer keine Regel brechen lässt, bekommt irgendwann eine Fehlermeldung statt eines Plans — und zwar nachts, im Batchlauf.</li>
+<li><strong>Genauer optimieren als die Daten sind.</strong> Ein Gap von 2 % ist bei ±10 % Datenunsicherheit bedeutungslos. Die Rechenzeit dafür ist verschenkt.</li>
+<li><strong>Einen Bericht für einen Beweis halten.</strong> Ein generierter Text erklärt das <strong>Modell</strong>, nicht die <strong>Wirklichkeit</strong>. Ist eine Eingabe falsch geschätzt, ist er überzeugend <strong>und</strong> falsch — die gefährlichste Kombination.</li>
+</ol>
+<h2 id="wenn-sie-nur-eines-mitnehmen">Wenn Sie nur eines mitnehmen</h2>
+<blockquote>
+<p><strong>🎯</strong> Ein Modell, das nur auf Ihrem Rechner und nur mit Ihren Daten läuft, ist ein Prototyp — kein System. Der Unterschied besteht aus drei Dingen, die alle nichts mit dem Solver zu tun haben: einer Abnahmeprüfung, einer Erklärung und einem Protokoll.</p>
+</blockquote>
+<p><strong>Danach:</strong> die Projektwerkstatt. Elf Aufträge, jeder mit Datenquellen, Modellskizze, Abnahmekriterien und Stolperfallen — zugeschnitten auf 10 bis 25 Stunden bis zu einem vorzeigbaren Ergebnis.</p>
+
+    </article>
+    
+    <nav class="prev-next"><a class="prev-next-knopf prev-next-prev" href="testing.html"><svg class="icon" aria-hidden="true"><use href="#icon-chevron-left"></use></svg><span><small>Zurück</small>Kapitel 23: Testen, Messen, Ausliefern</span></a><a class="prev-next-knopf prev-next-next" href="projektwerkstatt.html"><span><small>Weiter</small>Projektwerkstatt</span><svg class="icon" aria-hidden="true"><use href="#icon-chevron-right"></use></svg></a></nav>
+  </main>
+</div>
+<footer class="site-footer">
+  <p>© Dieter Schlüter · <a href="gesamtdokument.html">Gesamtdokument</a> ·
+  <a href="programme.html">Beispielprogramme</a></p>
+</footer>
+<script defer src="assets/search-index.js"></script>
+<script defer src="assets/programme.js"></script>
+<script defer src="assets/site.js"></script>
+</body>
+</html>
diff --git a/OR_HTML_04/testing.html b/OR_HTML_04/testing.html
index 9833ba3..34fdede 100644
--- a/OR_HTML_04/testing.html
+++ b/OR_HTML_04/testing.html
@@ -94,17 +94,17 @@
 </header>
 <div class="site-body">
   <div class="sidebar-overlay" id="sidebar-overlay" hidden></div>
-  <nav class="sidebar" id="sidebar" aria-label="Kapitelnavigation"><div class="sidebar-inhalt"><details class="sidebar-gruppe"><summary>Einstieg</summary><ul><li data-kapitel="vorwort.html"><a href="vorwort.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Vorwort & Lesehilfe</span></a></li><li data-kapitel="notation.html"><a href="notation.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Notation & Abkürzungen</span></a></li></ul></details><details class="sidebar-gruppe"><summary>Teil I: Grundlagen des Operations Research</summary><ul><li data-kapitel="einfuehrung.html"><a href="einfuehrung.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 1: Einführung in Operations Research — Vom Ursprung zur mathematischen Entscheidungsfindung</span></a></li><li data-kapitel="fundament.html"><a href="fundament.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 2: Das mathematische Fundament — Vektoren, Matrizen, Konvexität</span></a></li><li data-kapitel="oekosystem.html"><a href="oekosystem.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 3: Das Python-Ökosystem für OR — Solver, Bindings und Modellierungsschichten</span></a></li><li data-kapitel="modellierung.html"><a href="modellierung.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 4: Vom Management-Wunsch zum Modell</span></a></li></ul></details><details class="sidebar-gruppe"><summary>Teil II: Die Kernverfahren der deterministischen Optimierung</summary><ul><li data-kapitel="lp.html"><a href="lp.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 5: Lineare Programmierung — Simplex, Dualität und Schattenpreise</span></a></li><li data-kapitel="milp.html"><a href="milp.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 6: Gemischt-ganzzahlige Optimierung — Diskrete Entscheidungen und Branch-and-Bound</span></a></li><li data-kapitel="cpsat.html"><a href="cpsat.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 7: Constraint Programming mit CP-SAT — Logik, Scheduling und Zuweisung</span></a></li><li data-kapitel="graphen.html"><a href="graphen.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 8: Graphen, Flüsse und Touren — Min-Cost-Flow, Matching und VRP</span></a></li><li data-kapitel="metaheuristiken.html"><a href="metaheuristiken.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 9: Metaheuristiken — wenn der exakte Solver aussteigt</span></a></li><li data-kapitel="dekomposition.html"><a href="dekomposition.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 10: Spaltengenerierung — das Modell umbauen statt die Lösung raten</span></a></li></ul></details><details class="sidebar-gruppe"><summary>Teil III: Nichtlinearität, Unsicherheit und mehrperiodige Dynamik</summary><ul><li data-kapitel="qp-nlp.html"><a href="qp-nlp.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 11: Quadratische und nichtlineare Optimierung — KKT, Lagrange, Konvexität</span></a></li><li data-kapitel="unsicherheit.html"><a href="unsicherheit.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 12: Optimierung unter Unsicherheit — Monte-Carlo, Stochastik, Robustheit</span></a></li><li data-kapitel="dynamische-programmierung.html"><a href="dynamische-programmierung.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 13: Dynamische Programmierung — Die Bellman-Gleichung und Order-Execution</span></a></li><li data-kapitel="mehrziel.html"><a href="mehrziel.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 14: Mehrere Ziele — Pareto-Fronten statt Gewichte</span></a></li><li data-kapitel="prognose.html"><a href="prognose.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 15: Predict-then-Optimize — die bessere Prognose, die schlechtere Entscheidung</span></a></li></ul></details><details class="sidebar-gruppe"><summary>Teil IV: Anwendungen — Energiewirtschaft und Finanzmärkte</summary><ul><li data-kapitel="bruecke.html"><a href="bruecke.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 16: Die Strukturbrücke — dieselbe Mathematik, zwei Welten</span></a></li><li data-kapitel="supplychain.html"><a href="supplychain.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 17: Supply-Chain und Energieeinsatz unter Unsicherheit</span></a></li><li data-kapitel="finanzdaten.html"><a href="finanzdaten.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 18: Finanzdaten-Modellierung — Renditen, Kovarianz und Shrinkage</span></a></li><li data-kapitel="markowitz.html"><a href="markowitz.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 19: Die moderne Portfoliotheorie nach Markowitz</span></a></li><li data-kapitel="cvar.html"><a href="cvar.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 20: Tail-Risiko, CVaR und Transaktionskosten</span></a></li><li data-kapitel="handelsmaschine.html"><a href="handelsmaschine.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 21: Die vollständige quantitative Handelsmaschine</span></a></li></ul></details><details class="sidebar-gruppe" open><summary>Teil V: Praxis</summary><ul><li data-kapitel="praxisfallen.html"><a href="praxisfallen.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 22: Praxisfallen und der Weg zum produktiven Einsatz</span></a></li><li data-kapitel="testing.html" class="aktiv"><a href="testing.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 23: Testen, Messen, Ausliefern</span></a></li><li data-kapitel="projektwerkstatt.html"><a href="projektwerkstatt.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Projektwerkstatt</span></a></li></ul></details><details class="sidebar-gruppe"><summary>Anhänge</summary><ul><li data-kapitel="anhang-loesungen.html"><a href="anhang-loesungen.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Anhang A: Lösungen zu allen Übungsaufgaben</span></a></li><li data-kapitel="anhang-modellierungsmuster.html"><a href="anhang-modellierungsmuster.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Anhang B: Katalog der Modellierungsmuster</span></a></li><li data-kapitel="anhang-fehlerdiagnose.html"><a href="anhang-fehlerdiagnose.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Anhang C: Fehlerdiagnose-Handbuch</span></a></li><li data-kapitel="anhang-spickzettel.html"><a href="anhang-spickzettel.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Anhang D: Spickzettel der Solver</span></a></li><li data-kapitel="anhang-glossar-literatur.html"><a href="anhang-glossar-literatur.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Anhang E: Glossar und Literatur</span></a></li></ul></details><ul class="sidebar-extra"><li><a href="programme.html"><svg class="icon" aria-hidden="true"><use href="#icon-book"></use></svg> Beispielprogramme</a></li><li><a href="stichwortverzeichnis.html"><svg class="icon" aria-hidden="true"><use href="#icon-search"></use></svg> Stichwortverzeichnis</a></li><li><a href="gesamtdokument.html"><svg class="icon" aria-hidden="true"><use href="#icon-external-link"></use></svg> Gesamtdokument (eine Seite)</a></li><li><a href="Operations_Research_mit_Python_Version_04.pdf" download><svg class="icon" aria-hidden="true"><use href="#icon-download"></use></svg> Download als PDF</a></li></ul></div></nav>
+  <nav class="sidebar" id="sidebar" aria-label="Kapitelnavigation"><div class="sidebar-inhalt"><details class="sidebar-gruppe"><summary>Einstieg</summary><ul><li data-kapitel="vorwort.html"><a href="vorwort.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Vorwort & Lesehilfe</span></a></li><li data-kapitel="notation.html"><a href="notation.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Notation & Abkürzungen</span></a></li></ul></details><details class="sidebar-gruppe"><summary>Teil I: Grundlagen des Operations Research</summary><ul><li data-kapitel="einfuehrung.html"><a href="einfuehrung.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 1: Einführung in Operations Research — Vom Ursprung zur mathematischen Entscheidungsfindung</span></a></li><li data-kapitel="fundament.html"><a href="fundament.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 2: Das mathematische Fundament — Vektoren, Matrizen, Konvexität</span></a></li><li data-kapitel="oekosystem.html"><a href="oekosystem.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 3: Das Python-Ökosystem für OR — Solver, Bindings und Modellierungsschichten</span></a></li><li data-kapitel="modellierung.html"><a href="modellierung.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 4: Vom Management-Wunsch zum Modell</span></a></li><li data-kapitel="synthese-grundlagen.html"><a href="synthese-grundlagen.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Synthese Teil I</span></a></li></ul></details><details class="sidebar-gruppe"><summary>Teil II: Die Kernverfahren der deterministischen Optimierung</summary><ul><li data-kapitel="lp.html"><a href="lp.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 5: Lineare Programmierung — Simplex, Dualität und Schattenpreise</span></a></li><li data-kapitel="milp.html"><a href="milp.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 6: Gemischt-ganzzahlige Optimierung — Diskrete Entscheidungen und Branch-and-Bound</span></a></li><li data-kapitel="cpsat.html"><a href="cpsat.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 7: Constraint Programming mit CP-SAT — Logik, Scheduling und Zuweisung</span></a></li><li data-kapitel="graphen.html"><a href="graphen.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 8: Graphen, Flüsse und Touren — Min-Cost-Flow, Matching und VRP</span></a></li><li data-kapitel="metaheuristiken.html"><a href="metaheuristiken.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 9: Metaheuristiken — wenn der exakte Solver aussteigt</span></a></li><li data-kapitel="dekomposition.html"><a href="dekomposition.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 10: Spaltengenerierung — das Modell umbauen statt die Lösung raten</span></a></li><li data-kapitel="synthese-kernverfahren.html"><a href="synthese-kernverfahren.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Synthese Teil II</span></a></li></ul></details><details class="sidebar-gruppe"><summary>Teil III: Nichtlinearität, Unsicherheit und mehrperiodige Dynamik</summary><ul><li data-kapitel="qp-nlp.html"><a href="qp-nlp.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 11: Quadratische und nichtlineare Optimierung — KKT, Lagrange, Konvexität</span></a></li><li data-kapitel="unsicherheit.html"><a href="unsicherheit.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 12: Optimierung unter Unsicherheit — Monte-Carlo, Stochastik, Robustheit</span></a></li><li data-kapitel="dynamische-programmierung.html"><a href="dynamische-programmierung.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 13: Dynamische Programmierung — Die Bellman-Gleichung und Order-Execution</span></a></li><li data-kapitel="mehrziel.html"><a href="mehrziel.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 14: Mehrere Ziele — Pareto-Fronten statt Gewichte</span></a></li><li data-kapitel="prognose.html"><a href="prognose.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 15: Predict-then-Optimize — die bessere Prognose, die schlechtere Entscheidung</span></a></li><li data-kapitel="synthese-nichtlinear.html"><a href="synthese-nichtlinear.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Synthese Teil III</span></a></li></ul></details><details class="sidebar-gruppe"><summary>Teil IV: Anwendungen — Energiewirtschaft und Finanzmärkte</summary><ul><li data-kapitel="bruecke.html"><a href="bruecke.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 16: Die Strukturbrücke — dieselbe Mathematik, zwei Welten</span></a></li><li data-kapitel="supplychain.html"><a href="supplychain.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 17: Supply-Chain und Energieeinsatz unter Unsicherheit</span></a></li><li data-kapitel="finanzdaten.html"><a href="finanzdaten.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 18: Finanzdaten-Modellierung — Renditen, Kovarianz und Shrinkage</span></a></li><li data-kapitel="markowitz.html"><a href="markowitz.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 19: Die moderne Portfoliotheorie nach Markowitz</span></a></li><li data-kapitel="cvar.html"><a href="cvar.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 20: Tail-Risiko, CVaR und Transaktionskosten</span></a></li><li data-kapitel="handelsmaschine.html"><a href="handelsmaschine.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 21: Die vollständige quantitative Handelsmaschine</span></a></li><li data-kapitel="synthese-anwendungen.html"><a href="synthese-anwendungen.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Synthese Teil IV</span></a></li></ul></details><details class="sidebar-gruppe" open><summary>Teil V: Praxis</summary><ul><li data-kapitel="praxisfallen.html"><a href="praxisfallen.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 22: Praxisfallen und der Weg zum produktiven Einsatz</span></a></li><li data-kapitel="testing.html" class="aktiv"><a href="testing.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 23: Testen, Messen, Ausliefern</span></a></li><li data-kapitel="synthese-praxis.html"><a href="synthese-praxis.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Synthese Teil V</span></a></li><li data-kapitel="projektwerkstatt.html"><a href="projektwerkstatt.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Projektwerkstatt</span></a></li></ul></details><details class="sidebar-gruppe"><summary>Anhänge</summary><ul><li data-kapitel="anhang-loesungen.html"><a href="anhang-loesungen.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Anhang A: Lösungen zu allen Übungsaufgaben</span></a></li><li data-kapitel="anhang-modellierungsmuster.html"><a href="anhang-modellierungsmuster.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Anhang B: Katalog der Modellierungsmuster</span></a></li><li data-kapitel="anhang-fehlerdiagnose.html"><a href="anhang-fehlerdiagnose.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Anhang C: Fehlerdiagnose-Handbuch</span></a></li><li data-kapitel="anhang-spickzettel.html"><a href="anhang-spickzettel.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Anhang D: Spickzettel der Solver</span></a></li><li data-kapitel="anhang-glossar-literatur.html"><a href="anhang-glossar-literatur.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Anhang E: Glossar und Literatur</span></a></li></ul></details><ul class="sidebar-extra"><li><a href="programme.html"><svg class="icon" aria-hidden="true"><use href="#icon-book"></use></svg> Beispielprogramme</a></li><li><a href="stichwortverzeichnis.html"><svg class="icon" aria-hidden="true"><use href="#icon-search"></use></svg> Stichwortverzeichnis</a></li><li><a href="gesamtdokument.html"><svg class="icon" aria-hidden="true"><use href="#icon-external-link"></use></svg> Gesamtdokument (eine Seite)</a></li><li><a href="Operations_Research_mit_Python_Version_04.pdf" download><svg class="icon" aria-hidden="true"><use href="#icon-download"></use></svg> Download als PDF</a></li></ul></div></nav>
   <main class="content">
     <nav class="breadcrumb" aria-label="Breadcrumb"><a href="index.html">Start</a> › <span>Teil V</span> › <span>Kapitel 23: Testen, Messen, Ausliefern</span></nav>
-    <nav class="prev-next"><a class="prev-next-knopf prev-next-prev" href="praxisfallen.html"><svg class="icon" aria-hidden="true"><use href="#icon-chevron-left"></use></svg><span><small>Zurück</small>Kapitel 22: Praxisfallen und der Weg zum produktiven Einsatz</span></a><a class="prev-next-knopf prev-next-next" href="projektwerkstatt.html"><span><small>Weiter</small>Projektwerkstatt</span><svg class="icon" aria-hidden="true"><use href="#icon-chevron-right"></use></svg></a></nav>
+    <nav class="prev-next"><a class="prev-next-knopf prev-next-prev" href="praxisfallen.html"><svg class="icon" aria-hidden="true"><use href="#icon-chevron-left"></use></svg><span><small>Zurück</small>Kapitel 22: Praxisfallen und der Weg zum produktiven Einsatz</span></a><a class="prev-next-knopf prev-next-next" href="synthese-praxis.html"><span><small>Weiter</small>Synthese Teil V</span><svg class="icon" aria-hidden="true"><use href="#icon-chevron-right"></use></svg></a></nav>
     <article>
     <h1 id="kap-testing">Kapitel 23: Testen, Messen, Ausliefern</h1>
 <div class="card card-blick">
 <blockquote>
 <p><strong>📌 Kapitel auf einen Blick</strong></p>
 <p><strong>Worum geht es?</strong> Um die drei Fragen, die zwischen einem funktionierenden Modell und einem System stehen, auf das sich jemand verlässt: <em>Woher weiß ich, dass es stimmt? Woher weiß ich, dass es schnell genug ist? Wie kommt es zu den Leuten, die es brauchen?</em></p>
-<p><strong>Voraussetzungen:</strong> <a href="praxisfallen.html#kap-praxisfallen">Kapitel 22</a>, insbesondere <code>or_kern.py</code> aus <a href="praxisfallen.html#sec:praxisfallen-or-kern">Abschnitt 22.5</a> — dieses Kapitel testet genau dieses Modul.</p>
+<p><strong>Voraussetzungen:</strong> <a href="praxisfallen.html#kap-praxisfallen">Kapitel 22</a>, insbesondere <code>or_kern.py</code> aus <a href="praxisfallen.html#sec:praxisfallen-or-kern">Abschnitt 22.6</a> — dieses Kapitel testet genau dieses Modul.</p>
 <p><strong>Danach können Sie:</strong> ein Optimierungsmodell testen, obwohl Sie die richtige Antwort nicht kennen; Ihre eigene Testsuite auf Lücken prüfen; einen Solververgleich aufsetzen, dem man glauben kann; und das Modell als Dienst betreiben, ohne dass die erste große Anfrage ihn blockiert.</p>
 <p><strong>Zeitbedarf:</strong> ca. 5 Stunden.</p>
 <p><strong>Programme:</strong><br />
@@ -865,173 +865,184 @@ moeglichen Fehler. Was zaehlt, ist die LISTE der Ueberlebenden.
 <span id="cb9-33"><a href="#cb9-33" aria-hidden="true" tabindex="-1"></a></span>
 <span id="cb9-34"><a href="#cb9-34" aria-hidden="true" tabindex="-1"></a><span class="im">from</span> __future__ <span class="im">import</span> annotations</span>
 <span id="cb9-35"><a href="#cb9-35" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb9-36"><a href="#cb9-36" aria-hidden="true" tabindex="-1"></a><span class="im">import</span> json</span>
-<span id="cb9-37"><a href="#cb9-37" aria-hidden="true" tabindex="-1"></a><span class="im">import</span> subprocess</span>
-<span id="cb9-38"><a href="#cb9-38" aria-hidden="true" tabindex="-1"></a><span class="im">import</span> sys</span>
-<span id="cb9-39"><a href="#cb9-39" aria-hidden="true" tabindex="-1"></a><span class="im">import</span> textwrap</span>
+<span id="cb9-36"><a href="#cb9-36" aria-hidden="true" tabindex="-1"></a><span class="im">import</span> multiprocessing</span>
+<span id="cb9-37"><a href="#cb9-37" aria-hidden="true" tabindex="-1"></a><span class="im">import</span> resource</span>
+<span id="cb9-38"><a href="#cb9-38" aria-hidden="true" tabindex="-1"></a><span class="im">import</span> time</span>
+<span id="cb9-39"><a href="#cb9-39" aria-hidden="true" tabindex="-1"></a><span class="im">from</span> concurrent.futures <span class="im">import</span> ProcessPoolExecutor</span>
 <span id="cb9-40"><a href="#cb9-40" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb9-41"><a href="#cb9-41" aria-hidden="true" tabindex="-1"></a>GROESSEN <span class="op">=</span> [(<span class="dv">10</span>, <span class="dv">10</span>), (<span class="dv">32</span>, <span class="dv">32</span>), (<span class="dv">100</span>, <span class="dv">100</span>)]   <span class="co"># (Lager, Kunden) -&gt; 100 / 1.024 / 10.000 Variablen</span></span>
+<span id="cb9-41"><a href="#cb9-41" aria-hidden="true" tabindex="-1"></a><span class="im">import</span> numpy <span class="im">as</span> np</span>
 <span id="cb9-42"><a href="#cb9-42" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb9-43"><a href="#cb9-43" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb9-44"><a href="#cb9-44" aria-hidden="true" tabindex="-1"></a><span class="co"># Jeder Eintrag ist ein eigenstaendiges Programm: Instanz aufbauen, loesen,</span></span>
-<span id="cb9-45"><a href="#cb9-45" aria-hidden="true" tabindex="-1"></a><span class="co"># Ergebnis als JSON ausgeben. Die Instanz wird in jedem Kindprozess aus</span></span>
-<span id="cb9-46"><a href="#cb9-46" aria-hidden="true" tabindex="-1"></a><span class="co"># derselben Saat neu erzeugt - so reist nichts ueber die Prozessgrenze,</span></span>
-<span id="cb9-47"><a href="#cb9-47" aria-hidden="true" tabindex="-1"></a><span class="co"># was das Ergebnis verfaelschen koennte.</span></span>
-<span id="cb9-48"><a href="#cb9-48" aria-hidden="true" tabindex="-1"></a>VORSPANN <span class="op">=</span> <span class="st">&quot;&quot;&quot;</span></span>
-<span id="cb9-49"><a href="#cb9-49" aria-hidden="true" tabindex="-1"></a><span class="st">import json, time, resource</span></span>
-<span id="cb9-50"><a href="#cb9-50" aria-hidden="true" tabindex="-1"></a><span class="st">import numpy as np</span></span>
-<span id="cb9-51"><a href="#cb9-51" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb9-52"><a href="#cb9-52" aria-hidden="true" tabindex="-1"></a><span class="st">def instanz(m, n):</span></span>
-<span id="cb9-53"><a href="#cb9-53" aria-hidden="true" tabindex="-1"></a><span class="st">    rng = np.random.default_rng(20)</span></span>
-<span id="cb9-54"><a href="#cb9-54" aria-hidden="true" tabindex="-1"></a><span class="st">    kosten = rng.integers(5, 95, (m, n)).astype(float)</span></span>
-<span id="cb9-55"><a href="#cb9-55" aria-hidden="true" tabindex="-1"></a><span class="st">    angebot = rng.integers(50, 150, m).astype(float)</span></span>
-<span id="cb9-56"><a href="#cb9-56" aria-hidden="true" tabindex="-1"></a><span class="st">    bedarf = angebot.sum() * rng.dirichlet(np.ones(n))</span></span>
-<span id="cb9-57"><a href="#cb9-57" aria-hidden="true" tabindex="-1"></a><span class="st">    return kosten, angebot, bedarf</span></span>
+<span id="cb9-43"><a href="#cb9-43" aria-hidden="true" tabindex="-1"></a>GROESSEN <span class="op">=</span> [(<span class="dv">10</span>, <span class="dv">10</span>), (<span class="dv">32</span>, <span class="dv">32</span>), (<span class="dv">100</span>, <span class="dv">100</span>)]   <span class="co"># (Lager, Kunden) -&gt; 100 / 1.024 / 10.000 Variablen</span></span>
+<span id="cb9-44"><a href="#cb9-44" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb9-45"><a href="#cb9-45" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb9-46"><a href="#cb9-46" aria-hidden="true" tabindex="-1"></a><span class="co"># Instanz und Speichermessung stehen als gewoehnliche Funktionen hier - nicht</span></span>
+<span id="cb9-47"><a href="#cb9-47" aria-hidden="true" tabindex="-1"></a><span class="co"># in einem String, den ein Kindprozess ausfuehrt. Jede Messfunktion baut die</span></span>
+<span id="cb9-48"><a href="#cb9-48" aria-hidden="true" tabindex="-1"></a><span class="co"># Instanz aus derselben Saat neu auf, damit ueber die Prozessgrenze nichts</span></span>
+<span id="cb9-49"><a href="#cb9-49" aria-hidden="true" tabindex="-1"></a><span class="co"># reist, was das Ergebnis verfaelschen koennte.</span></span>
+<span id="cb9-50"><a href="#cb9-50" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb9-51"><a href="#cb9-51" aria-hidden="true" tabindex="-1"></a><span class="kw">def</span> instanz(m: <span class="bu">int</span>, n: <span class="bu">int</span>):</span>
+<span id="cb9-52"><a href="#cb9-52" aria-hidden="true" tabindex="-1"></a>    rng <span class="op">=</span> np.random.default_rng(<span class="dv">20</span>)</span>
+<span id="cb9-53"><a href="#cb9-53" aria-hidden="true" tabindex="-1"></a>    kosten <span class="op">=</span> rng.integers(<span class="dv">5</span>, <span class="dv">95</span>, (m, n)).astype(<span class="bu">float</span>)</span>
+<span id="cb9-54"><a href="#cb9-54" aria-hidden="true" tabindex="-1"></a>    angebot <span class="op">=</span> rng.integers(<span class="dv">50</span>, <span class="dv">150</span>, m).astype(<span class="bu">float</span>)</span>
+<span id="cb9-55"><a href="#cb9-55" aria-hidden="true" tabindex="-1"></a>    bedarf <span class="op">=</span> angebot.<span class="bu">sum</span>() <span class="op">*</span> rng.dirichlet(np.ones(n))</span>
+<span id="cb9-56"><a href="#cb9-56" aria-hidden="true" tabindex="-1"></a>    <span class="cf">return</span> kosten, angebot, bedarf</span>
+<span id="cb9-57"><a href="#cb9-57" aria-hidden="true" tabindex="-1"></a></span>
 <span id="cb9-58"><a href="#cb9-58" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb9-59"><a href="#cb9-59" aria-hidden="true" tabindex="-1"></a><span class="st">def speicher_mb():</span></span>
-<span id="cb9-60"><a href="#cb9-60" aria-hidden="true" tabindex="-1"></a><span class="st">    # ru_maxrss ist unter Linux in Kilobyte</span></span>
-<span id="cb9-61"><a href="#cb9-61" aria-hidden="true" tabindex="-1"></a><span class="st">    return resource.getrusage(resource.RUSAGE_SELF).ru_maxrss / 1024</span></span>
-<span id="cb9-62"><a href="#cb9-62" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb9-63"><a href="#cb9-63" aria-hidden="true" tabindex="-1"></a><span class="st">M, N = </span><span class="sc">{m}</span><span class="st">, </span><span class="sc">{n}</span></span>
-<span id="cb9-64"><a href="#cb9-64" aria-hidden="true" tabindex="-1"></a><span class="st">kosten, angebot, bedarf = instanz(M, N)</span></span>
-<span id="cb9-65"><a href="#cb9-65" aria-hidden="true" tabindex="-1"></a><span class="st">&quot;&quot;&quot;</span></span>
-<span id="cb9-66"><a href="#cb9-66" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb9-67"><a href="#cb9-67" aria-hidden="true" tabindex="-1"></a>ANSAETZE <span class="op">=</span> {</span>
-<span id="cb9-68"><a href="#cb9-68" aria-hidden="true" tabindex="-1"></a>    <span class="st">&quot;scipy.linprog&quot;</span>: <span class="st">&quot;&quot;&quot;</span></span>
-<span id="cb9-69"><a href="#cb9-69" aria-hidden="true" tabindex="-1"></a><span class="st">        from scipy.optimize import linprog</span></span>
-<span id="cb9-70"><a href="#cb9-70" aria-hidden="true" tabindex="-1"></a><span class="st">        t0 = time.perf_counter()</span></span>
-<span id="cb9-71"><a href="#cb9-71" aria-hidden="true" tabindex="-1"></a><span class="st">        c = kosten.reshape(-1)</span></span>
-<span id="cb9-72"><a href="#cb9-72" aria-hidden="true" tabindex="-1"></a><span class="st">        A_ub = np.zeros((M, M * N)); A_eq = np.zeros((N, M * N))</span></span>
-<span id="cb9-73"><a href="#cb9-73" aria-hidden="true" tabindex="-1"></a><span class="st">        for i in range(M):</span></span>
-<span id="cb9-74"><a href="#cb9-74" aria-hidden="true" tabindex="-1"></a><span class="st">            A_ub[i, i * N:(i + 1) * N] = 1.0</span></span>
-<span id="cb9-75"><a href="#cb9-75" aria-hidden="true" tabindex="-1"></a><span class="st">        for j in range(N):</span></span>
-<span id="cb9-76"><a href="#cb9-76" aria-hidden="true" tabindex="-1"></a><span class="st">            A_eq[j, j::N] = 1.0</span></span>
-<span id="cb9-77"><a href="#cb9-77" aria-hidden="true" tabindex="-1"></a><span class="st">        aufbau = time.perf_counter() - t0</span></span>
-<span id="cb9-78"><a href="#cb9-78" aria-hidden="true" tabindex="-1"></a><span class="st">        t0 = time.perf_counter()</span></span>
-<span id="cb9-79"><a href="#cb9-79" aria-hidden="true" tabindex="-1"></a><span class="st">        r = linprog(c=c, A_ub=A_ub, b_ub=angebot, A_eq=A_eq, b_eq=bedarf,</span></span>
-<span id="cb9-80"><a href="#cb9-80" aria-hidden="true" tabindex="-1"></a><span class="st">                    bounds=(0, None), method=&quot;highs&quot;)</span></span>
-<span id="cb9-81"><a href="#cb9-81" aria-hidden="true" tabindex="-1"></a><span class="st">        loesen = time.perf_counter() - t0</span></span>
-<span id="cb9-82"><a href="#cb9-82" aria-hidden="true" tabindex="-1"></a><span class="st">        ausgabe = (float(r.fun), aufbau, loesen, speicher_mb())</span></span>
-<span id="cb9-83"><a href="#cb9-83" aria-hidden="true" tabindex="-1"></a><span class="st">    &quot;&quot;&quot;</span>,</span>
-<span id="cb9-84"><a href="#cb9-84" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb9-85"><a href="#cb9-85" aria-hidden="true" tabindex="-1"></a>    <span class="st">&quot;highspy&quot;</span>: <span class="st">&quot;&quot;&quot;</span></span>
-<span id="cb9-86"><a href="#cb9-86" aria-hidden="true" tabindex="-1"></a><span class="st">        import highspy</span></span>
-<span id="cb9-87"><a href="#cb9-87" aria-hidden="true" tabindex="-1"></a><span class="st">        t0 = time.perf_counter()</span></span>
-<span id="cb9-88"><a href="#cb9-88" aria-hidden="true" tabindex="-1"></a><span class="st">        h = highspy.Highs(); h.setOptionValue(&quot;output_flag&quot;, False)</span></span>
-<span id="cb9-89"><a href="#cb9-89" aria-hidden="true" tabindex="-1"></a><span class="st">        h.addVars(M * N, np.zeros(M * N), np.full(M * N, highspy.kHighsInf))</span></span>
-<span id="cb9-90"><a href="#cb9-90" aria-hidden="true" tabindex="-1"></a><span class="st">        for k in range(M * N):</span></span>
-<span id="cb9-91"><a href="#cb9-91" aria-hidden="true" tabindex="-1"></a><span class="st">            h.changeColCost(k, float(kosten.reshape(-1)[k]))</span></span>
-<span id="cb9-92"><a href="#cb9-92" aria-hidden="true" tabindex="-1"></a><span class="st">        for i in range(M):</span></span>
-<span id="cb9-93"><a href="#cb9-93" aria-hidden="true" tabindex="-1"></a><span class="st">            idx = np.arange(i * N, (i + 1) * N, dtype=np.int32)</span></span>
-<span id="cb9-94"><a href="#cb9-94" aria-hidden="true" tabindex="-1"></a><span class="st">            h.addRow(-highspy.kHighsInf, float(angebot[i]), N, idx, np.ones(N))</span></span>
-<span id="cb9-95"><a href="#cb9-95" aria-hidden="true" tabindex="-1"></a><span class="st">        for j in range(N):</span></span>
-<span id="cb9-96"><a href="#cb9-96" aria-hidden="true" tabindex="-1"></a><span class="st">            idx = np.arange(j, M * N, N, dtype=np.int32)</span></span>
-<span id="cb9-97"><a href="#cb9-97" aria-hidden="true" tabindex="-1"></a><span class="st">            h.addRow(float(bedarf[j]), float(bedarf[j]), M, idx, np.ones(M))</span></span>
-<span id="cb9-98"><a href="#cb9-98" aria-hidden="true" tabindex="-1"></a><span class="st">        aufbau = time.perf_counter() - t0</span></span>
-<span id="cb9-99"><a href="#cb9-99" aria-hidden="true" tabindex="-1"></a><span class="st">        t0 = time.perf_counter(); h.run(); loesen = time.perf_counter() - t0</span></span>
-<span id="cb9-100"><a href="#cb9-100" aria-hidden="true" tabindex="-1"></a><span class="st">        ausgabe = (h.getInfo().objective_function_value, aufbau, loesen, speicher_mb())</span></span>
-<span id="cb9-101"><a href="#cb9-101" aria-hidden="true" tabindex="-1"></a><span class="st">    &quot;&quot;&quot;</span>,</span>
-<span id="cb9-102"><a href="#cb9-102" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb9-103"><a href="#cb9-103" aria-hidden="true" tabindex="-1"></a>    <span class="st">&quot;ortools/GLOP&quot;</span>: <span class="st">&quot;&quot;&quot;</span></span>
-<span id="cb9-104"><a href="#cb9-104" aria-hidden="true" tabindex="-1"></a><span class="st">        from ortools.linear_solver import pywraplp</span></span>
-<span id="cb9-105"><a href="#cb9-105" aria-hidden="true" tabindex="-1"></a><span class="st">        t0 = time.perf_counter()</span></span>
-<span id="cb9-106"><a href="#cb9-106" aria-hidden="true" tabindex="-1"></a><span class="st">        s = pywraplp.Solver.CreateSolver(&quot;GLOP&quot;)</span></span>
-<span id="cb9-107"><a href="#cb9-107" aria-hidden="true" tabindex="-1"></a><span class="st">        x = [[s.NumVar(0, s.infinity(), f&quot;x</span><span class="sc">{i}</span><span class="st">_</span><span class="sc">{j}</span><span class="st">&quot;) for j in range(N)]</span></span>
-<span id="cb9-108"><a href="#cb9-108" aria-hidden="true" tabindex="-1"></a><span class="st">             for i in range(M)]</span></span>
-<span id="cb9-109"><a href="#cb9-109" aria-hidden="true" tabindex="-1"></a><span class="st">        for i in range(M):</span></span>
-<span id="cb9-110"><a href="#cb9-110" aria-hidden="true" tabindex="-1"></a><span class="st">            s.Add(sum(x[i]) &lt;= float(angebot[i]))</span></span>
-<span id="cb9-111"><a href="#cb9-111" aria-hidden="true" tabindex="-1"></a><span class="st">        for j in range(N):</span></span>
-<span id="cb9-112"><a href="#cb9-112" aria-hidden="true" tabindex="-1"></a><span class="st">            s.Add(sum(x[i][j] for i in range(M)) == float(bedarf[j]))</span></span>
-<span id="cb9-113"><a href="#cb9-113" aria-hidden="true" tabindex="-1"></a><span class="st">        s.Minimize(sum(float(kosten[i, j]) * x[i][j]</span></span>
-<span id="cb9-114"><a href="#cb9-114" aria-hidden="true" tabindex="-1"></a><span class="st">                       for i in range(M) for j in range(N)))</span></span>
-<span id="cb9-115"><a href="#cb9-115" aria-hidden="true" tabindex="-1"></a><span class="st">        aufbau = time.perf_counter() - t0</span></span>
-<span id="cb9-116"><a href="#cb9-116" aria-hidden="true" tabindex="-1"></a><span class="st">        t0 = time.perf_counter(); s.Solve(); loesen = time.perf_counter() - t0</span></span>
-<span id="cb9-117"><a href="#cb9-117" aria-hidden="true" tabindex="-1"></a><span class="st">        ausgabe = (s.Objective().Value(), aufbau, loesen, speicher_mb())</span></span>
-<span id="cb9-118"><a href="#cb9-118" aria-hidden="true" tabindex="-1"></a><span class="st">    &quot;&quot;&quot;</span>,</span>
+<span id="cb9-59"><a href="#cb9-59" aria-hidden="true" tabindex="-1"></a><span class="kw">def</span> speicher_mb() <span class="op">-&gt;</span> <span class="bu">float</span>:</span>
+<span id="cb9-60"><a href="#cb9-60" aria-hidden="true" tabindex="-1"></a>    <span class="co"># ru_maxrss ist unter Linux in Kilobyte. Gemessen wird der Kindprozess -</span></span>
+<span id="cb9-61"><a href="#cb9-61" aria-hidden="true" tabindex="-1"></a>    <span class="co"># deshalb muss jede Messung einen eigenen bekommen.</span></span>
+<span id="cb9-62"><a href="#cb9-62" aria-hidden="true" tabindex="-1"></a>    <span class="cf">return</span> resource.getrusage(resource.RUSAGE_SELF).ru_maxrss <span class="op">/</span> <span class="dv">1024</span></span>
+<span id="cb9-63"><a href="#cb9-63" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb9-64"><a href="#cb9-64" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb9-65"><a href="#cb9-65" aria-hidden="true" tabindex="-1"></a><span class="kw">def</span> messe_scipy(m: <span class="bu">int</span>, n: <span class="bu">int</span>):</span>
+<span id="cb9-66"><a href="#cb9-66" aria-hidden="true" tabindex="-1"></a>    <span class="im">from</span> scipy.optimize <span class="im">import</span> linprog</span>
+<span id="cb9-67"><a href="#cb9-67" aria-hidden="true" tabindex="-1"></a>    kosten, angebot, bedarf <span class="op">=</span> instanz(m, n)</span>
+<span id="cb9-68"><a href="#cb9-68" aria-hidden="true" tabindex="-1"></a>    t0 <span class="op">=</span> time.perf_counter()</span>
+<span id="cb9-69"><a href="#cb9-69" aria-hidden="true" tabindex="-1"></a>    c <span class="op">=</span> kosten.reshape(<span class="op">-</span><span class="dv">1</span>)</span>
+<span id="cb9-70"><a href="#cb9-70" aria-hidden="true" tabindex="-1"></a>    A_ub <span class="op">=</span> np.zeros((m, m <span class="op">*</span> n))<span class="op">;</span> A_eq <span class="op">=</span> np.zeros((n, m <span class="op">*</span> n))</span>
+<span id="cb9-71"><a href="#cb9-71" aria-hidden="true" tabindex="-1"></a>    <span class="cf">for</span> i <span class="kw">in</span> <span class="bu">range</span>(m):</span>
+<span id="cb9-72"><a href="#cb9-72" aria-hidden="true" tabindex="-1"></a>        A_ub[i, i <span class="op">*</span> n:(i <span class="op">+</span> <span class="dv">1</span>) <span class="op">*</span> n] <span class="op">=</span> <span class="fl">1.0</span></span>
+<span id="cb9-73"><a href="#cb9-73" aria-hidden="true" tabindex="-1"></a>    <span class="cf">for</span> j <span class="kw">in</span> <span class="bu">range</span>(n):</span>
+<span id="cb9-74"><a href="#cb9-74" aria-hidden="true" tabindex="-1"></a>        A_eq[j, j::n] <span class="op">=</span> <span class="fl">1.0</span></span>
+<span id="cb9-75"><a href="#cb9-75" aria-hidden="true" tabindex="-1"></a>    aufbau <span class="op">=</span> time.perf_counter() <span class="op">-</span> t0</span>
+<span id="cb9-76"><a href="#cb9-76" aria-hidden="true" tabindex="-1"></a>    t0 <span class="op">=</span> time.perf_counter()</span>
+<span id="cb9-77"><a href="#cb9-77" aria-hidden="true" tabindex="-1"></a>    r <span class="op">=</span> linprog(c<span class="op">=</span>c, A_ub<span class="op">=</span>A_ub, b_ub<span class="op">=</span>angebot, A_eq<span class="op">=</span>A_eq, b_eq<span class="op">=</span>bedarf,</span>
+<span id="cb9-78"><a href="#cb9-78" aria-hidden="true" tabindex="-1"></a>                bounds<span class="op">=</span>(<span class="dv">0</span>, <span class="va">None</span>), method<span class="op">=</span><span class="st">&quot;highs&quot;</span>)</span>
+<span id="cb9-79"><a href="#cb9-79" aria-hidden="true" tabindex="-1"></a>    loesen <span class="op">=</span> time.perf_counter() <span class="op">-</span> t0</span>
+<span id="cb9-80"><a href="#cb9-80" aria-hidden="true" tabindex="-1"></a>    <span class="cf">return</span> <span class="bu">float</span>(r.fun), aufbau, loesen, speicher_mb()</span>
+<span id="cb9-81"><a href="#cb9-81" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb9-82"><a href="#cb9-82" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb9-83"><a href="#cb9-83" aria-hidden="true" tabindex="-1"></a><span class="kw">def</span> messe_highspy(m: <span class="bu">int</span>, n: <span class="bu">int</span>):</span>
+<span id="cb9-84"><a href="#cb9-84" aria-hidden="true" tabindex="-1"></a>    <span class="im">import</span> highspy</span>
+<span id="cb9-85"><a href="#cb9-85" aria-hidden="true" tabindex="-1"></a>    kosten, angebot, bedarf <span class="op">=</span> instanz(m, n)</span>
+<span id="cb9-86"><a href="#cb9-86" aria-hidden="true" tabindex="-1"></a>    t0 <span class="op">=</span> time.perf_counter()</span>
+<span id="cb9-87"><a href="#cb9-87" aria-hidden="true" tabindex="-1"></a>    h <span class="op">=</span> highspy.Highs()<span class="op">;</span> h.setOptionValue(<span class="st">&quot;output_flag&quot;</span>, <span class="va">False</span>)</span>
+<span id="cb9-88"><a href="#cb9-88" aria-hidden="true" tabindex="-1"></a>    h.addVars(m <span class="op">*</span> n, np.zeros(m <span class="op">*</span> n), np.full(m <span class="op">*</span> n, highspy.kHighsInf))</span>
+<span id="cb9-89"><a href="#cb9-89" aria-hidden="true" tabindex="-1"></a>    <span class="cf">for</span> k <span class="kw">in</span> <span class="bu">range</span>(m <span class="op">*</span> n):</span>
+<span id="cb9-90"><a href="#cb9-90" aria-hidden="true" tabindex="-1"></a>        h.changeColCost(k, <span class="bu">float</span>(kosten.reshape(<span class="op">-</span><span class="dv">1</span>)[k]))</span>
+<span id="cb9-91"><a href="#cb9-91" aria-hidden="true" tabindex="-1"></a>    <span class="cf">for</span> i <span class="kw">in</span> <span class="bu">range</span>(m):</span>
+<span id="cb9-92"><a href="#cb9-92" aria-hidden="true" tabindex="-1"></a>        idx <span class="op">=</span> np.arange(i <span class="op">*</span> n, (i <span class="op">+</span> <span class="dv">1</span>) <span class="op">*</span> n, dtype<span class="op">=</span>np.int32)</span>
+<span id="cb9-93"><a href="#cb9-93" aria-hidden="true" tabindex="-1"></a>        h.addRow(<span class="op">-</span>highspy.kHighsInf, <span class="bu">float</span>(angebot[i]), n, idx, np.ones(n))</span>
+<span id="cb9-94"><a href="#cb9-94" aria-hidden="true" tabindex="-1"></a>    <span class="cf">for</span> j <span class="kw">in</span> <span class="bu">range</span>(n):</span>
+<span id="cb9-95"><a href="#cb9-95" aria-hidden="true" tabindex="-1"></a>        idx <span class="op">=</span> np.arange(j, m <span class="op">*</span> n, n, dtype<span class="op">=</span>np.int32)</span>
+<span id="cb9-96"><a href="#cb9-96" aria-hidden="true" tabindex="-1"></a>        h.addRow(<span class="bu">float</span>(bedarf[j]), <span class="bu">float</span>(bedarf[j]), m, idx, np.ones(m))</span>
+<span id="cb9-97"><a href="#cb9-97" aria-hidden="true" tabindex="-1"></a>    aufbau <span class="op">=</span> time.perf_counter() <span class="op">-</span> t0</span>
+<span id="cb9-98"><a href="#cb9-98" aria-hidden="true" tabindex="-1"></a>    t0 <span class="op">=</span> time.perf_counter()<span class="op">;</span> h.run()<span class="op">;</span> loesen <span class="op">=</span> time.perf_counter() <span class="op">-</span> t0</span>
+<span id="cb9-99"><a href="#cb9-99" aria-hidden="true" tabindex="-1"></a>    <span class="cf">return</span> h.getInfo().objective_function_value, aufbau, loesen, speicher_mb()</span>
+<span id="cb9-100"><a href="#cb9-100" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb9-101"><a href="#cb9-101" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb9-102"><a href="#cb9-102" aria-hidden="true" tabindex="-1"></a><span class="kw">def</span> messe_ortools(m: <span class="bu">int</span>, n: <span class="bu">int</span>):</span>
+<span id="cb9-103"><a href="#cb9-103" aria-hidden="true" tabindex="-1"></a>    <span class="im">from</span> ortools.linear_solver <span class="im">import</span> pywraplp</span>
+<span id="cb9-104"><a href="#cb9-104" aria-hidden="true" tabindex="-1"></a>    kosten, angebot, bedarf <span class="op">=</span> instanz(m, n)</span>
+<span id="cb9-105"><a href="#cb9-105" aria-hidden="true" tabindex="-1"></a>    t0 <span class="op">=</span> time.perf_counter()</span>
+<span id="cb9-106"><a href="#cb9-106" aria-hidden="true" tabindex="-1"></a>    s <span class="op">=</span> pywraplp.Solver.CreateSolver(<span class="st">&quot;GLOP&quot;</span>)</span>
+<span id="cb9-107"><a href="#cb9-107" aria-hidden="true" tabindex="-1"></a>    x <span class="op">=</span> [[s.NumVar(<span class="dv">0</span>, s.infinity(), <span class="ss">f&quot;x</span><span class="sc">{</span>i<span class="sc">}</span><span class="ss">_</span><span class="sc">{</span>j<span class="sc">}</span><span class="ss">&quot;</span>) <span class="cf">for</span> j <span class="kw">in</span> <span class="bu">range</span>(n)]</span>
+<span id="cb9-108"><a href="#cb9-108" aria-hidden="true" tabindex="-1"></a>         <span class="cf">for</span> i <span class="kw">in</span> <span class="bu">range</span>(m)]</span>
+<span id="cb9-109"><a href="#cb9-109" aria-hidden="true" tabindex="-1"></a>    <span class="cf">for</span> i <span class="kw">in</span> <span class="bu">range</span>(m):</span>
+<span id="cb9-110"><a href="#cb9-110" aria-hidden="true" tabindex="-1"></a>        s.Add(<span class="bu">sum</span>(x[i]) <span class="op">&lt;=</span> <span class="bu">float</span>(angebot[i]))</span>
+<span id="cb9-111"><a href="#cb9-111" aria-hidden="true" tabindex="-1"></a>    <span class="cf">for</span> j <span class="kw">in</span> <span class="bu">range</span>(n):</span>
+<span id="cb9-112"><a href="#cb9-112" aria-hidden="true" tabindex="-1"></a>        s.Add(<span class="bu">sum</span>(x[i][j] <span class="cf">for</span> i <span class="kw">in</span> <span class="bu">range</span>(m)) <span class="op">==</span> <span class="bu">float</span>(bedarf[j]))</span>
+<span id="cb9-113"><a href="#cb9-113" aria-hidden="true" tabindex="-1"></a>    s.Minimize(<span class="bu">sum</span>(<span class="bu">float</span>(kosten[i, j]) <span class="op">*</span> x[i][j]</span>
+<span id="cb9-114"><a href="#cb9-114" aria-hidden="true" tabindex="-1"></a>                   <span class="cf">for</span> i <span class="kw">in</span> <span class="bu">range</span>(m) <span class="cf">for</span> j <span class="kw">in</span> <span class="bu">range</span>(n)))</span>
+<span id="cb9-115"><a href="#cb9-115" aria-hidden="true" tabindex="-1"></a>    aufbau <span class="op">=</span> time.perf_counter() <span class="op">-</span> t0</span>
+<span id="cb9-116"><a href="#cb9-116" aria-hidden="true" tabindex="-1"></a>    t0 <span class="op">=</span> time.perf_counter()<span class="op">;</span> s.Solve()<span class="op">;</span> loesen <span class="op">=</span> time.perf_counter() <span class="op">-</span> t0</span>
+<span id="cb9-117"><a href="#cb9-117" aria-hidden="true" tabindex="-1"></a>    <span class="cf">return</span> s.Objective().Value(), aufbau, loesen, speicher_mb()</span>
+<span id="cb9-118"><a href="#cb9-118" aria-hidden="true" tabindex="-1"></a></span>
 <span id="cb9-119"><a href="#cb9-119" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb9-120"><a href="#cb9-120" aria-hidden="true" tabindex="-1"></a>    <span class="st">&quot;cvxpy&quot;</span>: <span class="st">&quot;&quot;&quot;</span></span>
-<span id="cb9-121"><a href="#cb9-121" aria-hidden="true" tabindex="-1"></a><span class="st">        import cvxpy as cp</span></span>
-<span id="cb9-122"><a href="#cb9-122" aria-hidden="true" tabindex="-1"></a><span class="st">        t0 = time.perf_counter()</span></span>
-<span id="cb9-123"><a href="#cb9-123" aria-hidden="true" tabindex="-1"></a><span class="st">        x = cp.Variable((M, N), nonneg=True)</span></span>
-<span id="cb9-124"><a href="#cb9-124" aria-hidden="true" tabindex="-1"></a><span class="st">        problem = cp.Problem(cp.Minimize(cp.sum(cp.multiply(kosten, x))),</span></span>
-<span id="cb9-125"><a href="#cb9-125" aria-hidden="true" tabindex="-1"></a><span class="st">                             [cp.sum(x, axis=1) &lt;= angebot,</span></span>
-<span id="cb9-126"><a href="#cb9-126" aria-hidden="true" tabindex="-1"></a><span class="st">                              cp.sum(x, axis=0) == bedarf])</span></span>
-<span id="cb9-127"><a href="#cb9-127" aria-hidden="true" tabindex="-1"></a><span class="st">        aufbau = time.perf_counter() - t0</span></span>
-<span id="cb9-128"><a href="#cb9-128" aria-hidden="true" tabindex="-1"></a><span class="st">        t0 = time.perf_counter(); problem.solve(); loesen = time.perf_counter() - t0</span></span>
-<span id="cb9-129"><a href="#cb9-129" aria-hidden="true" tabindex="-1"></a><span class="st">        ausgabe = (float(problem.value), aufbau, loesen, speicher_mb())</span></span>
-<span id="cb9-130"><a href="#cb9-130" aria-hidden="true" tabindex="-1"></a><span class="st">    &quot;&quot;&quot;</span>,</span>
-<span id="cb9-131"><a href="#cb9-131" aria-hidden="true" tabindex="-1"></a>}</span>
+<span id="cb9-120"><a href="#cb9-120" aria-hidden="true" tabindex="-1"></a><span class="kw">def</span> messe_cvxpy(m: <span class="bu">int</span>, n: <span class="bu">int</span>):</span>
+<span id="cb9-121"><a href="#cb9-121" aria-hidden="true" tabindex="-1"></a>    <span class="im">import</span> cvxpy <span class="im">as</span> cp</span>
+<span id="cb9-122"><a href="#cb9-122" aria-hidden="true" tabindex="-1"></a>    kosten, angebot, bedarf <span class="op">=</span> instanz(m, n)</span>
+<span id="cb9-123"><a href="#cb9-123" aria-hidden="true" tabindex="-1"></a>    t0 <span class="op">=</span> time.perf_counter()</span>
+<span id="cb9-124"><a href="#cb9-124" aria-hidden="true" tabindex="-1"></a>    x <span class="op">=</span> cp.Variable((m, n), nonneg<span class="op">=</span><span class="va">True</span>)</span>
+<span id="cb9-125"><a href="#cb9-125" aria-hidden="true" tabindex="-1"></a>    problem <span class="op">=</span> cp.Problem(cp.Minimize(cp.<span class="bu">sum</span>(cp.multiply(kosten, x))),</span>
+<span id="cb9-126"><a href="#cb9-126" aria-hidden="true" tabindex="-1"></a>                         [cp.<span class="bu">sum</span>(x, axis<span class="op">=</span><span class="dv">1</span>) <span class="op">&lt;=</span> angebot,</span>
+<span id="cb9-127"><a href="#cb9-127" aria-hidden="true" tabindex="-1"></a>                          cp.<span class="bu">sum</span>(x, axis<span class="op">=</span><span class="dv">0</span>) <span class="op">==</span> bedarf])</span>
+<span id="cb9-128"><a href="#cb9-128" aria-hidden="true" tabindex="-1"></a>    aufbau <span class="op">=</span> time.perf_counter() <span class="op">-</span> t0</span>
+<span id="cb9-129"><a href="#cb9-129" aria-hidden="true" tabindex="-1"></a>    t0 <span class="op">=</span> time.perf_counter()<span class="op">;</span> problem.solve()<span class="op">;</span> loesen <span class="op">=</span> time.perf_counter() <span class="op">-</span> t0</span>
+<span id="cb9-130"><a href="#cb9-130" aria-hidden="true" tabindex="-1"></a>    <span class="cf">return</span> <span class="bu">float</span>(problem.value), aufbau, loesen, speicher_mb()</span>
+<span id="cb9-131"><a href="#cb9-131" aria-hidden="true" tabindex="-1"></a></span>
 <span id="cb9-132"><a href="#cb9-132" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb9-133"><a href="#cb9-133" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb9-134"><a href="#cb9-134" aria-hidden="true" tabindex="-1"></a><span class="kw">def</span> messe(name: <span class="bu">str</span>, quelltext: <span class="bu">str</span>, m: <span class="bu">int</span>, n: <span class="bu">int</span>):</span>
-<span id="cb9-135"><a href="#cb9-135" aria-hidden="true" tabindex="-1"></a>    <span class="co">&quot;&quot;&quot;Fuehrt einen Ansatz in einem eigenen Prozess aus.&quot;&quot;&quot;</span></span>
-<span id="cb9-136"><a href="#cb9-136" aria-hidden="true" tabindex="-1"></a>    programm <span class="op">=</span> (VORSPANN.<span class="bu">format</span>(m<span class="op">=</span>m, n<span class="op">=</span>n) <span class="op">+</span> textwrap.dedent(quelltext)</span>
-<span id="cb9-137"><a href="#cb9-137" aria-hidden="true" tabindex="-1"></a>                <span class="op">+</span> <span class="st">&quot;</span><span class="ch">\n</span><span class="st">print(json.dumps(ausgabe))</span><span class="ch">\n</span><span class="st">&quot;</span>)</span>
-<span id="cb9-138"><a href="#cb9-138" aria-hidden="true" tabindex="-1"></a>    ergebnis <span class="op">=</span> subprocess.run([sys.executable, <span class="st">&quot;-c&quot;</span>, programm],</span>
-<span id="cb9-139"><a href="#cb9-139" aria-hidden="true" tabindex="-1"></a>                              capture_output<span class="op">=</span><span class="va">True</span>, text<span class="op">=</span><span class="va">True</span>, timeout<span class="op">=</span><span class="dv">600</span>)</span>
-<span id="cb9-140"><a href="#cb9-140" aria-hidden="true" tabindex="-1"></a>    <span class="cf">if</span> ergebnis.returncode <span class="op">!=</span> <span class="dv">0</span>:</span>
-<span id="cb9-141"><a href="#cb9-141" aria-hidden="true" tabindex="-1"></a>        <span class="cf">return</span> <span class="va">None</span>, ergebnis.stderr.strip().splitlines()[<span class="op">-</span><span class="dv">1</span>][:<span class="dv">60</span>]</span>
-<span id="cb9-142"><a href="#cb9-142" aria-hidden="true" tabindex="-1"></a>    <span class="cf">return</span> json.loads(ergebnis.stdout.strip().splitlines()[<span class="op">-</span><span class="dv">1</span>]), <span class="va">None</span></span>
-<span id="cb9-143"><a href="#cb9-143" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb9-144"><a href="#cb9-144" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb9-145"><a href="#cb9-145" aria-hidden="true" tabindex="-1"></a><span class="cf">if</span> <span class="va">__name__</span> <span class="op">==</span> <span class="st">&quot;__main__&quot;</span>:</span>
-<span id="cb9-146"><a href="#cb9-146" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;=&quot;</span> <span class="op">*</span> <span class="dv">92</span>)</span>
-<span id="cb9-147"><a href="#cb9-147" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;  SKALIERUNGSVERGLEICH: TRANSPORTPROBLEM, VIER BIBLIOTHEKEN&quot;</span>)</span>
-<span id="cb9-148"><a href="#cb9-148" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;=&quot;</span> <span class="op">*</span> <span class="dv">92</span>)</span>
-<span id="cb9-149"><a href="#cb9-149" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;Jede Zeile ein eigener Prozess. Zeiten und Speicher sind &quot;</span></span>
-<span id="cb9-150"><a href="#cb9-150" aria-hidden="true" tabindex="-1"></a>          <span class="st">&quot;hardwareabhaengig,&quot;</span>)</span>
-<span id="cb9-151"><a href="#cb9-151" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;die Zielwerte und ihr Verhaeltnis zueinander nicht.</span><span class="ch">\n</span><span class="st">&quot;</span>)</span>
-<span id="cb9-152"><a href="#cb9-152" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb9-153"><a href="#cb9-153" aria-hidden="true" tabindex="-1"></a>    <span class="cf">for</span> m, n <span class="kw">in</span> GROESSEN:</span>
-<span id="cb9-154"><a href="#cb9-154" aria-hidden="true" tabindex="-1"></a>        kopf <span class="op">=</span> <span class="ss">f&quot;--- </span><span class="sc">{</span>m<span class="sc">}</span><span class="ss"> Lager x </span><span class="sc">{</span>n<span class="sc">}</span><span class="ss"> Kunden = </span><span class="sc">{</span>m <span class="op">*</span> n<span class="sc">:,}</span><span class="ss"> Variablen &quot;</span></span>
-<span id="cb9-155"><a href="#cb9-155" aria-hidden="true" tabindex="-1"></a>        <span class="bu">print</span>(kopf <span class="op">+</span> <span class="st">&quot;-&quot;</span> <span class="op">*</span> <span class="bu">max</span>(<span class="dv">3</span>, <span class="dv">92</span> <span class="op">-</span> <span class="bu">len</span>(kopf)))</span>
-<span id="cb9-156"><a href="#cb9-156" aria-hidden="true" tabindex="-1"></a>        <span class="bu">print</span>(<span class="ss">f&quot;  </span><span class="sc">{</span><span class="st">&#39;Bibliothek&#39;</span><span class="sc">:&lt;16}</span><span class="ss"> </span><span class="sc">{</span><span class="st">&#39;Zielwert&#39;</span><span class="sc">:&gt;14}</span><span class="ss"> </span><span class="sc">{</span><span class="st">&#39;Aufbau&#39;</span><span class="sc">:&gt;9}</span><span class="ss"> &quot;</span></span>
-<span id="cb9-157"><a href="#cb9-157" aria-hidden="true" tabindex="-1"></a>              <span class="ss">f&quot;</span><span class="sc">{</span><span class="st">&#39;Loesen&#39;</span><span class="sc">:&gt;9}</span><span class="ss"> </span><span class="sc">{</span><span class="st">&#39;Anteil&#39;</span><span class="sc">:&gt;8}</span><span class="ss"> </span><span class="sc">{</span><span class="st">&#39;Speicher&#39;</span><span class="sc">:&gt;10}</span><span class="ss">&quot;</span>)</span>
-<span id="cb9-158"><a href="#cb9-158" aria-hidden="true" tabindex="-1"></a>        <span class="bu">print</span>(<span class="st">&quot;  &quot;</span> <span class="op">+</span> <span class="st">&quot;-&quot;</span> <span class="op">*</span> <span class="dv">72</span>)</span>
-<span id="cb9-159"><a href="#cb9-159" aria-hidden="true" tabindex="-1"></a>        zielwerte <span class="op">=</span> {}</span>
-<span id="cb9-160"><a href="#cb9-160" aria-hidden="true" tabindex="-1"></a>        <span class="cf">for</span> name, quelltext <span class="kw">in</span> ANSAETZE.items():</span>
-<span id="cb9-161"><a href="#cb9-161" aria-hidden="true" tabindex="-1"></a>            werte, fehler <span class="op">=</span> messe(name, quelltext, m, n)</span>
-<span id="cb9-162"><a href="#cb9-162" aria-hidden="true" tabindex="-1"></a>            <span class="cf">if</span> werte <span class="kw">is</span> <span class="va">None</span>:</span>
-<span id="cb9-163"><a href="#cb9-163" aria-hidden="true" tabindex="-1"></a>                <span class="bu">print</span>(<span class="ss">f&quot;  </span><span class="sc">{</span>name<span class="sc">:&lt;16}</span><span class="ss"> nicht verfuegbar: </span><span class="sc">{</span>fehler<span class="sc">}</span><span class="ss">&quot;</span>)</span>
-<span id="cb9-164"><a href="#cb9-164" aria-hidden="true" tabindex="-1"></a>                <span class="cf">continue</span></span>
-<span id="cb9-165"><a href="#cb9-165" aria-hidden="true" tabindex="-1"></a>            ziel, aufbau, loesen, speicher <span class="op">=</span> werte</span>
-<span id="cb9-166"><a href="#cb9-166" aria-hidden="true" tabindex="-1"></a>            zielwerte[name] <span class="op">=</span> ziel</span>
-<span id="cb9-167"><a href="#cb9-167" aria-hidden="true" tabindex="-1"></a>            anteil <span class="op">=</span> aufbau <span class="op">/</span> (aufbau <span class="op">+</span> loesen) <span class="op">*</span> <span class="dv">100</span></span>
-<span id="cb9-168"><a href="#cb9-168" aria-hidden="true" tabindex="-1"></a>            <span class="bu">print</span>(<span class="ss">f&quot;  </span><span class="sc">{</span>name<span class="sc">:&lt;16}</span><span class="ss"> </span><span class="sc">{</span>ziel<span class="sc">:&gt;14,.2f}</span><span class="ss"> </span><span class="sc">{</span>aufbau<span class="sc">:&gt;8.3f}</span><span class="ss">s &quot;</span></span>
-<span id="cb9-169"><a href="#cb9-169" aria-hidden="true" tabindex="-1"></a>                  <span class="ss">f&quot;</span><span class="sc">{</span>loesen<span class="sc">:&gt;8.3f}</span><span class="ss">s </span><span class="sc">{</span>anteil<span class="sc">:&gt;7.0f}</span><span class="ss">% </span><span class="sc">{</span>speicher<span class="sc">:&gt;9.0f}</span><span class="ss"> MB&quot;</span>)</span>
-<span id="cb9-170"><a href="#cb9-170" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb9-171"><a href="#cb9-171" aria-hidden="true" tabindex="-1"></a>        <span class="co"># Die wichtigste Zeile: Rechnen alle dasselbe aus?</span></span>
-<span id="cb9-172"><a href="#cb9-172" aria-hidden="true" tabindex="-1"></a>        spanne <span class="op">=</span> <span class="bu">max</span>(zielwerte.values()) <span class="op">-</span> <span class="bu">min</span>(zielwerte.values())</span>
-<span id="cb9-173"><a href="#cb9-173" aria-hidden="true" tabindex="-1"></a>        bezug <span class="op">=</span> <span class="bu">max</span>(<span class="bu">abs</span>(v) <span class="cf">for</span> v <span class="kw">in</span> zielwerte.values())</span>
-<span id="cb9-174"><a href="#cb9-174" aria-hidden="true" tabindex="-1"></a>        <span class="bu">print</span>(<span class="ss">f&quot;  </span><span class="sc">{</span><span class="st">&#39;&#39;</span><span class="sc">:16}</span><span class="ss"> Spannweite der Zielwerte: </span><span class="sc">{</span>spanne<span class="sc">:.2e}</span><span class="ss"> &quot;</span></span>
-<span id="cb9-175"><a href="#cb9-175" aria-hidden="true" tabindex="-1"></a>              <span class="ss">f&quot;(relativ </span><span class="sc">{</span>spanne <span class="op">/</span> bezug<span class="sc">:.1e}</span><span class="ss">)&quot;</span>)</span>
-<span id="cb9-176"><a href="#cb9-176" aria-hidden="true" tabindex="-1"></a>        <span class="cf">if</span> spanne <span class="op">/</span> bezug <span class="op">&gt;</span> <span class="fl">1e-6</span>:</span>
-<span id="cb9-177"><a href="#cb9-177" aria-hidden="true" tabindex="-1"></a>            <span class="bu">print</span>(<span class="st">&quot;  ACHTUNG: Die Bibliotheken widersprechen sich - &quot;</span></span>
-<span id="cb9-178"><a href="#cb9-178" aria-hidden="true" tabindex="-1"></a>                  <span class="st">&quot;der Zeitvergleich ist wertlos.&quot;</span>)</span>
-<span id="cb9-179"><a href="#cb9-179" aria-hidden="true" tabindex="-1"></a>        <span class="bu">print</span>()</span>
-<span id="cb9-180"><a href="#cb9-180" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb9-181"><a href="#cb9-181" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;=&quot;</span> <span class="op">*</span> <span class="dv">92</span>)</span>
-<span id="cb9-182"><a href="#cb9-182" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;  WAS MAN AUS SO EINER TABELLE ABLESEN DARF - UND WAS NICHT&quot;</span>)</span>
-<span id="cb9-183"><a href="#cb9-183" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;=&quot;</span> <span class="op">*</span> <span class="dv">92</span>)</span>
-<span id="cb9-184"><a href="#cb9-184" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;DARF man ablesen:&quot;</span>)</span>
-<span id="cb9-185"><a href="#cb9-185" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;  * Die Spalte &#39;Anteil&#39; - wie viel der Zeit in den AUFBAU geht statt&quot;</span>)</span>
-<span id="cb9-186"><a href="#cb9-186" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;    ins Loesen. Wenn dort 80 </span><span class="sc">% s</span><span class="st">tehen, ist ein schnellerer Solver die&quot;</span>)</span>
-<span id="cb9-187"><a href="#cb9-187" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;    falsche Antwort; dann gehoert das Modell vektorisiert aufgebaut&quot;</span>)</span>
-<span id="cb9-188"><a href="#cb9-188" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;    (Kapitel Oekosystem).&quot;</span>)</span>
-<span id="cb9-189"><a href="#cb9-189" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;  * Die Groessenordnung des Speicherbedarfs. Sie entscheidet, was auf&quot;</span>)</span>
-<span id="cb9-190"><a href="#cb9-190" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;    einer bestimmten Maschine ueberhaupt laeuft.&quot;</span>)</span>
-<span id="cb9-191"><a href="#cb9-191" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;  * Wie sich beides mit der Groesse ENTWICKELT. Der Trend ist&quot;</span>)</span>
-<span id="cb9-192"><a href="#cb9-192" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;    uebertragbarer als der Absolutwert.&quot;</span>)</span>
-<span id="cb9-193"><a href="#cb9-193" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>()</span>
-<span id="cb9-194"><a href="#cb9-194" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;NICHT ablesen darf man:&quot;</span>)</span>
-<span id="cb9-195"><a href="#cb9-195" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;  * &#39;Bibliothek X ist schneller als Y.&#39; Gemessen wurde EIN&quot;</span>)</span>
-<span id="cb9-196"><a href="#cb9-196" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;    Problemtyp in EINER Formulierung. Ein MILP, ein QP oder eine&quot;</span>)</span>
-<span id="cb9-197"><a href="#cb9-197" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;    andere Modellierung desselben Problems koennen die Reihenfolge&quot;</span>)</span>
-<span id="cb9-198"><a href="#cb9-198" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;    umdrehen.&quot;</span>)</span>
-<span id="cb9-199"><a href="#cb9-199" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;  * Etwas ueber Ihre Maschine. Diese Zahlen stammen von einer&quot;</span>)</span>
-<span id="cb9-200"><a href="#cb9-200" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;    anderen. Der Sinn des Programms ist, dass Sie es auf Ihrer&quot;</span>)</span>
-<span id="cb9-201"><a href="#cb9-201" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;    laufen lassen.&quot;</span>)</span>
-<span id="cb9-202"><a href="#cb9-202" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;=&quot;</span> <span class="op">*</span> <span class="dv">92</span>)</span></code></pre></div>
+<span id="cb9-133"><a href="#cb9-133" aria-hidden="true" tabindex="-1"></a>ANSAETZE <span class="op">=</span> {<span class="st">&quot;scipy.linprog&quot;</span>: messe_scipy, <span class="st">&quot;highspy&quot;</span>: messe_highspy,</span>
+<span id="cb9-134"><a href="#cb9-134" aria-hidden="true" tabindex="-1"></a>            <span class="st">&quot;ortools/GLOP&quot;</span>: messe_ortools, <span class="st">&quot;cvxpy&quot;</span>: messe_cvxpy}</span>
+<span id="cb9-135"><a href="#cb9-135" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb9-136"><a href="#cb9-136" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb9-137"><a href="#cb9-137" aria-hidden="true" tabindex="-1"></a><span class="kw">def</span> messe(funktion, m: <span class="bu">int</span>, n: <span class="bu">int</span>):</span>
+<span id="cb9-138"><a href="#cb9-138" aria-hidden="true" tabindex="-1"></a>    <span class="co">&quot;&quot;&quot;Fuehrt eine Messfunktion in einem FRISCHEN Prozess aus.</span></span>
+<span id="cb9-139"><a href="#cb9-139" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb9-140"><a href="#cb9-140" aria-hidden="true" tabindex="-1"></a><span class="co">    &#39;spawn&#39; und max_tasks_per_child=1 zusammen garantieren, was Regel 1</span></span>
+<span id="cb9-141"><a href="#cb9-141" aria-hidden="true" tabindex="-1"></a><span class="co">    verlangt: Jede Messung sieht einen leeren Interpreter. Ohne das</span></span>
+<span id="cb9-142"><a href="#cb9-142" aria-hidden="true" tabindex="-1"></a><span class="co">    zweite wuerde der Pool seinen Arbeiter wiederverwenden - dann waere</span></span>
+<span id="cb9-143"><a href="#cb9-143" aria-hidden="true" tabindex="-1"></a><span class="co">    der Speicherwert der zweiten Bibliothek um die erste zu hoch, und</span></span>
+<span id="cb9-144"><a href="#cb9-144" aria-hidden="true" tabindex="-1"></a><span class="co">    ortools und highspy saessen im selben Prozess.</span></span>
+<span id="cb9-145"><a href="#cb9-145" aria-hidden="true" tabindex="-1"></a><span class="co">    &quot;&quot;&quot;</span></span>
+<span id="cb9-146"><a href="#cb9-146" aria-hidden="true" tabindex="-1"></a>    <span class="cf">with</span> ProcessPoolExecutor(</span>
+<span id="cb9-147"><a href="#cb9-147" aria-hidden="true" tabindex="-1"></a>            max_workers<span class="op">=</span><span class="dv">1</span>,</span>
+<span id="cb9-148"><a href="#cb9-148" aria-hidden="true" tabindex="-1"></a>            mp_context<span class="op">=</span>multiprocessing.get_context(<span class="st">&quot;spawn&quot;</span>),</span>
+<span id="cb9-149"><a href="#cb9-149" aria-hidden="true" tabindex="-1"></a>            max_tasks_per_child<span class="op">=</span><span class="dv">1</span>) <span class="im">as</span> pool:</span>
+<span id="cb9-150"><a href="#cb9-150" aria-hidden="true" tabindex="-1"></a>        <span class="cf">try</span>:</span>
+<span id="cb9-151"><a href="#cb9-151" aria-hidden="true" tabindex="-1"></a>            <span class="cf">return</span> pool.submit(funktion, m, n).result(timeout<span class="op">=</span><span class="dv">600</span>), <span class="va">None</span></span>
+<span id="cb9-152"><a href="#cb9-152" aria-hidden="true" tabindex="-1"></a>        <span class="cf">except</span> <span class="pp">Exception</span> <span class="im">as</span> fehler:</span>
+<span id="cb9-153"><a href="#cb9-153" aria-hidden="true" tabindex="-1"></a>            <span class="cf">return</span> <span class="va">None</span>, <span class="bu">str</span>(fehler).strip().splitlines()[<span class="op">-</span><span class="dv">1</span>][:<span class="dv">60</span>]</span>
+<span id="cb9-154"><a href="#cb9-154" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb9-155"><a href="#cb9-155" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb9-156"><a href="#cb9-156" aria-hidden="true" tabindex="-1"></a><span class="cf">if</span> <span class="va">__name__</span> <span class="op">==</span> <span class="st">&quot;__main__&quot;</span>:</span>
+<span id="cb9-157"><a href="#cb9-157" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;=&quot;</span> <span class="op">*</span> <span class="dv">92</span>)</span>
+<span id="cb9-158"><a href="#cb9-158" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;  SKALIERUNGSVERGLEICH: TRANSPORTPROBLEM, VIER BIBLIOTHEKEN&quot;</span>)</span>
+<span id="cb9-159"><a href="#cb9-159" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;=&quot;</span> <span class="op">*</span> <span class="dv">92</span>)</span>
+<span id="cb9-160"><a href="#cb9-160" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;Jede Zeile ein eigener Prozess. Zeiten und Speicher sind &quot;</span></span>
+<span id="cb9-161"><a href="#cb9-161" aria-hidden="true" tabindex="-1"></a>          <span class="st">&quot;hardwareabhaengig,&quot;</span>)</span>
+<span id="cb9-162"><a href="#cb9-162" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;die Zielwerte und ihr Verhaeltnis zueinander nicht.</span><span class="ch">\n</span><span class="st">&quot;</span>)</span>
+<span id="cb9-163"><a href="#cb9-163" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb9-164"><a href="#cb9-164" aria-hidden="true" tabindex="-1"></a>    <span class="cf">for</span> m, n <span class="kw">in</span> GROESSEN:</span>
+<span id="cb9-165"><a href="#cb9-165" aria-hidden="true" tabindex="-1"></a>        kopf <span class="op">=</span> <span class="ss">f&quot;--- </span><span class="sc">{</span>m<span class="sc">}</span><span class="ss"> Lager x </span><span class="sc">{</span>n<span class="sc">}</span><span class="ss"> Kunden = </span><span class="sc">{</span>m <span class="op">*</span> n<span class="sc">:,}</span><span class="ss"> Variablen &quot;</span></span>
+<span id="cb9-166"><a href="#cb9-166" aria-hidden="true" tabindex="-1"></a>        <span class="bu">print</span>(kopf <span class="op">+</span> <span class="st">&quot;-&quot;</span> <span class="op">*</span> <span class="bu">max</span>(<span class="dv">3</span>, <span class="dv">92</span> <span class="op">-</span> <span class="bu">len</span>(kopf)))</span>
+<span id="cb9-167"><a href="#cb9-167" aria-hidden="true" tabindex="-1"></a>        <span class="bu">print</span>(<span class="ss">f&quot;  </span><span class="sc">{</span><span class="st">&#39;Bibliothek&#39;</span><span class="sc">:&lt;16}</span><span class="ss"> </span><span class="sc">{</span><span class="st">&#39;Zielwert&#39;</span><span class="sc">:&gt;14}</span><span class="ss"> </span><span class="sc">{</span><span class="st">&#39;Aufbau&#39;</span><span class="sc">:&gt;9}</span><span class="ss"> &quot;</span></span>
+<span id="cb9-168"><a href="#cb9-168" aria-hidden="true" tabindex="-1"></a>              <span class="ss">f&quot;</span><span class="sc">{</span><span class="st">&#39;Loesen&#39;</span><span class="sc">:&gt;9}</span><span class="ss"> </span><span class="sc">{</span><span class="st">&#39;Anteil&#39;</span><span class="sc">:&gt;8}</span><span class="ss"> </span><span class="sc">{</span><span class="st">&#39;Speicher&#39;</span><span class="sc">:&gt;10}</span><span class="ss">&quot;</span>)</span>
+<span id="cb9-169"><a href="#cb9-169" aria-hidden="true" tabindex="-1"></a>        <span class="bu">print</span>(<span class="st">&quot;  &quot;</span> <span class="op">+</span> <span class="st">&quot;-&quot;</span> <span class="op">*</span> <span class="dv">72</span>)</span>
+<span id="cb9-170"><a href="#cb9-170" aria-hidden="true" tabindex="-1"></a>        zielwerte <span class="op">=</span> {}</span>
+<span id="cb9-171"><a href="#cb9-171" aria-hidden="true" tabindex="-1"></a>        <span class="cf">for</span> name, funktion <span class="kw">in</span> ANSAETZE.items():</span>
+<span id="cb9-172"><a href="#cb9-172" aria-hidden="true" tabindex="-1"></a>            werte, fehler <span class="op">=</span> messe(funktion, m, n)</span>
+<span id="cb9-173"><a href="#cb9-173" aria-hidden="true" tabindex="-1"></a>            <span class="cf">if</span> werte <span class="kw">is</span> <span class="va">None</span>:</span>
+<span id="cb9-174"><a href="#cb9-174" aria-hidden="true" tabindex="-1"></a>                <span class="bu">print</span>(<span class="ss">f&quot;  </span><span class="sc">{</span>name<span class="sc">:&lt;16}</span><span class="ss"> nicht verfuegbar: </span><span class="sc">{</span>fehler<span class="sc">}</span><span class="ss">&quot;</span>)</span>
+<span id="cb9-175"><a href="#cb9-175" aria-hidden="true" tabindex="-1"></a>                <span class="cf">continue</span></span>
+<span id="cb9-176"><a href="#cb9-176" aria-hidden="true" tabindex="-1"></a>            ziel, aufbau, loesen, speicher <span class="op">=</span> werte</span>
+<span id="cb9-177"><a href="#cb9-177" aria-hidden="true" tabindex="-1"></a>            zielwerte[name] <span class="op">=</span> ziel</span>
+<span id="cb9-178"><a href="#cb9-178" aria-hidden="true" tabindex="-1"></a>            anteil <span class="op">=</span> aufbau <span class="op">/</span> (aufbau <span class="op">+</span> loesen) <span class="op">*</span> <span class="dv">100</span></span>
+<span id="cb9-179"><a href="#cb9-179" aria-hidden="true" tabindex="-1"></a>            <span class="bu">print</span>(<span class="ss">f&quot;  </span><span class="sc">{</span>name<span class="sc">:&lt;16}</span><span class="ss"> </span><span class="sc">{</span>ziel<span class="sc">:&gt;14,.2f}</span><span class="ss"> </span><span class="sc">{</span>aufbau<span class="sc">:&gt;8.3f}</span><span class="ss">s &quot;</span></span>
+<span id="cb9-180"><a href="#cb9-180" aria-hidden="true" tabindex="-1"></a>                  <span class="ss">f&quot;</span><span class="sc">{</span>loesen<span class="sc">:&gt;8.3f}</span><span class="ss">s </span><span class="sc">{</span>anteil<span class="sc">:&gt;7.0f}</span><span class="ss">% </span><span class="sc">{</span>speicher<span class="sc">:&gt;9.0f}</span><span class="ss"> MB&quot;</span>)</span>
+<span id="cb9-181"><a href="#cb9-181" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb9-182"><a href="#cb9-182" aria-hidden="true" tabindex="-1"></a>        <span class="co"># Die wichtigste Zeile: Rechnen alle dasselbe aus?</span></span>
+<span id="cb9-183"><a href="#cb9-183" aria-hidden="true" tabindex="-1"></a>        spanne <span class="op">=</span> <span class="bu">max</span>(zielwerte.values()) <span class="op">-</span> <span class="bu">min</span>(zielwerte.values())</span>
+<span id="cb9-184"><a href="#cb9-184" aria-hidden="true" tabindex="-1"></a>        bezug <span class="op">=</span> <span class="bu">max</span>(<span class="bu">abs</span>(v) <span class="cf">for</span> v <span class="kw">in</span> zielwerte.values())</span>
+<span id="cb9-185"><a href="#cb9-185" aria-hidden="true" tabindex="-1"></a>        <span class="bu">print</span>(<span class="ss">f&quot;  </span><span class="sc">{</span><span class="st">&#39;&#39;</span><span class="sc">:16}</span><span class="ss"> Spannweite der Zielwerte: </span><span class="sc">{</span>spanne<span class="sc">:.2e}</span><span class="ss"> &quot;</span></span>
+<span id="cb9-186"><a href="#cb9-186" aria-hidden="true" tabindex="-1"></a>              <span class="ss">f&quot;(relativ </span><span class="sc">{</span>spanne <span class="op">/</span> bezug<span class="sc">:.1e}</span><span class="ss">)&quot;</span>)</span>
+<span id="cb9-187"><a href="#cb9-187" aria-hidden="true" tabindex="-1"></a>        <span class="cf">if</span> spanne <span class="op">/</span> bezug <span class="op">&gt;</span> <span class="fl">1e-6</span>:</span>
+<span id="cb9-188"><a href="#cb9-188" aria-hidden="true" tabindex="-1"></a>            <span class="bu">print</span>(<span class="st">&quot;  ACHTUNG: Die Bibliotheken widersprechen sich - &quot;</span></span>
+<span id="cb9-189"><a href="#cb9-189" aria-hidden="true" tabindex="-1"></a>                  <span class="st">&quot;der Zeitvergleich ist wertlos.&quot;</span>)</span>
+<span id="cb9-190"><a href="#cb9-190" aria-hidden="true" tabindex="-1"></a>        <span class="bu">print</span>()</span>
+<span id="cb9-191"><a href="#cb9-191" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb9-192"><a href="#cb9-192" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;=&quot;</span> <span class="op">*</span> <span class="dv">92</span>)</span>
+<span id="cb9-193"><a href="#cb9-193" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;  WAS MAN AUS SO EINER TABELLE ABLESEN DARF - UND WAS NICHT&quot;</span>)</span>
+<span id="cb9-194"><a href="#cb9-194" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;=&quot;</span> <span class="op">*</span> <span class="dv">92</span>)</span>
+<span id="cb9-195"><a href="#cb9-195" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;DARF man ablesen:&quot;</span>)</span>
+<span id="cb9-196"><a href="#cb9-196" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;  * Die Spalte &#39;Anteil&#39; - wie viel der Zeit in den AUFBAU geht statt&quot;</span>)</span>
+<span id="cb9-197"><a href="#cb9-197" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;    ins Loesen. Wenn dort 80 </span><span class="sc">% s</span><span class="st">tehen, ist ein schnellerer Solver die&quot;</span>)</span>
+<span id="cb9-198"><a href="#cb9-198" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;    falsche Antwort; dann gehoert das Modell vektorisiert aufgebaut&quot;</span>)</span>
+<span id="cb9-199"><a href="#cb9-199" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;    (Kapitel Oekosystem).&quot;</span>)</span>
+<span id="cb9-200"><a href="#cb9-200" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;  * Die Groessenordnung des Speicherbedarfs. Sie entscheidet, was auf&quot;</span>)</span>
+<span id="cb9-201"><a href="#cb9-201" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;    einer bestimmten Maschine ueberhaupt laeuft.&quot;</span>)</span>
+<span id="cb9-202"><a href="#cb9-202" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;  * Wie sich beides mit der Groesse ENTWICKELT. Der Trend ist&quot;</span>)</span>
+<span id="cb9-203"><a href="#cb9-203" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;    uebertragbarer als der Absolutwert.&quot;</span>)</span>
+<span id="cb9-204"><a href="#cb9-204" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>()</span>
+<span id="cb9-205"><a href="#cb9-205" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;NICHT ablesen darf man:&quot;</span>)</span>
+<span id="cb9-206"><a href="#cb9-206" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;  * &#39;Bibliothek X ist schneller als Y.&#39; Gemessen wurde EIN&quot;</span>)</span>
+<span id="cb9-207"><a href="#cb9-207" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;    Problemtyp in EINER Formulierung. Ein MILP, ein QP oder eine&quot;</span>)</span>
+<span id="cb9-208"><a href="#cb9-208" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;    andere Modellierung desselben Problems koennen die Reihenfolge&quot;</span>)</span>
+<span id="cb9-209"><a href="#cb9-209" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;    umdrehen.&quot;</span>)</span>
+<span id="cb9-210"><a href="#cb9-210" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;  * Etwas ueber Ihre Maschine. Diese Zahlen stammen von einer&quot;</span>)</span>
+<span id="cb9-211"><a href="#cb9-211" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;    anderen. Der Sinn des Programms ist, dass Sie es auf Ihrer&quot;</span>)</span>
+<span id="cb9-212"><a href="#cb9-212" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;    laufen lassen.&quot;</span>)</span>
+<span id="cb9-213"><a href="#cb9-213" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;=&quot;</span> <span class="op">*</span> <span class="dv">92</span>)</span></code></pre></div>
 <p><strong>Erwartete Ausgabe</strong> (Zeiten und Speicher hardwareabhängig, die Zielwerte nicht):</p>
 <pre><code>============================================================================================
   SKALIERUNGSVERGLEICH: TRANSPORTPROBLEM, VIER BIBLIOTHEKEN
@@ -1042,28 +1053,28 @@ die Zielwerte und ihr Verhaeltnis zueinander nicht.
 --- 10 Lager x 10 Kunden = 100 Variablen ---------------------------------------------------
   Bibliothek             Zielwert    Aufbau    Loesen   Anteil   Speicher
   ------------------------------------------------------------------------
-  scipy.linprog         13,509.48    0.000s    0.004s       1%        78 MB
-  highspy               13,509.48    0.001s    0.002s      34%        41 MB
-  ortools/GLOP          13,509.48    0.002s    0.001s      80%        54 MB
+  scipy.linprog         13,509.48    0.000s    0.004s       1%        79 MB
+  highspy               13,509.48    0.001s    0.002s      36%        44 MB
+  ortools/GLOP          13,509.48    0.003s    0.001s      80%        56 MB
   cvxpy                 13,509.48    0.001s    0.009s       9%       229 MB
                    Spannweite der Zielwerte: 1.33e-06 (relativ 9.8e-11)
 
 --- 32 Lager x 32 Kunden = 1,024 Variablen -------------------------------------------------
   Bibliothek             Zielwert    Aufbau    Loesen   Anteil   Speicher
   ------------------------------------------------------------------------
-  scipy.linprog         35,744.25    0.000s    0.009s       4%        80 MB
-  highspy               35,744.25    0.004s    0.005s      47%        42 MB
-  ortools/GLOP          35,744.25    0.015s    0.002s      85%        55 MB
-  cvxpy                 35,744.25    0.001s    0.016s       5%       230 MB
+  scipy.linprog         35,744.25    0.000s    0.009s       3%        81 MB
+  highspy               35,744.25    0.004s    0.005s      44%        45 MB
+  ortools/GLOP          35,744.25    0.014s    0.002s      85%        58 MB
+  cvxpy                 35,744.25    0.001s    0.017s       5%       231 MB
                    Spannweite der Zielwerte: 9.54e-05 (relativ 2.7e-09)
 
 --- 100 Lager x 100 Kunden = 10,000 Variablen ----------------------------------------------
   Bibliothek             Zielwert    Aufbau    Loesen   Anteil   Speicher
   ------------------------------------------------------------------------
-  scipy.linprog         72,220.34    0.002s    0.070s       3%       120 MB
-  highspy               72,220.34    0.029s    0.034s      45%        47 MB
-  ortools/GLOP          72,220.34    0.123s    0.036s      77%        66 MB
-  cvxpy                 72,220.34    0.001s    0.103s       1%       242 MB
+  scipy.linprog         72,220.34    0.004s    0.072s       5%       122 MB
+  highspy               72,220.34    0.026s    0.032s      45%        50 MB
+  ortools/GLOP          72,220.34    0.141s    0.043s      77%        68 MB
+  cvxpy                 72,220.34    0.001s    0.108s       1%       242 MB
                    Spannweite der Zielwerte: 3.65e-04 (relativ 5.0e-09)
 
 ============================================================================================
@@ -1551,7 +1562,7 @@ Das zugehoerige Dockerfile ist kurz genug, um es ganz zu zeigen:
 <blockquote>
 <p><strong>💻 Code-Durchgang: drei Entscheidungen</strong></p>
 <p><strong>1. Das Domänenmodell ist das API-Schema.</strong> Der Parameter heißt <code>problem: Produktionsproblem</code> — mehr steht nicht da. FastAPI validiert die Anfrage damit gegen dieselben Pydantic-Regeln wie der Excel-Import aus <a href="einfuehrung.html#kap-einfuehrung">Kapitel 1</a> und antwortet bei Unsinn mit <code>422</code>, <strong>bevor</strong> ein Solver startet. Die drei abgewiesenen Anfragen im Selbsttest sind genau die drei Fälle, die <code>or_kern.py</code> schon beim Einlesen abfängt.</p>
-<p><strong>2. Die Antwort enthält Status und Gap, nicht nur Zahlen.</strong> Ein Aufrufer, der nur die Mengen bekommt, kann nicht unterscheiden, ob er ein bewiesenes Optimum oder einen Zeitlimit-Abbruch in der Hand hält. Das <code>Loesung</code>-Objekt geht deshalb vollständig durch die Schnittstelle — dasselbe DTO, das in <a href="praxisfallen.html#sec:praxisfallen-solverwechsel">Abschnitt 22.6</a> schon eine Prozessgrenze überlebt hat.</p>
+<p><strong>2. Die Antwort enthält Status und Gap, nicht nur Zahlen.</strong> Ein Aufrufer, der nur die Mengen bekommt, kann nicht unterscheiden, ob er ein bewiesenes Optimum oder einen Zeitlimit-Abbruch in der Hand hält. Das <code>Loesung</code>-Objekt geht deshalb vollständig durch die Schnittstelle — dasselbe DTO, das in <a href="praxisfallen.html#sec:praxisfallen-solverwechsel">Abschnitt 22.7</a> schon eine Prozessgrenze überlebt hat.</p>
 <p><strong>3. Die Abnahmeprüfung läuft auch hier.</strong> <code>pruefe_loesung()</code> steht im Arbeiter, nicht nur im Skript. Ein Dienst ohne sie liefert Fehler schneller aus, als ein Mensch sie finden könnte.</p>
 </blockquote>
 <h3 id="threads-oder-prozesse-eine-messung-keine-meinung">Threads oder Prozesse? Eine Messung, keine Meinung</h3>
@@ -1650,7 +1661,7 @@ Das zugehoerige Dockerfile ist kurz genug, um es ganz zu zeigen:
 
     </article>
     <button type="button" class="fortschritt-knopf" data-kapitel="testing.html"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg> <span>Als gelesen markieren</span></button>
-    <nav class="prev-next"><a class="prev-next-knopf prev-next-prev" href="praxisfallen.html"><svg class="icon" aria-hidden="true"><use href="#icon-chevron-left"></use></svg><span><small>Zurück</small>Kapitel 22: Praxisfallen und der Weg zum produktiven Einsatz</span></a><a class="prev-next-knopf prev-next-next" href="projektwerkstatt.html"><span><small>Weiter</small>Projektwerkstatt</span><svg class="icon" aria-hidden="true"><use href="#icon-chevron-right"></use></svg></a></nav>
+    <nav class="prev-next"><a class="prev-next-knopf prev-next-prev" href="praxisfallen.html"><svg class="icon" aria-hidden="true"><use href="#icon-chevron-left"></use></svg><span><small>Zurück</small>Kapitel 22: Praxisfallen und der Weg zum produktiven Einsatz</span></a><a class="prev-next-knopf prev-next-next" href="synthese-praxis.html"><span><small>Weiter</small>Synthese Teil V</span><svg class="icon" aria-hidden="true"><use href="#icon-chevron-right"></use></svg></a></nav>
   </main>
 </div>
 <footer class="site-footer">
diff --git a/OR_HTML_04/unsicherheit.html b/OR_HTML_04/unsicherheit.html
index 74fd808..b57f638 100644
--- a/OR_HTML_04/unsicherheit.html
+++ b/OR_HTML_04/unsicherheit.html
@@ -94,7 +94,7 @@
 </header>
 <div class="site-body">
   <div class="sidebar-overlay" id="sidebar-overlay" hidden></div>
-  <nav class="sidebar" id="sidebar" aria-label="Kapitelnavigation"><div class="sidebar-inhalt"><details class="sidebar-gruppe"><summary>Einstieg</summary><ul><li data-kapitel="vorwort.html"><a href="vorwort.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Vorwort & Lesehilfe</span></a></li><li data-kapitel="notation.html"><a href="notation.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Notation & Abkürzungen</span></a></li></ul></details><details class="sidebar-gruppe"><summary>Teil I: Grundlagen des Operations Research</summary><ul><li data-kapitel="einfuehrung.html"><a href="einfuehrung.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 1: Einführung in Operations Research — Vom Ursprung zur mathematischen Entscheidungsfindung</span></a></li><li data-kapitel="fundament.html"><a href="fundament.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 2: Das mathematische Fundament — Vektoren, Matrizen, Konvexität</span></a></li><li data-kapitel="oekosystem.html"><a href="oekosystem.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 3: Das Python-Ökosystem für OR — Solver, Bindings und Modellierungsschichten</span></a></li><li data-kapitel="modellierung.html"><a href="modellierung.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 4: Vom Management-Wunsch zum Modell</span></a></li></ul></details><details class="sidebar-gruppe"><summary>Teil II: Die Kernverfahren der deterministischen Optimierung</summary><ul><li data-kapitel="lp.html"><a href="lp.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 5: Lineare Programmierung — Simplex, Dualität und Schattenpreise</span></a></li><li data-kapitel="milp.html"><a href="milp.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 6: Gemischt-ganzzahlige Optimierung — Diskrete Entscheidungen und Branch-and-Bound</span></a></li><li data-kapitel="cpsat.html"><a href="cpsat.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 7: Constraint Programming mit CP-SAT — Logik, Scheduling und Zuweisung</span></a></li><li data-kapitel="graphen.html"><a href="graphen.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 8: Graphen, Flüsse und Touren — Min-Cost-Flow, Matching und VRP</span></a></li><li data-kapitel="metaheuristiken.html"><a href="metaheuristiken.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 9: Metaheuristiken — wenn der exakte Solver aussteigt</span></a></li><li data-kapitel="dekomposition.html"><a href="dekomposition.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 10: Spaltengenerierung — das Modell umbauen statt die Lösung raten</span></a></li></ul></details><details class="sidebar-gruppe" open><summary>Teil III: Nichtlinearität, Unsicherheit und mehrperiodige Dynamik</summary><ul><li data-kapitel="qp-nlp.html"><a href="qp-nlp.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 11: Quadratische und nichtlineare Optimierung — KKT, Lagrange, Konvexität</span></a></li><li data-kapitel="unsicherheit.html" class="aktiv"><a href="unsicherheit.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 12: Optimierung unter Unsicherheit — Monte-Carlo, Stochastik, Robustheit</span></a></li><li data-kapitel="dynamische-programmierung.html"><a href="dynamische-programmierung.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 13: Dynamische Programmierung — Die Bellman-Gleichung und Order-Execution</span></a></li><li data-kapitel="mehrziel.html"><a href="mehrziel.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 14: Mehrere Ziele — Pareto-Fronten statt Gewichte</span></a></li><li data-kapitel="prognose.html"><a href="prognose.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 15: Predict-then-Optimize — die bessere Prognose, die schlechtere Entscheidung</span></a></li></ul></details><details class="sidebar-gruppe"><summary>Teil IV: Anwendungen — Energiewirtschaft und Finanzmärkte</summary><ul><li data-kapitel="bruecke.html"><a href="bruecke.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 16: Die Strukturbrücke — dieselbe Mathematik, zwei Welten</span></a></li><li data-kapitel="supplychain.html"><a href="supplychain.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 17: Supply-Chain und Energieeinsatz unter Unsicherheit</span></a></li><li data-kapitel="finanzdaten.html"><a href="finanzdaten.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 18: Finanzdaten-Modellierung — Renditen, Kovarianz und Shrinkage</span></a></li><li data-kapitel="markowitz.html"><a href="markowitz.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 19: Die moderne Portfoliotheorie nach Markowitz</span></a></li><li data-kapitel="cvar.html"><a href="cvar.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 20: Tail-Risiko, CVaR und Transaktionskosten</span></a></li><li data-kapitel="handelsmaschine.html"><a href="handelsmaschine.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 21: Die vollständige quantitative Handelsmaschine</span></a></li></ul></details><details class="sidebar-gruppe"><summary>Teil V: Praxis</summary><ul><li data-kapitel="praxisfallen.html"><a href="praxisfallen.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 22: Praxisfallen und der Weg zum produktiven Einsatz</span></a></li><li data-kapitel="testing.html"><a href="testing.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 23: Testen, Messen, Ausliefern</span></a></li><li data-kapitel="projektwerkstatt.html"><a href="projektwerkstatt.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Projektwerkstatt</span></a></li></ul></details><details class="sidebar-gruppe"><summary>Anhänge</summary><ul><li data-kapitel="anhang-loesungen.html"><a href="anhang-loesungen.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Anhang A: Lösungen zu allen Übungsaufgaben</span></a></li><li data-kapitel="anhang-modellierungsmuster.html"><a href="anhang-modellierungsmuster.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Anhang B: Katalog der Modellierungsmuster</span></a></li><li data-kapitel="anhang-fehlerdiagnose.html"><a href="anhang-fehlerdiagnose.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Anhang C: Fehlerdiagnose-Handbuch</span></a></li><li data-kapitel="anhang-spickzettel.html"><a href="anhang-spickzettel.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Anhang D: Spickzettel der Solver</span></a></li><li data-kapitel="anhang-glossar-literatur.html"><a href="anhang-glossar-literatur.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Anhang E: Glossar und Literatur</span></a></li></ul></details><ul class="sidebar-extra"><li><a href="programme.html"><svg class="icon" aria-hidden="true"><use href="#icon-book"></use></svg> Beispielprogramme</a></li><li><a href="stichwortverzeichnis.html"><svg class="icon" aria-hidden="true"><use href="#icon-search"></use></svg> Stichwortverzeichnis</a></li><li><a href="gesamtdokument.html"><svg class="icon" aria-hidden="true"><use href="#icon-external-link"></use></svg> Gesamtdokument (eine Seite)</a></li><li><a href="Operations_Research_mit_Python_Version_04.pdf" download><svg class="icon" aria-hidden="true"><use href="#icon-download"></use></svg> Download als PDF</a></li></ul></div></nav>
+  <nav class="sidebar" id="sidebar" aria-label="Kapitelnavigation"><div class="sidebar-inhalt"><details class="sidebar-gruppe"><summary>Einstieg</summary><ul><li data-kapitel="vorwort.html"><a href="vorwort.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Vorwort & Lesehilfe</span></a></li><li data-kapitel="notation.html"><a href="notation.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Notation & Abkürzungen</span></a></li></ul></details><details class="sidebar-gruppe"><summary>Teil I: Grundlagen des Operations Research</summary><ul><li data-kapitel="einfuehrung.html"><a href="einfuehrung.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 1: Einführung in Operations Research — Vom Ursprung zur mathematischen Entscheidungsfindung</span></a></li><li data-kapitel="fundament.html"><a href="fundament.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 2: Das mathematische Fundament — Vektoren, Matrizen, Konvexität</span></a></li><li data-kapitel="oekosystem.html"><a href="oekosystem.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 3: Das Python-Ökosystem für OR — Solver, Bindings und Modellierungsschichten</span></a></li><li data-kapitel="modellierung.html"><a href="modellierung.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 4: Vom Management-Wunsch zum Modell</span></a></li><li data-kapitel="synthese-grundlagen.html"><a href="synthese-grundlagen.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Synthese Teil I</span></a></li></ul></details><details class="sidebar-gruppe"><summary>Teil II: Die Kernverfahren der deterministischen Optimierung</summary><ul><li data-kapitel="lp.html"><a href="lp.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 5: Lineare Programmierung — Simplex, Dualität und Schattenpreise</span></a></li><li data-kapitel="milp.html"><a href="milp.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 6: Gemischt-ganzzahlige Optimierung — Diskrete Entscheidungen und Branch-and-Bound</span></a></li><li data-kapitel="cpsat.html"><a href="cpsat.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 7: Constraint Programming mit CP-SAT — Logik, Scheduling und Zuweisung</span></a></li><li data-kapitel="graphen.html"><a href="graphen.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 8: Graphen, Flüsse und Touren — Min-Cost-Flow, Matching und VRP</span></a></li><li data-kapitel="metaheuristiken.html"><a href="metaheuristiken.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 9: Metaheuristiken — wenn der exakte Solver aussteigt</span></a></li><li data-kapitel="dekomposition.html"><a href="dekomposition.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 10: Spaltengenerierung — das Modell umbauen statt die Lösung raten</span></a></li><li data-kapitel="synthese-kernverfahren.html"><a href="synthese-kernverfahren.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Synthese Teil II</span></a></li></ul></details><details class="sidebar-gruppe" open><summary>Teil III: Nichtlinearität, Unsicherheit und mehrperiodige Dynamik</summary><ul><li data-kapitel="qp-nlp.html"><a href="qp-nlp.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 11: Quadratische und nichtlineare Optimierung — KKT, Lagrange, Konvexität</span></a></li><li data-kapitel="unsicherheit.html" class="aktiv"><a href="unsicherheit.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 12: Optimierung unter Unsicherheit — Monte-Carlo, Stochastik, Robustheit</span></a></li><li data-kapitel="dynamische-programmierung.html"><a href="dynamische-programmierung.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 13: Dynamische Programmierung — Die Bellman-Gleichung und Order-Execution</span></a></li><li data-kapitel="mehrziel.html"><a href="mehrziel.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 14: Mehrere Ziele — Pareto-Fronten statt Gewichte</span></a></li><li data-kapitel="prognose.html"><a href="prognose.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 15: Predict-then-Optimize — die bessere Prognose, die schlechtere Entscheidung</span></a></li><li data-kapitel="synthese-nichtlinear.html"><a href="synthese-nichtlinear.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Synthese Teil III</span></a></li></ul></details><details class="sidebar-gruppe"><summary>Teil IV: Anwendungen — Energiewirtschaft und Finanzmärkte</summary><ul><li data-kapitel="bruecke.html"><a href="bruecke.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 16: Die Strukturbrücke — dieselbe Mathematik, zwei Welten</span></a></li><li data-kapitel="supplychain.html"><a href="supplychain.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 17: Supply-Chain und Energieeinsatz unter Unsicherheit</span></a></li><li data-kapitel="finanzdaten.html"><a href="finanzdaten.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 18: Finanzdaten-Modellierung — Renditen, Kovarianz und Shrinkage</span></a></li><li data-kapitel="markowitz.html"><a href="markowitz.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 19: Die moderne Portfoliotheorie nach Markowitz</span></a></li><li data-kapitel="cvar.html"><a href="cvar.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 20: Tail-Risiko, CVaR und Transaktionskosten</span></a></li><li data-kapitel="handelsmaschine.html"><a href="handelsmaschine.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 21: Die vollständige quantitative Handelsmaschine</span></a></li><li data-kapitel="synthese-anwendungen.html"><a href="synthese-anwendungen.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Synthese Teil IV</span></a></li></ul></details><details class="sidebar-gruppe"><summary>Teil V: Praxis</summary><ul><li data-kapitel="praxisfallen.html"><a href="praxisfallen.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 22: Praxisfallen und der Weg zum produktiven Einsatz</span></a></li><li data-kapitel="testing.html"><a href="testing.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 23: Testen, Messen, Ausliefern</span></a></li><li data-kapitel="synthese-praxis.html"><a href="synthese-praxis.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Synthese Teil V</span></a></li><li data-kapitel="projektwerkstatt.html"><a href="projektwerkstatt.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Projektwerkstatt</span></a></li></ul></details><details class="sidebar-gruppe"><summary>Anhänge</summary><ul><li data-kapitel="anhang-loesungen.html"><a href="anhang-loesungen.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Anhang A: Lösungen zu allen Übungsaufgaben</span></a></li><li data-kapitel="anhang-modellierungsmuster.html"><a href="anhang-modellierungsmuster.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Anhang B: Katalog der Modellierungsmuster</span></a></li><li data-kapitel="anhang-fehlerdiagnose.html"><a href="anhang-fehlerdiagnose.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Anhang C: Fehlerdiagnose-Handbuch</span></a></li><li data-kapitel="anhang-spickzettel.html"><a href="anhang-spickzettel.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Anhang D: Spickzettel der Solver</span></a></li><li data-kapitel="anhang-glossar-literatur.html"><a href="anhang-glossar-literatur.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Anhang E: Glossar und Literatur</span></a></li></ul></details><ul class="sidebar-extra"><li><a href="programme.html"><svg class="icon" aria-hidden="true"><use href="#icon-book"></use></svg> Beispielprogramme</a></li><li><a href="stichwortverzeichnis.html"><svg class="icon" aria-hidden="true"><use href="#icon-search"></use></svg> Stichwortverzeichnis</a></li><li><a href="gesamtdokument.html"><svg class="icon" aria-hidden="true"><use href="#icon-external-link"></use></svg> Gesamtdokument (eine Seite)</a></li><li><a href="Operations_Research_mit_Python_Version_04.pdf" download><svg class="icon" aria-hidden="true"><use href="#icon-download"></use></svg> Download als PDF</a></li></ul></div></nav>
   <main class="content">
     <nav class="breadcrumb" aria-label="Breadcrumb"><a href="index.html">Start</a> › <span>Teil III</span> › <span>Kapitel 12: Optimierung unter Unsicherheit — Monte-Carlo, Stochastik, Robustheit</span></nav>
     <nav class="prev-next"><a class="prev-next-knopf prev-next-prev" href="qp-nlp.html"><svg class="icon" aria-hidden="true"><use href="#icon-chevron-left"></use></svg><span><small>Zurück</small>Kapitel 11: Quadratische und nichtlineare Optimierung — KKT, Lagrange, Konvexität</span></a><a class="prev-next-knopf prev-next-next" href="dynamische-programmierung.html"><span><small>Weiter</small>Kapitel 13: Dynamische Programmierung — Die Bellman-Gleichung und Order-Execution</span><svg class="icon" aria-hidden="true"><use href="#icon-chevron-right"></use></svg></a></nav>
@@ -536,7 +536,7 @@ Feinsuche (Raster 100..500): Optimum bei Kapazitaet 180, Kosten 12,810 EUR
 <p><strong>🎯 Eine wichtige Einschränkung — und was man daraus lernt</strong></p>
 <p>Hier kostet die naive Mittelwertplanung nur <strong>1 %</strong>. In der Handrechnung zum Fluch des Durchschnitts waren es 2,7 %, in Lehrbüchern liest man von 20 % und mehr. <strong>Wie groß der Effekt ist, hängt von der Verteilung ab</strong> — und das ist selbst die Lektion.</p>
 <p>Bei dieser Mischverteilung liegt zwischen dem Normalbetrieb (um 150) und den Lastspitzen (um 450) ein Bereich, in dem kaum Wahrscheinlichkeitsmasse liegt. Zusätzliche Kapazität zwischen 200 und 400 nützt daher wenig: Sie ist im Normalfall Leerlauf und reicht im Krisenfall trotzdem nicht. Deshalb ist die Kostenkurve dort flach, und die Wahl zwischen 180 und 196 macht kaum einen Unterschied.</p>
-<p><strong>Was Sie mitnehmen sollten:</strong> Die Frage „Wie teuer ist Mittelwertplanung?“ hat keine allgemeine Antwort — <strong>rechnen Sie es aus.</strong> Genau dafür ist Monte-Carlo da. Und beachten Sie die Spalte „Unterdeckung“: Bei Kapazität 200 wird in <strong>24 % der Fälle</strong> nachgekauft. Ob das akzeptabel ist, entscheidet kein Optimierer, sondern ein Servicelevel-Ziel (Übung 9.5).</p>
+<p><strong>Was Sie mitnehmen sollten:</strong> Die Frage „Wie teuer ist Mittelwertplanung?“ hat keine allgemeine Antwort — <strong>rechnen Sie es aus.</strong> Genau dafür ist Monte-Carlo da. Und beachten Sie die Spalte „Unterdeckung“: Bei Kapazität 200 wird in <strong>24 % der Fälle</strong> nachgekauft. Ob das akzeptabel ist, entscheidet kein Optimierer, sondern ein Servicelevel-Ziel (Aufgabe <em>Monte-Carlo erweitern</em>, <a href="#sec:unsicherheit-uebungsaufgaben">Abschnitt 12.8</a>).</p>
 </blockquote>
 <blockquote>
 <p><strong>💡 Wann Monte-Carlo das richtige Werkzeug ist</strong> Immer dann, wenn Sie <strong>eine Kennzahl brauchen, die keine Formel hat</strong>: die Wahrscheinlichkeit, ein Servicelevel zu verfehlen; der erwartete Verlust in den schlechtesten 5 % der Fälle; die Verteilung der Projektdauer. Der Preis ist, dass Monte-Carlo nur <strong>bewertet</strong> — die Optimierung müssen Sie durch Rastersuche oder ein eigenes Modell ergänzen.</p>
@@ -715,7 +715,7 @@ den Mittelwert (225), weil Unterdeckung (120 EUR)
 deutlich teurer ist als Leerlauf (5 EUR).
 ==================================================================================</code></pre>
 <p><strong>Lesen Sie die Vergleichstabelle von unten nach oben.</strong> Die beiden extremen Haltungen sind die teuersten: Wer den Worst Case abdeckt (500 Einheiten), zahlt 5 000 € zu viel für Kapazität, die in 80 % der Fälle brachliegt. Wer optimistisch plant (100), zahlt 2 625 € Strafe für ständige Notzukäufe. Die naive Mittelwertplanung liegt dazwischen — aber eben auch nicht optimal.</p>
-<p>Der <strong>EVPI von 7 375 €</strong> ist bemerkenswert hoch: 45 % der Gesamtkosten entstehen allein daraus, dass man die Zukunft nicht kennt. In so einem Fall lohnt sich Investition in bessere Prognosen tatsächlich — anders als in dem Beispiel aus Übung 9.4.</p>
+<p>Der <strong>EVPI von 7 375 €</strong> ist bemerkenswert hoch: 45 % der Gesamtkosten entstehen allein daraus, dass man die Zukunft nicht kennt. In so einem Fall lohnt sich Investition in bessere Prognosen tatsächlich — anders als in dem Beispiel aus der Aufgabe <em>EVPI interpretieren</em> (<a href="#sec:unsicherheit-uebungsaufgaben">Abschnitt 12.8</a>).</p>
 <blockquote>
 <p><strong>💡 Was ist der EVPI?</strong> Der <strong>Expected Value of Perfect Information</strong> beziffert, wie viel eine perfekte Prognose wert wäre: die Differenz zwischen den Kosten unter Unsicherheit und den Kosten bei vollständigem Wissen. Er ist eine <strong>Obergrenze für jedes Prognoseprojekt</strong>. Wenn der EVPI bei 12 000 € pro Jahr liegt, lohnt sich keine Prognosesoftware für 50 000 € — selbst wenn sie perfekt wäre. Diese Zahl bewahrt Projekte vor teuren Fehlinvestitionen.</p>
 </blockquote>
@@ -1194,7 +1194,7 @@ Szenarien, 95 %         43,760,709   350    0    0  350     100.00 %     94.84 %
 <h2 id="sec:unsicherheit-denkfehler">12.9 Finde den Denkfehler</h2>
 <div class="card card-denkfehler">
 <blockquote>
-<p><strong>🐛 Finde den Denkfehler 9.1: Warum jedes Projekt zu spät fertig wird</strong></p>
+<p><strong>🐛 Finde den Denkfehler: Warum jedes Projekt zu spät fertig wird</strong></p>
 <p>Ein Projektleiter plant eine Umbaumaßnahme. Fünf Gewerke arbeiten <strong>parallel</strong> und unabhängig voneinander; fertig ist der Umbau, wenn das letzte fertig ist. Für jedes Gewerk liegt eine Schätzung vor: mindestens 6 Tage, wahrscheinlich 10, im schlechtesten Fall 18.</p>
 <p>Er rechnet: <em>„Jedes Gewerk braucht im Mittel <span class="math inline">(6 + 10 + 18)/3 = 11{,}3</span> Tage. Alle laufen gleichzeitig. Also ist der Umbau nach 11,3 Tagen fertig — ich plane großzügig 12 ein.“</em></p>
 <p>Nachgerechnet mit 200 000 simulierten Umbauten:</p>
@@ -1224,7 +1224,7 @@ Anteil ueber 11,34 Tage:       95.5 %</code></pre>
 <h2 id="sec:unsicherheit-quiz">12.10 Micro-Quiz</h2>
 <div class="card card-quiz">
 <blockquote>
-<p><strong>❓ Micro-Quiz 9: Drei Fragen zum Selbstcheck</strong></p>
+<p><strong>❓ Micro-Quiz 12: Drei Fragen zum Selbstcheck</strong></p>
 <p>Genau eine Antwort ist jeweils richtig. Auflösung in <a href="anhang-loesungen.html#quiz-loesung-unsicherheit">Anhang A</a>.</p>
 <p><strong>1. Bei einem Ersatzteil kostet ein Stück zu wenig 1 400 €, ein Stück zu viel 120 €. Der Bedarf beträgt im Mittel 30 Stück. Wie viel bestellen Sie?</strong> (a) 30 — das ist der Erwartungswert des Bedarfs. (b) Deutlich mehr als 30, nämlich das 92,1-%-Quantil des Bedarfs. Das kritische Verhältnis <span class="math inline">1400/(1400+120)</span> sagt, wie weit man sich auf die günstigere Fehlerseite stellen soll. (c) Weniger als 30, weil Lagerhaltung Kapital bindet.</p>
 <p><strong>2. Was unterscheidet </strong>stochastische** von <strong>robuster</strong> Optimierung?** (a) Stochastische Optimierung ist genauer, robuste ist eine Näherung für schnelle Rechnungen. (b) Stochastische Optimierung braucht <strong>Wahrscheinlichkeiten</strong> und optimiert den Erwartungswert; robuste Optimierung braucht nur <strong>Bandbreiten</strong> und sichert den schlechtesten Fall darin ab. (c) Robuste Optimierung berücksichtigt mehr Szenarien.</p>
diff --git a/OR_HTML_04/vorwort.html b/OR_HTML_04/vorwort.html
index 753f40f..0ff571c 100644
--- a/OR_HTML_04/vorwort.html
+++ b/OR_HTML_04/vorwort.html
@@ -94,7 +94,7 @@
 </header>
 <div class="site-body">
   <div class="sidebar-overlay" id="sidebar-overlay" hidden></div>
-  <nav class="sidebar" id="sidebar" aria-label="Kapitelnavigation"><div class="sidebar-inhalt"><details class="sidebar-gruppe" open><summary>Einstieg</summary><ul><li data-kapitel="vorwort.html" class="aktiv"><a href="vorwort.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Vorwort & Lesehilfe</span></a></li><li data-kapitel="notation.html"><a href="notation.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Notation & Abkürzungen</span></a></li></ul></details><details class="sidebar-gruppe"><summary>Teil I: Grundlagen des Operations Research</summary><ul><li data-kapitel="einfuehrung.html"><a href="einfuehrung.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 1: Einführung in Operations Research — Vom Ursprung zur mathematischen Entscheidungsfindung</span></a></li><li data-kapitel="fundament.html"><a href="fundament.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 2: Das mathematische Fundament — Vektoren, Matrizen, Konvexität</span></a></li><li data-kapitel="oekosystem.html"><a href="oekosystem.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 3: Das Python-Ökosystem für OR — Solver, Bindings und Modellierungsschichten</span></a></li><li data-kapitel="modellierung.html"><a href="modellierung.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 4: Vom Management-Wunsch zum Modell</span></a></li></ul></details><details class="sidebar-gruppe"><summary>Teil II: Die Kernverfahren der deterministischen Optimierung</summary><ul><li data-kapitel="lp.html"><a href="lp.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 5: Lineare Programmierung — Simplex, Dualität und Schattenpreise</span></a></li><li data-kapitel="milp.html"><a href="milp.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 6: Gemischt-ganzzahlige Optimierung — Diskrete Entscheidungen und Branch-and-Bound</span></a></li><li data-kapitel="cpsat.html"><a href="cpsat.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 7: Constraint Programming mit CP-SAT — Logik, Scheduling und Zuweisung</span></a></li><li data-kapitel="graphen.html"><a href="graphen.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 8: Graphen, Flüsse und Touren — Min-Cost-Flow, Matching und VRP</span></a></li><li data-kapitel="metaheuristiken.html"><a href="metaheuristiken.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 9: Metaheuristiken — wenn der exakte Solver aussteigt</span></a></li><li data-kapitel="dekomposition.html"><a href="dekomposition.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 10: Spaltengenerierung — das Modell umbauen statt die Lösung raten</span></a></li></ul></details><details class="sidebar-gruppe"><summary>Teil III: Nichtlinearität, Unsicherheit und mehrperiodige Dynamik</summary><ul><li data-kapitel="qp-nlp.html"><a href="qp-nlp.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 11: Quadratische und nichtlineare Optimierung — KKT, Lagrange, Konvexität</span></a></li><li data-kapitel="unsicherheit.html"><a href="unsicherheit.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 12: Optimierung unter Unsicherheit — Monte-Carlo, Stochastik, Robustheit</span></a></li><li data-kapitel="dynamische-programmierung.html"><a href="dynamische-programmierung.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 13: Dynamische Programmierung — Die Bellman-Gleichung und Order-Execution</span></a></li><li data-kapitel="mehrziel.html"><a href="mehrziel.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 14: Mehrere Ziele — Pareto-Fronten statt Gewichte</span></a></li><li data-kapitel="prognose.html"><a href="prognose.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 15: Predict-then-Optimize — die bessere Prognose, die schlechtere Entscheidung</span></a></li></ul></details><details class="sidebar-gruppe"><summary>Teil IV: Anwendungen — Energiewirtschaft und Finanzmärkte</summary><ul><li data-kapitel="bruecke.html"><a href="bruecke.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 16: Die Strukturbrücke — dieselbe Mathematik, zwei Welten</span></a></li><li data-kapitel="supplychain.html"><a href="supplychain.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 17: Supply-Chain und Energieeinsatz unter Unsicherheit</span></a></li><li data-kapitel="finanzdaten.html"><a href="finanzdaten.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 18: Finanzdaten-Modellierung — Renditen, Kovarianz und Shrinkage</span></a></li><li data-kapitel="markowitz.html"><a href="markowitz.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 19: Die moderne Portfoliotheorie nach Markowitz</span></a></li><li data-kapitel="cvar.html"><a href="cvar.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 20: Tail-Risiko, CVaR und Transaktionskosten</span></a></li><li data-kapitel="handelsmaschine.html"><a href="handelsmaschine.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 21: Die vollständige quantitative Handelsmaschine</span></a></li></ul></details><details class="sidebar-gruppe"><summary>Teil V: Praxis</summary><ul><li data-kapitel="praxisfallen.html"><a href="praxisfallen.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 22: Praxisfallen und der Weg zum produktiven Einsatz</span></a></li><li data-kapitel="testing.html"><a href="testing.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 23: Testen, Messen, Ausliefern</span></a></li><li data-kapitel="projektwerkstatt.html"><a href="projektwerkstatt.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Projektwerkstatt</span></a></li></ul></details><details class="sidebar-gruppe"><summary>Anhänge</summary><ul><li data-kapitel="anhang-loesungen.html"><a href="anhang-loesungen.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Anhang A: Lösungen zu allen Übungsaufgaben</span></a></li><li data-kapitel="anhang-modellierungsmuster.html"><a href="anhang-modellierungsmuster.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Anhang B: Katalog der Modellierungsmuster</span></a></li><li data-kapitel="anhang-fehlerdiagnose.html"><a href="anhang-fehlerdiagnose.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Anhang C: Fehlerdiagnose-Handbuch</span></a></li><li data-kapitel="anhang-spickzettel.html"><a href="anhang-spickzettel.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Anhang D: Spickzettel der Solver</span></a></li><li data-kapitel="anhang-glossar-literatur.html"><a href="anhang-glossar-literatur.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Anhang E: Glossar und Literatur</span></a></li></ul></details><ul class="sidebar-extra"><li><a href="programme.html"><svg class="icon" aria-hidden="true"><use href="#icon-book"></use></svg> Beispielprogramme</a></li><li><a href="stichwortverzeichnis.html"><svg class="icon" aria-hidden="true"><use href="#icon-search"></use></svg> Stichwortverzeichnis</a></li><li><a href="gesamtdokument.html"><svg class="icon" aria-hidden="true"><use href="#icon-external-link"></use></svg> Gesamtdokument (eine Seite)</a></li><li><a href="Operations_Research_mit_Python_Version_04.pdf" download><svg class="icon" aria-hidden="true"><use href="#icon-download"></use></svg> Download als PDF</a></li></ul></div></nav>
+  <nav class="sidebar" id="sidebar" aria-label="Kapitelnavigation"><div class="sidebar-inhalt"><details class="sidebar-gruppe" open><summary>Einstieg</summary><ul><li data-kapitel="vorwort.html" class="aktiv"><a href="vorwort.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Vorwort & Lesehilfe</span></a></li><li data-kapitel="notation.html"><a href="notation.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Notation & Abkürzungen</span></a></li></ul></details><details class="sidebar-gruppe"><summary>Teil I: Grundlagen des Operations Research</summary><ul><li data-kapitel="einfuehrung.html"><a href="einfuehrung.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 1: Einführung in Operations Research — Vom Ursprung zur mathematischen Entscheidungsfindung</span></a></li><li data-kapitel="fundament.html"><a href="fundament.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 2: Das mathematische Fundament — Vektoren, Matrizen, Konvexität</span></a></li><li data-kapitel="oekosystem.html"><a href="oekosystem.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 3: Das Python-Ökosystem für OR — Solver, Bindings und Modellierungsschichten</span></a></li><li data-kapitel="modellierung.html"><a href="modellierung.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 4: Vom Management-Wunsch zum Modell</span></a></li><li data-kapitel="synthese-grundlagen.html"><a href="synthese-grundlagen.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Synthese Teil I</span></a></li></ul></details><details class="sidebar-gruppe"><summary>Teil II: Die Kernverfahren der deterministischen Optimierung</summary><ul><li data-kapitel="lp.html"><a href="lp.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 5: Lineare Programmierung — Simplex, Dualität und Schattenpreise</span></a></li><li data-kapitel="milp.html"><a href="milp.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 6: Gemischt-ganzzahlige Optimierung — Diskrete Entscheidungen und Branch-and-Bound</span></a></li><li data-kapitel="cpsat.html"><a href="cpsat.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 7: Constraint Programming mit CP-SAT — Logik, Scheduling und Zuweisung</span></a></li><li data-kapitel="graphen.html"><a href="graphen.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 8: Graphen, Flüsse und Touren — Min-Cost-Flow, Matching und VRP</span></a></li><li data-kapitel="metaheuristiken.html"><a href="metaheuristiken.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 9: Metaheuristiken — wenn der exakte Solver aussteigt</span></a></li><li data-kapitel="dekomposition.html"><a href="dekomposition.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 10: Spaltengenerierung — das Modell umbauen statt die Lösung raten</span></a></li><li data-kapitel="synthese-kernverfahren.html"><a href="synthese-kernverfahren.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Synthese Teil II</span></a></li></ul></details><details class="sidebar-gruppe"><summary>Teil III: Nichtlinearität, Unsicherheit und mehrperiodige Dynamik</summary><ul><li data-kapitel="qp-nlp.html"><a href="qp-nlp.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 11: Quadratische und nichtlineare Optimierung — KKT, Lagrange, Konvexität</span></a></li><li data-kapitel="unsicherheit.html"><a href="unsicherheit.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 12: Optimierung unter Unsicherheit — Monte-Carlo, Stochastik, Robustheit</span></a></li><li data-kapitel="dynamische-programmierung.html"><a href="dynamische-programmierung.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 13: Dynamische Programmierung — Die Bellman-Gleichung und Order-Execution</span></a></li><li data-kapitel="mehrziel.html"><a href="mehrziel.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 14: Mehrere Ziele — Pareto-Fronten statt Gewichte</span></a></li><li data-kapitel="prognose.html"><a href="prognose.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 15: Predict-then-Optimize — die bessere Prognose, die schlechtere Entscheidung</span></a></li><li data-kapitel="synthese-nichtlinear.html"><a href="synthese-nichtlinear.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Synthese Teil III</span></a></li></ul></details><details class="sidebar-gruppe"><summary>Teil IV: Anwendungen — Energiewirtschaft und Finanzmärkte</summary><ul><li data-kapitel="bruecke.html"><a href="bruecke.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 16: Die Strukturbrücke — dieselbe Mathematik, zwei Welten</span></a></li><li data-kapitel="supplychain.html"><a href="supplychain.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 17: Supply-Chain und Energieeinsatz unter Unsicherheit</span></a></li><li data-kapitel="finanzdaten.html"><a href="finanzdaten.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 18: Finanzdaten-Modellierung — Renditen, Kovarianz und Shrinkage</span></a></li><li data-kapitel="markowitz.html"><a href="markowitz.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 19: Die moderne Portfoliotheorie nach Markowitz</span></a></li><li data-kapitel="cvar.html"><a href="cvar.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 20: Tail-Risiko, CVaR und Transaktionskosten</span></a></li><li data-kapitel="handelsmaschine.html"><a href="handelsmaschine.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 21: Die vollständige quantitative Handelsmaschine</span></a></li><li data-kapitel="synthese-anwendungen.html"><a href="synthese-anwendungen.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Synthese Teil IV</span></a></li></ul></details><details class="sidebar-gruppe"><summary>Teil V: Praxis</summary><ul><li data-kapitel="praxisfallen.html"><a href="praxisfallen.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 22: Praxisfallen und der Weg zum produktiven Einsatz</span></a></li><li data-kapitel="testing.html"><a href="testing.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Kapitel 23: Testen, Messen, Ausliefern</span></a></li><li data-kapitel="synthese-praxis.html"><a href="synthese-praxis.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Synthese Teil V</span></a></li><li data-kapitel="projektwerkstatt.html"><a href="projektwerkstatt.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Projektwerkstatt</span></a></li></ul></details><details class="sidebar-gruppe"><summary>Anhänge</summary><ul><li data-kapitel="anhang-loesungen.html"><a href="anhang-loesungen.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Anhang A: Lösungen zu allen Übungsaufgaben</span></a></li><li data-kapitel="anhang-modellierungsmuster.html"><a href="anhang-modellierungsmuster.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Anhang B: Katalog der Modellierungsmuster</span></a></li><li data-kapitel="anhang-fehlerdiagnose.html"><a href="anhang-fehlerdiagnose.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Anhang C: Fehlerdiagnose-Handbuch</span></a></li><li data-kapitel="anhang-spickzettel.html"><a href="anhang-spickzettel.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Anhang D: Spickzettel der Solver</span></a></li><li data-kapitel="anhang-glossar-literatur.html"><a href="anhang-glossar-literatur.html"><span class="fortschritt-haken"><svg class="icon" aria-hidden="true"><use href="#icon-check"></use></svg></span><span>Anhang E: Glossar und Literatur</span></a></li></ul></details><ul class="sidebar-extra"><li><a href="programme.html"><svg class="icon" aria-hidden="true"><use href="#icon-book"></use></svg> Beispielprogramme</a></li><li><a href="stichwortverzeichnis.html"><svg class="icon" aria-hidden="true"><use href="#icon-search"></use></svg> Stichwortverzeichnis</a></li><li><a href="gesamtdokument.html"><svg class="icon" aria-hidden="true"><use href="#icon-external-link"></use></svg> Gesamtdokument (eine Seite)</a></li><li><a href="Operations_Research_mit_Python_Version_04.pdf" download><svg class="icon" aria-hidden="true"><use href="#icon-download"></use></svg> Download als PDF</a></li></ul></div></nav>
   <main class="content">
     <nav class="breadcrumb" aria-label="Breadcrumb"><a href="index.html">Start</a> › <span>Vorwort & Lesehilfe</span></nav>
     <nav class="prev-next"><span class="prev-next-leer"></span><a class="prev-next-knopf prev-next-next" href="notation.html"><span><small>Weiter</small>Notation & Abkürzungen</span><svg class="icon" aria-hidden="true"><use href="#icon-chevron-right"></use></svg></a></nav>
@@ -349,6 +349,57 @@ Alles bereit — Sie können mit dem ersten Kapitel beginnen.</code></pre>
 <li><strong>Lauffähiges Python-Programm</strong> — vollständig abgedruckt, mit erwarteter Ausgabe.</li>
 </ol>
 <hr />
+<h2 class="unnumbered" id="für-wen-dieses-buch-geschrieben-ist">Für wen dieses Buch geschrieben ist</h2>
+<p>Die Lernpfade weiter unten sind nach <strong>Themen</strong> geschnitten. Dieser Abschnitt ist nach <strong>Rollen</strong> geschnitten: vier Einstiege für vier Arten, mit Optimierung zu tun zu haben. Jeder nennt den Schmerzpunkt, drei Dinge, die das Buch dafür wirklich liefert — mit den Zahlen, die es dazu misst —, den passenden Lernpfad und die Frage, an der es in dieser Rolle am häufigsten scheitert.</p>
+<p>Suchen Sie sich einen aus. Sie können auch alle vier überspringen; nötig sind sie nicht.</p>
+<h3 class="unnumbered" id="für-entscheider-und-manager-der-geschäftsfall">Für Entscheider und Manager — der Geschäftsfall</h3>
+<blockquote>
+<p><em>„Wir planen seit Jahren mit Erfahrungswerten, und es funktioniert. Warum sollte ein Modell das besser können — und was kostet mich der Irrtum, wenn ich es nicht tue?“</em></p>
+</blockquote>
+<ul>
+<li><strong>Was Planen mit Durchschnitten kostet, wird hier beziffert, nicht behauptet.</strong> Im Kraftwerkseinsatz aus <a href="supplychain.html#kap-supplychain">Kapitel 17</a> kostet ein Plan, der mit dem Wind-<strong>Erwartungswert</strong> rechnet, in der Wirklichkeit <strong>149 % mehr</strong> als einer, der 40 Szenarien berücksichtigt — 874 870 € statt 351 356 € — und führt in <strong>28 von 40 Szenarien</strong> zum Lastabwurf statt in keinem.</li>
+<li><strong>„Wie sicher soll es sein?“ wird eine Preisfrage.</strong> <a href="unsicherheit.html#sec:unsicherheit-chance-constraints">Abschnitt 12.7</a> rechnet aus, was ein Prozentpunkt Versorgungssicherheit kostet: rund 56 000 € auf dem Weg zu 80 %, rund 254 000 € zwischen 95 und 99 %. Das <strong>4,5-fache</strong>. Wer 99,9 % fordert, ohne diese Kurve gesehen zu haben, fordert ins Blaue.</li>
+<li><strong>Für die Sitzung gibt es einen Bericht, keine Tabelle.</strong> <a href="praxisfallen.html#sec:praxisfallen-attribution">Abschnitt 22.4</a> beziffert je Nebenbedingung, was sie den Plan kostet, und formuliert daraus Sätze in Alltagssprache. Für die Frage des Betriebsrats — <em>„warum ausgerechnet ich?“</em> — liefert <a href="praxisfallen.html#kap-praxisfallen">Kapitel 22</a> den Constraint-Trace, der die einzelne Zuweisung begründet.</li>
+</ul>
+<p><strong>Ihr Weg.</strong> Zuerst Pfad E (2–4 Stunden): <a href="einfuehrung.html#sec:einfuehrung-historischer-kontext-und-evolution">Abschnitt 1.5</a> und <a href="anhang-modellierungsmuster.html#anhang-modellierungsmuster">Anhang B</a>. Wenn Sie danach wissen wollen, was in Ihrem Betrieb geht, Pfad B und Projekt <strong>P1</strong> oder <strong>P2</strong>.</p>
+<p><strong>Woran es scheitert.</strong> Nicht am Modell, sondern an der Einführung — das ist der meistgenannte Befund in <a href="praxisfallen.html#kap-praxisfallen">Kapitel 22</a>. Und an einer Verwechslung, die dieses Buch Ihnen nicht abnehmen kann: Ein Bericht erklärt das <strong>Modell</strong>, nicht die <strong>Wirklichkeit</strong>. Ist ein Deckungsbeitrag falsch geschätzt, ist er überzeugend <strong>und</strong> falsch. Fragen Sie deshalb jedes Mal, worauf eine Zahl beruht.</p>
+<blockquote>
+<p><strong>Eine Erwartung, die dieses Buch enttäuscht:</strong> Es nennt keine ROI-Kennzahl und keine Amortisationsdauer. Beide hängen an Ihrem Betrieb, und jede Zahl hier wäre erfunden. Was es stattdessen liefert, ist das Werkzeug, Ihre eigene auszurechnen: den <strong>EVPI</strong> in <a href="unsicherheit.html#kap-unsicherheit">Kapitel 12</a> (was eine perfekte Prognose überhaupt wert wäre — eine Obergrenze für jedes Prognoseprojekt) und die Kostenzurechnung aus <a href="praxisfallen.html#sec:praxisfallen-attribution">Abschnitt 22.4</a>.</p>
+</blockquote>
+<h3 class="unnumbered" id="für-ingenieure-und-produktionsplaner-die-physik-des-systems">Für Ingenieure und Produktionsplaner — die Physik des Systems</h3>
+<blockquote>
+<p><em>„Der Engpass wandert. Kaum ist eine Maschine entlastet, steht die nächste — und niemand kann mir vorher sagen, welche.“</em></p>
+</blockquote>
+<ul>
+<li><strong>Der Engpass lässt sich benennen und bepreisen.</strong> <a href="praxisfallen.html#sec:praxisfallen-attribution">Abschnitt 22.4</a> rechnet für jede Kapazität aus, was die nächste Stunde wert ist — und wie weit dieser Wert trägt. Im Beispiel gilt der Schattenpreis der Lackiererei exakt bis <strong>+15 Stunden</strong>; eine ganze Sonderschicht von 30 Stunden bringt deshalb 60 € statt der rechnerischen 120 €. <strong>Die zweite Hälfte wäre bezahlt und wirkungslos.</strong></li>
+<li><strong>Rüstzeiten, Reihenfolgen, Taktzeiten sind der Kern, nicht die Ausnahme.</strong> <a href="cpsat.html#kap-cpsat">Kapitel 7</a> modelliert Maschinenbelegung mit Intervallvariablen, <a href="metaheuristiken.html#kap-metaheuristiken">Kapitel 9</a> zeigt am selben Fall das Gesamtbild: Faustregel 2 497 Minuten Rüstzeit, CP-SAT allein 2 628, Simulated Annealing 2 343, Annealing plus LNS <strong>2 289</strong> — und die untere Schranke bei 1 768, damit sichtbar bleibt, wie viel Luft noch da ist.</li>
+<li><strong>Wenn der Solver zu lange braucht, gibt es Zahlen statt Ratschläge.</strong> <a href="cpsat.html#sec:cpsat-parallele-suche">Abschnitt 7.7</a> misst, was mehrere Suchstränge bringen (hier Faktor 12,3) — und ab wo mehr Arbeiter wieder schaden.</li>
+</ul>
+<p><strong>Ihr Weg.</strong> Pfad B bis <a href="cpsat.html#kap-cpsat">Kapitel 7</a>, dann Projekt <strong>P5</strong> (Produktionsplanung mit Rüstkosten). Wenn Ihre echten Instanzen den Solver stehen lassen: <a href="metaheuristiken.html#kap-metaheuristiken">Kapitel 9</a> und Projekt <strong>P9</strong>.</p>
+<p><strong>Woran es scheitert.</strong> An der Verwechslung von <em>bindend</em> und <em>teuer</em>. Eine Bedingung kann den Plan berühren und trotzdem <strong>nichts</strong> kosten — im Beispiel von <a href="praxisfallen.html#sec:praxisfallen-attribution">Abschnitt 22.4</a> gilt das für eine von fünf bindenden. Wer sie nachverhandelt, gewinnt nichts und hält das Verfahren für nutzlos.</p>
+<h3 class="unnumbered" id="für-investoren-und-finanzanalysten-risiko-und-ertrag">Für Investoren und Finanzanalysten — Risiko und Ertrag</h3>
+<blockquote>
+<p><em>„Die Optimierung liefert mir Gewichte, die kein Mensch halten würde: 60 % in einem Titel, null in fünf anderen. Und im nächsten Quartal sieht sie völlig anders aus.“</em></p>
+</blockquote>
+<ul>
+<li><strong>Der Grund dafür steht in <a href="finanzdaten.html#kap-finanzdaten">Kapitel 18</a>, nicht in <a href="markowitz.html#kap-markowitz">Kapitel 19</a>.</strong> Eine aus kurzen Zeitreihen geschätzte Kovarianzmatrix ist schlecht konditioniert; der Optimierer setzt dann auf Schätzrauschen. Shrinkage nach Ledoit-Wolf ist das Gegenmittel; ihre Wirkung wird an <strong>Eigenwertspektrum und Konditionszahl</strong> gemessen, nicht behauptet.</li>
+<li><strong>Der VaR verschweigt genau das, worauf es ankommt.</strong> In der Stichprobe aus <a href="cvar.html#kap-cvar">Kapitel 20</a> sagt der VaR: „an 95 % der Tage höchstens <strong>1,86 %</strong> Verlust“. Der CVaR sagt: „und wenn doch, dann im Mittel <strong>2,99 %</strong>“. Der schlechteste Tag der Stichprobe liegt bei <strong>−23,0 %</strong> — am VaR ändert dieser eine Tag <strong>nichts</strong>, am CVaR sehr wohl. Deshalb ist der CVaR die Größe, die man optimiert.</li>
+<li><strong>Transaktionskosten und Rebalancing sind Teil des Modells, nicht ein Abzug danach.</strong> <a href="cvar.html#kap-cvar">Kapitel 20</a> nimmt sie in die Zielfunktion, <a href="handelsmaschine.html#kap-handelsmaschine">Kapitel 21</a> setzt den Backtest daneben — samt der Fallen, die einen guten Backtest wertlos machen.</li>
+</ul>
+<p><strong>Ihr Weg.</strong> Pfad D, und zwar <strong>mit</strong> <a href="finanzdaten.html#kap-finanzdaten">Kapitel 18</a>. Danach Projekt <strong>P6</strong> (Portfolio-Rebalancer) oder <strong>P7</strong> (Risikoreport mit CVaR und Stresstests).</p>
+<p><strong>Woran es scheitert.</strong> An der Reihenfolge. Wer bei Markowitz einsteigt und die Datenkapitel überspringt, bekommt ein Modell, das seine eigenen Schätzfehler maximiert — und merkt es erst im Echtgeldbetrieb.</p>
+<h3 class="unnumbered" id="für-studierende-und-data-scientists-die-methodik">Für Studierende und Data Scientists — die Methodik</h3>
+<blockquote>
+<p><em>„Ich kann ein Modell trainieren und den Fehler senken. Aber wie wird aus einer Prognose eine Entscheidung — und woher weiß ich, dass sie gut ist?“</em></p>
+</blockquote>
+<ul>
+<li><strong>Die unbequemste Erkenntnis zuerst.</strong> <a href="prognose.html#kap-prognose">Kapitel 15</a> zeigt an einem gerechneten Fall, dass das Modell mit dem <strong>schlechteren</strong> MSE die <strong>günstigere</strong> Entscheidung trifft. Prognosegüte und Entscheidungsqualität sind zwei verschiedene Größen; wer die eine optimiert, bekommt die andere nicht geschenkt.</li>
+<li><strong>Dieselbe Mathematik, zwei Welten.</strong> <a href="bruecke.html#kap-bruecke">Kapitel 16</a> lässt <strong>denselben Code</strong> einmal über eine Werkstatt und einmal über ein Depot laufen — und benennt die drei Stellen, an denen die Analogie endet. Struktur zu erkennen ist die eigentliche Fähigkeit, nicht Bibliothekskenntnis; zu wissen, wo eine Analogie aufhört, gehört dazu.</li>
+<li><strong>Es wird gerechnet, nicht nacherzählt.</strong> Zu jedem Kapitel gehören Aufgaben mit vollständigen Lösungen, Handrechnungen und ein „Finde den Denkfehler“ — und jedes abgedruckte Ergebnis stammt aus einem echten Lauf des danebenstehenden Programms.</li>
+</ul>
+<p><strong>Ihr Weg.</strong> Pfad A, wenn Sie Zeit haben. Sonst Pfad B oder D bis zum ersten Projekt und von dort zurück in die Grundlagen. Für eigene Fragestellungen: Projekt <strong>P8</strong>.</p>
+<p><strong>Woran es scheitert.</strong> An der Annahme, ein Solver sei eine Bibliothek wie jede andere. Die schwierige Arbeit steckt in der Formulierung — <a href="modellierung.html#kap-modellierung">Kapitel 4</a> ist deshalb kein Vorgeplänkel, sondern das Kapitel, auf das alle anderen aufbauen.</p>
+<hr />
 <h2 class="unnumbered" id="lernpfade">Lernpfade</h2>
 <p>Sie müssen nicht alles lesen, um etwas Nützliches bauen zu können.</p>
 <h3 class="unnumbered" id="pfad-a-vollständiger-lehrgang-100140-stunden">Pfad A — Vollständiger Lehrgang (100–140 Stunden)</h3>
@@ -362,7 +413,7 @@ Alles bereit — Sie können mit dem ersten Kapitel beginnen.</code></pre>
 <h3 class="unnumbered" id="pfad-d-quantitative-finance-ca.-30-stunden">Pfad D — Quantitative Finance (ca. 30 Stunden)</h3>
 <p><a href="einfuehrung.html#kap-einfuehrung">Kapitel 1</a> → <a href="fundament.html#kap-fundament">Kapitel 2</a> → <a href="qp-nlp.html#kap-qp-nlp">Kapitel 11</a> (QP, KKT) → <a href="finanzdaten.html#kap-finanzdaten">Kapitel 18</a> (Daten, Shrinkage) → <a href="markowitz.html#kap-markowitz">Kapitel 19</a> (Markowitz) → <a href="cvar.html#kap-cvar">Kapitel 20</a> (CVaR) → <a href="handelsmaschine.html#kap-handelsmaschine">Kapitel 21</a> (Backtest) → Projekt <strong>P6</strong> (Portfolio-Rebalancer) oder <strong>P7</strong> (Risikoreport). <strong>Wichtig:</strong> Überspringen Sie <a href="finanzdaten.html#kap-finanzdaten">Kapitel 18</a> nicht. Wer direkt bei Markowitz einsteigt, optimiert Schätzrauschen und wundert sich über absurde Gewichte.</p>
 <h3 class="unnumbered" id="pfad-e-ich-habe-morgen-ein-konkretes-problem-24-stunden">Pfad E — Ich habe morgen ein konkretes Problem (2–4 Stunden)</h3>
-<p>Lesen Sie <a href="einfuehrung.html#sec:einfuehrung-historischer-kontext-und-evolution">Abschnitt 1.5</a> (die vier Bausteine), dann <a href="anhang-modellierungsmuster.html#anhang-modellierungsmuster">Anhang B</a> (<a href="anhang-modellierungsmuster.html">Modellierungsmuster</a>) und suchen Sie dort das Muster, das zu Ihrem Problem passt. Von jedem Muster führt ein Verweis in das zuständige Kapitel. Wie die gewählte Bibliothek es schreibt, steht in <a href="anhang-spickzettel.html#anhang-spickzettel">Anhang D</a> (<a href="anhang-spickzettel.html">Spickzettel</a>); wenn etwas nicht läuft, in <a href="anhang-fehlerdiagnose.html#anhang-fehlerdiagnose">Anhang C</a> (<a href="anhang-fehlerdiagnose.html">Fehlerdiagnose</a>).</p>
+<p>Lesen Sie <a href="einfuehrung.html#sec:einfuehrung-historischer-kontext-und-evolution">Abschnitt 1.5</a> (die vier Bausteine) und <a href="modellierung.html#sec:modellierung-glossar">Abschnitt 4.6</a> (welcher Satz welcher Baustein ist), dann <a href="anhang-modellierungsmuster.html#anhang-modellierungsmuster">Anhang B</a> (<a href="anhang-modellierungsmuster.html">Modellierungsmuster</a>) und suchen Sie dort das Muster, das zu Ihrem Problem passt. Von jedem Muster führt ein Verweis in das zuständige Kapitel. Wie die gewählte Bibliothek es schreibt, steht in <a href="anhang-spickzettel.html#anhang-spickzettel">Anhang D</a> (<a href="anhang-spickzettel.html">Spickzettel</a>); wenn etwas nicht läuft, in <a href="anhang-fehlerdiagnose.html#anhang-fehlerdiagnose">Anhang C</a> (<a href="anhang-fehlerdiagnose.html">Fehlerdiagnose</a>).</p>
 <h3 class="unnumbered" id="pfad-f-vom-prototyp-in-den-betrieb-ca.-15-stunden">Pfad F — Vom Prototyp in den Betrieb (ca. 15 Stunden)</h3>
 <p>Für alle, deren Modell <strong>rechnet</strong> und die es jetzt jemand anderem übergeben müssen: <a href="praxisfallen.html#kap-praxisfallen">Kapitel 22</a> (die fünf Praxisfallen, <code>or_kern.py</code>, Erklärbarkeit) → <a href="testing.html#kap-testing">Kapitel 23</a> (Testsuite, Mutationstest, Benchmark, HTTP-Dienst) → <a href="anhang-fehlerdiagnose.html#anhang-fehlerdiagnose">Anhang C</a> als Nachschlagewerk für den Ernstfall, dann Projekt <strong>P11</strong> (Vom Skript zum Dienst). Setzt voraus, dass Sie mindestens einen der Pfade B, C oder D hinter sich haben — P11 baut auf einem Modell auf, das Sie schon haben.</p>
 <p><em>Der Kern in einem Satz:</em> Ein Modell, das nur auf Ihrem Rechner und nur mit Ihren Daten läuft, ist ein Prototyp — kein System.</p>
@@ -519,200 +570,210 @@ Alles bereit — Sie können mit dem ersten Kapitel beginnen.</code></pre>
 <td><a href="cpsat.html#kap-cpsat">Kapitel 7</a></td>
 </tr>
 <tr class="even">
+<td><code>Parallele_Suche.py</code></td>
+<td>num_workers: Tempo gegen Reproduzierbarkeit</td>
+<td><a href="cpsat.html#kap-cpsat">Kapitel 7</a></td>
+</tr>
+<tr class="odd">
 <td><code>CP_SAT_Statusfaelle.py</code></td>
 <td>Die fünf Solver-Antworten</td>
 <td><a href="cpsat.html#kap-cpsat">Kapitel 7</a></td>
 </tr>
-<tr class="odd">
+<tr class="even">
 <td><code>Strafgewichte.py</code></td>
 <td>Gewichte als Wechselkurse</td>
 <td><a href="cpsat.html#kap-cpsat">Kapitel 7</a></td>
 </tr>
-<tr class="even">
+<tr class="odd">
 <td><code>Min_Cost_Flow.py</code></td>
 <td>Netzwerkfluss</td>
 <td><a href="graphen.html#kap-graphen">Kapitel 8</a></td>
 </tr>
-<tr class="odd">
+<tr class="even">
 <td><code>Zuordnung_Ungarisch.py</code></td>
 <td>Zuordnung, Unimodularität</td>
 <td><a href="graphen.html#kap-graphen">Kapitel 8</a></td>
 </tr>
-<tr class="even">
+<tr class="odd">
 <td><code>VRP_Flotten_Routing.py</code></td>
 <td>CVRPTW</td>
 <td><a href="graphen.html#kap-graphen">Kapitel 8</a></td>
 </tr>
-<tr class="odd">
+<tr class="even">
 <td><code>VRP_Kapazitaetsfalle.py</code></td>
 <td>Vergessene Dimension im Routing</td>
 <td><a href="graphen.html#kap-graphen">Kapitel 8</a></td>
 </tr>
-<tr class="even">
+<tr class="odd">
 <td><code>Simulated_Annealing.py</code></td>
 <td>Lokale Suche, Temperatur kalibrieren</td>
 <td><a href="metaheuristiken.html#kap-metaheuristiken">Kapitel 9</a></td>
 </tr>
-<tr class="odd">
+<tr class="even">
 <td><code>Metaheuristik_vs_Exakt.py</code></td>
 <td>Der Umschlagpunkt, und die Schranke</td>
 <td><a href="metaheuristiken.html#kap-metaheuristiken">Kapitel 9</a></td>
 </tr>
-<tr class="even">
+<tr class="odd">
 <td><code>Large_Neighborhood_Search.py</code></td>
 <td>Zerstören und exakt reparieren</td>
 <td><a href="metaheuristiken.html#kap-metaheuristiken">Kapitel 9</a></td>
 </tr>
-<tr class="odd">
+<tr class="even">
 <td><code>Spaltengenerierung.py</code></td>
 <td>Muster statt Stücke, Master und Pricing</td>
 <td><a href="dekomposition.html#kap-dekomposition">Kapitel 10</a></td>
 </tr>
-<tr class="even">
+<tr class="odd">
 <td><code>QP_Grundlagen.py</code></td>
 <td>Konvexität, DCP-Check</td>
 <td><a href="qp-nlp.html#kap-qp-nlp">Kapitel 11</a></td>
 </tr>
-<tr class="odd">
+<tr class="even">
 <td><code>KKT_Nachweis.py</code></td>
 <td>KKT numerisch prüfen</td>
 <td><a href="qp-nlp.html#kap-qp-nlp">Kapitel 11</a></td>
 </tr>
-<tr class="even">
+<tr class="odd">
 <td><code>Entropie_Maximierte_Allokation.py</code></td>
 <td>NLP mit Entropie</td>
 <td><a href="qp-nlp.html#kap-qp-nlp">Kapitel 11</a></td>
 </tr>
-<tr class="odd">
+<tr class="even">
 <td><code>Lokale_Optima_Multistart.py</code></td>
 <td>Lokale Optima, Multistart</td>
 <td><a href="qp-nlp.html#kap-qp-nlp">Kapitel 11</a></td>
 </tr>
-<tr class="even">
+<tr class="odd">
 <td><code>Fluch_des_Durchschnitts.py</code></td>
 <td>Optimum ≠ Mittelwert</td>
 <td><a href="unsicherheit.html#kap-unsicherheit">Kapitel 12</a></td>
 </tr>
-<tr class="odd">
+<tr class="even">
 <td><code>Monte_Carlo.py</code></td>
 <td>Monte-Carlo-Bewertung</td>
 <td><a href="unsicherheit.html#kap-unsicherheit">Kapitel 12</a></td>
 </tr>
-<tr class="even">
+<tr class="odd">
 <td><code>Stochastische_Optimierung.py</code></td>
 <td>Two-Stage mit Recourse</td>
 <td><a href="unsicherheit.html#kap-unsicherheit">Kapitel 12</a></td>
 </tr>
-<tr class="odd">
+<tr class="even">
 <td><code>Robuste_Optimierung.py</code></td>
 <td>Worst-Case-Absicherung</td>
 <td><a href="unsicherheit.html#kap-unsicherheit">Kapitel 12</a></td>
 </tr>
-<tr class="even">
+<tr class="odd">
 <td><code>Chance_Constraints.py</code></td>
 <td>Zusage „mit 95 % Sicherheit“, SOC und Big-M</td>
 <td><a href="unsicherheit.html#kap-unsicherheit">Kapitel 12</a></td>
 </tr>
-<tr class="odd">
+<tr class="even">
 <td><code>Bellman_Minimalbeispiel.py</code></td>
 <td>Rückwärtsinduktion</td>
 <td><a href="dynamische-programmierung.html#kap-dynamische-programmierung">Kapitel 13</a></td>
 </tr>
-<tr class="even">
+<tr class="odd">
 <td><code>Mehrziel_Pareto.py</code></td>
 <td>Pareto-Front, ε-Constraint, Gewichtslücke</td>
 <td><a href="mehrziel.html#kap-mehrziel">Kapitel 14</a></td>
 </tr>
-<tr class="odd">
+<tr class="even">
 <td><code>Predict_then_Optimize.py</code></td>
 <td>MSE gegen Entscheidungskosten</td>
 <td><a href="prognose.html#kap-prognose">Kapitel 15</a></td>
 </tr>
-<tr class="even">
+<tr class="odd">
 <td><code>Strukturbruecke.py</code></td>
 <td>Derselbe Code über Werkstatt und Depot</td>
 <td><a href="bruecke.html#kap-bruecke">Kapitel 16</a></td>
 </tr>
-<tr class="odd">
+<tr class="even">
 <td><code>Kraftwerkseinsatz.py</code></td>
 <td>Unit Commitment unter Windunsicherheit</td>
 <td><a href="supplychain.html#kap-supplychain">Kapitel 17</a></td>
 </tr>
-<tr class="even">
+<tr class="odd">
 <td><code>Mehrperiodige_Order_Execution.py</code></td>
 <td>Almgren-Chriss</td>
 <td><a href="dynamische-programmierung.html#kap-dynamische-programmierung">Kapitel 13</a></td>
 </tr>
-<tr class="odd">
+<tr class="even">
 <td><code>Renditen_Vergleich.py</code></td>
 <td>Diskret vs. logarithmisch</td>
 <td><a href="finanzdaten.html#kap-finanzdaten">Kapitel 18</a></td>
 </tr>
-<tr class="even">
+<tr class="odd">
 <td><code>Schaetzrauschen_Demo.py</code></td>
 <td>Error-Maximizer messen</td>
 <td><a href="finanzdaten.html#kap-finanzdaten">Kapitel 18</a></td>
 </tr>
-<tr class="odd">
+<tr class="even">
 <td><code>Finanzdaten_Ledoit_Wolf.py</code></td>
 <td>Datenpipeline, Shrinkage</td>
 <td><a href="finanzdaten.html#kap-finanzdaten">Kapitel 18</a></td>
 </tr>
-<tr class="even">
+<tr class="odd">
 <td><code>Kovarianz_Falle.py</code></td>
 <td>Singuläre Kovarianz, Error-Maximizer</td>
 <td><a href="finanzdaten.html#kap-finanzdaten">Kapitel 18</a></td>
 </tr>
-<tr class="odd">
+<tr class="even">
 <td><code>Markowitz_CVXPY.py</code></td>
 <td>GMV, Max Sharpe, Frontier</td>
 <td><a href="markowitz.html#kap-markowitz">Kapitel 19</a></td>
 </tr>
-<tr class="even">
+<tr class="odd">
 <td><code>Diversifikation_Demo.py</code></td>
 <td>Korrelation und Portfoliorisiko</td>
 <td><a href="markowitz.html#kap-markowitz">Kapitel 19</a></td>
 </tr>
-<tr class="odd">
+<tr class="even">
 <td><code>Renditeschaetzung_Falle.py</code></td>
 <td>Schätzfehler in erwarteten Renditen</td>
 <td><a href="markowitz.html#kap-markowitz">Kapitel 19</a></td>
 </tr>
-<tr class="even">
+<tr class="odd">
 <td><code>VaR_CVaR_Demo.py</code></td>
 <td>Fat Tails, Subadditivität</td>
 <td><a href="cvar.html#kap-cvar">Kapitel 20</a></td>
 </tr>
-<tr class="odd">
+<tr class="even">
 <td><code>CVaR_Portfolio.py</code></td>
 <td>CVaR mit Reibung</td>
 <td><a href="cvar.html#kap-cvar">Kapitel 20</a></td>
 </tr>
-<tr class="even">
+<tr class="odd">
 <td><code>QuantitativeTradingEngine.py</code></td>
 <td>Walk-Forward-Backtest</td>
 <td><a href="handelsmaschine.html#kap-handelsmaschine">Kapitel 21</a></td>
 </tr>
-<tr class="odd">
+<tr class="even">
 <td><code>Backtest_Fallen.py</code></td>
 <td>Fünf Selbsttäuschungen</td>
 <td><a href="handelsmaschine.html#kap-handelsmaschine">Kapitel 21</a></td>
 </tr>
-<tr class="even">
+<tr class="odd">
 <td><code>Data_Snooping.py</code></td>
 <td>Bestes aus N Versuchen auf Rauschen</td>
 <td><a href="handelsmaschine.html#kap-handelsmaschine">Kapitel 21</a></td>
 </tr>
-<tr class="odd">
+<tr class="even">
 <td><code>Infeasibility_Diagnose.py</code></td>
 <td>Notfallplan statt Fehler</td>
 <td><a href="praxisfallen.html#kap-praxisfallen">Kapitel 22</a></td>
 </tr>
-<tr class="even">
+<tr class="odd">
 <td><code>Erklaerbarkeit.py</code></td>
 <td>Constraint-Trace, Was-wäre-wenn</td>
 <td><a href="praxisfallen.html#kap-praxisfallen">Kapitel 22</a></td>
 </tr>
+<tr class="even">
+<td><code>Constraint_Attribution.py</code></td>
+<td>Was kostet welche Bedingung? Managementbericht</td>
+<td><a href="praxisfallen.html#kap-praxisfallen">Kapitel 22</a></td>
+</tr>
 <tr class="odd">
 <td><code>Betriebsueberwachung.py</code></td>
 <td>Status, Gap und Zeitausschöpfung</td>
diff --git a/Operations_Research_mit_Python_Version_04.md b/Operations_Research_mit_Python_Version_04.md
index 121f42c..705ad32 100644
--- a/Operations_Research_mit_Python_Version_04.md
+++ b/Operations_Research_mit_Python_Version_04.md
@@ -272,6 +272,64 @@ Jedes Kapitel folgt derselben Struktur. Wenn Sie wissen, wie die Bausteine funkt
 
 ---
 
+## Für wen dieses Buch geschrieben ist {-}
+
+Die Lernpfade weiter unten sind nach **Themen** geschnitten. Dieser Abschnitt ist nach **Rollen** geschnitten: vier Einstiege für vier Arten, mit Optimierung zu tun zu haben. Jeder nennt den Schmerzpunkt, drei Dinge, die das Buch dafür wirklich liefert — mit den Zahlen, die es dazu misst —, den passenden Lernpfad und die Frage, an der es in dieser Rolle am häufigsten scheitert.
+
+Suchen Sie sich einen aus. Sie können auch alle vier überspringen; nötig sind sie nicht.
+
+### Für Entscheider und Manager — der Geschäftsfall {-}
+
+> *„Wir planen seit Jahren mit Erfahrungswerten, und es funktioniert. Warum sollte ein Modell das besser können — und was kostet mich der Irrtum, wenn ich es nicht tue?“*
+
+* **Was Planen mit Durchschnitten kostet, wird hier beziffert, nicht behauptet.** Im Kraftwerkseinsatz aus [Kapitel 17](#kap-supplychain) kostet ein Plan, der mit dem Wind-**Erwartungswert** rechnet, in der Wirklichkeit **149 % mehr** als einer, der 40 Szenarien berücksichtigt — 874 870 € statt 351 356 € — und führt in **28 von 40 Szenarien** zum Lastabwurf statt in keinem.
+* **„Wie sicher soll es sein?“ wird eine Preisfrage.** [Abschnitt 12.7](#sec:unsicherheit-chance-constraints) rechnet aus, was ein Prozentpunkt Versorgungssicherheit kostet: rund 56 000 € auf dem Weg zu 80 %, rund 254 000 € zwischen 95 und 99 %. Das **4,5-fache**. Wer 99,9 % fordert, ohne diese Kurve gesehen zu haben, fordert ins Blaue.
+* **Für die Sitzung gibt es einen Bericht, keine Tabelle.** [Abschnitt 22.4](#sec:praxisfallen-attribution) beziffert je Nebenbedingung, was sie den Plan kostet, und formuliert daraus Sätze in Alltagssprache. Für die Frage des Betriebsrats — *„warum ausgerechnet ich?“* — liefert [Kapitel 22](#kap-praxisfallen) den Constraint-Trace, der die einzelne Zuweisung begründet.
+
+**Ihr Weg.** Zuerst Pfad E (2–4 Stunden): [Abschnitt 1.5](#sec:einfuehrung-historischer-kontext-und-evolution) und [Anhang B](#anhang-modellierungsmuster). Wenn Sie danach wissen wollen, was in Ihrem Betrieb geht, Pfad B und Projekt **P1** oder **P2**.
+
+**Woran es scheitert.** Nicht am Modell, sondern an der Einführung — das ist der meistgenannte Befund in [Kapitel 22](#kap-praxisfallen). Und an einer Verwechslung, die dieses Buch Ihnen nicht abnehmen kann: Ein Bericht erklärt das **Modell**, nicht die **Wirklichkeit**. Ist ein Deckungsbeitrag falsch geschätzt, ist er überzeugend **und** falsch. Fragen Sie deshalb jedes Mal, worauf eine Zahl beruht.
+
+> **Eine Erwartung, die dieses Buch enttäuscht:** Es nennt keine ROI-Kennzahl und keine Amortisationsdauer. Beide hängen an Ihrem Betrieb, und jede Zahl hier wäre erfunden. Was es stattdessen liefert, ist das Werkzeug, Ihre eigene auszurechnen: den **EVPI** in [Kapitel 12](#kap-unsicherheit) (was eine perfekte Prognose überhaupt wert wäre — eine Obergrenze für jedes Prognoseprojekt) und die Kostenzurechnung aus [Abschnitt 22.4](#sec:praxisfallen-attribution).
+
+### Für Ingenieure und Produktionsplaner — die Physik des Systems {-}
+
+> *„Der Engpass wandert. Kaum ist eine Maschine entlastet, steht die nächste — und niemand kann mir vorher sagen, welche.“*
+
+* **Der Engpass lässt sich benennen und bepreisen.** [Abschnitt 22.4](#sec:praxisfallen-attribution) rechnet für jede Kapazität aus, was die nächste Stunde wert ist — und wie weit dieser Wert trägt. Im Beispiel gilt der Schattenpreis der Lackiererei exakt bis **+15 Stunden**; eine ganze Sonderschicht von 30 Stunden bringt deshalb 60 € statt der rechnerischen 120 €. **Die zweite Hälfte wäre bezahlt und wirkungslos.**
+* **Rüstzeiten, Reihenfolgen, Taktzeiten sind der Kern, nicht die Ausnahme.** [Kapitel 7](#kap-cpsat) modelliert Maschinenbelegung mit Intervallvariablen, [Kapitel 9](#kap-metaheuristiken) zeigt am selben Fall das Gesamtbild: Faustregel 2 497 Minuten Rüstzeit, CP-SAT allein 2 628, Simulated Annealing 2 343, Annealing plus LNS **2 289** — und die untere Schranke bei 1 768, damit sichtbar bleibt, wie viel Luft noch da ist.
+* **Wenn der Solver zu lange braucht, gibt es Zahlen statt Ratschläge.** [Abschnitt 7.7](#sec:cpsat-parallele-suche) misst, was mehrere Suchstränge bringen (hier Faktor 12,3) — und ab wo mehr Arbeiter wieder schaden.
+
+**Ihr Weg.** Pfad B bis [Kapitel 7](#kap-cpsat), dann Projekt **P5** (Produktionsplanung mit Rüstkosten). Wenn Ihre echten Instanzen den Solver stehen lassen: [Kapitel 9](#kap-metaheuristiken) und Projekt **P9**.
+
+**Woran es scheitert.** An der Verwechslung von *bindend* und *teuer*. Eine Bedingung kann den Plan berühren und trotzdem **nichts** kosten — im Beispiel von [Abschnitt 22.4](#sec:praxisfallen-attribution) gilt das für eine von fünf bindenden. Wer sie nachverhandelt, gewinnt nichts und hält das Verfahren für nutzlos.
+
+### Für Investoren und Finanzanalysten — Risiko und Ertrag {-}
+
+> *„Die Optimierung liefert mir Gewichte, die kein Mensch halten würde: 60 % in einem Titel, null in fünf anderen. Und im nächsten Quartal sieht sie völlig anders aus.“*
+
+* **Der Grund dafür steht in [Kapitel 18](#kap-finanzdaten), nicht in [Kapitel 19](#kap-markowitz).** Eine aus kurzen Zeitreihen geschätzte Kovarianzmatrix ist schlecht konditioniert; der Optimierer setzt dann auf Schätzrauschen. Shrinkage nach Ledoit-Wolf ist das Gegenmittel; ihre Wirkung wird an **Eigenwertspektrum und Konditionszahl** gemessen, nicht behauptet.
+* **Der VaR verschweigt genau das, worauf es ankommt.** In der Stichprobe aus [Kapitel 20](#kap-cvar) sagt der VaR: „an 95 % der Tage höchstens **1,86 %** Verlust“. Der CVaR sagt: „und wenn doch, dann im Mittel **2,99 %**“. Der schlechteste Tag der Stichprobe liegt bei **−23,0 %** — am VaR ändert dieser eine Tag **nichts**, am CVaR sehr wohl. Deshalb ist der CVaR die Größe, die man optimiert.
+* **Transaktionskosten und Rebalancing sind Teil des Modells, nicht ein Abzug danach.** [Kapitel 20](#kap-cvar) nimmt sie in die Zielfunktion, [Kapitel 21](#kap-handelsmaschine) setzt den Backtest daneben — samt der Fallen, die einen guten Backtest wertlos machen.
+
+**Ihr Weg.** Pfad D, und zwar **mit** [Kapitel 18](#kap-finanzdaten). Danach Projekt **P6** (Portfolio-Rebalancer) oder **P7** (Risikoreport mit CVaR und Stresstests).
+
+**Woran es scheitert.** An der Reihenfolge. Wer bei Markowitz einsteigt und die Datenkapitel überspringt, bekommt ein Modell, das seine eigenen Schätzfehler maximiert — und merkt es erst im Echtgeldbetrieb.
+
+### Für Studierende und Data Scientists — die Methodik {-}
+
+> *„Ich kann ein Modell trainieren und den Fehler senken. Aber wie wird aus einer Prognose eine Entscheidung — und woher weiß ich, dass sie gut ist?“*
+
+* **Die unbequemste Erkenntnis zuerst.** [Kapitel 15](#kap-prognose) zeigt an einem gerechneten Fall, dass das Modell mit dem **schlechteren** MSE die **günstigere** Entscheidung trifft. Prognosegüte und Entscheidungsqualität sind zwei verschiedene Größen; wer die eine optimiert, bekommt die andere nicht geschenkt.
+* **Dieselbe Mathematik, zwei Welten.** [Kapitel 16](#kap-bruecke) lässt **denselben Code** einmal über eine Werkstatt und einmal über ein Depot laufen — und benennt die drei Stellen, an denen die Analogie endet. Struktur zu erkennen ist die eigentliche Fähigkeit, nicht Bibliothekskenntnis; zu wissen, wo eine Analogie aufhört, gehört dazu.
+* **Es wird gerechnet, nicht nacherzählt.** Zu jedem Kapitel gehören Aufgaben mit vollständigen Lösungen, Handrechnungen und ein „Finde den Denkfehler“ — und jedes abgedruckte Ergebnis stammt aus einem echten Lauf des danebenstehenden Programms.
+
+**Ihr Weg.** Pfad A, wenn Sie Zeit haben. Sonst Pfad B oder D bis zum ersten Projekt und von dort zurück in die Grundlagen. Für eigene Fragestellungen: Projekt **P8**.
+
+**Woran es scheitert.** An der Annahme, ein Solver sei eine Bibliothek wie jede andere. Die schwierige Arbeit steckt in der Formulierung — [Kapitel 4](#kap-modellierung) ist deshalb kein Vorgeplänkel, sondern das Kapitel, auf das alle anderen aufbauen.
+
+---
+
 ## Lernpfade {-}
 
 Sie müssen nicht alles lesen, um etwas Nützliches bauen zu können.
@@ -298,7 +356,7 @@ Sie müssen nicht alles lesen, um etwas Nützliches bauen zu können.
 
 ### Pfad E — Ich habe morgen ein konkretes Problem (2–4 Stunden) {-}
 
-Lesen Sie [Abschnitt 1.5](#sec:einfuehrung-historischer-kontext-und-evolution) (die vier Bausteine), dann [Anhang B](#anhang-modellierungsmuster) (**Modellierungsmuster**) und suchen Sie dort das Muster, das zu Ihrem Problem passt. Von jedem Muster führt ein Verweis in das zuständige Kapitel. Wie die gewählte Bibliothek es schreibt, steht in [Anhang D](#anhang-spickzettel) (**Spickzettel**); wenn etwas nicht läuft, in [Anhang C](#anhang-fehlerdiagnose) (**Fehlerdiagnose**).
+Lesen Sie [Abschnitt 1.5](#sec:einfuehrung-historischer-kontext-und-evolution) (die vier Bausteine) und [Abschnitt 4.6](#sec:modellierung-glossar) (welcher Satz welcher Baustein ist), dann [Anhang B](#anhang-modellierungsmuster) (**Modellierungsmuster**) und suchen Sie dort das Muster, das zu Ihrem Problem passt. Von jedem Muster führt ein Verweis in das zuständige Kapitel. Wie die gewählte Bibliothek es schreibt, steht in [Anhang D](#anhang-spickzettel) (**Spickzettel**); wenn etwas nicht läuft, in [Anhang C](#anhang-fehlerdiagnose) (**Fehlerdiagnose**).
 
 ### Pfad F — Vom Prototyp in den Betrieb (ca. 15 Stunden) {-}
 
@@ -341,6 +399,7 @@ Alle Beispielprogramme dieses Buchs im Überblick, sortiert nach Kapitel — pra
 | `Propagation_Demo.py` | Propagation messbar | [Kapitel 7](#kap-cpsat) |
 | `CP_SAT_Vertretungssystem.py` | Vertretungsplan | [Kapitel 7](#kap-cpsat) |
 | `JobShop_Intervalle.py` | Job-Shop-Scheduling | [Kapitel 7](#kap-cpsat) |
+| `Parallele_Suche.py` | num_workers: Tempo gegen Reproduzierbarkeit | [Kapitel 7](#kap-cpsat) |
 | `CP_SAT_Statusfaelle.py` | Die fünf Solver-Antworten | [Kapitel 7](#kap-cpsat) |
 | `Strafgewichte.py` | Gewichte als Wechselkurse | [Kapitel 7](#kap-cpsat) |
 | `Min_Cost_Flow.py` | Netzwerkfluss | [Kapitel 8](#kap-graphen) |
@@ -380,6 +439,7 @@ Alle Beispielprogramme dieses Buchs im Überblick, sortiert nach Kapitel — pra
 | `Data_Snooping.py` | Bestes aus N Versuchen auf Rauschen | [Kapitel 21](#kap-handelsmaschine) |
 | `Infeasibility_Diagnose.py` | Notfallplan statt Fehler | [Kapitel 22](#kap-praxisfallen) |
 | `Erklaerbarkeit.py` | Constraint-Trace, Was-wäre-wenn | [Kapitel 22](#kap-praxisfallen) |
+| `Constraint_Attribution.py` | Was kostet welche Bedingung? Managementbericht | [Kapitel 22](#kap-praxisfallen) |
 | `Betriebsueberwachung.py` | Status, Gap und Zeitausschöpfung | [Kapitel 22](#kap-praxisfallen) |
 | `or_kern.py` | Gemeinsamer Unterbau: Domäne, Status, Prüfung | [Kapitel 22](#kap-praxisfallen) |
 | `Solverwechsel_CPSAT_HiGHS.py` | Derselbe Fall in zwei Solvern | [Kapitel 22](#kap-praxisfallen) |
@@ -1086,7 +1146,7 @@ Damit die Zerlegung zur Gewohnheit wird, hier eine Vorlage, die Sie bei jedem ne
 > * **Harte Bedingungen:** $0{,}5x_1 + 0{,}6x_2 \le 90$ (Mehl); $4x_1 + 3x_2 \le 600$ (Ofen); $x_1 \ge 40$ (Vertrag).
 > * **Weiche Bedingungen:** keine.
 >
-> Dieses Problem lösen Sie in Übung 1.5 selbst.
+> Dieses Problem lösen Sie in der Aufgabe *Die Bäckerei programmieren* ([Abschnitt 1.9](#sec:einfuehrung-uebungsaufgaben)) selbst.
 
 Die Vorlage lässt sich fast wörtlich in Code übersetzen — wer die fünf Zeilen ausgefüllt hat, hat den größten Teil der Modellierungsarbeit schon erledigt:
 
@@ -1408,7 +1468,7 @@ Das Ergebnis deckt sich mit der Handrechnung *Das Optimum zu Fuß finden* — ei
 
 > **📎 Warum dieses Programm alles selbst macht**
 >
-> Wenige Seiten weiter, in der Excel-Brücke, steht ein Programm, das mit 96 Zeilen auskommt, weil es die immer gleichen Arbeitsschritte aus dem gemeinsamen Modul `or_kern.py` bezieht ([Abschnitt 22.5](#sec:praxisfallen-or-kern)). Warum tut `Bot_Allokation.py` das nicht auch?
+> Wenige Seiten weiter, in der Excel-Brücke, steht ein Programm, das mit 96 Zeilen auskommt, weil es die immer gleichen Arbeitsschritte aus dem gemeinsamen Modul `or_kern.py` bezieht ([Abschnitt 22.6](#sec:praxisfallen-or-kern)). Warum tut `Bot_Allokation.py` das nicht auch?
 >
 > Weil es hier nicht darum geht, **wenig Code** zu schreiben, sondern darum zu sehen, wie ein Modell **entsteht**: Variablen, Nebenbedingungen, Zielfunktion, Status, Prüfung — jeder Schritt einzeln und sichtbar. Eine Abstraktion, die diese Schritte zusammenfasst, ist genau dann ein Gewinn, wenn man sie schon einmal von Hand gegangen ist; vorher versteckt sie nur, was man verstehen will.
 >
@@ -1438,7 +1498,7 @@ Das folgende Programm zeigt den ganzen Weg an einem Stück. Es legt die Eingabem
 
 > **📎 Zum Modul `or_kern.py`**
 >
-> Die vier Arbeitsschritte — lesen, lösen, prüfen, schreiben — stehen nicht in diesem Programm, sondern in `or_kern.py`. Das ist ein gemeinsamer Unterbau, den alle Programme dieses Buchs benutzen können; er liegt im selben Verzeichnis und ist in [Abschnitt 22.5](#sec:praxisfallen-or-kern) vollständig abgedruckt und erklärt.
+> Die vier Arbeitsschritte — lesen, lösen, prüfen, schreiben — stehen nicht in diesem Programm, sondern in `or_kern.py`. Das ist ein gemeinsamer Unterbau, den alle Programme dieses Buchs benutzen können; er liegt im selben Verzeichnis und ist in [Abschnitt 22.6](#sec:praxisfallen-or-kern) vollständig abgedruckt und erklärt.
 >
 > Sie müssen ihn jetzt noch nicht verstehen. Wichtig ist nur die Aufteilung: **Hier** steht, was diesen Fall ausmacht — dort steht, was jedes Optimierungsprogramm braucht. Genau deshalb ist der Code unten so kurz.
 
@@ -1605,7 +1665,7 @@ Ergebnis geschrieben nach: produktionsmix_ergebnis.xlsx
 
 Ein Programm, das abstürzt, ist harmlos — Sie sehen sofort, dass etwas nicht stimmt. Gefährlich sind Programme, die fehlerfrei durchlaufen, einen Status `OPTIMAL` melden und eine Zahl liefern, die betriebswirtschaftlich Unsinn ist. Genau solche Fälle üben wir hier.
 
-> **🐛 Finde den Denkfehler 1.1: Die Schreinerei verdoppelt ihren Gewinn**
+> **🐛 Finde den Denkfehler: Die Schreinerei verdoppelt ihren Gewinn**
 >
 > Eine Kollegin hat das Schreinerei-Modell aus dem Kapitelanfang leicht umgebaut — sie fand die Schleife übersichtlicher als zwei einzelne `Add`-Aufrufe. Das Programm läuft, der Solver meldet `OPTIMAL`, und der Deckungsbeitrag ist plötzlich **18 600 €** statt 10 800 €. Der Chef ist begeistert. Sollte er das sein?
 >
@@ -2733,7 +2793,7 @@ und runden Sie Solver-Ergebnisse NIE ohne Toleranzpruefung.
 
 ## 2.9 Finde den Denkfehler {#sec:fundament-denkfehler}
 
-> **🐛 Finde den Denkfehler 2.1: Die unauffällige Transposition**
+> **🐛 Finde den Denkfehler: Die unauffällige Transposition**
 >
 > Ein Kollege überträgt ein Produktionsmodell in Matrixform. Zwei Produkte, zwei Ressourcen — die Technologiematrix ist quadratisch:
 >
@@ -3067,6 +3127,21 @@ $$
 >
 > Der Installationstest im Vorspann umgeht die Falle bereits: Er lädt `ortools` zuerst, prüft `highspy` und `cvxpy` in der Paketübersicht nur auf Anwesenheit (`importlib.util.find_spec`) und importiert CVXPY erst im Funktionstest.
 
+### Wie die Isolation aussieht, wenn sie tragen soll
+
+„Eigener Prozess" ist schnell gesagt. Die naheliegende Umsetzung — ein Codeschnipsel als Zeichenkette an `python -c` übergeben — funktioniert und ist trotzdem die schlechteste: Der Schnipsel ist für Editor, Linter und Testwerkzeug unsichtbar, ein Tippfehler darin fällt erst zur Laufzeit auf, und übergeben lassen sich nur Zeichenketten.
+
+Tragfähig ist stattdessen: **jeder Solver eine gewöhnliche Funktion mit lokalem Import**, ausgeführt von einem `ProcessPoolExecutor` mit zwei Einstellungen, die zusammen die Garantie ergeben:
+
+| Einstellung | Wozu |
+| --- | --- |
+| `mp_context=multiprocessing.get_context("spawn")` | Der Kindprozess startet mit einem **frischen** Interpreter, statt den Speicher des Elternprozesses zu erben. Unter Linux ist `fork` der Standard — und damit wäre alles, was hier schon importiert ist, auch dort importiert. |
+| `max_tasks_per_child=1` | Jede Aufgabe bekommt einen **neuen** Prozess. Ohne das verwendet der Pool seinen Arbeiter wieder, und beim zweiten Solver ist der Konflikt zurück. Genau dieser Fehler ist leicht zu machen und schwer zu finden. |
+
+> **⚠️ `max_tasks_per_child=1` ist nicht optional** Ein Pool ohne diese Angabe ist der **Normalfall** — er soll seine Arbeiter ja wiederverwenden. Wer die Isolation über einen Pool herstellt und das vergisst, hat einen Prozesswechsel programmiert, aber keine Isolation gewonnen: Die zweite Aufgabe landet im selben Interpreter wie die erste. Der Absturz kommt dann nicht beim ersten Solver, sondern beim zweiten — und sieht aus wie ein Problem des zweiten.
+
+Denselben Aufbau verwenden `Solverwechsel_CPSAT_HiGHS.py` ([Kapitel 22](#kap-praxisfallen)) und `Benchmark_Skalierung.py` ([Kapitel 23](#kap-testing)). Dort wandern zusätzlich **Datenobjekte** über die Prozessgrenze statt Zeichenketten — möglich, weil Domänenmodell und Lösungs-DTO keinen Solver kennen ([Abschnitt 22.6](#sec:praxisfallen-or-kern)).
+
 ```python
 #!/usr/bin/env python3
 
@@ -3078,85 +3153,104 @@ Kapitel Oekosystem: Dasselbe LP in vier Bibliotheken.
           2*x1 + 3*x2 + x3 <= 50
           x >= 0
 
-Deckt scipy.optimize, highspy, CVXPY und OR-Tools/GLOP ab, mit Kreuzvergleich am Ende.
+Deckt scipy.optimize, highspy, CVXPY und OR-Tools/GLOP ab, mit Kreuzvergleich
+am Ende.
 
-WICHTIG: Jeder Solver läuft in einem EIGENEN Prozess, weil sich ortools und
+WICHTIG: Jeder Solver laeuft in einem EIGENEN Prozess, weil sich ortools und
 highspy auf vielen Systemen nicht gemeinsam importieren lassen (beide bringen
 eine eigene HiGHS-Kopie mit -> Symbolkonflikt).
+
+Die Isolation besorgt ein ProcessPoolExecutor. Drei Einstellungen ergeben
+zusammen die Garantie:
+
+  mp_context "spawn"     Der Kindprozess startet mit einem FRISCHEN
+                         Interpreter, statt den Speicher des Elternprozesses
+                         zu erben. Was hier schon importiert ist, ist dort
+                         nicht importiert. Mit dem Standard "fork" auf Linux
+                         waere das nicht so.
+  max_tasks_per_child=1  Jede Aufgabe bekommt einen NEUEN Prozess. Ohne das
+                         wuerde der Pool seinen Arbeiter wiederverwenden - und
+                         beim zweiten Solver waere der Konflikt zurueck.
+  max_workers=1          Haelt die vier Laeufe nacheinander. Nicht aus
+                         Vorsicht, sondern damit die gemessenen Zeiten
+                         vergleichbar bleiben.
+
+Jeder Solver steht in einer eigenen Funktion mit LOKALEM Import. Das ist der
+Unterschied zu einem Codestring, den man an 'python -c' uebergibt: Die
+Funktion laesst sich einzeln aufrufen, testen und vom Editor pruefen - ein
+String nicht.
+
+Benoetigt: scipy, highspy, cvxpy, ortools
 """
 
-import json
-import subprocess
-import sys
-import textwrap
+import multiprocessing
 import time
+from concurrent.futures import ProcessPoolExecutor
 
 ERWARTET = 530.0            # Ergebnis der Handrechnung zum Produktionsprogramm
 
-# Jeder Eintrag ist ein eigenständiges Miniprogramm, das sein Ergebnis als
-# JSON auf stdout ausgibt. So bleibt jeder Import in seinem eigenen Prozess.
-ANSAETZE: dict[str, str] = {
+# Die Instanz - einmal notiert, von allen vier Funktionen benutzt.
+ZIEL = [10.0, 15.0, 25.0]
+MATRIX = [[1, 1, 2], [2, 3, 1]]
+KAPAZITAET = [40.0, 50.0]
 
-    "scipy.optimize.linprog": """
-        from scipy.optimize import linprog
-        res = linprog(c=[-10.0, -15.0, -25.0],           # linprog MINIMIERT -> negieren
-                      A_ub=[[1, 1, 2], [2, 3, 1]], b_ub=[40, 50],
-                      bounds=[(0, None)] * 3, method="highs")
-        ausgabe = (-res.fun, list(res.x))
-    """,
 
-    "highspy (natives HiGHS)": """
-        import numpy as np, highspy
-        h = highspy.Highs()
-        h.setOptionValue("output_flag", False)
-        h.addVars(3, np.zeros(3), np.full(3, highspy.kHighsInf))
-        h.changeObjectiveSense(highspy.ObjSense.kMaximize)
-        for j, wert in enumerate([10.0, 15.0, 25.0]):
-            h.changeColCost(j, wert)
-        # CSR-Format: starts[i] = Beginn von Zeile i in indices/values
-        h.addRows(2, np.full(2, -highspy.kHighsInf), np.array([40.0, 50.0]), 6,
-                  np.array([0, 3], dtype=np.int32),
-                  np.array([0, 1, 2, 0, 1, 2], dtype=np.int32),
-                  np.array([1.0, 1.0, 2.0, 2.0, 3.0, 1.0]))
-        h.run()
-        ausgabe = (h.getInfo().objective_function_value,
-                   list(h.getSolution().col_value[:3]))
-    """,
+def loese_mit_scipy() -> tuple[float, list[float]]:
+    from scipy.optimize import linprog
+    ergebnis = linprog(c=[-w for w in ZIEL],          # linprog MINIMIERT -> negieren
+                       A_ub=MATRIX, b_ub=KAPAZITAET,
+                       bounds=[(0, None)] * 3, method="highs")
+    return -ergebnis.fun, list(ergebnis.x)
 
-    "cvxpy": """
-        import numpy as np, cvxpy as cp
-        x = cp.Variable(3, nonneg=True)
-        problem = cp.Problem(cp.Maximize(np.array([10.0, 15.0, 25.0]) @ x),
-                             [np.array([[1, 1, 2], [2, 3, 1]]) @ x <= np.array([40, 50])])
-        problem.solve()
-        ausgabe = (float(problem.value), [float(v) for v in x.value])
-    """,
 
-    "ortools / GLOP": """
-        from ortools.linear_solver import pywraplp
-        s = pywraplp.Solver.CreateSolver("GLOP")
-        x = [s.NumVar(0, s.infinity(), f"x{j+1}") for j in range(3)]
-        A = [[1, 1, 2], [2, 3, 1]]
-        for i, kap in enumerate([40, 50]):
-            s.Add(sum(A[i][j] * x[j] for j in range(3)) <= kap)
-        s.Maximize(10 * x[0] + 15 * x[1] + 25 * x[2])
-        s.Solve()
-        ausgabe = (s.Objective().Value(), [v.solution_value() for v in x])
-    """,
+def loese_mit_highspy() -> tuple[float, list[float]]:
+    import highspy
+    import numpy as np
+    h = highspy.Highs()
+    h.setOptionValue("output_flag", False)
+    h.addVars(3, np.zeros(3), np.full(3, highspy.kHighsInf))
+    h.changeObjectiveSense(highspy.ObjSense.kMaximize)
+    for j, wert in enumerate(ZIEL):
+        h.changeColCost(j, wert)
+    # CSR-Format: starts[i] = Beginn von Zeile i in indices/values
+    h.addRows(2, np.full(2, -highspy.kHighsInf), np.array(KAPAZITAET), 6,
+              np.array([0, 3], dtype=np.int32),
+              np.array([0, 1, 2, 0, 1, 2], dtype=np.int32),
+              np.array([float(w) for zeile in MATRIX for w in zeile]))
+    h.run()
+    return (h.getInfo().objective_function_value,
+            list(h.getSolution().col_value[:3]))
+
+
+def loese_mit_cvxpy() -> tuple[float, list[float]]:
+    import cvxpy as cp
+    import numpy as np
+    x = cp.Variable(3, nonneg=True)
+    problem = cp.Problem(cp.Maximize(np.array(ZIEL) @ x),
+                         [np.array(MATRIX) @ x <= np.array(KAPAZITAET)])
+    problem.solve()
+    return float(problem.value), [float(v) for v in x.value]
+
+
+def loese_mit_ortools() -> tuple[float, list[float]]:
+    from ortools.linear_solver import pywraplp
+    s = pywraplp.Solver.CreateSolver("GLOP")
+    x = [s.NumVar(0, s.infinity(), f"x{j+1}") for j in range(3)]
+    for i, kapazitaet in enumerate(KAPAZITAET):
+        s.Add(sum(MATRIX[i][j] * x[j] for j in range(3)) <= kapazitaet)
+    s.Maximize(sum(ZIEL[j] * x[j] for j in range(3)))
+    s.Solve()
+    return s.Objective().Value(), [v.solution_value() for v in x]
+
+
+ANSAETZE = {
+    "scipy.optimize.linprog": loese_mit_scipy,
+    "highspy (natives HiGHS)": loese_mit_highspy,
+    "cvxpy": loese_mit_cvxpy,
+    "ortools / GLOP": loese_mit_ortools,
 }
 
 
-def fuehre_in_eigenem_prozess_aus(quelltext: str) -> tuple[float, list[float]]:
-    """Startet den Codeschnipsel als separaten Python-Prozess und liest das Ergebnis."""
-    programm = textwrap.dedent(quelltext) + "\nimport json; print(json.dumps(ausgabe))\n"
-    ergebnis = subprocess.run([sys.executable, "-c", programm],
-                              capture_output=True, text=True, timeout=120)
-    if ergebnis.returncode != 0:
-        raise RuntimeError(ergebnis.stderr.strip().splitlines()[-1])
-    wert, loesung = json.loads(ergebnis.stdout.strip().splitlines()[-1])
-    return wert, loesung
-
-
 if __name__ == "__main__":
     print("=" * 78)
     print("  EIN SYSTEM - VIER ANSAETZE (je eigener Prozess)")
@@ -3165,17 +3259,23 @@ if __name__ == "__main__":
     print("-" * 78)
 
     werte = []
-    for name, quelltext in ANSAETZE.items():
-        t0 = time.perf_counter()
-        try:
-            wert, x = fuehre_in_eigenem_prozess_aus(quelltext)
-        except RuntimeError as fehler:
-            print(f"{name:<26} nicht verfuegbar: {fehler[:40]}")
-            continue
-        dauer = time.perf_counter() - t0
-        werte.append(wert)
-        print(f"{name:<26} {wert:>10.2f} {x[0]:>7.2f} {x[1]:>7.2f} {x[2]:>7.2f} "
-              f"{dauer:>8.2f} s")
+    # Ein Pool, vier Aufgaben, vier frische Prozesse. Der Kontext muss
+    # "spawn" sein - siehe Modulkommentar.
+    with ProcessPoolExecutor(
+            max_workers=1,
+            mp_context=multiprocessing.get_context("spawn"),
+            max_tasks_per_child=1) as pool:
+        for name, funktion in ANSAETZE.items():
+            beginn = time.perf_counter()
+            try:
+                wert, x = pool.submit(funktion).result(timeout=120)
+            except Exception as fehler:                     # Bibliothek fehlt o. Ae.
+                print(f"{name:<26} nicht verfuegbar: {str(fehler)[:40]}")
+                continue
+            dauer = time.perf_counter() - beginn
+            werte.append(wert)
+            print(f"{name:<26} {wert:>10.2f} {x[0]:>7.2f} {x[1]:>7.2f} {x[2]:>7.2f} "
+                  f"{dauer:>8.2f} s")
 
     print("-" * 78)
     spanne = max(werte) - min(werte)
@@ -3185,8 +3285,8 @@ if __name__ == "__main__":
     assert spanne < 1e-6, "Die Bibliotheken widersprechen sich!"
     assert abs(werte[0] - ERWARTET) < 1e-6, "Ergebnis weicht von der Handrechnung ab!"
     print("Alle Wege fuehren zum selben, von Hand bestaetigten Optimum.")
-    print("(Die Zeiten enthalten den Prozessstart und den Import - sie messen")
-    print(" NICHT die reine Solverleistung, siehe Uebung 3.5.)")
+    print("(Die Zeiten enthalten Prozessstart und Import - sie messen NICHT die")
+    print(" reine Solverleistung. Die Uebungsaufgabe 'Laufzeitvergleich' trennt beides.)")
     print("=" * 78)
 ```
 
@@ -3198,16 +3298,16 @@ if __name__ == "__main__":
 ==============================================================================
 Bibliothek                         Z*      x1      x2      x3       Zeit
 ------------------------------------------------------------------------------
-scipy.optimize.linprog         530.00    0.00   12.00   14.00     0.55 s
-highspy (natives HiGHS)        530.00    0.00   12.00   14.00     0.17 s
-cvxpy                          530.00    0.00   12.00   14.00     1.52 s
-ortools / GLOP                 530.00    0.00   12.00   14.00     0.09 s
+scipy.optimize.linprog         530.00    0.00   12.00   14.00     0.59 s
+highspy (natives HiGHS)        530.00    0.00   12.00   14.00     0.12 s
+cvxpy                          530.00    0.00   12.00   14.00     1.24 s
+ortools / GLOP                 530.00    0.00   12.00   14.00     0.33 s
 ------------------------------------------------------------------------------
 Spannweite zwischen den Bibliotheken: 2.41e-08
 Abweichung zur Handrechnung (530):        0.00e+00
 Alle Wege fuehren zum selben, von Hand bestaetigten Optimum.
-(Die Zeiten enthalten den Prozessstart und den Import - sie messen
- NICHT die reine Solverleistung, siehe Uebung 3.5.)
+(Die Zeiten enthalten Prozessstart und Import - sie messen NICHT die
+ reine Solverleistung. Die Uebungsaufgabe 'Laufzeitvergleich' trennt beides.)
 ==============================================================================
 ```
 
@@ -3836,7 +3936,7 @@ Groesse                    Variante                      Aufbau    Loesen  Aufba
 
 ## 3.10 Finde den Denkfehler {#sec:oekosystem-denkfehler}
 
-> **🐛 Finde den Denkfehler 3.1: Der Solver, der angeblich dreimal schneller ist**
+> **🐛 Finde den Denkfehler: Der Solver, der angeblich dreimal schneller ist**
 >
 > Ein Team vergleicht zwei Bibliotheken für sein Zuordnungsproblem und schreibt ins Protokoll: *„CVXPY braucht 1,9 s, SciPy nur 0,6 s — wir setzen auf SciPy.“* Gemessen wurde so:
 >
@@ -3988,6 +4088,7 @@ Nach diesem Kapitel können Sie …
 3. … erkennen, dass ein Satz wie „Stammkunden dürfen wir nicht verlieren" mehrere Lesarten hat, und den Unterschied in Euro beziffern.
 4. … begründen, wann eine Regel hart und wann sie weich sein muss — und was eine harte Regel im Betrieb anrichtet, wenn sie einmal nicht erfüllbar ist.
 5. … einen Kennzahlen-Fehlanreiz benennen, bevor er in die Zielfunktion gerät.
+6. … einen Satz aus einer Besprechung in den passenden Modellierungsbaustein übersetzen — und die fünf Wendungen erkennen, bei denen genau das nicht geht, ohne vorher nachzufragen.
 
 ---
 
@@ -4411,7 +4512,7 @@ Dieselbe Regel als Strafkosten je abgelehntem Stammkundenauftrag:
 
 Bei 3 000 € ändert sich **nichts**: Die Strafe liegt unter dem Deckungsbeitrag, den die Stammkundenaufträge verdrängen würden. Bei 10 000 € kommt genau Lesart A heraus.
 
-Daraus folgt eine Einsicht, die das Modellieren erleichtert: **Eine harte Regel ist eine weiche mit hinreichend großer Strafe.** Man kann also immer weich anfangen und die Strafe hochdrehen, bis die Regel greift — und sieht dabei, was sie kostet. Was ein Strafgewicht darüber hinaus bedeutet und warum zwei Gewichte einen *Wechselkurs* festlegen und keine Wichtigkeiten, steht in [Abschnitt 7.9](#sec:cpsat-denkfehler).
+Daraus folgt eine Einsicht, die das Modellieren erleichtert: **Eine harte Regel ist eine weiche mit hinreichend großer Strafe.** Man kann also immer weich anfangen und die Strafe hochdrehen, bis die Regel greift — und sieht dabei, was sie kostet. Was ein Strafgewicht darüber hinaus bedeutet und warum zwei Gewichte einen *Wechselkurs* festlegen und keine Wichtigkeiten, steht in [Abschnitt 7.10](#sec:cpsat-denkfehler).
 
 ### Teil 4: Ein Quartal später
 
@@ -4460,7 +4561,68 @@ Was aus den vier Teilen als Handwerkszeug bleibt — Fragen, die man in der erst
 
 ---
 
-## 4.6 Übungsaufgaben {#sec:modellierung-uebungsaufgaben}
+## 4.6 Deutsch — OR: ein Übersetzungslexikon {#sec:modellierung-glossar}
+
+Die zwölf Fragen liefern Sätze. Sätze sind noch kein Modell — aber die meisten von ihnen haben eine **Standardübersetzung**, und wer sie kennt, spart sich das Nachdenken für die Fälle, in denen es keine gibt.
+
+Die Tabelle liest sich von links nach rechts: Was in der Besprechung **gesagt** wird, was es **bedeutet**, und welcher **Baustein** daraus wird. Die B-Nummern verweisen auf [Anhang B](#anhang-modellierungsmuster), wo jedes Muster mit Formulierung und Code steht.
+
+| Was gesagt wird | Was gemeint ist | Baustein |
+| --- | --- | --- |
+| „Wir haben nur 400 Stunden." | eine Obergrenze, die nicht überschritten werden darf | harte Kapazitätsgrenze $\le b$ ([Kapitel 5](#kap-lp)) |
+| „Mehr als zwei Millionen gibt es nicht." | dasselbe, auf Geld | Budgetlimit (B27) |
+| „Möglichst nicht über 40 Stunden." | eine Grenze, die im Notfall gebrochen werden darf | weiche Grenze mit Strafkosten (B8) |
+| „Wir können nur ganze Kisten liefern." | die Menge ist nicht teilbar | Ganzzahligkeitsbedingung ([Kapitel 6](#kap-milp)) |
+| „Wenn wir die Anlage nutzen, fallen Fixkosten an." | Kosten, die erst ab der ersten Einheit anfallen | Aktivierungsschalter (B1) |
+| „Entweder gar nicht oder mindestens 50." | kein Betrieb im Kleinen | semikontinuierliche Variable (B2) |
+| „Wenn wir A bauen, brauchen wir auch B." | eine Folgeverpflichtung | Implikation (B3) |
+| „Höchstens drei Positionen im Depot." | eine Obergrenze auf die **Anzahl**, nicht die Menge | Kardinalität (B6) |
+| „Der Anteil muss mindestens 30 % betragen." | eine Bedingung auf ein **Verhältnis** | Verhältnis-Bedingung (B12) |
+| „Jeder Auftrag genau einem Mitarbeiter." | eine vollständige, eindeutige Zuordnung | Zuordnung 1:1 (B23) |
+| „Eine Maschine kann nur eines gleichzeitig." | zeitliche Ausschließlichkeit | Nichtüberlappung (B14) |
+| „B kann erst nach A." | eine Reihenfolge | Vorrangbeziehung (B13) |
+| „Höchstens fünf Tage am Stück." | eine Bedingung über ein **gleitendes Fenster** | gleitendes Fenster (B16) |
+| „Umstellen kostet uns eine halbe Stunde." | reihenfolgeabhängige Kosten | Umrüstkosten (B17), Rüstzeit als Kapazität (B26) |
+| „Was reinkommt, muss auch wieder raus." | Erhaltung an jedem Knoten | Flusserhaltung (B22) |
+| „Notfalls brechen wir die Regel." | die Bedingung ist weich, aber teuer | Schlupfvariablen (B18) |
+| „Erst Termintreue, dann Kosten." | eine Rangfolge zwischen Zielen | hierarchische Ziele (B19) |
+| „Es soll gerecht zugehen." | den Schlechtestgestellten verbessern | Min/Max in der Zielfunktion (B11) |
+| „Was brächte uns eine zusätzliche Stunde?" | die Frage nach dem Grenzwert einer Ressource | Schattenpreis ([Kapitel 5](#kap-lp), [Abschnitt 22.4](#sec:praxisfallen-attribution)) |
+| „Mit 95 % Sicherheit muss es halten." | eine Zusage auf eine **Quote**, nicht auf einen Mittelwert | Chance Constraint ([Abschnitt 12.7](#sec:unsicherheit-chance-constraints)) |
+| „Wir sichern uns gegen Schätzfehler ab." | gegen die ungünstigste Parameterlage planen | Worst-Case-Abzug (B21) |
+
+### Fünf Wendungen, bei denen die Übersetzung eine Entscheidung erzwingt
+
+Die Tabelle oben tut so, als sei die Zuordnung eindeutig. Bei den folgenden fünf ist sie es nicht — und **das Nachfragen ist die eigentliche Modellierungsarbeit**:
+
+| Wendung | Die Frage, die dahinter steckt |
+| --- | --- |
+| **„möglichst"** | Hart oder weich? Und wenn weich: Was darf ein Verstoß kosten? Ohne Zahl ist „möglichst" keine Bedingung, sondern eine Stimmung. |
+| **„nicht mehr als drei pro Woche"** | Je Person oder über alle zusammen? Kalenderwoche oder gleitende sieben Tage? Beide Lesarten sind vertretbar und ergeben verschiedene Modelle. |
+| **„im Durchschnitt"** | Fast immer eine Falle. Der Durchschnittskunde kauft nie — siehe [Abschnitt 12.3](#sec:unsicherheit-der-fluch-des-durchschnitts). Gemeint ist meist ein Quantil („in 9 von 10 Fällen"). |
+| **„so schnell wie möglich"** | Welche Zahl? Ende des letzten Auftrags, Summe aller Fertigstellungszeiten oder größte Verspätung? Drei Zielfunktionen, drei verschiedene Pläne. |
+| **„fair"** | Den Schlechtesten verbessern, die Spannweite verkleinern oder gleiche Anteile erzwingen? Erst die Wahl macht daraus ein Modell — und sie gehört dem Betrieb, nicht dem Modellierer. |
+
+> **🎯 Der Nutzen dieser Liste** Sie ersetzt kein Nachdenken. Sie sorgt dafür, dass das Nachdenken an den **richtigen** vier oder fünf Stellen stattfindet, statt an allen zwanzig gleichzeitig.
+
+### Und die Gegenrichtung: OR — Deutsch
+
+Dieselbe Barriere gibt es rückwärts. Diese Sätze haben sich bewährt, wenn ein Ergebnis jemandem erklärt werden muss, der das Modell nicht kennt:
+
+| Fachbegriff | Was Sie in der Besprechung sagen |
+| --- | --- |
+| Schattenpreis / Dualwert | „Die nächste Stunde auf dieser Maschine wäre uns 9 € wert." |
+| bindende Bedingung mit Dualwert 0 | „Die Regel berührt den Plan, kostet uns aber nichts — dort zu verhandeln bringt nichts." |
+| `INFEASIBLE` | „Ihre Regeln widersprechen sich." **Nicht:** „Der Computer schafft es nicht." |
+| Optimalitätslücke von 2 % | „Besser als das hier geht es höchstens um 2 % — und die liegen unter unserer Datenungenauigkeit." |
+| CVaR | „Wenn es schiefgeht, verlieren wir im Mittel so viel." (Der VaR sagt nur, **ob** es schiefgeht.) |
+| EVPI | „Selbst eine perfekte Prognose wäre uns höchstens so viel wert." |
+| Relaxation | „Wir haben die Regel probeweise gelockert, um zu sehen, was sie kostet." |
+| Chance Constraint | „Der Plan hält in 95 von 100 Fällen — und der nächste Prozentpunkt kostet …" |
+
+---
+
+## 4.7 Übungsaufgaben {#sec:modellierung-uebungsaufgaben}
 
 > Lösungen: [Abschnitt A.4](#sec:loesungen-modellierung).
 
@@ -4472,11 +4634,13 @@ Was aus den vier Teilen als Handwerkszeug bleibt — Fragen, die man in der erst
 
 **Aufgabe 4.4 ⭐⭐ — Zwei Ziele gleichzeitig.** Maximieren Sie $\text{DB} + \lambda \cdot \text{Umsatz}$ für $\lambda \in \{0; 0{,}1; 0{,}3; 1\}$ und tragen Sie die Ergebnisse als Tabelle auf. Ab welchem $\lambda$ kippt der Plan von der DB- in die Umsatzlösung? Was sagt dieser Wert dem Betrieb?
 
-**Aufgabe 4.5 ⭐⭐⭐ — Die Anforderung schreiben.** Formulieren Sie für den Fall dieses Kapitels eine vollständige, prüfbare Anforderung: Ziel, harte Regeln, weiche Regeln mit Strafgewichten, Verhalten bei Unlösbarkeit, auszuweisende Kennzahlen. Zwei Seiten genügen — sie sind mehr wert als zwei Wochen Programmierung.
+**Aufgabe 4.5 ⭐⭐ — Übersetzen, wo es nicht eindeutig ist.** Übersetzen Sie mit [Abschnitt 4.6](#sec:modellierung-glossar): (a) „Die Monteure sollen möglichst gleichmäßig ausgelastet sein." Nennen Sie **drei** Zielfunktionen, die alle „gleichmäßig" bedeuten können, und je einen Fall, in dem die Wahl den Plan sichtbar ändert. (b) „Kein Kunde darf länger als drei Tage warten." Formulieren Sie die Bedingung einmal hart und einmal weich. Welche Frage müssen Sie dem Betrieb stellen, um zu entscheiden? (c) Suchen Sie in einer echten Anforderung aus Ihrem Umfeld einen Satz, der nach der Tabelle eindeutig aussieht, es aber nicht ist.
+
+**Aufgabe 4.6 ⭐⭐⭐ — Die Anforderung schreiben.** Formulieren Sie für den Fall dieses Kapitels eine vollständige, prüfbare Anforderung: Ziel, harte Regeln, weiche Regeln mit Strafgewichten, Verhalten bei Unlösbarkeit, auszuweisende Kennzahlen. Zwei Seiten genügen — sie sind mehr wert als zwei Wochen Programmierung.
 
 ---
 
-## 4.7 Finde den Denkfehler {#sec:modellierung-denkfehler}
+## 4.8 Finde den Denkfehler {#sec:modellierung-denkfehler}
 
 > **🐛 „Die Engpassmaschine soll zu mindestens 92 % ausgelastet sein"**
 >
@@ -4492,7 +4656,7 @@ Was aus den vier Teilen als Handwerkszeug bleibt — Fragen, die man in der erst
 
 ---
 
-## 4.8 Micro-Quiz {#sec:modellierung-quiz}
+## 4.9 Micro-Quiz {#sec:modellierung-quiz}
 
 > **❓ Drei Fragen**
 >
@@ -4504,7 +4668,7 @@ Was aus den vier Teilen als Handwerkszeug bleibt — Fragen, die man in der erst
 
 ---
 
-## 4.9 Selbsttest {#sec:modellierung-selbsttest}
+## 4.10 Selbsttest {#sec:modellierung-selbsttest}
 
 1. Warum ist „Was ist Ihnen wichtig?" eine schlechte Frage und „Welche Zahl steht im Jahresbericht?" eine gute?
 2. Nennen Sie zwei Kennzahlen aus Ihrem eigenen Arbeitsumfeld, deren Maximierung schaden würde.
@@ -4514,16 +4678,47 @@ Was aus den vier Teilen als Handwerkszeug bleibt — Fragen, die man in der erst
 
 ---
 
-## 4.10 Zusammenfassung {#sec:modellierung-zusammenfassung}
+## 4.11 Zusammenfassung {#sec:modellierung-zusammenfassung}
 
 * Ein Modell rechnet aus, was **aufgeschrieben** wurde, nicht was gemeint war. Die Zielfunktion ist eine vollständige Aussage: Was nicht darin steht, ist wertlos.
 * Die **Zielgröße** ist die folgenreichste Entscheidung eines OR-Projekts. Umsatz, Auslastung und Deckungsbeitrag führten hier auf demselben Datensatz zu drei verschiedenen Plänen mit 24 500 € Unterschied.
 * **Auslastung ist ein Ergebnis, kein Ziel.** Bei knapper Kapazität ist die Maschine ohnehin voll; entscheidend ist, womit.
 * Ein Satz aus einer Besprechung hat meist **mehrere Lesarten**. „Stammkunden nicht verlieren" kostete je nach Lesart 3 500 € oder 12 500 € — bei identischem Ergebnis für die Kunden.
 * **Hart ist nur, was rechtlich oder physikalisch unmöglich ist.** Eine harte Regel ist eine weiche mit hinreichend großer Strafe; der Unterschied zeigt sich erst, wenn sie einmal nicht erfüllbar ist — dann liefert die harte Variante gar nichts mehr.
+* **Die meisten Sätze haben eine Standardübersetzung** — das Lexikon in [Abschnitt 4.6](#sec:modellierung-glossar) nennt sie. Sein Wert liegt aber in den fünf Wendungen, bei denen es keine gibt: „möglichst", „nicht mehr als", „im Durchschnitt", „so schnell wie möglich", „fair". Dort ist Nachfragen die Modellierungsarbeit.
 * Die vier Fragen — worüber wird entschieden, woran gemessen, was ist unverhandelbar, was bei Unlösbarkeit — gehören in die erste Besprechung. Der Leitfaden in [Abschnitt 4.5](#sec:modellierung-leitfaden) macht zwölf daraus.
 
 
+---
+
+# Synthese Teil I — Grundlagen auf einen Blick
+
+Vier Kapitel, eine Frage: **Was muss vorliegen, bevor ein Solver überhaupt sinnvoll gestartet werden kann?** Die Antwort ist unbequem, weil das meiste davon nichts mit Programmieren zu tun hat.
+
+## Was welches Kapitel klärt
+
+| Frage | Kapitel | Was Sie danach können |
+| --- | --- | --- |
+| Was ist überhaupt ein Optimierungsmodell? | [Kapitel 1](#kap-einfuehrung) | Die vier Bausteine benennen — Variablen, Zielfunktion, Nebenbedingungen, Daten — und sie in einem fremden Problem wiedererkennen |
+| Warum rechnet der Solver falsch, obwohl das Modell stimmt? | [Kapitel 2](#kap-fundament) | Konvexität beurteilen, den zulässigen Bereich als Polyeder sehen, schlechte Konditionierung erkennen und beheben |
+| Welche Bibliothek, und warum vertragen sie sich nicht? | [Kapitel 3](#kap-oekosystem) | Solver, Bindings und Modellierungsschichten unterscheiden — und den HiGHS-Symbolkonflikt zwischen `ortools` und `highspy` umgehen |
+| Wie wird aus einem Satz ein Modell? | [Kapitel 4](#kap-modellierung) | Die vier Fragen stellen, harte von weichen Regeln trennen, einen Besprechungssatz übersetzen ([Abschnitt 4.6](#sec:modellierung-glossar)) |
+
+## Die Reihenfolge ist die Aussage
+
+Dieser Teil steht bewusst **vor** den Verfahren. Die drei häufigsten Gründe, aus denen ein OR-Projekt scheitert, liegen alle hier — und keiner davon ist ein Solverproblem:
+
+1. **Die falsche Zielgröße.** Sie ist die folgenreichste Entscheidung des ganzen Projekts, und sie wird meist in den ersten zehn Minuten nebenbei getroffen. Auslastung ist ein Ergebnis, kein Ziel; „Umsatz" wird gesagt, wenn „Deckungsbeitrag" gemeint ist.
+2. **Zu viele harte Regeln.** Jede unnötig harte Bedingung ist eine Zeitbombe: Irgendwann ist sie nicht erfüllbar, und das System antwortet gar nicht mehr. Hart ist nur, was rechtlich oder physikalisch unmöglich ist.
+3. **Ein Satz, der mehrere Lesarten hat.** „Stammkunden dürfen wir nicht verlieren" lässt sich auf mindestens drei Arten modellieren, und keine ist aus dem Satz ableitbar. Die Wahl trifft man — im Zweifel unbewusst.
+
+## Wenn Sie nur eines mitnehmen
+
+> **🎯** Ein Modell rechnet aus, was **aufgeschrieben** wurde, nicht was gemeint war. Die Arbeit, die darüber entscheidet, ob am Ende etwas Brauchbares herauskommt, findet vor der ersten Zeile Code statt — und sie besteht aus Fragen an andere Menschen, nicht aus Mathematik.
+
+**Vor [Teil II](#teil-kernverfahren)** sollten Sie an einem eigenen Beispiel die vier Fragen aus [Abschnitt 4.3](#sec:modellierung-vier-fragen) durchgespielt haben. Ohne das bleiben die Verfahren Technik ohne Anwendung.
+
+
 ---
 
 # Teil II: Die Kernverfahren der deterministischen Optimierung {#teil-kernverfahren}
@@ -5336,7 +5531,7 @@ Der Zukauf für 18 €/h ist hochprofitabel: Jede zusätzliche Prüfstunde bring
 
 > **⚠️ Grenzen der Schattenpreis-Aussage**
 >
-> Der Schattenpreis gilt nur **lokal**, in einem begrenzten Intervall um die aktuelle Kapazität. Kauft man 200 Prüfstunden zu, wird irgendwann eine andere Ressource zum Engpass, und der Schattenpreis springt auf einen neuen Wert (oder auf null). Wer große Kapazitätsänderungen bewerten will, muss das Modell **neu rechnen** — nicht linear hochrechnen. Übung 4.6 macht diesen Effekt sichtbar.
+> Der Schattenpreis gilt nur **lokal**, in einem begrenzten Intervall um die aktuelle Kapazität. Kauft man 200 Prüfstunden zu, wird irgendwann eine andere Ressource zum Engpass, und der Schattenpreis springt auf einen neuen Wert (oder auf null). Wer große Kapazitätsänderungen bewerten will, muss das Modell **neu rechnen** — nicht linear hochrechnen. Die Aufgabe *Gültigkeitsbereich des Schattenpreises* ([Abschnitt 5.10](#sec:lp-uebungsaufgaben)) macht diesen Effekt sichtbar.
 
 ---
 
@@ -5670,7 +5865,7 @@ brauchbare Aussage. Ein erfundener Einzelwert ist es nicht.
 
 ## 5.11 Finde den Denkfehler {#sec:lp-denkfehler}
 
-> **🐛 Finde den Denkfehler 4.1: Die 380 000-Euro-Maschine**
+> **🐛 Finde den Denkfehler: Die 380 000-Euro-Maschine**
 >
 > Ein Werksleiter lässt die Engpässe seiner Fertigung analysieren. Das Skript liefert für den Lackierofen einen Schattenpreis von **50 €/Stunde**. Er rechnet:
 >
@@ -5701,7 +5896,7 @@ brauchbare Aussage. Ein erfundener Einzelwert ist es nicht.
 
 ## 5.12 Micro-Quiz {#sec:lp-quiz}
 
-> **❓ Micro-Quiz 4: Drei Fragen zum Selbstcheck**
+> **❓ Micro-Quiz 5: Drei Fragen zum Selbstcheck**
 >
 > Genau eine Antwort ist jeweils richtig. Auflösung in [Anhang A](#quiz-loesung-lp).
 >
@@ -6240,7 +6435,7 @@ $$
 
 > **📎 Zwei Bausteine aus `or_kern.py`**
 >
-> Das Programm wertet den Solver nicht über `ergebnis.success` aus, sondern über `status_von_scipy()` und das `Loesung`-Objekt aus dem gemeinsamen Unterbau ([Abschnitt 22.5](#sec:praxisfallen-or-kern)). Der Unterschied ist kein Schönheitsfehler:
+> Das Programm wertet den Solver nicht über `ergebnis.success` aus, sondern über `status_von_scipy()` und das `Loesung`-Objekt aus dem gemeinsamen Unterbau ([Abschnitt 22.6](#sec:praxisfallen-or-kern)). Der Unterschied ist kein Schönheitsfehler:
 >
 > * `success` ist **ein Bit**. Es unterscheidet nicht zwischen „es gibt keine Lösung“ (Modellfehler — das Modell muss geändert werden) und „die Zeit war um“ (Rechenproblem — mehr Zeit oder ein besserer Startwert hilft). Das sind zwei völlig verschiedene Nachrichten an völlig verschiedene Adressaten.
 > * Das `Loesung`-Objekt führt neben dem Zielwert die **Schranke** mit und rechnet daraus den Gap aus. Erst dadurch steht in der Ausgabe `Gap: 0.00%` — die Zusage, dass hier wirklich das Optimum gefunden *und bewiesen* wurde und nicht bloß irgendetwas.
@@ -6491,7 +6686,7 @@ Abnahmepruefung: alle Nebenbedingungen geprueft und eingehalten.
 > | `zeile[i]=1; zeile[N+i]=-MAX_POSITION` | Muster 1: $x_i - U y_i \le 0$. **$M = U = 40\,000$** — die kleinstmögliche gültige Wahl |
 > | `zeile[i]=-1; zeile[N+i]=MIN_POSITION` | Muster 5 unten: $L y_i - x_i \le 0$ |
 > | `integrality=concat([zeros(N), ones(N)])` | nur die $y$ sind ganzzahlig — das ist das „mixed“ in MILP |
-> | `status = status_von_scipy(ergebnis)` | übersetzt den SciPy-Rückgabewert in die gemeinsame Sprache aus [Abschnitt 22.5](#sec:praxisfallen-or-kern) — die drei `if`-Zweige darunter behandeln Modellfehler, Abbruch ohne Lösung und „zulässig, aber unbewiesen“ getrennt |
+> | `status = status_von_scipy(ergebnis)` | übersetzt den SciPy-Rückgabewert in die gemeinsame Sprache aus [Abschnitt 22.6](#sec:praxisfallen-or-kern) — die drei `if`-Zweige darunter behandeln Modellfehler, Abbruch ohne Lösung und „zulässig, aber unbewiesen“ getrennt |
 > | `schranke=-ergebnis.mip_dual_bound` | die zweite Zahl aus [Abschnitt 6.8](#sec:milp-gap). Erst mit ihr kann das `Loesung`-Objekt den Gap ausrechnen — und der Bericht sagt `Gap: 0.00%`, also *beweisbar* optimal |
 > | `pruefe_portfolio(...)` | prüft **jede** modellierte Regel einzeln nach und liefert eine Liste von Beanstandungen |
 >
@@ -6908,7 +7103,8 @@ def loese(dauer: np.ndarray, n_maschinen: int, zeitlimit: float,
 
     loeser = cp_model.CpSolver()
     loeser.parameters.max_time_in_seconds = zeitlimit
-    # Ein Arbeiter und fester Startwert, damit die Messung reproduzierbar ist.
+    # Ein Arbeiter und fester Startwert, damit die Messung reproduzierbar ist -
+    # der Seed allein genuegt dafuer NICHT (Kapitel Constraint Programming).
     # Im Produktivbetrieb laesst man beides auf den Standardwerten.
     loeser.parameters.num_workers = 1
     loeser.parameters.random_seed = 1
@@ -7032,7 +7228,7 @@ Hier wirkt der Hinweis: Faktor 2,2 bzw. 1,4. Beachten Sie aber, dass der Faktor
 
 Die Warnung „$M$ so klein wie möglich“ wird meist mit der Laufzeit begründet: schwache Relaxation, mehr Knoten. Das stimmt — und ist die **harmlosere** Hälfte der Wahrheit.
 
-> **🐛 Finde den Denkfehler 5.1: Elf Lager, die keine Fixkosten kosten**
+> **🐛 Finde den Denkfehler: Elf Lager, die keine Fixkosten kosten**
 >
 > Ein Team plant Standorte: 12 mögliche Lager, 40 Kunden, Fixkosten je eröffnetem Lager. Für das Big-M in der Kopplung
 >
@@ -7310,7 +7506,7 @@ funktioniert immer.
 
 ## 6.11 Micro-Quiz {#sec:milp-quiz}
 
-> **❓ Micro-Quiz 5: Drei Fragen zum Selbstcheck**
+> **❓ Micro-Quiz 6: Drei Fragen zum Selbstcheck**
 >
 > Genau eine Antwort ist jeweils richtig. Auflösung in [Anhang A](#quiz-loesung-milp).
 >
@@ -7365,6 +7561,7 @@ funktioniert immer.
 > `Propagation_Demo.py`\
 > `CP_SAT_Vertretungssystem.py`\
 > `JobShop_Intervalle.py`\
+> `Parallele_Suche.py`\
 > `CP_SAT_Statusfaelle.py`\
 > `Strafgewichte.py`
 >
@@ -7418,7 +7615,7 @@ funktioniert immer.
 
 Nein — und das ist die wichtigste Lektion dieses Kapitels. Der Plan erfüllt **jede** Regel, die wir aufgeschrieben haben. Wir haben nur nie nach Fairness gefragt, und wir haben nie gesagt, dass Dienste nicht aufeinanderfolgen sollen. Ein Solver liefert exakt das Bestellte — nicht das Gemeinte.
 
-> **🎯 Merksatz** Ein Modell, das durchläuft, ist noch kein richtiges Modell. Die eigentliche Arbeit im Constraint Programming ist nicht das Lösen, sondern das vollständige Aufschreiben dessen, was „ein guter Plan“ überhaupt heißt. Wie man Wünsche wie Fairness als **weiche** Bedingungen mit Strafkosten formuliert, zeigt [Abschnitt 7.5](#sec:cpsat-praxisfall-dynamisches-vertretungssystem) — und [Abschnitt 7.9](#sec:cpsat-denkfehler) zeigt, was passiert, wenn man ihr Gewicht falsch wählt.
+> **🎯 Merksatz** Ein Modell, das durchläuft, ist noch kein richtiges Modell. Die eigentliche Arbeit im Constraint Programming ist nicht das Lösen, sondern das vollständige Aufschreiben dessen, was „ein guter Plan“ überhaupt heißt. Wie man Wünsche wie Fairness als **weiche** Bedingungen mit Strafkosten formuliert, zeigt [Abschnitt 7.5](#sec:cpsat-praxisfall-dynamisches-vertretungssystem) — und [Abschnitt 7.10](#sec:cpsat-denkfehler) zeigt, was passiert, wenn man ihr Gewicht falsch wählt.
 
 ---
 
@@ -7432,7 +7629,8 @@ Nach diesem Kapitel können Sie …
 4. … mit **Intervallvariablen**`\index{Intervallvariable}`{=latex} ein Maschinenbelegungsproblem modellieren.
 5. … harte Regeln und weiche Ziele in einem Modell kombinieren und gewichten.
 6. … die fünf CP-SAT-Statusfälle unterscheiden — insbesondere `INFEASIBLE` (es gibt keine Lösung) von `UNKNOWN` (es wurde keine gefunden) und `MODEL_INVALID` (Ihr Code ist fehlerhaft).
-7. … begründen, warum ein Strafgewicht ein **Wechselkurs** ist, und welche Regeln deshalb niemals in die Zielfunktion gehören.
+7. … begründen, warum `num_workers = 1` für einen reproduzierbaren Lauf nötig ist und ein fester `random_seed` allein nicht genügt — und was ein Test deshalb prüfen darf.
+8. … begründen, warum ein Strafgewicht ein **Wechselkurs** ist, und welche Regeln deshalb niemals in die Zielfunktion gehören.
 
 ---
 
@@ -7895,7 +8093,7 @@ Suchstatistik: 113 Verzweigungen, 3 Konflikte, 0.006 s
 > ```python
 > status = status_von_cpsat(rohstatus)
 > ```
-> Danach heißen die Fälle `status.modellfehler` (die Regeln widersprechen sich — das Modell muss geändert werden) und `status.brauchbar` (es liegt etwas Ausführbares vor). Das ist **dieselbe** Fallunterscheidung wie bei HiGHS in [Kapitel 6](#kap-milp) und bei GLOP in [Kapitel 5](#kap-lp); nur die eine Übersetzerzeile weiß, welcher Solver gerechnet hat. Wer den Auswertungscode direkt gegen `cp_model.INFEASIBLE` schreibt, kann ihn bei einem Solverwechsel wegwerfen — [Abschnitt 22.6](#sec:praxisfallen-solverwechsel) führt genau diesen Wechsel vor.
+> Danach heißen die Fälle `status.modellfehler` (die Regeln widersprechen sich — das Modell muss geändert werden) und `status.brauchbar` (es liegt etwas Ausführbares vor). Das ist **dieselbe** Fallunterscheidung wie bei HiGHS in [Kapitel 6](#kap-milp) und bei GLOP in [Kapitel 5](#kap-lp); nur die eine Übersetzerzeile weiß, welcher Solver gerechnet hat. Wer den Auswertungscode direkt gegen `cp_model.INFEASIBLE` schreibt, kann ihn bei einem Solverwechsel wegwerfen — [Abschnitt 22.7](#sec:praxisfallen-solverwechsel) führt genau diesen Wechsel vor.
 
 > **⚠️ Typische Fehler**
 >
@@ -8063,6 +8261,8 @@ Erreichter Makespan: 11
 >
 > Deshalb setzt das Programm oben `num_workers = 1` und `random_seed = 1`: nur so ist die abgedruckte Ausgabe reproduzierbar. **Im Produktivbetrieb lässt man beides weg** — mehrere Arbeiter sind deutlich schneller.
 >
+> Wie viel schneller, und warum der Seed allein **nicht** genügt, misst [Abschnitt 7.7](#sec:cpsat-parallele-suche) an genau diesem Modell.
+>
 > Die Lehre für Ihre eigenen Tests: Prüfen Sie bei mehrdeutigen Optima nie auf einen **bestimmten Plan**, sondern immer auf den **Zielwert** und auf die Einhaltung aller Regeln. Ein Test wie `assert plan == erwarteter_plan` besteht sonst mal und scheitert mal, ohne dass sich am Code etwas geändert hätte.
 
 Bemerkenswert ist die letzte Zeile: Die untere Schranke liegt bei 10, erreicht wurden 11. Die Schranke ist also **nicht erreichbar** — kein Plan kann 10 schaffen, obwohl weder ein einzelner Auftrag noch eine einzelne Maschine mehr als 10 Zeiteinheiten braucht. Der Grund sind die Wechselwirkungen. Das ist typisch für Scheduling: **Einfache Schranken sind selten scharf.** Trotzdem sind sie nützlich — sie sagten uns hier, dass wir höchstens 10 % vom theoretischen Ideal entfernt sein können, noch bevor der Solver fertig war.
@@ -8073,7 +8273,302 @@ Bemerkenswert ist die letzte Zeile: Die untere Schranke liegt bei 10, erreicht w
 
 ---
 
-## 7.7 Die fünf Antworten von CP-SAT {#sec:cpsat-statusfaelle}
+## 7.7 Parallele Suche: was `num_workers` wirklich bewirkt {#sec:cpsat-parallele-suche}
+
+An mehreren Stellen dieses Buchs steht `loeser.parameters.num_workers = 1`, mit dem Kommentar „für eine reproduzierbare Ausgabe“. Darin stecken zwei Behauptungen: dass parallele Suche **schneller** ist, und dass sie **von Lauf zu Lauf andere, gleich gute** Lösungen liefert. Beides lässt sich messen — und beim Messen kommt mehr heraus als erwartet.
+
+Gerechnet wird auf demselben Modell wie [Abschnitt 7.6](#sec:cpsat-intervallvariablen-job-shop-scheduling), nur groß genug, dass die Suche wirklich arbeitet: 12 Aufträge auf 10 Maschinen, jeder Auftrag besucht jede Maschine. Entscheidend ist, dass `random_seed` in **jedem** Lauf denselben Wert hat.
+
+```python
+#!/usr/bin/env python3
+
+# Parallele_Suche.py
+"""
+Kapitel CP-SAT: Was mehrere Arbeiter wirklich bringen - und was sie kosten.
+
+Das Buch setzt an mehreren Stellen 'num_workers = 1', damit die abgedruckte
+Ausgabe reproduzierbar ist. Behauptet wird dabei zweierlei: dass parallele
+Suche schneller ist, und dass sie von Lauf zu Lauf verschiedene, gleich gute
+Loesungen findet. Beides wird hier gemessen statt geglaubt.
+
+Gerechnet wird auf einem Job-Shop wie in JobShop_Intervalle.py, nur gross
+genug, dass die Suche wirklich arbeitet: 12 Auftraege auf 10 Maschinen,
+jeder Auftrag besucht jede Maschine.
+
+Zwei Messungen:
+  1. Dieselbe Aufgabe mit 1, 2, 4 und 8 Arbeitern - Laufzeit und Ergebnis.
+  2. Dieselbe Konfiguration mehrfach, bei FESTEM random_seed - wie oft kommt
+     derselbe Plan heraus?
+
+Die zweite ist die wichtigere: Sie entscheidet, wie man Tests schreibt.
+
+Achtung, Laufzeiten sind hardwareabhaengig. Die ZAHL der verschiedenen
+Plaene ist es auch - und genau das ist die Aussage.
+
+Benoetigt: numpy, ortools
+"""
+
+from __future__ import annotations
+
+import collections
+import time
+
+import numpy as np
+from ortools.sat.python import cp_model
+
+AUFTRAEGE = 12
+MASCHINEN = 10
+INSTANZ_SEED = 20260908
+SOLVER_SEED = 1          # bleibt ueber ALLE Laeufe gleich - das ist der Punkt
+ARBEITERZAHLEN = (1, 2, 4, 8)
+WIEDERHOLUNGEN = 4
+ZEITLIMIT = 120.0
+
+
+def baue_instanz() -> list[list[tuple[int, int]]]:
+    """Klassischer Job-Shop: Jeder Auftrag besucht jede Maschine genau einmal,
+    in einer eigenen zufaelligen Reihenfolge."""
+    rng = np.random.default_rng(INSTANZ_SEED)
+    return [[(int(m), int(rng.integers(2, 20))) for m in rng.permutation(MASCHINEN)]
+            for _ in range(AUFTRAEGE)]
+
+
+def loese(auftraege, arbeiter: int):
+    """Minimiert den Makespan. Gibt Status, Zielwert, Laufzeit und den Plan
+    zurueck - den Plan als Tupel aller Startzeiten, damit sich zwei Laeufe
+    vergleichen lassen."""
+    horizont = sum(dauer for auftrag in auftraege for _, dauer in auftrag)
+    modell = cp_model.CpModel()
+    Gang = collections.namedtuple("Gang", "start ende intervall")
+    plaene: dict[tuple[int, int], Gang] = {}
+    je_maschine = collections.defaultdict(list)
+
+    for a, auftrag in enumerate(auftraege):
+        for g, (maschine, dauer) in enumerate(auftrag):
+            start = modell.NewIntVar(0, horizont, f"start_{a}_{g}")
+            ende = modell.NewIntVar(0, horizont, f"ende_{a}_{g}")
+            intervall = modell.NewIntervalVar(start, dauer, ende, f"iv_{a}_{g}")
+            plaene[a, g] = Gang(start, ende, intervall)
+            je_maschine[maschine].append(intervall)
+
+    for maschine in range(MASCHINEN):
+        modell.AddNoOverlap(je_maschine[maschine])
+    for a, auftrag in enumerate(auftraege):
+        for g in range(len(auftrag) - 1):
+            modell.Add(plaene[a, g + 1].start >= plaene[a, g].ende)
+
+    makespan = modell.NewIntVar(0, horizont, "makespan")
+    modell.AddMaxEquality(
+        makespan, [plaene[a, len(auftrag) - 1].ende
+                   for a, auftrag in enumerate(auftraege)])
+    modell.Minimize(makespan)
+
+    loeser = cp_model.CpSolver()
+    loeser.parameters.num_workers = arbeiter
+    loeser.parameters.random_seed = SOLVER_SEED
+    loeser.parameters.max_time_in_seconds = ZEITLIMIT
+
+    beginn = time.perf_counter()
+    status = loeser.Solve(modell)
+    dauer = time.perf_counter() - beginn
+
+    if status not in (cp_model.OPTIMAL, cp_model.FEASIBLE):
+        return loeser.StatusName(status), None, dauer, None
+    plan = tuple(loeser.Value(plaene[a, g].start)
+                 for a, auftrag in enumerate(auftraege)
+                 for g in range(len(auftrag)))
+    return loeser.StatusName(status), int(loeser.ObjectiveValue()), dauer, plan
+
+
+if __name__ == "__main__":
+    auftraege = baue_instanz()
+    gaenge = sum(len(a) for a in auftraege)
+
+    print("=" * 78)
+    print("  WAS MEHRERE ARBEITER WIRKLICH BRINGEN")
+    print("=" * 78)
+    print(f"Job-Shop: {AUFTRAEGE} Auftraege, {MASCHINEN} Maschinen, "
+          f"{gaenge} Arbeitsgaenge.")
+    print(f"random_seed = {SOLVER_SEED} in JEDEM Lauf, "
+          f"{WIEDERHOLUNGEN} Wiederholungen je Arbeiterzahl.\n")
+
+    # Jede Konfiguration mehrfach - ein einzelner Zeitwert sagt nichts.
+    ergebnisse: dict[int, list[tuple]] = {}
+    for arbeiter in ARBEITERZAHLEN:
+        ergebnisse[arbeiter] = [loese(auftraege, arbeiter)
+                                for _ in range(WIEDERHOLUNGEN)]
+
+    print("=" * 78)
+    print("  (1) Laufzeit: was die Arbeiter bringen")
+    print("=" * 78)
+    print(f"{'Arbeiter':>9} {'Status':>9} {'Makespan':>9} "
+          f"{'schnellste':>11} {'langsamste':>11} {'Beschleunigung':>15}")
+    print("-" * 78)
+    basis_zeit = min(d for _, _, d, _ in ergebnisse[1])
+    for arbeiter in ARBEITERZAHLEN:
+        laeufe = ergebnisse[arbeiter]
+        zeiten = [d for _, _, d, _ in laeufe]
+        ziele = {o for _, o, _, _ in laeufe}
+        status = {s for s, _, _, _ in laeufe}
+        print(f"{arbeiter:>9} {'/'.join(sorted(status)):>9} "
+              f"{'/'.join(str(z) for z in sorted(ziele)):>9} "
+              f"{min(zeiten):>10.2f}s {max(zeiten):>10.2f}s "
+              f"{basis_zeit / min(zeiten):>14.1f}x")
+
+    beste = min(ARBEITERZAHLEN, key=lambda w: min(d for _, _, d, _ in ergebnisse[w]))
+    faktor = basis_zeit / min(d for _, _, d, _ in ergebnisse[beste])
+    print(f"\n  Am schnellsten sind {beste} Arbeiter: Faktor {faktor:.1f} gegenueber")
+    print(f"  einem einzigen - also MEHR, als {beste} Kerne hergeben sollten.")
+    print(f"  Das ist kein Messfehler. CP-SAT laesst nicht {beste}-mal dieselbe Suche")
+    print("  laufen, sondern verschiedene Strategien nebeneinander, die einander")
+    print("  ihre Schranken zurufen. Der zweite Arbeiter ist deshalb nicht der")
+    print("  'zweite Kern', sondern ein anderes Verfahren.")
+    letzte = ARBEITERZAHLEN[-1]
+    if beste != letzte:
+        zeit_letzte = min(d for _, _, d, _ in ergebnisse[letzte])
+        print(f"\n  Und mehr ist nicht immer besser: {letzte} Arbeiter brauchen "
+              f"{zeit_letzte:.2f}s")
+        print(f"  gegenueber {min(d for _, _, d, _ in ergebnisse[beste]):.2f}s bei "
+              f"{beste}. Ab einer gewissen Zahl kosten Abstimmung")
+        print("  und Speicherbandbreite mehr, als ein weiterer Suchstrang einbringt.")
+
+    print("\n" + "=" * 78)
+    print("  (2) Reproduzierbarkeit: derselbe Seed, derselbe Plan?")
+    print("=" * 78)
+    print(f"{'Arbeiter':>9} {'Laeufe':>7} {'verschiedene Plaene':>21} "
+          f"{'Makespan':>10}")
+    print("-" * 78)
+    for arbeiter in ARBEITERZAHLEN:
+        plaene = {p for _, _, _, p in ergebnisse[arbeiter] if p is not None}
+        ziele = {o for _, o, _, _ in ergebnisse[arbeiter]}
+        print(f"{arbeiter:>9} {WIEDERHOLUNGEN:>7} {len(plaene):>21} "
+              f"{'/'.join(str(z) for z in sorted(ziele)):>10}")
+
+    einer = len({p for _, _, _, p in ergebnisse[1]})
+    # Ab welcher Arbeiterzahl bricht die Reproduzierbarkeit? Das ist die
+    # eigentliche Zahl - nicht, was acht Arbeiter anrichten.
+    ab = next((w for w in ARBEITERZAHLEN
+               if len({p for _, _, _, p in ergebnisse[w]}) > 1), None)
+    print(f"\n  Mit einem Arbeiter: {einer} Plan aus {WIEDERHOLUNGEN} Laeufen.")
+    if ab is not None:
+        viele = len({p for _, _, _, p in ergebnisse[ab]})
+        print(f"  Schon mit {ab} Arbeitern: {viele} verschiedene Plaene aus "
+              f"{WIEDERHOLUNGEN} Laeufen -")
+        print("  bei identischem random_seed und identischem Zielwert.")
+        print(f"  Es braucht also keine acht Arbeiter, um die Reproduzierbarkeit")
+        print(f"  zu verlieren. {ab} genuegen.")
+    print("\n  Der Seed allein macht einen Lauf also NICHT reproduzierbar. Er legt")
+    print("  fest, wie ein einzelner Suchstrang wuerfelt - nicht, welcher von")
+    print("  mehreren zuerst fertig wird. Das entscheidet die Uhr.")
+
+    print("\n" + "=" * 78)
+    print("  (3) Was daraus fuer Tests folgt")
+    print("=" * 78)
+    print("  Ein Test der Form  assert plan == erwarteter_plan  besteht mal und")
+    print("  scheitert mal, ohne dass sich am Code etwas geaendert haette.")
+    print("  Zu pruefen sind stattdessen:")
+    print("    * der ZIELWERT (hier in allen Laeufen gleich),")
+    print("    * die Einhaltung aller Regeln (Abnahmepruefung, Kapitel Praxisfallen),")
+    print("    * und der Status - nicht die Gestalt der Loesung.")
+    print("\n  Wer doch einen bestimmten Plan braucht - fuer eine abgedruckte")
+    print("  Ausgabe, fuer einen Regressionstest -, setzt num_workers = 1.")
+    print(f"  Das kostet hier den Faktor {faktor:.1f} an Laufzeit und ist genau")
+    print("  deshalb eine Entscheidung fuer den Test, nicht fuer den Betrieb.")
+    print("=" * 78)
+```
+
+**Erwartete Ausgabe** (Laufzeiten *und* die Zahl der verschiedenen Pläne sind hardwareabhängig — genau das ist die Aussage; der Zielwert ist es nicht):
+
+```
+==============================================================================
+  WAS MEHRERE ARBEITER WIRKLICH BRINGEN
+==============================================================================
+Job-Shop: 12 Auftraege, 10 Maschinen, 120 Arbeitsgaenge.
+random_seed = 1 in JEDEM Lauf, 4 Wiederholungen je Arbeiterzahl.
+
+==============================================================================
+  (1) Laufzeit: was die Arbeiter bringen
+==============================================================================
+ Arbeiter    Status  Makespan  schnellste  langsamste  Beschleunigung
+------------------------------------------------------------------------------
+        1   OPTIMAL       183       5.62s       5.82s            1.0x
+        2   OPTIMAL       183       1.43s       2.04s            3.9x
+        4   OPTIMAL       183       0.60s       0.66s            9.4x
+        8   OPTIMAL       183       0.46s       0.65s           12.3x
+
+  Am schnellsten sind 8 Arbeiter: Faktor 12.3 gegenueber
+  einem einzigen - also MEHR, als 8 Kerne hergeben sollten.
+  Das ist kein Messfehler. CP-SAT laesst nicht 8-mal dieselbe Suche
+  laufen, sondern verschiedene Strategien nebeneinander, die einander
+  ihre Schranken zurufen. Der zweite Arbeiter ist deshalb nicht der
+  'zweite Kern', sondern ein anderes Verfahren.
+
+==============================================================================
+  (2) Reproduzierbarkeit: derselbe Seed, derselbe Plan?
+==============================================================================
+ Arbeiter  Laeufe   verschiedene Plaene   Makespan
+------------------------------------------------------------------------------
+        1       4                     1        183
+        2       4                     3        183
+        4       4                     3        183
+        8       4                     4        183
+
+  Mit einem Arbeiter: 1 Plan aus 4 Laeufen.
+  Schon mit 2 Arbeitern: 3 verschiedene Plaene aus 4 Laeufen -
+  bei identischem random_seed und identischem Zielwert.
+  Es braucht also keine acht Arbeiter, um die Reproduzierbarkeit
+  zu verlieren. 2 genuegen.
+
+  Der Seed allein macht einen Lauf also NICHT reproduzierbar. Er legt
+  fest, wie ein einzelner Suchstrang wuerfelt - nicht, welcher von
+  mehreren zuerst fertig wird. Das entscheidet die Uhr.
+
+==============================================================================
+  (3) Was daraus fuer Tests folgt
+==============================================================================
+  Ein Test der Form  assert plan == erwarteter_plan  besteht mal und
+  scheitert mal, ohne dass sich am Code etwas geaendert haette.
+  Zu pruefen sind stattdessen:
+    * der ZIELWERT (hier in allen Laeufen gleich),
+    * die Einhaltung aller Regeln (Abnahmepruefung, Kapitel Praxisfallen),
+    * und der Status - nicht die Gestalt der Loesung.
+
+  Wer doch einen bestimmten Plan braucht - fuer eine abgedruckte
+  Ausgabe, fuer einen Regressionstest -, setzt num_workers = 1.
+  Das kostet hier den Faktor 12.3 an Laufzeit und ist genau
+  deshalb eine Entscheidung fuer den Test, nicht fuer den Betrieb.
+==============================================================================
+```
+
+### Was die Messung zeigt
+
+**Erstens: Die Beschleunigung ist überlinear.** Acht Arbeiter sind im abgedruckten Lauf nicht achtmal, sondern **gut zwölfmal** schneller als einer. Das sieht nach Messfehler aus, ist aber die korrekte Beschreibung dessen, was CP-SAT tut: Es lässt **nicht** achtmal dieselbe Suche auf verschiedenen Kernen laufen, sondern **verschiedene Strategien nebeneinander** — Suche mit LP-Relaxation, Suche mit anderen Verzweigungsregeln, lokale Suche —, und die teilen einander ihre Schranken mit. Der zweite Arbeiter ist deshalb nicht „der zweite Kern“, sondern ein anderes Verfahren, das zufällig auch rechnet.
+
+Daraus folgt zweierlei. Ein Speedup über der Kernzahl ist bei CP-SAT normal und kein Grund zum Misstrauen. Und der Zugewinn flacht ab: Zwischen vier und acht Arbeitern lag in unseren Wiederholungen mal das eine, mal das andere vorn — ab einer gewissen Zahl kosten Abstimmung und Speicherbandbreite mehr, als ein weiterer Suchstrang einbringt. Auch hier gilt: messen, nicht schätzen.
+
+**Zweitens — und das ist der Befund, der die Testpraxis bestimmt: Der Seed genügt nicht.** Bei einem Arbeiter liefern vier Läufe **einen** Plan. Schon bei **zwei** Arbeitern liefern vier Läufe **drei verschiedene** — bei identischem `random_seed` und identischem Zielwert 183.
+
+Es braucht also keine acht Arbeiter, um die Reproduzierbarkeit zu verlieren. Zwei genügen. Der Grund ist einfach, sobald man ihn ausspricht: Der Seed legt fest, wie ein **einzelner** Suchstrang würfelt. Er legt nicht fest, **welcher von mehreren zuerst fertig wird** — das entscheidet die Uhr, und die ist bei jedem Lauf anders.
+
+> **⚠️ `random_seed` allein macht nichts reproduzierbar** Ein häufiger Irrtum: „Ich habe doch einen Seed gesetzt.“ Für einen Zufallsgenerator stimmt das. Für einen **parallelen** Solver nicht — dort ist die zweite Zufallsquelle die Ausführungsreihenfolge, und die lässt sich nicht mit einem Parameter festnageln. Reproduzierbar wird der Lauf erst mit `num_workers = 1` **und** Seed. Wer nur eines von beidem setzt, hat einen Test, der gelegentlich grundlos rot wird.
+
+### Was daraus für Tests folgt
+
+Der Zielwert war in **allen** sechzehn Läufen derselbe: 183. Die Gestalt der Lösung war es nicht. Genau daran entscheidet sich, was ein Test prüfen darf:
+
+| Prüfen | Nicht prüfen |
+| --- | --- |
+| den **Zielwert** — er ist eindeutig, wenn das Modell optimal gelöst wurde | die **Gestalt** des Plans (`assert plan == erwarteter_plan`) |
+| die **Einhaltung aller Regeln** über eine Abnahmeprüfung ([Abschnitt 22.6](#sec:praxisfallen-or-kern)) | die Reihenfolge, in der gleichwertige Aufträge zugewiesen wurden |
+| den **Status** (`OPTIMAL`, `FEASIBLE`, `INFEASIBLE`) | die Laufzeit als feste Zahl |
+
+Wer doch einen bestimmten Plan braucht — für eine abgedruckte Ausgabe, für einen Regressionstest —, setzt `num_workers = 1`. Das kostet hier den Faktor 12 an Laufzeit, und genau deshalb ist es eine Entscheidung **für den Test**, nicht für den Betrieb. In Produktion lässt man beide Parameter auf ihren Standardwerten.
+
+> **🎯 Merksatz** Ein paralleler Solver hat zwei Zufallsquellen: den Seed und die Uhr. Nur die erste lässt sich setzen. Wer Reproduzierbarkeit braucht, muss die zweite abschalten — und das heißt `num_workers = 1`.
+
+---
+
+## 7.8 Die fünf Antworten von CP-SAT {#sec:cpsat-statusfaelle}
 
 [Abschnitt 6.8](#sec:milp-gap) hat gezeigt, warum `OPTIMAL` bei ganzzahligen Problemen nicht der Normalfall ist. Bei CP-SAT kommt eine Besonderheit hinzu: Es gibt **fünf** verschiedene Antworten, und drei davon werden regelmäßig verwechselt.
 
@@ -8390,7 +8885,7 @@ genau die Information, die zur Fehlersuche noetig waere.
 
 ---
 
-## 7.8 Übungsaufgaben {#sec:cpsat-uebungsaufgaben}
+## 7.9 Übungsaufgaben {#sec:cpsat-uebungsaufgaben}
 
 > Lösungen: [Abschnitt A.7](#sec:loesungen-cpsat).
 
@@ -8404,15 +8899,17 @@ genau die Information, die zur Fehlersuche noetig waere.
 
 **Aufgabe 7.5 ⭐⭐ — Sudoku.** Lösen Sie ein 9×9-Sudoku mit CP-SAT. Sie brauchen nur `NewIntVar(1, 9, ...)` und `AddAllDifferent` für Zeilen, Spalten und die neun 3×3-Blöcke. Wie viele Zeilen Modellcode benötigen Sie?
 
-**Aufgabe 7.6 ⭐⭐⭐ — Job-Shop erweitern.** Ergänzen Sie `JobShop_Intervalle.py` um: (a) Rüstzeiten von 1 Zeiteinheit zwischen zwei Aufträgen auf derselben Maschine. (b) Fälligkeitstermine je Auftrag mit Strafkosten für Verspätung. (c) Eine zweite Fräse (Kapazität 2 statt 1) mit `AddCumulative`.
+**Aufgabe 7.6 ⭐⭐ — Die Grenze der Parallelität finden.** `Parallele_Suche.py` misst 1, 2, 4 und 8 Arbeiter. (a) Ergänzen Sie 16 und 24 (bzw. die Kernzahl Ihres Rechners). Ab wo bringt ein weiterer Arbeiter nichts mehr — und wird es irgendwann wieder schlechter? (b) Setzen Sie `random_seed` bei jedem Lauf auf einen **anderen** Wert, aber `num_workers = 1`. Wie viele verschiedene Pläne kommen jetzt heraus? Was folgt daraus für die Frage, welcher der beiden Parameter die Reproduzierbarkeit sichert? (c) Vergrößern Sie die Instanz auf 15 Aufträge. Ab welcher Größe erreicht der Lauf mit einem Arbeiter das Zeitlimit, während acht noch `OPTIMAL` melden?
 
-**Aufgabe 7.7 ⭐⭐⭐ — Eigener Dienstplan.** Modellieren Sie einen Wochendienstplan: 7 Tage, 3 Schichten (früh/spät/nacht), 8 Mitarbeitende. Regeln: Jede Schicht 2 Personen; nach Nachtschicht mindestens 2 Tage frei; höchstens 5 Arbeitstage in Folge; jede Person mindestens 2 freie Tage pro Woche; Wünsche als weiche Ziele. Geben Sie den Plan als Wochentabelle aus.
+**Aufgabe 7.7 ⭐⭐⭐ — Job-Shop erweitern.** Ergänzen Sie `JobShop_Intervalle.py` um: (a) Rüstzeiten von 1 Zeiteinheit zwischen zwei Aufträgen auf derselben Maschine. (b) Fälligkeitstermine je Auftrag mit Strafkosten für Verspätung. (c) Eine zweite Fräse (Kapazität 2 statt 1) mit `AddCumulative`.
+
+**Aufgabe 7.8 ⭐⭐⭐ — Eigener Dienstplan.** Modellieren Sie einen Wochendienstplan: 7 Tage, 3 Schichten (früh/spät/nacht), 8 Mitarbeitende. Regeln: Jede Schicht 2 Personen; nach Nachtschicht mindestens 2 Tage frei; höchstens 5 Arbeitstage in Folge; jede Person mindestens 2 freie Tage pro Woche; Wünsche als weiche Ziele. Geben Sie den Plan als Wochentabelle aus.
 
 ---
 
-## 7.9 Finde den Denkfehler {#sec:cpsat-denkfehler}
+## 7.10 Finde den Denkfehler {#sec:cpsat-denkfehler}
 
-> **🐛 Finde den Denkfehler 6.1: Die Betriebsvereinbarung, die niemanden interessiert**
+> **🐛 Finde den Denkfehler: Die Betriebsvereinbarung, die niemanden interessiert**
 >
 > Ein Klinikteam lässt seinen Schichtplan optimieren. Zwei Wünsche kommen aus dem Betrieb:
 >
@@ -8618,9 +9115,9 @@ Nebenbedingungen. Alles, was einen Preis hat, wird irgendwann gekauft.
 
 ---
 
-## 7.10 Micro-Quiz {#sec:cpsat-quiz}
+## 7.11 Micro-Quiz {#sec:cpsat-quiz}
 
-> **❓ Micro-Quiz 6: Drei Fragen zum Selbstcheck**
+> **❓ Micro-Quiz 7: Drei Fragen zum Selbstcheck**
 >
 > Genau eine Antwort ist jeweils richtig. Auflösung in [Anhang A](#quiz-loesung-cpsat).
 >
@@ -8632,7 +9129,7 @@ Nebenbedingungen. Alles, was einen Preis hat, wird irgendwann gekauft.
 
 ---
 
-## 7.11 Selbsttest {#sec:cpsat-selbsttest}
+## 7.12 Selbsttest {#sec:cpsat-selbsttest}
 
 > Antworten: [Anhang A](#selbsttest-loesung-cpsat).
 
@@ -8640,11 +9137,13 @@ Nebenbedingungen. Alles, was einen Preis hat, wird irgendwann gekauft.
 2. Welchen Vorteil hat `AddAllDifferent(x)` gegenüber $\binom{n}{2}$ Einzelbedingungen?
 3. Was ist eine Intervallvariable, und welche Bedingung garantiert sie automatisch?
 4. Warum sollten möglichst wenige Bedingungen hart formuliert werden?
-5. Warum ist die Aufschlüsselung der Strafkosten in der Praxis wichtiger als der Zielwert selbst?
+5. Warum ist die Aufschlüsselung der Strafkosten in der Praxis wichtiger als der Zielwert
+6. Sie setzen `random_seed = 1`, bekommen aber trotzdem bei jedem Lauf einen anderen Plan. Woran liegt das, und was hilft?
+7. Warum kann ein CP-SAT-Lauf mit acht Arbeitern **mehr** als achtmal schneller sein als mit einem? selbst?
 
 ---
 
-## 7.12 Zusammenfassung {#sec:cpsat-zusammenfassung}
+## 7.13 Zusammenfassung {#sec:cpsat-zusammenfassung}
 
 * **CP denkt in Wertebereichen und Regeln**, nicht in Ungleichungen und Schranken.
 * **Propagation** streicht unmögliche Werte, bevor gesucht wird; **Conflict Learning**`\index{CDCL!Conflict Learning}`{=latex} verhindert, dieselbe Sackgasse zweimal zu betreten.
@@ -8655,7 +9154,8 @@ Nebenbedingungen. Alles, was einen Preis hat, wird irgendwann gekauft.
 * **Fünf Antworten, nicht zwei.** `INFEASIBLE` (es gibt keine Lösung), `UNKNOWN` (es wurde keine gefunden) und `MODEL_INVALID` (Ihr Code ist fehlerhaft) bedeuten Grundverschiedenes. Wer sie in ein `else` zusammenfasst, verliert die Information zur Fehlersuche.
 * **Bei mehrdeutigen Optima nie auf einen bestimmten Plan testen** — nur auf den Zielwert und die Einhaltung aller Regeln.
 
-**Ausblick.** [Kapitel 8](#kap-graphen) behandelt Probleme, die sich am besten als **Graph** begreifen lassen: Flüsse durch Netzwerke, Zuordnungen und die Tourenplanung mit Fahrzeugen und Zeitfenstern.
+* **Ein paralleler Solver hat zwei Zufallsquellen: den Seed und die Uhr.** Nur die erste lässt sich setzen. Reproduzierbar wird ein Lauf erst mit `num_workers = 1` **und** Seed — gemessen in [Abschnitt 7.7](#sec:cpsat-parallele-suche): schon zwei Arbeiter liefern bei identischem Seed drei verschiedene Pläne zum selben Zielwert.
+* **Parallele Suche kann überlinear beschleunigen**, weil CP-SAT nicht dieselbe Suche vervielfacht, sondern verschiedene Strategien nebeneinander laufen lässt, die einander ihre Schranken mitteilen. **Ausblick.** [Kapitel 8](#kap-graphen) behandelt Probleme, die sich am besten als **Graph** begreifen lassen: Flüsse durch Netzwerke, Zuordnungen und die Tourenplanung mit Fahrzeugen und Zeitfenstern.
 
 
 ---
@@ -9305,7 +9805,7 @@ if __name__ == "__main__":
 
 ## 8.7 Finde den Denkfehler {#sec:graphen-denkfehler}
 
-> **🐛 Finde den Denkfehler 7.1: Die vergessene Dimension**
+> **🐛 Finde den Denkfehler: Die vergessene Dimension**
 >
 > Eine Spedition lässt ihre Tagestouren optimieren: 16 Kunden, 4 Fahrzeuge zu je 10 Paletten, Gesamtbedarf 37 Paletten. Das erste Ergebnis begeistert alle — **326 km**. Nach einem Hinweis aus dem Fuhrpark wird das Modell überarbeitet; jetzt kommen **572 km** heraus, 75 % mehr. Der Auftraggeber ist verärgert: *„Ihre erste Version war doch viel besser.“*
 >
@@ -9553,7 +10053,7 @@ plausibel aussieht.
 
 ## 8.8 Micro-Quiz {#sec:graphen-quiz}
 
-> **❓ Micro-Quiz 7: Drei Fragen zum Selbstcheck**
+> **❓ Micro-Quiz 8: Drei Fragen zum Selbstcheck**
 >
 > Genau eine Antwort ist jeweils richtig. Auflösung in [Anhang A](#quiz-loesung-graphen).
 >
@@ -11636,13 +12136,53 @@ Und selbst dort, wo die Ersparnis null ist, liefert das Verfahren etwas, das die
 * Auch wo es nichts spart, liefert es die **Schranke** — und damit die Erlaubnis, aufzuhören.
 
 
+---
+
+# Synthese Teil II — Die Kernverfahren nebeneinander
+
+Sechs Kapitel, sechs Werkzeuge. Jedes einzelne wurde im Zusammenhang gezeigt; hier stehen sie zum ersten Mal **nebeneinander**, mit der Frage, die vor jedem Projekt zu beantworten ist: Welches nehme ich, und was bekomme ich dafür?
+
+## Die Entscheidungsmatrix
+
+| Verfahren | Wofür es gebaut ist | Was Sie bekommen | Wo es aufhört | Kapitel |
+| --- | --- | --- | --- | --- |
+| **LP** | teilbare Mengen, lineare Zusammenhänge | beweisbares Optimum **plus Schattenpreise** | sobald etwas ganzzahlig sein muss | [Kapitel 5](#kap-lp) |
+| **MILP** | Ja/Nein-Entscheidungen, Fixkosten, Logik | beweisbares Optimum, Gap als Fortschrittsmaß | Laufzeit wächst mit der Zahl der Binärvariablen | [Kapitel 6](#kap-milp) |
+| **CP-SAT** | Zuweisung, Reihenfolge, Kalender, harte Logik | beweisbares Optimum, sehr ausdrucksstarke Bedingungen | keine Schattenpreise, keine stetigen Größen | [Kapitel 7](#kap-cpsat) |
+| **Graphenalgorithmen** | Flüsse, Zuordnung, Touren | oft **polynomiell** statt exponentiell | nur, wenn die Struktur wirklich passt | [Kapitel 8](#kap-graphen) |
+| **Metaheuristiken** | wenn der exakte Solver aussteigt | eine gute Lösung in **fester Zeit** | keine Garantie, kein Beweis, keine Schranke | [Kapitel 9](#kap-metaheuristiken) |
+| **Spaltengenerierung** | Modelle mit astronomisch vielen Variablen | beweisbares Optimum über nie erzeugte Spalten | lohnt nur bei bestimmter Instanzstruktur | [Kapitel 10](#kap-dekomposition) |
+
+**Die Spalte, die am meisten wert ist, ist die vierte.** Ein Verfahren zu kennen heißt zu wissen, wo es aufhört — nicht, wofür es gedacht ist.
+
+## Was dieser Teil gemessen hat
+
+| Behauptung | Gemessen | Wo |
+| --- | --- | --- |
+| „Der exakte Solver ist immer besser." | Bei 500 Aufträgen liefert CP-SAT eine Lösung, die **5,2 % schlechter** ist als die Faustregel eines Meisters | [Kapitel 9](#kap-metaheuristiken) |
+| „Metaheuristiken sind ungenau." | Faustregel 2 497 → Annealing 2 343 → Annealing plus LNS **2 289** Minuten Rüstzeit; untere Schranke 1 768 | [Kapitel 9](#kap-metaheuristiken) |
+| „Man muss alle Variablen aufschreiben." | 28 erzeugte Muster von **46 408** möglichen — und die Lösung ist beweisbar optimal | [Kapitel 10](#kap-dekomposition) |
+| „Dekomposition lohnt sich immer." | Bei drei Stücken je Rolle **11 %** Ersparnis, bei sechs **nichts** | [Kapitel 10](#kap-dekomposition) |
+| „Mit Seed ist der Lauf reproduzierbar." | Schon **zwei** Arbeiter liefern bei identischem Seed drei verschiedene Pläne zum selben Zielwert | [Abschnitt 7.7](#sec:cpsat-parallele-suche) |
+
+## Drei Fehler, die dieser Teil verhindert
+
+1. **Runden.** Die LP-Lösung ist keine Näherung der ganzzahligen Lösung — sie kann beliebig weit danebenliegen, und gerundet sogar unzulässig werden.
+2. **Ein zu großes Big-M.** Es macht das Modell nicht falsch, sondern die Suche langsam und die Schranken wertlos. So klein wie zulässig, nie „sicherheitshalber groß".
+3. **Zu früh heuristisch werden.** Der Umschlagpunkt, ab dem eine Metaheuristik den exakten Solver schlägt, ist eine Eigenschaft **des Problems** und lässt sich messen. Wer ihn nicht misst, verzichtet auf Optimalitätsgarantien, die er hätte haben können.
+
+## Wenn Sie nur eines mitnehmen
+
+> **🎯** Die Frage lautet nie „welcher Solver ist der beste", sondern „welche Garantie brauche ich, und was bin ich bereit, dafür an Laufzeit zu zahlen". Ein Verfahren ohne Schranke liefert eine Lösung; ein Verfahren mit Schranke liefert die Erlaubnis, aufzuhören.
+
+
 ---
 
 # Teil III: Nichtlinearität, Unsicherheit und mehrperiodige Dynamik {#teil-nichtlinear}
 
 [Teil II](#teil-kernverfahren) ging von festen Daten und linearen Zusammenhängen aus. Beides gilt in der Praxis oft nicht: Risiko wächst **quadratisch** mit dem Einsatz, Nachfrage ist erst morgen bekannt, und eine Entscheidung heute verändert, welche Möglichkeiten übermorgen noch offenstehen.
 
-Die drei Kapitel dieses Teils behandeln genau diese drei Abweichungen. Welches Werkzeug Sie brauchen, hängt davon ab, **welche** davon bei Ihnen vorliegt:
+Drei Kapitel dieses Teils behandeln genau diese drei Abweichungen. Welches Werkzeug Sie brauchen, hängt davon ab, **welche** davon bei Ihnen vorliegt:
 
 ![Entscheidungsdiagramm: Welches Werkzeug passt zu meinem Problem? (Teil III)](bilder_04/teil3_solverwahl.svg)
 
@@ -11650,6 +12190,8 @@ Die drei Kapitel dieses Teils behandeln genau diese drei Abweichungen. Welches W
 >
 > Der häufigste Fehler an dieser Stelle ist, Unsicherheit durch **Mittelwerte** zu ersetzen und dann deterministisch zu rechnen. Warum das systematisch danebengeht, zeigt [Kapitel 12](#kap-unsicherheit) unter dem Namen *Fluch des Durchschnitts*.
 
+Zwei weitere Kapitel schließen sich an, weil sie dieselbe Voraussetzung aufgeben, nur an einer anderen Stelle: [Kapitel 14](#kap-mehrziel) gibt das **eine Ziel** auf, [Kapitel 15](#kap-prognose) die Annahme, die **Eingabedaten** seien gegeben statt selbst geschätzt. Was dieser Teil insgesamt leistet, fasst die Synthese an seinem Ende zusammen.
+
 ---
 
 # Kapitel 11: Quadratische und nichtlineare Optimierung — KKT, Lagrange, Konvexität {#kap-qp-nlp}
@@ -12303,7 +12845,7 @@ Interessant ist auch die Wirkung des Entropieterms: Er verschiebt nur rund 7 Pro
 > 2. **Multistart.** Zehn Startpunkte, und die Spannweite der Ergebnisse wird gemessen. Sind alle gleich, ist das ein starkes Indiz für Konvexität. Weichen sie ab, wissen Sie sofort, dass Sie einem lokalen Optimum aufsitzen. Diese fünf Zeilen sollten in jedem SLSQP-Projekt stehen.
 > 3. **Analytischer Gradient.** `jac=gradient` spart nicht nur Zeit — die numerische Approximation von Ableitungen ist bei Termen wie $\ln w$ nahe null numerisch heikel.
 >
-> **Zur Skalierung:** Mit $\alpha = 1$ ist der Ertragsterm ($\approx 0{,}1$) zehnmal größer als der Varianzterm ($\approx 0{,}01$). Das Modell ist also stark renditegetrieben. Übung 8.5 lässt Sie diese Balance untersuchen — sie ist eine fachliche Entscheidung, keine technische.
+> **Zur Skalierung:** Mit $\alpha = 1$ ist der Ertragsterm ($\approx 0{,}1$) zehnmal größer als der Varianzterm ($\approx 0{,}01$). Das Modell ist also stark renditegetrieben. Die Aufgabe *Effekt der Gewichtung untersuchen* ([Abschnitt 11.7](#sec:qp-nlp-uebungsaufgaben)) lässt Sie diese Balance untersuchen — sie ist eine fachliche Entscheidung, keine technische.
 
 ---
 
@@ -12677,7 +13219,7 @@ else:
 
 ## 11.8 Finde den Denkfehler {#sec:qp-nlp-denkfehler}
 
-> **🐛 Finde den Denkfehler 8.1: Die Kovarianzmatrix aus dem Controlling**
+> **🐛 Finde den Denkfehler: Die Kovarianzmatrix aus dem Controlling**
 >
 > Ein Analyst soll das Risiko eines Portfolios aus drei Anlagen minimieren. Die Korrelationen hat er aus drei verschiedenen Quartalsberichten zusammengetragen — jede für sich plausibel:
 >
@@ -12730,7 +13272,7 @@ else:
 
 ## 11.9 Micro-Quiz {#sec:qp-nlp-quiz}
 
-> **❓ Micro-Quiz 8: Drei Fragen zum Selbstcheck**
+> **❓ Micro-Quiz 11: Drei Fragen zum Selbstcheck**
 >
 > Genau eine Antwort ist jeweils richtig. Auflösung in [Anhang A](#quiz-loesung-qp-nlp).
 >
@@ -13148,7 +13690,7 @@ Feinsuche (Raster 100..500): Optimum bei Kapazitaet 180, Kosten 12,810 EUR
 >
 > Bei dieser Mischverteilung liegt zwischen dem Normalbetrieb (um 150) und den Lastspitzen (um 450) ein Bereich, in dem kaum Wahrscheinlichkeitsmasse liegt. Zusätzliche Kapazität zwischen 200 und 400 nützt daher wenig: Sie ist im Normalfall Leerlauf und reicht im Krisenfall trotzdem nicht. Deshalb ist die Kostenkurve dort flach, und die Wahl zwischen 180 und 196 macht kaum einen Unterschied.
 >
-> **Was Sie mitnehmen sollten:** Die Frage „Wie teuer ist Mittelwertplanung?“ hat keine allgemeine Antwort — **rechnen Sie es aus.** Genau dafür ist Monte-Carlo da. Und beachten Sie die Spalte „Unterdeckung“: Bei Kapazität 200 wird in **24 % der Fälle** nachgekauft. Ob das akzeptabel ist, entscheidet kein Optimierer, sondern ein Servicelevel-Ziel (Übung 9.5).
+> **Was Sie mitnehmen sollten:** Die Frage „Wie teuer ist Mittelwertplanung?“ hat keine allgemeine Antwort — **rechnen Sie es aus.** Genau dafür ist Monte-Carlo da. Und beachten Sie die Spalte „Unterdeckung“: Bei Kapazität 200 wird in **24 % der Fälle** nachgekauft. Ob das akzeptabel ist, entscheidet kein Optimierer, sondern ein Servicelevel-Ziel (Aufgabe *Monte-Carlo erweitern*, [Abschnitt 12.8](#sec:unsicherheit-uebungsaufgaben)).
 
 > **💡 Wann Monte-Carlo das richtige Werkzeug ist** Immer dann, wenn Sie **eine Kennzahl brauchen, die keine Formel hat**: die Wahrscheinlichkeit, ein Servicelevel zu verfehlen; der erwartete Verlust in den schlechtesten 5 % der Fälle; die Verteilung der Projektdauer. Der Preis ist, dass Monte-Carlo nur **bewertet** — die Optimierung müssen Sie durch Rastersuche oder ein eigenes Modell ergänzen.
 
@@ -13343,7 +13885,7 @@ deutlich teurer ist als Leerlauf (5 EUR).
 
 **Lesen Sie die Vergleichstabelle von unten nach oben.** Die beiden extremen Haltungen sind die teuersten: Wer den Worst Case abdeckt (500 Einheiten), zahlt 5 000 € zu viel für Kapazität, die in 80 % der Fälle brachliegt. Wer optimistisch plant (100), zahlt 2 625 € Strafe für ständige Notzukäufe. Die naive Mittelwertplanung liegt dazwischen — aber eben auch nicht optimal.
 
-Der **EVPI von 7 375 €** ist bemerkenswert hoch: 45 % der Gesamtkosten entstehen allein daraus, dass man die Zukunft nicht kennt. In so einem Fall lohnt sich Investition in bessere Prognosen tatsächlich — anders als in dem Beispiel aus Übung 9.4.
+Der **EVPI von 7 375 €** ist bemerkenswert hoch: 45 % der Gesamtkosten entstehen allein daraus, dass man die Zukunft nicht kennt. In so einem Fall lohnt sich Investition in bessere Prognosen tatsächlich — anders als in dem Beispiel aus der Aufgabe *EVPI interpretieren* ([Abschnitt 12.8](#sec:unsicherheit-uebungsaufgaben)).
 
 > **💡 Was ist der EVPI?** Der **Expected Value of Perfect Information**`\index{EVPI}`{=latex} beziffert, wie viel eine perfekte Prognose wert wäre: die Differenz zwischen den Kosten unter Unsicherheit und den Kosten bei vollständigem Wissen. Er ist eine **Obergrenze für jedes Prognoseprojekt**. Wenn der EVPI bei 12 000 € pro Jahr liegt, lohnt sich keine Prognosesoftware für 50 000 € — selbst wenn sie perfekt wäre. Diese Zahl bewahrt Projekte vor teuren Fehlinvestitionen.
 
@@ -13873,7 +14415,7 @@ Der szenariobasierte Weg kennt diese Fälle, weil sie in den Daten stehen. Er ko
 
 ## 12.9 Finde den Denkfehler {#sec:unsicherheit-denkfehler}
 
-> **🐛 Finde den Denkfehler 9.1: Warum jedes Projekt zu spät fertig wird**
+> **🐛 Finde den Denkfehler: Warum jedes Projekt zu spät fertig wird**
 >
 > Ein Projektleiter plant eine Umbaumaßnahme. Fünf Gewerke arbeiten **parallel** und unabhängig voneinander; fertig ist der Umbau, wenn das letzte fertig ist. Für jedes Gewerk liegt eine Schätzung vor: mindestens 6 Tage, wahrscheinlich 10, im schlechtesten Fall 18.
 >
@@ -13913,7 +14455,7 @@ Der szenariobasierte Weg kennt diese Fälle, weil sie in den Daten stehen. Er ko
 
 ## 12.10 Micro-Quiz {#sec:unsicherheit-quiz}
 
-> **❓ Micro-Quiz 9: Drei Fragen zum Selbstcheck**
+> **❓ Micro-Quiz 12: Drei Fragen zum Selbstcheck**
 >
 > Genau eine Antwort ist jeweils richtig. Auflösung in [Anhang A](#quiz-loesung-unsicherheit).
 >
@@ -14592,7 +15134,7 @@ Das Problem entsteht, sobald der Zustand **mehrere Dimensionen** hat:
 
 Bei dynamischer Programmierung entscheidet eine einzige Frage über Erfolg oder Misserfolg: **Was gehört in den Zustand?** Ist er zu klein, rechnet das Verfahren völlig korrekt — nur eben an einem anderen Problem.
 
-> **🐛 Finde den Denkfehler 10.1: Der Zustand, der zu wenig weiß**
+> **🐛 Finde den Denkfehler: Der Zustand, der zu wenig weiß**
 >
 > Eine Werkstatt plant vier Perioden. Der Bedarf beträgt 3, 1, 4, 2 Stück; produziert werden können höchstens 5 je Periode, gelagert höchstens 6 Stück.
 >
@@ -14635,7 +15177,7 @@ Bei dynamischer Programmierung entscheidet eine einzige Frage über Erfolg oder
 
 ## 13.8 Micro-Quiz {#sec:dynamische-programmierung-quiz}
 
-> **❓ Micro-Quiz 10: Drei Fragen zum Selbstcheck**
+> **❓ Micro-Quiz 13: Drei Fragen zum Selbstcheck**
 >
 > Genau eine Antwort ist jeweils richtig. Auflösung in [Anhang A](#quiz-loesung-dynamische-programmierung).
 >
@@ -14807,7 +15349,7 @@ $$
 > | --- | --- |
 > | $c(x)$ | Transportkosten des Plans $x$, in Euro. |
 > | $e(x)$ | CO₂-Ausstoß desselben Plans, in Kilogramm. |
-> | $w$ | „So viele Euro ist mir ein Kilogramm CO₂ wert.“ Ein **Wechselkurs**, kein Wichtigkeitsregler ([Abschnitt 7.9](#sec:cpsat-denkfehler)). |
+> | $w$ | „So viele Euro ist mir ein Kilogramm CO₂ wert.“ Ein **Wechselkurs**, kein Wichtigkeitsregler ([Abschnitt 7.10](#sec:cpsat-denkfehler)). |
 > | $\min_{x \in X}$ | über alle zulässigen Pläne. |
 >
 > Der Ausdruck hat eine Einheit: Euro. Damit ist $w$ keine freie Zahl zwischen 0 und 1, sondern ein CO₂-Preis in €/kg — und den kann man tatsächlich beziffern.
@@ -15939,6 +16481,44 @@ Hier war es ein einziger Parameter, mit einer Rasterschleife bestimmt. Der allge
 * Ein Kennzahlenvergleich braucht eine **Streuungsangabe**. Bei 180 Testtagen sah das schlechtere Modell in gut jedem zehnten Fall besser aus — und wer einmal misst, hat genau eine Ziehung.
 
 
+---
+
+# Synthese Teil III — Wenn die Idealwelt nicht gilt
+
+[Teil II](#teil-kernverfahren) setzte voraus: feste Daten, lineare Zusammenhänge, ein Ziel, eine Periode. Dieser Teil nimmt jede dieser vier Voraussetzungen einzeln weg. Die Tabelle ordnet die Kapitel danach, **welche** Voraussetzung bei Ihnen verletzt ist.
+
+## Welche Annahme fällt weg?
+
+| Was nicht gilt | Woran Sie es merken | Werkzeug | Kapitel |
+| --- | --- | --- | --- |
+| **Linearität** | Risiko wächst quadratisch, Kosten degressiv, Sättigung | QP, konvexe Optimierung, KKT | [Kapitel 11](#kap-qp-nlp) |
+| **Feste Daten** | Nachfrage, Wind, Rendite stehen erst morgen fest | Monte-Carlo, Zweistufigkeit, Robustheit, Chance Constraints | [Kapitel 12](#kap-unsicherheit) |
+| **Eine Periode** | die Entscheidung heute verändert, was übermorgen möglich ist | Bellman-Gleichung, Rückwärtsinduktion | [Kapitel 13](#kap-dynamische-programmierung) |
+| **Ein Ziel** | zwei Kennzahlen sollen gleichzeitig stimmen | Pareto-Front, ε-Constraint | [Kapitel 14](#kap-mehrziel) |
+| **Daten sind gegeben** | die Eingabe ist selbst eine Prognose | Predict-then-Optimize, entscheidungsorientiertes Lernen | [Kapitel 15](#kap-prognose) |
+
+Die letzte Zeile ist die unbequemste: Dort ist nicht das Modell unsicher, sondern seine **Eingabe** — und die kommt aus einem zweiten Modell, das nach anderen Kriterien gebaut wurde.
+
+## Was dieser Teil gemessen hat
+
+| Behauptung | Gemessen | Wo |
+| --- | --- | --- |
+| „Mit dem Mittelwert zu rechnen ist eine brauchbare Näherung." | Der Mittelwertplan hält seine Zusage in **50,08 %** der Fälle — per Definition | [Abschnitt 12.7](#sec:unsicherheit-chance-constraints) |
+| „Versorgungssicherheit kostet linear." | 56 289 € je Prozentpunkt auf dem Weg zu 80 %, **253 848 €** zwischen 95 und 99 % — das 4,5-fache | [Abschnitt 12.7](#sec:unsicherheit-chance-constraints) |
+| „Eine Zusage aus dem Modell hält." | Der 95-%-Plan hält **87,44 %**, sobald die Testverteilung einen Fall enthält, in dem alles zugleich ausfällt | [Abschnitt 12.7](#sec:unsicherheit-chance-constraints) |
+| „Die bessere Prognose führt zur besseren Entscheidung." | Das Modell mit dem **schlechteren** MSE trifft die günstigere Entscheidung | [Kapitel 15](#kap-prognose) |
+
+## Drei Fehler, die dieser Teil verhindert
+
+1. **Unsicherheit durch Mittelwerte ersetzen.** Der Durchschnittskunde kauft nie. Bei asymmetrischen Kosten liegt das Optimum systematisch neben dem Mittelwert, und eine Terminzusage ist ein **Quantil**, kein Erwartungswert.
+2. **Konvexität voraussetzen, ohne sie zu prüfen.** Ohne sie gibt es keine Optimalitätsgarantie, sondern nur ein lokales Ergebnis — und der Solver sagt das nicht von selbst.
+3. **Zwei Ziele mit einem Gewicht verrechnen, bevor die Front bekannt ist.** Ein Gewicht ist eine Antwort auf eine Frage, die noch niemand gestellt hat. Die Pareto-Front stellt sie zuerst.
+
+## Wenn Sie nur eines mitnehmen
+
+> **🎯** Jede der vier Annahmen lässt sich einzeln aufgeben — aber jede kostet etwas Bestimmtes: Linearität kostet die Optimalitätsgarantie, feste Daten kosten Rechenzeit oder Vorsicht, eine Periode kostet Zustandsraum, ein Ziel kostet eine Entscheidung, die nicht der Modellierer treffen darf. Wer weiß, **welche** Annahme bei ihm fällt, weiß auch, welchen Preis er zahlt.
+
+
 ---
 
 # Teil IV: Anwendungen — Energiewirtschaft und Finanzmärkte {#teil-anwendungen}
@@ -15967,7 +16547,7 @@ Er hat drei Abschnitte, und Sie können nach jedem aufhören:
 >
 > **Worum geht es?** Um den Nachweis, dass die Verfahren aus Teil II und III unverändert in der Finanzwelt funktionieren — und um die drei Stellen, an denen die Analogie endet.
 >
-> **Voraussetzungen:** [Kapitel 1](#kap-einfuehrung) (Allokation als LP), [Kapitel 12](#kap-unsicherheit) (Szenarien) und [Abschnitt 22.5](#sec:praxisfallen-or-kern) (`or_kern.py`).
+> **Voraussetzungen:** [Kapitel 1](#kap-einfuehrung) (Allokation als LP), [Kapitel 12](#kap-unsicherheit) (Szenarien) und [Abschnitt 22.6](#sec:praxisfallen-or-kern) (`or_kern.py`).
 >
 > **Danach können Sie:** ein betriebswirtschaftliches Modell in die andere Domäne übersetzen, ohne den Modellcode anzufassen; Schattenpreise in beiden Welten lesen; und benennen, welche Annahmen dabei **nicht** mitwandern.
 >
@@ -17150,6 +17730,16 @@ Was Versorgungssicherheit kostet
 
 Der Erwartungswert-Plan kostet in der Wirklichkeit **149 % mehr**, und sein schlimmster Tag ist sechsmal so teuer.
 
+**Wofür genau?** Die Summendifferenz von 523 514 € sagt noch nicht, wo sie entsteht. Zerlegt man sie nach Kostenarten, wird aus dem Befund eine Aussage, die man vorlegen kann:
+
+![Abb. 17.1: Wofür der Erwartungswert-Plan 149 % mehr bezahlt](bilder_04/kap_supplychain_wirkung.svg)
+
+Drei Dinge stehen darin, die die Tabelle nicht zeigt. Die **Anfahrkosten sind in beiden Plänen gleich** (58 000 €) — der Erwartungswert-Plan spart also nicht dort, wo man es vermuten würde. Er spart **12 725 € Brennstoff**, weil er weniger Blockstunden vorhält. Und er bezahlt dafür **536 239 € Lastabwurf**: das **42-fache** seiner Ersparnis.
+
+Genau diese Gegenüberstellung ist es, die eine Investitionsentscheidung trägt. „149 % mehr" ist eine Zahl, über die man streiten kann; „wir sparen 12 725 € und riskieren dafür 536 239 €" ist eine, über die man entscheidet.
+
+> **📌 Zum Diagramm** Es wird von `bilder_04/erzeuge_wirkung.py` erzeugt, das die Instanz aus `Kraftwerkseinsatz.py` **erneut rechnet** statt Zahlen zu übernehmen — und dabei die beiden abgedruckten Summen exakt reproduziert. Die Trennung von Brennstoff- und Abwurfkosten ist der einzige Zusatz; das Buchprogramm braucht sie nicht.
+
 Der Unterschied zwischen den beiden Plänen ist dabei erstaunlich klein:
 
 ```
@@ -17646,7 +18236,7 @@ Ein häufiges Missverständnis: Es gibt nämlich **mehrere** Ledoit-Wolf-Variant
 
 **Wichtig ist, Text und Code konsistent auf dieselbe Variante zu beziehen** — zum Beispiel `sklearn.covariance.LedoitWolf`, das die skalierte Einheitsmatrix verwendet, versus eine manuelle Implementierung des Konstant-Korrelations-Ziels. Dieses Buch nennt beide und macht transparent, welches wo zum Einsatz kommt.
 
-> **💡 Welches Ziel ist besser?** Es kommt darauf an. Die **Einheitsmatrix** unterstellt, dass alle Titel gleich riskant und unkorreliert sind — eine starke, aber sehr stabile Annahme. Das **Konstant-Korrelations-Ziel** behält die geschätzten Einzelvarianzen und glättet nur die Korrelationen; das ist bei Aktien meist realistischer, weil Titel tatsächlich sehr unterschiedliche Volatilitäten haben. In Übung 11.5 implementieren Sie es selbst und vergleichen.
+> **💡 Welches Ziel ist besser?** Es kommt darauf an. Die **Einheitsmatrix** unterstellt, dass alle Titel gleich riskant und unkorreliert sind — eine starke, aber sehr stabile Annahme. Das **Konstant-Korrelations-Ziel** behält die geschätzten Einzelvarianzen und glättet nur die Korrelationen; das ist bei Aktien meist realistischer, weil Titel tatsächlich sehr unterschiedliche Volatilitäten haben. In der Aufgabe *Beide Shrinkage-Ziele vergleichen* ([Abschnitt 18.7](#sec:finanzdaten-uebungsaufgaben)) implementieren Sie es selbst und vergleichen.
 
 Das Ergebnis ist in jedem Fall garantiert **positiv definit**, wohlkonditioniert und stabil invertierbar.
 
@@ -17843,7 +18433,7 @@ if __name__ == "__main__":
 
 ## 18.8 Finde den Denkfehler {#sec:finanzdaten-denkfehler}
 
-> **🐛 Finde den Denkfehler 11.1: Das risikofreie Portfolio**
+> **🐛 Finde den Denkfehler: Das risikofreie Portfolio**
 >
 > Ein Analyst stellt ein Portfolio aus **30 Titeln** zusammen. Für die Kovarianzmatrix nimmt er das letzte Quartal — bei Wochendaten sind das **20 Beobachtungen**. Dann minimiert er die Varianz.
 >
@@ -17913,7 +18503,8 @@ def minimales_risiko(kovarianz: np.ndarray) -> tuple[np.ndarray, float]:
     exakt positiv semidefinit ist - rechne trotzdem.' Das ist hier bewusst so
     gewaehlt, denn genau diese Eigenschaft wollen wir vorfuehren. Im
     Produktivbetrieb waere die DCP-Fehlermeldung das Warnsignal, dem man
-    nachgehen muss (siehe Denkfehler 8.1).
+    nachgehen muss (siehe den Denkfehler im Kapitel Quadratische und
+    nichtlineare Optimierung).
     """
     gewichte = cp.Variable(ANZAHL_ANLAGEN)
     problem = cp.Problem(cp.Minimize(cp.quad_form(gewichte, cp.psd_wrap(kovarianz))),
@@ -18036,7 +18627,7 @@ e 0: \mathbf{w}^	op\mathbf{S}\mathbf{w} = 0$ | „In genau diesen Richtungen mis
 
 ## 18.9 Micro-Quiz {#sec:finanzdaten-quiz}
 
-> **❓ Micro-Quiz 11: Drei Fragen zum Selbstcheck**
+> **❓ Micro-Quiz 18: Drei Fragen zum Selbstcheck**
 >
 > Genau eine Antwort ist jeweils richtig. Auflösung in [Anhang A](#quiz-loesung-finanzdaten).
 >
@@ -18727,7 +19318,7 @@ if __name__ == "__main__":
 
 [Kapitel 18](#kap-finanzdaten) hat gezeigt, was eine schlecht geschätzte **Kovarianzmatrix** anrichtet. Bei den erwarteten **Renditen** ist es schlimmer — und weil sie in der Zielfunktion stehen statt in der Nebenbedingung, fällt es schwerer auf.
 
-> **🐛 Finde den Denkfehler 12.1: Zwölf gleiche Anlagen, ein sehr ungleiches Portfolio**
+> **🐛 Finde den Denkfehler: Zwölf gleiche Anlagen, ein sehr ungleiches Portfolio**
 >
 > Ein Analyst optimiert ein Portfolio aus zwölf Anlagen. Erwartete Renditen und Kovarianzen schätzt er aus einem Jahr Tagesdaten — 250 Beobachtungen, in der Praxis durchaus üblich.
 >
@@ -18933,7 +19524,7 @@ Drei praktische Konsequenzen:
 
 ## 19.9 Micro-Quiz {#sec:markowitz-quiz}
 
-> **❓ Micro-Quiz 12: Drei Fragen zum Selbstcheck**
+> **❓ Micro-Quiz 19: Drei Fragen zum Selbstcheck**
 >
 > Genau eine Antwort ist jeweils richtig. Auflösung in [Anhang A](#quiz-loesung-markowitz).
 >
@@ -19560,7 +20151,7 @@ if __name__ == "__main__":
 
 ## 20.8 Finde den Denkfehler {#sec:cvar-denkfehler}
 
-> **🐛 Finde den Denkfehler 13.1: Das Risikobudget, das durch Diversifikation stieg**
+> **🐛 Finde den Denkfehler: Das Risikobudget, das durch Diversifikation stieg**
 >
 > Eine Bank vergibt Risikobudgets je Abteilung. Zwei Kreditabteilungen halten je eine Unternehmensanleihe über 100 € Nominal mit **4 % Ausfallwahrscheinlichkeit** (bei Ausfall Totalverlust, sonst 2 € Kupon). Der Risikocontroller misst für jede einzeln:
 >
@@ -19596,7 +20187,7 @@ if __name__ == "__main__":
 
 ## 20.9 Micro-Quiz {#sec:cvar-quiz}
 
-> **❓ Micro-Quiz 13: Drei Fragen zum Selbstcheck**
+> **❓ Micro-Quiz 20: Drei Fragen zum Selbstcheck**
 >
 > Genau eine Antwort ist jeweils richtig. Auflösung in [Anhang A](#quiz-loesung-cvar).
 >
@@ -20297,7 +20888,7 @@ Ein guter Backtest ist eine **notwendige**, keine hinreichende Bedingung. Was zw
 
 Die beiden übrigen Selbsttäuschungen sind anders gebaut. Sie entstehen nicht im Code, sondern in der **Arbeitsweise davor** — und hinterlassen im Programm keine Spur. Ein Backtest, der zwanzigmal nachjustiert wurde, sieht am Ende genauso sauber aus wie einer, der beim ersten Versuch funktioniert hat.
 
-> **🐛 Finde den Denkfehler 14.1: Die Strategie mit dem hochsignifikanten Ergebnis**
+> **🐛 Finde den Denkfehler: Die Strategie mit dem hochsignifikanten Ergebnis**
 >
 > Eine Analystin entwickelt über mehrere Wochen eine Handelsstrategie. Sie probiert verschiedene Signalfenster, Schwellenwerte, Filter und Haltedauern durch — insgesamt rund **hundert Varianten**. Die beste testet sie sauber: kein Lookahead, korrektes Universum, Transaktionskosten berücksichtigt.
 >
@@ -20505,7 +21096,7 @@ von allen Fehlversuchen genau einen: den erfolgreichsten.
 
 ## 21.10 Micro-Quiz {#sec:handelsmaschine-quiz}
 
-> **❓ Micro-Quiz 14: Drei Fragen zum Selbstcheck**
+> **❓ Micro-Quiz 21: Drei Fragen zum Selbstcheck**
 >
 > Genau eine Antwort ist jeweils richtig. Auflösung in [Anhang A](#quiz-loesung-handelsmaschine).
 >
@@ -20543,6 +21134,45 @@ von allen Fehlversuchen genau einen: den erfolgreichsten.
 **Ausblick.** [Kapitel 22](#kap-praxisfallen) zieht die Summe aus allen Teilen: die typischen Praxisfallen und der Weg vom Skript zum produktiven System.
 
 
+---
+
+# Synthese Teil IV — Zwei Domänen, dieselbe Mathematik
+
+Sechs Kapitel, zwei Branchen, die sich für unvergleichbar halten. Die Werkstatt plant Maschinen, das Depot plant Titel — und beide lösen dasselbe Problem: **knappe Mittel auf konkurrierende Verwendungen verteilen, unter Unsicherheit.**
+
+## Dieselbe Struktur, andere Namen
+
+| Werkstatt und Kraftwerk | Depot und Handel | Was mathematisch dahintersteht |
+| --- | --- | --- |
+| Produkt, Maschinenstunde | Titel, Kapital | Entscheidungsvariable |
+| Deckungsbeitrag | erwartete Rendite | linearer Zielterm |
+| Kapazität, Liefervertrag | Positionsgrenze, Sektorlimit | Nebenbedingung |
+| Rüstkosten, Anfahrkosten | Transaktionskosten | Fixkosten mit Binärvariable (B1) |
+| Lastabwurf, Konventionalstrafe | Tail-Verlust | Straf- bzw. Risikoterm |
+| Wind- und Nachfrageszenarien | Renditeszenarien | Szenariomenge |
+
+**Und wo die Analogie endet**, benennt [Kapitel 16](#kap-bruecke) an drei Stellen ausdrücklich — das ist der wertvollere Teil. Eine Analogie, die man nicht begrenzen kann, ist keine Erkenntnis, sondern eine Redewendung.
+
+## Was dieser Teil gemessen hat
+
+| Behauptung | Gemessen | Wo |
+| --- | --- | --- |
+| „Planen mit der Prognose ist gut genug." | Der Erwartungswert-Plan kostet **149 % mehr** (874 870 € statt 351 356 €) und wirft in **28 von 40** Szenarien Last ab | [Kapitel 17](#kap-supplychain) |
+| „Dann sparen wir eben beim Brennstoff." | Genau das tut er: 12 725 € gespart, **536 239 €** Lastabwurf bezahlt — das 42-fache. Die Anfahrkosten sind in beiden Plänen gleich | [Kapitel 17](#kap-supplychain) |
+| „Der VaR sagt, wie riskant es ist." | VaR **1,86 %**, CVaR **2,99 %** — und der schlechteste Tag der Stichprobe (**−23,0 %**) ändert am VaR **nichts** | [Kapitel 20](#kap-cvar) |
+| „Die Kovarianzmatrix ist eine Eingabe wie jede andere." | Aus kurzen Reihen geschätzt ist sie schlecht konditioniert; die Optimierung setzt dann auf Schätzrauschen | [Kapitel 18](#kap-finanzdaten) |
+
+## Drei Fehler, die dieser Teil verhindert
+
+1. **Bei Markowitz einsteigen.** Wer [Kapitel 18](#kap-finanzdaten) überspringt, optimiert seine eigenen Schätzfehler und wundert sich über Gewichte, die niemand halten würde.
+2. **Den VaR für ein Risikomaß halten.** Er sagt, **ob** die Schwelle gerissen wird, nicht **wie schlimm** es dahinter aussieht — und er ist nicht kohärent. Optimiert wird der CVaR.
+3. **Trägheit unterschätzen.** Im Kraftwerkspark ist nicht die Prognosegüte das Problem, sondern dass sich ein Block mit acht Stunden Mindestlaufzeit um 18 Uhr nicht mehr herbeirufen lässt. Dieselbe Trägheit heißt im Depot Transaktionskosten.
+
+## Wenn Sie nur eines mitnehmen
+
+> **🎯** Wer die Struktur erkennt, kann sein Werkzeug mitnehmen, wenn er die Branche wechselt. Wer nur die Bibliothek kennt, fängt jedes Mal von vorn an — und wer die Grenzen der Analogie nicht kennt, überträgt irgendwann auch das, was nicht überträgt.
+
+
 ---
 
 # Teil V: Praxis {#teil-praxis}
@@ -20564,6 +21194,7 @@ von allen Fehlversuchen genau einen: den erfolgreichsten.
 > **Programme:**\
 > `Infeasibility_Diagnose.py`\
 > `Erklaerbarkeit.py`\
+> `Constraint_Attribution.py`\
 > `Betriebsueberwachung.py`\
 > `or_kern.py`\
 > `Solverwechsel_CPSAT_HiGHS.py`
@@ -20623,12 +21254,13 @@ Nach diesem Kapitel können Sie …
 1. … die fünf typischen Praxisfallen benennen und je ein Gegenmittel nennen.
 2. … ein unlösbares Modell in einen „am wenigsten schlechten“ Plan verwandeln.
 3. … Solver-Ergebnisse erklärbar machen (*Explainable OR*).
-4. … Zeitlimits und Optimalitätslücken sinnvoll setzen.
-5. … die Architektur einer produktionsreifen OR-Plattform skizzieren.
-6. … eine **modellunabhängige Abnahmeprüfung** schreiben, die eine Lösung gegen die Anforderungen prüft statt gegen das Modell.
-7. … Status, Gap und Zeitausschöpfung protokollieren und begründen, warum eine konstante Laufzeit bei Zeitlimit ein Warnsignal ist.
-8. … ein Modell in Domänenschicht, Modellbauer und Lösungs-DTO trennen — und begründen, warum sich das nicht wegen des Solverwechsels lohnt, sondern wegen der Prüfbarkeit.
-9. … die Statuswerte verschiedener Solverbibliotheken auf eine gemeinsame Sprache abbilden.
+4. … für jede Nebenbedingung beziffern, was sie den Plan kostet — und begründen, warum der Schattenpreis diese Frage nur für die *nächste* Einheit beantwortet.
+5. … Zeitlimits und Optimalitätslücken sinnvoll setzen.
+6. … die Architektur einer produktionsreifen OR-Plattform skizzieren.
+7. … eine **modellunabhängige Abnahmeprüfung** schreiben, die eine Lösung gegen die Anforderungen prüft statt gegen das Modell.
+8. … Status, Gap und Zeitausschöpfung protokollieren und begründen, warum eine konstante Laufzeit bei Zeitlimit ein Warnsignal ist.
+9. … ein Modell in Domänenschicht, Modellbauer und Lösungs-DTO trennen — und begründen, warum sich das nicht wegen des Solverwechsels lohnt, sondern wegen der Prüfbarkeit.
+10. … die Statuswerte verschiedener Solverbibliotheken auf eine gemeinsame Sprache abbilden.
 
 ---
 
@@ -20889,6 +21521,8 @@ if __name__ == "__main__":
 
 Der letzte Punkt ist der eigentliche Lerneffekt: Die Obergrenze schließt Ben zwar technisch aus, aber selbst wenn er dürfte, wäre er wegen seiner Vorbelastung immer noch teurer als Anna. **Eine bindende Bedingung zu lockern hilft nur, wenn sie tatsächlich die kostenrelevante ist** — sonst ist die Mühe umsonst.
 
+Derselbe Unterschied kehrt auf Modellebene wieder, und dort lässt er sich in Euro beziffern: [Abschnitt 22.4](#sec:praxisfallen-attribution) misst für jede Bedingung, was sie den ganzen Plan kostet — und baut daraus einen Bericht, den man vorlegen kann.
+
 ### Falle 3 — Regimewechsel und Schätzfehler
 
 Ein Modell, das auf einer mehrjährigen Aufwärtsphase kalibriert wurde, kennt keine Liquiditätskrise und keine Zinswende.
@@ -20918,7 +21552,457 @@ Exakte Optimalität kann bei MILP oder CP-SAT Minuten bis Stunden dauern — und
 
 ---
 
-## 22.4 Architektur einer produktionsreifen OR-Plattform {#sec:praxisfallen-architektur-einer-produktionsreifen-or-plattform}
+## 22.4 Constraint Attribution: welche Bedingung kostet wie viel? {#sec:praxisfallen-attribution}
+
+Der Constraint-Trace beantwortet „warum **diese** Zuweisung?“. Der Deletion Filter in [Anhang C](#anhang-fehlerdiagnose) beantwortet „warum geht es **gar nicht**?“. Der häufigste Fall in der Praxis liegt dazwischen, und für ihn hat bisher niemand ein Werkzeug bekommen:
+
+> *Das Modell rechnet. Der Plan ist zulässig. Und trotzdem ist er enttäuschend — nur weiß niemand, woran es liegt.*
+
+Die Antwort heißt **Constraint Attribution**`\index{Constraint Attribution}`{=latex}: Jede Bedingungsgruppe wird einzeln gelockert, und gemessen wird, was sich am Zielwert ändert. Das ist dasselbe Verfahren wie der Deletion Filter — nur mit **Kosten** statt Zulässigkeit als Kriterium.
+
+Gerechnet wird auf derselben Fabrik wie die Konfliktsuche in [Anhang C](#anhang-fehlerdiagnose), aber **nach der Reparatur**: Dort war die Lackierkapazität von 150 Stunden der Kern des Widerspruchs ($2 \cdot 40 + 3 \cdot 30 = 170 > 150$). Eine zweite Schicht hat sie auf 210 gebracht, der Mindestumsatz wurde auf 10 000 € gesenkt. Jetzt ist das Modell lösbar — und die Frage lautet nicht mehr „warum nicht?“, sondern „was kostet uns was?“.
+
+```python
+#!/usr/bin/env python3
+
+# Constraint_Attribution.py
+"""
+Kapitel Praxisfallen: Welche Bedingung kostet wie viel - und was sagt man
+dem Management?
+
+Zwischen den beiden bekannten Faellen klafft eine Luecke:
+
+  * Erklaerbarkeit.py beantwortet "warum diese eine Zuweisung?"
+  * Konfliktsuche.py (Anhang Fehlerdiagnose) beantwortet "warum geht es gar
+    nicht?"
+
+Der haeufigste Fall in der Praxis liegt dazwischen: Das Modell rechnet, der
+Plan ist zulaessig - und trotzdem unbefriedigend. Niemand weiss, WORAN es
+liegt. Genau das beantwortet Constraint Attribution.
+
+Gerechnet wird auf derselben Fabrik wie in Konfliktsuche.py, nur nach der
+Reparatur: Dort war die Lackierkapazitaet von 150 Stunden der Kern des
+Widerspruchs (2*40 + 3*30 = 170 > 150). Eine zweite Schicht hat sie auf 210
+gebracht, und der Mindestumsatz wurde auf 10.000 EUR gesenkt. Jetzt ist das
+Modell loesbar - und die Frage lautet nicht mehr "warum nicht?", sondern
+"was kostet uns was?".
+
+Gezeigt werden vier Dinge:
+  1. Welche Bedingungen binden - und dass "bindend" nicht "teuer" heisst.
+  2. Dass der Schattenpreis eine MOMENTAUFNAHME ist: hochgerechnet auf eine
+     realistische Sonderschicht verspricht er hier das Doppelte des
+     tatsaechlichen Nutzens.
+  3. Dass ein Wunsch aus dem Vertrieb nicht teuer, sondern unmoeglich sein
+     kann - und welche Bedingungen ihn gemeinsam blockieren.
+  4. Wie aus alledem ein Bericht in Alltagssprache wird.
+
+Benoetigt: numpy, scipy
+"""
+
+from __future__ import annotations
+
+import textwrap
+
+import numpy as np
+from scipy.optimize import linprog
+
+PRODUKTE = ["Rahmen", "Gehaeuse", "Deckel", "Traeger", "Halter"]
+DECKUNGSBEITRAG = np.array([35.0, 28.0, 9.0, 22.0, 6.0])   # EUR je Stueck
+
+# Dieselben Bedingungen wie in Konfliktsuche.py, mit den beiden Reparaturen.
+# Der sprechende Name ist keine Kosmetik: Ohne ihn ist kein Bericht moeglich,
+# der jemandem ausserhalb der Modellierung etwas sagt.
+BEDINGUNGEN: list[tuple[str, list[float], str, float]] = [
+    ("Kapazitaet Montage",       [3, 2, 1, 4, 2],      "<=",   400),
+    ("Kapazitaet Lackieren",     [2, 3, 0, 1, 0],      "<=",   210),
+    ("Kapazitaet Pruefung",      [1, 1, 1, 1, 1],      "<=",   300),
+    ("Liefervertrag Rahmen",     [1, 0, 0, 0, 0],      ">=",    40),
+    ("Liefervertrag Gehaeuse",   [0, 1, 0, 0, 0],      ">=",    30),
+    ("Liefervertrag Deckel",     [0, 0, 1, 0, 0],      ">=",    20),
+    ("Liefervertrag Traeger",    [0, 0, 0, 1, 0],      ">=",    25),
+    ("Marktgrenze Rahmen",       [1, 0, 0, 0, 0],      "<=",   120),
+    ("Marktgrenze Gehaeuse",     [0, 1, 0, 0, 0],      "<=",    90),
+    ("Marktgrenze Deckel",       [0, 0, 1, 0, 0],      "<=",   150),
+    ("Marktgrenze Halter",       [0, 0, 0, 0, 1],      "<=",   200),
+    ("Mindestumsatz",            [90, 70, 30, 60, 20], ">=", 10000),
+    ("Sortimentsbreite",         [0, 0, 1, 1, 1],      ">=",   100),
+    ("Lackierbudget Schicht 2",  [0, 1, 0, 1, 0],      "<=",    55),
+]
+
+# Was liesse sich im Ernstfall wirklich bewegen - und um wie viel? Nicht "eine
+# Einheit", sondern der Schritt, den ein Planer tatsaechlich gehen kann: eine
+# Sonderschicht, ein nachverhandelter Vertrag. Genau an dieser Groesse
+# scheitert das blosse Hochrechnen des Schattenpreises.
+STELLSCHRAUBEN: dict[str, tuple[float, str]] = {
+    "Kapazitaet Montage":      (+50, "eine Sonderschicht Montage"),
+    "Kapazitaet Lackieren":    (+30, "eine Sonderschicht Lackieren"),
+    "Kapazitaet Pruefung":     (+50, "eine Sonderschicht Pruefung"),
+    "Lackierbudget Schicht 2": (+10, "10 Stunden mehr Budget in Schicht 2"),
+    "Liefervertrag Traeger":   (-10, "10 Stueck weniger Abnahmepflicht Traeger"),
+    "Liefervertrag Gehaeuse":  (-10, "10 Stueck weniger Abnahmepflicht Gehaeuse"),
+}
+
+WUNSCH_MENGE = 55.0      # der Vertrieb haette gern mehr Rahmen
+WUNSCH_PRODUKT = "Rahmen"
+
+
+def loese(bedingungen: list[tuple[str, list[float], str, float]]):
+    """Maximiert den Deckungsbeitrag. linprog minimiert, daher das Vorzeichen."""
+    matrix, rechte_seite = [], []
+    for _, koeffizienten, richtung, grenze in bedingungen:
+        zeile = np.array(koeffizienten, dtype=float)
+        matrix.append(zeile if richtung == "<=" else -zeile)
+        rechte_seite.append(grenze if richtung == "<=" else -grenze)
+    return linprog(-DECKUNGSBEITRAG,
+                   A_ub=np.array(matrix), b_ub=np.array(rechte_seite),
+                   bounds=[(0, None)] * len(PRODUKTE), method="highs")
+
+
+def geaendert(name: str, delta: float,
+              basis=None) -> list[tuple[str, list[float], str, float]]:
+    """Dieselben Bedingungen, eine davon um delta verschoben."""
+    return [(n, k, r, g + delta if n == name else g)
+            for n, k, r, g in (basis or BEDINGUNGEN)]
+
+
+def auswertung(ergebnis, bedingungen=None):
+    """Schlupf und Schattenpreis je Bedingung."""
+    x = ergebnis.x
+    dual = ergebnis.ineqlin.marginals
+    zeilen = []
+    for i, (name, koeff, richtung, grenze) in enumerate(bedingungen or BEDINGUNGEN):
+        links = float(np.array(koeff, dtype=float) @ x)
+        schlupf = (grenze - links) if richtung == "<=" else (links - grenze)
+        zeilen.append((name, links, richtung, grenze, schlupf, abs(dual[i])))
+    return zeilen
+
+
+def blockierer(bedingungen, zusatz) -> list[str]:
+    """Welche Bedingungen verhindern 'zusatz' - einzeln weggelassen.
+
+    Dasselbe Vorgehen wie der Deletion Filter in Konfliktsuche.py, nur mit
+    umgekehrtem Vorzeichen: Dort wird gesucht, was den Widerspruch AUSMACHT,
+    hier, was einen Wunsch VERHINDERT. Wird das Modell ohne eine Bedingung
+    loesbar, gehoert sie zum Konflikt.
+    """
+    gefunden = []
+    for i, (name, _, _, _) in enumerate(bedingungen):
+        rest = [c for j, c in enumerate(bedingungen) if j != i] + [zusatz]
+        if loese(rest).success:
+            gefunden.append(name)
+    return gefunden
+
+
+def euro(betrag: float) -> str:
+    return f"{betrag:,.2f} EUR"
+
+
+if __name__ == "__main__":
+    basis = loese(BEDINGUNGEN)
+    db_basis = -basis.fun
+    plan = dict(zip(PRODUKTE, basis.x))
+
+    print("=" * 78)
+    print("  CONSTRAINT ATTRIBUTION: Was kostet uns welche Bedingung?")
+    print("=" * 78)
+    print(f"Status: {basis.message.split('(')[0].strip()}")
+    print(f"Deckungsbeitrag des Plans: {euro(db_basis)}\n")
+    print("  " + "  ".join(f"{p}: {m:.1f}" for p, m in plan.items()))
+
+    # --- 1. Wer begrenzt den Plan? -----------------------------------------
+    print("\n" + "=" * 78)
+    print("  (1) Welche Bedingungen binden - und was kostet die naechste Einheit?")
+    print("=" * 78)
+    print(f"{'Bedingung':<24} {'genutzt':>9} {'Grenze':>7} {'Schlupf':>8} "
+          f"{'Schattenpreis':>11}")
+    print("-" * 78)
+    bindend = []
+    for name, links, richtung, grenze, schlupf, dual in auswertung(basis):
+        marke = ""
+        if abs(schlupf) < 1e-6:
+            bindend.append((name, dual))
+            marke = "  <-- bindend"
+        print(f"{name:<24} {links:>9.1f} {grenze:>7.0f} {schlupf:>8.1f} "
+              f"{dual:>11.2f}{marke}")
+
+    ohne_preis = [n for n, d in bindend if d < 1e-9]
+    print(f"\n  {len(bindend)} Bedingungen binden. Aber: "
+          f"{', '.join(ohne_preis)} bindet")
+    print("  mit einem Schattenpreis von 0,00 EUR - sie beruehrt den Plan, ohne ihn")
+    print("  zu verteuern. Bindend und kostenrelevant sind zwei verschiedene Dinge.")
+
+    # --- 2. Der Schattenpreis als Momentaufnahme ---------------------------
+    print("\n" + "=" * 78)
+    print("  (2) Was der Schattenpreis verschweigt")
+    print("=" * 78)
+    print("Der Schattenpreis gilt fuer die NAECHSTE Einheit. Ein Planer kauft aber")
+    print("keine Einheit, sondern eine ganze Schicht. Beides gegenuebergestellt:\n")
+    preise = {name: dual for name, *_, dual in auswertung(basis)}
+    print(f"{'Stellschraube':<24} {'Preis':>9} {'Schritt':>7} "
+          f"{'hochgerechnet':>13} {'gemessen':>9} {'Abw.':>9}")
+    print("-" * 78)
+    wirkung = {}
+    for name, (delta, _) in STELLSCHRAUBEN.items():
+        ergebnis = loese(geaendert(name, delta))
+        echt = (-ergebnis.fun) - db_basis if ergebnis.success else 0.0
+        linear = preise[name] * abs(delta)
+        wirkung[name] = echt
+        print(f"{name:<24} {preise[name]:>9.2f} {delta:>+7.0f} "
+              f"{linear:>13.2f} {echt:>9.2f} {echt - linear:>+9.2f}")
+
+    # Wo endet der Gueltigkeitsbereich? Schrittweise nachfahren.
+    abweichler = max(STELLSCHRAUBEN,
+                     key=lambda n: preise[n] * abs(STELLSCHRAUBEN[n][0]) - wirkung[n])
+    delta_max = STELLSCHRAUBEN[abweichler][0]
+    grenze_gueltig = 0.0
+    schritt = delta_max / 60.0
+    vorher = db_basis
+    for i in range(1, 61):
+        d = schritt * i
+        e = loese(geaendert(abweichler, d))
+        db = -e.fun if e.success else vorher
+        if db - vorher > 1e-9:
+            grenze_gueltig = d
+        vorher = db
+    print(f"\n  '{abweichler}': hochgerechnet "
+          f"{preise[abweichler] * abs(delta_max):.2f} EUR, tatsaechlich "
+          f"{wirkung[abweichler]:.2f} EUR.")
+    print(f"  Der Preis von {preise[abweichler]:.2f} EUR gilt nur bis "
+          f"+{grenze_gueltig:.0f} Stunden. Jede weitere Stunde")
+    print("  dieser Sonderschicht bringt exakt nichts - der Engpass ist dann ein anderer.")
+
+    nach_preis = sorted(STELLSCHRAUBEN, key=lambda n: -preise[n])[0]
+    nach_wirkung = max(wirkung, key=wirkung.get)
+    print(f"\n  Und die Ranglisten drehen sich: Nach Schattenpreis fuehrt")
+    print(f"  '{nach_preis}' ({preise[nach_preis]:.2f} EUR je Einheit),")
+    print(f"  nach tatsaechlicher Wirkung '{nach_wirkung}' "
+          f"({wirkung[nach_wirkung]:.2f} EUR).")
+    print("  Der Schattenpreis sagt, was eine Einheit wert ist - nicht, wie viele")
+    print("  Einheiten zu haben sind.")
+
+    # --- 3. Der Wunsch aus dem Vertrieb ------------------------------------
+    print("\n" + "=" * 78)
+    print(f"  (3) Was-waere-wenn: mindestens {WUNSCH_MENGE:.0f} "
+          f"{WUNSCH_PRODUKT} statt {plan[WUNSCH_PRODUKT]:.1f}")
+    print("=" * 78)
+    wunsch = (f"Wunsch Vertrieb {WUNSCH_PRODUKT}",
+              [1 if p == WUNSCH_PRODUKT else 0 for p in PRODUKTE], ">=", WUNSCH_MENGE)
+    mit_wunsch = loese(BEDINGUNGEN + [wunsch])
+    schuldige: list[str] = []
+    engpass = noetig = None
+    wunsch_gratis = False
+
+    if mit_wunsch.success:
+        print(f"Erfuellbar, kostet {euro(db_basis - (-mit_wunsch.fun))}.")
+    else:
+        schuldige = blockierer(BEDINGUNGEN, wunsch)
+        print("Der Wunsch ist nicht teuer - er ist UNMOEGLICH.\n")
+        print(f"Blockiert wird er von {len(schuldige)} Bedingungen gemeinsam. "
+              f"Faellt eine davon")
+        print("weg, ist er erfuellbar; keine allein ist 'der' Grund:")
+        for name in schuldige:
+            e = loese([c for c in BEDINGUNGEN if c[0] != name] + [wunsch])
+            print(f"   ohne '{name}': moeglich, Deckungsbeitrag {euro(-e.fun)}")
+
+        engpass = next((n for n in schuldige if n in STELLSCHRAUBEN), schuldige[0])
+        for schritt in range(1, 61):
+            if loese(geaendert(engpass, schritt) + [wunsch]).success:
+                noetig = schritt
+                break
+        if noetig is not None:
+            e = loese(geaendert(engpass, noetig) + [wunsch])
+            ohne = loese(geaendert(engpass, noetig))
+            wunsch_gratis = abs((-e.fun) - (-ohne.fun)) < 1e-6
+            print(f"\n   Mit +{noetig} bei '{engpass}' wird der Wunsch erfuellbar:")
+            print(f"   Deckungsbeitrag {euro(-e.fun)} "
+                  f"({-e.fun - db_basis:+,.2f} gegenueber heute).")
+            if wunsch_gratis:
+                print(f"   Und ohne den Wunsch ergaebe dieselbe Lockerung "
+                      f"{euro(-ohne.fun)} bei")
+                print(f"   {ohne.x[PRODUKTE.index(WUNSCH_PRODUKT)]:.0f} "
+                      f"{WUNSCH_PRODUKT} - der Wunsch kostet also NICHTS.")
+                print("   Er war nie das Problem. Der Engpass war es.")
+
+    # --- 4. Der Bericht ----------------------------------------------------
+    # Aus denselben Zahlen, die oben in Tabellen stehen, wird hier Prosa. Kein
+    # Satz enthaelt eine Zahl, die nicht vorher gerechnet wurde - das ist der
+    # ganze Trick und zugleich die Bedingung dafuer, dass der Bericht nicht
+    # irgendwann leise falsch wird.
+    print("\n" + "=" * 78)
+    print("  (4) Und so steht es in der Vorlage fuer die Abteilungsleiterrunde")
+    print("=" * 78)
+
+    teuerste = sorted(((n, d) for n, d in bindend if d > 0), key=lambda t: -t[1])
+    gross = STELLSCHRAUBEN[nach_wirkung][1]
+    klein = STELLSCHRAUBEN[abweichler][1]
+
+    absaetze = [
+        f"Der Plan bringt {euro(db_basis)} Deckungsbeitrag. Begrenzt wird er von "
+        f"{len(bindend)} Bedingungen, von denen {len(teuerste)} tatsaechlich Geld "
+        f"kosten; \"{ohne_preis[0]}\" beruehrt den Plan, ohne ihn zu verteuern.",
+
+        f"Teuerste Bindung ist \"{teuerste[0][0]}\" mit "
+        f"{teuerste[0][1]:.2f} EUR je Einheit, gefolgt von \"{teuerste[1][0]}\" "
+        f"mit {teuerste[1][1]:.2f} EUR.",
+
+        f"Die groesste einzelne Verbesserung bringt {gross}: "
+        f"{euro(wirkung[nach_wirkung])} mehr Deckungsbeitrag. {klein[0].upper()}{klein[1:]} "
+        f"dagegen bringt nur {euro(wirkung[abweichler])} statt der rechnerischen "
+        f"{euro(preise[abweichler] * abs(delta_max))} - ab +{grenze_gueltig:.0f} "
+        f"Stunden begrenzt uns etwas anderes. Wer die ganze Schicht bezahlt, "
+        f"bezahlt die zweite Haelfte umsonst.",
+    ]
+
+    if schuldige and noetig is not None:
+        namen = ", ".join(f'"{s}"' for s in schuldige)
+        satz = (f"Zum Wunsch des Vertriebs ({WUNSCH_MENGE:.0f} {WUNSCH_PRODUKT} statt "
+                f"{plan[WUNSCH_PRODUKT]:.1f}): Er ist mit der heutigen Ausstattung "
+                f"nicht erfuellbar - nicht aus Kostengruenden, sondern weil {namen} "
+                f"ihn gemeinsam blockieren. Mit +{noetig} Stunden bei "
+                f'"{engpass}" wird er moeglich')
+        satz += (", und er kostet dann nichts: Der Plan waehlt diese Menge von "
+                 "sich aus." if wunsch_gratis else ".")
+        absaetze.append(satz)
+
+    for absatz in absaetze:
+        print()
+        print(textwrap.fill(absatz, width=76))
+    print("\n" + "=" * 78)
+```
+
+**Ausgabe:**
+
+```
+==============================================================================
+  CONSTRAINT ATTRIBUTION: Was kostet uns welche Bedingung?
+==============================================================================
+Status: Optimization terminated successfully.
+Deckungsbeitrag des Plans: 3,930.00 EUR
+
+  Rahmen: 47.5  Gehaeuse: 30.0  Deckel: 97.5  Traeger: 25.0  Halter: 0.0
+
+==============================================================================
+  (1) Welche Bedingungen binden - und was kostet die naechste Einheit?
+==============================================================================
+Bedingung                  genutzt  Grenze  Schlupf Schattenpreis
+------------------------------------------------------------------------------
+Kapazitaet Montage           400.0     400      0.0        9.00  <-- bindend
+Kapazitaet Lackieren         210.0     210      0.0        4.00  <-- bindend
+Kapazitaet Pruefung          200.0     300    100.0        0.00
+Liefervertrag Rahmen          47.5      40      7.5        0.00
+Liefervertrag Gehaeuse        30.0      30      0.0        2.00  <-- bindend
+Liefervertrag Deckel          97.5      20     77.5        0.00
+Liefervertrag Traeger         25.0      25      0.0       18.00  <-- bindend
+Marktgrenze Rahmen            47.5     120     72.5        0.00
+Marktgrenze Gehaeuse          30.0      90     60.0        0.00
+Marktgrenze Deckel            97.5     150     52.5        0.00
+Marktgrenze Halter             0.0     200    200.0        0.00
+Mindestumsatz              10800.0   10000    800.0        0.00
+Sortimentsbreite             122.5     100     22.5        0.00
+Lackierbudget Schicht 2       55.0      55      0.0        0.00  <-- bindend
+
+  5 Bedingungen binden. Aber: Lackierbudget Schicht 2 bindet
+  mit einem Schattenpreis von 0,00 EUR - sie beruehrt den Plan, ohne ihn
+  zu verteuern. Bindend und kostenrelevant sind zwei verschiedene Dinge.
+
+==============================================================================
+  (2) Was der Schattenpreis verschweigt
+==============================================================================
+Der Schattenpreis gilt fuer die NAECHSTE Einheit. Ein Planer kauft aber
+keine Einheit, sondern eine ganze Schicht. Beides gegenuebergestellt:
+
+Stellschraube                Preis Schritt hochgerechnet  gemessen      Abw.
+------------------------------------------------------------------------------
+Kapazitaet Montage            9.00     +50        450.00    450.00     +0.00
+Kapazitaet Lackieren          4.00     +30        120.00     60.00    -60.00
+Kapazitaet Pruefung           0.00     +50          0.00      0.00     +0.00
+Lackierbudget Schicht 2       0.00     +10          0.00      0.00     +0.00
+Liefervertrag Traeger        18.00     -10        180.00    180.00     +0.00
+Liefervertrag Gehaeuse        2.00     -10         20.00     18.00     -2.00
+
+  'Kapazitaet Lackieren': hochgerechnet 120.00 EUR, tatsaechlich 60.00 EUR.
+  Der Preis von 4.00 EUR gilt nur bis +15 Stunden. Jede weitere Stunde
+  dieser Sonderschicht bringt exakt nichts - der Engpass ist dann ein anderer.
+
+  Und die Ranglisten drehen sich: Nach Schattenpreis fuehrt
+  'Liefervertrag Traeger' (18.00 EUR je Einheit),
+  nach tatsaechlicher Wirkung 'Kapazitaet Montage' (450.00 EUR).
+  Der Schattenpreis sagt, was eine Einheit wert ist - nicht, wie viele
+  Einheiten zu haben sind.
+
+==============================================================================
+  (3) Was-waere-wenn: mindestens 55 Rahmen statt 47.5
+==============================================================================
+Der Wunsch ist nicht teuer - er ist UNMOEGLICH.
+
+Blockiert wird er von 3 Bedingungen gemeinsam. Faellt eine davon
+weg, ist er erfuellbar; keine allein ist 'der' Grund:
+   ohne 'Kapazitaet Lackieren': moeglich, Deckungsbeitrag 3,990.00 EUR
+   ohne 'Liefervertrag Gehaeuse': moeglich, Deckungsbeitrag 3,948.00 EUR
+   ohne 'Liefervertrag Traeger': moeglich, Deckungsbeitrag 4,320.00 EUR
+
+   Mit +15 bei 'Kapazitaet Lackieren' wird der Wunsch erfuellbar:
+   Deckungsbeitrag 3,990.00 EUR (+60.00 gegenueber heute).
+   Und ohne den Wunsch ergaebe dieselbe Lockerung 3,990.00 EUR bei
+   55 Rahmen - der Wunsch kostet also NICHTS.
+   Er war nie das Problem. Der Engpass war es.
+
+==============================================================================
+  (4) Und so steht es in der Vorlage fuer die Abteilungsleiterrunde
+==============================================================================
+
+Der Plan bringt 3,930.00 EUR Deckungsbeitrag. Begrenzt wird er von 5
+Bedingungen, von denen 4 tatsaechlich Geld kosten; "Lackierbudget Schicht 2"
+beruehrt den Plan, ohne ihn zu verteuern.
+
+Teuerste Bindung ist "Liefervertrag Traeger" mit 18.00 EUR je Einheit,
+gefolgt von "Kapazitaet Montage" mit 9.00 EUR.
+
+Die groesste einzelne Verbesserung bringt eine Sonderschicht Montage: 450.00
+EUR mehr Deckungsbeitrag. Eine Sonderschicht Lackieren dagegen bringt nur
+60.00 EUR statt der rechnerischen 120.00 EUR - ab +15 Stunden begrenzt uns
+etwas anderes. Wer die ganze Schicht bezahlt, bezahlt die zweite Haelfte
+umsonst.
+
+Zum Wunsch des Vertriebs (55 Rahmen statt 47.5): Er ist mit der heutigen
+Ausstattung nicht erfuellbar - nicht aus Kostengruenden, sondern weil
+"Kapazitaet Lackieren", "Liefervertrag Gehaeuse", "Liefervertrag Traeger"
+ihn gemeinsam blockieren. Mit +15 Stunden bei "Kapazitaet Lackieren" wird er
+moeglich, und er kostet dann nichts: Der Plan waehlt diese Menge von sich
+aus.
+
+==============================================================================
+```
+
+### Drei Befunde, und keiner steht im Solverergebnis
+
+**Erstens: bindend heißt nicht teuer.** Fünf Bedingungen binden, aber „Lackierbudget Schicht 2“ tut es mit einem Schattenpreis von **0,00 €**. Sie berührt den Plan, ohne ihn zu verteuern — wer sie nachverhandelt, gewinnt nichts. Das ist derselbe Unterschied, den `Erklaerbarkeit.py` oben an einer einzelnen Zuweisung zeigt, hier im Dualwert eines LP.
+
+**Zweitens: Der Schattenpreis ist eine Momentaufnahme.** Er gilt für die **nächste** Einheit. Ein Planer kauft aber keine Einheit, sondern eine Schicht. Für die Lackiererei verspricht die Hochrechnung $4{,}00 \cdot 30 = 120$ €; gemessen kommen **60 €**. Der Preis von 4,00 € gilt exakt bis **+15 Stunden**, danach begrenzt etwas anderes — **die zweite Hälfte der Sonderschicht wäre bezahlt und wirkungslos.**
+
+Und die Ranglisten drehen sich dabei um: Nach Schattenpreis führt der Trägervertrag mit 18,00 € je Stück, nach tatsächlicher Wirkung die Montage-Sonderschicht mit 450 €. Der Schattenpreis sagt, was **eine** Einheit wert ist — nicht, wie viele Einheiten zu haben sind. Für die Frage „welchen Hebel ziehen wir?“ ist das der entscheidende Unterschied.
+
+**Drittens: Ein Wunsch kann unmöglich statt teuer sein.** Der Vertrieb hätte gern 55 Rahmen statt 47,5. Das Modell antwortet nicht mit einem Preis, sondern mit `INFEASIBLE` — und drei Bedingungen blockieren den Wunsch **gemeinsam**: Fällt eine davon weg, ist er erfüllbar, keine allein ist „der“ Grund. Genau die Struktur, die [Anhang C](#anhang-fehlerdiagnose) für den unlösbaren Fall beschreibt, hier auf einen Wunsch angewandt.
+
+Die Pointe steht am Ende: Mit +15 Stunden Lackierkapazität wird der Wunsch erfüllbar — und kostet dann **nichts**. Der Plan wählt diese Menge von sich aus, sobald der Engpass weg ist. Der Konflikt bestand nie zwischen Vertrieb und Produktion. Er bestand zwischen dem Vertrieb und der Lackiererei, und niemand wusste das.
+
+> **🎯 Die drei Fragen, jetzt auf Modellebene** Die Faustregel oben stellt sie für eine einzelne Zuweisung. Constraint Attribution stellt dieselben drei für den **ganzen Plan**:
+> 1. **Warum dieser Zielwert?** — welche Bedingungen binden, und welche davon kosten Geld.
+> 2. **Warum nicht besser?** — was eine realistische Lockerung wirklich bringt, gemessen statt hochgerechnet.
+> 3. **Was ist mit meinem Wunsch?** — erfüllbar und zu welchem Preis, oder unmöglich und warum.
+
+### Vom Zahlenwerk zur Vorlage
+
+Alle drei Antworten stehen bis hierhin in Tabellen. Tabellen liest niemand in einer Abteilungsleiterrunde. Teil (4) des Programms baut aus **denselben** Zahlen einen Text — und das ist weniger trivial, als es aussieht:
+
+* **Kein Satz enthält eine Zahl, die nicht vorher gerechnet wurde.** Auch nicht die Rangfolge, auch nicht die Namen der blockierenden Bedingungen. Sobald sich das Modell ändert, ändert sich der Bericht mit — er kann nicht leise falsch werden.
+* **Der sprechende Name jeder Bedingung ist die Voraussetzung dafür.** `A_ub[7]` ergibt keinen Satz. Deshalb tragen die Bedingungen in beiden Programmen einen Namen, und deshalb ist das keine Kosmetik.
+
+> **⚠️ Was ein solcher Bericht nicht leistet** Er erklärt das **Modell**, nicht die **Wirklichkeit**. „Liefervertrag Träger kostet 18 € je Stück“ heißt: *in diesem Modell, mit diesen Deckungsbeiträgen*. Ist ein Deckungsbeitrag falsch geschätzt, ist der Bericht überzeugend **und** falsch — die gefährlichste Kombination. Ein generierter Text macht ein Modell nicht richtiger, nur schwerer anzuzweifeln. Deshalb gehört zu jedem solchen Bericht die Angabe, worauf er beruht.
+
+---
+
+## 22.5 Architektur einer produktionsreifen OR-Plattform {#sec:praxisfallen-architektur-einer-produktionsreifen-or-plattform}
 
 ![Abb. 22.2: Architektur einer produktionsreifen OR-Plattform](bilder_04/kap15_or_plattform.svg)
 
@@ -20945,7 +22029,7 @@ In einer professionellen Umgebung ist der Optimierer kein Skript, sondern ein **
 
 ---
 
-## 22.5 Der gemeinsame Unterbau: `or_kern.py` {#sec:praxisfallen-or-kern}
+## 22.6 Der gemeinsame Unterbau: `or_kern.py` {#sec:praxisfallen-or-kern}
 
 Die fünf Prinzipien oben beschreiben eine Plattform. Der Weg dorthin beginnt aber viel kleiner — mit der Frage, welche Teile eines Optimierungsprogramms **immer dieselben** sind.
 
@@ -21537,7 +22621,7 @@ Domaenenschicht.
 > | --- | --- | --- |
 > | `PositiveZahl = Annotated[float, Field(gt=0)]` | Prüfung im **Typ**, nicht im Code | Sie gilt damit überall, wo der Typ verwendet wird — man kann sie nicht vergessen. |
 > | `SolverStatus.brauchbar` | fragt „habe ich etwas in der Hand?“ | Nicht „war der Solver erfolgreich?“. `ZULAESSIG` ist im Betrieb meist völlig ausreichend ([Abschnitt 6.8](#sec:milp-gap)). |
-> | `SolverStatus.modellfehler` | trennt Modell- von Zeitproblemen | Genau die Unterscheidung, die [Abschnitt 7.7](#sec:cpsat-statusfaelle) als häufigste Verwechslung benennt. |
+> | `SolverStatus.modellfehler` | trennt Modell- von Zeitproblemen | Genau die Unterscheidung, die [Abschnitt 7.8](#sec:cpsat-statusfaelle) als häufigste Verwechslung benennt. |
 > | `model_validator(mode="after")` | prüft Zusammenhänge **zwischen** Feldern | Einzelne Felder prüft Pydantic selbst; dass jedes Produkt nur bekannte Ressourcen verbraucht, muss man sagen. |
 > | `ressourcen` als sortierte Liste | feste Spaltenreihenfolge | Die Vertauschungsfalle aus [Kapitel 18](#kap-finanzdaten) wird hier strukturell unmöglich. |
 > | `loese_mit_glop` / `loese_mit_scipy` | zwei Modellbauer, ein Auswertungscode | Der Solverwechsel betrifft **eine** Funktion. Alles danach — Bericht, Prüfung, Test — bleibt unverändert. |
@@ -21549,7 +22633,7 @@ Domaenenschicht.
 
 ---
 
-## 22.6 Der Solverwechsel in der Praxis {#sec:praxisfallen-solverwechsel}
+## 22.7 Der Solverwechsel in der Praxis {#sec:praxisfallen-solverwechsel}
 
 Der vorige Abschnitt endet mit einer Behauptung: Ein Solverwechsel betreffe genau **einen** Baustein. Das ist die Art Satz, die in jedem Architekturvortrag vorkommt und die man deshalb nicht glauben sollte, bevor sie jemand vorgeführt hat.
 
@@ -21619,9 +22703,9 @@ Benoetigt: numpy, pydantic, ortools, highspy (jeweils im eigenen Prozess)
 
 from __future__ import annotations
 
-import subprocess
-import sys
+import multiprocessing
 import time
+from concurrent.futures import ProcessPoolExecutor
 
 import numpy as np
 from pydantic import BaseModel, Field, model_validator
@@ -21824,25 +22908,29 @@ def geoeffnete_lager(problem: Standortproblem, loesung: Loesung) -> list[str]:
             if any(loesung.werte[problem.schluessel(i, j)] > 0.5 for j in range(m))]
 
 
-def loese_in_eigenem_prozess(name: str) -> Loesung:
-    """Startet dieses Programm noch einmal - mit genau einem Solverimport."""
-    ergebnis = subprocess.run([sys.executable, __file__, name],
-                              capture_output=True, text=True, timeout=300)
-    if ergebnis.returncode != 0:
-        raise RuntimeError(ergebnis.stderr.strip().splitlines()[-1])
-    # Das DTO als JSON - genau dafuer ist ein Datenobjekt ohne Solverbezug gut.
-    return Loesung.model_validate_json(ergebnis.stdout.strip().splitlines()[-1])
+def loese_in_eigenem_prozess(name: str, problem: Standortproblem) -> Loesung:
+    """Laesst genau einen Modellbauer in einem frischen Prozess rechnen.
+
+    'spawn' statt des Linux-Standards 'fork': Der Kindprozess startet mit
+    einem leeren Interpreter und importiert nur den Solver, den SEIN
+    Modellbauer braucht. max_tasks_per_child=1 sorgt dafuer, dass der Pool
+    seinen Arbeiter nicht wiederverwendet - sonst saessen beim zweiten Aufruf
+    wieder beide Bibliotheken im selben Prozess.
+
+    Hin und zurueck wandert das Domaenenmodell bzw. das Loesungs-DTO. Beide
+    kennen keinen Solver, sind also serialisierbar - genau dafuer sind sie da.
+    """
+    with ProcessPoolExecutor(
+            max_workers=1,
+            mp_context=multiprocessing.get_context("spawn"),
+            max_tasks_per_child=1) as pool:
+        return pool.submit(MODELLBAUER[name], problem).result(timeout=300)
 
 
 if __name__ == "__main__":
     problem = beispielproblem()
 
-    # --- Kindprozess: rechnen und das DTO als JSON ausgeben ---------------
-    if len(sys.argv) > 1:
-        print(MODELLBAUER[sys.argv[1]](problem).model_dump_json())
-        sys.exit(0)
-
-    # --- Hauptprozess: beide Solver anstossen und vergleichen -------------
+    # --- Beide Solver anstossen und vergleichen ---------------------------
     print("=" * 82)
     print("  DERSELBE FALL, ZWEI SOLVER - UND EIN AUSWERTUNGSCODE")
     print("=" * 82)
@@ -21854,7 +22942,7 @@ if __name__ == "__main__":
     loesungen: dict[str, Loesung] = {}
     for name, beschriftung in [("cpsat", "OR-Tools CP-SAT"),
                                ("highs", "HiGHS (highspy)")]:
-        loesung = loesungen[name] = loese_in_eigenem_prozess(name)
+        loesung = loesungen[name] = loese_in_eigenem_prozess(name, problem)
         beanstandungen = pruefe_zuordnung(problem, loesung)
 
         print(f"{beschriftung}")
@@ -21965,7 +23053,7 @@ ein unzuverlaessiger Test (siehe JobShop_Intervalle.py).
 
 ---
 
-## 22.7 Eine Checkliste vor dem Produktivgang {#sec:praxisfallen-eine-checkliste-vor-dem-produktivgang}
+## 22.8 Eine Checkliste vor dem Produktivgang {#sec:praxisfallen-eine-checkliste-vor-dem-produktivgang}
 
 Arbeiten Sie diese Liste ab, bevor ein OR-System in Betrieb geht:
 
@@ -21996,7 +23084,7 @@ Arbeiten Sie diese Liste ab, bevor ein OR-System in Betrieb geht:
 
 ---
 
-## 22.8 Weiterführende Literatur und Roadmap {#sec:praxisfallen-weiterfuehrende-literatur-und-roadmap}
+## 22.9 Weiterführende Literatur und Roadmap {#sec:praxisfallen-weiterfuehrende-literatur-und-roadmap}
 
 **Grundlagen und lineare/ganzzahlige Optimierung**
 * Bertsimas & Tsitsiklis: *Introduction to Linear Optimization* — Standardwerk zu Simplex, Dualität, Polyedertheorie.
@@ -22028,7 +23116,7 @@ Wenn Sie doch tiefer in die Methodik wollen, sind das die lohnendsten Richtungen
 
 ---
 
-## 22.9 Übungsaufgaben {#sec:praxisfallen-uebungsaufgaben}
+## 22.10 Übungsaufgaben {#sec:praxisfallen-uebungsaufgaben}
 
 > Lösungen: [Abschnitt A.22](#sec:loesungen-praxisfallen).
 
@@ -22036,21 +23124,23 @@ Wenn Sie doch tiefer in die Methodik wollen, sind das die lohnendsten Richtungen
 
 **Aufgabe 22.2 ⭐ — Zeitlimit wählen.** Für welche Szenarien setzen Sie welches Zeitlimit und welchen Gap? (a) Taxi-Disposition in Echtzeit, (b) Wochendienstplan, freitags erstellt, (c) Jahresproduktionsplanung, (d) Portfolio-Rebalancing monatlich.
 
-**Aufgabe 22.3 ⭐⭐ — Relaxation einbauen.** Nehmen Sie Ihr Modell aus Übung 6.7 (Wochendienstplan) und machen Sie es `INFEASIBLE`-sicher: Schlupfvariablen für unbesetzte Schichten, gestaffelte Strafen. Testen Sie mit einem bewusst überlasteten Szenario.
+**Aufgabe 22.3 ⭐⭐ — Relaxation einbauen.** Nehmen Sie Ihr Modell aus der Aufgabe *Eigener Dienstplan* ([Abschnitt 7.9](#sec:cpsat-uebungsaufgaben)) und machen Sie es `INFEASIBLE`-sicher: Schlupfvariablen für unbesetzte Schichten, gestaffelte Strafen. Testen Sie mit einem bewusst überlasteten Szenario.
 
 **Aufgabe 22.4 ⭐⭐ — Erklärbarkeit implementieren.** Erweitern Sie ein beliebiges Modell aus dem Kurs um einen `erklaere(loesung)`-Report, der die drei Fragen aus [Abschnitt 22.3](#sec:praxisfallen-die-fuenf-typischen-praxisfallen) beantwortet.
 
-**Aufgabe 22.5 ⭐⭐⭐ — Gap gegen Laufzeit.** Nehmen Sie das MILP-Portfolio aus [Kapitel 6](#kap-milp) und vergrößern Sie es auf 50 Anlagen. Messen Sie Laufzeit und Zielwert bei Gap-Vorgaben von 10 %, 5 %, 2 %, 1 %, 0,1 % und 0 %. Stellen Sie den Zusammenhang grafisch dar und leiten Sie eine Empfehlung ab.
+**Aufgabe 22.5 ⭐⭐ — Den Bericht in die Irre führen.** `Constraint_Attribution.py` erzeugt seinen Bericht aus gerechneten Zahlen — richtig ist er deshalb noch nicht. (a) Setzen Sie den Deckungsbeitrag von *Deckel* von 9 € auf 20 €. Wie ändern sich Plan, Rangliste und Bericht? Welche Sätze bleiben wörtlich stehen, obwohl sie jetzt etwas anderes bedeuten? (b) Der Bericht nennt „Liefervertrag Träger" als teuerste Bindung. Formulieren Sie den Satz so um, dass ein Leser erkennt, **worauf** die Aussage beruht. (c) Welche Angabe müsste das Programm zusätzlich ausgeben, damit ein Empfänger die Belastbarkeit selbst einschätzen kann?
 
-**Aufgabe 22.6 ⭐⭐⭐ — Post-Mortem schreiben.** Suchen Sie sich einen der im Buch besprochenen Fehler aus (z. B. die Vorzeichenfalle in [Abschnitt 5.7](#sec:lp-die-vorzeichenfalle-bei-schattenpreisen), die ungültige Kovarianzmatrix in [Kapitel 11](#kap-qp-nlp), die Sektor-Positionsindizes in [Kapitel 19](#kap-markowitz), die vermischten Einheiten in [Abschnitt 20.6](#sec:cvar-implementierung-cvar-portfolio-mit-reibung) oder die Rebalancing-Termine in [Abschnitt 21.4](#sec:handelsmaschine-rebalancing-termine-richtig-bestimmen)) und schreiben Sie ein einseitiges Post-Mortem: Was war der Fehler? Warum fiel er nicht auf? Welche Prüfung hätte ihn gefunden? Welche Regel leiten Sie daraus für eigene Projekte ab?
+**Aufgabe 22.6 ⭐⭐⭐ — Gap gegen Laufzeit.** Nehmen Sie das MILP-Portfolio aus [Kapitel 6](#kap-milp) und vergrößern Sie es auf 50 Anlagen. Messen Sie Laufzeit und Zielwert bei Gap-Vorgaben von 10 %, 5 %, 2 %, 1 %, 0,1 % und 0 %. Stellen Sie den Zusammenhang grafisch dar und leiten Sie eine Empfehlung ab.
+
+**Aufgabe 22.7 ⭐⭐⭐ — Post-Mortem schreiben.** Suchen Sie sich einen der im Buch besprochenen Fehler aus (z. B. die Vorzeichenfalle in [Abschnitt 5.7](#sec:lp-die-vorzeichenfalle-bei-schattenpreisen), die ungültige Kovarianzmatrix in [Kapitel 11](#kap-qp-nlp), die Sektor-Positionsindizes in [Kapitel 19](#kap-markowitz), die vermischten Einheiten in [Abschnitt 20.6](#sec:cvar-implementierung-cvar-portfolio-mit-reibung) oder die Rebalancing-Termine in [Abschnitt 21.4](#sec:handelsmaschine-rebalancing-termine-richtig-bestimmen)) und schreiben Sie ein einseitiges Post-Mortem: Was war der Fehler? Warum fiel er nicht auf? Welche Prüfung hätte ihn gefunden? Welche Regel leiten Sie daraus für eigene Projekte ab?
 
 ---
 
-## 22.10 Finde den Denkfehler {#sec:praxisfallen-denkfehler}
+## 22.11 Finde den Denkfehler {#sec:praxisfallen-denkfehler}
 
 Falle 5 — die Laufzeitexplosion — zeigt sich im Betrieb selten als Absturz. Sie zeigt sich als **gar nichts**.
 
-> **🐛 Finde den Denkfehler 15.1: Das Modell, das seit einem Jahr nicht mehr optimiert**
+> **🐛 Finde den Denkfehler: Das Modell, das seit einem Jahr nicht mehr optimiert**
 >
 > Ein Standortplanungsmodell geht 2024 in Betrieb. Es läuft jede Nacht, hat drei Sekunden Zeitbudget und liefert zuverlässig die Kosten des Tagesplans. Das Betriebsteam überwacht Abstürze und Laufzeitspitzen — beides tritt nie auf.
 >
@@ -22322,9 +23412,9 @@ sichtbar wird, und gibt Zeit zum Handeln.
 
 ---
 
-## 22.11 Micro-Quiz {#sec:praxisfallen-quiz}
+## 22.12 Micro-Quiz {#sec:praxisfallen-quiz}
 
-> **❓ Micro-Quiz 15: Drei Fragen zum Selbstcheck**
+> **❓ Micro-Quiz 22: Drei Fragen zum Selbstcheck**
 >
 > Genau eine Antwort ist jeweils richtig. Auflösung in [Anhang A](#quiz-loesung-praxisfallen).
 >
@@ -22336,7 +23426,7 @@ sichtbar wird, und gibt Zeit zum Handeln.
 
 ---
 
-## 22.12 Selbsttest {#sec:praxisfallen-selbsttest}
+## 22.13 Selbsttest {#sec:praxisfallen-selbsttest}
 
 > Antworten: [Anhang A](#selbsttest-loesung-praxisfallen).
 
@@ -22345,13 +23435,19 @@ sichtbar wird, und gibt Zeit zum Handeln.
 3. Warum ist ein MIP-Gap von 2 % in der Praxis meist ausreichend?
 4. Was ist das Snapshot-Prinzip und wozu dient es?
 5. Was ist der häufigste Grund, aus dem OR-Projekte scheitern?
+6. Eine Bedingung bindet, ihr Schattenpreis ist 0. Was heißt das — und was folgt daraus für eine Nachverhandlung?
+7. Warum kann die Rangfolge nach Schattenpreis eine andere sein als die Rangfolge nach tatsächlichem Nutzen einer Lockerung?
 
 ---
 
-## 22.13 Zusammenfassung {#sec:praxisfallen-zusammenfassung}
+## 22.14 Zusammenfassung {#sec:praxisfallen-zusammenfassung}
 
 * **Infeasibility ist ein Entwurfsproblem, kein Solverproblem.** Wer alles hart formuliert, erhält irgendwann eine Fehlermeldung statt eines Plans.
 * **Erklärbarkeit entscheidet über Akzeptanz.** Schattenpreise, Kostenzerlegung und Constraint-Traces sind keine Kür.
+* **Bindend heißt nicht teuer.** Eine Bedingung kann den Plan berühren und trotzdem 0,00 € kosten. Nur die kostenrelevanten lohnen eine Nachverhandlung.
+* **Der Schattenpreis gilt für die nächste Einheit, nicht für die nächste Schicht.** Hochgerechnet auf einen realistischen Schritt überschätzt er den Nutzen — im Beispiel um das Doppelte. Wer wissen will, was ein Hebel bringt, **misst** die Lockerung, statt zu multiplizieren; die beiden Ranglisten können sich dabei umdrehen.
+* **Ein Wunsch kann unmöglich statt teuer sein** — und dann ist die richtige Antwort nicht ein Preis, sondern die Liste der Bedingungen, die ihn gemeinsam blockieren.
+* **Ein generierter Bericht macht ein Modell nicht richtiger, nur schwerer anzuzweifeln.** Er erklärt das Modell, nicht die Wirklichkeit — deshalb gehört dazu, worauf er beruht.
 * **Optimieren Sie nicht genauer als Ihre Daten.** Ein Gap von 2 % ist bei ±10 % Datenunsicherheit irrelevant.
 * **Der Optimierer schlägt vor, der Mensch entscheidet** — jedenfalls anfangs.
 * **Reproduzierbarkeit braucht Snapshots und Versionierung**, nicht guten Willen.
@@ -22369,7 +23465,7 @@ sichtbar wird, und gibt Zeit zum Handeln.
 >
 > **Worum geht es?** Um die drei Fragen, die zwischen einem funktionierenden Modell und einem System stehen, auf das sich jemand verlässt: *Woher weiß ich, dass es stimmt? Woher weiß ich, dass es schnell genug ist? Wie kommt es zu den Leuten, die es brauchen?*
 >
-> **Voraussetzungen:** [Kapitel 22](#kap-praxisfallen), insbesondere `or_kern.py` aus [Abschnitt 22.5](#sec:praxisfallen-or-kern) — dieses Kapitel testet genau dieses Modul.
+> **Voraussetzungen:** [Kapitel 22](#kap-praxisfallen), insbesondere `or_kern.py` aus [Abschnitt 22.6](#sec:praxisfallen-or-kern) — dieses Kapitel testet genau dieses Modul.
 >
 > **Danach können Sie:** ein Optimierungsmodell testen, obwohl Sie die richtige Antwort nicht kennen; Ihre eigene Testsuite auf Lücken prüfen; einen Solververgleich aufsetzen, dem man glauben kann; und das Modell als Dienst betreiben, ohne dass die erste große Anfrage ihn blockiert.
 >
@@ -23109,113 +24205,124 @@ Benoetigt: numpy; in den Kindprozessen scipy, highspy, ortools, cvxpy
 
 from __future__ import annotations
 
-import json
-import subprocess
-import sys
-import textwrap
+import multiprocessing
+import resource
+import time
+from concurrent.futures import ProcessPoolExecutor
+
+import numpy as np
 
 GROESSEN = [(10, 10), (32, 32), (100, 100)]   # (Lager, Kunden) -> 100 / 1.024 / 10.000 Variablen
 
 
-# Jeder Eintrag ist ein eigenstaendiges Programm: Instanz aufbauen, loesen,
-# Ergebnis als JSON ausgeben. Die Instanz wird in jedem Kindprozess aus
-# derselben Saat neu erzeugt - so reist nichts ueber die Prozessgrenze,
-# was das Ergebnis verfaelschen koennte.
-VORSPANN = """
-import json, time, resource
-import numpy as np
+# Instanz und Speichermessung stehen als gewoehnliche Funktionen hier - nicht
+# in einem String, den ein Kindprozess ausfuehrt. Jede Messfunktion baut die
+# Instanz aus derselben Saat neu auf, damit ueber die Prozessgrenze nichts
+# reist, was das Ergebnis verfaelschen koennte.
 
-def instanz(m, n):
+def instanz(m: int, n: int):
     rng = np.random.default_rng(20)
     kosten = rng.integers(5, 95, (m, n)).astype(float)
     angebot = rng.integers(50, 150, m).astype(float)
     bedarf = angebot.sum() * rng.dirichlet(np.ones(n))
     return kosten, angebot, bedarf
 
-def speicher_mb():
-    # ru_maxrss ist unter Linux in Kilobyte
+
+def speicher_mb() -> float:
+    # ru_maxrss ist unter Linux in Kilobyte. Gemessen wird der Kindprozess -
+    # deshalb muss jede Messung einen eigenen bekommen.
     return resource.getrusage(resource.RUSAGE_SELF).ru_maxrss / 1024
 
-M, N = {m}, {n}
-kosten, angebot, bedarf = instanz(M, N)
-"""
 
-ANSAETZE = {
-    "scipy.linprog": """
-        from scipy.optimize import linprog
-        t0 = time.perf_counter()
-        c = kosten.reshape(-1)
-        A_ub = np.zeros((M, M * N)); A_eq = np.zeros((N, M * N))
-        for i in range(M):
-            A_ub[i, i * N:(i + 1) * N] = 1.0
-        for j in range(N):
-            A_eq[j, j::N] = 1.0
-        aufbau = time.perf_counter() - t0
-        t0 = time.perf_counter()
-        r = linprog(c=c, A_ub=A_ub, b_ub=angebot, A_eq=A_eq, b_eq=bedarf,
-                    bounds=(0, None), method="highs")
-        loesen = time.perf_counter() - t0
-        ausgabe = (float(r.fun), aufbau, loesen, speicher_mb())
-    """,
-
-    "highspy": """
-        import highspy
-        t0 = time.perf_counter()
-        h = highspy.Highs(); h.setOptionValue("output_flag", False)
-        h.addVars(M * N, np.zeros(M * N), np.full(M * N, highspy.kHighsInf))
-        for k in range(M * N):
-            h.changeColCost(k, float(kosten.reshape(-1)[k]))
-        for i in range(M):
-            idx = np.arange(i * N, (i + 1) * N, dtype=np.int32)
-            h.addRow(-highspy.kHighsInf, float(angebot[i]), N, idx, np.ones(N))
-        for j in range(N):
-            idx = np.arange(j, M * N, N, dtype=np.int32)
-            h.addRow(float(bedarf[j]), float(bedarf[j]), M, idx, np.ones(M))
-        aufbau = time.perf_counter() - t0
-        t0 = time.perf_counter(); h.run(); loesen = time.perf_counter() - t0
-        ausgabe = (h.getInfo().objective_function_value, aufbau, loesen, speicher_mb())
-    """,
-
-    "ortools/GLOP": """
-        from ortools.linear_solver import pywraplp
-        t0 = time.perf_counter()
-        s = pywraplp.Solver.CreateSolver("GLOP")
-        x = [[s.NumVar(0, s.infinity(), f"x{i}_{j}") for j in range(N)]
-             for i in range(M)]
-        for i in range(M):
-            s.Add(sum(x[i]) <= float(angebot[i]))
-        for j in range(N):
-            s.Add(sum(x[i][j] for i in range(M)) == float(bedarf[j]))
-        s.Minimize(sum(float(kosten[i, j]) * x[i][j]
-                       for i in range(M) for j in range(N)))
-        aufbau = time.perf_counter() - t0
-        t0 = time.perf_counter(); s.Solve(); loesen = time.perf_counter() - t0
-        ausgabe = (s.Objective().Value(), aufbau, loesen, speicher_mb())
-    """,
-
-    "cvxpy": """
-        import cvxpy as cp
-        t0 = time.perf_counter()
-        x = cp.Variable((M, N), nonneg=True)
-        problem = cp.Problem(cp.Minimize(cp.sum(cp.multiply(kosten, x))),
-                             [cp.sum(x, axis=1) <= angebot,
-                              cp.sum(x, axis=0) == bedarf])
-        aufbau = time.perf_counter() - t0
-        t0 = time.perf_counter(); problem.solve(); loesen = time.perf_counter() - t0
-        ausgabe = (float(problem.value), aufbau, loesen, speicher_mb())
-    """,
-}
+def messe_scipy(m: int, n: int):
+    from scipy.optimize import linprog
+    kosten, angebot, bedarf = instanz(m, n)
+    t0 = time.perf_counter()
+    c = kosten.reshape(-1)
+    A_ub = np.zeros((m, m * n)); A_eq = np.zeros((n, m * n))
+    for i in range(m):
+        A_ub[i, i * n:(i + 1) * n] = 1.0
+    for j in range(n):
+        A_eq[j, j::n] = 1.0
+    aufbau = time.perf_counter() - t0
+    t0 = time.perf_counter()
+    r = linprog(c=c, A_ub=A_ub, b_ub=angebot, A_eq=A_eq, b_eq=bedarf,
+                bounds=(0, None), method="highs")
+    loesen = time.perf_counter() - t0
+    return float(r.fun), aufbau, loesen, speicher_mb()
 
 
-def messe(name: str, quelltext: str, m: int, n: int):
-    """Fuehrt einen Ansatz in einem eigenen Prozess aus."""
-    programm = (VORSPANN.format(m=m, n=n) + textwrap.dedent(quelltext)
-                + "\nprint(json.dumps(ausgabe))\n")
-    ergebnis = subprocess.run([sys.executable, "-c", programm],
-                              capture_output=True, text=True, timeout=600)
-    if ergebnis.returncode != 0:
-        return None, ergebnis.stderr.strip().splitlines()[-1][:60]
-    return json.loads(ergebnis.stdout.strip().splitlines()[-1]), None
+def messe_highspy(m: int, n: int):
+    import highspy
+    kosten, angebot, bedarf = instanz(m, n)
+    t0 = time.perf_counter()
+    h = highspy.Highs(); h.setOptionValue("output_flag", False)
+    h.addVars(m * n, np.zeros(m * n), np.full(m * n, highspy.kHighsInf))
+    for k in range(m * n):
+        h.changeColCost(k, float(kosten.reshape(-1)[k]))
+    for i in range(m):
+        idx = np.arange(i * n, (i + 1) * n, dtype=np.int32)
+        h.addRow(-highspy.kHighsInf, float(angebot[i]), n, idx, np.ones(n))
+    for j in range(n):
+        idx = np.arange(j, m * n, n, dtype=np.int32)
+        h.addRow(float(bedarf[j]), float(bedarf[j]), m, idx, np.ones(m))
+    aufbau = time.perf_counter() - t0
+    t0 = time.perf_counter(); h.run(); loesen = time.perf_counter() - t0
+    return h.getInfo().objective_function_value, aufbau, loesen, speicher_mb()
+
+
+def messe_ortools(m: int, n: int):
+    from ortools.linear_solver import pywraplp
+    kosten, angebot, bedarf = instanz(m, n)
+    t0 = time.perf_counter()
+    s = pywraplp.Solver.CreateSolver("GLOP")
+    x = [[s.NumVar(0, s.infinity(), f"x{i}_{j}") for j in range(n)]
+         for i in range(m)]
+    for i in range(m):
+        s.Add(sum(x[i]) <= float(angebot[i]))
+    for j in range(n):
+        s.Add(sum(x[i][j] for i in range(m)) == float(bedarf[j]))
+    s.Minimize(sum(float(kosten[i, j]) * x[i][j]
+                   for i in range(m) for j in range(n)))
+    aufbau = time.perf_counter() - t0
+    t0 = time.perf_counter(); s.Solve(); loesen = time.perf_counter() - t0
+    return s.Objective().Value(), aufbau, loesen, speicher_mb()
+
+
+def messe_cvxpy(m: int, n: int):
+    import cvxpy as cp
+    kosten, angebot, bedarf = instanz(m, n)
+    t0 = time.perf_counter()
+    x = cp.Variable((m, n), nonneg=True)
+    problem = cp.Problem(cp.Minimize(cp.sum(cp.multiply(kosten, x))),
+                         [cp.sum(x, axis=1) <= angebot,
+                          cp.sum(x, axis=0) == bedarf])
+    aufbau = time.perf_counter() - t0
+    t0 = time.perf_counter(); problem.solve(); loesen = time.perf_counter() - t0
+    return float(problem.value), aufbau, loesen, speicher_mb()
+
+
+ANSAETZE = {"scipy.linprog": messe_scipy, "highspy": messe_highspy,
+            "ortools/GLOP": messe_ortools, "cvxpy": messe_cvxpy}
+
+
+def messe(funktion, m: int, n: int):
+    """Fuehrt eine Messfunktion in einem FRISCHEN Prozess aus.
+
+    'spawn' und max_tasks_per_child=1 zusammen garantieren, was Regel 1
+    verlangt: Jede Messung sieht einen leeren Interpreter. Ohne das
+    zweite wuerde der Pool seinen Arbeiter wiederverwenden - dann waere
+    der Speicherwert der zweiten Bibliothek um die erste zu hoch, und
+    ortools und highspy saessen im selben Prozess.
+    """
+    with ProcessPoolExecutor(
+            max_workers=1,
+            mp_context=multiprocessing.get_context("spawn"),
+            max_tasks_per_child=1) as pool:
+        try:
+            return pool.submit(funktion, m, n).result(timeout=600), None
+        except Exception as fehler:
+            return None, str(fehler).strip().splitlines()[-1][:60]
 
 
 if __name__ == "__main__":
@@ -23233,8 +24340,8 @@ if __name__ == "__main__":
               f"{'Loesen':>9} {'Anteil':>8} {'Speicher':>10}")
         print("  " + "-" * 72)
         zielwerte = {}
-        for name, quelltext in ANSAETZE.items():
-            werte, fehler = messe(name, quelltext, m, n)
+        for name, funktion in ANSAETZE.items():
+            werte, fehler = messe(funktion, m, n)
             if werte is None:
                 print(f"  {name:<16} nicht verfuegbar: {fehler}")
                 continue
@@ -23290,28 +24397,28 @@ die Zielwerte und ihr Verhaeltnis zueinander nicht.
 --- 10 Lager x 10 Kunden = 100 Variablen ---------------------------------------------------
   Bibliothek             Zielwert    Aufbau    Loesen   Anteil   Speicher
   ------------------------------------------------------------------------
-  scipy.linprog         13,509.48    0.000s    0.004s       1%        78 MB
-  highspy               13,509.48    0.001s    0.002s      34%        41 MB
-  ortools/GLOP          13,509.48    0.002s    0.001s      80%        54 MB
+  scipy.linprog         13,509.48    0.000s    0.004s       1%        79 MB
+  highspy               13,509.48    0.001s    0.002s      36%        44 MB
+  ortools/GLOP          13,509.48    0.003s    0.001s      80%        56 MB
   cvxpy                 13,509.48    0.001s    0.009s       9%       229 MB
                    Spannweite der Zielwerte: 1.33e-06 (relativ 9.8e-11)
 
 --- 32 Lager x 32 Kunden = 1,024 Variablen -------------------------------------------------
   Bibliothek             Zielwert    Aufbau    Loesen   Anteil   Speicher
   ------------------------------------------------------------------------
-  scipy.linprog         35,744.25    0.000s    0.009s       4%        80 MB
-  highspy               35,744.25    0.004s    0.005s      47%        42 MB
-  ortools/GLOP          35,744.25    0.015s    0.002s      85%        55 MB
-  cvxpy                 35,744.25    0.001s    0.016s       5%       230 MB
+  scipy.linprog         35,744.25    0.000s    0.009s       3%        81 MB
+  highspy               35,744.25    0.004s    0.005s      44%        45 MB
+  ortools/GLOP          35,744.25    0.014s    0.002s      85%        58 MB
+  cvxpy                 35,744.25    0.001s    0.017s       5%       231 MB
                    Spannweite der Zielwerte: 9.54e-05 (relativ 2.7e-09)
 
 --- 100 Lager x 100 Kunden = 10,000 Variablen ----------------------------------------------
   Bibliothek             Zielwert    Aufbau    Loesen   Anteil   Speicher
   ------------------------------------------------------------------------
-  scipy.linprog         72,220.34    0.002s    0.070s       3%       120 MB
-  highspy               72,220.34    0.029s    0.034s      45%        47 MB
-  ortools/GLOP          72,220.34    0.123s    0.036s      77%        66 MB
-  cvxpy                 72,220.34    0.001s    0.103s       1%       242 MB
+  scipy.linprog         72,220.34    0.004s    0.072s       5%       122 MB
+  highspy               72,220.34    0.026s    0.032s      45%        50 MB
+  ortools/GLOP          72,220.34    0.141s    0.043s      77%        68 MB
+  cvxpy                 72,220.34    0.001s    0.108s       1%       242 MB
                    Spannweite der Zielwerte: 3.65e-04 (relativ 5.0e-09)
 
 ============================================================================================
@@ -23782,7 +24889,7 @@ Das zugehoerige Dockerfile ist kurz genug, um es ganz zu zeigen:
 >
 > **1. Das Domänenmodell ist das API-Schema.** Der Parameter heißt `problem: Produktionsproblem` — mehr steht nicht da. FastAPI validiert die Anfrage damit gegen dieselben Pydantic-Regeln wie der Excel-Import aus [Kapitel 1](#kap-einfuehrung) und antwortet bei Unsinn mit `422`, **bevor** ein Solver startet. Die drei abgewiesenen Anfragen im Selbsttest sind genau die drei Fälle, die `or_kern.py` schon beim Einlesen abfängt.
 >
-> **2. Die Antwort enthält Status und Gap, nicht nur Zahlen.** Ein Aufrufer, der nur die Mengen bekommt, kann nicht unterscheiden, ob er ein bewiesenes Optimum oder einen Zeitlimit-Abbruch in der Hand hält. Das `Loesung`-Objekt geht deshalb vollständig durch die Schnittstelle — dasselbe DTO, das in [Abschnitt 22.6](#sec:praxisfallen-solverwechsel) schon eine Prozessgrenze überlebt hat.
+> **2. Die Antwort enthält Status und Gap, nicht nur Zahlen.** Ein Aufrufer, der nur die Mengen bekommt, kann nicht unterscheiden, ob er ein bewiesenes Optimum oder einen Zeitlimit-Abbruch in der Hand hält. Das `Loesung`-Objekt geht deshalb vollständig durch die Schnittstelle — dasselbe DTO, das in [Abschnitt 22.7](#sec:praxisfallen-solverwechsel) schon eine Prozessgrenze überlebt hat.
 >
 > **3. Die Abnahmeprüfung läuft auch hier.** `pruefe_loesung()` steht im Arbeiter, nicht nur im Skript. Ein Dienst ohne sie liefert Fehler schneller aus, als ein Mensch sie finden könnte.
 
@@ -23878,6 +24985,45 @@ Das Dockerfile ist kurz genug, um es ganz zu zeigen — es steht im Programm und
 * Ein **Optimierungsdienst** ist zweistufig: annehmen und prüfen sofort, rechnen im Hintergrund, Ergebnis mit Status und Gap abholen. Die Frage Threads oder Prozesse gehört gemessen — bei C++-Solvern genügen Threads, bei Python-Heuristiken nicht.
 
 
+---
+
+# Synthese Teil V — Vom rechnenden Modell zum benutzten System
+
+Zwei Kapitel, ein Übergang: Das Modell rechnet — und muss jetzt jemand anderem übergeben werden. Was dabei schiefgeht, hat selten mit Mathematik zu tun.
+
+## Was schiefgeht, und was dagegen hilft
+
+| Was in Produktion passiert | Gegenmittel | Wo |
+| --- | --- | --- |
+| `INFEASIBLE` um 3 Uhr nachts, niemand weiß warum | Relaxation mit gestaffelten Strafkosten (B18); Deletion Filter für die Diagnose | [Kapitel 22](#kap-praxisfallen), [Anhang C](#anhang-fehlerdiagnose) |
+| Der Disponent lehnt den Plan ab, weil er ihn nicht versteht | Constraint-Trace für die einzelne Zuweisung; Kostenzurechnung für den ganzen Plan | [Kapitel 22](#kap-praxisfallen), [Abschnitt 22.4](#sec:praxisfallen-attribution) |
+| Der Solver läuft ins Zeitlimit und keiner merkt es | Status, Gap und Zeitausschöpfung protokollieren — konstante Laufzeit ist ein Warnsignal | [Kapitel 22](#kap-praxisfallen) |
+| Ein Test wird grundlos mal rot, mal grün | auf Zielwert und Regeln prüfen, nicht auf die Gestalt der Lösung; `num_workers = 1` **und** Seed | [Abschnitt 7.7](#sec:cpsat-parallele-suche), [Kapitel 23](#kap-testing) |
+| Ein Ergebnis lässt sich später nicht mehr nachvollziehen | Snapshot-Prinzip: unveränderlicher Datenstand mit ID je Lauf | [Kapitel 22](#kap-praxisfallen) |
+| Das Modell prüft sich selbst | Abnahmeprüfung als eigener Baustein, ohne Solver und ohne Modellvariable | [Abschnitt 22.6](#sec:praxisfallen-or-kern) |
+
+## Was dieser Teil gemessen hat
+
+| Behauptung | Gemessen | Wo |
+| --- | --- | --- |
+| „Der Solver nennt schon den Grund für `INFEASIBLE`." | Er nennt gar nichts. Der Deletion Filter findet einen kleinsten Konflikt — dieses Modell enthält **neun** verschiedene, und welchen man sieht, steuert die Prüfreihenfolge | [Anhang C](#anhang-fehlerdiagnose) |
+| „Bindende Bedingungen sind die teuren." | Von fünf bindenden Bedingungen kostet eine **0,00 €** | [Abschnitt 22.4](#sec:praxisfallen-attribution) |
+| „Der Schattenpreis sagt, was der Hebel bringt." | Hochgerechnet 120 €, gemessen **60 €** — er gilt nur bis +15 Stunden. Die Ranglisten nach Preis und nach Wirkung drehen sich um | [Abschnitt 22.4](#sec:praxisfallen-attribution) |
+| „Mehr Arbeiter sind proportional schneller." | **12,3-fach** bei acht Arbeitern — überlinear, weil verschiedene Strategien statt derselben Suche laufen | [Abschnitt 7.7](#sec:cpsat-parallele-suche) |
+
+## Drei Fehler, die dieser Teil verhindert
+
+1. **Alles hart formulieren.** Wer keine Regel brechen lässt, bekommt irgendwann eine Fehlermeldung statt eines Plans — und zwar nachts, im Batchlauf.
+2. **Genauer optimieren als die Daten sind.** Ein Gap von 2 % ist bei ±10 % Datenunsicherheit bedeutungslos. Die Rechenzeit dafür ist verschenkt.
+3. **Einen Bericht für einen Beweis halten.** Ein generierter Text erklärt das **Modell**, nicht die **Wirklichkeit**. Ist eine Eingabe falsch geschätzt, ist er überzeugend **und** falsch — die gefährlichste Kombination.
+
+## Wenn Sie nur eines mitnehmen
+
+> **🎯** Ein Modell, das nur auf Ihrem Rechner und nur mit Ihren Daten läuft, ist ein Prototyp — kein System. Der Unterschied besteht aus drei Dingen, die alle nichts mit dem Solver zu tun haben: einer Abnahmeprüfung, einer Erklärung und einem Protokoll.
+
+**Danach:** die Projektwerkstatt. Elf Aufträge, jeder mit Datenquellen, Modellskizze, Abnahmekriterien und Stolperfallen — zugeschnitten auf 10 bis 25 Stunden bis zu einem vorzeigbaren Ergebnis.
+
+
 ---
 
 # Projektwerkstatt — elf eigene Anwendungen
@@ -24215,7 +25361,7 @@ Probe: Mehl $0{,}5\cdot96 + 0{,}6\cdot70 = 48 + 42 = 90$ kg ✓ (voll ausgelaste
 
 **1.7 — Eigenes Problem.** Individuell. Prüfkriterien: Sind die Variablen wirklich *entscheidbar* (nicht bereits festgelegt)? Hat die Zielfunktion eine **Einheit**? Ist jede harte Bedingung wirklich unverhandelbar?
 
-### Finde den Denkfehler 1.1 — Die Schreinerei verdoppelt ihren Gewinn
+### Finde den Denkfehler — Die Schreinerei verdoppelt ihren Gewinn
 
 (a) **Nachrechnen.** Der Plan lautet 40 Tische und 150 Stühle: $40 \cdot 3 + 150 \cdot 1 = \mathbf{270}$ Montagestunden bei 150 verfügbaren, und $40 \cdot 6 + 150 \cdot 1 = \mathbf{390}$ m² Material bei 240 verfügbaren. Beide Vorräte sind fast doppelt überzogen — der Plan ist in der Werkstatt nicht ausführbar.
 
@@ -24279,7 +25425,7 @@ def repariere(P):
 ```
 Für $\mathbf{P}_2$ ergibt sich eine PSD-Matrix mit Korrelation exakt $1{,}0$ — das Verfahren zieht die unmögliche Korrelation auf den nächstgelegenen zulässigen Wert. Für Kovarianzmatrizen setzt man in der Praxis auf einen kleinen positiven Wert statt auf 0 (`np.maximum(lam, 1e-10)`), damit die Matrix invertierbar bleibt.
 
-### Finde den Denkfehler 2.1 — Die unauffällige Transposition
+### Finde den Denkfehler — Die unauffällige Transposition
 
 (a) **Warum nichts auffällt.** $\mathbf{A}$ ist quadratisch, also passen die Dimensionen auch transponiert. NumPy prüft Formen, nicht Bedeutungen; der Solver bekommt ein vollkommen zulässiges LP vorgelegt und löst es korrekt — nur eben ein **anderes**. Eine Transposition ist genau dann gefährlich, wenn sie folgenlos *aussieht*: Wäre die Matrix $2 \times 3$ gewesen, hätte NumPy sofort einen Dimensionsfehler geworfen.
 
@@ -24289,7 +25435,7 @@ $$\mathbf{A}\mathbf{x} = \begin{pmatrix} 1\cdot5{,}6 + 2\cdot0{,}8 \\ 3\cdot5{,}
 
 Die zweite Ressource ist um **47 % überzogen** (17,6 statt 12). Der Plan ist in der Werkstatt nicht ausführbar.
 
-(c) **Warum „zu klein“ schlimmer ist als „zu groß“.** Ein unerwartet *hoher* Zielwert weckt Misstrauen — man rechnet nach (siehe Denkfehler 1.1). Ein leicht *niedrigerer* Wert wirkt dagegen wie ein normales, etwas enttäuschendes Ergebnis: Niemand prüft nach, warum die Optimierung „nur“ 20,80 € statt der erhofften 22 € bringt. Fehler, die sich als Bescheidenheit tarnen, überleben am längsten.
+(c) **Warum „zu klein“ schlimmer ist als „zu groß“.** Ein unerwartet *hoher* Zielwert weckt Misstrauen — man rechnet nach (siehe [Abschnitt 1.10](#sec:einfuehrung-denkfehler)). Ein leicht *niedrigerer* Wert wirkt dagegen wie ein normales, etwas enttäuschendes Ergebnis: Niemand prüft nach, warum die Optimierung „nur“ 20,80 € statt der erhofften 22 € bringt. Fehler, die sich als Bescheidenheit tarnen, überleben am längsten.
 
 (d) **Zwei Zeilen, die es aufgedeckt hätten.** Erstens beim Einlesen die Form gegen die Bedeutung prüfen, zweitens nach dem Lösen den Verbrauch gegen den Vorrat:
 
@@ -24333,7 +25479,7 @@ Vorbeugend hilft außerdem, Matrizen nie positionsweise abzutippen, sondern übe
 
 **3.6 — Eigene Entscheidungshilfe.** Ergänzungen: Bei kommerzieller Lizenz Gurobi/CPLEX über Pyomo oder CVXPY empfehlen; bei Lesbarkeitsanforderung Pyomo (algebraische Notation, Trennung von Daten und Modell).
 
-### Finde den Denkfehler 3.1 — Der Solver, der angeblich dreimal schneller ist
+### Finde den Denkfehler — Der Solver, der angeblich dreimal schneller ist
 
 (a) **Was da alles mitgemessen wird.** Die Stoppuhr läuft ab der ersten Zeile, also mindestens über drei Dinge, die mit Lösegeschwindigkeit nichts zu tun haben:
 
@@ -24387,15 +25533,15 @@ Und die vierte, wichtigste Regel: **die Größe messen, die später auch läuft.
 
 ## A.4 Lösungen zu Kapitel „Vom Management-Wunsch zum Modell“ {#sec:loesungen-modellierung}
 
-**Die fehlende Lesart.** Eine dritte Lesart: **„Der Umsatzanteil der Stammkunden darf nicht unter 30 % fallen."** Sie zielt weder auf einzelne Aufträge noch auf einzelne Kunden, sondern auf das Gesamtbild. Sie beschreibt einen Betrieb, dem die *Struktur* seines Geschäfts wichtig ist — etwa weil Stammkunden verlässlicher zahlen oder weil eine zu große Abhängigkeit von Neukunden als Risiko gilt. Sie lässt zu, dass ein einzelner Stammkunde in einem Quartal leer ausgeht, solange die Summe stimmt.
+**4.1 — Die fehlende Lesart.** Eine dritte Lesart: **„Der Umsatzanteil der Stammkunden darf nicht unter 30 % fallen."** Sie zielt weder auf einzelne Aufträge noch auf einzelne Kunden, sondern auf das Gesamtbild. Sie beschreibt einen Betrieb, dem die *Struktur* seines Geschäfts wichtig ist — etwa weil Stammkunden verlässlicher zahlen oder weil eine zu große Abhängigkeit von Neukunden als Risiko gilt. Sie lässt zu, dass ein einzelner Stammkunde in einem Quartal leer ausgeht, solange die Summe stimmt.
 
 Der Punkt der Aufgabe: Alle drei Lesarten sind vertretbar, und keine ist aus dem Satz ableitbar. Die Wahl trifft man — im Zweifel unbewusst.
 
-**Frage 5 anwenden.** Wird die *durchschnittliche* Wartezeit minimiert, lohnt es sich, viele leichte Fälle schnell abzuarbeiten und die aufwendigen nach hinten zu schieben: Ein Fall mit vier Stunden Wartezeit zählt genauso viel wie vier Fälle mit einer Stunde. Der optimale Plan behandelt also bevorzugt Bagatellen und lässt schwere Fälle warten — medizinisch das Gegenteil des Gewollten.
+**4.2 — Frage 5 anwenden.** Wird die *durchschnittliche* Wartezeit minimiert, lohnt es sich, viele leichte Fälle schnell abzuarbeiten und die aufwendigen nach hinten zu schieben: Ein Fall mit vier Stunden Wartezeit zählt genauso viel wie vier Fälle mit einer Stunde. Der optimale Plan behandelt also bevorzugt Bagatellen und lässt schwere Fälle warten — medizinisch das Gegenteil des Gewollten.
 
 Das ist genau der Ertrag von Frage 5: Der Plan lässt sich *ablehnen*, und aus der Ablehnung folgt die richtige Zielgröße — etwa die maximale Wartezeit je Dringlichkeitsstufe, oder die Einhaltung von Zielzeiten je Triage-Kategorie.
 
-**Der Kompromiss dazwischen.** Je Stammkunde eine Nebenbedingung: Die Summe der zugeteilten Stunden dieses Kunden muss mindestens die Hälfte seiner angefragten Stunden betragen.
+**4.3 — Der Kompromiss dazwischen.** Je Stammkunde eine Nebenbedingung: Die Summe der zugeteilten Stunden dieses Kunden muss mindestens die Hälfte seiner angefragten Stunden betragen.
 
 ```python
 for kunde in STAMMKUNDEN:
@@ -24406,11 +25552,13 @@ for kunde in STAMMKUNDEN:
 
 Erwartung: Das Ergebnis liegt zwischen Lesart A und B — die Regel bindet stärker als „ein Auftrag genügt", aber schwächer als „alle Aufträge". Der Lehrpunkt ist nicht die Zahl, sondern dass sich zwischen zwei Lesarten beliebig fein abstufen lässt, sobald man sie einmal als Ungleichung geschrieben hat.
 
-**Zwei Ziele gleichzeitig.** Bei $\lambda = 0$ ergibt sich der DB-Plan (78 500 € DB), bei großem $\lambda$ der Umsatzplan (66 000 € DB). Dazwischen kippt es an genau einer Stelle — und zwar **sprunghaft**, nicht allmählich: Weil die Entscheidungsvariablen binär sind, gibt es nur endlich viele Pläne, und der Wechsel erfolgt, sobald ein anderer Plan den höheren gewichteten Wert hat.
+**4.4 — Zwei Ziele gleichzeitig.** Bei $\lambda = 0$ ergibt sich der DB-Plan (78 500 € DB), bei großem $\lambda$ der Umsatzplan (66 000 € DB). Dazwischen kippt es an genau einer Stelle — und zwar **sprunghaft**, nicht allmählich: Weil die Entscheidungsvariablen binär sind, gibt es nur endlich viele Pläne, und der Wechsel erfolgt, sobald ein anderer Plan den höheren gewichteten Wert hat.
 
 Der Kippwert sagt dem Betrieb etwas Konkretes: *„Erst wenn Ihnen ein Euro Umsatz mehr wert ist als λ Euro Deckungsbeitrag, ändert sich Ihr Plan."* Das ist eine Frage, die ein Kaufmann beantworten kann — anders als „welche Gewichtung hätten Sie gern?".
 
-**Die Anforderung schreiben.** Eine tragfähige Anforderung enthält mindestens:
+**4.5 — Übersetzen, wo es nicht eindeutig ist.** (a) Drei Lesarten von „gleichmäßig ausgelastet": **(1) Spannweite minimieren** — $\max_i a_i - \min_i a_i$. Bestraft Ausreißer nach beiden Seiten; ein einzelner Untätiger ist genauso schlimm wie ein Überlasteter. **(2) Den Schlechtestgestellten verbessern** — $\max_i a_i$ minimieren (B11). Interessiert sich nicht dafür, wie ungleich die übrigen liegen, solange die Spitze sinkt. **(3) Abweichung vom Mittel minimieren** — $\sum_i |a_i - \bar a|$ (B10). Verteilt die Last am gleichmäßigsten, kann aber die Spitze höher lassen als (2). Wo es sichtbar wird: Bei fünf Monteuren mit 8, 8, 8, 8 und 16 Stunden senkt (2) die 16 zuerst; bei 4, 8, 8, 8, 12 tut (1) am meisten gegen die Spreizung, während (2) kaum etwas findet. Und wenn ein Monteur aus guten Gründen nur halbtags da ist, bestrafen (1) und (3) genau das — (2) nicht. (b) Hart: $w_k \le 3$ für jeden Kunden $k$. Weich: $w_k \le 3 + s_k$ mit $s_k \ge 0$ und Strafkosten $c \cdot s_k$ in der Zielfunktion (B8, B18). Die Frage an den Betrieb ist die dritte der vier: *Was passiert, wenn es einmal nicht geht?* Führt die Antwort zu „dann müssen wir eben" — weich. Führt sie zu „das darf nicht passieren, dann rufen wir an und verschieben" — dann ist auch das ein Prozess, und die Bedingung bleibt weich, nur mit sehr hohen Strafkosten. Wirklich hart ist sie nur, wenn ein Verstoß rechtlich unmöglich ist. (c) Individuell. Prüfkriterium: Wird eine Wendung gefunden, die **zwei** vertretbare Modelle zulässt — und wird benannt, wer die Wahl treffen muss? Die häufigsten Kandidaten in echten Anforderungen sind „in der Regel", „zeitnah", „vergleichbar" und jede Zahl ohne Bezugszeitraum.
+
+**4.6 — Die Anforderung schreiben.** Eine tragfähige Anforderung enthält mindestens:
 
 * **Entscheidung:** Für jede Anfrage im Planungszeitraum: annehmen oder ablehnen.
 * **Ziel:** Deckungsbeitrag maximieren (Umsatz minus Material).
@@ -24466,21 +25614,21 @@ Im schwachen Monat ist die Vorgabe schlicht nicht erfüllbar — es gibt nicht g
 
 ## A.5 Lösungen zu Kapitel „Lineare Programmierung — Simplex, Dualität und Schattenpreise“ {#sec:loesungen-lp}
 
-**4.1 — Schlupf deuten.** (a) Ressourcen 1 und 3 (Schlupf 0). (b) Ja: Überall ist $s_i \cdot y_i = 0$. (c) In Ressource 3 — der höchste Schattenpreis (9,8) bedeutet den größten Grenznutzen.
+**5.1 — Schlupf deuten.** (a) Ressourcen 1 und 3 (Schlupf 0). (b) Ja: Überall ist $s_i \cdot y_i = 0$. (c) In Ressource 3 — der höchste Schattenpreis (9,8) bedeutet den größten Grenznutzen.
 
-**4.2 — Vorzeichen.** Er hat die Zielfunktion für `linprog` negiert und die Dualwerte nicht zurückgedreht. Der korrekte Schattenpreis ist **+45 €**.
+**5.2 — Vorzeichen.** Er hat die Zielfunktion für `linprog` negiert und die Dualwerte nicht zurückgedreht. Der korrekte Schattenpreis ist **+45 €**.
 
-**4.3 — Simplex von Hand.** Starttableau mit $s_1, s_2$ in der Basis. Erste Iteration: Pivotspalte $x_1$ ($-5$), Quotienten $24/6 = 4$ und $6/1 = 6$ → Pivotzeile 1. Nach dem Tausch: $x_1 = 4$, $Z = 20$. Zweite Iteration: Pivotspalte $x_2$, Pivotzeile 2 → $x_1 = 3$, $x_2 = 1{,}5$, $Z = 21$. **Optimum:** $\mathbf{x}^* = (3;\ 1{,}5)$, $Z^* = 21$, Schattenpreise $y^* = (0{,}75;\ 0{,}50)$.
+**5.3 — Simplex von Hand.** Starttableau mit $s_1, s_2$ in der Basis. Erste Iteration: Pivotspalte $x_1$ ($-5$), Quotienten $24/6 = 4$ und $6/1 = 6$ → Pivotzeile 1. Nach dem Tausch: $x_1 = 4$, $Z = 20$. Zweite Iteration: Pivotspalte $x_2$, Pivotzeile 2 → $x_1 = 3$, $x_2 = 1{,}5$, $Z = 21$. **Optimum:** $\mathbf{x}^* = (3;\ 1{,}5)$, $Z^* = 21$, Schattenpreise $y^* = (0{,}75;\ 0{,}50)$.
 
-**4.4 — Duales Problem.** $\min 24y_1 + 6y_2$ u. d. N. $6y_1 + y_2 \ge 5$, $4y_1 + 2y_2 \ge 4$, $y \ge 0$. Lösung $y^* = (0{,}75;\ 0{,}50)$. Probe der Restriktionen: $6\cdot0{,}75 + 0{,}5 = 5$ ✓ (mit Gleichheit, weil $x_1 > 0$), $4\cdot0{,}75 + 2\cdot0{,}5 = 4$ ✓ (ebenfalls Gleichheit, weil $x_2 > 0$). Zielwert $24\cdot0{,}75 + 6\cdot0{,}5 = 18 + 3 = 21 = Z^*$ ✓ — starker Dualitätssatz bestätigt.
+**5.4 — Duales Problem.** $\min 24y_1 + 6y_2$ u. d. N. $6y_1 + y_2 \ge 5$, $4y_1 + 2y_2 \ge 4$, $y \ge 0$. Lösung $y^* = (0{,}75;\ 0{,}50)$. Probe der Restriktionen: $6\cdot0{,}75 + 0{,}5 = 5$ ✓ (mit Gleichheit, weil $x_1 > 0$), $4\cdot0{,}75 + 2\cdot0{,}5 = 4$ ✓ (ebenfalls Gleichheit, weil $x_2 > 0$). Zielwert $24\cdot0{,}75 + 6\cdot0{,}5 = 18 + 3 = 21 = Z^*$ ✓ — starker Dualitätssatz bestätigt.
 
-**4.5 — Unbeschränktheit.** Der Solver wirft „Problem ist unbeschränkt“. Geometrisch: Der zulässige Bereich $\{x_1 - x_2 \le 5,\ x \ge 0\}$ ist nach oben offen — man kann $x_1$ und $x_2$ gemeinsam beliebig wachsen lassen (z. B. $x_1 = x_2 = t$ für $t \to \infty$), ohne eine Bedingung zu verletzen, und $Z = 2t$ wächst mit. In der Praxis fehlt fast immer eine Kapazitätsgrenze.
+**5.5 — Unbeschränktheit.** Der Solver wirft „Problem ist unbeschränkt“. Geometrisch: Der zulässige Bereich $\{x_1 - x_2 \le 5,\ x \ge 0\}$ ist nach oben offen — man kann $x_1$ und $x_2$ gemeinsam beliebig wachsen lassen (z. B. $x_1 = x_2 = t$ für $t \to \infty$), ohne eine Bedingung zu verletzen, und $Z = 2t$ wächst mit. In der Praxis fehlt fast immer eine Kapazitätsgrenze.
 
-**4.6 — Gültigkeitsbereich.** (a) Bei ca. 66,7 Stunden Prüfkapazität wird die **Lackierzeit** zum Engpass; der Schattenpreis der Prüfung fällt dann. (b) Zukaufen lohnt bis zu dem Punkt, an dem der Schattenpreis unter 18 €/h fällt. (c) Der Gewinnverlauf ist **stückweise linear und konkav**: Jedes Teilstück hat die Steigung des jeweils gültigen Schattenpreises, und die Steigungen werden immer flacher — jede zusätzliche Einheit bringt weniger, weil andere Engpässe nachrücken.
+**5.6 — Gültigkeitsbereich.** (a) Bei ca. 66,7 Stunden Prüfkapazität wird die **Lackierzeit** zum Engpass; der Schattenpreis der Prüfung fällt dann. (b) Zukaufen lohnt bis zu dem Punkt, an dem der Schattenpreis unter 18 €/h fällt. (c) Der Gewinnverlauf ist **stückweise linear und konkav**: Jedes Teilstück hat die Steigung des jeweils gültigen Schattenpreises, und die Steigungen werden immer flacher — jede zusätzliche Einheit bringt weniger, weil andere Engpässe nachrücken.
 
-**4.7 — Phase 1.**`\index{Zwei-Phasen-Simplex-Methode}`{=latex} Ansatz: Für jede Zeile mit $b_i < 0$ (nach Umformung zu $\ge$) eine künstliche Variable $a_i \ge 0$ einführen, Hilfszielfunktion $\min \sum a_i$ lösen. Ist das Minimum 0, existiert eine zulässige Basislösung, und man startet Phase 2 mit dem erreichten Tableau. Ist es $> 0$, ist das Problem unzulässig. Für das Beispiel: Optimum $(12;\ 0)$, $Z = 36$.
+**5.7 — Phase 1.**`\index{Zwei-Phasen-Simplex-Methode}`{=latex} Ansatz: Für jede Zeile mit $b_i < 0$ (nach Umformung zu $\ge$) eine künstliche Variable $a_i \ge 0$ einführen, Hilfszielfunktion $\min \sum a_i$ lösen. Ist das Minimum 0, existiert eine zulässige Basislösung, und man startet Phase 2 mit dem erreichten Tableau. Ist es $> 0$, ist das Problem unzulässig. Für das Beispiel: Optimum $(12;\ 0)$, $Z = 36$.
 
-### Finde den Denkfehler 4.1 — Die 380 000-Euro-Maschine
+### Finde den Denkfehler — Die 380 000-Euro-Maschine
 
 (a) **Eine Ableitung gilt lokal.** $y_i = \partial Z^*/\partial b_i$ beschreibt die Steigung der Zielfunktion **am aktuellen Punkt**. Sie sagt: „Die *nächste* Stunde ist 50 € wert“ — nicht: „jede der nächsten 2 000 Stunden ist 50 € wert“. Der Werksleiter behandelt eine Ableitung wie eine Konstante und multipliziert sie mit einer großen Zahl. Genau daran scheitert die Rechnung.
 
@@ -24532,21 +25680,21 @@ Das ist die allgemeine Regel für jede Sensitivitätsaussage über mehr als eine
 
 ## A.6 Lösungen zu Kapitel „Gemischt-ganzzahlige Optimierung — Diskrete Entscheidungen und Branch-and-Bound“ {#sec:loesungen-milp}
 
-**5.1 — Runden widerlegen.** Beispiel: $\max x_1 + x_2$ u. d. N. $10x_1 + 10x_2 \le 15$, ganzzahlig. LP-Optimum $Z = 1{,}5$; Abrunden ergibt $(0,0)$ mit $Z = 0$ — **100 % Verlust**. Das ganzzahlige Optimum ist $(1,0)$ mit $Z = 1$. Prinzip: kleine Zahlen plus knappe Kapazität.
+**6.1 — Runden widerlegen.** Beispiel: $\max x_1 + x_2$ u. d. N. $10x_1 + 10x_2 \le 15$, ganzzahlig. LP-Optimum $Z = 1{,}5$; Abrunden ergibt $(0,0)$ mit $Z = 0$ — **100 % Verlust**. Das ganzzahlige Optimum ist $(1,0)$ mit $Z = 1$. Prinzip: kleine Zahlen plus knappe Kapazität.
 
-**5.2 — Big-M wählen.** $M = 250$ (die bekannte Kapazität). Bei $M = 10^6$ bleibt das Modell korrekt, aber die LP-Relaxation wird extrem schwach: $y_j$ darf schon bei $x_j/10^6$ liegen, die Schranke ist praktisch wertlos, und Branch-and-Bound muss weit mehr Knoten durchsuchen.
+**6.2 — Big-M wählen.** $M = 250$ (die bekannte Kapazität). Bei $M = 10^6$ bleibt das Modell korrekt, aber die LP-Relaxation wird extrem schwach: $y_j$ darf schon bei $x_j/10^6$ liegen, die Schranke ist praktisch wertlos, und Branch-and-Bound muss weit mehr Knoten durchsuchen.
 
-**5.3 — Regeln übersetzen.** (a) $y_A + y_B \le 1$. (b) $\sum_{j=1}^4 y_j \ge 2$. (c) $y_1 + y_2 - 1 \le y_{\text{Lager}}$. (d) $500\,y \le x \le 2000\,y$ mit $y \in \{0,1\}$. (e) $\sum_{j=1}^3 y_j = 1$.
+**6.3 — Regeln übersetzen.** (a) $y_A + y_B \le 1$. (b) $\sum_{j=1}^4 y_j \ge 2$. (c) $y_1 + y_2 - 1 \le y_{\text{Lager}}$. (d) $500\,y \le x \le 2000\,y$ mit $y \in \{0,1\}$. (e) $\sum_{j=1}^3 y_j = 1$.
 
-**5.4 — Branch-and-Bound.** LP-Relaxation der Wurzel: nach Nutzen/Gewicht sortieren ($8/5=1{,}6$; $11/7=1{,}57$; $6/4=1{,}5$; $4/3=1{,}33$). Gierig füllen: $x_1=1$ (Rest 9), $x_2=1$ (Rest 2), $x_3 = 0{,}5$ → $Z_{LP} = 8+11+3 = 22$. Verzweigen über $x_3$. Ast $x_3=0$: $x_1=1,x_2=1,x_4=2/3$ → $Z = 21{,}67$; weiter verzweigen → beste ganzzahlige Lösung $(1,1,0,0)$ mit $Z=19$. Ast $x_3=1$: $x_1=1$, $x_3=1$, Rest 5 → $x_2=5/7$ → $Z = 21{,}86$; verzweigen führt auf $(1,0,1,1)$ mit $Z = 18$ und $(0,1,1,0)$ mit $Z=17$. **Optimum: $(1,1,0,0)$, $Z = 19$.**
+**6.4 — Branch-and-Bound.** LP-Relaxation der Wurzel: nach Nutzen/Gewicht sortieren ($8/5=1{,}6$; $11/7=1{,}57$; $6/4=1{,}5$; $4/3=1{,}33$). Gierig füllen: $x_1=1$ (Rest 9), $x_2=1$ (Rest 2), $x_3 = 0{,}5$ → $Z_{LP} = 8+11+3 = 22$. Verzweigen über $x_3$. Ast $x_3=0$: $x_1=1,x_2=1,x_4=2/3$ → $Z = 21{,}67$; weiter verzweigen → beste ganzzahlige Lösung $(1,1,0,0)$ mit $Z=19$. Ast $x_3=1$: $x_1=1$, $x_3=1$, Rest 5 → $x_2=5/7$ → $Z = 21{,}86$; verzweigen führt auf $(1,0,1,1)$ mit $Z = 18$ und $(0,1,1,0)$ mit $Z=17$. **Optimum: $(1,1,0,0)$, $Z = 19$.**
 
-**5.5 — Kardinalität variieren.** (a) Ab $K = 3$ steigt der Ertrag nicht mehr wesentlich, weil bereits drei Positionen à 40 000 € das Budget von 100 000 € abdecken können. (b) Rechenzeit steigt zunächst (mehr Kombinationen), fällt bei großem $K$ wieder (Restriktion bindet nicht mehr). (c) Der faire Preis ist die Differenz der Netto-Erträge zwischen $K=3$ und $K=4$ — bei den gegebenen Daten nahe null, weil die Obergrenze von 40 000 € bereits bindet.
+**6.5 — Kardinalität variieren.** (a) Ab $K = 3$ steigt der Ertrag nicht mehr wesentlich, weil bereits drei Positionen à 40 000 € das Budget von 100 000 € abdecken können. (b) Rechenzeit steigt zunächst (mehr Kombinationen), fällt bei großem $K$ wieder (Restriktion bindet nicht mehr). (c) Der faire Preis ist die Differenz der Netto-Erträge zwischen $K=3$ und $K=4$ — bei den gegebenen Daten nahe null, weil die Obergrenze von 40 000 € bereits bindet.
 
-**5.6 — Big-M-Effekt.** Erwartetes Muster: Knotenzahl und Laufzeit steigen deutlich mit $M$. Bei $M = 10^9$ ist die Relaxation so schwach, dass der Solver kaum noch prunen kann.
+**6.6 — Big-M-Effekt.** Erwartetes Muster: Knotenzahl und Laufzeit steigen deutlich mit $M$. Bei $M = 10^9$ ist die Relaxation so schwach, dass der Solver kaum noch prunen kann.
 
-**5.7 — Standortplanung.** Modell wie in Projekt P4. Prüfen Sie: Gesamtkapazität der eröffneten Lager $\ge$ Gesamtbedarf (140); bei Kapazität 80 je Lager sind mindestens $\lceil 140/80 \rceil = 2$ Lager nötig.
+**6.7 — Standortplanung.** Modell wie in Projekt P4. Prüfen Sie: Gesamtkapazität der eröffneten Lager $\ge$ Gesamtbedarf (140); bei Kapazität 80 je Lager sind mindestens $\lceil 140/80 \rceil = 2$ Lager nötig.
 
-### Finde den Denkfehler 5.1 — Elf Lager, die keine Fixkosten kosten
+### Finde den Denkfehler — Elf Lager, die keine Fixkosten kosten
 
 (a) **Warum die Zahl kleiner ist.** Ein größeres $M$ **lockert** die Nebenbedingung $\sum_j x_{ij} \le M y_i$. Der zulässige Bereich des Modells wird also größer, und in einem größeren Bereich kann das Minimum nur kleiner oder gleich bleiben. Bei einem *korrekt* formulierten Modell dürfte das aber gar nicht auffallen: Solange $y_i$ wirklich binär ist, ist $M \cdot 1 = M$ ohnehin größer als jede mögliche Liefermenge — die Lockerung wäre wirkungslos. Dass sich der Zielwert überhaupt ändert, ist deshalb schon der Beweis, dass $y_i$ **nicht** wirklich binär ist.
 
@@ -24601,15 +25749,15 @@ Test 3 ist der wichtigste. Er vergleicht nicht Modell mit Modell, sondern **Mode
 
 ## A.7 Lösungen zu Kapitel „Constraint Programming mit CP-SAT — Logik, Scheduling und Zuweisung“ {#sec:loesungen-cpsat}
 
-**6.1 — Propagation.** Aus $x_1 + x_2 = 8$ und $x_1 < x_2$ folgt $x_1 < 4$, also $x_1 \in \{2,3\}$ (denn $x_2 = 8-x_1 \le 6$ verlangt $x_1 \ge 2$) und entsprechend $x_2 \in \{5,6\}$. Aus 36 Kombinationen werden 2 zulässige.
+**7.1 — Propagation.** Aus $x_1 + x_2 = 8$ und $x_1 < x_2$ folgt $x_1 < 4$, also $x_1 \in \{2,3\}$ (denn $x_2 = 8-x_1 \le 6$ verlangt $x_1 \ge 2$) und entsprechend $x_2 \in \{5,6\}$. Aus 36 Kombinationen werden 2 zulässige.
 
-**6.2 — Hart oder weich.** (a) hart. (b) weich, mittlere Strafe (~50). (c) hart. (d) weich, mittlere Strafe (~80, weil geteilte Dienste stark belasten). (e) hart, falls gesetzlich; sonst weich mit sehr hoher Strafe (~1000).
+**7.2 — Hart oder weich.** (a) hart. (b) weich, mittlere Strafe (~50). (c) hart. (d) weich, mittlere Strafe (~80, weil geteilte Dienste stark belasten). (e) hart, falls gesetzlich; sonst weich mit sehr hoher Strafe (~1000).
 
-**6.3 — Regeln ergänzen.** (a) `for s in (2,3): modell.Add(x["Frau_Albrecht", s] == 0)` (b) Hilfsvariablen `arbeitet_bauer`, `arbeitet_koch` per `AddMaxEquality` an die Zuweisungssummen koppeln, dann `modell.Add(arbeitet_bauer + arbeitet_koch <= 1)`. (c) Belohnung = negative Strafe: `strafterme.append(-30 * folge_var)`, wobei `folge_var` per `AddBoolAnd`/`OnlyEnforceIf` an $x_{p,0} \wedge x_{p,1}$ gekoppelt wird.
+**7.3 — Regeln ergänzen.** (a) `for s in (2,3): modell.Add(x["Frau_Albrecht", s] == 0)` (b) Hilfsvariablen `arbeitet_bauer`, `arbeitet_koch` per `AddMaxEquality` an die Zuweisungssummen koppeln, dann `modell.Add(arbeitet_bauer + arbeitet_koch <= 1)`. (c) Belohnung = negative Strafe: `strafterme.append(-30 * folge_var)`, wobei `folge_var` per `AddBoolAnd`/`OnlyEnforceIf` an $x_{p,0} \wedge x_{p,1}$ gekoppelt wird.
 
-**6.4 — Infeasibility.** Mit `MAX_VERTRETUNGEN = 0` meldet der Solver `INFEASIBLE`. Nach Einbau der Schlupfvariablen lässt der Solver **alle vier** Stunden ausfallen (4 × 10 000 = 40 000 Strafpunkte) — es geht nicht anders. Interessanter wird es bei `MAX_VERTRETUNGEN = 1`: Dann fällt genau die Stunde aus, für die am wenigsten qualifiziertes Personal zur Verfügung steht.
+**7.4 — Infeasibility.** Mit `MAX_VERTRETUNGEN = 0` meldet der Solver `INFEASIBLE`. Nach Einbau der Schlupfvariablen lässt der Solver **alle vier** Stunden ausfallen (4 × 10 000 = 40 000 Strafpunkte) — es geht nicht anders. Interessanter wird es bei `MAX_VERTRETUNGEN = 1`: Dann fällt genau die Stunde aus, für die am wenigsten qualifiziertes Personal zur Verfügung steht.
 
-**6.5 — Sudoku.**
+**7.5 — Sudoku.**
 ```python
 x = [[m.NewIntVar(1, 9, f"x{i}{j}") for j in range(9)] for i in range(9)]
 for i in range(9): m.AddAllDifferent(x[i])                       # Zeilen
@@ -24623,11 +25771,20 @@ for i in range(9):
 ```
 **Etwa 10 Zeilen Modellcode** — und der Solver löst jedes Sudoku in Millisekunden. Das ist die Stärke globaler Constraints.
 
-**6.6 — Job-Shop erweitern.** (a) Rüstzeiten: `AddNoOverlap` durch paarweise Disjunktionen mit Übergangszeit ersetzen, oder `AddCircuit` je Maschine mit Übergangsmatrix. (b) Verspätung: `tardiness = MaxEquality(0, ende - faellig)`, in die Zielfunktion. (c) `AddCumulative(intervalle, [1]*n, 2)` statt `AddNoOverlap` für die Doppelmaschine.
+**7.6 — Die Grenze der Parallelität finden.** (a) Der Gewinn flacht ab und kehrt sich um. Auf einem Rechner mit 24 Kernen gemessen (Faktor gegenüber einem Arbeiter): 8 Arbeiter **10,2**, 16 Arbeiter **12,3**, 24 Arbeiter **9,0**. Wer alle Kerne belegt, ist langsamer als mit zwei Dritteln — dem Betriebssystem, dem Speicherbus und den Suchsträngen untereinander bleibt zu wenig Luft. Die Faustregel „so viele Arbeiter wie Kerne" ist also falsch; die richtige Zahl ist eine Messung, keine Einstellung. (b) **Fünf verschiedene Pläne aus fünf Seeds** — bei `num_workers = 1` und identischem Zielwert 183. Das ist die andere Hälfte der Antwort: Der Seed *wirkt*, aber nur auf den einzelnen Suchstrang. Es sichert also **keiner der beiden Parameter allein** die Reproduzierbarkeit:
 
-**6.7 — Wochendienstplan.** Siehe Projekt P2. Kernpunkte: Nachtschicht-Folgeregel über `AddImplication`; „höchstens 5 Tage in Folge“ über gleitende Fenster (`sum(x[p,t..t+5]) <= 5`).
+| | Seed fest | Seed variabel |
+| --- | --- | --- |
+| **1 Arbeiter** | reproduzierbar | 5 Pläne aus 5 Läufen |
+| **mehrere Arbeiter** | 3 Pläne aus 4 Läufen | erst recht nicht |
 
-### Finde den Denkfehler 6.1 — Die Betriebsvereinbarung, die niemanden interessiert
+Nur die Kombination trägt. (c) Bei **15 Aufträgen** (60 s Zeitlimit): Ein Arbeiter läuft ins Limit und meldet `FEASIBLE` mit Makespan 200; acht Arbeiter melden `OPTIMAL` mit **demselben** Makespan 200 nach 26,4 s. Bei 13 Aufträgen sind es 11,2 s gegen 2,8 s, bei 14 schon 21,4 s gegen 3,7 s. Bemerkenswert ist, dass beide denselben Wert finden — der Unterschied liegt nicht in der Lösung, sondern im **Beweis**, dass es keine bessere gibt. Genau diese Arbeit teilen sich die parallelen Stränge auf.
+
+**7.7 — Job-Shop erweitern.** (a) Rüstzeiten: `AddNoOverlap` durch paarweise Disjunktionen mit Übergangszeit ersetzen, oder `AddCircuit` je Maschine mit Übergangsmatrix. (b) Verspätung: `tardiness = MaxEquality(0, ende - faellig)`, in die Zielfunktion. (c) `AddCumulative(intervalle, [1]*n, 2)` statt `AddNoOverlap` für die Doppelmaschine.
+
+**7.8 — Wochendienstplan.** Siehe Projekt P2. Kernpunkte: Nachtschicht-Folgeregel über `AddImplication`; „höchstens 5 Tage in Folge“ über gleitende Fenster (`sum(x[p,t..t+5]) <= 5`).
+
+### Finde den Denkfehler — Die Betriebsvereinbarung, die niemanden interessiert
 
 (a) **Warum die Regel verletzt wird.** Weil sie einen **Preis** hat. Eine weiche Nebenbedingung verbietet nichts — sie verteuert. Der Solver vergleicht in jedem Schritt, was ihn eine Verletzung kostet und was sie ihm einbringt. Bei einem Gewicht von 1 gegen 10 lohnt sich eine Drei-Tage-Serie, sobald sie auch nur ein Zehntel eines Wunsches rettet. Der Solver hat genau das getan, was im Modell steht — er hat nur nicht getan, was gemeint war.
 
@@ -24676,16 +25833,18 @@ Das ist eine Frage, die eine Zahl als Antwort hat. Und wenn der Auftraggeber sie
 3. Eine Variable mit Start, Dauer und Ende; sie garantiert automatisch `start + dauer == ende`.
 4. Weil jede zusätzliche harte Bedingung das Risiko von `INFEASIBLE` erhöht — und eine Fehlermeldung dem Anwender nicht hilft.
 5. Weil Anwender die Frage „Warum ich?“ stellen. Ohne Antwort wird das System umgangen.
+6. Weil der Seed nur festlegt, wie ein **einzelner** Suchstrang würfelt — nicht, welcher von mehreren parallelen zuerst fertig wird. Das entscheidet die Ausführungsreihenfolge, also die Uhr. Abhilfe: zusätzlich `num_workers = 1`. Gemessen: schon zwei Arbeiter liefern bei identischem Seed drei verschiedene Pläne zum selben Zielwert.
+7. Weil CP-SAT nicht dieselbe Suche vervielfacht, sondern **verschiedene Strategien** nebeneinander laufen lässt (LP-gestützt, andere Verzweigungsregeln, lokale Suche), die einander ihre Schranken mitteilen. Ein zusätzlicher Arbeiter ist deshalb nicht ein weiterer Kern für dieselbe Arbeit, sondern ein anderes Verfahren — und wenn eines davon früh eine gute Schranke findet, profitieren alle.
 
 ---
 
 ## A.8 Lösungen zu Kapitel „Graphen, Flüsse und Touren — Min-Cost-Flow, Matching und VRP“ {#sec:loesungen-graphen}
 
-**7.1 — Flusserhaltung.** $b_i = (15+3) - (12+8) = -2$ → **Senke** (Nettobedarf 2).
+**8.1 — Flusserhaltung.** $b_i = (15+3) - (12+8) = -2$ → **Senke** (Nettobedarf 2).
 
-**7.2 — Unlösbarkeit.** Die Summe aller Flusserhaltungsgleichungen ergibt $\sum_i b_i = 0$ (jede Kante taucht einmal mit $+1$ und einmal mit $-1$ auf). Ist die Summe ungleich null, widersprechen sich die Gleichungen. Bei Angebotsüberschuss führt man einen künstlichen **Dummy-Senkenknoten** mit dem Restbedarf und Kosten 0 ein.
+**8.2 — Unlösbarkeit.** Die Summe aller Flusserhaltungsgleichungen ergibt $\sum_i b_i = 0$ (jede Kante taucht einmal mit $+1$ und einmal mit $-1$ auf). Ist die Summe ungleich null, widersprechen sich die Gleichungen. Bei Angebotsüberschuss führt man einen künstlichen **Dummy-Senkenknoten** mit dem Restbedarf und Kosten 0 ein.
 
-**7.3 — Transportproblem.** (a) Angebot $30+25+45 = 100$, Bedarf $25+30+20+25 = 100$ ✓ (b) Optimale Kosten: **790**. Transportplan:
+**8.3 — Transportproblem.** (a) Angebot $30+25+45 = 100$, Bedarf $25+30+20+25 = 100$ ✓ (b) Optimale Kosten: **790**. Transportplan:
 
 | von \ nach | L1 | L2 | L3 | L4 | Summe |
 | --- | ---: | ---: | ---: | ---: | ---: |
@@ -24696,15 +25855,15 @@ Das ist eine Frage, die eine Zahl als Antwort hat. Und wenn der Auftraggeber sie
 
 Beachten Sie, dass Werk 3 seine günstigste Verbindung (L4 zu 5) voll ausschöpft und W2 ausschließlich L1 beliefert (9), obwohl L4 mit 7 billiger wäre — dort ist der Bedarf bereits von W3 gedeckt. (c) Die Lösung ist ganzzahlig, obwohl nicht gefordert — die Transportmatrix ist **total unimodular**, alle Ecken sind ganzzahlig.
 
-**7.4 — Zuordnung mit Verboten.** Kosten auf einen sehr hohen Wert setzen (`kosten[2][2] = 1e6`) oder mit `np.inf` arbeiten (bei `linear_sum_assignment` erlaubt). Die Lösung weicht auf die zweitbeste Zuordnung für Carla aus; die Gesamtkosten steigen um die Differenz.
+**8.4 — Zuordnung mit Verboten.** Kosten auf einen sehr hohen Wert setzen (`kosten[2][2] = 1e6`) oder mit `np.inf` arbeiten (bei `linear_sum_assignment` erlaubt). Die Lösung weicht auf die zweitbeste Zuordnung für Carla aus; die Gesamtkosten steigen um die Differenz.
 
-**7.5 — Engpass finden.** Die Dualwerte der Kapazitätsschranken (`res.upper.marginals` bei `linprog`) zeigen es direkt; alternativ jede Kapazität einzeln um 1 erhöhen und neu rechnen. Im Beispiel ist die Kante `Werk_A → Umschlag` der Engpass (voll ausgelastet, günstigster Weg).
+**8.5 — Engpass finden.** Die Dualwerte der Kapazitätsschranken (`res.upper.marginals` bei `linprog`) zeigen es direkt; alternativ jede Kapazität einzeln um 1 erhöhen und neu rechnen. Im Beispiel ist die Kante `Werk_A → Umschlag` der Engpass (voll ausgelastet, günstigster Weg).
 
-**7.6 — VRP variieren.** (a) Mit 3 Fahrzeugen werden die Touren länger, die Gesamtfahrzeit steigt leicht, die Auslastung deutlich. (b) Unlösbar, sobald $\text{Kapazität} \times \text{Fahrzeuge} < \text{Gesamtbedarf}$ (hier: bei 3 Fahrzeugen à 10 sind 30 < 37 → unlösbar) **oder** wenn Zeitfenster nicht mehr eingehalten werden können. (c) 1 s liefert meist eine brauchbare, 30 s eine spürbar bessere Lösung — die Metaheuristik verbessert kontinuierlich. (d) Doppelte Servicezeit kann Zeitfenster verletzen → möglicherweise unlösbar.
+**8.6 — VRP variieren.** (a) Mit 3 Fahrzeugen werden die Touren länger, die Gesamtfahrzeit steigt leicht, die Auslastung deutlich. (b) Unlösbar, sobald $\text{Kapazität} \times \text{Fahrzeuge} < \text{Gesamtbedarf}$ (hier: bei 3 Fahrzeugen à 10 sind 30 < 37 → unlösbar) **oder** wenn Zeitfenster nicht mehr eingehalten werden können. (c) 1 s liefert meist eine brauchbare, 30 s eine spürbar bessere Lösung — die Metaheuristik verbessert kontinuierlich. (d) Doppelte Servicezeit kann Zeitfenster verletzen → möglicherweise unlösbar.
 
-**7.7 — TSP mit MTZ.** Erwartetes Ergebnis: Bei 8 Städten löst das MILP in Sekunden. Ab etwa 12–15 Städten wird die schwache MTZ-Relaxation zum Problem, und die Laufzeit steigt stark — während OR-Tools weiterhin in Sekundenbruchteilen sehr gute Touren liefert.
+**8.7 — TSP mit MTZ.** Erwartetes Ergebnis: Bei 8 Städten löst das MILP in Sekunden. Ab etwa 12–15 Städten wird die schwache MTZ-Relaxation zum Problem, und die Laufzeit steigt stark — während OR-Tools weiterhin in Sekundenbruchteilen sehr gute Touren liefert.
 
-### Finde den Denkfehler 7.1 — Die vergessene Dimension
+### Finde den Denkfehler — Die vergessene Dimension
 
 (a) **Was die Fahrzeuge tun.** Fahrzeuge 1, 2 und 3 fahren **gar nicht** — sie stehen mit null Stopps im Depot. Fahrzeug 4 bedient alle 16 Kunden und lädt dabei **37 Paletten** bei einer Kapazität von 10. Es ist um 270 % überladen. Physikalisch ist dieser Plan nicht ausführbar; im Modell ist er die beste Lösung.
 
@@ -24735,7 +25894,7 @@ ladung = loesung.Value(routing.GetDimensionOrDie("Ladung").CumulVar(index))
 
 Diese Zeile fragt das Modell, ob das Modell sich an sich selbst hält. Existiert die Dimension „Ladung“ gar nicht, stürzt sie ab — und existiert sie, kann sie per Konstruktion nie verletzt sein. Sie prüft also entweder nichts oder gar nichts.
 
-**Die allgemeine Regel:** Eine Prüfung, die dieselben Bausteine verwendet wie das Modell, prüft das Modell gegen sich selbst. Nützlich ist nur eine Prüfung, die von der **ausgegebenen Lösung** ausgeht und die Anforderungen der Wirklichkeit unabhängig nachrechnet — genau wie die Kostengegenrechnung in [Denkfehler 5.1](#kapitel-5) und die Verbrauchsprüfung in [Denkfehler 1.1](#kapitel-1).
+**Die allgemeine Regel:** Eine Prüfung, die dieselben Bausteine verwendet wie das Modell, prüft das Modell gegen sich selbst. Nützlich ist nur eine Prüfung, die von der **ausgegebenen Lösung** ausgeht und die Anforderungen der Wirklichkeit unabhängig nachrechnet — genau wie die Kostengegenrechnung in [Abschnitt 6.10](#sec:milp-denkfehler) und die Verbrauchsprüfung in [Abschnitt 1.10](#sec:einfuehrung-denkfehler).
 
 ### Micro-Quiz {#quiz-loesung-graphen}
 
@@ -24743,7 +25902,7 @@ Diese Zeile fragt das Modell, ob das Modell sich an sich selbst hält. Existiert
 
 **2 — (b) die Struktur geht verloren.** „Höchstens 4 von 12“ ist eine Kardinalitätsregel; ihre Zeile passt nicht in das Schema, das die totale Unimodularität sichert. Die Relaxation kann dann Brüche liefern (etwa vier Monteure zu je 0,75 Überstunden), und man braucht Binärvariablen und Branch-and-Bound. (a) ist die gefährliche Fehlannahme: Die Eigenschaft ist **zerbrechlich**, eine einzige zusätzliche Zeile genügt. (c) verwechselt „schwerer zu lösen“ mit „unlösbar“.
 
-**3 — (b) fehlende Dimension.** Ohne begrenzende Dimension ist jede zusätzliche Tour reine Zusatzstrecke — ein Optimierer legt dann folgerichtig alles auf ein Fahrzeug. Genau dieses Bild zeigt Denkfehler 7.1. (a) wäre zu prüfen, wenn die Lösung *schlecht* aussähe, nicht wenn sie verdächtig gut ist. (c) ist zwar eine sinnvolle Datenprüfung, erklärt aber nicht, warum drei Fahrzeuge unbenutzt bleiben.
+**3 — (b) fehlende Dimension.** Ohne begrenzende Dimension ist jede zusätzliche Tour reine Zusatzstrecke — ein Optimierer legt dann folgerichtig alles auf ein Fahrzeug. Genau dieses Bild zeigt [Abschnitt 8.7](#sec:graphen-denkfehler). (a) wäre zu prüfen, wenn die Lösung *schlecht* aussähe, nicht wenn sie verdächtig gut ist. (c) ist zwar eine sinnvolle Datenprüfung, erklärt aber nicht, warum drei Fahrzeuge unbenutzt bleiben.
 
 ### Selbsttest {#selbsttest-loesung-graphen}
 1. Abfluss minus Zufluss = Knotensaldo; entspricht der Kirchhoffschen Knotenregel.
@@ -24756,15 +25915,15 @@ Diese Zeile fragt das Modell, ob das Modell sich an sich selbst hält. Existiert
 
 ## A.9 Lösungen zu Kapitel „Metaheuristiken — wenn der exakte Solver aussteigt“ {#sec:loesungen-metaheuristiken}
 
-**Die Kurzsichtigkeit von Hand.** Ab *Schwarz* wählt die Faustregel: Schwarz → Dunkelrot (26) → Rot (5) → … und muss dann in die helle Gruppe: Rot → Weiß (50) → Elfenbein (2) → Beige (2). Summe **85 Minuten** — also noch einen Deut schlechter als die 84 ab Weiß. Der Grund ist derselbe: Die Regel erwischt den Gruppenwechsel an der teuersten Stelle. Bemerkenswert ist aber, dass der *Startpunkt* kaum etwas ändert. Das ist typisch: Eine kurzsichtige Regel scheitert nicht am Anfang, sondern an der Reihenfolge, in der sie ihre Möglichkeiten verbraucht.
+**9.1 — Die Kurzsichtigkeit von Hand.** Ab *Schwarz* wählt die Faustregel: Schwarz → Dunkelrot (26) → Rot (5) → … und muss dann in die helle Gruppe: Rot → Weiß (50) → Elfenbein (2) → Beige (2). Summe **85 Minuten** — also noch einen Deut schlechter als die 84 ab Weiß. Der Grund ist derselbe: Die Regel erwischt den Gruppenwechsel an der teuersten Stelle. Bemerkenswert ist aber, dass der *Startpunkt* kaum etwas ändert. Das ist typisch: Eine kurzsichtige Regel scheitert nicht am Anfang, sondern an der Reihenfolge, in der sie ihre Möglichkeiten verbraucht.
 
-**Zuggröße und Temperatur.** Gesucht ist $T$ mit $e^{-70/T} = e^{-1}$, also **$T = 70$**. Die getesteten Temperaturen liegen zwischen 0,5 und 8 — allesamt **eine Größenordnung darunter**. Bei $T_0 = 8$ hat eine mediane Verschlechterung die Annahmewahrscheinlichkeit $e^{-70/8} \approx 0{,}00016$. Genau das ist der Punkt der Warnung im Kapitel: Die verbreitete Regel „20 bis 50 % Annahmequote“ würde hier $T_0 \approx 50$ verlangen, und bei dieser Temperatur ist die Suche ein reiner Zufallslauf.
+**9.2 — Zuggröße und Temperatur.** Gesucht ist $T$ mit $e^{-70/T} = e^{-1}$, also **$T = 70$**. Die getesteten Temperaturen liegen zwischen 0,5 und 8 — allesamt **eine Größenordnung darunter**. Bei $T_0 = 8$ hat eine mediane Verschlechterung die Annahmewahrscheinlichkeit $e^{-70/8} \approx 0{,}00016$. Genau das ist der Punkt der Warnung im Kapitel: Die verbreitete Regel „20 bis 50 % Annahmequote“ würde hier $T_0 \approx 50$ verlangen, und bei dieser Temperatur ist die Suche ein reiner Zufallslauf.
 
-**Die teure Bewertung.** Statt `delta_verschieben` die Reihenfolge tatsächlich umbauen und `gesamtruestzeit()` neu rechnen. Bei $n = 200$ kostet das rund 200 Matrixzugriffe statt sechs. Erwartung: Die Zugzahl je Sekunde bricht um etwa zwei Größenordnungen ein. Bei gleichem **Zeitbudget** kommt die Suche entsprechend weniger weit; bei gleichem **Zugbudget** ist das Ergebnis identisch (die Bewertung ist ja korrekt, nur langsam). Genau diese Unterscheidung ist der Lehrpunkt: Die Implementierung ändert nicht das Verfahren, sondern nur, wie viel davon in das Zeitbudget passt.
+**9.3 — Die teure Bewertung.** Statt `delta_verschieben` die Reihenfolge tatsächlich umbauen und `gesamtruestzeit()` neu rechnen. Bei $n = 200$ kostet das rund 200 Matrixzugriffe statt sechs. Erwartung: Die Zugzahl je Sekunde bricht um etwa zwei Größenordnungen ein. Bei gleichem **Zeitbudget** kommt die Suche entsprechend weniger weit; bei gleichem **Zugbudget** ist das Ergebnis identisch (die Bewertung ist ja korrekt, nur langsam). Genau diese Unterscheidung ist der Lehrpunkt: Die Implementierung ändert nicht das Verfahren, sondern nur, wie viel davon in das Zeitbudget passt.
 
-**Der Umschlagpunkt genauer.** Sinnvolle Zwischengrößen sind 250, 300, 350 und 400. Zu erwarten ist ein **verwaschener** Übergang, kein scharfer Punkt: Der exakte Solver verschlechtert sich nicht sprunghaft, sondern sein Gap wächst, und irgendwann liegt seine beste gefundene Lösung über der heuristischen. Wo genau das passiert, hängt zusätzlich vom Zeitlimit ab — mit 300 Sekunden statt 30 verschiebt sich der Punkt nach oben. Die belastbare Aussage ist deshalb nie „ab $n = 380$“, sondern immer „ab $n \approx 380$ **bei diesem Zeitbudget**“.
+**9.4 — Der Umschlagpunkt genauer.** Sinnvolle Zwischengrößen sind 250, 300, 350 und 400. Zu erwarten ist ein **verwaschener** Übergang, kein scharfer Punkt: Der exakte Solver verschlechtert sich nicht sprunghaft, sondern sein Gap wächst, und irgendwann liegt seine beste gefundene Lösung über der heuristischen. Wo genau das passiert, hängt zusätzlich vom Zeitlimit ab — mit 300 Sekunden statt 30 verschiebt sich der Punkt nach oben. Die belastbare Aussage ist deshalb nie „ab $n = 380$“, sondern immer „ab $n \approx 380$ **bei diesem Zeitbudget**“.
 
-**Zerstören nach Maß.** Die kostenbasierte Zerstörung entfernt gezielt dort, wo etwas zu holen ist, und findet deshalb pro Runde mehr. Sie hat aber zwei Nachteile: Sie muss die Übergangskosten jedes Mal sortieren, und die entfernten Aufträge liegen über den ganzen Plan verstreut — das Teilproblem für CP-SAT ist damit schwieriger als ein zusammenhängendes Fenster gleicher Größe, weil auch alle Einfügestellen offen sind.
+**9.5 — Zerstören nach Maß.** Die kostenbasierte Zerstörung entfernt gezielt dort, wo etwas zu holen ist, und findet deshalb pro Runde mehr. Sie hat aber zwei Nachteile: Sie muss die Übergangskosten jedes Mal sortieren, und die entfernten Aufträge liegen über den ganzen Plan verstreut — das Teilproblem für CP-SAT ist damit schwieriger als ein zusammenhängendes Fenster gleicher Größe, weil auch alle Einfügestellen offen sind.
 
 Die Aufgabe ist bewusst so gestellt, dass die Antwort **gemessen** werden muss. Wer nur die Ergebniswerte vergleicht, kann Strategie und Rundenzahl nicht trennen. Die saubere Auswertung protokolliert beides: Verbesserungen **je Runde** (Güte der Strategie) und Runden **je Sekunde** (ihr Preis).
 
@@ -24800,28 +25959,28 @@ Die Konsequenz ist keine Absage an das Projekt — 6,2 % sind echt und werden ve
 
 ## A.10 Lösungen zu Kapitel „Spaltengenerierung“ {#sec:loesungen-dekomposition}
 
-**Das Abbruchkriterium.** Die Eins ist der Zielfunktionskoeffizient eines Musters: Jedes geschnittene Muster verbraucht **genau eine** Mutterrolle, und die Zielfunktion lautet $\min \sum_p x_p$. Die reduzierten Kosten einer neuen Spalte sind $c_p - \pi^\top a_p = 1 - \sum_i \pi_i a_{ip}$; sie sind negativ — die Spalte lohnt sich also —, wenn $\sum_i \pi_i a_{ip} > 1$.
+**10.1 — Das Abbruchkriterium.** Die Eins ist der Zielfunktionskoeffizient eines Musters: Jedes geschnittene Muster verbraucht **genau eine** Mutterrolle, und die Zielfunktion lautet $\min \sum_p x_p$. Die reduzierten Kosten einer neuen Spalte sind $c_p - \pi^\top a_p = 1 - \sum_i \pi_i a_{ip}$; sie sind negativ — die Spalte lohnt sich also —, wenn $\sum_i \pi_i a_{ip} > 1$.
 
 Wäre die Zielfunktion eine andere — etwa „minimiere den Verschnitt in Millimetern" —, stünde dort statt der Eins der Verschnitt des Musters. Die Eins ist also kein Zauberwert, sondern schlicht die Kosten der Spalte.
 
-**Die Startbasis.** Ein Muster, das nur eine einzige Breite enthält, ist immer zulässig: $\lfloor W / b_i \rfloor$ Stücke der Breite $i$ passen in jede Rolle. Mit diesen $n$ Mustern lässt sich **jeder** Bedarf decken — notfalls sehr verschwenderisch, aber zulässig.
+**10.2 — Die Startbasis.** Ein Muster, das nur eine einzige Breite enthält, ist immer zulässig: $\lfloor W / b_i \rfloor$ Stücke der Breite $i$ passen in jede Rolle. Mit diesen $n$ Mustern lässt sich **jeder** Bedarf decken — notfalls sehr verschwenderisch, aber zulässig.
 
 Eine leere Startmenge wäre ein Problem, weil das Master-LP dann unzulässig ist: Es gibt keine Spalten, mit denen sich die Bedarfszeilen erfüllen ließen. Ohne zulässige Lösung gibt es keine Dualwerte, und ohne Dualwerte kann das Pricing nicht arbeiten. Die Schleife käme nie in Gang.
 
 (In der Literatur behilft man sich alternativ mit künstlichen Variablen und sehr hohen Strafkosten — dieselbe Idee wie die Big-M-Phase des Simplex aus [Kapitel 5](#kap-lp).)
 
-**Die Kennzahl prüfen.** Zu erwarten ist ein deutlicher, monotoner Zusammenhang: Je mehr Stücke auf eine Rolle passen, desto kleiner die Ersparnis. Bei zwei Stücken je Rolle entscheidet jede Paarung, und die Faustregel verschenkt regelmäßig ganze Rollen; ab acht bis zehn Stücken ist sie praktisch immer optimal.
+**10.3 — Die Kennzahl prüfen.** Zu erwarten ist ein deutlicher, monotoner Zusammenhang: Je mehr Stücke auf eine Rolle passen, desto kleiner die Ersparnis. Bei zwei Stücken je Rolle entscheidet jede Paarung, und die Faustregel verschenkt regelmäßig ganze Rollen; ab acht bis zehn Stücken ist sie praktisch immer optimal.
 
 Der Grund ist ein Verhältnis: Der Verschnitt einer Rolle ist höchstens so groß wie das kleinste nicht mehr passende Stück. Sind die Stücke klein gegen die Rolle, ist auch dieser Rest klein — und der Gesamtverschnitt nähert sich der theoretischen Untergrenze $\lceil \sum_i b_i d_i / W \rceil$, die jede Methode erreichen muss.
 
-**Dienstplanung.** Eine „Spalte" ist ein **vollständiger zulässiger Wochenplan einer Person**: an welchen Tagen sie welche Schicht übernimmt.
+**10.4 — Dienstplanung.** Eine „Spalte" ist ein **vollständiger zulässiger Wochenplan einer Person**: an welchen Tagen sie welche Schicht übernimmt.
 
 * **Ins Master gehört**, was Personen miteinander koppelt: Jede Schicht muss besetzt sein ($\sum_p a_{sp} x_p \ge$ Bedarf je Schicht $s$), und jede Person bekommt genau einen Plan.
 * **Ins Teilproblem gehört**, was innerhalb einer Person gilt: Höchstarbeitszeit, Ruhezeiten, Qualifikation, keine zwei Schichten am selben Tag, höchstens zwei Wochenenden im Monat.
 
 Das ist der eigentliche Gewinn der Zerlegung: Die komplizierten arbeitsrechtlichen Regeln stehen im Teilproblem und werden dort **einmal je Person** geprüft, statt das Master zu überfrachten. Das Teilproblem ist meist ein kürzester Weg über ein Zeit-Zustands-Netz ([Kapitel 8](#kap-graphen)) statt eines Rucksacks.
 
-**Branch-and-Price.** Das Problem: Verzweigt man auf einer Mustervariablen ($x_p \le 3$ gegen $x_p \ge 4$), so ist diese Bedingung im **Pricing** nicht darstellbar. Das Teilproblem erzeugt Muster, es kennt keine Verzweigungsentscheidungen über einzelne Spalten — es könnte im nächsten Schritt genau das ausgeschlossene Muster wieder erzeugen.
+**10.5 — Branch-and-Price.** Das Problem: Verzweigt man auf einer Mustervariablen ($x_p \le 3$ gegen $x_p \ge 4$), so ist diese Bedingung im **Pricing** nicht darstellbar. Das Teilproblem erzeugt Muster, es kennt keine Verzweigungsentscheidungen über einzelne Spalten — es könnte im nächsten Schritt genau das ausgeschlossene Muster wieder erzeugen.
 
 Branch-and-Price löst das, indem es auf **Originalgrößen** verzweigt statt auf Spalten: etwa „in wie vielen Rollen kommen Breite $i$ und Breite $j$ gemeinsam vor?" Solche Bedingungen lassen sich ins Pricing-Teilproblem einbauen, weil sie über die Struktur eines Musters sprechen und nicht über seine Identität.
 
@@ -24867,19 +26026,19 @@ Die Schranke sagt: *Weniger als 73 Rollen sind unmöglich.* Sie sagt **nicht**:
 
 ## A.11 Lösungen zu Kapitel „Quadratische und nichtlineare Optimierung — KKT, Lagrange, Konvexität“ {#sec:loesungen-qp-nlp}
 
-**8.1 — Konvexität einordnen.** PSD (alle $\ge 0$) → **konvex**, aber **nicht streng** konvex; die Lösung ist **nicht notwendig eindeutig**. Der Eigenwert 0 bedeutet eine **flache Richtung**: Entlang des zugehörigen Eigenvektors ändert sich der quadratische Term nicht — es gibt eine Rinne statt eines Punktes.
+**11.1 — Konvexität einordnen.** PSD (alle $\ge 0$) → **konvex**, aber **nicht streng** konvex; die Lösung ist **nicht notwendig eindeutig**. Der Eigenwert 0 bedeutet eine **flache Richtung**: Entlang des zugehörigen Eigenvektors ändert sich der quadratische Term nicht — es gibt eine Rinne statt eines Punktes.
 
-**8.2 — Komplementärer Schlupf.** Ja, verträglich: $\lambda_i w_i = 0$ gilt für alle $i$ ($w_2 = 0$ mit $\lambda_2 > 0$; die anderen mit $\lambda = 0$). $\lambda_2 = 0{,}03$ bedeutet: Würde man Titel 2 zwingen, ein kleines positives Gewicht zu tragen, verschlechterte sich der Zielwert um 0,03 je Einheit — die Nichtnegativitätsschranke ist dort **bindend**.
+**11.2 — Komplementärer Schlupf.** Ja, verträglich: $\lambda_i w_i = 0$ gilt für alle $i$ ($w_2 = 0$ mit $\lambda_2 > 0$; die anderen mit $\lambda = 0$). $\lambda_2 = 0{,}03$ bedeutet: Würde man Titel 2 zwingen, ein kleines positives Gewicht zu tragen, verschlechterte sich der Zielwert um 0,03 je Einheit — die Nichtnegativitätsschranke ist dort **bindend**.
 
-**8.3 — KKT von Hand.** $\mathcal{L} = x_1^2 + x_2^2 + \lambda(4 - x_1 - x_2)$. Stationarität: $2x_1 = \lambda$, $2x_2 = \lambda$ → $x_1 = x_2$. Bindend ($\lambda > 0$): $x_1 + x_2 = 4$ → $x_1 = x_2 = 2$, $\lambda = 4$. Prüfung: $\lambda = 4 > 0$ ✓, $f = 8$. **Interpretation:** Würde die Forderung auf $\ge 4{,}1$ steigen, stiege $f$ um etwa $4 \cdot 0{,}1 = 0{,}4$. Probe: $2\cdot(2{,}05)^2 = 8{,}405$ ✓.
+**11.3 — KKT von Hand.** $\mathcal{L} = x_1^2 + x_2^2 + \lambda(4 - x_1 - x_2)$. Stationarität: $2x_1 = \lambda$, $2x_2 = \lambda$ → $x_1 = x_2$. Bindend ($\lambda > 0$): $x_1 + x_2 = 4$ → $x_1 = x_2 = 2$, $\lambda = 4$. Prüfung: $\lambda = 4 > 0$ ✓, $f = 8$. **Interpretation:** Würde die Forderung auf $\ge 4{,}1$ steigen, stiege $f$ um etwa $4 \cdot 0{,}1 = 0{,}4$. Probe: $2\cdot(2{,}05)^2 = 8{,}405$ ✓.
 
-**8.4 — Unmögliche Korrelationsmatrix.** Eigenwerte $\approx (-0{,}62;\ 1{,}0;\ 2{,}62)$ → **nicht PSD**, also unmöglich. Anschaulich: Wenn A stark **positiv** mit B korreliert und B stark positiv mit C, kann A nicht gleichzeitig stark **negativ** mit C korrelieren — Korrelation ist eingeschränkt transitiv. Formal: $\rho_{AC} \ge \rho_{AB}\rho_{BC} - \sqrt{(1-\rho_{AB}^2)(1-\rho_{BC}^2)} = 0{,}81 - 0{,}19 = 0{,}62$; verlangt waren $-0{,}9$.
+**11.4 — Unmögliche Korrelationsmatrix.** Eigenwerte $\approx (-0{,}62;\ 1{,}0;\ 2{,}62)$ → **nicht PSD**, also unmöglich. Anschaulich: Wenn A stark **positiv** mit B korreliert und B stark positiv mit C, kann A nicht gleichzeitig stark **negativ** mit C korrelieren — Korrelation ist eingeschränkt transitiv. Formal: $\rho_{AC} \ge \rho_{AB}\rho_{BC} - \sqrt{(1-\rho_{AB}^2)(1-\rho_{BC}^2)} = 0{,}81 - 0{,}19 = 0{,}62$; verlangt waren $-0{,}9$.
 
-**8.5 — Gewichtung untersuchen.** Erwartetes Muster: Größeres $\alpha$ → mehr Rendite, mehr Konzentration im Titel mit höchstem $\mu$. Größeres $\beta$ → gleichmäßigere Gewichte, Entropie steigt Richtung $\ln 4 = 1{,}386$. Ab etwa $\beta \approx 0{,}1$ dominiert die Entropie und man nähert sich der Gleichgewichtung. **Empfehlung an einen Ausschuss:** Nicht mit $\beta$ argumentieren, sondern mit der resultierenden **Maximalposition** — „mit dieser Einstellung liegt keine Position über 40 %“ ist verständlich, „$\beta = 0{,}015$“ nicht.
+**11.5 — Gewichtung untersuchen.** Erwartetes Muster: Größeres $\alpha$ → mehr Rendite, mehr Konzentration im Titel mit höchstem $\mu$. Größeres $\beta$ → gleichmäßigere Gewichte, Entropie steigt Richtung $\ln 4 = 1{,}386$. Ab etwa $\beta \approx 0{,}1$ dominiert die Entropie und man nähert sich der Gleichgewichtung. **Empfehlung an einen Ausschuss:** Nicht mit $\beta$ argumentieren, sondern mit der resultierenden **Maximalposition** — „mit dieser Einstellung liegt keine Position über 40 %“ ist verständlich, „$\beta = 0{,}015$“ nicht.
 
-**8.6 — Nicht-Konvexität demonstrieren.** Mit der bewusst fehlerhaft konstruierten Matrix finden 20 Startpunkte typischerweise mehrere verschiedene Optima; die „Portfoliovarianz“ $w^\top\Sigma w$ kann bei geeigneten Gewichten negativ werden (der zugehörige Eigenvektor liegt allerdings teilweise außerhalb des zulässigen Bereichs $w \ge 0{,}001$, $\sum w = 1$ — deshalb fällt der Fehler bei naiver Prüfung nicht auf).
+**11.6 — Nicht-Konvexität demonstrieren.** Mit der bewusst fehlerhaft konstruierten Matrix finden 20 Startpunkte typischerweise mehrere verschiedene Optima; die „Portfoliovarianz“ $w^\top\Sigma w$ kann bei geeigneten Gewichten negativ werden (der zugehörige Eigenvektor liegt allerdings teilweise außerhalb des zulässigen Bereichs $w \ge 0{,}001$, $\sum w = 1$ — deshalb fällt der Fehler bei naiver Prüfung nicht auf).
 
-### Finde den Denkfehler 8.1 — Die Kovarianzmatrix aus dem Controlling
+### Finde den Denkfehler — Die Kovarianzmatrix aus dem Controlling
 
 (a) **Ohne zu rechnen.** Stellen Sie sich die drei Anlagen als drei Personen vor, die nebeneinander gehen. A und B gehen fast im Gleichschritt ($0{,}9$). B und C gehen fast im Gleichschritt ($0{,}9$). Können A und C dann in *entgegengesetzte* Richtungen laufen? Nein — wenn A B folgt und B C folgt, muss A ungefähr auch C folgen. Korrelation ist zwar nicht transitiv im strengen Sinne, aber sie ist **eingeschränkt**: Zwei starke Bindungen zwingen die dritte in einen engen Bereich.
 
@@ -24918,7 +26077,7 @@ Der Ausweg auf `scipy` hat das Warnsystem umgangen, nicht das Problem gelöst. R
 
 ### Micro-Quiz {#quiz-loesung-qp-nlp}
 
-**1 — (b).** Der `DCPError` ist eine inhaltliche Aussage: Für diese Formulierung kann es keine Optimalitätsgarantie geben. Auf `scipy` auszuweichen (a) beseitigt die Meldung, nicht die Ursache — man bekommt dann ein lokales Ergebnis ohne Garantie und ohne Warnung, wie Denkfehler 8.1 zeigt. Toleranzen (c) haben mit Konvexität nichts zu tun. Richtig ist, zwischen zwei bewussten Wegen zu wählen: konvex umformulieren, oder lokal rechnen **und** das im Bericht kenntlich machen.
+**1 — (b).** Der `DCPError` ist eine inhaltliche Aussage: Für diese Formulierung kann es keine Optimalitätsgarantie geben. Auf `scipy` auszuweichen (a) beseitigt die Meldung, nicht die Ursache — man bekommt dann ein lokales Ergebnis ohne Garantie und ohne Warnung, wie [Abschnitt 11.8](#sec:qp-nlp-denkfehler) zeigt. Toleranzen (c) haben mit Konvexität nichts zu tun. Richtig ist, zwischen zwei bewussten Wegen zu wählen: konvex umformulieren, oder lokal rechnen **und** das im Bericht kenntlich machen.
 
 **2 — (b) ein lokales Minimum.** `success: True` beschreibt die Konvergenz des Verfahrens, nicht die Qualität des Ergebnisses. Bei Mengenrabatten ist die Zielfunktion nicht konvex, also kann es mehrere lokale Minima geben — im Kapitelbeispiel fünf, mit 8 % Spanne. (a) wäre nur bei einem konvexen Problem richtig. (c) ist zu pessimistisch: Ein lokales Minimum ist es sehr wohl, die Zulässigkeit wird von SLSQP eingehalten.
 
@@ -24935,26 +26094,26 @@ Der Ausweg auf `scipy` hat das Warnsystem umgangen, nicht das Problem gelöst. R
 
 ## A.12 Lösungen zu Kapitel „Optimierung unter Unsicherheit — Monte-Carlo, Stochastik, Robustheit“ {#sec:loesungen-unsicherheit}
 
-**9.1 — Fluch des Durchschnitts.** Weil sich Verzögerungen **fortpflanzen** und die Verteilung rechtsschief ist: Ein Gewerk, das früher fertig wird, beschleunigt selten den Gesamtablauf (der nächste Schritt ist noch nicht bereit), ein verspätetes verzögert alles. Weitere Beispiele: Wartezeiten in Warteschlangen (nichtlinear in der Auslastung), Projektkosten mit Nachträgen.
+**12.1 — Fluch des Durchschnitts.** Weil sich Verzögerungen **fortpflanzen** und die Verteilung rechtsschief ist: Ein Gewerk, das früher fertig wird, beschleunigt selten den Gesamtablauf (der nächste Schritt ist noch nicht bereit), ein verspätetes verzögert alles. Weitere Beispiele: Wartezeiten in Warteschlangen (nichtlinear in der Auslastung), Projektkosten mit Nachträgen.
 
-**9.2 — Ansatz wählen.** (a) robust (Ausfall ist existenziell, Wahrscheinlichkeiten unzuverlässig). (b) stochastisch (Verteilung bekannt). (c) robust bzw. Extremwertstatistik (seltene Ereignisse, katastrophale Folgen). (d) stochastisch (Szenarien mit Wahrscheinlichkeiten liegen vor). (e) Chance Constraint — die Zusage ist bereits als Quote formuliert („an 99 % aller Wintertage“). Robust wäre hier zu teuer (es gibt immer einen kälteren Tag), der Erwartungswert zu schwach (er sagt nichts über die Zusage).
+**12.2 — Ansatz wählen.** (a) robust (Ausfall ist existenziell, Wahrscheinlichkeiten unzuverlässig). (b) stochastisch (Verteilung bekannt). (c) robust bzw. Extremwertstatistik (seltene Ereignisse, katastrophale Folgen). (d) stochastisch (Szenarien mit Wahrscheinlichkeiten liegen vor). (e) Chance Constraint — die Zusage ist bereits als Quote formuliert („an 99 % aller Wintertage“). Robust wäre hier zu teuer (es gibt immer einen kälteren Tag), der Erwartungswert zu schwach (er sagt nichts über die Zusage).
 
-**9.3 — Zweistufig rechnen.** (a) Mit Spot = 60: Ableitung bei $x \in (100,250)$: $40 - 60\cdot0{,}5 + 5\cdot0{,}5 = 40-30+2{,}5 = +12{,}5 > 0$ → Kapazität **senken**. Bei $x < 100$: $40 - 60 = -20 < 0$ → erhöhen. Optimum daher $x^* = 100$. (b) Billige Nachbesserung macht Vorhalten unattraktiv. (c) Bei $x = 225$ optimal müsste die Ableitung dort das Vorzeichen wechseln — das ist bei diskreten Szenarien nur zufällig der Fall; der Mittelwert ist nur bei symmetrischen Kosten und stetiger Verteilung optimal.
+**12.3 — Zweistufig rechnen.** (a) Mit Spot = 60: Ableitung bei $x \in (100,250)$: $40 - 60\cdot0{,}5 + 5\cdot0{,}5 = 40-30+2{,}5 = +12{,}5 > 0$ → Kapazität **senken**. Bei $x < 100$: $40 - 60 = -20 < 0$ → erhöhen. Optimum daher $x^* = 100$. (b) Billige Nachbesserung macht Vorhalten unattraktiv. (c) Bei $x = 225$ optimal müsste die Ableitung dort das Vorzeichen wechseln — das ist bei diskreten Szenarien nur zufällig der Fall; der Mittelwert ist nur bei symmetrischen Kosten und stetiger Verteilung optimal.
 
-**9.4 — EVPI interpretieren.** Selbst eine **perfekte** Prognose wäre nur 8 400 € pro Jahr wert. Eine Lösung für 15 000 € kann sich also **niemals** rechnen — unabhängig von ihrer Güte. Argument: „Der theoretische Maximalnutzen liegt unter dem Preis.“
+**12.4 — EVPI interpretieren.** Selbst eine **perfekte** Prognose wäre nur 8 400 € pro Jahr wert. Eine Lösung für 15 000 € kann sich also **niemals** rechnen — unabhängig von ihrer Güte. Argument: „Der theoretische Maximalnutzen liegt unter dem Preis.“
 
-**9.5 — Monte-Carlo erweitern.** (a) Servicelevel 95 %: Kapazität = 95 %-Quantil des Bedarfs (ca. 485). Die Zusatzkosten gegenüber dem Kostenoptimum (180) betragen ein Vielfaches — Servicelevel ist teuer, und genau diese Zahl braucht die Geschäftsleitung für die Entscheidung. (b) `cvar = kosten[kosten >= np.quantile(kosten, 0.95)].mean()`. (c) Erwartetes Bild: Bei kleiner Kapazität ist die Kostenverteilung stark rechtsschief (seltene, teure Notzukäufe); bei großer Kapazität schmal und nach rechts verschoben.
+**12.5 — Monte-Carlo erweitern.** (a) Servicelevel 95 %: Kapazität = 95 %-Quantil des Bedarfs (ca. 485). Die Zusatzkosten gegenüber dem Kostenoptimum (180) betragen ein Vielfaches — Servicelevel ist teuer, und genau diese Zahl braucht die Geschäftsleitung für die Entscheidung. (b) `cvar = kosten[kosten >= np.quantile(kosten, 0.95)].mean()`. (c) Erwartetes Bild: Bei kleiner Kapazität ist die Kostenverteilung stark rechtsschief (seltene, teure Notzukäufe); bei großer Kapazität schmal und nach rechts verschoben.
 
-**9.6 — Den Preis der Zusage selbst bestimmen.** (a) Die Kosten je Prozentpunkt steigen weiter steil an; der Mix verschiebt sich dabei fast nur noch zugunsten des Gaskraftwerks, weil Biomasse längst an ihrer Ausbaugrenze liegt. Wind und Sonne bleiben bei einem kleinen Rest — sie senken über ihre Gegenläufigkeit die Norm, tragen zur gesicherten Leistung aber kaum bei. (b) Der Unterschied ist **nicht** numerisch, sondern inhaltlich. Bei 200 MW Biomasse liefert selbst der **Vollausbau** in der Kältewelle nur rund 440 MW — 7,5 % der Szenarien sind schlicht nicht bedienbar, egal wie viel Geld man ausgibt. Das Szenariomodell sieht diese Fälle in den Daten und meldet korrekt `infeasible`, sobald die Zusage über 92 % steigt. Das analytische Modell kennt sie nicht: Für eine Normalverteilung ist jede Zusage unter 100 % erfüllbar, wenn man nur genug Streuung wegkauft. Es meldet `optimal` — und der Plan hält gemessen 87,4 %. Glauben sollte man dem Szenariomodell: Ein `infeasible` ist hier die **richtige** Antwort. Es sagt, dass die Zusage nicht am Budget scheitert, sondern am Kraftwerkspark, und dass nicht mehr Geld hilft, sondern nur eine andere Anlage oder eine kleinere Zusage. (c) Sinngemäß: „99,99 % kosten nicht 5 % mehr als 99 %, sondern ein Vielfaches — der letzte Prozentpunkt ist bereits 4,5-mal so teuer wie der erste. Sagen Sie mir, was ein Ausfalltag das Unternehmen kostet, dann rechne ich aus, welche Quote sich lohnt. Und die Zusage gilt nur für die Wetterlagen, die wir modelliert haben — die Kältewelle gehört hinein.“
+**12.6 — Den Preis der Zusage selbst bestimmen.** (a) Die Kosten je Prozentpunkt steigen weiter steil an; der Mix verschiebt sich dabei fast nur noch zugunsten des Gaskraftwerks, weil Biomasse längst an ihrer Ausbaugrenze liegt. Wind und Sonne bleiben bei einem kleinen Rest — sie senken über ihre Gegenläufigkeit die Norm, tragen zur gesicherten Leistung aber kaum bei. (b) Der Unterschied ist **nicht** numerisch, sondern inhaltlich. Bei 200 MW Biomasse liefert selbst der **Vollausbau** in der Kältewelle nur rund 440 MW — 7,5 % der Szenarien sind schlicht nicht bedienbar, egal wie viel Geld man ausgibt. Das Szenariomodell sieht diese Fälle in den Daten und meldet korrekt `infeasible`, sobald die Zusage über 92 % steigt. Das analytische Modell kennt sie nicht: Für eine Normalverteilung ist jede Zusage unter 100 % erfüllbar, wenn man nur genug Streuung wegkauft. Es meldet `optimal` — und der Plan hält gemessen 87,4 %. Glauben sollte man dem Szenariomodell: Ein `infeasible` ist hier die **richtige** Antwort. Es sagt, dass die Zusage nicht am Budget scheitert, sondern am Kraftwerkspark, und dass nicht mehr Geld hilft, sondern nur eine andere Anlage oder eine kleinere Zusage. (c) Sinngemäß: „99,99 % kosten nicht 5 % mehr als 99 %, sondern ein Vielfaches — der letzte Prozentpunkt ist bereits 4,5-mal so teuer wie der erste. Sagen Sie mir, was ein Ausfalltag das Unternehmen kostet, dann rechne ich aus, welche Quote sich lohnt. Und die Zusage gilt nur für die Wetterlagen, die wir modelliert haben — die Kältewelle gehört hinein.“
 
-**9.7 — Budgeted Uncertainty.**
+**12.7 — Budgeted Uncertainty.**
 ```python
 abzug = cp.sum_largest(cp.multiply(UNSICHERHEIT, w), Gamma)
 ziel = cp.Maximize(MU_SCHAETZUNG @ w - abzug - 0.5*LAMBDA*cp.quad_form(w, SIGMA))
 ```
 $\Gamma = 0$ entspricht dem nominalen Fall, $\Gamma = n$ dem vollen Worst Case. Dazwischen steuert $\Gamma$ die Vorsicht stufenlos — der praktisch nützlichste Bereich liegt meist bei $\Gamma \approx \sqrt{n}$.
 
-### Finde den Denkfehler 9.1 — Warum jedes Projekt zu spät fertig wird
+### Finde den Denkfehler — Warum jedes Projekt zu spät fertig wird
 
 (a) **Warum 14,38 statt 11,34 Tage.** Der Projektleiter hat den Mittelwert der **Einzeldauer** berechnet und ihn für den Mittelwert der **Projektdauer** gehalten. Das sind zwei verschiedene Größen:
 
@@ -25003,7 +26162,7 @@ Und die Formulierung gegenüber dem Auftraggeber lautet nicht „der Umbau dauer
 
 **2 — (b).** Der Unterschied liegt darin, **was man wissen muss**: Stochastische Optimierung setzt eine Wahrscheinlichkeitsverteilung voraus und minimiert den Erwartungswert; robuste Optimierung kommt mit einer bloßen Bandbreite aus und sichert den ungünstigsten Fall darin ab. Keines ist „genauer“ (a) — sie beantworten verschiedene Fragen. (c) trifft es nicht: Robuste Optimierung betrachtet nicht mehr Szenarien, sondern eine ganze Menge auf einmal, und interessiert sich darin nur für den schlechtesten Punkt.
 
-**3 — (c).** Bei durchgehender Linearität und ohne nachgelagerte Entscheidung gilt $\mathbb{E}[f(X)] = f(\mathbb{E}[X])$ — dann ist Rechnen mit Mittelwerten korrekt. Sobald aber ein Maximum, ein Minimum, ein Betrag oder eine Nachbesserungsentscheidung auftaucht, gilt das nicht mehr: Genau das sind die beiden Fälle aus Schnellstart (asymmetrische Kosten über `maximum`) und Denkfehler 9.1 (Maximum über parallele Vorgänge). (a) ist die Fehlannahme, um die es im ganzen Kapitel geht; (b) ist zu absolut — es gibt den linearen Fall, in dem es tatsächlich zulässig ist.
+**3 — (c).** Bei durchgehender Linearität und ohne nachgelagerte Entscheidung gilt $\mathbb{E}[f(X)] = f(\mathbb{E}[X])$ — dann ist Rechnen mit Mittelwerten korrekt. Sobald aber ein Maximum, ein Minimum, ein Betrag oder eine Nachbesserungsentscheidung auftaucht, gilt das nicht mehr: Genau das sind die beiden Fälle aus Schnellstart (asymmetrische Kosten über `maximum`) und [Abschnitt 12.9](#sec:unsicherheit-denkfehler) (Maximum über parallele Vorgänge). (a) ist die Fehlannahme, um die es im ganzen Kapitel geht; (b) ist zu absolut — es gibt den linearen Fall, in dem es tatsächlich zulässig ist.
 
 ### Selbsttest {#selbsttest-loesung-unsicherheit}
 1. Wegen der Jensenschen Ungleichung: Bei konvexen Kosten ist $\mathbb{E}[f(X)] \ge f(\mathbb{E}[X])$ — Planung mit dem Mittelwert unterschätzt die Kosten systematisch.
@@ -25018,13 +26177,13 @@ Und die Formulierung gegenüber dem Auftraggeber lautet nicht „der Umbau dauer
 
 ## A.13 Lösungen zu Kapitel „Dynamische Programmierung — Die Bellman-Gleichung und Order-Execution“ {#sec:loesungen-dynamische-programmierung}
 
-**10.1 — Bausteine.** Stufe = Tag 1–5; Zustand = verbleibende Distanz (ggf. plus Erschöpfungsgrad); Aktion = heutige Tagesetappe; Wertfunktion = minimale Restanstrengung. **Nicht** in den Zustand gehören: bereits gelaufene Kilometer (redundant, wenn die Restdistanz bekannt ist) und das Wetter von gestern (ohne Einfluss auf die Zukunft).
+**13.1 — Bausteine.** Stufe = Tag 1–5; Zustand = verbleibende Distanz (ggf. plus Erschöpfungsgrad); Aktion = heutige Tagesetappe; Wertfunktion = minimale Restanstrengung. **Nicht** in den Zustand gehören: bereits gelaufene Kilometer (redundant, wenn die Restdistanz bekannt ist) und das Wetter von gestern (ohne Einfluss auf die Zukunft).
 
-**10.2 — Optimalitätsprinzip.** Weil der Wert eines Zustands nur von den *künftigen* Entscheidungen abhängt, kann man ihn ab dem Ende rekursiv berechnen. Hängen die Kosten zusätzlich von **früheren** Aktionen ab, ist die Markov-Eigenschaft verletzt — die Lösung: die relevante Vergangenheit **in den Zustand aufnehmen** (dann wächst allerdings der Zustandsraum).
+**13.2 — Optimalitätsprinzip.** Weil der Wert eines Zustands nur von den *künftigen* Entscheidungen abhängt, kann man ihn ab dem Ende rekursiv berechnen. Hängen die Kosten zusätzlich von **früheren** Aktionen ab, ist die Markov-Eigenschaft verletzt — die Lösung: die relevante Vergangenheit **in den Zustand aufnehmen** (dann wächst allerdings der Zustandsraum).
 
-**10.3 — Rückwärtsinduktion.** Mit $C(n) = n^2 + 2n$ und 5 Einheiten in 3 Perioden ergibt sich als optimaler Pfad $2 \to 2 \to 1$ (oder eine Permutation davon) mit Gesamtkosten $8 + 8 + 3 = 19$. Alles auf einmal kostet $25 + 10 = 35$.
+**13.3 — Rückwärtsinduktion.** Mit $C(n) = n^2 + 2n$ und 5 Einheiten in 3 Perioden ergibt sich als optimaler Pfad $2 \to 2 \to 1$ (oder eine Permutation davon) mit Gesamtkosten $8 + 8 + 3 = 19$. Alles auf einmal kostet $25 + 10 = 35$.
 
-**10.4 — Rucksack als DP.**
+**13.4 — Rucksack als DP.**
 ```python
 V = np.zeros((n + 1, kapazitaet + 1))
 for i in range(1, n + 1):
@@ -25035,11 +26194,11 @@ for i in range(1, n + 1):
 ```
 Ergebnis identisch zum MILP (110). Laufzeit $O(n \cdot C)$ — bei kleinen ganzzahligen Kapazitäten schneller als Branch-and-Bound, bei großen oder nicht-ganzzahligen Kapazitäten schlechter (dann ist das MILP überlegen). Man nennt das **pseudopolynomiell**.
 
-**10.5 — Risikoaversion kalibrieren.** (a) Zwischen $\lambda = 10^{-5}$ (41 %) und $10^{-4}$ (78 %); genauer etwa bei $\lambda \approx 3\cdot10^{-5}$. (b) Höheres $\lambda$ → höhere Gesamtkosten (man kauft Sicherheit mit Slippage). (c) Iterativ: $\lambda$ so wählen, dass der Anteil der Marktauswirkungskosten an den Gesamtkosten bei 20 % liegt — im Programm ausrechnen und per Bisektion einstellen.
+**13.5 — Risikoaversion kalibrieren.** (a) Zwischen $\lambda = 10^{-5}$ (41 %) und $10^{-4}$ (78 %); genauer etwa bei $\lambda \approx 3\cdot10^{-5}$. (b) Höheres $\lambda$ → höhere Gesamtkosten (man kauft Sicherheit mit Slippage). (c) Iterativ: $\lambda$ so wählen, dass der Anteil der Marktauswirkungskosten an den Gesamtkosten bei 20 % liegt — im Programm ausrechnen und per Bisektion einstellen.
 
-**10.6 — Zustandsraum erweitern.** Der Zustand wird zu (Restbestand, Orderbuchtiefe); der Zustandsraum verdreifacht sich, die Rechenzeit ebenfalls. Die Strategie wird **zustandsabhängig**: Bei tiefem Buch wird mehr verkauft, bei dünnem gewartet. Genau diese Adaptivität ist der Mehrwert von DP gegenüber einem festen Pfad.
+**13.6 — Zustandsraum erweitern.** Der Zustand wird zu (Restbestand, Orderbuchtiefe); der Zustandsraum verdreifacht sich, die Rechenzeit ebenfalls. Die Strategie wird **zustandsabhängig**: Bei tiefem Buch wird mehr verkauft, bei dünnem gewartet. Genau diese Adaptivität ist der Mehrwert von DP gegenüber einem festen Pfad.
 
-### Finde den Denkfehler 10.1 — Der Zustand, der zu wenig weiß
+### Finde den Denkfehler — Der Zustand, der zu wenig weiß
 
 (a) **Die fehlende Information.** Die Zeile
 
@@ -25087,7 +26246,7 @@ Eine Prüfung, die nur den ausgegebenen Plan nachrechnet, bestätigt also alles.
 
 **2 — (b).** Das Optimalitätsprinzip sagt, dass jedes **Reststück** einer optimalen Lösung selbst optimal ist. Deshalb genügt es, je Zustand einen einzigen Wert zu speichern, statt alle Wege dorthin zu unterscheiden. (a) ist die verbreitetste Fehldeutung — sie beschriebe gieriges Vorgehen, und genau das scheitert im Schnellstart dieses Kapitels (21 statt 14 Minuten). (c) ist eine Allgemeinplatz-Aussage ohne Bezug zum Prinzip.
 
-**3 — (b).** Der Rabatt hängt von der bisher kumulierten Menge ab; ohne diese Größe im Zustand kann das Modell die Kosten der nächsten Bestellung nicht bestimmen — dasselbe Muster wie in Denkfehler 10.1. (a) übersieht genau das: Kosten, die von der Vorgeschichte abhängen, **sind** Zustandsinformation. (c) ist zu absolut — DP bleibt anwendbar, der Zustandsraum wird nur größer; ob sich stattdessen ein MILP lohnt, ist eine Frage der Größe, nicht der Eignung.
+**3 — (b).** Der Rabatt hängt von der bisher kumulierten Menge ab; ohne diese Größe im Zustand kann das Modell die Kosten der nächsten Bestellung nicht bestimmen — dasselbe Muster wie in [Abschnitt 13.7](#sec:dynamische-programmierung-denkfehler). (a) übersieht genau das: Kosten, die von der Vorgeschichte abhängen, **sind** Zustandsinformation. (c) ist zu absolut — DP bleibt anwendbar, der Zustandsraum wird nur größer; ob sich stattdessen ein MILP lohnt, ist eine Frage der Größe, nicht der Eignung.
 
 ### Selbsttest {#selbsttest-loesung-dynamische-programmierung}
 1. Jeder Teilabschnitt einer optimalen Strategie ist selbst optimal für den Zustand, in dem er beginnt.
@@ -25100,25 +26259,25 @@ Eine Prüfung, die nur den ausgegebenen Plan nachrechnet, bestätigt also alles.
 
 ## A.14 Lösungen zu Kapitel „Mehrere Ziele — Pareto-Fronten statt Gewichte“ {#sec:loesungen-mehrziel}
 
-**Dominanz prüfen.** P (14 000 €, 6 000 kg) und Q (13 800 €, 6 100 kg): **keiner dominiert den anderen.** Q ist billiger, P ist sauberer — beide sind pareto-optimal, die Wahl ist eine Präferenzfrage.
+**14.1 — Dominanz prüfen.** P (14 000 €, 6 000 kg) und Q (13 800 €, 6 100 kg): **keiner dominiert den anderen.** Q ist billiger, P ist sauberer — beide sind pareto-optimal, die Wahl ist eine Präferenzfrage.
 
 R (14 000 €, 6 100 kg) dagegen wird **von beiden dominiert**: gleich teuer wie P, aber schmutziger; schmutziger als Q *und* teurer. R kann man wegwerfen, ohne jemanden zu fragen — und genau das ist der Zweck des Dominanzbegriffs: Er trennt die Fälle, in denen der Modellierer entscheiden darf, von denen, in denen er es nicht darf.
 
-**Der Schattenpreis in der Praxis.** Man geht die Front von unten durch, solange der Schattenpreis unter 0,90 €/kg liegt. Aus der Ausgabe: 0,58 — 0,93 — 0,40 — 0,59 — 0,77 — 0,65 — 0,77 — 1,09 — 1,32. Die Werte steigen nicht monoton, weil die Front bei ganzzahligen Modellen keine glatte Kurve ist; maßgeblich ist deshalb nicht der einzelne Schritt, sondern der **Gesamtschattenpreis** gegenüber dem Kostenminimum.
+**14.2 — Der Schattenpreis in der Praxis.** Man geht die Front von unten durch, solange der Schattenpreis unter 0,90 €/kg liegt. Aus der Ausgabe: 0,58 — 0,93 — 0,40 — 0,59 — 0,77 — 0,65 — 0,77 — 1,09 — 1,32. Die Werte steigen nicht monoton, weil die Front bei ganzzahligen Modellen keine glatte Kurve ist; maßgeblich ist deshalb nicht der einzelne Schritt, sondern der **Gesamtschattenpreis** gegenüber dem Kostenminimum.
 
 Der letzte Punkt, dessen Gesamtschattenpreis unter 0,90 € liegt, ist **14 189 € / 5 632 kg**: 646 € Aufpreis für 843 kg Ersparnis, also 0,77 €/kg. Der nächste Punkt kostet 1,09 €/kg und liegt damit über dem internen Preis.
 
 Begründung in einem Satz: *„Für 646 Euro sparen wir 843 Kilogramm CO₂ — zu 77 Cent je Kilogramm, während wir intern mit 90 Cent rechnen.“*
 
-**Mehr Trassen.** Mit 8 statt 5 Trassen wird der Engpass schwächer. Zu erwarten ist eine **kürzere** Front: Der Zielkonflikt entsteht ja allein aus der Knappheit; je mehr Trassen, desto näher rücken Kostenminimum und CO₂-Minimum zusammen. Im Grenzfall genügend vieler Trassen fallen beide zusammen — die Bahn ist billiger *und* sauberer, also gibt es gar keinen Konflikt mehr und die Front schrumpft auf einen Punkt.
+**14.3 — Mehr Trassen.** Mit 8 statt 5 Trassen wird der Engpass schwächer. Zu erwarten ist eine **kürzere** Front: Der Zielkonflikt entsteht ja allein aus der Knappheit; je mehr Trassen, desto näher rücken Kostenminimum und CO₂-Minimum zusammen. Im Grenzfall genügend vieler Trassen fallen beide zusammen — die Bahn ist billiger *und* sauberer, also gibt es gar keinen Konflikt mehr und die Front schrumpft auf einen Punkt.
 
 Der Lehrpunkt: **Ein Zielkonflikt ist keine Eigenschaft der Ziele, sondern der Knappheit.** Wer ihn auflösen will, sollte zuerst prüfen, ob sich die Ressource vermehren lässt, statt über Gewichte zu verhandeln.
 
-**Die Front der Relaxation.** Ohne `integrality` ist der zulässige Bereich konvex, und die Pareto-Front liegt vollständig auf ihrer eigenen unteren konvexen Hülle. Es gibt also **keinen** Punkt oberhalb — jeder Punkt der Front ist durch ein passendes Gewicht erreichbar.
+**14.4 — Die Front der Relaxation.** Ohne `integrality` ist der zulässige Bereich konvex, und die Pareto-Front liegt vollständig auf ihrer eigenen unteren konvexen Hülle. Es gibt also **keinen** Punkt oberhalb — jeder Punkt der Front ist durch ein passendes Gewicht erreichbar.
 
 Genau das ist der Grund, warum das Problem in Lehrbüchern zur linearen Programmierung nicht vorkommt und in der betrieblichen Praxis ständig: Sobald „welcher Träger“, „welches Lager“ oder „welche Schicht“ entschieden wird, zerfällt der Bereich in einzelne Punkte, und zwischen ihnen entstehen die Einbuchtungen, in denen die nicht gestützten Lösungen liegen.
 
-**Drei Ziele.** Die Front wird zu einer Fläche im dreidimensionalen Zielraum. Das ε-Verfahren braucht dann ein **Gitter** über zwei Schranken statt einer Folge über eine — der Aufwand wächst von $O(k)$ auf $O(k^2)$, bei $m$ Zielen auf $O(k^{m-1})$.
+**14.5 — Drei Ziele.** Die Front wird zu einer Fläche im dreidimensionalen Zielraum. Das ε-Verfahren braucht dann ein **Gitter** über zwei Schranken statt einer Folge über eine — der Aufwand wächst von $O(k)$ auf $O(k^2)$, bei $m$ Zielen auf $O(k^{m-1})$.
 
 Zwei praktische Folgerungen: Erstens ist bei drei und mehr Zielen die vollständige Front meist nicht mehr bezahlbar; man arbeitet dann mit einer Stichprobe oder mit Metaheuristiken, die eine Front approximieren (NSGA-II, in `pymoo` enthalten). Zweitens ist eine Front mit hunderten Punkten für die Entscheidung ohnehin unbrauchbar — ab drei Zielen ist die bessere Frage meist, ob sich zwei davon zusammenfassen lassen.
 
@@ -25158,23 +26317,23 @@ Deshalb genügt es nicht, sorgfältig zu sein — man braucht ein Verfahren mit
 
 ## A.15 Lösungen zu Kapitel „Predict-then-Optimize“ {#sec:loesungen-prognose}
 
-**Andere Preise.** Der Überhang kostet nur noch 1,50 €, die Fehlmenge weiterhin 6 €. Das kritische Verhältnis steigt von $6/9 = 0{,}667$ auf $6/7{,}5 = 0{,}80$. Die Bestellmenge verschiebt sich also **nach oben** — man bestellt jetzt das 80-%-Quantil statt des 66,7-%-Quantils.
+**15.1 — Andere Preise.** Der Überhang kostet nur noch 1,50 €, die Fehlmenge weiterhin 6 €. Das kritische Verhältnis steigt von $6/9 = 0{,}667$ auf $6/7{,}5 = 0{,}80$. Die Bestellmenge verschiebt sich also **nach oben** — man bestellt jetzt das 80-%-Quantil statt des 66,7-%-Quantils.
 
 Das ist die richtige Richtung und leicht zu merken: Je billiger der Überhang, desto großzügiger darf man ansetzen. Im Grenzfall kostenloser Entsorgung ($c_+ \to 0$) geht das kritische Verhältnis gegen 1 — man bestellt so viel, dass praktisch nie etwas fehlt.
 
-**Wann ist der Mittelwert richtig?** Nur wenn $c_- = c_+$ **und** die Nachfrageverteilung symmetrisch ist. Dann liegt das kritische Verhältnis bei 0,5, das 50-%-Quantil ist der Median, und bei Symmetrie fällt der Median mit dem Mittelwert zusammen.
+**15.2 — Wann ist der Mittelwert richtig?** Nur wenn $c_- = c_+$ **und** die Nachfrageverteilung symmetrisch ist. Dann liegt das kritische Verhältnis bei 0,5, das 50-%-Quantil ist der Median, und bei Symmetrie fällt der Median mit dem Mittelwert zusammen.
 
 Beide Bedingungen sind unrealistisch. Fehlmenge und Überhang kosten fast nie dasselbe — bei Frischware ist der Überhang teurer, bei Ersatzteilen die Fehlmenge um Größenordnungen. Und Nachfrageverteilungen sind meist rechtsschief. Der Mittelwert ist damit die Ausnahme, nicht die Regel — er wird nur benutzt, weil Regressionsmodelle ihn standardmäßig liefern.
 
-**Die Kennzahl der Prognoseabteilung.** Die Rangfolge bleibt: Die Punktprognose gewinnt auch beim MAPE, weil beide Maße den *Erwartungswert* belohnen — der MAPE etwas anders gewichtet, aber ebenfalls symmetrisch in dem Sinne, dass er nicht weiß, dass Unterschätzung teurer ist als Überschätzung.
+**15.3 — Die Kennzahl der Prognoseabteilung.** Die Rangfolge bleibt: Die Punktprognose gewinnt auch beim MAPE, weil beide Maße den *Erwartungswert* belohnen — der MAPE etwas anders gewichtet, aber ebenfalls symmetrisch in dem Sinne, dass er nicht weiß, dass Unterschätzung teurer ist als Überschätzung.
 
 Das ist kein Zufall, sondern der Kern des Kapitels: **Jedes rein statistische Fehlermaß ignoriert die Kostenasymmetrie.** Man kann das Problem nicht lösen, indem man das Fehlermaß wechselt; man muss die Kosten selbst messen. (Die einzige Ausnahme ist der *Pinball Loss* — genau das Maß, das die Quantilregression minimiert, und das ist eben kein allgemeines Prognosemaß, sondern eines für ein bestimmtes Quantil.)
 
-**Zwei Quantile.** Das Band ist an **Aktionstagen** deutlich breiter — dort ist die Streuung im Modell fast viermal so groß. Genau das ist die Information, die eine Punktprognose plus fester Zuschlag wegwirft.
+**15.4 — Zwei Quantile.** Das Band ist an **Aktionstagen** deutlich breiter — dort ist die Streuung im Modell fast viermal so groß. Genau das ist die Information, die eine Punktprognose plus fester Zuschlag wegwirft.
 
 Ein praktischer Nebeneffekt: Ein solches Band ist die verständlichste Form, Unsicherheit an die Disposition zu berichten. „Zwischen 130 und 210" sagt einem Menschen mehr als „170 ± Sicherheitszuschlag".
 
-**Der Wert der Merkmale.** Zu erwarten ist, dass die **Kosten stärker steigen als der MSE**. Der Grund: Das Merkmal „Aktion" trägt zwei verschiedene Informationen — es verschiebt den Erwartungswert (um 45 Stück) *und* die Streuung (von 8 auf 30). Der MSE bemerkt nur den ersten Teil; die Entscheidungskosten spüren beide.
+**15.5 — Der Wert der Merkmale.** Zu erwarten ist, dass die **Kosten stärker steigen als der MSE**. Der Grund: Das Merkmal „Aktion" trägt zwei verschiedene Informationen — es verschiebt den Erwartungswert (um 45 Stück) *und* die Streuung (von 8 auf 30). Der MSE bemerkt nur den ersten Teil; die Entscheidungskosten spüren beide.
 
 Der Lehrsatz dahinter: **Der Wert eines Merkmals hängt davon ab, wofür man es benutzt.** Eine Merkmalsauswahl, die nach MSE-Beitrag sortiert, wirft möglicherweise genau die Merkmale weg, die für die Entscheidung am wichtigsten sind — nämlich die, die etwas über die Unsicherheit sagen.
 
@@ -25215,27 +26374,27 @@ Es ist also nicht die bessere Prognose, die schadet, sondern die **nicht mitgezo
 
 ## A.16 Lösungen zu Kapitel „Die Strukturbrücke — dieselbe Mathematik, zwei Welten“ {#sec:loesungen-bruecke}
 
-**Die dritte Ressource.** „Liquidität" — wie schnell sich eine Position ohne Kursabschlag verkaufen lässt — entspricht in der Werkstatt der **Umrüstbarkeit** oder der **Vorlaufzeit**: Wie schnell lässt sich die Fertigung von diesem Produkt wieder wegdrehen, wenn der Auftrag storniert wird? In beiden Fällen ist es eine knappe Größe, die nichts mit dem Ertrag zu tun hat und trotzdem die Auswahl einschränkt.
+**16.1 — Die dritte Ressource.** „Liquidität" — wie schnell sich eine Position ohne Kursabschlag verkaufen lässt — entspricht in der Werkstatt der **Umrüstbarkeit** oder der **Vorlaufzeit**: Wie schnell lässt sich die Fertigung von diesem Produkt wieder wegdrehen, wenn der Auftrag storniert wird? In beiden Fällen ist es eine knappe Größe, die nichts mit dem Ertrag zu tun hat und trotzdem die Auswahl einschränkt.
 
 Im Modell ist es schlicht eine weitere Zeile in `kapazitaeten` und ein weiterer Eintrag in jedem `verbrauch`. Genau das ist der Punkt des Kapitels: Eine neue Ressource kostet keinen Modellcode.
 
-**Den Schattenpreis lesen.** Bis zu **602,60 €** für 10 Einheiten (10 × 60,26 €) lohnt sich der Kauf — darüber nicht.
+**16.2 — Den Schattenpreis lesen.** Bis zu **602,60 €** für 10 Einheiten (10 × 60,26 €) lohnt sich der Kauf — darüber nicht.
 
 Die Einschränkung aus [Abschnitt 5.9](#sec:lp-entartung): Der Schattenpreis gilt nur **lokal**, solange sich die optimale Basis nicht ändert. Nach einer gewissen Erhöhung wird eine andere Nebenbedingung bindend (hier voraussichtlich das Kapital), und ab dort ist die zusätzliche Einheit weniger wert. Bei 10 Einheiten auf 90 ist das eine Erhöhung um 11 % — schon groß genug, dass man es nachrechnen sollte, statt zu extrapolieren.
 
 Zweite Einschränkung: Bei **Entartung** ist der Schattenpreis nicht eindeutig. Verschiedene Solver können dann verschiedene, gleichermaßen gültige Werte liefern — auch das steht in [Abschnitt 5.9](#sec:lp-entartung).
 
-**Die Brücke rückwärts.** Shrinkage hilft, wenn man eine **Kovarianzmatrix** aus wenigen Beobachtungen schätzt. Bei Lieferzeiten tritt genau dasselbe Problem auf, sobald man die *Korrelationen zwischen* Lieferanten braucht — und die braucht man, sobald Lieferanten gemeinsame Ursachen haben: derselbe Hafen, dasselbe Vorprodukt, dieselbe Region.
+**16.3 — Die Brücke rückwärts.** Shrinkage hilft, wenn man eine **Kovarianzmatrix** aus wenigen Beobachtungen schätzt. Bei Lieferzeiten tritt genau dasselbe Problem auf, sobald man die *Korrelationen zwischen* Lieferanten braucht — und die braucht man, sobald Lieferanten gemeinsame Ursachen haben: derselbe Hafen, dasselbe Vorprodukt, dieselbe Region.
 
 Bei 40 Lieferanten hat die Kovarianzmatrix 820 zu schätzende Einträge. Wer dafür 36 Monatswerte hat, schätzt 820 Zahlen aus 36 Beobachtungen — dasselbe Missverhältnis wie bei Aktienrenditen, mit denselben Folgen (`Kovarianz_Falle.py`).
 
 Benötigt würden: Lieferzeit-Zeitreihen je Lieferant über denselben Zeitraum, gleich getaktet. Genau daran scheitert es in der Praxis meist — die Daten liegen in Bestellvorgängen, nicht in einer Matrix.
 
-**CVaR mit Ganzzahligkeit.** Man ergänzt Binärvariablen $y_j$ je Lieferant und die Kopplung $w_j \le y_j$ sowie $\sum_j y_j \le 3$. Da CVXPY gemischt-ganzzahlige Probleme unterstützt, genügt `cp.Variable(n, boolean=True)`.
+**16.4 — CVaR mit Ganzzahligkeit.** Man ergänzt Binärvariablen $y_j$ je Lieferant und die Kopplung $w_j \le y_j$ sowie $\sum_j y_j \le 3$. Da CVXPY gemischt-ganzzahlige Probleme unterstützt, genügt `cp.Variable(n, boolean=True)`.
 
 Zu erwarten ist ein **höherer** CVaR: Der zulässige Bereich wird kleiner, und die Feinabstimmung über sechs Lieferanten fällt weg. Der Aufschlag ist der Preis der Vertragswirklichkeit — und genau die Zahl, die man dem Einkauf vorlegt, wenn dort jemand sagt, drei Lieferanten seien genug.
 
-**Die eigene Brücke.** Freie Antwort. Eine gute Bearbeitung nennt das Modell, die Entsprechung und **die Zeile der Grenztabelle, die im Weg steht** — meist ist es die dritte (Teilbarkeit) oder die erste (gemessen gegen geschätzt). Wenn keine im Weg steht, ist die Übertragung wahrscheinlich zu oberflächlich geprüft.
+**16.5 — Die eigene Brücke.** Freie Antwort. Eine gute Bearbeitung nennt das Modell, die Entsprechung und **die Zeile der Grenztabelle, die im Weg steht** — meist ist es die dritte (Teilbarkeit) oder die erste (gemessen gegen geschätzt). Wenn keine im Weg steht, ist die Übertragung wahrscheinlich zu oberflächlich geprüft.
 
 ### Finde den Denkfehler — „Das ist doch dasselbe Problem“ {#denkfehler-loesung-bruecke}
 
@@ -25271,11 +26430,11 @@ Markowitz liefert stetige Anteile: 7,3 % bei Lieferant A, 4,1 % bei B. Ein Liefe
 
 ## A.17 Lösungen zu Kapitel „Supply-Chain und Energieeinsatz unter Unsicherheit“ {#sec:loesungen-supplychain}
 
-**Der Umschlagpunkt.** Bei 60 MW statt 120 MW halbiert sich die Grenzkostendifferenz je Stunde (83 €/MWh × 60 MW = 4 980 €/h). Der Umschlagpunkt verdoppelt sich auf **7,7 Stunden**.
+**17.1 — Der Umschlagpunkt.** Bei 60 MW statt 120 MW halbiert sich die Grenzkostendifferenz je Stunde (83 €/MWh × 60 MW = 4 980 €/h). Der Umschlagpunkt verdoppelt sich auf **7,7 Stunden**.
 
 Das ist plausibel: Je kleiner die abzudeckende Leistung, desto länger dauert es, bis der Grenzkostenvorteil des großen Blocks seine Anfahrkosten einspielt. Ein Kernblock lohnt sich für eine kleine Restlast noch weniger als für eine große — was erklärt, warum Grundlastblöcke gerade dann unwirtschaftlich werden, wenn viel Wind einspeist und nur eine kleine Restlast bleibt.
 
-**Die fehlende Nebenbedingung.** Analog zum Anfahren braucht man eine Abfahr-Indikatorvariable $b_{k,t} \ge u_{k,t-1} - u_{k,t}$ und dann:
+**17.2 — Die fehlende Nebenbedingung.** Analog zum Anfahren braucht man eine Abfahr-Indikatorvariable $b_{k,t} \ge u_{k,t-1} - u_{k,t}$ und dann:
 
 $$
 u_{k,\tau} \le 1 - b_{k,t} \qquad \text{für } \tau = t, \dots, t + M_k - 1
@@ -25285,17 +26444,17 @@ In Worten: Wer abfährt, bleibt $M_k$ Stunden aus.
 
 Der reale Sachverhalt: Ein abgeschalteter Dampfblock kühlt aus und darf aus werkstofftechnischen Gründen nicht sofort wieder hochgefahren werden — die Temperaturwechsel würden das Material schädigen. Bei Gasturbinen ist die Mindeststillstandszeit kurz oder null, bei Kernblöcken beträgt sie viele Stunden.
 
-**Wie viele Szenarien?** Zu erwarten ist, dass der Commitment-Plan ab einer gewissen Szenarienzahl stabil bleibt — oft schon bei 20 bis 40. Der Grund: Die erste Stufe ist binär und **grob**; sie kann nur ganze Blockstunden verschieben. Feine Unterschiede in der Szenarienmenge ändern daran nichts mehr.
+**17.3 — Wie viele Szenarien?** Zu erwarten ist, dass der Commitment-Plan ab einer gewissen Szenarienzahl stabil bleibt — oft schon bei 20 bis 40. Der Grund: Die erste Stufe ist binär und **grob**; sie kann nur ganze Blockstunden verschieben. Feine Unterschiede in der Szenarienmenge ändern daran nichts mehr.
 
 Der Zusammenhang mit [Abschnitt 15.6](#sec:prognose-messfalle) ist der interessante Teil: Dort ging es um die Zahl der **Beobachtungen** bei einer Bewertung, hier um die Zahl der **Szenarien** in einem Modell. Beide Male lautet die Frage nicht „wie viele sind genug?", sondern „ab wann ändert sich die Antwort nicht mehr?" — und beide Male beantwortet man sie, indem man es ausprobiert, statt eine Faustregel zu übernehmen.
 
-**Der Wert eines Speichers.** Der Speicher braucht Variablen für Ladung, Entladung und Füllstand je Szenario und Stunde, mit der Bilanz $F_{t} = F_{t-1} + \eta\, L_t - E_t/\eta$ und Grenzen für Leistung und Kapazität. Er gehört in die **zweite** Stufe: Wann geladen wird, darf sich am Tag selbst entscheiden.
+**17.4 — Der Wert eines Speichers.** Der Speicher braucht Variablen für Ladung, Entladung und Füllstand je Szenario und Stunde, mit der Bilanz $F_{t} = F_{t-1} + \eta\, L_t - E_t/\eta$ und Grenzen für Leistung und Kapazität. Er gehört in die **zweite** Stufe: Wann geladen wird, darf sich am Tag selbst entscheiden.
 
 Zu erwarten ist ein deutlicher Rückgang der erwarteten Kosten, und zwar aus zwei Quellen: Er verschiebt Energie aus billigen in teure Stunden *und* er ersetzt Vorhaltung — ein Speicher ist in Sekunden verfügbar, ein Kernblock in acht Stunden. Der zweite Effekt ist der größere und wird bei einer Betrachtung ohne Szenarien komplett übersehen.
 
 Der Wert je MWh Kapazität ergibt sich als Kostenersparnis geteilt durch 400 MWh. Er ist mit den Investitionskosten vergleichbar — dieselbe Rechnung wie der Schattenpreis in [Kapitel 5](#kap-lp), nur über einen ganzen Tag.
 
-**Wenn es größer wird.** Mit 20 Blöcken und 168 Stunden hat die erste Stufe 3 360 Binärvariablen statt 120, und die Szenarienkopplung vervielfacht die kontinuierlichen Variablen. Zu erwarten ist, dass der MIP-Gap nach dem Zeitlimit nicht mehr auf null geht.
+**17.5 — Wenn es größer wird.** Mit 20 Blöcken und 168 Stunden hat die erste Stufe 3 360 Binärvariablen statt 120, und die Szenarienkopplung vervielfacht die kontinuierlichen Variablen. Zu erwarten ist, dass der MIP-Gap nach dem Zeitlimit nicht mehr auf null geht.
 
 Zwei Wege aus [Kapitel 9](#kap-metaheuristiken): **Erstens** — und in der Praxis meist ausreichend — den Gap akzeptieren; 1 bis 2 % sind bei Unit Commitment üblich und betriebswirtschaftlich belanglos. **Zweitens** LNS: Das Commitment eines Tages herausbrechen und exakt neu optimieren, während der Rest der Woche festbleibt. Das ist genau die Struktur aus `Large_Neighborhood_Search.py` — ein zusammenhängendes Fenster zerstören und mit dem exakten Solver reparieren.
 
@@ -25339,19 +26498,19 @@ Die Reserve ist also nicht zu klein, sondern **von der falschen Art**. Was fehlt
 
 ## A.18 Lösungen zu Kapitel „Finanzdaten-Modellierung — Renditen, Kovarianz und Shrinkage“ {#sec:loesungen-finanzdaten}
 
-**11.1 — Renditeart.** (a) diskret. (b) logarithmisch. (c) logarithmisch (bzw. diskret kumuliert über Produkt). (d) logarithmisch (statistische Eigenschaften).
+**18.1 — Renditeart.** (a) diskret. (b) logarithmisch. (c) logarithmisch (bzw. diskret kumuliert über Produkt). (d) logarithmisch (statistische Eigenschaften).
 
-**11.2 — Mittelwertfalle.** (a) Arithmetisches Mittel: $(60-40+60-40)/4 = +10\,\%$. (b) $10\,000 \cdot 1{,}6 \cdot 0{,}6 \cdot 1{,}6 \cdot 0{,}6 = 10\,000 \cdot 0{,}9216 = \mathbf{9216\ €}$ — ein **Verlust**. (c) Geometrisches Mittel: $0{,}9216^{1/4} - 1 = -2{,}0\,\%$ p. a. Der Unterschied zwischen $+10\,\%$ und $-2\,\%$ ist der Grund, warum Fondswerbung gern arithmetische Mittel zeigt.
+**18.2 — Mittelwertfalle.** (a) Arithmetisches Mittel: $(60-40+60-40)/4 = +10\,\%$. (b) $10\,000 \cdot 1{,}6 \cdot 0{,}6 \cdot 1{,}6 \cdot 0{,}6 = 10\,000 \cdot 0{,}9216 = \mathbf{9216\ €}$ — ein **Verlust**. (c) Geometrisches Mittel: $0{,}9216^{1/4} - 1 = -2{,}0\,\%$ p. a. Der Unterschied zwischen $+10\,\%$ und $-2\,\%$ ist der Grund, warum Fondswerbung gern arithmetische Mittel zeigt.
 
-**11.3 — Konditionszahl.** Erwartetes Muster: Bei $T = 40 < N = 30$… (hier $T > N$, aber knapp): sehr große Konditionszahl, kleinster Eigenwert nahe null. Bei $T = 100$: deutlich besser. Bei $T = 1000$: stabil. Faustregel $T \ge 5N$ bis $10N$.
+**18.3 — Konditionszahl.** Erwartetes Muster: Bei $T = 40 < N = 30$… (hier $T > N$, aber knapp): sehr große Konditionszahl, kleinster Eigenwert nahe null. Bei $T = 100$: deutlich besser. Bei $T = 1000$: stabil. Faustregel $T \ge 5N$ bis $10N$.
 
-**11.4 — Spaltenreihenfolge.** `raw["Close"].columns` ist alphabetisch; `raw["Close"][tickers]` stellt die eigene Reihenfolge her. Existiert ein Ticker nicht, wirft `[tickers]` einen `KeyError` — **das ist erwünscht**: lieber ein lauter Fehler als eine stille Verschiebung.
+**18.4 — Spaltenreihenfolge.** `raw["Close"].columns` ist alphabetisch; `raw["Close"][tickers]` stellt die eigene Reihenfolge her. Existiert ein Ticker nicht, wirft `[tickers]` einen `KeyError` — **das ist erwünscht**: lieber ein lauter Fehler als eine stille Verschiebung.
 
-**11.5 — Beide Ziele vergleichen.** Erwartetes Ergebnis: Das Konstant-Korrelations-Ziel schneidet bei Aktien meist etwas besser ab, weil es die unterschiedlichen Einzelvolatilitäten erhält. Der Unterschied ist aber kleiner als der Unterschied zwischen „mit“ und „ohne“ Shrinkage — die Wahl des Ziels ist zweitrangig gegenüber der Entscheidung, überhaupt zu schrumpfen.
+**18.5 — Beide Ziele vergleichen.** Erwartetes Ergebnis: Das Konstant-Korrelations-Ziel schneidet bei Aktien meist etwas besser ab, weil es die unterschiedlichen Einzelvolatilitäten erhält. Der Unterschied ist aber kleiner als der Unterschied zwischen „mit“ und „ohne“ Shrinkage — die Wahl des Ziels ist zweitrangig gegenüber der Entscheidung, überhaupt zu schrumpfen.
 
-**11.6 — Error-Maximizer messen.** (a)/(b) Erwartetes Ergebnis: Die Gleichgewichtung schlägt die Stichproben-Optimierung bis etwa $T/N \approx 5$–10; Ledoit-Wolf schlägt sie schon früher. (c) **Praktische Folgerung:** Bei knapper Datenlage ist 1/N ein ernstzunehmender Kandidat, und jede Optimierung muss sich daran messen lassen.
+**18.6 — Error-Maximizer messen.** (a)/(b) Erwartetes Ergebnis: Die Gleichgewichtung schlägt die Stichproben-Optimierung bis etwa $T/N \approx 5$–10; Ledoit-Wolf schlägt sie schon früher. (c) **Praktische Folgerung:** Bei knapper Datenlage ist 1/N ein ernstzunehmender Kandidat, und jede Optimierung muss sich daran messen lassen.
 
-### Finde den Denkfehler 11.1 — Das risikofreie Portfolio
+### Finde den Denkfehler — Das risikofreie Portfolio
 
 (a) **Der Rang.** Eine aus $T$ Beobachtungen geschätzte Kovarianzmatrix hat höchstens den Rang $T-1$ — hier also **19** statt der nötigen 30. Geometrisch heißt das: Die 20 beobachteten Renditevektoren spannen nur einen 19-dimensionalen Unterraum des 30-dimensionalen Anlageraums auf. Es bleiben **11 Richtungen** übrig, über die die Daten schlicht **nichts** aussagen.
 
@@ -25400,7 +26559,7 @@ Und immer: **außerhalb des Schätzzeitraums prüfen.** Ein Modell, das nur im e
 
 ## A.19 Lösungen zu Kapitel „Die moderne Portfoliotheorie nach Markowitz“ {#sec:loesungen-markowitz}
 
-**12.1 — Diversifikationseffekt.**
+**19.1 — Diversifikationseffekt.**
 
 | $(w_1, w_2)$ | $\mu_p$ | $\sigma_p$ | Sharpe ($r_f=2\,\%$) |
 | --- | ---: | ---: | ---: |
@@ -25414,19 +26573,19 @@ Rechenweg für $(0{,}5;\ 0{,}5)$: $\sigma_p^2 = 0{,}25\cdot0{,}0625 + 0{,}25\cdo
 
 Beste Sharpe Ratio unter den vier Kandidaten: $(0{,}3;\ 0{,}7)$. Das exakte Optimum liegt bei $w_1 = 0{,}318$. **Bemerkenswert:** Die Mischung $(0{,}3;\ 0{,}7)$ hat mit 10,08 % eine **geringere** Volatilität als *beide* Einzeltitel (25 % und 12 %) — genau der Diversifikationseffekt, den die negative Korrelation ermöglicht.
 
-**12.2 — Lambda deuten.** Von $\lambda=0$ (GMV, linker unterer Punkt der Kurve) wandert die Lösung entlang der Effizienzgrenze nach rechts oben, bis sie bei $\lambda\to\infty$ im Titel mit der höchsten Rendite endet (bzw. an der Positionsobergrenze).
+**19.2 — Lambda deuten.** Von $\lambda=0$ (GMV, linker unterer Punkt der Kurve) wandert die Lösung entlang der Effizienzgrenze nach rechts oben, bis sie bei $\lambda\to\infty$ im Titel mit der höchsten Rendite endet (bzw. an der Positionsobergrenze).
 
-**12.3 — Korn-Transformation.** $\text{SR}(c\mathbf{w}) = \frac{c\mathbf{w}^\top\boldsymbol{\mu}-r_f}{\sqrt{c^2\mathbf{w}^\top\boldsymbol{\Sigma}\mathbf{w}}}$ — bei einem Portfolio mit $\sum w_i = 1$ und Überrenditen geschrieben als $\mathbf{w}^\top(\boldsymbol{\mu}-r_f\mathbf{1})$ kürzt sich $c$ heraus. Mit der Bedingung $\sum w_i = 1$ ist die Skala jedoch **fixiert**, man kann also nicht frei skalieren. Die Transformation ersetzt diese Bedingung durch $\sum y_i = \kappa$ mit freiem $\kappa$ und normiert stattdessen die Überrendite auf 1 — dadurch wird die Skala wieder frei und das Problem konvex.
+**19.3 — Korn-Transformation.** $\text{SR}(c\mathbf{w}) = \frac{c\mathbf{w}^\top\boldsymbol{\mu}-r_f}{\sqrt{c^2\mathbf{w}^\top\boldsymbol{\Sigma}\mathbf{w}}}$ — bei einem Portfolio mit $\sum w_i = 1$ und Überrenditen geschrieben als $\mathbf{w}^\top(\boldsymbol{\mu}-r_f\mathbf{1})$ kürzt sich $c$ heraus. Mit der Bedingung $\sum w_i = 1$ ist die Skala jedoch **fixiert**, man kann also nicht frei skalieren. Die Transformation ersetzt diese Bedingung durch $\sum y_i = \kappa$ mit freiem $\kappa$ und normiert stattdessen die Überrendite auf 1 — dadurch wird die Skala wieder frei und das Problem konvex.
 
-**12.4 — Restriktionen kosten.** Erwartetes Muster: Sharpe Ratio sinkt monoton mit strengerer Grenze. Unlösbar wird es bei $w_{\max} < 1/n$ — dann kann die Summe der Gewichte 1 nicht mehr erreicht werden.
+**19.4 — Restriktionen kosten.** Erwartetes Muster: Sharpe Ratio sinkt monoton mit strengerer Grenze. Unlösbar wird es bei $w_{\max} < 1/n$ — dann kann die Summe der Gewichte 1 nicht mehr erreicht werden.
 
-**12.5 — Den Sektorfehler nachstellen.** (a) AAPL, AMZN, CVX, GS statt AAPL, MSFT, NVDA, AMZN. (b) Die Gewichte unterscheiden sich deutlich, weil die eigentlich zu begrenzenden Tech-Titel frei laufen. (c) **Nein** — die Kennzahlen sehen völlig plausibel aus. Genau das macht den Fehler so gefährlich.
+**19.5 — Den Sektorfehler nachstellen.** (a) AAPL, AMZN, CVX, GS statt AAPL, MSFT, NVDA, AMZN. (b) Die Gewichte unterscheiden sich deutlich, weil die eigentlich zu begrenzenden Tech-Titel frei laufen. (c) **Nein** — die Kennzahlen sehen völlig plausibel aus. Genau das macht den Fehler so gefährlich.
 
-**12.6 — Kardinalität.** Erwartung: Die Sharpe Ratio sinkt leicht, die Rechenzeit steigt deutlich (MIQP statt QP). Bei $K \ge 5$ und $w_{\max} = 0{,}20$ ist die Restriktion praktisch nicht mehr bindend.
+**19.6 — Kardinalität.** Erwartung: Die Sharpe Ratio sinkt leicht, die Rechenzeit steigt deutlich (MIQP statt QP). Bei $K \ge 5$ und $w_{\max} = 0{,}20$ ist die Restriktion praktisch nicht mehr bindend.
 
-**12.7 — Out-of-Sample.** Typisches Ergebnis: Max-Sharpe schneidet in der zweiten Hälfte **schlechter** ab als in der ersten — es hat Schätzrauschen mitoptimiert. GMV ist stabiler (keine Renditeprognose nötig), 1/N oft überraschend gut. Mit Ledoit-Wolf verbessern sich GMV und Max-Sharpe spürbar. **Praxisfolgerung:** Renditeprognosen sind viel unzuverlässiger als Risikoschätzungen — Modelle, die ohne sie auskommen, sind robuster.
+**19.7 — Out-of-Sample.** Typisches Ergebnis: Max-Sharpe schneidet in der zweiten Hälfte **schlechter** ab als in der ersten — es hat Schätzrauschen mitoptimiert. GMV ist stabiler (keine Renditeprognose nötig), 1/N oft überraschend gut. Mit Ledoit-Wolf verbessern sich GMV und Max-Sharpe spürbar. **Praxisfolgerung:** Renditeprognosen sind viel unzuverlässiger als Risikoschätzungen — Modelle, die ohne sie auskommen, sind robuster.
 
-### Finde den Denkfehler 12.1 — Zwölf gleiche Anlagen, ein sehr ungleiches Portfolio
+### Finde den Denkfehler — Zwölf gleiche Anlagen, ein sehr ungleiches Portfolio
 
 (a) **Woher die Spanne kommt.** Aus reinem Rauschen. Der Mittelwert von 250 Beobachtungen einer Größe mit Standardabweichung $\sigma = 1{,}2\,\%$ hat selbst noch den **Standardfehler**
 
@@ -25458,7 +26617,7 @@ Zusammen ergibt das das beobachtete Bild: 38 % Konzentration in einer Anlage, ob
 
 1. **Renditeschätzung ganz vermeiden.** Das **Minimum-Varianz-Portfolio** minimiert nur $\mathbf{w}^\top\boldsymbol{\Sigma}\mathbf{w}$ und braucht überhaupt kein $\boldsymbol{\mu}$. Damit fällt die unzuverlässigste Eingangsgröße ersatzlos weg. Das ist das wirksamste Mittel, weil es das Problem nicht abmildert, sondern **beseitigt** — man kann eine Größe nicht falsch schätzen, die man nicht verwendet.
 2. **Stark schrumpfen.** Wenn Renditen gebraucht werden, zieht man sie kräftig zum Gesamtmittel (James-Stein) oder zu einer Gleichgewichtsannahme (Black-Litterman) — deutlich stärker als bei Kovarianzen, aus den Gründen unter (c).
-3. **Freiheit begrenzen.** Obergrenzen je Position (etwa 15 %), Sektorgrenzen, maximale Abweichung von einer Referenzgewichtung. Was der Optimierer nicht darf, kann er auch nicht auf Rauschen setzen — dasselbe Rezept wie in [Denkfehler 11.1](#kapitel-11).
+3. **Freiheit begrenzen.** Obergrenzen je Position (etwa 15 %), Sektorgrenzen, maximale Abweichung von einer Referenzgewichtung. Was der Optimierer nicht darf, kann er auch nicht auf Rauschen setzen — dasselbe Rezept wie in [Abschnitt 18.8](#sec:finanzdaten-denkfehler).
 
 **Und die Kontrollfrage für den Alltag:** Rechnen Sie Ihr Modell mit den Daten des halben Zeitraums und dann mit denen der anderen Hälfte. Wenn die Gewichte dabei stark springen, optimieren Sie Rauschen — unabhängig davon, wie gut die Kennzahlen im Schätzzeitraum aussehen.
 
@@ -25481,19 +26640,19 @@ Zusammen ergibt das das beobachtete Bild: 38 % Konzentration in einer Anlage, ob
 
 ## A.20 Lösungen zu Kapitel „Tail-Risiko, CVaR und Transaktionskosten“ {#sec:loesungen-cvar}
 
-**13.1 — VaR und CVaR von Hand.** Sortierte Verluste: $-2{,}0; -1{,}2; -0{,}8; -0{,}4; 0{,}3; 0{,}6; 1{,}1; 2{,}1; 5{,}4; 8{,}9$. Das 80 %-Quantil ist der 8. Wert: $\text{VaR}_{80\%} = 2{,}1$. $\text{CVaR}_{80\%} = $ Mittel der schlechtesten 20 % $= (5{,}4+8{,}9)/2 = \mathbf{7{,}15}$.
+**20.1 — VaR und CVaR von Hand.** Sortierte Verluste: $-2{,}0; -1{,}2; -0{,}8; -0{,}4; 0{,}3; 0{,}6; 1{,}1; 2{,}1; 5{,}4; 8{,}9$. Das 80 %-Quantil ist der 8. Wert: $\text{VaR}_{80\%} = 2{,}1$. $\text{CVaR}_{80\%} = $ Mittel der schlechtesten 20 % $= (5{,}4+8{,}9)/2 = \mathbf{7{,}15}$.
 
-**13.2 — Subadditivität.** Ein Risikomaß sollte Diversifikation nie bestrafen: Das Risiko eines zusammengelegten Portfolios darf nicht größer sein als die Summe der Einzelrisiken. Wird das verletzt, hätte eine Bank einen Anreiz, Portfolios künstlich aufzuspalten, um Eigenkapitalanforderungen zu senken — ökonomisch unsinnig.
+**20.2 — Subadditivität.** Ein Risikomaß sollte Diversifikation nie bestrafen: Das Risiko eines zusammengelegten Portfolios darf nicht größer sein als die Summe der Einzelrisiken. Wird das verletzt, hätte eine Bank einen Anreiz, Portfolios künstlich aufzuspalten, um Eigenkapitalanforderungen zu senken — ökonomisch unsinnig.
 
-**13.3 — Rockafellar-Uryasev nachvollziehen.** (a) Schlechtestes Drittel von $(1,4,9)$ ist $\{9\}$ → CVaR $= 9$. (b) Mit $\frac{1}{S(1-\alpha)} = \frac{1}{3\cdot(1/3)} = 1$: $\gamma=0$: $0 + (1+4+9) = 14$. $\gamma=1$: $1 + (0+3+8) = 12$. $\gamma=4$: $4 + (0+0+5) = \mathbf{9}$. $\gamma=5$: $5+4 = 9$. $\gamma=9$: $9+0 = 9$. (c) Minimum ab $\gamma = 4$ bei **9** — identisch mit (a) ✓. (Das Minimum wird auf einem ganzen Intervall angenommen, weil die Funktion stückweise linear ist — genau der Grund, warum der CVaR nicht *streng* konvex ist.)
+**20.3 — Rockafellar-Uryasev nachvollziehen.** (a) Schlechtestes Drittel von $(1,4,9)$ ist $\{9\}$ → CVaR $= 9$. (b) Mit $\frac{1}{S(1-\alpha)} = \frac{1}{3\cdot(1/3)} = 1$: $\gamma=0$: $0 + (1+4+9) = 14$. $\gamma=1$: $1 + (0+3+8) = 12$. $\gamma=4$: $4 + (0+0+5) = \mathbf{9}$. $\gamma=5$: $5+4 = 9$. $\gamma=9$: $9+0 = 9$. (c) Minimum ab $\gamma = 4$ bei **9** — identisch mit (a) ✓. (Das Minimum wird auf einem ganzen Intervall angenommen, weil die Funktion stückweise linear ist — genau der Grund, warum der CVaR nicht *streng* konvex ist.)
 
-**13.4 — Einheiten prüfen.** In einem Modell, das annualisierte Rendite gegen täglichen CVaR verrechnet, wirkt $1{,}5$ effektiv als $1{,}5/252 \approx 0{,}006$ auf Tagesbasis — der Risikoterm ist also um Faktor 252 zu leicht gewichtet. Um dieselbe Wirkung wie `RISIKOAVERSION = 1.5` im konsistenten Tagesmodell zu erzielen, hätte man dort `lambda_risk = 1.5 * 252 = 378` setzen müssen.
+**20.4 — Einheiten prüfen.** In einem Modell, das annualisierte Rendite gegen täglichen CVaR verrechnet, wirkt $1{,}5$ effektiv als $1{,}5/252 \approx 0{,}006$ auf Tagesbasis — der Risikoterm ist also um Faktor 252 zu leicht gewichtet. Um dieselbe Wirkung wie `RISIKOAVERSION = 1.5` im konsistenten Tagesmodell zu erzielen, hätte man dort `lambda_risk = 1.5 * 252 = 378` setzen müssen.
 
-**13.5 — Risikoaversion kalibrieren.** (a) Konkav, ähnlich der Markowitz-Frontier, aber im Rendite-CVaR-Raum. (b) Bei Normalverteilung entspricht CVaR-Optimierung ungefähr der Varianz-Optimierung; die Ergebnisse divergieren umso stärker, je schiefer die Verteilung ist. (c) Empfehlung ohne Fachjargon: „Bei dieser Einstellung liegt der durchschnittliche Verlust an den schlechtesten fünf Prozent der Tage bei X Prozent — bei einer erwarteten Rendite von Y Prozent.“ Das ist entscheidbar; „$\lambda = 4$“ ist es nicht.
+**20.5 — Risikoaversion kalibrieren.** (a) Konkav, ähnlich der Markowitz-Frontier, aber im Rendite-CVaR-Raum. (b) Bei Normalverteilung entspricht CVaR-Optimierung ungefähr der Varianz-Optimierung; die Ergebnisse divergieren umso stärker, je schiefer die Verteilung ist. (c) Empfehlung ohne Fachjargon: „Bei dieser Einstellung liegt der durchschnittliche Verlust an den schlechtesten fünf Prozent der Tage bei X Prozent — bei einer erwarteten Rendite von Y Prozent.“ Das ist entscheidbar; „$\lambda = 4$“ ist es nicht.
 
-**13.6 — Grenze statt Strafe.** (a) Mit engerer Grenze sinkt die erreichbare Rendite; bei $\tau = 0$ bleibt das Altportfolio. (b) **Vorteil der Grenze:** garantierte Obergrenze für die Handelsaktivität — wichtig, wenn Liquidität oder Compliance eine harte Schranke verlangen. **Nachteil:** Sie kann das Modell unlösbar machen und ignoriert, dass ein sehr lohnender Trade den Aufwand wert wäre. (c) Strafe bei ökonomischer Abwägung, Grenze bei regulatorischen oder Liquiditätsvorgaben.
+**20.6 — Grenze statt Strafe.** (a) Mit engerer Grenze sinkt die erreichbare Rendite; bei $\tau = 0$ bleibt das Altportfolio. (b) **Vorteil der Grenze:** garantierte Obergrenze für die Handelsaktivität — wichtig, wenn Liquidität oder Compliance eine harte Schranke verlangen. **Nachteil:** Sie kann das Modell unlösbar machen und ignoriert, dass ein sehr lohnender Trade den Aufwand wert wäre. (c) Strafe bei ökonomischer Abwägung, Grenze bei regulatorischen oder Liquiditätsvorgaben.
 
-### Finde den Denkfehler 13.1 — Das Risikobudget, das durch Diversifikation stieg
+### Finde den Denkfehler — Das Risikobudget, das durch Diversifikation stieg
 
 (a) **Die entscheidende Wahrscheinlichkeit.** Bei zwei unabhängigen Anleihen mit je 4 % Ausfallwahrscheinlichkeit fällt **mindestens eine** aus mit
 
@@ -25546,19 +26705,19 @@ Formal folgt die Subadditivität daraus, dass der CVaR sich als **Maximum über
 
 ## A.21 Lösungen zu Kapitel „Die vollständige quantitative Handelsmaschine“ {#sec:loesungen-handelsmaschine}
 
-**14.1 — Lookahead erkennen.** (a) sauber (`:heute`). (b) **Lookahead** — gesamter Zeitraum. (c) **Lookahead** — Volatilität über den ganzen Zeitraum enthält Zukunft. (d) sauber — Gewichte aus Daten bis heute, angewendet auf heute (idealerweise auf morgen). (e) **Survivorship-Bias** — das Universum wird danach gefiltert, wer über den gesamten Zeitraum Daten hat.
+**21.1 — Lookahead erkennen.** (a) sauber (`:heute`). (b) **Lookahead** — gesamter Zeitraum. (c) **Lookahead** — Volatilität über den ganzen Zeitraum enthält Zukunft. (d) sauber — Gewichte aus Daten bis heute, angewendet auf heute (idealerweise auf morgen). (e) **Survivorship-Bias** — das Universum wird danach gefiltert, wer über den gesamten Zeitraum Daten hat.
 
-**14.2 — Kennzahlen deuten.** A: Sharpe $= (12-2)/22 = 0{,}45$, Calmar $= 12/35 = 0{,}34$. B: Sharpe $= (8-2)/9 = 0{,}67$, Calmar $= 8/12 = 0{,}67$. **Empfehlung: B** — für einen Pensionsfonds ist der Drawdown entscheidend, weil laufende Auszahlungen in einer Verlustphase Substanz vernichten. B ist in beiden risikoadjustierten Maßen besser.
+**21.2 — Kennzahlen deuten.** A: Sharpe $= (12-2)/22 = 0{,}45$, Calmar $= 12/35 = 0{,}34$. B: Sharpe $= (8-2)/9 = 0{,}67$, Calmar $= 8/12 = 0{,}67$. **Empfehlung: B** — für einen Pensionsfonds ist der Drawdown entscheidend, weil laufende Auszahlungen in einer Verlustphase Substanz vernichten. B ist in beiden risikoadjustierten Maßen besser.
 
-**14.3 — Rebalancing-Kalender.** Etwa 25–30 % der Termine fallen aus. Die Kennzahlen ändern sich messbar — in welche Richtung, ist zufällig. Genau das ist der Punkt: Der Fehler verzerrt, ohne aufzufallen.
+**21.3 — Rebalancing-Kalender.** Etwa 25–30 % der Termine fallen aus. Die Kennzahlen ändern sich messbar — in welche Richtung, ist zufällig. Genau das ist der Punkt: Der Fehler verzerrt, ohne aufzufallen.
 
-**14.4 — Rebalancing-Frequenz.** Typisches Muster: Turnover und Kosten steigen etwa linear mit der Frequenz, der Bruttoertrag verbessert sich nur unterproportional. Bei 0,15 % Gebühren ist monatlich meist vertretbar, bei 0,5 % eher quartalsweise. Ein **Toleranzband** (nur handeln bei Abweichung > x %) schlägt fast immer die feste Frequenz.
+**21.4 — Rebalancing-Frequenz.** Typisches Muster: Turnover und Kosten steigen etwa linear mit der Frequenz, der Bruttoertrag verbessert sich nur unterproportional. Bei 0,15 % Gebühren ist monatlich meist vertretbar, bei 0,5 % eher quartalsweise. Ein **Toleranzband** (nur handeln bei Abweichung > x %) schlägt fast immer die feste Frequenz.
 
-**14.5 — Krisenverhalten.** Erwartung: Die Überrendite ist selten stabil; oft stammt sie aus wenigen Perioden. Folgerung: Eine gute Gesamtkennzahl kann von einer einzigen glücklichen Phase getragen sein — **immer** nach Teilzeiträumen aufschlüsseln.
+**21.5 — Krisenverhalten.** Erwartung: Die Überrendite ist selten stabil; oft stammt sie aus wenigen Perioden. Folgerung: Eine gute Gesamtkennzahl kann von einer einzigen glücklichen Phase getragen sein — **immer** nach Teilzeiträumen aufschlüsseln.
 
-**14.6 — Data Snooping messen.** Erwartetes Ergebnis: Die beste In-Sample-Sharpe-Ratio liegt deutlich über dem Mittelwert aller Varianten; auf dem zurückgehaltenen Zeitraum fällt sie Richtung Mittelwert zurück. Die **Differenz zwischen (a) und (c) ist der Selektionseffekt** — genau das, was die Deflated Sharpe Ratio korrigieren soll.
+**21.6 — Data Snooping messen.** Erwartetes Ergebnis: Die beste In-Sample-Sharpe-Ratio liegt deutlich über dem Mittelwert aller Varianten; auf dem zurückgehaltenen Zeitraum fällt sie Richtung Mittelwert zurück. Die **Differenz zwischen (a) und (c) ist der Selektionseffekt** — genau das, was die Deflated Sharpe Ratio korrigieren soll.
 
-### Finde den Denkfehler 14.1 — Die Strategie mit dem hochsignifikanten Ergebnis
+### Finde den Denkfehler — Die Strategie mit dem hochsignifikanten Ergebnis
 
 (a) **Warum ein korrekter Backtest wertlos sein kann.** Der Backtest misst genau das, was er messen soll: die Wertentwicklung *dieser einen* Strategie. Die Frage, die beantwortet werden soll, lautet aber anders — nämlich: *„Ist dieses Ergebnis besser, als es Zufall erklären kann?“*
 
@@ -25612,19 +26771,21 @@ Ein zweiter Blick auf denselben Testzeitraum ist deshalb kein „nochmal prüfen
 
 ## A.22 Lösungen zu Kapitel „Praxisfallen und der Weg zum produktiven Einsatz“ {#sec:loesungen-praxisfallen}
 
-**15.1 — Hart oder weich, revisited.** (a) hart: gesetzliche Ruhezeit, Qualifikationspflicht. (b) weich: individuelle Wunschtage, Vermeidung von Freistunden. (c) diskutabel: Höchstzahl Vertretungsstunden pro Tag (tariflich vs. Notfall), gleichmäßige Wochenendverteilung.
+**22.1 — Hart oder weich, revisited.** (a) hart: gesetzliche Ruhezeit, Qualifikationspflicht. (b) weich: individuelle Wunschtage, Vermeidung von Freistunden. (c) diskutabel: Höchstzahl Vertretungsstunden pro Tag (tariflich vs. Notfall), gleichmäßige Wochenendverteilung.
 
-**15.2 — Zeitlimit wählen.** (a) 1–3 s, Gap 5–10 % (Echtzeit schlägt Optimalität). (b) 1–5 min, Gap 1–2 %. (c) Stunden, Gap ~0 % (einmalige, folgenreiche Entscheidung). (d) 30–60 s, Gap 1 % — die Datenunsicherheit ist ohnehin größer.
+**22.2 — Zeitlimit wählen.** (a) 1–3 s, Gap 5–10 % (Echtzeit schlägt Optimalität). (b) 1–5 min, Gap 1–2 %. (c) Stunden, Gap ~0 % (einmalige, folgenreiche Entscheidung). (d) 30–60 s, Gap 1 % — die Datenunsicherheit ist ohnehin größer.
 
-**15.3 — Relaxation einbauen.** Muster wie in `Infeasibility_Diagnose.py`: Schlupfvariable je Mindestbesetzung, Strafe deutlich über allen weichen Zielen, aber endlich. Wichtig: **gestaffelte** Strafen, damit der Solver die *am wenigsten schmerzhafte* Verletzung wählt.
+**22.3 — Relaxation einbauen.** Muster wie in `Infeasibility_Diagnose.py`: Schlupfvariable je Mindestbesetzung, Strafe deutlich über allen weichen Zielen, aber endlich. Wichtig: **gestaffelte** Strafen, damit der Solver die *am wenigsten schmerzhafte* Verletzung wählt.
 
-**15.4 — Erklärbarkeit.** Report-Struktur: (1) Zielwert und Aufschlüsselung nach Bestandteilen; (2) je Entscheidung die bindenden Bedingungen; (3) Schattenpreise der knappsten Ressourcen mit Handlungsempfehlung.
+**22.4 — Erklärbarkeit.** Report-Struktur: (1) Zielwert und Aufschlüsselung nach Bestandteilen; (2) je Entscheidung die bindenden Bedingungen; (3) Schattenpreise der knappsten Ressourcen mit Handlungsempfehlung.
 
-**15.5 — Gap gegen Laufzeit.** Erwartetes Muster: Von 10 % auf 2 % kostet wenig Zeit; von 1 % auf 0 % kann die Laufzeit um Größenordnungen steigen, ohne dass sich der Zielwert nennenswert verbessert. Empfehlung: Gap dort ansetzen, wo die Kurve knickt — typischerweise 1–2 %.
+**22.5 — Den Bericht in die Irre führen.** (a) Der Plan kippt: *Rahmen* fällt von 47,5 auf **40** — das Minimum aus dem Liefervertrag —, *Deckel* steigt von 97,5 auf **120**, die Marktgrenze. Der Deckungsbeitrag springt von 3 930 € auf **5 190 €**. Mit ihm wechselt die Engpassstruktur: „Kapazität Lackieren" bindet **nicht mehr**, dafür bindet jetzt „Liefervertrag Rahmen" — und zwar als *Kosten* von 25 € je Stück, weil der Vertrag zur Herstellung eines inzwischen unattraktiven Produkts zwingt. Alle Schattenpreise steigen deutlich (Träger von 18 € auf 58 €). Der entscheidende Punkt der Aufgabe: Der Satz *„Teuerste Bindung ist Liefervertrag Träger"* steht **wörtlich unverändert** im Bericht — obwohl die Zahl dahinter sich mehr als verdreifacht hat und ein anderer Engpass die Fabrik begrenzt. Ein Bericht, der sich nicht ändert, ist kein Beweis dafür, dass sich nichts geändert hat. (b) Etwa: *„Unter der Annahme eines Deckungsbeitrags von 9 € je Deckel ist ‚Liefervertrag Träger' die teuerste Bindung (18 € je Stück)."* Die Aussage bekommt damit ihre Voraussetzung mit — und wird angreifbar, was sie sein soll. (c) Mindestens eines von beidem: den **Gültigkeitsbereich** jedes Schattenpreises (bis wohin gilt er?), oder das Ergebnis einer **Sensitivitätsrechnung** über die unsichersten Eingangsgrößen — etwa „bei ±20 % Deckungsbeitrag Deckel bleibt die Rangfolge/kippt sie". Das Programm rechnet den Gültigkeitsbereich für die auffälligste Stellschraube bereits aus; ihn für alle auszuweisen ist eine kleine Erweiterung.
 
-**15.6 — Post-Mortem.** Bewertungskriterien: Wird zwischen **Symptom**, **Ursache** und **fehlender Prüfung** unterschieden? Ist die abgeleitete Regel allgemein genug, um beim nächsten Projekt zu helfen (z. B. „Nach jeder Vorzeichenumkehr eine numerische Gegenprobe“), aber konkret genug, um überprüfbar zu sein?
+**22.6 — Gap gegen Laufzeit.** Erwartetes Muster: Von 10 % auf 2 % kostet wenig Zeit; von 1 % auf 0 % kann die Laufzeit um Größenordnungen steigen, ohne dass sich der Zielwert nennenswert verbessert. Empfehlung: Gap dort ansetzen, wo die Kurve knickt — typischerweise 1–2 %.
 
-### Finde den Denkfehler 15.1 — Das Modell, das seit einem Jahr nicht mehr optimiert
+**22.7 — Post-Mortem.** Bewertungskriterien: Wird zwischen **Symptom**, **Ursache** und **fehlender Prüfung** unterschieden? Ist die abgeleitete Regel allgemein genug, um beim nächsten Projekt zu helfen (z. B. „Nach jeder Vorzeichenumkehr eine numerische Gegenprobe“), aber konkret genug, um überprüfbar zu sein?
+
+### Finde den Denkfehler — Das Modell, das seit einem Jahr nicht mehr optimiert
 
 (a) **Warum die konstante Laufzeit das Symptom ist.** Ein Solver, der fertig wird, braucht so lange, wie das Problem eben dauert — und diese Zeit wächst mit den Daten. Eine Laufzeit, die über Jahre exakt bei 3,00 Sekunden liegt, kann deshalb nur eines bedeuten: Der Job wird nicht fertig, sondern **abgeschnitten**.
 
@@ -25668,6 +26829,8 @@ Das ist das eigentliche Argument für die Überwachung: Nicht, dass ein Gap von
 3. Weil die Datenunsicherheit (oft ±10 %) die verbleibende Optimalitätslücke bei Weitem übersteigt.
 4. Jeder Lauf arbeitet auf einem unveränderlichen, mit ID versehenen Datenstand — nur so sind Ergebnisse reproduzierbar und belegbar.
 5. Die **Einführung**: mangelnde Akzeptanz, weil Ergebnisse nicht nachvollziehbar sind.
+6. Sie berührt den Plan, ohne ihn zu verteuern — die Lösung liegt genau auf ihrer Grenze, wäre aber auch ohne sie dieselbe (Entartung). Für eine Nachverhandlung folgt: **nichts tun.** Der Aufwand brächte 0 €. „Bindend" ist ein geometrischer, „teuer" ein wirtschaftlicher Befund.
+7. Weil der Schattenpreis nur für die **nächste** Einheit gilt und sein Gültigkeitsbereich endet, sobald ein anderer Engpass bindend wird. Realistische Lockerungen sind unterschiedlich groß — eine Sonderschicht bringt 50 Einheiten, ein nachverhandelter Vertrag 10. Der Preis je Einheit sagt daher nichts darüber, welcher Hebel insgesamt am meisten bringt; dafür muss man die Lockerung rechnen, nicht den Preis multiplizieren.
 
 ---
 
@@ -25675,11 +26838,11 @@ Das ist das eigentliche Argument für die Überwachung: Nicht, dass ein Gap von
 
 ## A.23 Lösungen zu Kapitel „Testen, Messen, Ausliefern“ {#sec:loesungen-testing}
 
-**Den Schnellstart reparieren.** Zwei Wege: (a) **Abrunden statt runden** — `np.floor` statt `np.round`. Das ist immer zulässig, weil weniger produzieren nie eine Kapazität sprengt, kostet aber Deckungsbeitrag und ist im Allgemeinen **nicht** die optimale ganzzahlige Lösung. (b) **Ganzzahlig modellieren** — `linprog(..., integrality=1)` bzw. `IntVar`. Das ist der richtige Weg.
+**23.1 — Den Schnellstart reparieren.** Zwei Wege: (a) **Abrunden statt runden** — `np.floor` statt `np.round`. Das ist immer zulässig, weil weniger produzieren nie eine Kapazität sprengt, kostet aber Deckungsbeitrag und ist im Allgemeinen **nicht** die optimale ganzzahlige Lösung. (b) **Ganzzahlig modellieren** — `linprog(..., integrality=1)` bzw. `IntVar`. Das ist der richtige Weg.
 
 Warum das ein eigenes Kapitel wert ist ([Kapitel 6](#kap-milp)): Runden ist nicht nur ungenau, sondern kann *beliebig* danebenliegen. Es gibt Instanzen, bei denen die gerundete LP-Lösung nicht nur suboptimal, sondern unzulässig ist — genau das zeigt der Schnellstart — und andere, bei denen zwischen gerundetem LP und echtem Optimum Welten liegen (`Runden_Gegenbeispiel.py`).
 
-**Eine Invariante mehr.**
+**23.2 — Eine Invariante mehr.**
 
 ```python
 def test_kapazitaeten_verdoppeln(bauer):
@@ -25693,7 +26856,7 @@ def test_kapazitaeten_verdoppeln(bauer):
 
 Bei einem **LP** gilt das exakt: Der zulässige Bereich wird um den Faktor 2 gestreckt, und weil die Zielfunktion linear ist, skaliert das Optimum mit. Bei einem **MILP** gilt es nicht: Die Ganzzahligkeitsbedingung skaliert nicht mit. Aus 30,67 wird beim Verdoppeln 61,33 — und ob dazwischen eine bessere ganzzahlige Lösung liegt, hängt vom Einzelfall ab. Der Test wäre dort also falsch.
 
-**Eine eigene Mutation.** Zwei lohnende Kandidaten:
+**23.3 — Eine eigene Mutation.** Zwei lohnende Kandidaten:
 
 ```python
 ("Kapazitaetspruefung mit falschem Vergleich",
@@ -25704,9 +26867,9 @@ Bei einem **LP** gilt das exakt: Der zulässige Bereich wird um den Faktor 2 ges
 
 Die erste wird getötet (`test_pruefung_findet_kapazitaetsverletzung`). Die zweite ist interessanter: Sie macht die Prüfung *strenger* statt schwächer — eine Lösung mit einer Menge von exakt 0 würde als negativ beanstandet. Ob sie überlebt, hängt daran, ob die Suite eine Instanz enthält, in der ein Produkt mit Menge 0 vorkommt. In der Schreinerei ist das nicht der Fall — die Mutation überlebt also und zeigt eine echte Lücke: Es fehlt eine Testinstanz, in der ein Produkt nicht produziert wird.
 
-**Der Benchmark mit MILP.** Zu erwarten ist, dass sich die Reihenfolge ändert. Beim reinen LP entscheidet vor allem der Modellaufbau in Python; beim MILP verschiebt sich das Gewicht zum Lösen, und dort spielen die Branch-and-Bound-Heuristiken der Bibliotheken gegeneinander. Die Spalte „Anteil" sollte bei allen deutlich **fallen** — nicht weil der Aufbau schneller würde, sondern weil das Lösen langsamer wird. Genau deshalb steht im Kapitel, dass die Tabelle nichts über MILPs sagt.
+**23.4 — Der Benchmark mit MILP.** Zu erwarten ist, dass sich die Reihenfolge ändert. Beim reinen LP entscheidet vor allem der Modellaufbau in Python; beim MILP verschiebt sich das Gewicht zum Lösen, und dort spielen die Branch-and-Bound-Heuristiken der Bibliotheken gegeneinander. Die Spalte „Anteil" sollte bei allen deutlich **fallen** — nicht weil der Aufbau schneller würde, sondern weil das Lösen langsamer wird. Genau deshalb steht im Kapitel, dass die Tabelle nichts über MILPs sagt.
 
-**Der Dienst mit Zeitlimit.** Der Modellbauer in `or_kern.py` nimmt bisher kein Zeitlimit entgegen — das ist der erste Schritt (bei GLOP `solver.SetTimeLimit(millisekunden)`). Danach im Arbeiter durchreichen und den Status auswerten: Liefert der Solver `ZEITLIMIT`, ist `stand` weiterhin `gescheitert`, aber mit einer anderen Begründung als bei `UNZULAESSIG` — der Unterschied zwischen „rechne länger" und „ändere das Modell" ([Kapitel 6](#kap-milp)).
+**23.5 — Der Dienst mit Zeitlimit.** Der Modellbauer in `or_kern.py` nimmt bisher kein Zeitlimit entgegen — das ist der erste Schritt (bei GLOP `solver.SetTimeLimit(millisekunden)`). Danach im Arbeiter durchreichen und den Status auswerten: Liefert der Solver `ZEITLIMIT`, ist `stand` weiterhin `gescheitert`, aber mit einer anderen Begründung als bei `UNZULAESSIG` — der Unterschied zwischen „rechne länger" und „ändere das Modell" ([Kapitel 6](#kap-milp)).
 
 Für den Test braucht es eine Instanz, die das Limit reißt. Ein LP eignet sich schlecht dafür; nehmen Sie ein MILP mit einigen hundert Binärvariablen und ein Limit von 0,1 Sekunden.
 
@@ -25791,6 +26954,8 @@ Was geholfen hätte — drei Dinge, keines davon ein Unit-Test:
 | B23 | Zuordnung 1:1 | „Jeder genau eine Aufgabe“ | [Kapitel 8](#kap-graphen) |
 | B24 | Subtour-Eliminierung | „Keine isolierten Kreise“ | [Kapitel 8](#kap-graphen) |
 
+> **Umgekehrte Richtung:** Wer von einem Satz aus der Besprechung kommt und das Muster sucht, findet in [Abschnitt 4.6](#sec:modellierung-glossar) ein Lexikon, das genau so herum aufgebaut ist — und die Wendungen benennt, bei denen es keine eindeutige Übersetzung gibt.
+>
 > Die Spalte „Wo im Buch“ nennt das Kapitel, in dem das Muster **im Zusammenhang** vorkommt — nicht die einzige Stelle, an der es taugt. Die Nummern entstehen beim Bauen; im Quelltext dieses Anhangs steht keine einzige.
 
 ---
@@ -26753,7 +27918,7 @@ ImportError: .../highspy/_core...so: undefined symbol: _ZN5Highs13releaseMemoryE
 
 **Abhilfen (in dieser Reihenfolge):**
 1. Nur eines von beiden im selben Skript verwenden.
-2. Getrennte Prozesse (`subprocess`) — siehe `Ein_System_Vier_Ansaetze.py`.
+2. Getrennte Prozesse — ein `ProcessPoolExecutor` mit `mp_context="spawn"` und `max_tasks_per_child=1`, siehe `Ein_System_Vier_Ansaetze.py`.
 3. Auf `highspy` verzichten: HiGHS ist ohnehin Backend von `scipy.optimize.linprog` und CVXPY.
 4. Getrennte virtuelle Umgebungen.
 
diff --git a/Operations_Research_mit_Python_Version_04.pdf b/Operations_Research_mit_Python_Version_04.pdf
index d5e8848..077f0a4 100644
Binary files a/Operations_Research_mit_Python_Version_04.pdf and b/Operations_Research_mit_Python_Version_04.pdf differ
diff --git a/Operations_Research_mit_Python_Version_04/00_Vorwort_und_Lesehilfe.md b/Operations_Research_mit_Python_Version_04/00_Vorwort_und_Lesehilfe.md
index aabc7f4..3074a01 100644
--- a/Operations_Research_mit_Python_Version_04/00_Vorwort_und_Lesehilfe.md
+++ b/Operations_Research_mit_Python_Version_04/00_Vorwort_und_Lesehilfe.md
@@ -334,6 +334,134 @@ können Sie gezielt springen.
 
 ---
 
+## Für wen dieses Buch geschrieben ist {-}
+
+Die Lernpfade weiter unten sind nach **Themen** geschnitten. Dieser Abschnitt ist nach
+**Rollen** geschnitten: vier Einstiege für vier Arten, mit Optimierung zu tun zu haben.
+Jeder nennt den Schmerzpunkt, drei Dinge, die das Buch dafür wirklich liefert — mit den
+Zahlen, die es dazu misst —, den passenden Lernpfad und die Frage, an der es in dieser
+Rolle am häufigsten scheitert.
+
+Suchen Sie sich einen aus. Sie können auch alle vier überspringen; nötig sind sie nicht.
+
+### Für Entscheider und Manager — der Geschäftsfall {-}
+
+> *„Wir planen seit Jahren mit Erfahrungswerten, und es funktioniert. Warum sollte ein
+> Modell das besser können — und was kostet mich der Irrtum, wenn ich es nicht tue?“*
+
+* **Was Planen mit Durchschnitten kostet, wird hier beziffert, nicht behauptet.** Im
+  Kraftwerkseinsatz aus {ref:kap:supplychain} kostet ein Plan, der mit dem
+  Wind-**Erwartungswert** rechnet, in der Wirklichkeit **149 % mehr** als einer, der
+  40 Szenarien berücksichtigt — 874 870 € statt 351 356 € — und führt in **28 von
+  40 Szenarien** zum Lastabwurf statt in keinem.
+* **„Wie sicher soll es sein?“ wird eine Preisfrage.**
+  {ref:sec:unsicherheit-chance-constraints} rechnet aus, was ein Prozentpunkt
+  Versorgungssicherheit kostet: rund 56 000 € auf dem Weg zu 80 %, rund 254 000 € zwischen
+  95 und 99 %. Das **4,5-fache**. Wer 99,9 % fordert, ohne diese Kurve gesehen zu haben,
+  fordert ins Blaue.
+* **Für die Sitzung gibt es einen Bericht, keine Tabelle.**
+  {ref:sec:praxisfallen-attribution} beziffert je Nebenbedingung, was sie den Plan kostet,
+  und formuliert daraus Sätze in Alltagssprache. Für die Frage des Betriebsrats — *„warum
+  ausgerechnet ich?“* — liefert {ref:kap:praxisfallen} den Constraint-Trace, der die
+  einzelne Zuweisung begründet.
+
+**Ihr Weg.** Zuerst Pfad E (2–4 Stunden): {ref:sec:einfuehrung-historischer-kontext-und-evolution}
+und {ref:anhang:modellierungsmuster}. Wenn Sie danach wissen wollen, was in Ihrem Betrieb
+geht, Pfad B und Projekt **P1** oder **P2**.
+
+**Woran es scheitert.** Nicht am Modell, sondern an der Einführung — das ist der
+meistgenannte Befund in {ref:kap:praxisfallen}. Und an einer Verwechslung, die dieses Buch
+Ihnen nicht abnehmen kann: Ein Bericht erklärt das **Modell**, nicht die **Wirklichkeit**.
+Ist ein Deckungsbeitrag falsch geschätzt, ist er überzeugend **und** falsch. Fragen Sie
+deshalb jedes Mal, worauf eine Zahl beruht.
+
+> **Eine Erwartung, die dieses Buch enttäuscht:** Es nennt keine ROI-Kennzahl und keine
+> Amortisationsdauer. Beide hängen an Ihrem Betrieb, und jede Zahl hier wäre erfunden.
+> Was es stattdessen liefert, ist das Werkzeug, Ihre eigene auszurechnen: den **EVPI** in
+> {ref:kap:unsicherheit} (was eine perfekte Prognose überhaupt wert wäre — eine
+> Obergrenze für jedes Prognoseprojekt) und die Kostenzurechnung aus
+> {ref:sec:praxisfallen-attribution}.
+
+### Für Ingenieure und Produktionsplaner — die Physik des Systems {-}
+
+> *„Der Engpass wandert. Kaum ist eine Maschine entlastet, steht die nächste — und niemand
+> kann mir vorher sagen, welche.“*
+
+* **Der Engpass lässt sich benennen und bepreisen.**
+  {ref:sec:praxisfallen-attribution} rechnet für jede Kapazität aus, was die nächste Stunde
+  wert ist — und wie weit dieser Wert trägt. Im Beispiel gilt der Schattenpreis der
+  Lackiererei exakt bis **+15 Stunden**; eine ganze Sonderschicht von 30 Stunden bringt
+  deshalb 60 € statt der rechnerischen 120 €. **Die zweite Hälfte wäre bezahlt und
+  wirkungslos.**
+* **Rüstzeiten, Reihenfolgen, Taktzeiten sind der Kern, nicht die Ausnahme.**
+  {ref:kap:cpsat} modelliert Maschinenbelegung mit Intervallvariablen,
+  {ref:kap:metaheuristiken} zeigt am selben Fall das Gesamtbild: Faustregel 2 497 Minuten
+  Rüstzeit, CP-SAT allein 2 628, Simulated Annealing 2 343, Annealing plus LNS **2 289** —
+  und die untere Schranke bei 1 768, damit sichtbar bleibt, wie viel Luft noch da ist.
+* **Wenn der Solver zu lange braucht, gibt es Zahlen statt Ratschläge.**
+  {ref:sec:cpsat-parallele-suche} misst, was mehrere Suchstränge bringen (hier Faktor 12,3)
+  — und ab wo mehr Arbeiter wieder schaden.
+
+**Ihr Weg.** Pfad B bis {ref:kap:cpsat}, dann Projekt **P5** (Produktionsplanung mit
+Rüstkosten). Wenn Ihre echten Instanzen den Solver stehen lassen: {ref:kap:metaheuristiken}
+und Projekt **P9**.
+
+**Woran es scheitert.** An der Verwechslung von *bindend* und *teuer*. Eine Bedingung kann
+den Plan berühren und trotzdem **nichts** kosten — im Beispiel von
+{ref:sec:praxisfallen-attribution} gilt das für eine von fünf bindenden. Wer sie
+nachverhandelt, gewinnt nichts und hält das Verfahren für nutzlos.
+
+### Für Investoren und Finanzanalysten — Risiko und Ertrag {-}
+
+> *„Die Optimierung liefert mir Gewichte, die kein Mensch halten würde: 60 % in einem
+> Titel, null in fünf anderen. Und im nächsten Quartal sieht sie völlig anders aus.“*
+
+* **Der Grund dafür steht in {ref:kap:finanzdaten}, nicht in {ref:kap:markowitz}.** Eine
+  aus kurzen Zeitreihen geschätzte Kovarianzmatrix ist schlecht konditioniert; der
+  Optimierer setzt dann auf Schätzrauschen. Shrinkage nach Ledoit-Wolf ist das Gegenmittel;
+  ihre Wirkung wird an **Eigenwertspektrum und Konditionszahl** gemessen, nicht behauptet.
+* **Der VaR verschweigt genau das, worauf es ankommt.** In der Stichprobe aus
+  {ref:kap:cvar} sagt der VaR: „an 95 % der Tage höchstens **1,86 %** Verlust“. Der CVaR
+  sagt: „und wenn doch, dann im Mittel **2,99 %**“. Der schlechteste Tag der Stichprobe
+  liegt bei **−23,0 %** — am VaR ändert dieser eine Tag **nichts**, am CVaR sehr wohl.
+  Deshalb ist der CVaR die Größe, die man optimiert.
+* **Transaktionskosten und Rebalancing sind Teil des Modells, nicht ein Abzug danach.**
+  {ref:kap:cvar} nimmt sie in die Zielfunktion, {ref:kap:handelsmaschine} setzt den
+  Backtest daneben — samt der Fallen, die einen guten Backtest wertlos machen.
+
+**Ihr Weg.** Pfad D, und zwar **mit** {ref:kap:finanzdaten}. Danach Projekt **P6**
+(Portfolio-Rebalancer) oder **P7** (Risikoreport mit CVaR und Stresstests).
+
+**Woran es scheitert.** An der Reihenfolge. Wer bei Markowitz einsteigt und die
+Datenkapitel überspringt, bekommt ein Modell, das seine eigenen Schätzfehler maximiert —
+und merkt es erst im Echtgeldbetrieb.
+
+### Für Studierende und Data Scientists — die Methodik {-}
+
+> *„Ich kann ein Modell trainieren und den Fehler senken. Aber wie wird aus einer Prognose
+> eine Entscheidung — und woher weiß ich, dass sie gut ist?“*
+
+* **Die unbequemste Erkenntnis zuerst.** {ref:kap:prognose} zeigt an einem gerechneten
+  Fall, dass das Modell mit dem **schlechteren** MSE die **günstigere** Entscheidung
+  trifft. Prognosegüte und Entscheidungsqualität sind zwei verschiedene Größen; wer die
+  eine optimiert, bekommt die andere nicht geschenkt.
+* **Dieselbe Mathematik, zwei Welten.** {ref:kap:bruecke} lässt **denselben Code** einmal
+  über eine Werkstatt und einmal über ein Depot laufen — und benennt die drei Stellen, an
+  denen die Analogie endet. Struktur zu erkennen ist die eigentliche Fähigkeit, nicht
+  Bibliothekskenntnis; zu wissen, wo eine Analogie aufhört, gehört dazu.
+* **Es wird gerechnet, nicht nacherzählt.** Zu jedem Kapitel gehören Aufgaben mit
+  vollständigen Lösungen, Handrechnungen und ein „Finde den Denkfehler“ — und jedes
+  abgedruckte Ergebnis stammt aus einem echten Lauf des danebenstehenden Programms.
+
+**Ihr Weg.** Pfad A, wenn Sie Zeit haben. Sonst Pfad B oder D bis zum ersten Projekt und
+von dort zurück in die Grundlagen. Für eigene Fragestellungen: Projekt **P8**.
+
+**Woran es scheitert.** An der Annahme, ein Solver sei eine Bibliothek wie jede andere.
+Die schwierige Arbeit steckt in der Formulierung — {ref:kap:modellierung} ist deshalb kein
+Vorgeplänkel, sondern das Kapitel, auf das alle anderen aufbauen.
+
+---
+
 ## Lernpfade {-}
 
 Sie müssen nicht alles lesen, um etwas Nützliches bauen zu können.
@@ -376,7 +504,8 @@ bei Markowitz einsteigt, optimiert Schätzrauschen und wundert sich über absurd
 
 ### Pfad E — Ich habe morgen ein konkretes Problem (2–4 Stunden) {-}
 
-Lesen Sie {ref:sec:einfuehrung-historischer-kontext-und-evolution} (die vier Bausteine), dann {ref:anhang:modellierungsmuster}
+Lesen Sie {ref:sec:einfuehrung-historischer-kontext-und-evolution} (die vier Bausteine) und
+{ref:sec:modellierung-glossar} (welcher Satz welcher Baustein ist), dann {ref:anhang:modellierungsmuster}
 ([Modellierungsmuster](91_Anhang_Modellierungsmuster.md)) und suchen Sie dort das Muster,
 das zu Ihrem Problem passt. Von jedem Muster führt ein Verweis in das zuständige Kapitel.
 Wie die gewählte Bibliothek es schreibt, steht in {ref:anhang:spickzettel}
@@ -431,6 +560,7 @@ Pfad E oder um gezielt nach einem Thema zu suchen:
 | `Propagation_Demo.py` | Propagation messbar | {ref:kap:cpsat} |
 | `CP_SAT_Vertretungssystem.py` | Vertretungsplan | {ref:kap:cpsat} |
 | `JobShop_Intervalle.py` | Job-Shop-Scheduling | {ref:kap:cpsat} |
+| `Parallele_Suche.py` | num_workers: Tempo gegen Reproduzierbarkeit | {ref:kap:cpsat} |
 | `CP_SAT_Statusfaelle.py` | Die fünf Solver-Antworten | {ref:kap:cpsat} |
 | `Strafgewichte.py` | Gewichte als Wechselkurse | {ref:kap:cpsat} |
 | `Min_Cost_Flow.py` | Netzwerkfluss | {ref:kap:graphen} |
@@ -470,6 +600,7 @@ Pfad E oder um gezielt nach einem Thema zu suchen:
 | `Data_Snooping.py` | Bestes aus N Versuchen auf Rauschen | {ref:kap:handelsmaschine} |
 | `Infeasibility_Diagnose.py` | Notfallplan statt Fehler | {ref:kap:praxisfallen} |
 | `Erklaerbarkeit.py` | Constraint-Trace, Was-wäre-wenn | {ref:kap:praxisfallen} |
+| `Constraint_Attribution.py` | Was kostet welche Bedingung? Managementbericht | {ref:kap:praxisfallen} |
 | `Betriebsueberwachung.py` | Status, Gap und Zeitausschöpfung | {ref:kap:praxisfallen} |
 | `or_kern.py` | Gemeinsamer Unterbau: Domäne, Status, Prüfung | {ref:kap:praxisfallen} |
 | `Solverwechsel_CPSAT_HiGHS.py` | Derselbe Fall in zwei Solvern | {ref:kap:praxisfallen} |
diff --git a/Operations_Research_mit_Python_Version_04/10_Einfuehrung_OR.md b/Operations_Research_mit_Python_Version_04/10_Einfuehrung_OR.md
index 026c930..78f1804 100644
--- a/Operations_Research_mit_Python_Version_04/10_Einfuehrung_OR.md
+++ b/Operations_Research_mit_Python_Version_04/10_Einfuehrung_OR.md
@@ -528,7 +528,8 @@ ausfüllen können — vor der ersten Codezeile.
 >   $4x_1 + 3x_2 \le 600$ (Ofen); $x_1 \ge 40$ (Vertrag).
 > * **Weiche Bedingungen:** keine.
 > 
-> Dieses Problem lösen Sie in Übung 1.5 selbst.
+> Dieses Problem lösen Sie in der Aufgabe *Die Bäckerei programmieren*
+> ({ref:sec:einfuehrung-uebungsaufgaben}) selbst.
 
 Die Vorlage lässt sich fast wörtlich in Code übersetzen — wer die fünf Zeilen ausgefüllt
 hat, hat den größten Teil der Modellierungsarbeit schon erledigt:
@@ -1142,7 +1143,7 @@ Ein Programm, das abstürzt, ist harmlos — Sie sehen sofort, dass etwas nicht
 Gefährlich sind Programme, die fehlerfrei durchlaufen, einen Status `OPTIMAL` melden und
 eine Zahl liefern, die betriebswirtschaftlich Unsinn ist. Genau solche Fälle üben wir hier.
 
-> **🐛 Finde den Denkfehler 1.1: Die Schreinerei verdoppelt ihren Gewinn**
+> **🐛 Finde den Denkfehler: Die Schreinerei verdoppelt ihren Gewinn**
 >
 > Eine Kollegin hat das Schreinerei-Modell aus dem Kapitelanfang leicht umgebaut — sie
 > fand die Schleife übersichtlicher als zwei einzelne `Add`-Aufrufe. Das Programm läuft,
@@ -1191,7 +1192,7 @@ eine Zahl liefern, die betriebswirtschaftlich Unsinn ist. Genau solche Fälle ü
 
 ## Micro-Quiz {#sec:einfuehrung-quiz}
 
-> **❓ Micro-Quiz 1: Drei Fragen zum Selbstcheck**
+> **❓ Micro-Quiz: Drei Fragen zum Selbstcheck**
 >
 > Genau eine Antwort ist jeweils richtig. Auflösung in
 > [Anhang A](90_Anhang_Loesungen.md#quiz-loesung-einfuehrung).
diff --git a/Operations_Research_mit_Python_Version_04/11_Mathematisches_Fundament.md b/Operations_Research_mit_Python_Version_04/11_Mathematisches_Fundament.md
index 1dcba80..516fc10 100644
--- a/Operations_Research_mit_Python_Version_04/11_Mathematisches_Fundament.md
+++ b/Operations_Research_mit_Python_Version_04/11_Mathematisches_Fundament.md
@@ -1243,7 +1243,7 @@ Prüfen Sie das Ergebnis und vergleichen Sie es mit dem Original.
 
 ## Finde den Denkfehler {#sec:fundament-denkfehler}
 
-> **🐛 Finde den Denkfehler 2.1: Die unauffällige Transposition**
+> **🐛 Finde den Denkfehler: Die unauffällige Transposition**
 >
 > Ein Kollege überträgt ein Produktionsmodell in Matrixform. Zwei Produkte, zwei
 > Ressourcen — die Technologiematrix ist quadratisch:
@@ -1288,7 +1288,7 @@ Prüfen Sie das Ergebnis und vergleichen Sie es mit dem Original.
 
 ## Micro-Quiz {#sec:fundament-quiz}
 
-> **❓ Micro-Quiz 2: Drei Fragen zum Selbstcheck**
+> **❓ Micro-Quiz: Drei Fragen zum Selbstcheck**
 >
 > Genau eine Antwort ist jeweils richtig. Auflösung in
 > [Anhang A](90_Anhang_Loesungen.md#quiz-loesung-fundament).
diff --git a/Operations_Research_mit_Python_Version_04/12_Python_Oekosystem.md b/Operations_Research_mit_Python_Version_04/12_Python_Oekosystem.md
index 4200158..0260121 100644
--- a/Operations_Research_mit_Python_Version_04/12_Python_Oekosystem.md
+++ b/Operations_Research_mit_Python_Version_04/12_Python_Oekosystem.md
@@ -308,6 +308,34 @@ $$
 > prüft `highspy` und `cvxpy` in der Paketübersicht nur auf Anwesenheit
 > (`importlib.util.find_spec`) und importiert CVXPY erst im Funktionstest.
 
+### Wie die Isolation aussieht, wenn sie tragen soll
+
+„Eigener Prozess" ist schnell gesagt. Die naheliegende Umsetzung — ein Codeschnipsel als
+Zeichenkette an `python -c` übergeben — funktioniert und ist trotzdem die schlechteste:
+Der Schnipsel ist für Editor, Linter und Testwerkzeug unsichtbar, ein Tippfehler darin
+fällt erst zur Laufzeit auf, und übergeben lassen sich nur Zeichenketten.
+
+Tragfähig ist stattdessen: **jeder Solver eine gewöhnliche Funktion mit lokalem Import**,
+ausgeführt von einem `ProcessPoolExecutor` mit zwei Einstellungen, die zusammen die
+Garantie ergeben:
+
+| Einstellung | Wozu |
+| --- | --- |
+| `mp_context=multiprocessing.get_context("spawn")` | Der Kindprozess startet mit einem **frischen** Interpreter, statt den Speicher des Elternprozesses zu erben. Unter Linux ist `fork` der Standard — und damit wäre alles, was hier schon importiert ist, auch dort importiert. |
+| `max_tasks_per_child=1` | Jede Aufgabe bekommt einen **neuen** Prozess. Ohne das verwendet der Pool seinen Arbeiter wieder, und beim zweiten Solver ist der Konflikt zurück. Genau dieser Fehler ist leicht zu machen und schwer zu finden. |
+
+> **⚠️ `max_tasks_per_child=1` ist nicht optional**
+> Ein Pool ohne diese Angabe ist der **Normalfall** — er soll seine Arbeiter ja
+> wiederverwenden. Wer die Isolation über einen Pool herstellt und das vergisst, hat einen
+> Prozesswechsel programmiert, aber keine Isolation gewonnen: Die zweite Aufgabe landet im
+> selben Interpreter wie die erste. Der Absturz kommt dann nicht beim ersten Solver,
+> sondern beim zweiten — und sieht aus wie ein Problem des zweiten.
+
+Denselben Aufbau verwenden `Solverwechsel_CPSAT_HiGHS.py` ({ref:kap:praxisfallen}) und
+`Benchmark_Skalierung.py` ({ref:kap:testing}). Dort wandern zusätzlich **Datenobjekte** über
+die Prozessgrenze statt Zeichenketten — möglich, weil Domänenmodell und Lösungs-DTO keinen
+Solver kennen ({ref:sec:praxisfallen-or-kern}).
+
 ```python
 #!/usr/bin/env python3
 
@@ -319,85 +347,104 @@ Kapitel Oekosystem: Dasselbe LP in vier Bibliotheken.
           2*x1 + 3*x2 + x3 <= 50
           x >= 0
 
-Deckt scipy.optimize, highspy, CVXPY und OR-Tools/GLOP ab, mit Kreuzvergleich am Ende.
+Deckt scipy.optimize, highspy, CVXPY und OR-Tools/GLOP ab, mit Kreuzvergleich
+am Ende.
 
-WICHTIG: Jeder Solver läuft in einem EIGENEN Prozess, weil sich ortools und
+WICHTIG: Jeder Solver laeuft in einem EIGENEN Prozess, weil sich ortools und
 highspy auf vielen Systemen nicht gemeinsam importieren lassen (beide bringen
 eine eigene HiGHS-Kopie mit -> Symbolkonflikt).
+
+Die Isolation besorgt ein ProcessPoolExecutor. Drei Einstellungen ergeben
+zusammen die Garantie:
+
+  mp_context "spawn"     Der Kindprozess startet mit einem FRISCHEN
+                         Interpreter, statt den Speicher des Elternprozesses
+                         zu erben. Was hier schon importiert ist, ist dort
+                         nicht importiert. Mit dem Standard "fork" auf Linux
+                         waere das nicht so.
+  max_tasks_per_child=1  Jede Aufgabe bekommt einen NEUEN Prozess. Ohne das
+                         wuerde der Pool seinen Arbeiter wiederverwenden - und
+                         beim zweiten Solver waere der Konflikt zurueck.
+  max_workers=1          Haelt die vier Laeufe nacheinander. Nicht aus
+                         Vorsicht, sondern damit die gemessenen Zeiten
+                         vergleichbar bleiben.
+
+Jeder Solver steht in einer eigenen Funktion mit LOKALEM Import. Das ist der
+Unterschied zu einem Codestring, den man an 'python -c' uebergibt: Die
+Funktion laesst sich einzeln aufrufen, testen und vom Editor pruefen - ein
+String nicht.
+
+Benoetigt: scipy, highspy, cvxpy, ortools
 """
 
-import json
-import subprocess
-import sys
-import textwrap
+import multiprocessing
 import time
+from concurrent.futures import ProcessPoolExecutor
 
 ERWARTET = 530.0            # Ergebnis der Handrechnung zum Produktionsprogramm
 
-# Jeder Eintrag ist ein eigenständiges Miniprogramm, das sein Ergebnis als
-# JSON auf stdout ausgibt. So bleibt jeder Import in seinem eigenen Prozess.
-ANSAETZE: dict[str, str] = {
+# Die Instanz - einmal notiert, von allen vier Funktionen benutzt.
+ZIEL = [10.0, 15.0, 25.0]
+MATRIX = [[1, 1, 2], [2, 3, 1]]
+KAPAZITAET = [40.0, 50.0]
 
-    "scipy.optimize.linprog": """
-        from scipy.optimize import linprog
-        res = linprog(c=[-10.0, -15.0, -25.0],           # linprog MINIMIERT -> negieren
-                      A_ub=[[1, 1, 2], [2, 3, 1]], b_ub=[40, 50],
-                      bounds=[(0, None)] * 3, method="highs")
-        ausgabe = (-res.fun, list(res.x))
-    """,
 
-    "highspy (natives HiGHS)": """
-        import numpy as np, highspy
-        h = highspy.Highs()
-        h.setOptionValue("output_flag", False)
-        h.addVars(3, np.zeros(3), np.full(3, highspy.kHighsInf))
-        h.changeObjectiveSense(highspy.ObjSense.kMaximize)
-        for j, wert in enumerate([10.0, 15.0, 25.0]):
-            h.changeColCost(j, wert)
-        # CSR-Format: starts[i] = Beginn von Zeile i in indices/values
-        h.addRows(2, np.full(2, -highspy.kHighsInf), np.array([40.0, 50.0]), 6,
-                  np.array([0, 3], dtype=np.int32),
-                  np.array([0, 1, 2, 0, 1, 2], dtype=np.int32),
-                  np.array([1.0, 1.0, 2.0, 2.0, 3.0, 1.0]))
-        h.run()
-        ausgabe = (h.getInfo().objective_function_value,
-                   list(h.getSolution().col_value[:3]))
-    """,
+def loese_mit_scipy() -> tuple[float, list[float]]:
+    from scipy.optimize import linprog
+    ergebnis = linprog(c=[-w for w in ZIEL],          # linprog MINIMIERT -> negieren
+                       A_ub=MATRIX, b_ub=KAPAZITAET,
+                       bounds=[(0, None)] * 3, method="highs")
+    return -ergebnis.fun, list(ergebnis.x)
 
-    "cvxpy": """
-        import numpy as np, cvxpy as cp
-        x = cp.Variable(3, nonneg=True)
-        problem = cp.Problem(cp.Maximize(np.array([10.0, 15.0, 25.0]) @ x),
-                             [np.array([[1, 1, 2], [2, 3, 1]]) @ x <= np.array([40, 50])])
-        problem.solve()
-        ausgabe = (float(problem.value), [float(v) for v in x.value])
-    """,
 
-    "ortools / GLOP": """
-        from ortools.linear_solver import pywraplp
-        s = pywraplp.Solver.CreateSolver("GLOP")
-        x = [s.NumVar(0, s.infinity(), f"x{j+1}") for j in range(3)]
-        A = [[1, 1, 2], [2, 3, 1]]
-        for i, kap in enumerate([40, 50]):
-            s.Add(sum(A[i][j] * x[j] for j in range(3)) <= kap)
-        s.Maximize(10 * x[0] + 15 * x[1] + 25 * x[2])
-        s.Solve()
-        ausgabe = (s.Objective().Value(), [v.solution_value() for v in x])
-    """,
+def loese_mit_highspy() -> tuple[float, list[float]]:
+    import highspy
+    import numpy as np
+    h = highspy.Highs()
+    h.setOptionValue("output_flag", False)
+    h.addVars(3, np.zeros(3), np.full(3, highspy.kHighsInf))
+    h.changeObjectiveSense(highspy.ObjSense.kMaximize)
+    for j, wert in enumerate(ZIEL):
+        h.changeColCost(j, wert)
+    # CSR-Format: starts[i] = Beginn von Zeile i in indices/values
+    h.addRows(2, np.full(2, -highspy.kHighsInf), np.array(KAPAZITAET), 6,
+              np.array([0, 3], dtype=np.int32),
+              np.array([0, 1, 2, 0, 1, 2], dtype=np.int32),
+              np.array([float(w) for zeile in MATRIX for w in zeile]))
+    h.run()
+    return (h.getInfo().objective_function_value,
+            list(h.getSolution().col_value[:3]))
+
+
+def loese_mit_cvxpy() -> tuple[float, list[float]]:
+    import cvxpy as cp
+    import numpy as np
+    x = cp.Variable(3, nonneg=True)
+    problem = cp.Problem(cp.Maximize(np.array(ZIEL) @ x),
+                         [np.array(MATRIX) @ x <= np.array(KAPAZITAET)])
+    problem.solve()
+    return float(problem.value), [float(v) for v in x.value]
+
+
+def loese_mit_ortools() -> tuple[float, list[float]]:
+    from ortools.linear_solver import pywraplp
+    s = pywraplp.Solver.CreateSolver("GLOP")
+    x = [s.NumVar(0, s.infinity(), f"x{j+1}") for j in range(3)]
+    for i, kapazitaet in enumerate(KAPAZITAET):
+        s.Add(sum(MATRIX[i][j] * x[j] for j in range(3)) <= kapazitaet)
+    s.Maximize(sum(ZIEL[j] * x[j] for j in range(3)))
+    s.Solve()
+    return s.Objective().Value(), [v.solution_value() for v in x]
+
+
+ANSAETZE = {
+    "scipy.optimize.linprog": loese_mit_scipy,
+    "highspy (natives HiGHS)": loese_mit_highspy,
+    "cvxpy": loese_mit_cvxpy,
+    "ortools / GLOP": loese_mit_ortools,
 }
 
 
-def fuehre_in_eigenem_prozess_aus(quelltext: str) -> tuple[float, list[float]]:
-    """Startet den Codeschnipsel als separaten Python-Prozess und liest das Ergebnis."""
-    programm = textwrap.dedent(quelltext) + "\nimport json; print(json.dumps(ausgabe))\n"
-    ergebnis = subprocess.run([sys.executable, "-c", programm],
-                              capture_output=True, text=True, timeout=120)
-    if ergebnis.returncode != 0:
-        raise RuntimeError(ergebnis.stderr.strip().splitlines()[-1])
-    wert, loesung = json.loads(ergebnis.stdout.strip().splitlines()[-1])
-    return wert, loesung
-
-
 if __name__ == "__main__":
     print("=" * 78)
     print("  EIN SYSTEM - VIER ANSAETZE (je eigener Prozess)")
@@ -406,17 +453,23 @@ if __name__ == "__main__":
     print("-" * 78)
 
     werte = []
-    for name, quelltext in ANSAETZE.items():
-        t0 = time.perf_counter()
-        try:
-            wert, x = fuehre_in_eigenem_prozess_aus(quelltext)
-        except RuntimeError as fehler:
-            print(f"{name:<26} nicht verfuegbar: {fehler[:40]}")
-            continue
-        dauer = time.perf_counter() - t0
-        werte.append(wert)
-        print(f"{name:<26} {wert:>10.2f} {x[0]:>7.2f} {x[1]:>7.2f} {x[2]:>7.2f} "
-              f"{dauer:>8.2f} s")
+    # Ein Pool, vier Aufgaben, vier frische Prozesse. Der Kontext muss
+    # "spawn" sein - siehe Modulkommentar.
+    with ProcessPoolExecutor(
+            max_workers=1,
+            mp_context=multiprocessing.get_context("spawn"),
+            max_tasks_per_child=1) as pool:
+        for name, funktion in ANSAETZE.items():
+            beginn = time.perf_counter()
+            try:
+                wert, x = pool.submit(funktion).result(timeout=120)
+            except Exception as fehler:                     # Bibliothek fehlt o. Ae.
+                print(f"{name:<26} nicht verfuegbar: {str(fehler)[:40]}")
+                continue
+            dauer = time.perf_counter() - beginn
+            werte.append(wert)
+            print(f"{name:<26} {wert:>10.2f} {x[0]:>7.2f} {x[1]:>7.2f} {x[2]:>7.2f} "
+                  f"{dauer:>8.2f} s")
 
     print("-" * 78)
     spanne = max(werte) - min(werte)
@@ -426,8 +479,8 @@ if __name__ == "__main__":
     assert spanne < 1e-6, "Die Bibliotheken widersprechen sich!"
     assert abs(werte[0] - ERWARTET) < 1e-6, "Ergebnis weicht von der Handrechnung ab!"
     print("Alle Wege fuehren zum selben, von Hand bestaetigten Optimum.")
-    print("(Die Zeiten enthalten den Prozessstart und den Import - sie messen")
-    print(" NICHT die reine Solverleistung, siehe Uebung 3.5.)")
+    print("(Die Zeiten enthalten Prozessstart und Import - sie messen NICHT die")
+    print(" reine Solverleistung. Die Uebungsaufgabe 'Laufzeitvergleich' trennt beides.)")
     print("=" * 78)
 ```
 
@@ -439,16 +492,16 @@ if __name__ == "__main__":
 ==============================================================================
 Bibliothek                         Z*      x1      x2      x3       Zeit
 ------------------------------------------------------------------------------
-scipy.optimize.linprog         530.00    0.00   12.00   14.00     0.55 s
-highspy (natives HiGHS)        530.00    0.00   12.00   14.00     0.17 s
-cvxpy                          530.00    0.00   12.00   14.00     1.52 s
-ortools / GLOP                 530.00    0.00   12.00   14.00     0.09 s
+scipy.optimize.linprog         530.00    0.00   12.00   14.00     0.59 s
+highspy (natives HiGHS)        530.00    0.00   12.00   14.00     0.12 s
+cvxpy                          530.00    0.00   12.00   14.00     1.24 s
+ortools / GLOP                 530.00    0.00   12.00   14.00     0.33 s
 ------------------------------------------------------------------------------
 Spannweite zwischen den Bibliotheken: 2.41e-08
 Abweichung zur Handrechnung (530):        0.00e+00
 Alle Wege fuehren zum selben, von Hand bestaetigten Optimum.
-(Die Zeiten enthalten den Prozessstart und den Import - sie messen
- NICHT die reine Solverleistung, siehe Uebung 3.5.)
+(Die Zeiten enthalten Prozessstart und Import - sie messen NICHT die
+ reine Solverleistung. Die Uebungsaufgabe 'Laufzeitvergleich' trennt beides.)
 ==============================================================================
 ```
 
@@ -1162,7 +1215,7 @@ passende Empfehlungen.
 
 ## Finde den Denkfehler {#sec:oekosystem-denkfehler}
 
-> **🐛 Finde den Denkfehler 3.1: Der Solver, der angeblich dreimal schneller ist**
+> **🐛 Finde den Denkfehler: Der Solver, der angeblich dreimal schneller ist**
 >
 > Ein Team vergleicht zwei Bibliotheken für sein Zuordnungsproblem und schreibt ins
 > Protokoll: *„CVXPY braucht 1,9 s, SciPy nur 0,6 s — wir setzen auf SciPy.“* Gemessen
@@ -1199,7 +1252,7 @@ passende Empfehlungen.
 
 ## Micro-Quiz {#sec:oekosystem-quiz}
 
-> **❓ Micro-Quiz 3: Drei Fragen zum Selbstcheck**
+> **❓ Micro-Quiz: Drei Fragen zum Selbstcheck**
 >
 > Genau eine Antwort ist jeweils richtig. Auflösung in
 > [Anhang A](90_Anhang_Loesungen.md#quiz-loesung-oekosystem).
@@ -1264,4 +1317,4 @@ Schattenpreise kommen — und was sie wirtschaftlich bedeuten.
 
 ---
 
-*Weiter mit:* [{ref:kap:lp} — Lineare Programmierung](20_Lineare_Programmierung.md)
+*Weiter mit:* [{ref:kap:modellierung} — Vom Management-Wunsch zum Modell](13_Vom_Wunsch_zum_Modell.md)
diff --git a/Operations_Research_mit_Python_Version_04/13_Vom_Wunsch_zum_Modell.md b/Operations_Research_mit_Python_Version_04/13_Vom_Wunsch_zum_Modell.md
index ce0e324..abd57ab 100644
--- a/Operations_Research_mit_Python_Version_04/13_Vom_Wunsch_zum_Modell.md
+++ b/Operations_Research_mit_Python_Version_04/13_Vom_Wunsch_zum_Modell.md
@@ -99,6 +99,9 @@ Nach diesem Kapitel können Sie …
 4. … begründen, wann eine Regel hart und wann sie weich sein muss — und was eine harte Regel
    im Betrieb anrichtet, wenn sie einmal nicht erfüllbar ist.
 5. … einen Kennzahlen-Fehlanreiz benennen, bevor er in die Zielfunktion gerät.
+6. … einen Satz aus einer Besprechung in den passenden Modellierungsbaustein
+   übersetzen — und die fünf Wendungen erkennen, bei denen genau das nicht geht,
+   ohne vorher nachzufragen.
 
 ---
 
@@ -614,6 +617,75 @@ stellt, bevor eine Zeile Code entsteht:
 
 ---
 
+## Deutsch — OR: ein Übersetzungslexikon {#sec:modellierung-glossar}
+
+Die zwölf Fragen liefern Sätze. Sätze sind noch kein Modell — aber die meisten von ihnen
+haben eine **Standardübersetzung**, und wer sie kennt, spart sich das Nachdenken für die
+Fälle, in denen es keine gibt.
+
+Die Tabelle liest sich von links nach rechts: Was in der Besprechung **gesagt** wird, was
+es **bedeutet**, und welcher **Baustein** daraus wird. Die B-Nummern verweisen auf
+{ref:anhang:modellierungsmuster}, wo jedes Muster mit Formulierung und Code steht.
+
+| Was gesagt wird | Was gemeint ist | Baustein |
+| --- | --- | --- |
+| „Wir haben nur 400 Stunden." | eine Obergrenze, die nicht überschritten werden darf | harte Kapazitätsgrenze $\le b$ ({ref:kap:lp}) |
+| „Mehr als zwei Millionen gibt es nicht." | dasselbe, auf Geld | Budgetlimit (B27) |
+| „Möglichst nicht über 40 Stunden." | eine Grenze, die im Notfall gebrochen werden darf | weiche Grenze mit Strafkosten (B8) |
+| „Wir können nur ganze Kisten liefern." | die Menge ist nicht teilbar | Ganzzahligkeitsbedingung ({ref:kap:milp}) |
+| „Wenn wir die Anlage nutzen, fallen Fixkosten an." | Kosten, die erst ab der ersten Einheit anfallen | Aktivierungsschalter (B1) |
+| „Entweder gar nicht oder mindestens 50." | kein Betrieb im Kleinen | semikontinuierliche Variable (B2) |
+| „Wenn wir A bauen, brauchen wir auch B." | eine Folgeverpflichtung | Implikation (B3) |
+| „Höchstens drei Positionen im Depot." | eine Obergrenze auf die **Anzahl**, nicht die Menge | Kardinalität (B6) |
+| „Der Anteil muss mindestens 30 % betragen." | eine Bedingung auf ein **Verhältnis** | Verhältnis-Bedingung (B12) |
+| „Jeder Auftrag genau einem Mitarbeiter." | eine vollständige, eindeutige Zuordnung | Zuordnung 1:1 (B23) |
+| „Eine Maschine kann nur eines gleichzeitig." | zeitliche Ausschließlichkeit | Nichtüberlappung (B14) |
+| „B kann erst nach A." | eine Reihenfolge | Vorrangbeziehung (B13) |
+| „Höchstens fünf Tage am Stück." | eine Bedingung über ein **gleitendes Fenster** | gleitendes Fenster (B16) |
+| „Umstellen kostet uns eine halbe Stunde." | reihenfolgeabhängige Kosten | Umrüstkosten (B17), Rüstzeit als Kapazität (B26) |
+| „Was reinkommt, muss auch wieder raus." | Erhaltung an jedem Knoten | Flusserhaltung (B22) |
+| „Notfalls brechen wir die Regel." | die Bedingung ist weich, aber teuer | Schlupfvariablen (B18) |
+| „Erst Termintreue, dann Kosten." | eine Rangfolge zwischen Zielen | hierarchische Ziele (B19) |
+| „Es soll gerecht zugehen." | den Schlechtestgestellten verbessern | Min/Max in der Zielfunktion (B11) |
+| „Was brächte uns eine zusätzliche Stunde?" | die Frage nach dem Grenzwert einer Ressource | Schattenpreis ({ref:kap:lp}, {ref:sec:praxisfallen-attribution}) |
+| „Mit 95 % Sicherheit muss es halten." | eine Zusage auf eine **Quote**, nicht auf einen Mittelwert | Chance Constraint ({ref:sec:unsicherheit-chance-constraints}) |
+| „Wir sichern uns gegen Schätzfehler ab." | gegen die ungünstigste Parameterlage planen | Worst-Case-Abzug (B21) |
+
+### Fünf Wendungen, bei denen die Übersetzung eine Entscheidung erzwingt
+
+Die Tabelle oben tut so, als sei die Zuordnung eindeutig. Bei den folgenden fünf ist sie es
+nicht — und **das Nachfragen ist die eigentliche Modellierungsarbeit**:
+
+| Wendung | Die Frage, die dahinter steckt |
+| --- | --- |
+| **„möglichst"** | Hart oder weich? Und wenn weich: Was darf ein Verstoß kosten? Ohne Zahl ist „möglichst" keine Bedingung, sondern eine Stimmung. |
+| **„nicht mehr als drei pro Woche"** | Je Person oder über alle zusammen? Kalenderwoche oder gleitende sieben Tage? Beide Lesarten sind vertretbar und ergeben verschiedene Modelle. |
+| **„im Durchschnitt"** | Fast immer eine Falle. Der Durchschnittskunde kauft nie — siehe {ref:sec:unsicherheit-der-fluch-des-durchschnitts}. Gemeint ist meist ein Quantil („in 9 von 10 Fällen"). |
+| **„so schnell wie möglich"** | Welche Zahl? Ende des letzten Auftrags, Summe aller Fertigstellungszeiten oder größte Verspätung? Drei Zielfunktionen, drei verschiedene Pläne. |
+| **„fair"** | Den Schlechtesten verbessern, die Spannweite verkleinern oder gleiche Anteile erzwingen? Erst die Wahl macht daraus ein Modell — und sie gehört dem Betrieb, nicht dem Modellierer. |
+
+> **🎯 Der Nutzen dieser Liste**
+> Sie ersetzt kein Nachdenken. Sie sorgt dafür, dass das Nachdenken an den **richtigen** vier
+> oder fünf Stellen stattfindet, statt an allen zwanzig gleichzeitig.
+
+### Und die Gegenrichtung: OR — Deutsch
+
+Dieselbe Barriere gibt es rückwärts. Diese Sätze haben sich bewährt, wenn ein Ergebnis
+jemandem erklärt werden muss, der das Modell nicht kennt:
+
+| Fachbegriff | Was Sie in der Besprechung sagen |
+| --- | --- |
+| Schattenpreis / Dualwert | „Die nächste Stunde auf dieser Maschine wäre uns 9 € wert." |
+| bindende Bedingung mit Dualwert 0 | „Die Regel berührt den Plan, kostet uns aber nichts — dort zu verhandeln bringt nichts." |
+| `INFEASIBLE` | „Ihre Regeln widersprechen sich." **Nicht:** „Der Computer schafft es nicht." |
+| Optimalitätslücke von 2 % | „Besser als das hier geht es höchstens um 2 % — und die liegen unter unserer Datenungenauigkeit." |
+| CVaR | „Wenn es schiefgeht, verlieren wir im Mittel so viel." (Der VaR sagt nur, **ob** es schiefgeht.) |
+| EVPI | „Selbst eine perfekte Prognose wäre uns höchstens so viel wert." |
+| Relaxation | „Wir haben die Regel probeweise gelockert, um zu sehen, was sie kostet." |
+| Chance Constraint | „Der Plan hält in 95 von 100 Fällen — und der nächste Prozentpunkt kostet …" |
+
+---
+
 ## Übungsaufgaben {#sec:modellierung-uebungsaufgaben}
 
 > Lösungen: {ref:sec:loesungen-modellierung}.
@@ -637,6 +709,16 @@ Maximieren Sie $\text{DB} + \lambda \cdot \text{Umsatz}$ für $\lambda \in \{0;
 und tragen Sie die Ergebnisse als Tabelle auf. Ab welchem $\lambda$ kippt der Plan von der
 DB- in die Umsatzlösung? Was sagt dieser Wert dem Betrieb?
 
+**Aufgabe ⭐⭐ — Übersetzen, wo es nicht eindeutig ist.**
+Übersetzen Sie mit {ref:sec:modellierung-glossar}:
+(a) „Die Monteure sollen möglichst gleichmäßig ausgelastet sein." Nennen Sie **drei**
+    Zielfunktionen, die alle „gleichmäßig" bedeuten können, und je einen Fall, in dem die
+    Wahl den Plan sichtbar ändert.
+(b) „Kein Kunde darf länger als drei Tage warten." Formulieren Sie die Bedingung einmal
+    hart und einmal weich. Welche Frage müssen Sie dem Betrieb stellen, um zu entscheiden?
+(c) Suchen Sie in einer echten Anforderung aus Ihrem Umfeld einen Satz, der nach der
+    Tabelle eindeutig aussieht, es aber nicht ist.
+
 **Aufgabe ⭐⭐⭐ — Die Anforderung schreiben.**
 Formulieren Sie für den Fall dieses Kapitels eine vollständige, prüfbare Anforderung: Ziel,
 harte Regeln, weiche Regeln mit Strafgewichten, Verhalten bei Unlösbarkeit, auszuweisende
@@ -720,6 +802,14 @@ Kennzahlen. Zwei Seiten genügen — sie sind mehr wert als zwei Wochen Programm
 * **Hart ist nur, was rechtlich oder physikalisch unmöglich ist.** Eine harte Regel ist eine
   weiche mit hinreichend großer Strafe; der Unterschied zeigt sich erst, wenn sie einmal
   nicht erfüllbar ist — dann liefert die harte Variante gar nichts mehr.
+* **Die meisten Sätze haben eine Standardübersetzung** — das Lexikon in
+  {ref:sec:modellierung-glossar} nennt sie. Sein Wert liegt aber in den fünf Wendungen, bei
+  denen es keine gibt: „möglichst", „nicht mehr als", „im Durchschnitt", „so schnell wie
+  möglich", „fair". Dort ist Nachfragen die Modellierungsarbeit.
 * Die vier Fragen — worüber wird entschieden, woran gemessen, was ist unverhandelbar, was
   bei Unlösbarkeit — gehören in die erste Besprechung. Der Leitfaden in
   {ref:sec:modellierung-leitfaden} macht zwölf daraus.
+
+---
+
+*Weiter mit:* [Synthese Teil I](19_Synthese_Grundlagen.md)
diff --git a/Operations_Research_mit_Python_Version_04/19_Synthese_Grundlagen.md b/Operations_Research_mit_Python_Version_04/19_Synthese_Grundlagen.md
new file mode 100644
index 0000000..47dd085
--- /dev/null
+++ b/Operations_Research_mit_Python_Version_04/19_Synthese_Grundlagen.md
@@ -0,0 +1,44 @@
+# Synthese Teil I — Grundlagen auf einen Blick
+
+Vier Kapitel, eine Frage: **Was muss vorliegen, bevor ein Solver überhaupt sinnvoll
+gestartet werden kann?** Die Antwort ist unbequem, weil das meiste davon nichts mit
+Programmieren zu tun hat.
+
+## Was welches Kapitel klärt
+
+| Frage | Kapitel | Was Sie danach können |
+| --- | --- | --- |
+| Was ist überhaupt ein Optimierungsmodell? | {ref:kap:einfuehrung} | Die vier Bausteine benennen — Variablen, Zielfunktion, Nebenbedingungen, Daten — und sie in einem fremden Problem wiedererkennen |
+| Warum rechnet der Solver falsch, obwohl das Modell stimmt? | {ref:kap:fundament} | Konvexität beurteilen, den zulässigen Bereich als Polyeder sehen, schlechte Konditionierung erkennen und beheben |
+| Welche Bibliothek, und warum vertragen sie sich nicht? | {ref:kap:oekosystem} | Solver, Bindings und Modellierungsschichten unterscheiden — und den HiGHS-Symbolkonflikt zwischen `ortools` und `highspy` umgehen |
+| Wie wird aus einem Satz ein Modell? | {ref:kap:modellierung} | Die vier Fragen stellen, harte von weichen Regeln trennen, einen Besprechungssatz übersetzen ({ref:sec:modellierung-glossar}) |
+
+## Die Reihenfolge ist die Aussage
+
+Dieser Teil steht bewusst **vor** den Verfahren. Die drei häufigsten Gründe, aus denen ein
+OR-Projekt scheitert, liegen alle hier — und keiner davon ist ein Solverproblem:
+
+1. **Die falsche Zielgröße.** Sie ist die folgenreichste Entscheidung des ganzen Projekts,
+   und sie wird meist in den ersten zehn Minuten nebenbei getroffen. Auslastung ist ein
+   Ergebnis, kein Ziel; „Umsatz" wird gesagt, wenn „Deckungsbeitrag" gemeint ist.
+2. **Zu viele harte Regeln.** Jede unnötig harte Bedingung ist eine Zeitbombe: Irgendwann
+   ist sie nicht erfüllbar, und das System antwortet gar nicht mehr. Hart ist nur, was
+   rechtlich oder physikalisch unmöglich ist.
+3. **Ein Satz, der mehrere Lesarten hat.** „Stammkunden dürfen wir nicht verlieren" lässt
+   sich auf mindestens drei Arten modellieren, und keine ist aus dem Satz ableitbar. Die
+   Wahl trifft man — im Zweifel unbewusst.
+
+## Wenn Sie nur eines mitnehmen
+
+> **🎯** Ein Modell rechnet aus, was **aufgeschrieben** wurde, nicht was gemeint war. Die
+> Arbeit, die darüber entscheidet, ob am Ende etwas Brauchbares herauskommt, findet vor der
+> ersten Zeile Code statt — und sie besteht aus Fragen an andere Menschen, nicht aus
+> Mathematik.
+
+**Vor {ref:teil:kernverfahren}** sollten Sie an einem eigenen Beispiel die vier Fragen aus
+{ref:sec:modellierung-vier-fragen} durchgespielt haben. Ohne das bleiben die Verfahren
+Technik ohne Anwendung.
+
+---
+
+*Weiter mit:* [{ref:kap:lp} — Lineare Programmierung](20_Lineare_Programmierung.md)
diff --git a/Operations_Research_mit_Python_Version_04/20_Lineare_Programmierung.md b/Operations_Research_mit_Python_Version_04/20_Lineare_Programmierung.md
index 880d384..4d4f026 100644
--- a/Operations_Research_mit_Python_Version_04/20_Lineare_Programmierung.md
+++ b/Operations_Research_mit_Python_Version_04/20_Lineare_Programmierung.md
@@ -933,7 +933,8 @@ Deckungsbeitrag, also 15,33 € Reingewinn.
 > Kapazität. Kauft man 200 Prüfstunden zu, wird irgendwann eine andere Ressource zum
 > Engpass, und der Schattenpreis springt auf einen neuen Wert (oder auf null). Wer große
 > Kapazitätsänderungen bewerten will, muss das Modell **neu rechnen** — nicht linear
-> hochrechnen. Übung 4.6 macht diesen Effekt sichtbar.
+> hochrechnen. Die Aufgabe *Gültigkeitsbereich des Schattenpreises*
+> ({ref:sec:lp-uebungsaufgaben}) macht diesen Effekt sichtbar.
 
 ---
 
@@ -1317,7 +1318,7 @@ $$\max\ 3x_1+2x_2 \quad\text{u. d. N.}\quad x_1+x_2 \ge 4,\quad x_1+3x_2 \le 12,
 
 ## Finde den Denkfehler {#sec:lp-denkfehler}
 
-> **🐛 Finde den Denkfehler 4.1: Die 380 000-Euro-Maschine**
+> **🐛 Finde den Denkfehler: Die 380 000-Euro-Maschine**
 >
 > Ein Werksleiter lässt die Engpässe seiner Fertigung analysieren. Das Skript liefert
 > für den Lackierofen einen Schattenpreis von **50 €/Stunde**. Er rechnet:
@@ -1356,7 +1357,7 @@ $$\max\ 3x_1+2x_2 \quad\text{u. d. N.}\quad x_1+x_2 \ge 4,\quad x_1+3x_2 \le 12,
 
 ## Micro-Quiz {#sec:lp-quiz}
 
-> **❓ Micro-Quiz 4: Drei Fragen zum Selbstcheck**
+> **❓ Micro-Quiz: Drei Fragen zum Selbstcheck**
 >
 > Genau eine Antwort ist jeweils richtig. Auflösung in
 > [Anhang A](90_Anhang_Loesungen.md#quiz-loesung-lp).
diff --git a/Operations_Research_mit_Python_Version_04/21_MILP.md b/Operations_Research_mit_Python_Version_04/21_MILP.md
index 24d3840..020fbf8 100644
--- a/Operations_Research_mit_Python_Version_04/21_MILP.md
+++ b/Operations_Research_mit_Python_Version_04/21_MILP.md
@@ -1308,7 +1308,8 @@ def loese(dauer: np.ndarray, n_maschinen: int, zeitlimit: float,
 
     loeser = cp_model.CpSolver()
     loeser.parameters.max_time_in_seconds = zeitlimit
-    # Ein Arbeiter und fester Startwert, damit die Messung reproduzierbar ist.
+    # Ein Arbeiter und fester Startwert, damit die Messung reproduzierbar ist -
+    # der Seed allein genuegt dafuer NICHT (Kapitel Constraint Programming).
     # Im Produktivbetrieb laesst man beides auf den Standardwerten.
     loeser.parameters.num_workers = 1
     loeser.parameters.random_seed = 1
@@ -1471,7 +1472,7 @@ eröffnete Lager hat Kapazität 80. Minimieren Sie Fix- plus Transportkosten.
 Die Warnung „$M$ so klein wie möglich“ wird meist mit der Laufzeit begründet: schwache
 Relaxation, mehr Knoten. Das stimmt — und ist die **harmlosere** Hälfte der Wahrheit.
 
-> **🐛 Finde den Denkfehler 5.1: Elf Lager, die keine Fixkosten kosten**
+> **🐛 Finde den Denkfehler: Elf Lager, die keine Fixkosten kosten**
 >
 > Ein Team plant Standorte: 12 mögliche Lager, 40 Kunden, Fixkosten je eröffnetem Lager.
 > Für das Big-M in der Kopplung
@@ -1758,7 +1759,7 @@ funktioniert immer.
 
 ## Micro-Quiz {#sec:milp-quiz}
 
-> **❓ Micro-Quiz 5: Drei Fragen zum Selbstcheck**
+> **❓ Micro-Quiz: Drei Fragen zum Selbstcheck**
 >
 > Genau eine Antwort ist jeweils richtig. Auflösung in
 > [Anhang A](90_Anhang_Loesungen.md#quiz-loesung-milp).
diff --git a/Operations_Research_mit_Python_Version_04/22_CP_SAT.md b/Operations_Research_mit_Python_Version_04/22_CP_SAT.md
index 521ecb0..2bef0e2 100644
--- a/Operations_Research_mit_Python_Version_04/22_CP_SAT.md
+++ b/Operations_Research_mit_Python_Version_04/22_CP_SAT.md
@@ -18,6 +18,7 @@
 > `Propagation_Demo.py`\
 > `CP_SAT_Vertretungssystem.py`\
 > `JobShop_Intervalle.py`\
+> `Parallele_Suche.py`\
 > `CP_SAT_Statusfaelle.py`\
 > `Strafgewichte.py`
 
@@ -101,7 +102,9 @@ Nach diesem Kapitel können Sie …
 6. … die fünf CP-SAT-Statusfälle unterscheiden — insbesondere `INFEASIBLE` (es gibt keine
    Lösung) von `UNKNOWN` (es wurde keine gefunden) und `MODEL_INVALID` (Ihr Code ist
    fehlerhaft).
-7. … begründen, warum ein Strafgewicht ein **Wechselkurs** ist, und welche Regeln deshalb
+7. … begründen, warum `num_workers = 1` für einen reproduzierbaren Lauf nötig ist und ein
+   fester `random_seed` allein nicht genügt — und was ein Test deshalb prüfen darf.
+8. … begründen, warum ein Strafgewicht ein **Wechselkurs** ist, und welche Regeln deshalb
    niemals in die Zielfunktion gehören.
 
 ---
@@ -794,6 +797,9 @@ Zusammenspiel von Reihenfolge- und Maschinenbedingungen, nicht aus einer schlech
 > abgedruckte Ausgabe reproduzierbar. **Im Produktivbetrieb lässt man beides weg** — mehrere
 > Arbeiter sind deutlich schneller.
 >
+> Wie viel schneller, und warum der Seed allein **nicht** genügt, misst
+> {ref:sec:cpsat-parallele-suche} an genau diesem Modell.
+>
 > Die Lehre für Ihre eigenen Tests: Prüfen Sie bei mehrdeutigen Optima nie auf einen
 > **bestimmten Plan**, sondern immer auf den **Zielwert** und auf die Einhaltung aller
 > Regeln. Ein Test wie `assert plan == erwarteter_plan` besteht sonst mal und scheitert mal,
@@ -817,6 +823,336 @@ theoretischen Ideal entfernt sein können, noch bevor der Solver fertig war.
 
 ---
 
+## Parallele Suche: was `num_workers` wirklich bewirkt {#sec:cpsat-parallele-suche}
+
+An mehreren Stellen dieses Buchs steht `loeser.parameters.num_workers = 1`, mit dem
+Kommentar „für eine reproduzierbare Ausgabe“. Darin stecken zwei Behauptungen: dass
+parallele Suche **schneller** ist, und dass sie **von Lauf zu Lauf andere, gleich gute**
+Lösungen liefert. Beides lässt sich messen — und beim Messen kommt mehr heraus als erwartet.
+
+Gerechnet wird auf demselben Modell wie
+{ref:sec:cpsat-intervallvariablen-job-shop-scheduling}, nur groß genug, dass die Suche
+wirklich arbeitet: 12 Aufträge auf 10 Maschinen, jeder Auftrag besucht jede Maschine.
+Entscheidend ist, dass `random_seed` in **jedem** Lauf denselben Wert hat.
+
+```python
+#!/usr/bin/env python3
+
+# Parallele_Suche.py
+"""
+Kapitel CP-SAT: Was mehrere Arbeiter wirklich bringen - und was sie kosten.
+
+Das Buch setzt an mehreren Stellen 'num_workers = 1', damit die abgedruckte
+Ausgabe reproduzierbar ist. Behauptet wird dabei zweierlei: dass parallele
+Suche schneller ist, und dass sie von Lauf zu Lauf verschiedene, gleich gute
+Loesungen findet. Beides wird hier gemessen statt geglaubt.
+
+Gerechnet wird auf einem Job-Shop wie in JobShop_Intervalle.py, nur gross
+genug, dass die Suche wirklich arbeitet: 12 Auftraege auf 10 Maschinen,
+jeder Auftrag besucht jede Maschine.
+
+Zwei Messungen:
+  1. Dieselbe Aufgabe mit 1, 2, 4 und 8 Arbeitern - Laufzeit und Ergebnis.
+  2. Dieselbe Konfiguration mehrfach, bei FESTEM random_seed - wie oft kommt
+     derselbe Plan heraus?
+
+Die zweite ist die wichtigere: Sie entscheidet, wie man Tests schreibt.
+
+Achtung, Laufzeiten sind hardwareabhaengig. Die ZAHL der verschiedenen
+Plaene ist es auch - und genau das ist die Aussage.
+
+Benoetigt: numpy, ortools
+"""
+
+from __future__ import annotations
+
+import collections
+import time
+
+import numpy as np
+from ortools.sat.python import cp_model
+
+AUFTRAEGE = 12
+MASCHINEN = 10
+INSTANZ_SEED = 20260908
+SOLVER_SEED = 1          # bleibt ueber ALLE Laeufe gleich - das ist der Punkt
+ARBEITERZAHLEN = (1, 2, 4, 8)
+WIEDERHOLUNGEN = 4
+ZEITLIMIT = 120.0
+
+
+def baue_instanz() -> list[list[tuple[int, int]]]:
+    """Klassischer Job-Shop: Jeder Auftrag besucht jede Maschine genau einmal,
+    in einer eigenen zufaelligen Reihenfolge."""
+    rng = np.random.default_rng(INSTANZ_SEED)
+    return [[(int(m), int(rng.integers(2, 20))) for m in rng.permutation(MASCHINEN)]
+            for _ in range(AUFTRAEGE)]
+
+
+def loese(auftraege, arbeiter: int):
+    """Minimiert den Makespan. Gibt Status, Zielwert, Laufzeit und den Plan
+    zurueck - den Plan als Tupel aller Startzeiten, damit sich zwei Laeufe
+    vergleichen lassen."""
+    horizont = sum(dauer for auftrag in auftraege for _, dauer in auftrag)
+    modell = cp_model.CpModel()
+    Gang = collections.namedtuple("Gang", "start ende intervall")
+    plaene: dict[tuple[int, int], Gang] = {}
+    je_maschine = collections.defaultdict(list)
+
+    for a, auftrag in enumerate(auftraege):
+        for g, (maschine, dauer) in enumerate(auftrag):
+            start = modell.NewIntVar(0, horizont, f"start_{a}_{g}")
+            ende = modell.NewIntVar(0, horizont, f"ende_{a}_{g}")
+            intervall = modell.NewIntervalVar(start, dauer, ende, f"iv_{a}_{g}")
+            plaene[a, g] = Gang(start, ende, intervall)
+            je_maschine[maschine].append(intervall)
+
+    for maschine in range(MASCHINEN):
+        modell.AddNoOverlap(je_maschine[maschine])
+    for a, auftrag in enumerate(auftraege):
+        for g in range(len(auftrag) - 1):
+            modell.Add(plaene[a, g + 1].start >= plaene[a, g].ende)
+
+    makespan = modell.NewIntVar(0, horizont, "makespan")
+    modell.AddMaxEquality(
+        makespan, [plaene[a, len(auftrag) - 1].ende
+                   for a, auftrag in enumerate(auftraege)])
+    modell.Minimize(makespan)
+
+    loeser = cp_model.CpSolver()
+    loeser.parameters.num_workers = arbeiter
+    loeser.parameters.random_seed = SOLVER_SEED
+    loeser.parameters.max_time_in_seconds = ZEITLIMIT
+
+    beginn = time.perf_counter()
+    status = loeser.Solve(modell)
+    dauer = time.perf_counter() - beginn
+
+    if status not in (cp_model.OPTIMAL, cp_model.FEASIBLE):
+        return loeser.StatusName(status), None, dauer, None
+    plan = tuple(loeser.Value(plaene[a, g].start)
+                 for a, auftrag in enumerate(auftraege)
+                 for g in range(len(auftrag)))
+    return loeser.StatusName(status), int(loeser.ObjectiveValue()), dauer, plan
+
+
+if __name__ == "__main__":
+    auftraege = baue_instanz()
+    gaenge = sum(len(a) for a in auftraege)
+
+    print("=" * 78)
+    print("  WAS MEHRERE ARBEITER WIRKLICH BRINGEN")
+    print("=" * 78)
+    print(f"Job-Shop: {AUFTRAEGE} Auftraege, {MASCHINEN} Maschinen, "
+          f"{gaenge} Arbeitsgaenge.")
+    print(f"random_seed = {SOLVER_SEED} in JEDEM Lauf, "
+          f"{WIEDERHOLUNGEN} Wiederholungen je Arbeiterzahl.\n")
+
+    # Jede Konfiguration mehrfach - ein einzelner Zeitwert sagt nichts.
+    ergebnisse: dict[int, list[tuple]] = {}
+    for arbeiter in ARBEITERZAHLEN:
+        ergebnisse[arbeiter] = [loese(auftraege, arbeiter)
+                                for _ in range(WIEDERHOLUNGEN)]
+
+    print("=" * 78)
+    print("  (1) Laufzeit: was die Arbeiter bringen")
+    print("=" * 78)
+    print(f"{'Arbeiter':>9} {'Status':>9} {'Makespan':>9} "
+          f"{'schnellste':>11} {'langsamste':>11} {'Beschleunigung':>15}")
+    print("-" * 78)
+    basis_zeit = min(d for _, _, d, _ in ergebnisse[1])
+    for arbeiter in ARBEITERZAHLEN:
+        laeufe = ergebnisse[arbeiter]
+        zeiten = [d for _, _, d, _ in laeufe]
+        ziele = {o for _, o, _, _ in laeufe}
+        status = {s for s, _, _, _ in laeufe}
+        print(f"{arbeiter:>9} {'/'.join(sorted(status)):>9} "
+              f"{'/'.join(str(z) for z in sorted(ziele)):>9} "
+              f"{min(zeiten):>10.2f}s {max(zeiten):>10.2f}s "
+              f"{basis_zeit / min(zeiten):>14.1f}x")
+
+    beste = min(ARBEITERZAHLEN, key=lambda w: min(d for _, _, d, _ in ergebnisse[w]))
+    faktor = basis_zeit / min(d for _, _, d, _ in ergebnisse[beste])
+    print(f"\n  Am schnellsten sind {beste} Arbeiter: Faktor {faktor:.1f} gegenueber")
+    print(f"  einem einzigen - also MEHR, als {beste} Kerne hergeben sollten.")
+    print(f"  Das ist kein Messfehler. CP-SAT laesst nicht {beste}-mal dieselbe Suche")
+    print("  laufen, sondern verschiedene Strategien nebeneinander, die einander")
+    print("  ihre Schranken zurufen. Der zweite Arbeiter ist deshalb nicht der")
+    print("  'zweite Kern', sondern ein anderes Verfahren.")
+    letzte = ARBEITERZAHLEN[-1]
+    if beste != letzte:
+        zeit_letzte = min(d for _, _, d, _ in ergebnisse[letzte])
+        print(f"\n  Und mehr ist nicht immer besser: {letzte} Arbeiter brauchen "
+              f"{zeit_letzte:.2f}s")
+        print(f"  gegenueber {min(d for _, _, d, _ in ergebnisse[beste]):.2f}s bei "
+              f"{beste}. Ab einer gewissen Zahl kosten Abstimmung")
+        print("  und Speicherbandbreite mehr, als ein weiterer Suchstrang einbringt.")
+
+    print("\n" + "=" * 78)
+    print("  (2) Reproduzierbarkeit: derselbe Seed, derselbe Plan?")
+    print("=" * 78)
+    print(f"{'Arbeiter':>9} {'Laeufe':>7} {'verschiedene Plaene':>21} "
+          f"{'Makespan':>10}")
+    print("-" * 78)
+    for arbeiter in ARBEITERZAHLEN:
+        plaene = {p for _, _, _, p in ergebnisse[arbeiter] if p is not None}
+        ziele = {o for _, o, _, _ in ergebnisse[arbeiter]}
+        print(f"{arbeiter:>9} {WIEDERHOLUNGEN:>7} {len(plaene):>21} "
+              f"{'/'.join(str(z) for z in sorted(ziele)):>10}")
+
+    einer = len({p for _, _, _, p in ergebnisse[1]})
+    # Ab welcher Arbeiterzahl bricht die Reproduzierbarkeit? Das ist die
+    # eigentliche Zahl - nicht, was acht Arbeiter anrichten.
+    ab = next((w for w in ARBEITERZAHLEN
+               if len({p for _, _, _, p in ergebnisse[w]}) > 1), None)
+    print(f"\n  Mit einem Arbeiter: {einer} Plan aus {WIEDERHOLUNGEN} Laeufen.")
+    if ab is not None:
+        viele = len({p for _, _, _, p in ergebnisse[ab]})
+        print(f"  Schon mit {ab} Arbeitern: {viele} verschiedene Plaene aus "
+              f"{WIEDERHOLUNGEN} Laeufen -")
+        print("  bei identischem random_seed und identischem Zielwert.")
+        print(f"  Es braucht also keine acht Arbeiter, um die Reproduzierbarkeit")
+        print(f"  zu verlieren. {ab} genuegen.")
+    print("\n  Der Seed allein macht einen Lauf also NICHT reproduzierbar. Er legt")
+    print("  fest, wie ein einzelner Suchstrang wuerfelt - nicht, welcher von")
+    print("  mehreren zuerst fertig wird. Das entscheidet die Uhr.")
+
+    print("\n" + "=" * 78)
+    print("  (3) Was daraus fuer Tests folgt")
+    print("=" * 78)
+    print("  Ein Test der Form  assert plan == erwarteter_plan  besteht mal und")
+    print("  scheitert mal, ohne dass sich am Code etwas geaendert haette.")
+    print("  Zu pruefen sind stattdessen:")
+    print("    * der ZIELWERT (hier in allen Laeufen gleich),")
+    print("    * die Einhaltung aller Regeln (Abnahmepruefung, Kapitel Praxisfallen),")
+    print("    * und der Status - nicht die Gestalt der Loesung.")
+    print("\n  Wer doch einen bestimmten Plan braucht - fuer eine abgedruckte")
+    print("  Ausgabe, fuer einen Regressionstest -, setzt num_workers = 1.")
+    print(f"  Das kostet hier den Faktor {faktor:.1f} an Laufzeit und ist genau")
+    print("  deshalb eine Entscheidung fuer den Test, nicht fuer den Betrieb.")
+    print("=" * 78)
+```
+
+**Erwartete Ausgabe** (Laufzeiten *und* die Zahl der verschiedenen Pläne sind
+hardwareabhängig — genau das ist die Aussage; der Zielwert ist es nicht):
+
+```
+==============================================================================
+  WAS MEHRERE ARBEITER WIRKLICH BRINGEN
+==============================================================================
+Job-Shop: 12 Auftraege, 10 Maschinen, 120 Arbeitsgaenge.
+random_seed = 1 in JEDEM Lauf, 4 Wiederholungen je Arbeiterzahl.
+
+==============================================================================
+  (1) Laufzeit: was die Arbeiter bringen
+==============================================================================
+ Arbeiter    Status  Makespan  schnellste  langsamste  Beschleunigung
+------------------------------------------------------------------------------
+        1   OPTIMAL       183       5.62s       5.82s            1.0x
+        2   OPTIMAL       183       1.43s       2.04s            3.9x
+        4   OPTIMAL       183       0.60s       0.66s            9.4x
+        8   OPTIMAL       183       0.46s       0.65s           12.3x
+
+  Am schnellsten sind 8 Arbeiter: Faktor 12.3 gegenueber
+  einem einzigen - also MEHR, als 8 Kerne hergeben sollten.
+  Das ist kein Messfehler. CP-SAT laesst nicht 8-mal dieselbe Suche
+  laufen, sondern verschiedene Strategien nebeneinander, die einander
+  ihre Schranken zurufen. Der zweite Arbeiter ist deshalb nicht der
+  'zweite Kern', sondern ein anderes Verfahren.
+
+==============================================================================
+  (2) Reproduzierbarkeit: derselbe Seed, derselbe Plan?
+==============================================================================
+ Arbeiter  Laeufe   verschiedene Plaene   Makespan
+------------------------------------------------------------------------------
+        1       4                     1        183
+        2       4                     3        183
+        4       4                     3        183
+        8       4                     4        183
+
+  Mit einem Arbeiter: 1 Plan aus 4 Laeufen.
+  Schon mit 2 Arbeitern: 3 verschiedene Plaene aus 4 Laeufen -
+  bei identischem random_seed und identischem Zielwert.
+  Es braucht also keine acht Arbeiter, um die Reproduzierbarkeit
+  zu verlieren. 2 genuegen.
+
+  Der Seed allein macht einen Lauf also NICHT reproduzierbar. Er legt
+  fest, wie ein einzelner Suchstrang wuerfelt - nicht, welcher von
+  mehreren zuerst fertig wird. Das entscheidet die Uhr.
+
+==============================================================================
+  (3) Was daraus fuer Tests folgt
+==============================================================================
+  Ein Test der Form  assert plan == erwarteter_plan  besteht mal und
+  scheitert mal, ohne dass sich am Code etwas geaendert haette.
+  Zu pruefen sind stattdessen:
+    * der ZIELWERT (hier in allen Laeufen gleich),
+    * die Einhaltung aller Regeln (Abnahmepruefung, Kapitel Praxisfallen),
+    * und der Status - nicht die Gestalt der Loesung.
+
+  Wer doch einen bestimmten Plan braucht - fuer eine abgedruckte
+  Ausgabe, fuer einen Regressionstest -, setzt num_workers = 1.
+  Das kostet hier den Faktor 12.3 an Laufzeit und ist genau
+  deshalb eine Entscheidung fuer den Test, nicht fuer den Betrieb.
+==============================================================================
+```
+
+### Was die Messung zeigt
+
+**Erstens: Die Beschleunigung ist überlinear.** Acht Arbeiter sind im abgedruckten Lauf
+nicht achtmal, sondern **gut zwölfmal** schneller als einer. Das sieht nach Messfehler aus, ist aber die
+korrekte Beschreibung dessen, was CP-SAT tut: Es lässt **nicht** achtmal dieselbe Suche auf
+verschiedenen Kernen laufen, sondern **verschiedene Strategien nebeneinander** — Suche mit
+LP-Relaxation, Suche mit anderen Verzweigungsregeln, lokale Suche —, und die teilen
+einander ihre Schranken mit. Der zweite Arbeiter ist deshalb nicht „der zweite Kern“,
+sondern ein anderes Verfahren, das zufällig auch rechnet.
+
+Daraus folgt zweierlei. Ein Speedup über der Kernzahl ist bei CP-SAT normal und kein Grund
+zum Misstrauen. Und der Zugewinn flacht ab: Zwischen vier und acht Arbeitern lag in unseren
+Wiederholungen mal das eine, mal das andere vorn — ab einer gewissen Zahl kosten Abstimmung
+und Speicherbandbreite mehr, als ein weiterer Suchstrang einbringt. Auch hier gilt: messen,
+nicht schätzen.
+
+**Zweitens — und das ist der Befund, der die Testpraxis bestimmt: Der Seed genügt nicht.**
+Bei einem Arbeiter liefern vier Läufe **einen** Plan. Schon bei **zwei** Arbeitern liefern
+vier Läufe **drei verschiedene** — bei identischem `random_seed` und identischem Zielwert
+183.
+
+Es braucht also keine acht Arbeiter, um die Reproduzierbarkeit zu verlieren. Zwei genügen.
+Der Grund ist einfach, sobald man ihn ausspricht: Der Seed legt fest, wie ein **einzelner**
+Suchstrang würfelt. Er legt nicht fest, **welcher von mehreren zuerst fertig wird** — das
+entscheidet die Uhr, und die ist bei jedem Lauf anders.
+
+> **⚠️ `random_seed` allein macht nichts reproduzierbar**
+> Ein häufiger Irrtum: „Ich habe doch einen Seed gesetzt.“ Für einen Zufallsgenerator
+> stimmt das. Für einen **parallelen** Solver nicht — dort ist die zweite Zufallsquelle die
+> Ausführungsreihenfolge, und die lässt sich nicht mit einem Parameter festnageln.
+> Reproduzierbar wird der Lauf erst mit `num_workers = 1` **und** Seed. Wer nur eines von
+> beidem setzt, hat einen Test, der gelegentlich grundlos rot wird.
+
+### Was daraus für Tests folgt
+
+Der Zielwert war in **allen** sechzehn Läufen derselbe: 183. Die Gestalt der Lösung war es
+nicht. Genau daran entscheidet sich, was ein Test prüfen darf:
+
+| Prüfen | Nicht prüfen |
+| --- | --- |
+| den **Zielwert** — er ist eindeutig, wenn das Modell optimal gelöst wurde | die **Gestalt** des Plans (`assert plan == erwarteter_plan`) |
+| die **Einhaltung aller Regeln** über eine Abnahmeprüfung ({ref:sec:praxisfallen-or-kern}) | die Reihenfolge, in der gleichwertige Aufträge zugewiesen wurden |
+| den **Status** (`OPTIMAL`, `FEASIBLE`, `INFEASIBLE`) | die Laufzeit als feste Zahl |
+
+Wer doch einen bestimmten Plan braucht — für eine abgedruckte Ausgabe, für einen
+Regressionstest —, setzt `num_workers = 1`. Das kostet hier den Faktor 12 an Laufzeit, und
+genau deshalb ist es eine Entscheidung **für den Test**, nicht für den Betrieb. In
+Produktion lässt man beide Parameter auf ihren Standardwerten.
+
+> **🎯 Merksatz**
+> Ein paralleler Solver hat zwei Zufallsquellen: den Seed und die Uhr. Nur die erste lässt
+> sich setzen. Wer Reproduzierbarkeit braucht, muss die zweite abschalten — und das heißt
+> `num_workers = 1`.
+
+---
+
 ## Die fünf Antworten von CP-SAT {#sec:cpsat-statusfaelle}
 
 {ref:sec:milp-gap} hat gezeigt, warum `OPTIMAL` bei ganzzahligen Problemen nicht der
@@ -1180,6 +1516,16 @@ Lösen Sie ein 9×9-Sudoku mit CP-SAT. Sie brauchen nur `NewIntVar(1, 9, ...)` u
 `AddAllDifferent` für Zeilen, Spalten und die neun 3×3-Blöcke. Wie viele Zeilen Modellcode
 benötigen Sie?
 
+**Aufgabe ⭐⭐ — Die Grenze der Parallelität finden.**
+`Parallele_Suche.py` misst 1, 2, 4 und 8 Arbeiter.
+(a) Ergänzen Sie 16 und 24 (bzw. die Kernzahl Ihres Rechners). Ab wo bringt ein weiterer
+    Arbeiter nichts mehr — und wird es irgendwann wieder schlechter?
+(b) Setzen Sie `random_seed` bei jedem Lauf auf einen **anderen** Wert, aber
+    `num_workers = 1`. Wie viele verschiedene Pläne kommen jetzt heraus? Was folgt daraus
+    für die Frage, welcher der beiden Parameter die Reproduzierbarkeit sichert?
+(c) Vergrößern Sie die Instanz auf 15 Aufträge. Ab welcher Größe erreicht der Lauf mit
+    einem Arbeiter das Zeitlimit, während acht noch `OPTIMAL` melden?
+
 **Aufgabe ⭐⭐⭐ — Job-Shop erweitern.**
 Ergänzen Sie `JobShop_Intervalle.py` um:
 (a) Rüstzeiten von 1 Zeiteinheit zwischen zwei Aufträgen auf derselben Maschine.
@@ -1196,7 +1542,7 @@ Wünsche als weiche Ziele. Geben Sie den Plan als Wochentabelle aus.
 
 ## Finde den Denkfehler {#sec:cpsat-denkfehler}
 
-> **🐛 Finde den Denkfehler 6.1: Die Betriebsvereinbarung, die niemanden interessiert**
+> **🐛 Finde den Denkfehler: Die Betriebsvereinbarung, die niemanden interessiert**
 >
 > Ein Klinikteam lässt seinen Schichtplan optimieren. Zwei Wünsche kommen aus dem Betrieb:
 >
@@ -1428,7 +1774,7 @@ Nebenbedingungen. Alles, was einen Preis hat, wird irgendwann gekauft.
 
 ## Micro-Quiz {#sec:cpsat-quiz}
 
-> **❓ Micro-Quiz 6: Drei Fragen zum Selbstcheck**
+> **❓ Micro-Quiz: Drei Fragen zum Selbstcheck**
 >
 > Genau eine Antwort ist jeweils richtig. Auflösung in
 > [Anhang A](90_Anhang_Loesungen.md#quiz-loesung-cpsat).
@@ -1466,6 +1812,10 @@ Nebenbedingungen. Alles, was einen Preis hat, wird irgendwann gekauft.
 3. Was ist eine Intervallvariable, und welche Bedingung garantiert sie automatisch?
 4. Warum sollten möglichst wenige Bedingungen hart formuliert werden?
 5. Warum ist die Aufschlüsselung der Strafkosten in der Praxis wichtiger als der Zielwert
+6. Sie setzen `random_seed = 1`, bekommen aber trotzdem bei jedem Lauf einen anderen Plan.
+   Woran liegt das, und was hilft?
+7. Warum kann ein CP-SAT-Lauf mit acht Arbeitern **mehr** als achtmal schneller sein als
+   mit einem?
    selbst?
 
 ---
@@ -1491,10 +1841,17 @@ Nebenbedingungen. Alles, was einen Preis hat, wird irgendwann gekauft.
 * **Bei mehrdeutigen Optima nie auf einen bestimmten Plan testen** — nur auf den Zielwert
   und die Einhaltung aller Regeln.
 
+* **Ein paralleler Solver hat zwei Zufallsquellen: den Seed und die Uhr.** Nur die erste
+  lässt sich setzen. Reproduzierbar wird ein Lauf erst mit `num_workers = 1` **und** Seed —
+  gemessen in {ref:sec:cpsat-parallele-suche}: schon zwei Arbeiter liefern bei identischem
+  Seed drei verschiedene Pläne zum selben Zielwert.
+* **Parallele Suche kann überlinear beschleunigen**, weil CP-SAT nicht dieselbe Suche
+  vervielfacht, sondern verschiedene Strategien nebeneinander laufen lässt, die einander
+  ihre Schranken mitteilen.
 **Ausblick.** {ref:kap:graphen} behandelt Probleme, die sich am besten als **Graph** begreifen
 lassen: Flüsse durch Netzwerke, Zuordnungen und die Tourenplanung mit Fahrzeugen und
 Zeitfenstern.
 
 ---
 
-*Weiter mit:* [{ref:kap:graphen} — Graphen, Flüsse, Touren](23_Graphen_Fluesse_Touren.md)
+*Weiter mit:* [{ref:kap:graphen} — Graphen, Flüsse und Touren](23_Graphen_Fluesse_Touren.md)
diff --git a/Operations_Research_mit_Python_Version_04/23_Graphen_Fluesse_Touren.md b/Operations_Research_mit_Python_Version_04/23_Graphen_Fluesse_Touren.md
index 0581ae8..f850d23 100644
--- a/Operations_Research_mit_Python_Version_04/23_Graphen_Fluesse_Touren.md
+++ b/Operations_Research_mit_Python_Version_04/23_Graphen_Fluesse_Touren.md
@@ -751,7 +751,7 @@ OR-Tools. Was beobachten Sie ab 12 Städten?
 
 ## Finde den Denkfehler {#sec:graphen-denkfehler}
 
-> **🐛 Finde den Denkfehler 7.1: Die vergessene Dimension**
+> **🐛 Finde den Denkfehler: Die vergessene Dimension**
 >
 > Eine Spedition lässt ihre Tagestouren optimieren: 16 Kunden, 4 Fahrzeuge zu je 10
 > Paletten, Gesamtbedarf 37 Paletten. Das erste Ergebnis begeistert alle — **326 km**.
@@ -1018,7 +1018,7 @@ plausibel aussieht.
 
 ## Micro-Quiz {#sec:graphen-quiz}
 
-> **❓ Micro-Quiz 7: Drei Fragen zum Selbstcheck**
+> **❓ Micro-Quiz: Drei Fragen zum Selbstcheck**
 >
 > Genau eine Antwort ist jeweils richtig. Auflösung in
 > [Anhang A](90_Anhang_Loesungen.md#quiz-loesung-graphen).
@@ -1084,4 +1084,4 @@ und die KKT-Bedingungen ein — das mathematische Fundament der Portfoliooptimie
 
 ---
 
-*Weiter mit:* [{ref:kap:qp-nlp} — Quadratische und nichtlineare Optimierung](30_QP_und_NLP.md)
+*Weiter mit:* [{ref:kap:metaheuristiken} — Metaheuristiken](24_Metaheuristiken.md)
diff --git a/Operations_Research_mit_Python_Version_04/24_Metaheuristiken.md b/Operations_Research_mit_Python_Version_04/24_Metaheuristiken.md
index 61db65b..368112f 100644
--- a/Operations_Research_mit_Python_Version_04/24_Metaheuristiken.md
+++ b/Operations_Research_mit_Python_Version_04/24_Metaheuristiken.md
@@ -1526,3 +1526,7 @@ liegt es an der Strategie oder an der Zahl der Runden, die sie schafft?
   könnte.
 * **LNS** kombiniert beide: zerstören, exakt reparieren, übernehmen. Die Fenstergröße hat
   ein Optimum in der Mitte und gehört gemessen.
+
+---
+
+*Weiter mit:* [{ref:kap:dekomposition} — Spaltengenerierung](25_Spaltengenerierung.md)
diff --git a/Operations_Research_mit_Python_Version_04/25_Spaltengenerierung.md b/Operations_Research_mit_Python_Version_04/25_Spaltengenerierung.md
index 3a1a315..8a17364 100644
--- a/Operations_Research_mit_Python_Version_04/25_Spaltengenerierung.md
+++ b/Operations_Research_mit_Python_Version_04/25_Spaltengenerierung.md
@@ -750,3 +750,7 @@ Spalten verzweigen kann.
   Verfahren 11 %, bei sechs nichts. Diese Kennzahl lässt sich vor dem Projekt ausrechnen.
 * Auch wo es nichts spart, liefert es die **Schranke** — und damit die Erlaubnis,
   aufzuhören.
+
+---
+
+*Weiter mit:* [Synthese Teil II](29_Synthese_Kernverfahren.md)
diff --git a/Operations_Research_mit_Python_Version_04/29_Synthese_Kernverfahren.md b/Operations_Research_mit_Python_Version_04/29_Synthese_Kernverfahren.md
new file mode 100644
index 0000000..dc26305
--- /dev/null
+++ b/Operations_Research_mit_Python_Version_04/29_Synthese_Kernverfahren.md
@@ -0,0 +1,50 @@
+# Synthese Teil II — Die Kernverfahren nebeneinander
+
+Sechs Kapitel, sechs Werkzeuge. Jedes einzelne wurde im Zusammenhang gezeigt; hier stehen
+sie zum ersten Mal **nebeneinander**, mit der Frage, die vor jedem Projekt zu beantworten
+ist: Welches nehme ich, und was bekomme ich dafür?
+
+## Die Entscheidungsmatrix
+
+| Verfahren | Wofür es gebaut ist | Was Sie bekommen | Wo es aufhört | Kapitel |
+| --- | --- | --- | --- | --- |
+| **LP** | teilbare Mengen, lineare Zusammenhänge | beweisbares Optimum **plus Schattenpreise** | sobald etwas ganzzahlig sein muss | {ref:kap:lp} |
+| **MILP** | Ja/Nein-Entscheidungen, Fixkosten, Logik | beweisbares Optimum, Gap als Fortschrittsmaß | Laufzeit wächst mit der Zahl der Binärvariablen | {ref:kap:milp} |
+| **CP-SAT** | Zuweisung, Reihenfolge, Kalender, harte Logik | beweisbares Optimum, sehr ausdrucksstarke Bedingungen | keine Schattenpreise, keine stetigen Größen | {ref:kap:cpsat} |
+| **Graphenalgorithmen** | Flüsse, Zuordnung, Touren | oft **polynomiell** statt exponentiell | nur, wenn die Struktur wirklich passt | {ref:kap:graphen} |
+| **Metaheuristiken** | wenn der exakte Solver aussteigt | eine gute Lösung in **fester Zeit** | keine Garantie, kein Beweis, keine Schranke | {ref:kap:metaheuristiken} |
+| **Spaltengenerierung** | Modelle mit astronomisch vielen Variablen | beweisbares Optimum über nie erzeugte Spalten | lohnt nur bei bestimmter Instanzstruktur | {ref:kap:dekomposition} |
+
+**Die Spalte, die am meisten wert ist, ist die vierte.** Ein Verfahren zu kennen heißt zu
+wissen, wo es aufhört — nicht, wofür es gedacht ist.
+
+## Was dieser Teil gemessen hat
+
+| Behauptung | Gemessen | Wo |
+| --- | --- | --- |
+| „Der exakte Solver ist immer besser." | Bei 500 Aufträgen liefert CP-SAT eine Lösung, die **5,2 % schlechter** ist als die Faustregel eines Meisters | {ref:kap:metaheuristiken} |
+| „Metaheuristiken sind ungenau." | Faustregel 2 497 → Annealing 2 343 → Annealing plus LNS **2 289** Minuten Rüstzeit; untere Schranke 1 768 | {ref:kap:metaheuristiken} |
+| „Man muss alle Variablen aufschreiben." | 28 erzeugte Muster von **46 408** möglichen — und die Lösung ist beweisbar optimal | {ref:kap:dekomposition} |
+| „Dekomposition lohnt sich immer." | Bei drei Stücken je Rolle **11 %** Ersparnis, bei sechs **nichts** | {ref:kap:dekomposition} |
+| „Mit Seed ist der Lauf reproduzierbar." | Schon **zwei** Arbeiter liefern bei identischem Seed drei verschiedene Pläne zum selben Zielwert | {ref:sec:cpsat-parallele-suche} |
+
+## Drei Fehler, die dieser Teil verhindert
+
+1. **Runden.** Die LP-Lösung ist keine Näherung der ganzzahligen Lösung — sie kann beliebig
+   weit danebenliegen, und gerundet sogar unzulässig werden.
+2. **Ein zu großes Big-M.** Es macht das Modell nicht falsch, sondern die Suche langsam und
+   die Schranken wertlos. So klein wie zulässig, nie „sicherheitshalber groß".
+3. **Zu früh heuristisch werden.** Der Umschlagpunkt, ab dem eine Metaheuristik den exakten
+   Solver schlägt, ist eine Eigenschaft **des Problems** und lässt sich messen. Wer ihn
+   nicht misst, verzichtet auf Optimalitätsgarantien, die er hätte haben können.
+
+## Wenn Sie nur eines mitnehmen
+
+> **🎯** Die Frage lautet nie „welcher Solver ist der beste", sondern „welche Garantie
+> brauche ich, und was bin ich bereit, dafür an Laufzeit zu zahlen". Ein Verfahren ohne
+> Schranke liefert eine Lösung; ein Verfahren mit Schranke liefert die Erlaubnis,
+> aufzuhören.
+
+---
+
+*Weiter mit:* [{ref:kap:qp-nlp} — Quadratische und nichtlineare Optimierung](30_QP_und_NLP.md)
diff --git a/Operations_Research_mit_Python_Version_04/30_QP_und_NLP.md b/Operations_Research_mit_Python_Version_04/30_QP_und_NLP.md
index 3ec2afa..98c984e 100644
--- a/Operations_Research_mit_Python_Version_04/30_QP_und_NLP.md
+++ b/Operations_Research_mit_Python_Version_04/30_QP_und_NLP.md
@@ -5,7 +5,7 @@ in der Praxis oft nicht: Risiko wächst **quadratisch** mit dem Einsatz, Nachfra
 morgen bekannt, und eine Entscheidung heute verändert, welche Möglichkeiten übermorgen noch
 offenstehen.
 
-Die drei Kapitel dieses Teils behandeln genau diese drei Abweichungen. Welches Werkzeug Sie
+Drei Kapitel dieses Teils behandeln genau diese drei Abweichungen. Welches Werkzeug Sie
 brauchen, hängt davon ab, **welche** davon bei Ihnen vorliegt:
 
 ![Entscheidungsdiagramm: Welches Werkzeug passt zu meinem Problem? (Teil III)](bilder_04/teil3_solverwahl.svg)
@@ -21,6 +21,11 @@ brauchen, hängt davon ab, **welche** davon bei Ihnen vorliegt:
 > und dann deterministisch zu rechnen. Warum das systematisch danebengeht, zeigt
 > {ref:kap:unsicherheit} unter dem Namen *Fluch des Durchschnitts*.
 
+Zwei weitere Kapitel schließen sich an, weil sie dieselbe Voraussetzung aufgeben, nur an
+einer anderen Stelle: {ref:kap:mehrziel} gibt das **eine Ziel** auf, {ref:kap:prognose} die
+Annahme, die **Eingabedaten** seien gegeben statt selbst geschätzt. Was dieser Teil
+insgesamt leistet, fasst die Synthese an seinem Ende zusammen.
+
 ---
 
 # Kapitel: Quadratische und nichtlineare Optimierung — KKT, Lagrange, Konvexität {#kap:qp-nlp}
@@ -778,7 +783,8 @@ unverändert gelassen. **Der weiche Term verteilt, die harte Schranke kappt.**
 >
 > **Zur Skalierung:** Mit $\alpha = 1$ ist der Ertragsterm ($\approx 0{,}1$) zehnmal größer
 > als der Varianzterm ($\approx 0{,}01$). Das Modell ist also stark renditegetrieben.
-> Übung 8.5 lässt Sie diese Balance untersuchen — sie ist eine fachliche Entscheidung, keine
+> Die Aufgabe *Effekt der Gewichtung untersuchen* ({ref:sec:qp-nlp-uebungsaufgaben}) lässt
+> Sie diese Balance untersuchen — sie ist eine fachliche Entscheidung, keine
 > technische.
 
 ---
@@ -1211,7 +1217,7 @@ groß ist der Unterschied zwischen bestem und schlechtestem Ergebnis? Kann die
 
 ## Finde den Denkfehler {#sec:qp-nlp-denkfehler}
 
-> **🐛 Finde den Denkfehler 8.1: Die Kovarianzmatrix aus dem Controlling**
+> **🐛 Finde den Denkfehler: Die Kovarianzmatrix aus dem Controlling**
 >
 > Ein Analyst soll das Risiko eines Portfolios aus drei Anlagen minimieren. Die
 > Korrelationen hat er aus drei verschiedenen Quartalsberichten zusammengetragen — jede
@@ -1279,7 +1285,7 @@ groß ist der Unterschied zwischen bestem und schlechtestem Ergebnis? Kann die
 
 ## Micro-Quiz {#sec:qp-nlp-quiz}
 
-> **❓ Micro-Quiz 8: Drei Fragen zum Selbstcheck**
+> **❓ Micro-Quiz: Drei Fragen zum Selbstcheck**
 >
 > Genau eine Antwort ist jeweils richtig. Auflösung in
 > [Anhang A](90_Anhang_Loesungen.md#quiz-loesung-qp-nlp).
diff --git a/Operations_Research_mit_Python_Version_04/31_Unsicherheit.md b/Operations_Research_mit_Python_Version_04/31_Unsicherheit.md
index 8855759..ea6ae32 100644
--- a/Operations_Research_mit_Python_Version_04/31_Unsicherheit.md
+++ b/Operations_Research_mit_Python_Version_04/31_Unsicherheit.md
@@ -428,7 +428,7 @@ Feinsuche (Raster 100..500): Optimum bei Kapazitaet 180, Kosten 12,810 EUR
 > allgemeine Antwort — **rechnen Sie es aus.** Genau dafür ist Monte-Carlo da. Und beachten
 > Sie die Spalte „Unterdeckung“: Bei Kapazität 200 wird in **24 % der Fälle** nachgekauft.
 > Ob das akzeptabel ist, entscheidet kein Optimierer, sondern ein Servicelevel-Ziel
-> (Übung 9.5).
+> (Aufgabe *Monte-Carlo erweitern*, {ref:sec:unsicherheit-uebungsaufgaben}).
 
 > **💡 Wann Monte-Carlo das richtige Werkzeug ist**
 > Immer dann, wenn Sie **eine Kennzahl brauchen, die keine Formel hat**: die
@@ -642,7 +642,8 @@ auch nicht optimal.
 
 Der **EVPI von 7 375 €** ist bemerkenswert hoch: 45 % der Gesamtkosten entstehen allein
 daraus, dass man die Zukunft nicht kennt. In so einem Fall lohnt sich Investition in bessere
-Prognosen tatsächlich — anders als in dem Beispiel aus Übung 9.4.
+Prognosen tatsächlich — anders als in dem Beispiel aus der Aufgabe *EVPI interpretieren*
+({ref:sec:unsicherheit-uebungsaufgaben}).
 
 > **💡 Was ist der EVPI?**
 > Der **Expected Value of Perfect Information**{idx:EVPI} beziffert, wie viel eine perfekte Prognose
@@ -1278,7 +1279,7 @@ das lässt sich in CVXPY mit `cp.sum_largest` formulieren.)
 
 ## Finde den Denkfehler {#sec:unsicherheit-denkfehler}
 
-> **🐛 Finde den Denkfehler 9.1: Warum jedes Projekt zu spät fertig wird**
+> **🐛 Finde den Denkfehler: Warum jedes Projekt zu spät fertig wird**
 >
 > Ein Projektleiter plant eine Umbaumaßnahme. Fünf Gewerke arbeiten **parallel** und
 > unabhängig voneinander; fertig ist der Umbau, wenn das letzte fertig ist. Für jedes
@@ -1334,7 +1335,7 @@ das lässt sich in CVXPY mit `cp.sum_largest` formulieren.)
 
 ## Micro-Quiz {#sec:unsicherheit-quiz}
 
-> **❓ Micro-Quiz 9: Drei Fragen zum Selbstcheck**
+> **❓ Micro-Quiz: Drei Fragen zum Selbstcheck**
 >
 > Genau eine Antwort ist jeweils richtig. Auflösung in
 > [Anhang A](90_Anhang_Loesungen.md#quiz-loesung-unsicherheit).
diff --git a/Operations_Research_mit_Python_Version_04/32_Dynamische_Programmierung.md b/Operations_Research_mit_Python_Version_04/32_Dynamische_Programmierung.md
index f344115..8461715 100644
--- a/Operations_Research_mit_Python_Version_04/32_Dynamische_Programmierung.md
+++ b/Operations_Research_mit_Python_Version_04/32_Dynamische_Programmierung.md
@@ -739,7 +739,7 @@ Bei dynamischer Programmierung entscheidet eine einzige Frage über Erfolg oder
 **Was gehört in den Zustand?** Ist er zu klein, rechnet das Verfahren völlig korrekt — nur
 eben an einem anderen Problem.
 
-> **🐛 Finde den Denkfehler 10.1: Der Zustand, der zu wenig weiß**
+> **🐛 Finde den Denkfehler: Der Zustand, der zu wenig weiß**
 >
 > Eine Werkstatt plant vier Perioden. Der Bedarf beträgt 3, 1, 4, 2 Stück; produziert werden
 > können höchstens 5 je Periode, gelagert höchstens 6 Stück.
@@ -796,7 +796,7 @@ eben an einem anderen Problem.
 
 ## Micro-Quiz {#sec:dynamische-programmierung-quiz}
 
-> **❓ Micro-Quiz 10: Drei Fragen zum Selbstcheck**
+> **❓ Micro-Quiz: Drei Fragen zum Selbstcheck**
 >
 > Genau eine Antwort ist jeweils richtig. Auflösung in
 > [Anhang A](90_Anhang_Loesungen.md#quiz-loesung-dynamische-programmierung).
@@ -862,4 +862,4 @@ Marktdaten — und lernen zuerst, warum diese Daten trügerisch sind.
 
 ---
 
-*Weiter mit:* [{ref:kap:finanzdaten} — Finanzdaten und Kovarianz-Shrinkage](40_Finanzdaten.md)
+*Weiter mit:* [{ref:kap:mehrziel} — Mehrere Ziele](33_Mehrziel_und_Pareto.md)
diff --git a/Operations_Research_mit_Python_Version_04/33_Mehrziel_und_Pareto.md b/Operations_Research_mit_Python_Version_04/33_Mehrziel_und_Pareto.md
index 278934e..aef5320 100644
--- a/Operations_Research_mit_Python_Version_04/33_Mehrziel_und_Pareto.md
+++ b/Operations_Research_mit_Python_Version_04/33_Mehrziel_und_Pareto.md
@@ -757,3 +757,7 @@ einer Fläche. Wie ändert sich das ε-Verfahren, und warum wächst der Aufwand
   dafür so sauber wie möglich" ist eine Frage, die ein Kaufmann beantworten kann.
 * Die Front wird erst entscheidbar durch die Spalte **€ je kg**: Sie ist mit dem internen
   CO₂-Preis vergleichbar und verwandelt eine Wertefrage in eine Rechnung.
+
+---
+
+*Weiter mit:* [{ref:kap:prognose} — Predict-then-Optimize](34_Predict_then_Optimize.md)
diff --git a/Operations_Research_mit_Python_Version_04/34_Predict_then_Optimize.md b/Operations_Research_mit_Python_Version_04/34_Predict_then_Optimize.md
index a5273aa..ea6822b 100644
--- a/Operations_Research_mit_Python_Version_04/34_Predict_then_Optimize.md
+++ b/Operations_Research_mit_Python_Version_04/34_Predict_then_Optimize.md
@@ -700,3 +700,7 @@ und zwar **in unterschiedlichem Ausmaß**? Was sagt das über den Wert eines Mer
 * Ein Kennzahlenvergleich braucht eine **Streuungsangabe**. Bei 180 Testtagen sah das
   schlechtere Modell in gut jedem zehnten Fall besser aus — und wer einmal misst, hat genau
   eine Ziehung.
+
+---
+
+*Weiter mit:* [Synthese Teil III](39_Synthese_Nichtlinear.md)
diff --git a/Operations_Research_mit_Python_Version_04/35_Strukturbruecke.md b/Operations_Research_mit_Python_Version_04/35_Strukturbruecke.md
index fc6d2e5..fcad86b 100644
--- a/Operations_Research_mit_Python_Version_04/35_Strukturbruecke.md
+++ b/Operations_Research_mit_Python_Version_04/35_Strukturbruecke.md
@@ -735,3 +735,7 @@ trägt — und schreiben Sie auf, welche der drei Zeilen im Weg steht.
   gegen reagierende Marktteilnehmer) und ob Teilbarkeit erlaubt ist (MILP gegen LP).
 * Die erste dieser Grenzen ist die gefährlichste: Dieselbe Optimierung ist in der Werkstatt
   Planung und im Depot Fehlerverstärkung.
+
+---
+
+*Weiter mit:* [{ref:kap:supplychain} — Supply-Chain und Energieeinsatz unter Unsicherheit](36_Supply_Chain_Energie.md)
diff --git a/Operations_Research_mit_Python_Version_04/36_Supply_Chain_Energie.md b/Operations_Research_mit_Python_Version_04/36_Supply_Chain_Energie.md
index 8b2cf2a..a9e2681 100644
--- a/Operations_Research_mit_Python_Version_04/36_Supply_Chain_Energie.md
+++ b/Operations_Research_mit_Python_Version_04/36_Supply_Chain_Energie.md
@@ -595,6 +595,26 @@ Was Versorgungssicherheit kostet
 Der Erwartungswert-Plan kostet in der Wirklichkeit **149 % mehr**, und sein schlimmster Tag
 ist sechsmal so teuer.
 
+**Wofür genau?** Die Summendifferenz von 523 514 € sagt noch nicht, wo sie entsteht. Zerlegt
+man sie nach Kostenarten, wird aus dem Befund eine Aussage, die man vorlegen kann:
+
+![Wofür der Erwartungswert-Plan 149 % mehr bezahlt](bilder_04/kap_supplychain_wirkung.svg)
+
+Drei Dinge stehen darin, die die Tabelle nicht zeigt. Die **Anfahrkosten sind in beiden
+Plänen gleich** (58 000 €) — der Erwartungswert-Plan spart also nicht dort, wo man es
+vermuten würde. Er spart **12 725 € Brennstoff**, weil er weniger Blockstunden vorhält. Und
+er bezahlt dafür **536 239 € Lastabwurf**: das **42-fache** seiner Ersparnis.
+
+Genau diese Gegenüberstellung ist es, die eine Investitionsentscheidung trägt. „149 % mehr"
+ist eine Zahl, über die man streiten kann; „wir sparen 12 725 € und riskieren dafür 536 239 €"
+ist eine, über die man entscheidet.
+
+> **📌 Zum Diagramm**
+> Es wird von `bilder_04/erzeuge_wirkung.py` erzeugt, das die Instanz aus
+> `Kraftwerkseinsatz.py` **erneut rechnet** statt Zahlen zu übernehmen — und dabei die
+> beiden abgedruckten Summen exakt reproduziert. Die Trennung von Brennstoff- und
+> Abwurfkosten ist der einzige Zusatz; das Buchprogramm braucht sie nicht.
+
 Der Unterschied zwischen den beiden Plänen ist dabei erstaunlich klein:
 
 ```
@@ -765,3 +785,7 @@ und welches Verfahren aus {ref:kap:metaheuristiken} würden Sie einsetzen?
   der erwarteten Kosten die Absicherung von selbst.
 * Wo sie greift, liefert sie den **Preis der Vorgabe**: 46 € je vermiedener MWh — eine Zahl,
   über die man verhandeln kann.
+
+---
+
+*Weiter mit:* [{ref:kap:finanzdaten} — Finanzdaten-Modellierung](40_Finanzdaten.md)
diff --git a/Operations_Research_mit_Python_Version_04/39_Synthese_Nichtlinear.md b/Operations_Research_mit_Python_Version_04/39_Synthese_Nichtlinear.md
new file mode 100644
index 0000000..0e8d8b7
--- /dev/null
+++ b/Operations_Research_mit_Python_Version_04/39_Synthese_Nichtlinear.md
@@ -0,0 +1,52 @@
+# Synthese Teil III — Wenn die Idealwelt nicht gilt
+
+{ref:teil:kernverfahren} setzte voraus: feste Daten, lineare Zusammenhänge, ein Ziel, eine
+Periode. Dieser Teil nimmt jede dieser vier Voraussetzungen einzeln weg. Die Tabelle ordnet
+die Kapitel danach, **welche** Voraussetzung bei Ihnen verletzt ist.
+
+## Welche Annahme fällt weg?
+
+| Was nicht gilt | Woran Sie es merken | Werkzeug | Kapitel |
+| --- | --- | --- | --- |
+| **Linearität** | Risiko wächst quadratisch, Kosten degressiv, Sättigung | QP, konvexe Optimierung, KKT | {ref:kap:qp-nlp} |
+| **Feste Daten** | Nachfrage, Wind, Rendite stehen erst morgen fest | Monte-Carlo, Zweistufigkeit, Robustheit, Chance Constraints | {ref:kap:unsicherheit} |
+| **Eine Periode** | die Entscheidung heute verändert, was übermorgen möglich ist | Bellman-Gleichung, Rückwärtsinduktion | {ref:kap:dynamische-programmierung} |
+| **Ein Ziel** | zwei Kennzahlen sollen gleichzeitig stimmen | Pareto-Front, ε-Constraint | {ref:kap:mehrziel} |
+| **Daten sind gegeben** | die Eingabe ist selbst eine Prognose | Predict-then-Optimize, entscheidungsorientiertes Lernen | {ref:kap:prognose} |
+
+Die letzte Zeile ist die unbequemste: Dort ist nicht das Modell unsicher, sondern seine
+**Eingabe** — und die kommt aus einem zweiten Modell, das nach anderen Kriterien gebaut
+wurde.
+
+## Was dieser Teil gemessen hat
+
+| Behauptung | Gemessen | Wo |
+| --- | --- | --- |
+| „Mit dem Mittelwert zu rechnen ist eine brauchbare Näherung." | Der Mittelwertplan hält seine Zusage in **50,08 %** der Fälle — per Definition | {ref:sec:unsicherheit-chance-constraints} |
+| „Versorgungssicherheit kostet linear." | 56 289 € je Prozentpunkt auf dem Weg zu 80 %, **253 848 €** zwischen 95 und 99 % — das 4,5-fache | {ref:sec:unsicherheit-chance-constraints} |
+| „Eine Zusage aus dem Modell hält." | Der 95-%-Plan hält **87,44 %**, sobald die Testverteilung einen Fall enthält, in dem alles zugleich ausfällt | {ref:sec:unsicherheit-chance-constraints} |
+| „Die bessere Prognose führt zur besseren Entscheidung." | Das Modell mit dem **schlechteren** MSE trifft die günstigere Entscheidung | {ref:kap:prognose} |
+
+## Drei Fehler, die dieser Teil verhindert
+
+1. **Unsicherheit durch Mittelwerte ersetzen.** Der Durchschnittskunde kauft nie. Bei
+   asymmetrischen Kosten liegt das Optimum systematisch neben dem Mittelwert, und eine
+   Terminzusage ist ein **Quantil**, kein Erwartungswert.
+2. **Konvexität voraussetzen, ohne sie zu prüfen.** Ohne sie gibt es keine
+   Optimalitätsgarantie, sondern nur ein lokales Ergebnis — und der Solver sagt das nicht
+   von selbst.
+3. **Zwei Ziele mit einem Gewicht verrechnen, bevor die Front bekannt ist.** Ein Gewicht
+   ist eine Antwort auf eine Frage, die noch niemand gestellt hat. Die Pareto-Front stellt
+   sie zuerst.
+
+## Wenn Sie nur eines mitnehmen
+
+> **🎯** Jede der vier Annahmen lässt sich einzeln aufgeben — aber jede kostet etwas
+> Bestimmtes: Linearität kostet die Optimalitätsgarantie, feste Daten kosten Rechenzeit
+> oder Vorsicht, eine Periode kostet Zustandsraum, ein Ziel kostet eine Entscheidung, die
+> nicht der Modellierer treffen darf. Wer weiß, **welche** Annahme bei ihm fällt, weiß
+> auch, welchen Preis er zahlt.
+
+---
+
+*Weiter mit:* [{ref:kap:bruecke} — Die Strukturbrücke](35_Strukturbruecke.md)
diff --git a/Operations_Research_mit_Python_Version_04/40_Finanzdaten.md b/Operations_Research_mit_Python_Version_04/40_Finanzdaten.md
index 40893fd..945b0a4 100644
--- a/Operations_Research_mit_Python_Version_04/40_Finanzdaten.md
+++ b/Operations_Research_mit_Python_Version_04/40_Finanzdaten.md
@@ -448,7 +448,8 @@ beide und macht transparent, welches wo zum Einsatz kommt.
 > unkorreliert sind — eine starke, aber sehr stabile Annahme. Das
 > **Konstant-Korrelations-Ziel** behält die geschätzten Einzelvarianzen und glättet nur die
 > Korrelationen; das ist bei Aktien meist realistischer, weil Titel tatsächlich sehr
-> unterschiedliche Volatilitäten haben. In Übung 11.5 implementieren Sie es selbst und
+> unterschiedliche Volatilitäten haben. In der Aufgabe *Beide Shrinkage-Ziele vergleichen*
+> ({ref:sec:finanzdaten-uebungsaufgaben}) implementieren Sie es selbst und
 > vergleichen.
 
 Das Ergebnis ist in jedem Fall garantiert **positiv definit**, wohlkonditioniert und stabil
@@ -680,7 +681,7 @@ Erweitern Sie `Schaetzrauschen_Demo.py` um eine dritte Variante: die
 
 ## Finde den Denkfehler {#sec:finanzdaten-denkfehler}
 
-> **🐛 Finde den Denkfehler 11.1: Das risikofreie Portfolio**
+> **🐛 Finde den Denkfehler: Das risikofreie Portfolio**
 >
 > Ein Analyst stellt ein Portfolio aus **30 Titeln** zusammen. Für die Kovarianzmatrix
 > nimmt er das letzte Quartal — bei Wochendaten sind das **20 Beobachtungen**. Dann
@@ -760,7 +761,8 @@ def minimales_risiko(kovarianz: np.ndarray) -> tuple[np.ndarray, float]:
     exakt positiv semidefinit ist - rechne trotzdem.' Das ist hier bewusst so
     gewaehlt, denn genau diese Eigenschaft wollen wir vorfuehren. Im
     Produktivbetrieb waere die DCP-Fehlermeldung das Warnsignal, dem man
-    nachgehen muss (siehe Denkfehler 8.1).
+    nachgehen muss (siehe den Denkfehler im Kapitel Quadratische und
+    nichtlineare Optimierung).
     """
     gewichte = cp.Variable(ANZAHL_ANLAGEN)
     problem = cp.Problem(cp.Minimize(cp.quad_form(gewichte, cp.psd_wrap(kovarianz))),
@@ -885,7 +887,7 @@ e 0: \mathbf{w}^	op\mathbf{S}\mathbf{w} = 0$ | „In genau diesen Richtungen mis
 
 ## Micro-Quiz {#sec:finanzdaten-quiz}
 
-> **❓ Micro-Quiz 11: Drei Fragen zum Selbstcheck**
+> **❓ Micro-Quiz: Drei Fragen zum Selbstcheck**
 >
 > Genau eine Antwort ist jeweils richtig. Auflösung in
 > [Anhang A](90_Anhang_Loesungen.md#quiz-loesung-finanzdaten).
@@ -950,4 +952,4 @@ Markowitz-Effizienzgrenze mit realistischen institutionellen Restriktionen.
 
 ---
 
-*Weiter mit:* [{ref:kap:markowitz} — Markowitz-Portfoliotheorie](41_Markowitz.md)
+*Weiter mit:* [{ref:kap:markowitz} — Die moderne Portfoliotheorie nach Markowitz](41_Markowitz.md)
diff --git a/Operations_Research_mit_Python_Version_04/41_Markowitz.md b/Operations_Research_mit_Python_Version_04/41_Markowitz.md
index 5fbfa45..fcb0a55 100644
--- a/Operations_Research_mit_Python_Version_04/41_Markowitz.md
+++ b/Operations_Research_mit_Python_Version_04/41_Markowitz.md
@@ -763,7 +763,7 @@ zweiten. Vergleichen Sie GMV, Max Sharpe und 1/N.
 anrichtet. Bei den erwarteten **Renditen** ist es schlimmer — und weil sie in der
 Zielfunktion stehen statt in der Nebenbedingung, fällt es schwerer auf.
 
-> **🐛 Finde den Denkfehler 12.1: Zwölf gleiche Anlagen, ein sehr ungleiches Portfolio**
+> **🐛 Finde den Denkfehler: Zwölf gleiche Anlagen, ein sehr ungleiches Portfolio**
 >
 > Ein Analyst optimiert ein Portfolio aus zwölf Anlagen. Erwartete Renditen und
 > Kovarianzen schätzt er aus einem Jahr Tagesdaten — 250 Beobachtungen, in der Praxis
@@ -986,7 +986,7 @@ Drei praktische Konsequenzen:
 
 ## Micro-Quiz {#sec:markowitz-quiz}
 
-> **❓ Micro-Quiz 12: Drei Fragen zum Selbstcheck**
+> **❓ Micro-Quiz: Drei Fragen zum Selbstcheck**
 >
 > Genau eine Antwort ist jeweils richtig. Auflösung in
 > [Anhang A](90_Anhang_Loesungen.md#quiz-loesung-markowitz).
diff --git a/Operations_Research_mit_Python_Version_04/42_CVaR.md b/Operations_Research_mit_Python_Version_04/42_CVaR.md
index 65b4d52..bacd723 100644
--- a/Operations_Research_mit_Python_Version_04/42_CVaR.md
+++ b/Operations_Research_mit_Python_Version_04/42_CVaR.md
@@ -720,7 +720,7 @@ $\tau \in \{0{,}05;\ 0{,}1;\ 0{,}25;\ 0{,}5;\ 1{,}0\}$.
 
 ## Finde den Denkfehler {#sec:cvar-denkfehler}
 
-> **🐛 Finde den Denkfehler 13.1: Das Risikobudget, das durch Diversifikation stieg**
+> **🐛 Finde den Denkfehler: Das Risikobudget, das durch Diversifikation stieg**
 >
 > Eine Bank vergibt Risikobudgets je Abteilung. Zwei Kreditabteilungen halten je eine
 > Unternehmensanleihe über 100 € Nominal mit **4 % Ausfallwahrscheinlichkeit** (bei
@@ -779,7 +779,7 @@ $\tau \in \{0{,}05;\ 0{,}1;\ 0{,}25;\ 0{,}5;\ 1{,}0\}$.
 
 ## Micro-Quiz {#sec:cvar-quiz}
 
-> **❓ Micro-Quiz 13: Drei Fragen zum Selbstcheck**
+> **❓ Micro-Quiz: Drei Fragen zum Selbstcheck**
 >
 > Genau eine Antwort ist jeweils richtig. Auflösung in
 > [Anhang A](90_Anhang_Loesungen.md#quiz-loesung-cvar).
@@ -846,4 +846,4 @@ Rebalancing und ein Walk-Forward-Backtest ohne Lookahead-Bias.
 
 ---
 
-*Weiter mit:* [{ref:kap:handelsmaschine} — Die vollständige Handelsmaschine](43_Handelsmaschine.md)
+*Weiter mit:* [{ref:kap:handelsmaschine} — Die vollständige quantitative Handelsmaschine](43_Handelsmaschine.md)
diff --git a/Operations_Research_mit_Python_Version_04/43_Handelsmaschine.md b/Operations_Research_mit_Python_Version_04/43_Handelsmaschine.md
index 7017af1..54d2059 100644
--- a/Operations_Research_mit_Python_Version_04/43_Handelsmaschine.md
+++ b/Operations_Research_mit_Python_Version_04/43_Handelsmaschine.md
@@ -754,7 +754,7 @@ sondern in der **Arbeitsweise davor** — und hinterlassen im Programm keine Spu
 Backtest, der zwanzigmal nachjustiert wurde, sieht am Ende genauso sauber aus wie einer,
 der beim ersten Versuch funktioniert hat.
 
-> **🐛 Finde den Denkfehler 14.1: Die Strategie mit dem hochsignifikanten Ergebnis**
+> **🐛 Finde den Denkfehler: Die Strategie mit dem hochsignifikanten Ergebnis**
 >
 > Eine Analystin entwickelt über mehrere Wochen eine Handelsstrategie. Sie probiert
 > verschiedene Signalfenster, Schwellenwerte, Filter und Haltedauern durch — insgesamt
@@ -980,7 +980,7 @@ von allen Fehlversuchen genau einen: den erfolgreichsten.
 
 ## Micro-Quiz {#sec:handelsmaschine-quiz}
 
-> **❓ Micro-Quiz 14: Drei Fragen zum Selbstcheck**
+> **❓ Micro-Quiz: Drei Fragen zum Selbstcheck**
 >
 > Genau eine Antwort ist jeweils richtig. Auflösung in
 > [Anhang A](90_Anhang_Loesungen.md#quiz-loesung-handelsmaschine).
@@ -1047,4 +1047,4 @@ der Weg vom Skript zum produktiven System.
 
 ---
 
-*Weiter mit:* [{ref:kap:praxisfallen} — Praxisfallen und produktiver Einsatz](50_Praxis.md)
+*Weiter mit:* [Synthese Teil IV](49_Synthese_Anwendungen.md)
diff --git a/Operations_Research_mit_Python_Version_04/49_Synthese_Anwendungen.md b/Operations_Research_mit_Python_Version_04/49_Synthese_Anwendungen.md
new file mode 100644
index 0000000..4af73d8
--- /dev/null
+++ b/Operations_Research_mit_Python_Version_04/49_Synthese_Anwendungen.md
@@ -0,0 +1,50 @@
+# Synthese Teil IV — Zwei Domänen, dieselbe Mathematik
+
+Sechs Kapitel, zwei Branchen, die sich für unvergleichbar halten. Die Werkstatt plant
+Maschinen, das Depot plant Titel — und beide lösen dasselbe Problem: **knappe Mittel auf
+konkurrierende Verwendungen verteilen, unter Unsicherheit.**
+
+## Dieselbe Struktur, andere Namen
+
+| Werkstatt und Kraftwerk | Depot und Handel | Was mathematisch dahintersteht |
+| --- | --- | --- |
+| Produkt, Maschinenstunde | Titel, Kapital | Entscheidungsvariable |
+| Deckungsbeitrag | erwartete Rendite | linearer Zielterm |
+| Kapazität, Liefervertrag | Positionsgrenze, Sektorlimit | Nebenbedingung |
+| Rüstkosten, Anfahrkosten | Transaktionskosten | Fixkosten mit Binärvariable (B1) |
+| Lastabwurf, Konventionalstrafe | Tail-Verlust | Straf- bzw. Risikoterm |
+| Wind- und Nachfrageszenarien | Renditeszenarien | Szenariomenge |
+
+**Und wo die Analogie endet**, benennt {ref:kap:bruecke} an drei Stellen ausdrücklich — das
+ist der wertvollere Teil. Eine Analogie, die man nicht begrenzen kann, ist keine Erkenntnis,
+sondern eine Redewendung.
+
+## Was dieser Teil gemessen hat
+
+| Behauptung | Gemessen | Wo |
+| --- | --- | --- |
+| „Planen mit der Prognose ist gut genug." | Der Erwartungswert-Plan kostet **149 % mehr** (874 870 € statt 351 356 €) und wirft in **28 von 40** Szenarien Last ab | {ref:kap:supplychain} |
+| „Dann sparen wir eben beim Brennstoff." | Genau das tut er: 12 725 € gespart, **536 239 €** Lastabwurf bezahlt — das 42-fache. Die Anfahrkosten sind in beiden Plänen gleich | {ref:kap:supplychain} |
+| „Der VaR sagt, wie riskant es ist." | VaR **1,86 %**, CVaR **2,99 %** — und der schlechteste Tag der Stichprobe (**−23,0 %**) ändert am VaR **nichts** | {ref:kap:cvar} |
+| „Die Kovarianzmatrix ist eine Eingabe wie jede andere." | Aus kurzen Reihen geschätzt ist sie schlecht konditioniert; die Optimierung setzt dann auf Schätzrauschen | {ref:kap:finanzdaten} |
+
+## Drei Fehler, die dieser Teil verhindert
+
+1. **Bei Markowitz einsteigen.** Wer {ref:kap:finanzdaten} überspringt, optimiert seine
+   eigenen Schätzfehler und wundert sich über Gewichte, die niemand halten würde.
+2. **Den VaR für ein Risikomaß halten.** Er sagt, **ob** die Schwelle gerissen wird, nicht
+   **wie schlimm** es dahinter aussieht — und er ist nicht kohärent. Optimiert wird der
+   CVaR.
+3. **Trägheit unterschätzen.** Im Kraftwerkspark ist nicht die Prognosegüte das Problem,
+   sondern dass sich ein Block mit acht Stunden Mindestlaufzeit um 18 Uhr nicht mehr
+   herbeirufen lässt. Dieselbe Trägheit heißt im Depot Transaktionskosten.
+
+## Wenn Sie nur eines mitnehmen
+
+> **🎯** Wer die Struktur erkennt, kann sein Werkzeug mitnehmen, wenn er die Branche
+> wechselt. Wer nur die Bibliothek kennt, fängt jedes Mal von vorn an — und wer die Grenzen
+> der Analogie nicht kennt, überträgt irgendwann auch das, was nicht überträgt.
+
+---
+
+*Weiter mit:* [{ref:kap:praxisfallen} — Praxisfallen und der Weg zum produktiven Einsatz](50_Praxis.md)
diff --git a/Operations_Research_mit_Python_Version_04/50_Praxis.md b/Operations_Research_mit_Python_Version_04/50_Praxis.md
index 10a3ccc..b02bbb0 100644
--- a/Operations_Research_mit_Python_Version_04/50_Praxis.md
+++ b/Operations_Research_mit_Python_Version_04/50_Praxis.md
@@ -20,6 +20,7 @@
 > **Programme:**\
 > `Infeasibility_Diagnose.py`\
 > `Erklaerbarkeit.py`\
+> `Constraint_Attribution.py`\
 > `Betriebsueberwachung.py`\
 > `or_kern.py`\
 > `Solverwechsel_CPSAT_HiGHS.py`
@@ -89,15 +90,17 @@ Nach diesem Kapitel können Sie …
 1. … die fünf typischen Praxisfallen benennen und je ein Gegenmittel nennen.
 2. … ein unlösbares Modell in einen „am wenigsten schlechten“ Plan verwandeln.
 3. … Solver-Ergebnisse erklärbar machen (*Explainable OR*).
-4. … Zeitlimits und Optimalitätslücken sinnvoll setzen.
-5. … die Architektur einer produktionsreifen OR-Plattform skizzieren.
-6. … eine **modellunabhängige Abnahmeprüfung** schreiben, die eine Lösung gegen die
+4. … für jede Nebenbedingung beziffern, was sie den Plan kostet — und begründen, warum
+   der Schattenpreis diese Frage nur für die *nächste* Einheit beantwortet.
+5. … Zeitlimits und Optimalitätslücken sinnvoll setzen.
+6. … die Architektur einer produktionsreifen OR-Plattform skizzieren.
+7. … eine **modellunabhängige Abnahmeprüfung** schreiben, die eine Lösung gegen die
    Anforderungen prüft statt gegen das Modell.
-7. … Status, Gap und Zeitausschöpfung protokollieren und begründen, warum eine konstante
+8. … Status, Gap und Zeitausschöpfung protokollieren und begründen, warum eine konstante
    Laufzeit bei Zeitlimit ein Warnsignal ist.
-8. … ein Modell in Domänenschicht, Modellbauer und Lösungs-DTO trennen — und begründen,
+9. … ein Modell in Domänenschicht, Modellbauer und Lösungs-DTO trennen — und begründen,
    warum sich das nicht wegen des Solverwechsels lohnt, sondern wegen der Prüfbarkeit.
-9. … die Statuswerte verschiedener Solverbibliotheken auf eine gemeinsame Sprache
+10. … die Statuswerte verschiedener Solverbibliotheken auf eine gemeinsame Sprache
    abbilden.
 
 ---
@@ -373,6 +376,10 @@ technisch aus, aber selbst wenn er dürfte, wäre er wegen seiner Vorbelastung i
 teurer als Anna. **Eine bindende Bedingung zu lockern hilft nur, wenn sie tatsächlich die
 kostenrelevante ist** — sonst ist die Mühe umsonst.
 
+Derselbe Unterschied kehrt auf Modellebene wieder, und dort lässt er sich in Euro
+beziffern: {ref:sec:praxisfallen-attribution} misst für jede Bedingung, was sie den
+ganzen Plan kostet — und baut daraus einen Bericht, den man vorlegen kann.
+
 ### Falle 3 — Regimewechsel und Schätzfehler
 
 Ein Modell, das auf einer mehrjährigen Aufwärtsphase kalibriert wurde, kennt keine
@@ -415,6 +422,500 @@ wächst nicht linear mit der Problemgröße.
 
 ---
 
+## Constraint Attribution: welche Bedingung kostet wie viel? {#sec:praxisfallen-attribution}
+
+Der Constraint-Trace beantwortet „warum **diese** Zuweisung?“. Der Deletion Filter in
+{ref:anhang:fehlerdiagnose} beantwortet „warum geht es **gar nicht**?“. Der häufigste Fall
+in der Praxis liegt dazwischen, und für ihn hat bisher niemand ein Werkzeug bekommen:
+
+> *Das Modell rechnet. Der Plan ist zulässig. Und trotzdem ist er enttäuschend — nur weiß
+> niemand, woran es liegt.*
+
+Die Antwort heißt **Constraint Attribution**{idx:Constraint Attribution}: Jede
+Bedingungsgruppe wird einzeln gelockert, und gemessen wird, was sich am Zielwert ändert. Das
+ist dasselbe Verfahren wie der Deletion Filter — nur mit **Kosten** statt Zulässigkeit als
+Kriterium.
+
+Gerechnet wird auf derselben Fabrik wie die Konfliktsuche in {ref:anhang:fehlerdiagnose},
+aber **nach der Reparatur**: Dort war die Lackierkapazität von 150 Stunden der Kern des
+Widerspruchs ($2 \cdot 40 + 3 \cdot 30 = 170 > 150$). Eine zweite Schicht hat sie auf 210
+gebracht, der Mindestumsatz wurde auf 10 000 € gesenkt. Jetzt ist das Modell lösbar — und
+die Frage lautet nicht mehr „warum nicht?“, sondern „was kostet uns was?“.
+
+```python
+#!/usr/bin/env python3
+
+# Constraint_Attribution.py
+"""
+Kapitel Praxisfallen: Welche Bedingung kostet wie viel - und was sagt man
+dem Management?
+
+Zwischen den beiden bekannten Faellen klafft eine Luecke:
+
+  * Erklaerbarkeit.py beantwortet "warum diese eine Zuweisung?"
+  * Konfliktsuche.py (Anhang Fehlerdiagnose) beantwortet "warum geht es gar
+    nicht?"
+
+Der haeufigste Fall in der Praxis liegt dazwischen: Das Modell rechnet, der
+Plan ist zulaessig - und trotzdem unbefriedigend. Niemand weiss, WORAN es
+liegt. Genau das beantwortet Constraint Attribution.
+
+Gerechnet wird auf derselben Fabrik wie in Konfliktsuche.py, nur nach der
+Reparatur: Dort war die Lackierkapazitaet von 150 Stunden der Kern des
+Widerspruchs (2*40 + 3*30 = 170 > 150). Eine zweite Schicht hat sie auf 210
+gebracht, und der Mindestumsatz wurde auf 10.000 EUR gesenkt. Jetzt ist das
+Modell loesbar - und die Frage lautet nicht mehr "warum nicht?", sondern
+"was kostet uns was?".
+
+Gezeigt werden vier Dinge:
+  1. Welche Bedingungen binden - und dass "bindend" nicht "teuer" heisst.
+  2. Dass der Schattenpreis eine MOMENTAUFNAHME ist: hochgerechnet auf eine
+     realistische Sonderschicht verspricht er hier das Doppelte des
+     tatsaechlichen Nutzens.
+  3. Dass ein Wunsch aus dem Vertrieb nicht teuer, sondern unmoeglich sein
+     kann - und welche Bedingungen ihn gemeinsam blockieren.
+  4. Wie aus alledem ein Bericht in Alltagssprache wird.
+
+Benoetigt: numpy, scipy
+"""
+
+from __future__ import annotations
+
+import textwrap
+
+import numpy as np
+from scipy.optimize import linprog
+
+PRODUKTE = ["Rahmen", "Gehaeuse", "Deckel", "Traeger", "Halter"]
+DECKUNGSBEITRAG = np.array([35.0, 28.0, 9.0, 22.0, 6.0])   # EUR je Stueck
+
+# Dieselben Bedingungen wie in Konfliktsuche.py, mit den beiden Reparaturen.
+# Der sprechende Name ist keine Kosmetik: Ohne ihn ist kein Bericht moeglich,
+# der jemandem ausserhalb der Modellierung etwas sagt.
+BEDINGUNGEN: list[tuple[str, list[float], str, float]] = [
+    ("Kapazitaet Montage",       [3, 2, 1, 4, 2],      "<=",   400),
+    ("Kapazitaet Lackieren",     [2, 3, 0, 1, 0],      "<=",   210),
+    ("Kapazitaet Pruefung",      [1, 1, 1, 1, 1],      "<=",   300),
+    ("Liefervertrag Rahmen",     [1, 0, 0, 0, 0],      ">=",    40),
+    ("Liefervertrag Gehaeuse",   [0, 1, 0, 0, 0],      ">=",    30),
+    ("Liefervertrag Deckel",     [0, 0, 1, 0, 0],      ">=",    20),
+    ("Liefervertrag Traeger",    [0, 0, 0, 1, 0],      ">=",    25),
+    ("Marktgrenze Rahmen",       [1, 0, 0, 0, 0],      "<=",   120),
+    ("Marktgrenze Gehaeuse",     [0, 1, 0, 0, 0],      "<=",    90),
+    ("Marktgrenze Deckel",       [0, 0, 1, 0, 0],      "<=",   150),
+    ("Marktgrenze Halter",       [0, 0, 0, 0, 1],      "<=",   200),
+    ("Mindestumsatz",            [90, 70, 30, 60, 20], ">=", 10000),
+    ("Sortimentsbreite",         [0, 0, 1, 1, 1],      ">=",   100),
+    ("Lackierbudget Schicht 2",  [0, 1, 0, 1, 0],      "<=",    55),
+]
+
+# Was liesse sich im Ernstfall wirklich bewegen - und um wie viel? Nicht "eine
+# Einheit", sondern der Schritt, den ein Planer tatsaechlich gehen kann: eine
+# Sonderschicht, ein nachverhandelter Vertrag. Genau an dieser Groesse
+# scheitert das blosse Hochrechnen des Schattenpreises.
+STELLSCHRAUBEN: dict[str, tuple[float, str]] = {
+    "Kapazitaet Montage":      (+50, "eine Sonderschicht Montage"),
+    "Kapazitaet Lackieren":    (+30, "eine Sonderschicht Lackieren"),
+    "Kapazitaet Pruefung":     (+50, "eine Sonderschicht Pruefung"),
+    "Lackierbudget Schicht 2": (+10, "10 Stunden mehr Budget in Schicht 2"),
+    "Liefervertrag Traeger":   (-10, "10 Stueck weniger Abnahmepflicht Traeger"),
+    "Liefervertrag Gehaeuse":  (-10, "10 Stueck weniger Abnahmepflicht Gehaeuse"),
+}
+
+WUNSCH_MENGE = 55.0      # der Vertrieb haette gern mehr Rahmen
+WUNSCH_PRODUKT = "Rahmen"
+
+
+def loese(bedingungen: list[tuple[str, list[float], str, float]]):
+    """Maximiert den Deckungsbeitrag. linprog minimiert, daher das Vorzeichen."""
+    matrix, rechte_seite = [], []
+    for _, koeffizienten, richtung, grenze in bedingungen:
+        zeile = np.array(koeffizienten, dtype=float)
+        matrix.append(zeile if richtung == "<=" else -zeile)
+        rechte_seite.append(grenze if richtung == "<=" else -grenze)
+    return linprog(-DECKUNGSBEITRAG,
+                   A_ub=np.array(matrix), b_ub=np.array(rechte_seite),
+                   bounds=[(0, None)] * len(PRODUKTE), method="highs")
+
+
+def geaendert(name: str, delta: float,
+              basis=None) -> list[tuple[str, list[float], str, float]]:
+    """Dieselben Bedingungen, eine davon um delta verschoben."""
+    return [(n, k, r, g + delta if n == name else g)
+            for n, k, r, g in (basis or BEDINGUNGEN)]
+
+
+def auswertung(ergebnis, bedingungen=None):
+    """Schlupf und Schattenpreis je Bedingung."""
+    x = ergebnis.x
+    dual = ergebnis.ineqlin.marginals
+    zeilen = []
+    for i, (name, koeff, richtung, grenze) in enumerate(bedingungen or BEDINGUNGEN):
+        links = float(np.array(koeff, dtype=float) @ x)
+        schlupf = (grenze - links) if richtung == "<=" else (links - grenze)
+        zeilen.append((name, links, richtung, grenze, schlupf, abs(dual[i])))
+    return zeilen
+
+
+def blockierer(bedingungen, zusatz) -> list[str]:
+    """Welche Bedingungen verhindern 'zusatz' - einzeln weggelassen.
+
+    Dasselbe Vorgehen wie der Deletion Filter in Konfliktsuche.py, nur mit
+    umgekehrtem Vorzeichen: Dort wird gesucht, was den Widerspruch AUSMACHT,
+    hier, was einen Wunsch VERHINDERT. Wird das Modell ohne eine Bedingung
+    loesbar, gehoert sie zum Konflikt.
+    """
+    gefunden = []
+    for i, (name, _, _, _) in enumerate(bedingungen):
+        rest = [c for j, c in enumerate(bedingungen) if j != i] + [zusatz]
+        if loese(rest).success:
+            gefunden.append(name)
+    return gefunden
+
+
+def euro(betrag: float) -> str:
+    return f"{betrag:,.2f} EUR"
+
+
+if __name__ == "__main__":
+    basis = loese(BEDINGUNGEN)
+    db_basis = -basis.fun
+    plan = dict(zip(PRODUKTE, basis.x))
+
+    print("=" * 78)
+    print("  CONSTRAINT ATTRIBUTION: Was kostet uns welche Bedingung?")
+    print("=" * 78)
+    print(f"Status: {basis.message.split('(')[0].strip()}")
+    print(f"Deckungsbeitrag des Plans: {euro(db_basis)}\n")
+    print("  " + "  ".join(f"{p}: {m:.1f}" for p, m in plan.items()))
+
+    # --- 1. Wer begrenzt den Plan? -----------------------------------------
+    print("\n" + "=" * 78)
+    print("  (1) Welche Bedingungen binden - und was kostet die naechste Einheit?")
+    print("=" * 78)
+    print(f"{'Bedingung':<24} {'genutzt':>9} {'Grenze':>7} {'Schlupf':>8} "
+          f"{'Schattenpreis':>11}")
+    print("-" * 78)
+    bindend = []
+    for name, links, richtung, grenze, schlupf, dual in auswertung(basis):
+        marke = ""
+        if abs(schlupf) < 1e-6:
+            bindend.append((name, dual))
+            marke = "  <-- bindend"
+        print(f"{name:<24} {links:>9.1f} {grenze:>7.0f} {schlupf:>8.1f} "
+              f"{dual:>11.2f}{marke}")
+
+    ohne_preis = [n for n, d in bindend if d < 1e-9]
+    print(f"\n  {len(bindend)} Bedingungen binden. Aber: "
+          f"{', '.join(ohne_preis)} bindet")
+    print("  mit einem Schattenpreis von 0,00 EUR - sie beruehrt den Plan, ohne ihn")
+    print("  zu verteuern. Bindend und kostenrelevant sind zwei verschiedene Dinge.")
+
+    # --- 2. Der Schattenpreis als Momentaufnahme ---------------------------
+    print("\n" + "=" * 78)
+    print("  (2) Was der Schattenpreis verschweigt")
+    print("=" * 78)
+    print("Der Schattenpreis gilt fuer die NAECHSTE Einheit. Ein Planer kauft aber")
+    print("keine Einheit, sondern eine ganze Schicht. Beides gegenuebergestellt:\n")
+    preise = {name: dual for name, *_, dual in auswertung(basis)}
+    print(f"{'Stellschraube':<24} {'Preis':>9} {'Schritt':>7} "
+          f"{'hochgerechnet':>13} {'gemessen':>9} {'Abw.':>9}")
+    print("-" * 78)
+    wirkung = {}
+    for name, (delta, _) in STELLSCHRAUBEN.items():
+        ergebnis = loese(geaendert(name, delta))
+        echt = (-ergebnis.fun) - db_basis if ergebnis.success else 0.0
+        linear = preise[name] * abs(delta)
+        wirkung[name] = echt
+        print(f"{name:<24} {preise[name]:>9.2f} {delta:>+7.0f} "
+              f"{linear:>13.2f} {echt:>9.2f} {echt - linear:>+9.2f}")
+
+    # Wo endet der Gueltigkeitsbereich? Schrittweise nachfahren.
+    abweichler = max(STELLSCHRAUBEN,
+                     key=lambda n: preise[n] * abs(STELLSCHRAUBEN[n][0]) - wirkung[n])
+    delta_max = STELLSCHRAUBEN[abweichler][0]
+    grenze_gueltig = 0.0
+    schritt = delta_max / 60.0
+    vorher = db_basis
+    for i in range(1, 61):
+        d = schritt * i
+        e = loese(geaendert(abweichler, d))
+        db = -e.fun if e.success else vorher
+        if db - vorher > 1e-9:
+            grenze_gueltig = d
+        vorher = db
+    print(f"\n  '{abweichler}': hochgerechnet "
+          f"{preise[abweichler] * abs(delta_max):.2f} EUR, tatsaechlich "
+          f"{wirkung[abweichler]:.2f} EUR.")
+    print(f"  Der Preis von {preise[abweichler]:.2f} EUR gilt nur bis "
+          f"+{grenze_gueltig:.0f} Stunden. Jede weitere Stunde")
+    print("  dieser Sonderschicht bringt exakt nichts - der Engpass ist dann ein anderer.")
+
+    nach_preis = sorted(STELLSCHRAUBEN, key=lambda n: -preise[n])[0]
+    nach_wirkung = max(wirkung, key=wirkung.get)
+    print(f"\n  Und die Ranglisten drehen sich: Nach Schattenpreis fuehrt")
+    print(f"  '{nach_preis}' ({preise[nach_preis]:.2f} EUR je Einheit),")
+    print(f"  nach tatsaechlicher Wirkung '{nach_wirkung}' "
+          f"({wirkung[nach_wirkung]:.2f} EUR).")
+    print("  Der Schattenpreis sagt, was eine Einheit wert ist - nicht, wie viele")
+    print("  Einheiten zu haben sind.")
+
+    # --- 3. Der Wunsch aus dem Vertrieb ------------------------------------
+    print("\n" + "=" * 78)
+    print(f"  (3) Was-waere-wenn: mindestens {WUNSCH_MENGE:.0f} "
+          f"{WUNSCH_PRODUKT} statt {plan[WUNSCH_PRODUKT]:.1f}")
+    print("=" * 78)
+    wunsch = (f"Wunsch Vertrieb {WUNSCH_PRODUKT}",
+              [1 if p == WUNSCH_PRODUKT else 0 for p in PRODUKTE], ">=", WUNSCH_MENGE)
+    mit_wunsch = loese(BEDINGUNGEN + [wunsch])
+    schuldige: list[str] = []
+    engpass = noetig = None
+    wunsch_gratis = False
+
+    if mit_wunsch.success:
+        print(f"Erfuellbar, kostet {euro(db_basis - (-mit_wunsch.fun))}.")
+    else:
+        schuldige = blockierer(BEDINGUNGEN, wunsch)
+        print("Der Wunsch ist nicht teuer - er ist UNMOEGLICH.\n")
+        print(f"Blockiert wird er von {len(schuldige)} Bedingungen gemeinsam. "
+              f"Faellt eine davon")
+        print("weg, ist er erfuellbar; keine allein ist 'der' Grund:")
+        for name in schuldige:
+            e = loese([c for c in BEDINGUNGEN if c[0] != name] + [wunsch])
+            print(f"   ohne '{name}': moeglich, Deckungsbeitrag {euro(-e.fun)}")
+
+        engpass = next((n for n in schuldige if n in STELLSCHRAUBEN), schuldige[0])
+        for schritt in range(1, 61):
+            if loese(geaendert(engpass, schritt) + [wunsch]).success:
+                noetig = schritt
+                break
+        if noetig is not None:
+            e = loese(geaendert(engpass, noetig) + [wunsch])
+            ohne = loese(geaendert(engpass, noetig))
+            wunsch_gratis = abs((-e.fun) - (-ohne.fun)) < 1e-6
+            print(f"\n   Mit +{noetig} bei '{engpass}' wird der Wunsch erfuellbar:")
+            print(f"   Deckungsbeitrag {euro(-e.fun)} "
+                  f"({-e.fun - db_basis:+,.2f} gegenueber heute).")
+            if wunsch_gratis:
+                print(f"   Und ohne den Wunsch ergaebe dieselbe Lockerung "
+                      f"{euro(-ohne.fun)} bei")
+                print(f"   {ohne.x[PRODUKTE.index(WUNSCH_PRODUKT)]:.0f} "
+                      f"{WUNSCH_PRODUKT} - der Wunsch kostet also NICHTS.")
+                print("   Er war nie das Problem. Der Engpass war es.")
+
+    # --- 4. Der Bericht ----------------------------------------------------
+    # Aus denselben Zahlen, die oben in Tabellen stehen, wird hier Prosa. Kein
+    # Satz enthaelt eine Zahl, die nicht vorher gerechnet wurde - das ist der
+    # ganze Trick und zugleich die Bedingung dafuer, dass der Bericht nicht
+    # irgendwann leise falsch wird.
+    print("\n" + "=" * 78)
+    print("  (4) Und so steht es in der Vorlage fuer die Abteilungsleiterrunde")
+    print("=" * 78)
+
+    teuerste = sorted(((n, d) for n, d in bindend if d > 0), key=lambda t: -t[1])
+    gross = STELLSCHRAUBEN[nach_wirkung][1]
+    klein = STELLSCHRAUBEN[abweichler][1]
+
+    absaetze = [
+        f"Der Plan bringt {euro(db_basis)} Deckungsbeitrag. Begrenzt wird er von "
+        f"{len(bindend)} Bedingungen, von denen {len(teuerste)} tatsaechlich Geld "
+        f"kosten; \"{ohne_preis[0]}\" beruehrt den Plan, ohne ihn zu verteuern.",
+
+        f"Teuerste Bindung ist \"{teuerste[0][0]}\" mit "
+        f"{teuerste[0][1]:.2f} EUR je Einheit, gefolgt von \"{teuerste[1][0]}\" "
+        f"mit {teuerste[1][1]:.2f} EUR.",
+
+        f"Die groesste einzelne Verbesserung bringt {gross}: "
+        f"{euro(wirkung[nach_wirkung])} mehr Deckungsbeitrag. {klein[0].upper()}{klein[1:]} "
+        f"dagegen bringt nur {euro(wirkung[abweichler])} statt der rechnerischen "
+        f"{euro(preise[abweichler] * abs(delta_max))} - ab +{grenze_gueltig:.0f} "
+        f"Stunden begrenzt uns etwas anderes. Wer die ganze Schicht bezahlt, "
+        f"bezahlt die zweite Haelfte umsonst.",
+    ]
+
+    if schuldige and noetig is not None:
+        namen = ", ".join(f'"{s}"' for s in schuldige)
+        satz = (f"Zum Wunsch des Vertriebs ({WUNSCH_MENGE:.0f} {WUNSCH_PRODUKT} statt "
+                f"{plan[WUNSCH_PRODUKT]:.1f}): Er ist mit der heutigen Ausstattung "
+                f"nicht erfuellbar - nicht aus Kostengruenden, sondern weil {namen} "
+                f"ihn gemeinsam blockieren. Mit +{noetig} Stunden bei "
+                f'"{engpass}" wird er moeglich')
+        satz += (", und er kostet dann nichts: Der Plan waehlt diese Menge von "
+                 "sich aus." if wunsch_gratis else ".")
+        absaetze.append(satz)
+
+    for absatz in absaetze:
+        print()
+        print(textwrap.fill(absatz, width=76))
+    print("\n" + "=" * 78)
+```
+
+**Ausgabe:**
+
+```
+==============================================================================
+  CONSTRAINT ATTRIBUTION: Was kostet uns welche Bedingung?
+==============================================================================
+Status: Optimization terminated successfully.
+Deckungsbeitrag des Plans: 3,930.00 EUR
+
+  Rahmen: 47.5  Gehaeuse: 30.0  Deckel: 97.5  Traeger: 25.0  Halter: 0.0
+
+==============================================================================
+  (1) Welche Bedingungen binden - und was kostet die naechste Einheit?
+==============================================================================
+Bedingung                  genutzt  Grenze  Schlupf Schattenpreis
+------------------------------------------------------------------------------
+Kapazitaet Montage           400.0     400      0.0        9.00  <-- bindend
+Kapazitaet Lackieren         210.0     210      0.0        4.00  <-- bindend
+Kapazitaet Pruefung          200.0     300    100.0        0.00
+Liefervertrag Rahmen          47.5      40      7.5        0.00
+Liefervertrag Gehaeuse        30.0      30      0.0        2.00  <-- bindend
+Liefervertrag Deckel          97.5      20     77.5        0.00
+Liefervertrag Traeger         25.0      25      0.0       18.00  <-- bindend
+Marktgrenze Rahmen            47.5     120     72.5        0.00
+Marktgrenze Gehaeuse          30.0      90     60.0        0.00
+Marktgrenze Deckel            97.5     150     52.5        0.00
+Marktgrenze Halter             0.0     200    200.0        0.00
+Mindestumsatz              10800.0   10000    800.0        0.00
+Sortimentsbreite             122.5     100     22.5        0.00
+Lackierbudget Schicht 2       55.0      55      0.0        0.00  <-- bindend
+
+  5 Bedingungen binden. Aber: Lackierbudget Schicht 2 bindet
+  mit einem Schattenpreis von 0,00 EUR - sie beruehrt den Plan, ohne ihn
+  zu verteuern. Bindend und kostenrelevant sind zwei verschiedene Dinge.
+
+==============================================================================
+  (2) Was der Schattenpreis verschweigt
+==============================================================================
+Der Schattenpreis gilt fuer die NAECHSTE Einheit. Ein Planer kauft aber
+keine Einheit, sondern eine ganze Schicht. Beides gegenuebergestellt:
+
+Stellschraube                Preis Schritt hochgerechnet  gemessen      Abw.
+------------------------------------------------------------------------------
+Kapazitaet Montage            9.00     +50        450.00    450.00     +0.00
+Kapazitaet Lackieren          4.00     +30        120.00     60.00    -60.00
+Kapazitaet Pruefung           0.00     +50          0.00      0.00     +0.00
+Lackierbudget Schicht 2       0.00     +10          0.00      0.00     +0.00
+Liefervertrag Traeger        18.00     -10        180.00    180.00     +0.00
+Liefervertrag Gehaeuse        2.00     -10         20.00     18.00     -2.00
+
+  'Kapazitaet Lackieren': hochgerechnet 120.00 EUR, tatsaechlich 60.00 EUR.
+  Der Preis von 4.00 EUR gilt nur bis +15 Stunden. Jede weitere Stunde
+  dieser Sonderschicht bringt exakt nichts - der Engpass ist dann ein anderer.
+
+  Und die Ranglisten drehen sich: Nach Schattenpreis fuehrt
+  'Liefervertrag Traeger' (18.00 EUR je Einheit),
+  nach tatsaechlicher Wirkung 'Kapazitaet Montage' (450.00 EUR).
+  Der Schattenpreis sagt, was eine Einheit wert ist - nicht, wie viele
+  Einheiten zu haben sind.
+
+==============================================================================
+  (3) Was-waere-wenn: mindestens 55 Rahmen statt 47.5
+==============================================================================
+Der Wunsch ist nicht teuer - er ist UNMOEGLICH.
+
+Blockiert wird er von 3 Bedingungen gemeinsam. Faellt eine davon
+weg, ist er erfuellbar; keine allein ist 'der' Grund:
+   ohne 'Kapazitaet Lackieren': moeglich, Deckungsbeitrag 3,990.00 EUR
+   ohne 'Liefervertrag Gehaeuse': moeglich, Deckungsbeitrag 3,948.00 EUR
+   ohne 'Liefervertrag Traeger': moeglich, Deckungsbeitrag 4,320.00 EUR
+
+   Mit +15 bei 'Kapazitaet Lackieren' wird der Wunsch erfuellbar:
+   Deckungsbeitrag 3,990.00 EUR (+60.00 gegenueber heute).
+   Und ohne den Wunsch ergaebe dieselbe Lockerung 3,990.00 EUR bei
+   55 Rahmen - der Wunsch kostet also NICHTS.
+   Er war nie das Problem. Der Engpass war es.
+
+==============================================================================
+  (4) Und so steht es in der Vorlage fuer die Abteilungsleiterrunde
+==============================================================================
+
+Der Plan bringt 3,930.00 EUR Deckungsbeitrag. Begrenzt wird er von 5
+Bedingungen, von denen 4 tatsaechlich Geld kosten; "Lackierbudget Schicht 2"
+beruehrt den Plan, ohne ihn zu verteuern.
+
+Teuerste Bindung ist "Liefervertrag Traeger" mit 18.00 EUR je Einheit,
+gefolgt von "Kapazitaet Montage" mit 9.00 EUR.
+
+Die groesste einzelne Verbesserung bringt eine Sonderschicht Montage: 450.00
+EUR mehr Deckungsbeitrag. Eine Sonderschicht Lackieren dagegen bringt nur
+60.00 EUR statt der rechnerischen 120.00 EUR - ab +15 Stunden begrenzt uns
+etwas anderes. Wer die ganze Schicht bezahlt, bezahlt die zweite Haelfte
+umsonst.
+
+Zum Wunsch des Vertriebs (55 Rahmen statt 47.5): Er ist mit der heutigen
+Ausstattung nicht erfuellbar - nicht aus Kostengruenden, sondern weil
+"Kapazitaet Lackieren", "Liefervertrag Gehaeuse", "Liefervertrag Traeger"
+ihn gemeinsam blockieren. Mit +15 Stunden bei "Kapazitaet Lackieren" wird er
+moeglich, und er kostet dann nichts: Der Plan waehlt diese Menge von sich
+aus.
+
+==============================================================================
+```
+
+### Drei Befunde, und keiner steht im Solverergebnis
+
+**Erstens: bindend heißt nicht teuer.** Fünf Bedingungen binden, aber „Lackierbudget
+Schicht 2“ tut es mit einem Schattenpreis von **0,00 €**. Sie berührt den Plan, ohne ihn zu
+verteuern — wer sie nachverhandelt, gewinnt nichts. Das ist derselbe Unterschied, den
+`Erklaerbarkeit.py` oben an einer einzelnen Zuweisung zeigt, hier im Dualwert eines LP.
+
+**Zweitens: Der Schattenpreis ist eine Momentaufnahme.** Er gilt für die **nächste**
+Einheit. Ein Planer kauft aber keine Einheit, sondern eine Schicht. Für die Lackiererei
+verspricht die Hochrechnung $4{,}00 \cdot 30 = 120$ €; gemessen kommen **60 €**. Der Preis
+von 4,00 € gilt exakt bis **+15 Stunden**, danach begrenzt etwas anderes — **die zweite
+Hälfte der Sonderschicht wäre bezahlt und wirkungslos.**
+
+Und die Ranglisten drehen sich dabei um: Nach Schattenpreis führt der Trägervertrag mit
+18,00 € je Stück, nach tatsächlicher Wirkung die Montage-Sonderschicht mit 450 €. Der
+Schattenpreis sagt, was **eine** Einheit wert ist — nicht, wie viele Einheiten zu haben
+sind. Für die Frage „welchen Hebel ziehen wir?“ ist das der entscheidende Unterschied.
+
+**Drittens: Ein Wunsch kann unmöglich statt teuer sein.** Der Vertrieb hätte gern
+55 Rahmen statt 47,5. Das Modell antwortet nicht mit einem Preis, sondern mit
+`INFEASIBLE` — und drei Bedingungen blockieren den Wunsch **gemeinsam**: Fällt eine davon
+weg, ist er erfüllbar, keine allein ist „der“ Grund. Genau die Struktur, die
+{ref:anhang:fehlerdiagnose} für den unlösbaren Fall beschreibt, hier auf einen Wunsch
+angewandt.
+
+Die Pointe steht am Ende: Mit +15 Stunden Lackierkapazität wird der Wunsch erfüllbar — und
+kostet dann **nichts**. Der Plan wählt diese Menge von sich aus, sobald der Engpass weg ist.
+Der Konflikt bestand nie zwischen Vertrieb und Produktion. Er bestand zwischen dem Vertrieb
+und der Lackiererei, und niemand wusste das.
+
+> **🎯 Die drei Fragen, jetzt auf Modellebene**
+> Die Faustregel oben stellt sie für eine einzelne Zuweisung. Constraint Attribution stellt
+> dieselben drei für den **ganzen Plan**:
+> 1. **Warum dieser Zielwert?** — welche Bedingungen binden, und welche davon kosten Geld.
+> 2. **Warum nicht besser?** — was eine realistische Lockerung wirklich bringt, gemessen
+>    statt hochgerechnet.
+> 3. **Was ist mit meinem Wunsch?** — erfüllbar und zu welchem Preis, oder unmöglich und
+>    warum.
+
+### Vom Zahlenwerk zur Vorlage
+
+Alle drei Antworten stehen bis hierhin in Tabellen. Tabellen liest niemand in einer
+Abteilungsleiterrunde. Teil (4) des Programms baut aus **denselben** Zahlen einen Text —
+und das ist weniger trivial, als es aussieht:
+
+* **Kein Satz enthält eine Zahl, die nicht vorher gerechnet wurde.** Auch nicht die
+  Rangfolge, auch nicht die Namen der blockierenden Bedingungen. Sobald sich das Modell
+  ändert, ändert sich der Bericht mit — er kann nicht leise falsch werden.
+* **Der sprechende Name jeder Bedingung ist die Voraussetzung dafür.** `A_ub[7]` ergibt
+  keinen Satz. Deshalb tragen die Bedingungen in beiden Programmen einen Namen, und deshalb
+  ist das keine Kosmetik.
+
+> **⚠️ Was ein solcher Bericht nicht leistet**
+> Er erklärt das **Modell**, nicht die **Wirklichkeit**. „Liefervertrag Träger kostet 18 €
+> je Stück“ heißt: *in diesem Modell, mit diesen Deckungsbeiträgen*. Ist ein
+> Deckungsbeitrag falsch geschätzt, ist der Bericht überzeugend **und** falsch — die
+> gefährlichste Kombination. Ein generierter Text macht ein Modell nicht richtiger, nur
+> schwerer anzuzweifeln. Deshalb gehört zu jedem solchen Bericht die Angabe, worauf er
+> beruht.
+
+---
+
 ## Architektur einer produktionsreifen OR-Plattform {#sec:praxisfallen-architektur-einer-produktionsreifen-or-plattform}
 
 ![Architektur einer produktionsreifen OR-Plattform](bilder_04/kap15_or_plattform.svg)
@@ -1165,9 +1666,9 @@ Benoetigt: numpy, pydantic, ortools, highspy (jeweils im eigenen Prozess)
 
 from __future__ import annotations
 
-import subprocess
-import sys
+import multiprocessing
 import time
+from concurrent.futures import ProcessPoolExecutor
 
 import numpy as np
 from pydantic import BaseModel, Field, model_validator
@@ -1370,25 +1871,29 @@ def geoeffnete_lager(problem: Standortproblem, loesung: Loesung) -> list[str]:
             if any(loesung.werte[problem.schluessel(i, j)] > 0.5 for j in range(m))]
 
 
-def loese_in_eigenem_prozess(name: str) -> Loesung:
-    """Startet dieses Programm noch einmal - mit genau einem Solverimport."""
-    ergebnis = subprocess.run([sys.executable, __file__, name],
-                              capture_output=True, text=True, timeout=300)
-    if ergebnis.returncode != 0:
-        raise RuntimeError(ergebnis.stderr.strip().splitlines()[-1])
-    # Das DTO als JSON - genau dafuer ist ein Datenobjekt ohne Solverbezug gut.
-    return Loesung.model_validate_json(ergebnis.stdout.strip().splitlines()[-1])
+def loese_in_eigenem_prozess(name: str, problem: Standortproblem) -> Loesung:
+    """Laesst genau einen Modellbauer in einem frischen Prozess rechnen.
+
+    'spawn' statt des Linux-Standards 'fork': Der Kindprozess startet mit
+    einem leeren Interpreter und importiert nur den Solver, den SEIN
+    Modellbauer braucht. max_tasks_per_child=1 sorgt dafuer, dass der Pool
+    seinen Arbeiter nicht wiederverwendet - sonst saessen beim zweiten Aufruf
+    wieder beide Bibliotheken im selben Prozess.
+
+    Hin und zurueck wandert das Domaenenmodell bzw. das Loesungs-DTO. Beide
+    kennen keinen Solver, sind also serialisierbar - genau dafuer sind sie da.
+    """
+    with ProcessPoolExecutor(
+            max_workers=1,
+            mp_context=multiprocessing.get_context("spawn"),
+            max_tasks_per_child=1) as pool:
+        return pool.submit(MODELLBAUER[name], problem).result(timeout=300)
 
 
 if __name__ == "__main__":
     problem = beispielproblem()
 
-    # --- Kindprozess: rechnen und das DTO als JSON ausgeben ---------------
-    if len(sys.argv) > 1:
-        print(MODELLBAUER[sys.argv[1]](problem).model_dump_json())
-        sys.exit(0)
-
-    # --- Hauptprozess: beide Solver anstossen und vergleichen -------------
+    # --- Beide Solver anstossen und vergleichen ---------------------------
     print("=" * 82)
     print("  DERSELBE FALL, ZWEI SOLVER - UND EIN AUSWERTUNGSCODE")
     print("=" * 82)
@@ -1400,7 +1905,7 @@ if __name__ == "__main__":
     loesungen: dict[str, Loesung] = {}
     for name, beschriftung in [("cpsat", "OR-Tools CP-SAT"),
                                ("highs", "HiGHS (highspy)")]:
-        loesung = loesungen[name] = loese_in_eigenem_prozess(name)
+        loesung = loesungen[name] = loese_in_eigenem_prozess(name, problem)
         beanstandungen = pruefe_zuordnung(problem, loesung)
 
         print(f"{beschriftung}")
@@ -1607,7 +2112,8 @@ Echtzeit, (b) Wochendienstplan, freitags erstellt, (c) Jahresproduktionsplanung,
 (d) Portfolio-Rebalancing monatlich.
 
 **Aufgabe ⭐⭐ — Relaxation einbauen.**
-Nehmen Sie Ihr Modell aus Übung 6.7 (Wochendienstplan) und machen Sie es
+Nehmen Sie Ihr Modell aus der Aufgabe *Eigener Dienstplan*
+({ref:sec:cpsat-uebungsaufgaben}) und machen Sie es
 `INFEASIBLE`-sicher: Schlupfvariablen für unbesetzte Schichten, gestaffelte Strafen. Testen
 Sie mit einem bewusst überlasteten Szenario.
 
@@ -1615,6 +2121,17 @@ Sie mit einem bewusst überlasteten Szenario.
 Erweitern Sie ein beliebiges Modell aus dem Kurs um einen `erklaere(loesung)`-Report, der
 die drei Fragen aus {ref:sec:praxisfallen-die-fuenf-typischen-praxisfallen} beantwortet.
 
+**Aufgabe ⭐⭐ — Den Bericht in die Irre führen.**
+`Constraint_Attribution.py` erzeugt seinen Bericht aus gerechneten Zahlen — richtig ist er
+deshalb noch nicht.
+(a) Setzen Sie den Deckungsbeitrag von *Deckel* von 9 € auf 20 €. Wie ändern sich Plan,
+    Rangliste und Bericht? Welche Sätze bleiben wörtlich stehen, obwohl sie jetzt etwas
+    anderes bedeuten?
+(b) Der Bericht nennt „Liefervertrag Träger" als teuerste Bindung. Formulieren Sie den
+    Satz so um, dass ein Leser erkennt, **worauf** die Aussage beruht.
+(c) Welche Angabe müsste das Programm zusätzlich ausgeben, damit ein Empfänger die
+    Belastbarkeit selbst einschätzen kann?
+
 **Aufgabe ⭐⭐⭐ — Gap gegen Laufzeit.**
 Nehmen Sie das MILP-Portfolio aus {ref:kap:milp} und vergrößern Sie es auf 50 Anlagen. Messen
 Sie Laufzeit und Zielwert bei Gap-Vorgaben von 10 %, 5 %, 2 %, 1 %, 0,1 % und 0 %.
@@ -1637,7 +2154,7 @@ eigene Projekte ab?
 Falle 5 — die Laufzeitexplosion — zeigt sich im Betrieb selten als Absturz. Sie zeigt
 sich als **gar nichts**.
 
-> **🐛 Finde den Denkfehler 15.1: Das Modell, das seit einem Jahr nicht mehr optimiert**
+> **🐛 Finde den Denkfehler: Das Modell, das seit einem Jahr nicht mehr optimiert**
 >
 > Ein Standortplanungsmodell geht 2024 in Betrieb. Es läuft jede Nacht, hat drei Sekunden
 > Zeitbudget und liefert zuverlässig die Kosten des Tagesplans. Das Betriebsteam
@@ -1924,7 +2441,7 @@ sichtbar wird, und gibt Zeit zum Handeln.
 
 ## Micro-Quiz {#sec:praxisfallen-quiz}
 
-> **❓ Micro-Quiz 15: Drei Fragen zum Selbstcheck**
+> **❓ Micro-Quiz: Drei Fragen zum Selbstcheck**
 >
 > Genau eine Antwort ist jeweils richtig. Auflösung in
 > [Anhang A](90_Anhang_Loesungen.md#quiz-loesung-praxisfallen).
@@ -1962,6 +2479,10 @@ sichtbar wird, und gibt Zeit zum Handeln.
 3. Warum ist ein MIP-Gap von 2 % in der Praxis meist ausreichend?
 4. Was ist das Snapshot-Prinzip und wozu dient es?
 5. Was ist der häufigste Grund, aus dem OR-Projekte scheitern?
+6. Eine Bedingung bindet, ihr Schattenpreis ist 0. Was heißt das — und was folgt daraus für
+   eine Nachverhandlung?
+7. Warum kann die Rangfolge nach Schattenpreis eine andere sein als die Rangfolge nach
+   tatsächlichem Nutzen einer Lockerung?
 
 ---
 
@@ -1971,6 +2492,16 @@ sichtbar wird, und gibt Zeit zum Handeln.
   erhält irgendwann eine Fehlermeldung statt eines Plans.
 * **Erklärbarkeit entscheidet über Akzeptanz.** Schattenpreise, Kostenzerlegung und
   Constraint-Traces sind keine Kür.
+* **Bindend heißt nicht teuer.** Eine Bedingung kann den Plan berühren und trotzdem
+  0,00 € kosten. Nur die kostenrelevanten lohnen eine Nachverhandlung.
+* **Der Schattenpreis gilt für die nächste Einheit, nicht für die nächste Schicht.**
+  Hochgerechnet auf einen realistischen Schritt überschätzt er den Nutzen — im Beispiel um
+  das Doppelte. Wer wissen will, was ein Hebel bringt, **misst** die Lockerung, statt zu
+  multiplizieren; die beiden Ranglisten können sich dabei umdrehen.
+* **Ein Wunsch kann unmöglich statt teuer sein** — und dann ist die richtige Antwort nicht
+  ein Preis, sondern die Liste der Bedingungen, die ihn gemeinsam blockieren.
+* **Ein generierter Bericht macht ein Modell nicht richtiger, nur schwerer anzuzweifeln.**
+  Er erklärt das Modell, nicht die Wirklichkeit — deshalb gehört dazu, worauf er beruht.
 * **Optimieren Sie nicht genauer als Ihre Daten.** Ein Gap von 2 % ist bei ±10 %
   Datenunsicherheit irrelevant.
 * **Der Optimierer schlägt vor, der Mensch entscheidet** — jedenfalls anfangs.
@@ -1989,4 +2520,4 @@ sichtbar wird, und gibt Zeit zum Handeln.
 
 ---
 
-*Weiter mit:* [Projektwerkstatt — acht eigene Anwendungen](59_Projektwerkstatt.md)
+*Weiter mit:* [{ref:kap:testing} — Testen, Messen, Ausliefern](51_Testing_und_Deployment.md)
diff --git a/Operations_Research_mit_Python_Version_04/51_Testing_und_Deployment.md b/Operations_Research_mit_Python_Version_04/51_Testing_und_Deployment.md
index e1d2e9a..f386979 100644
--- a/Operations_Research_mit_Python_Version_04/51_Testing_und_Deployment.md
+++ b/Operations_Research_mit_Python_Version_04/51_Testing_und_Deployment.md
@@ -787,113 +787,124 @@ Benoetigt: numpy; in den Kindprozessen scipy, highspy, ortools, cvxpy
 
 from __future__ import annotations
 
-import json
-import subprocess
-import sys
-import textwrap
+import multiprocessing
+import resource
+import time
+from concurrent.futures import ProcessPoolExecutor
+
+import numpy as np
 
 GROESSEN = [(10, 10), (32, 32), (100, 100)]   # (Lager, Kunden) -> 100 / 1.024 / 10.000 Variablen
 
 
-# Jeder Eintrag ist ein eigenstaendiges Programm: Instanz aufbauen, loesen,
-# Ergebnis als JSON ausgeben. Die Instanz wird in jedem Kindprozess aus
-# derselben Saat neu erzeugt - so reist nichts ueber die Prozessgrenze,
-# was das Ergebnis verfaelschen koennte.
-VORSPANN = """
-import json, time, resource
-import numpy as np
+# Instanz und Speichermessung stehen als gewoehnliche Funktionen hier - nicht
+# in einem String, den ein Kindprozess ausfuehrt. Jede Messfunktion baut die
+# Instanz aus derselben Saat neu auf, damit ueber die Prozessgrenze nichts
+# reist, was das Ergebnis verfaelschen koennte.
 
-def instanz(m, n):
+def instanz(m: int, n: int):
     rng = np.random.default_rng(20)
     kosten = rng.integers(5, 95, (m, n)).astype(float)
     angebot = rng.integers(50, 150, m).astype(float)
     bedarf = angebot.sum() * rng.dirichlet(np.ones(n))
     return kosten, angebot, bedarf
 
-def speicher_mb():
-    # ru_maxrss ist unter Linux in Kilobyte
+
+def speicher_mb() -> float:
+    # ru_maxrss ist unter Linux in Kilobyte. Gemessen wird der Kindprozess -
+    # deshalb muss jede Messung einen eigenen bekommen.
     return resource.getrusage(resource.RUSAGE_SELF).ru_maxrss / 1024
 
-M, N = {m}, {n}
-kosten, angebot, bedarf = instanz(M, N)
-"""
 
-ANSAETZE = {
-    "scipy.linprog": """
-        from scipy.optimize import linprog
-        t0 = time.perf_counter()
-        c = kosten.reshape(-1)
-        A_ub = np.zeros((M, M * N)); A_eq = np.zeros((N, M * N))
-        for i in range(M):
-            A_ub[i, i * N:(i + 1) * N] = 1.0
-        for j in range(N):
-            A_eq[j, j::N] = 1.0
-        aufbau = time.perf_counter() - t0
-        t0 = time.perf_counter()
-        r = linprog(c=c, A_ub=A_ub, b_ub=angebot, A_eq=A_eq, b_eq=bedarf,
-                    bounds=(0, None), method="highs")
-        loesen = time.perf_counter() - t0
-        ausgabe = (float(r.fun), aufbau, loesen, speicher_mb())
-    """,
-
-    "highspy": """
-        import highspy
-        t0 = time.perf_counter()
-        h = highspy.Highs(); h.setOptionValue("output_flag", False)
-        h.addVars(M * N, np.zeros(M * N), np.full(M * N, highspy.kHighsInf))
-        for k in range(M * N):
-            h.changeColCost(k, float(kosten.reshape(-1)[k]))
-        for i in range(M):
-            idx = np.arange(i * N, (i + 1) * N, dtype=np.int32)
-            h.addRow(-highspy.kHighsInf, float(angebot[i]), N, idx, np.ones(N))
-        for j in range(N):
-            idx = np.arange(j, M * N, N, dtype=np.int32)
-            h.addRow(float(bedarf[j]), float(bedarf[j]), M, idx, np.ones(M))
-        aufbau = time.perf_counter() - t0
-        t0 = time.perf_counter(); h.run(); loesen = time.perf_counter() - t0
-        ausgabe = (h.getInfo().objective_function_value, aufbau, loesen, speicher_mb())
-    """,
-
-    "ortools/GLOP": """
-        from ortools.linear_solver import pywraplp
-        t0 = time.perf_counter()
-        s = pywraplp.Solver.CreateSolver("GLOP")
-        x = [[s.NumVar(0, s.infinity(), f"x{i}_{j}") for j in range(N)]
-             for i in range(M)]
-        for i in range(M):
-            s.Add(sum(x[i]) <= float(angebot[i]))
-        for j in range(N):
-            s.Add(sum(x[i][j] for i in range(M)) == float(bedarf[j]))
-        s.Minimize(sum(float(kosten[i, j]) * x[i][j]
-                       for i in range(M) for j in range(N)))
-        aufbau = time.perf_counter() - t0
-        t0 = time.perf_counter(); s.Solve(); loesen = time.perf_counter() - t0
-        ausgabe = (s.Objective().Value(), aufbau, loesen, speicher_mb())
-    """,
-
-    "cvxpy": """
-        import cvxpy as cp
-        t0 = time.perf_counter()
-        x = cp.Variable((M, N), nonneg=True)
-        problem = cp.Problem(cp.Minimize(cp.sum(cp.multiply(kosten, x))),
-                             [cp.sum(x, axis=1) <= angebot,
-                              cp.sum(x, axis=0) == bedarf])
-        aufbau = time.perf_counter() - t0
-        t0 = time.perf_counter(); problem.solve(); loesen = time.perf_counter() - t0
-        ausgabe = (float(problem.value), aufbau, loesen, speicher_mb())
-    """,
-}
+def messe_scipy(m: int, n: int):
+    from scipy.optimize import linprog
+    kosten, angebot, bedarf = instanz(m, n)
+    t0 = time.perf_counter()
+    c = kosten.reshape(-1)
+    A_ub = np.zeros((m, m * n)); A_eq = np.zeros((n, m * n))
+    for i in range(m):
+        A_ub[i, i * n:(i + 1) * n] = 1.0
+    for j in range(n):
+        A_eq[j, j::n] = 1.0
+    aufbau = time.perf_counter() - t0
+    t0 = time.perf_counter()
+    r = linprog(c=c, A_ub=A_ub, b_ub=angebot, A_eq=A_eq, b_eq=bedarf,
+                bounds=(0, None), method="highs")
+    loesen = time.perf_counter() - t0
+    return float(r.fun), aufbau, loesen, speicher_mb()
 
 
-def messe(name: str, quelltext: str, m: int, n: int):
-    """Fuehrt einen Ansatz in einem eigenen Prozess aus."""
-    programm = (VORSPANN.format(m=m, n=n) + textwrap.dedent(quelltext)
-                + "\nprint(json.dumps(ausgabe))\n")
-    ergebnis = subprocess.run([sys.executable, "-c", programm],
-                              capture_output=True, text=True, timeout=600)
-    if ergebnis.returncode != 0:
-        return None, ergebnis.stderr.strip().splitlines()[-1][:60]
-    return json.loads(ergebnis.stdout.strip().splitlines()[-1]), None
+def messe_highspy(m: int, n: int):
+    import highspy
+    kosten, angebot, bedarf = instanz(m, n)
+    t0 = time.perf_counter()
+    h = highspy.Highs(); h.setOptionValue("output_flag", False)
+    h.addVars(m * n, np.zeros(m * n), np.full(m * n, highspy.kHighsInf))
+    for k in range(m * n):
+        h.changeColCost(k, float(kosten.reshape(-1)[k]))
+    for i in range(m):
+        idx = np.arange(i * n, (i + 1) * n, dtype=np.int32)
+        h.addRow(-highspy.kHighsInf, float(angebot[i]), n, idx, np.ones(n))
+    for j in range(n):
+        idx = np.arange(j, m * n, n, dtype=np.int32)
+        h.addRow(float(bedarf[j]), float(bedarf[j]), m, idx, np.ones(m))
+    aufbau = time.perf_counter() - t0
+    t0 = time.perf_counter(); h.run(); loesen = time.perf_counter() - t0
+    return h.getInfo().objective_function_value, aufbau, loesen, speicher_mb()
+
+
+def messe_ortools(m: int, n: int):
+    from ortools.linear_solver import pywraplp
+    kosten, angebot, bedarf = instanz(m, n)
+    t0 = time.perf_counter()
+    s = pywraplp.Solver.CreateSolver("GLOP")
+    x = [[s.NumVar(0, s.infinity(), f"x{i}_{j}") for j in range(n)]
+         for i in range(m)]
+    for i in range(m):
+        s.Add(sum(x[i]) <= float(angebot[i]))
+    for j in range(n):
+        s.Add(sum(x[i][j] for i in range(m)) == float(bedarf[j]))
+    s.Minimize(sum(float(kosten[i, j]) * x[i][j]
+                   for i in range(m) for j in range(n)))
+    aufbau = time.perf_counter() - t0
+    t0 = time.perf_counter(); s.Solve(); loesen = time.perf_counter() - t0
+    return s.Objective().Value(), aufbau, loesen, speicher_mb()
+
+
+def messe_cvxpy(m: int, n: int):
+    import cvxpy as cp
+    kosten, angebot, bedarf = instanz(m, n)
+    t0 = time.perf_counter()
+    x = cp.Variable((m, n), nonneg=True)
+    problem = cp.Problem(cp.Minimize(cp.sum(cp.multiply(kosten, x))),
+                         [cp.sum(x, axis=1) <= angebot,
+                          cp.sum(x, axis=0) == bedarf])
+    aufbau = time.perf_counter() - t0
+    t0 = time.perf_counter(); problem.solve(); loesen = time.perf_counter() - t0
+    return float(problem.value), aufbau, loesen, speicher_mb()
+
+
+ANSAETZE = {"scipy.linprog": messe_scipy, "highspy": messe_highspy,
+            "ortools/GLOP": messe_ortools, "cvxpy": messe_cvxpy}
+
+
+def messe(funktion, m: int, n: int):
+    """Fuehrt eine Messfunktion in einem FRISCHEN Prozess aus.
+
+    'spawn' und max_tasks_per_child=1 zusammen garantieren, was Regel 1
+    verlangt: Jede Messung sieht einen leeren Interpreter. Ohne das
+    zweite wuerde der Pool seinen Arbeiter wiederverwenden - dann waere
+    der Speicherwert der zweiten Bibliothek um die erste zu hoch, und
+    ortools und highspy saessen im selben Prozess.
+    """
+    with ProcessPoolExecutor(
+            max_workers=1,
+            mp_context=multiprocessing.get_context("spawn"),
+            max_tasks_per_child=1) as pool:
+        try:
+            return pool.submit(funktion, m, n).result(timeout=600), None
+        except Exception as fehler:
+            return None, str(fehler).strip().splitlines()[-1][:60]
 
 
 if __name__ == "__main__":
@@ -911,8 +922,8 @@ if __name__ == "__main__":
               f"{'Loesen':>9} {'Anteil':>8} {'Speicher':>10}")
         print("  " + "-" * 72)
         zielwerte = {}
-        for name, quelltext in ANSAETZE.items():
-            werte, fehler = messe(name, quelltext, m, n)
+        for name, funktion in ANSAETZE.items():
+            werte, fehler = messe(funktion, m, n)
             if werte is None:
                 print(f"  {name:<16} nicht verfuegbar: {fehler}")
                 continue
@@ -968,28 +979,28 @@ die Zielwerte und ihr Verhaeltnis zueinander nicht.
 --- 10 Lager x 10 Kunden = 100 Variablen ---------------------------------------------------
   Bibliothek             Zielwert    Aufbau    Loesen   Anteil   Speicher
   ------------------------------------------------------------------------
-  scipy.linprog         13,509.48    0.000s    0.004s       1%        78 MB
-  highspy               13,509.48    0.001s    0.002s      34%        41 MB
-  ortools/GLOP          13,509.48    0.002s    0.001s      80%        54 MB
+  scipy.linprog         13,509.48    0.000s    0.004s       1%        79 MB
+  highspy               13,509.48    0.001s    0.002s      36%        44 MB
+  ortools/GLOP          13,509.48    0.003s    0.001s      80%        56 MB
   cvxpy                 13,509.48    0.001s    0.009s       9%       229 MB
                    Spannweite der Zielwerte: 1.33e-06 (relativ 9.8e-11)
 
 --- 32 Lager x 32 Kunden = 1,024 Variablen -------------------------------------------------
   Bibliothek             Zielwert    Aufbau    Loesen   Anteil   Speicher
   ------------------------------------------------------------------------
-  scipy.linprog         35,744.25    0.000s    0.009s       4%        80 MB
-  highspy               35,744.25    0.004s    0.005s      47%        42 MB
-  ortools/GLOP          35,744.25    0.015s    0.002s      85%        55 MB
-  cvxpy                 35,744.25    0.001s    0.016s       5%       230 MB
+  scipy.linprog         35,744.25    0.000s    0.009s       3%        81 MB
+  highspy               35,744.25    0.004s    0.005s      44%        45 MB
+  ortools/GLOP          35,744.25    0.014s    0.002s      85%        58 MB
+  cvxpy                 35,744.25    0.001s    0.017s       5%       231 MB
                    Spannweite der Zielwerte: 9.54e-05 (relativ 2.7e-09)
 
 --- 100 Lager x 100 Kunden = 10,000 Variablen ----------------------------------------------
   Bibliothek             Zielwert    Aufbau    Loesen   Anteil   Speicher
   ------------------------------------------------------------------------
-  scipy.linprog         72,220.34    0.002s    0.070s       3%       120 MB
-  highspy               72,220.34    0.029s    0.034s      45%        47 MB
-  ortools/GLOP          72,220.34    0.123s    0.036s      77%        66 MB
-  cvxpy                 72,220.34    0.001s    0.103s       1%       242 MB
+  scipy.linprog         72,220.34    0.004s    0.072s       5%       122 MB
+  highspy               72,220.34    0.026s    0.032s      45%        50 MB
+  ortools/GLOP          72,220.34    0.141s    0.043s      77%        68 MB
+  cvxpy                 72,220.34    0.001s    0.108s       1%       242 MB
                    Spannweite der Zielwerte: 3.65e-04 (relativ 5.0e-09)
 
 ============================================================================================
@@ -1636,3 +1647,7 @@ Test, der eine Instanz einreicht, die das Limit überschreitet.
 * Ein **Optimierungsdienst** ist zweistufig: annehmen und prüfen sofort, rechnen im
   Hintergrund, Ergebnis mit Status und Gap abholen. Die Frage Threads oder Prozesse gehört
   gemessen — bei C++-Solvern genügen Threads, bei Python-Heuristiken nicht.
+
+---
+
+*Weiter mit:* [Synthese Teil V](52_Synthese_Praxis.md)
diff --git a/Operations_Research_mit_Python_Version_04/52_Synthese_Praxis.md b/Operations_Research_mit_Python_Version_04/52_Synthese_Praxis.md
new file mode 100644
index 0000000..1539ea5
--- /dev/null
+++ b/Operations_Research_mit_Python_Version_04/52_Synthese_Praxis.md
@@ -0,0 +1,48 @@
+# Synthese Teil V — Vom rechnenden Modell zum benutzten System
+
+Zwei Kapitel, ein Übergang: Das Modell rechnet — und muss jetzt jemand anderem übergeben
+werden. Was dabei schiefgeht, hat selten mit Mathematik zu tun.
+
+## Was schiefgeht, und was dagegen hilft
+
+| Was in Produktion passiert | Gegenmittel | Wo |
+| --- | --- | --- |
+| `INFEASIBLE` um 3 Uhr nachts, niemand weiß warum | Relaxation mit gestaffelten Strafkosten (B18); Deletion Filter für die Diagnose | {ref:kap:praxisfallen}, {ref:anhang:fehlerdiagnose} |
+| Der Disponent lehnt den Plan ab, weil er ihn nicht versteht | Constraint-Trace für die einzelne Zuweisung; Kostenzurechnung für den ganzen Plan | {ref:kap:praxisfallen}, {ref:sec:praxisfallen-attribution} |
+| Der Solver läuft ins Zeitlimit und keiner merkt es | Status, Gap und Zeitausschöpfung protokollieren — konstante Laufzeit ist ein Warnsignal | {ref:kap:praxisfallen} |
+| Ein Test wird grundlos mal rot, mal grün | auf Zielwert und Regeln prüfen, nicht auf die Gestalt der Lösung; `num_workers = 1` **und** Seed | {ref:sec:cpsat-parallele-suche}, {ref:kap:testing} |
+| Ein Ergebnis lässt sich später nicht mehr nachvollziehen | Snapshot-Prinzip: unveränderlicher Datenstand mit ID je Lauf | {ref:kap:praxisfallen} |
+| Das Modell prüft sich selbst | Abnahmeprüfung als eigener Baustein, ohne Solver und ohne Modellvariable | {ref:sec:praxisfallen-or-kern} |
+
+## Was dieser Teil gemessen hat
+
+| Behauptung | Gemessen | Wo |
+| --- | --- | --- |
+| „Der Solver nennt schon den Grund für `INFEASIBLE`." | Er nennt gar nichts. Der Deletion Filter findet einen kleinsten Konflikt — dieses Modell enthält **neun** verschiedene, und welchen man sieht, steuert die Prüfreihenfolge | {ref:anhang:fehlerdiagnose} |
+| „Bindende Bedingungen sind die teuren." | Von fünf bindenden Bedingungen kostet eine **0,00 €** | {ref:sec:praxisfallen-attribution} |
+| „Der Schattenpreis sagt, was der Hebel bringt." | Hochgerechnet 120 €, gemessen **60 €** — er gilt nur bis +15 Stunden. Die Ranglisten nach Preis und nach Wirkung drehen sich um | {ref:sec:praxisfallen-attribution} |
+| „Mehr Arbeiter sind proportional schneller." | **12,3-fach** bei acht Arbeitern — überlinear, weil verschiedene Strategien statt derselben Suche laufen | {ref:sec:cpsat-parallele-suche} |
+
+## Drei Fehler, die dieser Teil verhindert
+
+1. **Alles hart formulieren.** Wer keine Regel brechen lässt, bekommt irgendwann eine
+   Fehlermeldung statt eines Plans — und zwar nachts, im Batchlauf.
+2. **Genauer optimieren als die Daten sind.** Ein Gap von 2 % ist bei ±10 %
+   Datenunsicherheit bedeutungslos. Die Rechenzeit dafür ist verschenkt.
+3. **Einen Bericht für einen Beweis halten.** Ein generierter Text erklärt das **Modell**,
+   nicht die **Wirklichkeit**. Ist eine Eingabe falsch geschätzt, ist er überzeugend **und**
+   falsch — die gefährlichste Kombination.
+
+## Wenn Sie nur eines mitnehmen
+
+> **🎯** Ein Modell, das nur auf Ihrem Rechner und nur mit Ihren Daten läuft, ist ein
+> Prototyp — kein System. Der Unterschied besteht aus drei Dingen, die alle nichts mit dem
+> Solver zu tun haben: einer Abnahmeprüfung, einer Erklärung und einem Protokoll.
+
+**Danach:** die Projektwerkstatt. Elf Aufträge, jeder mit Datenquellen, Modellskizze,
+Abnahmekriterien und Stolperfallen — zugeschnitten auf 10 bis 25 Stunden bis zu einem
+vorzeigbaren Ergebnis.
+
+---
+
+*Weiter mit:* [Projektwerkstatt](59_Projektwerkstatt.md)
diff --git a/Operations_Research_mit_Python_Version_04/59_Projektwerkstatt.md b/Operations_Research_mit_Python_Version_04/59_Projektwerkstatt.md
index 0f4895e..8499219 100644
--- a/Operations_Research_mit_Python_Version_04/59_Projektwerkstatt.md
+++ b/Operations_Research_mit_Python_Version_04/59_Projektwerkstatt.md
@@ -367,4 +367,4 @@ Viel Erfolg.
 
 ---
 
-*Weiter mit:* [{ref:anhang:loesungen} — Lösungen](90_Anhang_Loesungen.md)
+*Weiter mit:* [{ref:anhang:loesungen} — Lösungen zu allen Übungsaufgaben](90_Anhang_Loesungen.md)
diff --git a/Operations_Research_mit_Python_Version_04/90_Anhang_Loesungen.md b/Operations_Research_mit_Python_Version_04/90_Anhang_Loesungen.md
index bdcd9c0..4c6664b 100644
--- a/Operations_Research_mit_Python_Version_04/90_Anhang_Loesungen.md
+++ b/Operations_Research_mit_Python_Version_04/90_Anhang_Loesungen.md
@@ -10,21 +10,21 @@
 
 ## Lösungen zu Kapitel „Einführung in Operations Research — Vom Ursprung zur mathematischen Entscheidungsfindung“ {#sec:loesungen-einfuehrung}
 
-**1.1 — Analytik-Stufen.**
+**{loesung} — Analytik-Stufen.**
 (a) deskriptiv (Vergangenheit beschreiben). (b) prädiktiv (Prognose). (c) **präskriptiv**
 (Handlungsanweisung unter Restriktionen). (d) prädiktiv (Klassifikation). (e) **präskriptiv**
 — hier kommt das begrenzte Budget ins Spiel, es muss zugeteilt werden. Beachten Sie das Paar
 (d)/(e): Die Prognose sagt, *wer* kündigen wird; die Optimierung sagt, *wen* man mit dem
 vorhandenen Geld halten kann.
 
-**1.2 — Hart oder weich?**
+**{loesung} — Hart oder weich?**
 (a) **hart** — gesetzlich zwingend. (b) **weich** — Wunsch, mit Strafkosten. (c) **hart** —
 Patientensicherheit, rechtlich vorgeschrieben. (d) **weich** — Fairnessziel, über
 Strafterme. (e) **hart**, falls tariflich/gesetzlich fixiert, sonst weich mit sehr hoher
 Strafe. Faustregel: Hart ist nur, was rechtlich oder physikalisch unmöglich zu verletzen
 ist.
 
-**1.3 — Kombinatorik.**
+**{loesung} — Kombinatorik.**
 (a) $12! = 479\,001\,600$.
 (b) $479\,001\,600 / 5\cdot10^6 \approx 95{,}8$ Sekunden $\approx 1{,}6$ Minuten.
 (c) $13! = 6\,227\,020\,800$; das sind $1245$ s $\approx 20{,}8$ Minuten — **Faktor 13**.
@@ -32,7 +32,7 @@ Jeder weitere Auftrag multipliziert die Zeit mit der neuen Anzahl.
 (d) Eine Stunde $= 3600$ s $\to 1{,}8\cdot10^{10}$ Prüfungen. $13! = 6{,}2\cdot10^9$ ✓,
 $14! = 8{,}7\cdot10^{10}$ ✗. Also **13 Aufträge**.
 
-**1.4 — Modell lesen.**
+**{loesung} — Modell lesen.**
 (a) Variablen $x_1, x_2 \ge 0$; Parameter $(3,5)$ und die Kapazitäten $(4,12,18)$;
 Zielfunktion $\max 3x_1+5x_2$; vier Nebenbedingungen inkl. Nichtnegativität.
 (b) $(2,6)$: $2\le4$ ✓, $12\le12$ ✓, $6+12=18\le18$ ✓ → zulässig, $Z=36$.
@@ -40,7 +40,7 @@ $(4,3)$: $4\le4$ ✓, $6\le12$ ✓, $12+6=18\le18$ ✓ → zulässig, $Z=27$.
 (c) Beste ganzzahlige Lösung ist $(2,6)$ mit $Z=36$ — sie ist hier bereits ganzzahlig, weil
 die Ecke des Polyeders zufällig auf Gitterpunkten liegt.
 
-**1.5 — Bäckerei.**
+**{loesung} — Bäckerei.**
 
 ```python
 from ortools.sat.python import cp_model
@@ -69,18 +69,18 @@ $Z = 2{,}5\cdot96 + 3\cdot70 = 240 + 210 = 450$ ✓.
    Mehlrestriktion ($2{,}5/0{,}5 = 5 = 3{,}0/0{,}6$). Prüfen Sie das nach: Genau deshalb
    ist hier auch die ganzzahlige Lösung ohne Verlust erreichbar.
 
-**1.6 — Sensitivität durch Ausprobieren.**
+**{loesung} — Sensitivität durch Ausprobieren.**
 Schleife über `RAM_GESAMT in range(54, 73, 2)`, jeweils Modell neu lösen.
 (a) Ab 62 GB steigt der Gewinn nicht mehr — dann bindet die **vCPU**-Grenze, RAM ist nicht
 mehr der Engpass.
 (b) Der Zuwachs je GB ist der **Schattenpreis** ({ref:kap:lp}). Solange RAM bindet, liegt er
 bei 31,25 €/GB; danach fällt er auf 0.
 
-**1.7 — Eigenes Problem.** Individuell. Prüfkriterien: Sind die Variablen wirklich
+**{loesung} — Eigenes Problem.** Individuell. Prüfkriterien: Sind die Variablen wirklich
 *entscheidbar* (nicht bereits festgelegt)? Hat die Zielfunktion eine **Einheit**? Ist jede
 harte Bedingung wirklich unverhandelbar?
 
-### Finde den Denkfehler 1.1 — Die Schreinerei verdoppelt ihren Gewinn
+### Finde den Denkfehler — Die Schreinerei verdoppelt ihren Gewinn
 
 (a) **Nachrechnen.** Der Plan lautet 40 Tische und 150 Stühle:
 $40 \cdot 3 + 150 \cdot 1 = \mathbf{270}$ Montagestunden bei 150 verfügbaren, und
@@ -152,24 +152,24 @@ Grund für die Rechenzeit.
 
 ## Lösungen zu Kapitel „Das mathematische Fundament — Vektoren, Matrizen, Konvexität“ {#sec:loesungen-fundament}
 
-**2.1 — Matrixform lesen.**
+**{loesung} — Matrixform lesen.**
 $\max 4x_1 + x_2 + 6x_3$ u. d. N. $x_1 + 2x_2 \le 10$, $x_2 + 3x_3 \le 12$, $x \ge 0$.
 **3 Variablen, 2 Nebenbedingungen** (plus Nichtnegativität).
 
-**2.2 — Standardform.**
+**{loesung} — Standardform.**
 $\min -7x_1 + 2x_2$ u. d. N.
 $-4x_1 - x_2 \le -20$ (aus „$\ge$“ durch Multiplikation mit $-1$),
 $x_1 - x_2 \le 3$ **und** $-x_1 + x_2 \le -3$ (Gleichung als zwei Ungleichungen),
 $x_1, x_2 \ge 0$.
 
-**2.3 — Ecken von Hand.**
+**{loesung} — Ecken von Hand.**
 (b) Ecken: $(0,0)$, $(6,0)$, $(4,4)$, $(0,8)$.
 (c) $Z$: 0, 12, 20, **24** → Optimum $(0,8)$ mit $Z = 24$.
 (d) Bei $\max 2x_1+2x_2$: $Z(4,4) = 16$, $Z(0,8) = 16$ — die Zielfunktion ist **parallel zur
 Kante** $x_1+x_2=8$. Es gibt dann **unendlich viele** optimale Lösungen (die ganze Kante),
 aber weiterhin mindestens eine in einer Ecke — der Fundamentalsatz bleibt gültig.
 
-**2.4 — Konvexität.**
+**{loesung} — Konvexität.**
 (a) konvex (linear, sogar affin — Grenzfall, auch konkav).
 (b) konvex ($f'' = 12x^2 \ge 0$).
 (c) **nicht** konvex, sondern **konkav** ($f'' = -\tfrac14 x^{-3/2} < 0$).
@@ -180,18 +180,18 @@ aber weiterhin mindestens eine in einer Ecke — der Fundamentalsatz bleibt gül
 konvex (Achtung, überraschend: die *Funktion* $1/x$ ist konvex, und die Menge
 $\{x_2 \ge 1/x_1\}$ ist der Epigraph einer konvexen Funktion, also konvex).
 
-**2.5 — Positive Semidefinitheit.**
+**{loesung} — Positive Semidefinitheit.**
 $\mathbf{P}_1$: Eigenwerte $\approx (3{,}8;\ 9{,}2)$ → PSD ✓, Korrelation
 $1/\sqrt{4\cdot9} = 0{,}167$ ✓.
 $\mathbf{P}_2$: Eigenwerte $\approx (-0{,}6;\ 13{,}6)$ → **nicht PSD**; implizierte
 Korrelation $7/\sqrt{36} = 1{,}167 > 1$ — unmöglich.
 $\mathbf{P}_3$: Eigenwerte $(0{,}5;\ 0{,}5;\ 2{,}0)$ → PSD ✓.
 
-**2.6 — Bäckerei visualisieren.** Ecken: $(40,0)$, $(150,0)$, $(40,116{,}67)$ und der
+**{loesung} — Bäckerei visualisieren.** Ecken: $(40,0)$, $(150,0)$, $(40,116{,}67)$ und der
 Schnittpunkt von Mehl- und Ofengrenze. Beste Ecke ist $(40;\ 116{,}67)$ mit $Z = 450$ (im
 kontinuierlichen Fall).
 
-**2.7 — Eigenwert-Clipping.**
+**{loesung} — Eigenwert-Clipping.**
 ```python
 def repariere(P):
     lam, V = np.linalg.eigh(P)
@@ -202,7 +202,7 @@ Verfahren zieht die unmögliche Korrelation auf den nächstgelegenen zulässigen
 Kovarianzmatrizen setzt man in der Praxis auf einen kleinen positiven Wert statt auf 0
 (`np.maximum(lam, 1e-10)`), damit die Matrix invertierbar bleibt.
 
-### Finde den Denkfehler 2.1 — Die unauffällige Transposition
+### Finde den Denkfehler — Die unauffällige Transposition
 
 (a) **Warum nichts auffällt.** $\mathbf{A}$ ist quadratisch, also passen die Dimensionen
 auch transponiert. NumPy prüft Formen, nicht Bedeutungen; der Solver bekommt ein
@@ -222,7 +222,7 @@ Die zweite Ressource ist um **47 % überzogen** (17,6 statt 12). Der Plan ist in
 Werkstatt nicht ausführbar.
 
 (c) **Warum „zu klein“ schlimmer ist als „zu groß“.** Ein unerwartet *hoher* Zielwert weckt
-Misstrauen — man rechnet nach (siehe Denkfehler 1.1). Ein leicht *niedrigerer* Wert wirkt
+Misstrauen — man rechnet nach (siehe {ref:sec:einfuehrung-denkfehler}). Ein leicht *niedrigerer* Wert wirkt
 dagegen wie ein normales, etwas enttäuschendes Ergebnis: Niemand prüft nach, warum die
 Optimierung „nur“ 20,80 € statt der erhofften 22 € bringt. Fehler, die sich als
 Bescheidenheit tarnen, überleben am längsten.
@@ -280,7 +280,7 @@ ist die Prüfung gegen die Toleranz mit Fehlermeldung im Zweifelsfall — die Fu
 
 ## Lösungen zu Kapitel „Das Python-Ökosystem für OR — Solver, Bindings und Modellierungsschichten“ {#sec:loesungen-oekosystem}
 
-**3.1 — Solverwahl.**
+**{loesung} — Solverwahl.**
 (a) CP-SAT (diskrete Zuordnung mit Zeitfenstern).
 (b) `scipy.optimize.linprog` (klassisches Mischungs-LP, klein).
 (c) CVXPY (konvexes QP).
@@ -288,34 +288,34 @@ ist die Prüfung gegen die Toleranz mit Fehlermeldung im Zweifelsfall — die Fu
 (e) MILP über `highspy` oder CP-SAT (Standortproblem mit Fixkosten).
 (f) `scipy.optimize.minimize` mit Multistart (nicht konvex).
 
-**3.2 — Bäckerei viermal.** Alle vier müssen $Z = 448$ (ganzzahlig) bzw. $450$
+**{loesung} — Bäckerei viermal.** Alle vier müssen $Z = 448$ (ganzzahlig) bzw. $450$
 (kontinuierlich) liefern. Denken Sie an die Prozesstrennung, falls `ortools` und `highspy`
 kollidieren.
 
-**3.3 — CSR-Format.**
+**{loesung} — CSR-Format.**
 `values = [3, 1, 2, 5, 4, 6]`, `indices = [0, 3, 2, 0, 1, 3]`, `starts = [0, 2, 3]`.
 CSR speichert 6 Werte + 6 Indizes + 3 Startpositionen = 15 Zahlen; die volle Matrix hätte
 $3\times4 = 12$. **Bei dieser winzigen, dicht besetzten Matrix lohnt CSR nicht** — der
 Vorteil entsteht erst bei großer, dünn besetzter Struktur (z. B. 1000×1000 mit 0,5 %
 Besetzung: 15 000 statt 1 000 000 Zahlen).
 
-**3.4 — Konvexitätsprüfung.**
+**{loesung} — Konvexitätsprüfung.**
 $\min x^3$ wirft `DCPError: Problem does not follow DCP rules`, weil $x^3$ auf
 $[-2,2]$ weder konvex noch konkav ist. $\min x^2$ läuft und liefert $x=0$. Der Unterschied:
 CVXPY akzeptiert nur Ausdrücke, deren Konvexität es **beweisen** kann — dafür garantiert es
 das globale Optimum.
 
-**3.5 — Laufzeitvergleich.** Erwartetes Muster: `linprog` und `highspy` liegen bei kleinen
+**{loesung} — Laufzeitvergleich.** Erwartetes Muster: `linprog` und `highspy` liegen bei kleinen
 Modellen gleichauf (Overhead dominiert); ab etwa $n \gtrsim 500$ zieht `highspy` davon, weil
 der Modellaufbau effizienter ist. CVXPY hat den größten festen Aufwand
 (Ausdrucksbaum-Kompilierung), der bei wiederholten Läufen mit `cp.Parameter` teilweise
 entfällt.
 
-**3.6 — Eigene Entscheidungshilfe.** Ergänzungen: Bei kommerzieller Lizenz Gurobi/CPLEX
+**{loesung} — Eigene Entscheidungshilfe.** Ergänzungen: Bei kommerzieller Lizenz Gurobi/CPLEX
 über Pyomo oder CVXPY empfehlen; bei Lesbarkeitsanforderung Pyomo (algebraische Notation,
 Trennung von Daten und Modell).
 
-### Finde den Denkfehler 3.1 — Der Solver, der angeblich dreimal schneller ist
+### Finde den Denkfehler — Der Solver, der angeblich dreimal schneller ist
 
 (a) **Was da alles mitgemessen wird.** Die Stoppuhr läuft ab der ersten Zeile, also
 mindestens über drei Dinge, die mit Lösegeschwindigkeit nichts zu tun haben:
@@ -400,7 +400,7 @@ es spezialisierte globale Solver ({ref:kap:qp-nlp}).
 
 ## Lösungen zu Kapitel „Vom Management-Wunsch zum Modell“ {#sec:loesungen-modellierung}
 
-**Die fehlende Lesart.**
+**{loesung} — Die fehlende Lesart.**
 Eine dritte Lesart: **„Der Umsatzanteil der Stammkunden darf nicht unter 30 % fallen."** Sie
 zielt weder auf einzelne Aufträge noch auf einzelne Kunden, sondern auf das Gesamtbild. Sie
 beschreibt einen Betrieb, dem die *Struktur* seines Geschäfts wichtig ist — etwa weil
@@ -411,7 +411,7 @@ solange die Summe stimmt.
 Der Punkt der Aufgabe: Alle drei Lesarten sind vertretbar, und keine ist aus dem Satz
 ableitbar. Die Wahl trifft man — im Zweifel unbewusst.
 
-**Frage 5 anwenden.**
+**{loesung} — Frage 5 anwenden.**
 Wird die *durchschnittliche* Wartezeit minimiert, lohnt es sich, viele leichte Fälle schnell
 abzuarbeiten und die aufwendigen nach hinten zu schieben: Ein Fall mit vier Stunden
 Wartezeit zählt genauso viel wie vier Fälle mit einer Stunde. Der optimale Plan behandelt
@@ -422,7 +422,7 @@ Das ist genau der Ertrag von Frage 5: Der Plan lässt sich *ablehnen*, und aus d
 folgt die richtige Zielgröße — etwa die maximale Wartezeit je Dringlichkeitsstufe, oder die
 Einhaltung von Zielzeiten je Triage-Kategorie.
 
-**Der Kompromiss dazwischen.**
+**{loesung} — Der Kompromiss dazwischen.**
 Je Stammkunde eine Nebenbedingung: Die Summe der zugeteilten Stunden dieses Kunden muss
 mindestens die Hälfte seiner angefragten Stunden betragen.
 
@@ -438,7 +438,7 @@ Auftrag genügt", aber schwächer als „alle Aufträge". Der Lehrpunkt ist nich
 sondern dass sich zwischen zwei Lesarten beliebig fein abstufen lässt, sobald man sie
 einmal als Ungleichung geschrieben hat.
 
-**Zwei Ziele gleichzeitig.**
+**{loesung} — Zwei Ziele gleichzeitig.**
 Bei $\lambda = 0$ ergibt sich der DB-Plan (78 500 € DB), bei großem $\lambda$ der Umsatzplan
 (66 000 € DB). Dazwischen kippt es an genau einer Stelle — und zwar **sprunghaft**, nicht
 allmählich: Weil die Entscheidungsvariablen binär sind, gibt es nur endlich viele Pläne, und
@@ -448,7 +448,30 @@ Der Kippwert sagt dem Betrieb etwas Konkretes: *„Erst wenn Ihnen ein Euro Umsa
 ist als λ Euro Deckungsbeitrag, ändert sich Ihr Plan."* Das ist eine Frage, die ein
 Kaufmann beantworten kann — anders als „welche Gewichtung hätten Sie gern?".
 
-**Die Anforderung schreiben.**
+**{loesung} — Übersetzen, wo es nicht eindeutig ist.**
+(a) Drei Lesarten von „gleichmäßig ausgelastet":
+**(1) Spannweite minimieren** — $\max_i a_i - \min_i a_i$. Bestraft Ausreißer nach beiden
+Seiten; ein einzelner Untätiger ist genauso schlimm wie ein Überlasteter.
+**(2) Den Schlechtestgestellten verbessern** — $\max_i a_i$ minimieren (B11). Interessiert
+sich nicht dafür, wie ungleich die übrigen liegen, solange die Spitze sinkt.
+**(3) Abweichung vom Mittel minimieren** — $\sum_i |a_i - \bar a|$ (B10). Verteilt die
+Last am gleichmäßigsten, kann aber die Spitze höher lassen als (2).
+Wo es sichtbar wird: Bei fünf Monteuren mit 8, 8, 8, 8 und 16 Stunden senkt (2) die 16
+zuerst; bei 4, 8, 8, 8, 12 tut (1) am meisten gegen die Spreizung, während (2) kaum etwas
+findet. Und wenn ein Monteur aus guten Gründen nur halbtags da ist, bestrafen (1) und (3)
+genau das — (2) nicht.
+(b) Hart: $w_k \le 3$ für jeden Kunden $k$. Weich: $w_k \le 3 + s_k$ mit $s_k \ge 0$ und
+Strafkosten $c \cdot s_k$ in der Zielfunktion (B8, B18). Die Frage an den Betrieb ist die
+dritte der vier: *Was passiert, wenn es einmal nicht geht?* Führt die Antwort zu „dann
+müssen wir eben" — weich. Führt sie zu „das darf nicht passieren, dann rufen wir an und
+verschieben" — dann ist auch das ein Prozess, und die Bedingung bleibt weich, nur mit sehr
+hohen Strafkosten. Wirklich hart ist sie nur, wenn ein Verstoß rechtlich unmöglich ist.
+(c) Individuell. Prüfkriterium: Wird eine Wendung gefunden, die **zwei** vertretbare
+Modelle zulässt — und wird benannt, wer die Wahl treffen muss? Die häufigsten Kandidaten in
+echten Anforderungen sind „in der Regel", „zeitnah", „vergleichbar" und jede Zahl ohne
+Bezugszeitraum.
+
+**{loesung} — Die Anforderung schreiben.**
 Eine tragfähige Anforderung enthält mindestens:
 
 * **Entscheidung:** Für jede Anfrage im Planungszeitraum: annehmen oder ablehnen.
@@ -546,21 +569,21 @@ die Auslastung nicht.
 
 ## Lösungen zu Kapitel „Lineare Programmierung — Simplex, Dualität und Schattenpreise“ {#sec:loesungen-lp}
 
-**4.1 — Schlupf deuten.**
+**{loesung} — Schlupf deuten.**
 (a) Ressourcen 1 und 3 (Schlupf 0). (b) Ja: Überall ist $s_i \cdot y_i = 0$. (c) In
 Ressource 3 — der höchste Schattenpreis (9,8) bedeutet den größten Grenznutzen.
 
-**4.2 — Vorzeichen.** Er hat die Zielfunktion für `linprog` negiert und die Dualwerte nicht
+**{loesung} — Vorzeichen.** Er hat die Zielfunktion für `linprog` negiert und die Dualwerte nicht
 zurückgedreht. Der korrekte Schattenpreis ist **+45 €**.
 
-**4.3 — Simplex von Hand.**
+**{loesung} — Simplex von Hand.**
 Starttableau mit $s_1, s_2$ in der Basis. Erste Iteration: Pivotspalte $x_1$ ($-5$),
 Quotienten $24/6 = 4$ und $6/1 = 6$ → Pivotzeile 1. Nach dem Tausch: $x_1 = 4$, $Z = 20$.
 Zweite Iteration: Pivotspalte $x_2$, Pivotzeile 2 → $x_1 = 3$, $x_2 = 1{,}5$, $Z = 21$.
 **Optimum:** $\mathbf{x}^* = (3;\ 1{,}5)$, $Z^* = 21$, Schattenpreise
 $y^* = (0{,}75;\ 0{,}50)$.
 
-**4.4 — Duales Problem.**
+**{loesung} — Duales Problem.**
 $\min 24y_1 + 6y_2$ u. d. N. $6y_1 + y_2 \ge 5$, $4y_1 + 2y_2 \ge 4$, $y \ge 0$.
 Lösung $y^* = (0{,}75;\ 0{,}50)$. Probe der Restriktionen:
 $6\cdot0{,}75 + 0{,}5 = 5$ ✓ (mit Gleichheit, weil $x_1 > 0$),
@@ -568,13 +591,13 @@ $4\cdot0{,}75 + 2\cdot0{,}5 = 4$ ✓ (ebenfalls Gleichheit, weil $x_2 > 0$).
 Zielwert $24\cdot0{,}75 + 6\cdot0{,}5 = 18 + 3 = 21 = Z^*$ ✓ — starker Dualitätssatz
 bestätigt.
 
-**4.5 — Unbeschränktheit.**
+**{loesung} — Unbeschränktheit.**
 Der Solver wirft „Problem ist unbeschränkt“. Geometrisch: Der zulässige Bereich
 $\{x_1 - x_2 \le 5,\ x \ge 0\}$ ist nach oben offen — man kann $x_1$ und $x_2$ gemeinsam
 beliebig wachsen lassen (z. B. $x_1 = x_2 = t$ für $t \to \infty$), ohne eine Bedingung zu
 verletzen, und $Z = 2t$ wächst mit. In der Praxis fehlt fast immer eine Kapazitätsgrenze.
 
-**4.6 — Gültigkeitsbereich.**
+**{loesung} — Gültigkeitsbereich.**
 (a) Bei ca. 66,7 Stunden Prüfkapazität wird die **Lackierzeit** zum Engpass; der
 Schattenpreis der Prüfung fällt dann.
 (b) Zukaufen lohnt bis zu dem Punkt, an dem der Schattenpreis unter 18 €/h fällt.
@@ -582,13 +605,13 @@ Schattenpreis der Prüfung fällt dann.
 des jeweils gültigen Schattenpreises, und die Steigungen werden immer flacher — jede
 zusätzliche Einheit bringt weniger, weil andere Engpässe nachrücken.
 
-**4.7 — Phase 1.**{idx:Zwei-Phasen-Simplex-Methode}
+**{loesung} — Phase 1.**{idx:Zwei-Phasen-Simplex-Methode}
 Ansatz: Für jede Zeile mit $b_i < 0$ (nach Umformung zu $\ge$) eine künstliche Variable
 $a_i \ge 0$ einführen, Hilfszielfunktion $\min \sum a_i$ lösen. Ist das Minimum 0, existiert
 eine zulässige Basislösung, und man startet Phase 2 mit dem erreichten Tableau. Ist es
 $> 0$, ist das Problem unzulässig. Für das Beispiel: Optimum $(12;\ 0)$, $Z = 36$.
 
-### Finde den Denkfehler 4.1 — Die 380 000-Euro-Maschine
+### Finde den Denkfehler — Die 380 000-Euro-Maschine
 
 (a) **Eine Ableitung gilt lokal.** $y_i = \partial Z^*/\partial b_i$ beschreibt die
 Steigung der Zielfunktion **am aktuellen Punkt**. Sie sagt: „Die *nächste* Stunde ist 50 €
@@ -676,24 +699,24 @@ abgesehen von genau diesem Rauschen.
 
 ## Lösungen zu Kapitel „Gemischt-ganzzahlige Optimierung — Diskrete Entscheidungen und Branch-and-Bound“ {#sec:loesungen-milp}
 
-**5.1 — Runden widerlegen.**
+**{loesung} — Runden widerlegen.**
 Beispiel: $\max x_1 + x_2$ u. d. N. $10x_1 + 10x_2 \le 15$, ganzzahlig. LP-Optimum
 $Z = 1{,}5$; Abrunden ergibt $(0,0)$ mit $Z = 0$ — **100 % Verlust**. Das ganzzahlige
 Optimum ist $(1,0)$ mit $Z = 1$. Prinzip: kleine Zahlen plus knappe Kapazität.
 
-**5.2 — Big-M wählen.**
+**{loesung} — Big-M wählen.**
 $M = 250$ (die bekannte Kapazität). Bei $M = 10^6$ bleibt das Modell korrekt, aber die
 LP-Relaxation wird extrem schwach: $y_j$ darf schon bei $x_j/10^6$ liegen, die Schranke ist
 praktisch wertlos, und Branch-and-Bound muss weit mehr Knoten durchsuchen.
 
-**5.3 — Regeln übersetzen.**
+**{loesung} — Regeln übersetzen.**
 (a) $y_A + y_B \le 1$.
 (b) $\sum_{j=1}^4 y_j \ge 2$.
 (c) $y_1 + y_2 - 1 \le y_{\text{Lager}}$.
 (d) $500\,y \le x \le 2000\,y$ mit $y \in \{0,1\}$.
 (e) $\sum_{j=1}^3 y_j = 1$.
 
-**5.4 — Branch-and-Bound.**
+**{loesung} — Branch-and-Bound.**
 LP-Relaxation der Wurzel: nach Nutzen/Gewicht sortieren ($8/5=1{,}6$; $11/7=1{,}57$;
 $6/4=1{,}5$; $4/3=1{,}33$). Gierig füllen: $x_1=1$ (Rest 9), $x_2=1$ (Rest 2),
 $x_3 = 0{,}5$ → $Z_{LP} = 8+11+3 = 22$. Verzweigen über $x_3$.
@@ -703,21 +726,21 @@ Ast $x_3=1$: $x_1=1$, $x_3=1$, Rest 5 → $x_2=5/7$ → $Z = 21{,}86$; verzweige
 $(1,0,1,1)$ mit $Z = 18$ und $(0,1,1,0)$ mit $Z=17$.
 **Optimum: $(1,1,0,0)$, $Z = 19$.**
 
-**5.5 — Kardinalität variieren.**
+**{loesung} — Kardinalität variieren.**
 (a) Ab $K = 3$ steigt der Ertrag nicht mehr wesentlich, weil bereits drei Positionen à
 40 000 € das Budget von 100 000 € abdecken können. (b) Rechenzeit steigt zunächst (mehr
 Kombinationen), fällt bei großem $K$ wieder (Restriktion bindet nicht mehr). (c) Der faire
 Preis ist die Differenz der Netto-Erträge zwischen $K=3$ und $K=4$ — bei den gegebenen Daten
 nahe null, weil die Obergrenze von 40 000 € bereits bindet.
 
-**5.6 — Big-M-Effekt.** Erwartetes Muster: Knotenzahl und Laufzeit steigen deutlich mit $M$.
+**{loesung} — Big-M-Effekt.** Erwartetes Muster: Knotenzahl und Laufzeit steigen deutlich mit $M$.
 Bei $M = 10^9$ ist die Relaxation so schwach, dass der Solver kaum noch prunen kann.
 
-**5.7 — Standortplanung.** Modell wie in Projekt P4. Prüfen Sie: Gesamtkapazität der
+**{loesung} — Standortplanung.** Modell wie in Projekt P4. Prüfen Sie: Gesamtkapazität der
 eröffneten Lager $\ge$ Gesamtbedarf (140); bei Kapazität 80 je Lager sind mindestens
 $\lceil 140/80 \rceil = 2$ Lager nötig.
 
-### Finde den Denkfehler 5.1 — Elf Lager, die keine Fixkosten kosten
+### Finde den Denkfehler — Elf Lager, die keine Fixkosten kosten
 
 (a) **Warum die Zahl kleiner ist.** Ein größeres $M$ **lockert** die Nebenbedingung
 $\sum_j x_{ij} \le M y_i$. Der zulässige Bereich des Modells wird also größer, und in einem
@@ -812,30 +835,30 @@ sonst messen Sie einen Warm-Start-Effekt, den es gar nicht gibt.
 
 ## Lösungen zu Kapitel „Constraint Programming mit CP-SAT — Logik, Scheduling und Zuweisung“ {#sec:loesungen-cpsat}
 
-**6.1 — Propagation.**
+**{loesung} — Propagation.**
 Aus $x_1 + x_2 = 8$ und $x_1 < x_2$ folgt $x_1 < 4$, also $x_1 \in \{2,3\}$ (denn $x_2 =
 8-x_1 \le 6$ verlangt $x_1 \ge 2$) und entsprechend $x_2 \in \{5,6\}$. Aus 36 Kombinationen
 werden 2 zulässige.
 
-**6.2 — Hart oder weich.**
+**{loesung} — Hart oder weich.**
 (a) hart. (b) weich, mittlere Strafe (~50). (c) hart. (d) weich, mittlere Strafe (~80,
 weil geteilte Dienste stark belasten). (e) hart, falls gesetzlich; sonst weich mit sehr
 hoher Strafe (~1000).
 
-**6.3 — Regeln ergänzen.**
+**{loesung} — Regeln ergänzen.**
 (a) `for s in (2,3): modell.Add(x["Frau_Albrecht", s] == 0)`
 (b) Hilfsvariablen `arbeitet_bauer`, `arbeitet_koch` per `AddMaxEquality` an die
 Zuweisungssummen koppeln, dann `modell.Add(arbeitet_bauer + arbeitet_koch <= 1)`.
 (c) Belohnung = negative Strafe: `strafterme.append(-30 * folge_var)`, wobei `folge_var`
 per `AddBoolAnd`/`OnlyEnforceIf` an $x_{p,0} \wedge x_{p,1}$ gekoppelt wird.
 
-**6.4 — Infeasibility.**
+**{loesung} — Infeasibility.**
 Mit `MAX_VERTRETUNGEN = 0` meldet der Solver `INFEASIBLE`. Nach Einbau der Schlupfvariablen
 lässt der Solver **alle vier** Stunden ausfallen (4 × 10 000 = 40 000 Strafpunkte) — es geht
 nicht anders. Interessanter wird es bei `MAX_VERTRETUNGEN = 1`: Dann fällt genau die Stunde
 aus, für die am wenigsten qualifiziertes Personal zur Verfügung steht.
 
-**6.5 — Sudoku.**
+**{loesung} — Sudoku.**
 ```python
 x = [[m.NewIntVar(1, 9, f"x{i}{j}") for j in range(9)] for i in range(9)]
 for i in range(9): m.AddAllDifferent(x[i])                       # Zeilen
@@ -850,17 +873,42 @@ for i in range(9):
 **Etwa 10 Zeilen Modellcode** — und der Solver löst jedes Sudoku in Millisekunden. Das ist
 die Stärke globaler Constraints.
 
-**6.6 — Job-Shop erweitern.**
+**{loesung} — Die Grenze der Parallelität finden.**
+(a) Der Gewinn flacht ab und kehrt sich um. Auf einem Rechner mit 24 Kernen gemessen
+(Faktor gegenüber einem Arbeiter): 8 Arbeiter **10,2**, 16 Arbeiter **12,3**,
+24 Arbeiter **9,0**. Wer alle Kerne belegt, ist langsamer als mit zwei Dritteln — dem
+Betriebssystem, dem Speicherbus und den Suchsträngen untereinander bleibt zu wenig Luft.
+Die Faustregel „so viele Arbeiter wie Kerne" ist also falsch; die richtige Zahl ist eine
+Messung, keine Einstellung.
+(b) **Fünf verschiedene Pläne aus fünf Seeds** — bei `num_workers = 1` und identischem
+Zielwert 183. Das ist die andere Hälfte der Antwort: Der Seed *wirkt*, aber nur auf den
+einzelnen Suchstrang. Es sichert also **keiner der beiden Parameter allein** die
+Reproduzierbarkeit:
+
+| | Seed fest | Seed variabel |
+| --- | --- | --- |
+| **1 Arbeiter** | reproduzierbar | 5 Pläne aus 5 Läufen |
+| **mehrere Arbeiter** | 3 Pläne aus 4 Läufen | erst recht nicht |
+
+Nur die Kombination trägt.
+(c) Bei **15 Aufträgen** (60 s Zeitlimit): Ein Arbeiter läuft ins Limit und meldet
+`FEASIBLE` mit Makespan 200; acht Arbeiter melden `OPTIMAL` mit **demselben** Makespan 200
+nach 26,4 s. Bei 13 Aufträgen sind es 11,2 s gegen 2,8 s, bei 14 schon 21,4 s gegen 3,7 s.
+Bemerkenswert ist, dass beide denselben Wert finden — der Unterschied liegt nicht in der
+Lösung, sondern im **Beweis**, dass es keine bessere gibt. Genau diese Arbeit teilen sich
+die parallelen Stränge auf.
+
+**{loesung} — Job-Shop erweitern.**
 (a) Rüstzeiten: `AddNoOverlap` durch paarweise Disjunktionen mit Übergangszeit ersetzen,
 oder `AddCircuit` je Maschine mit Übergangsmatrix.
 (b) Verspätung: `tardiness = MaxEquality(0, ende - faellig)`, in die Zielfunktion.
 (c) `AddCumulative(intervalle, [1]*n, 2)` statt `AddNoOverlap` für die Doppelmaschine.
 
-**6.7 — Wochendienstplan.** Siehe Projekt P2. Kernpunkte: Nachtschicht-Folgeregel über
+**{loesung} — Wochendienstplan.** Siehe Projekt P2. Kernpunkte: Nachtschicht-Folgeregel über
 `AddImplication`; „höchstens 5 Tage in Folge“ über gleitende Fenster
 (`sum(x[p,t..t+5]) <= 5`).
 
-### Finde den Denkfehler 6.1 — Die Betriebsvereinbarung, die niemanden interessiert
+### Finde den Denkfehler — Die Betriebsvereinbarung, die niemanden interessiert
 
 (a) **Warum die Regel verletzt wird.** Weil sie einen **Preis** hat. Eine weiche
 Nebenbedingung verbietet nichts — sie verteuert. Der Solver vergleicht in jedem Schritt,
@@ -950,19 +998,28 @@ Regeln. Wer eine reproduzierbare Ausgabe braucht — etwa für ein Buch —, fix
 4. Weil jede zusätzliche harte Bedingung das Risiko von `INFEASIBLE` erhöht — und eine
    Fehlermeldung dem Anwender nicht hilft.
 5. Weil Anwender die Frage „Warum ich?“ stellen. Ohne Antwort wird das System umgangen.
+6. Weil der Seed nur festlegt, wie ein **einzelner** Suchstrang würfelt — nicht, welcher
+   von mehreren parallelen zuerst fertig wird. Das entscheidet die Ausführungsreihenfolge,
+   also die Uhr. Abhilfe: zusätzlich `num_workers = 1`. Gemessen: schon zwei Arbeiter
+   liefern bei identischem Seed drei verschiedene Pläne zum selben Zielwert.
+7. Weil CP-SAT nicht dieselbe Suche vervielfacht, sondern **verschiedene Strategien**
+   nebeneinander laufen lässt (LP-gestützt, andere Verzweigungsregeln, lokale Suche), die
+   einander ihre Schranken mitteilen. Ein zusätzlicher Arbeiter ist deshalb nicht ein
+   weiterer Kern für dieselbe Arbeit, sondern ein anderes Verfahren — und wenn eines davon
+   früh eine gute Schranke findet, profitieren alle.
 
 ---
 
 ## Lösungen zu Kapitel „Graphen, Flüsse und Touren — Min-Cost-Flow, Matching und VRP“ {#sec:loesungen-graphen}
 
-**7.1 — Flusserhaltung.** $b_i = (15+3) - (12+8) = -2$ → **Senke** (Nettobedarf 2).
+**{loesung} — Flusserhaltung.** $b_i = (15+3) - (12+8) = -2$ → **Senke** (Nettobedarf 2).
 
-**7.2 — Unlösbarkeit.** Die Summe aller Flusserhaltungsgleichungen ergibt $\sum_i b_i = 0$
+**{loesung} — Unlösbarkeit.** Die Summe aller Flusserhaltungsgleichungen ergibt $\sum_i b_i = 0$
 (jede Kante taucht einmal mit $+1$ und einmal mit $-1$ auf). Ist die Summe ungleich null,
 widersprechen sich die Gleichungen. Bei Angebotsüberschuss führt man einen künstlichen
 **Dummy-Senkenknoten** mit dem Restbedarf und Kosten 0 ein.
 
-**7.3 — Transportproblem.**
+**{loesung} — Transportproblem.**
 (a) Angebot $30+25+45 = 100$, Bedarf $25+30+20+25 = 100$ ✓
 (b) Optimale Kosten: **790**. Transportplan:
 
@@ -979,17 +1036,17 @@ von W3 gedeckt.
 (c) Die Lösung ist ganzzahlig, obwohl nicht gefordert — die Transportmatrix ist **total
 unimodular**, alle Ecken sind ganzzahlig.
 
-**7.4 — Zuordnung mit Verboten.** Kosten auf einen sehr hohen Wert setzen
+**{loesung} — Zuordnung mit Verboten.** Kosten auf einen sehr hohen Wert setzen
 (`kosten[2][2] = 1e6`) oder mit `np.inf` arbeiten (bei `linear_sum_assignment` erlaubt).
 Die Lösung weicht auf die zweitbeste Zuordnung für Carla aus; die Gesamtkosten steigen um
 die Differenz.
 
-**7.5 — Engpass finden.** Die Dualwerte der Kapazitätsschranken (`res.upper.marginals` bei
+**{loesung} — Engpass finden.** Die Dualwerte der Kapazitätsschranken (`res.upper.marginals` bei
 `linprog`) zeigen es direkt; alternativ jede Kapazität einzeln um 1 erhöhen und neu rechnen.
 Im Beispiel ist die Kante `Werk_A → Umschlag` der Engpass (voll ausgelastet, günstigster
 Weg).
 
-**7.6 — VRP variieren.**
+**{loesung} — VRP variieren.**
 (a) Mit 3 Fahrzeugen werden die Touren länger, die Gesamtfahrzeit steigt leicht, die
 Auslastung deutlich. (b) Unlösbar, sobald $\text{Kapazität} \times \text{Fahrzeuge} <
 \text{Gesamtbedarf}$ (hier: bei 3 Fahrzeugen à 10 sind 30 < 37 → unlösbar) **oder** wenn
@@ -997,11 +1054,11 @@ Zeitfenster nicht mehr eingehalten werden können. (c) 1 s liefert meist eine br
 30 s eine spürbar bessere Lösung — die Metaheuristik verbessert kontinuierlich.
 (d) Doppelte Servicezeit kann Zeitfenster verletzen → möglicherweise unlösbar.
 
-**7.7 — TSP mit MTZ.** Erwartetes Ergebnis: Bei 8 Städten löst das MILP in Sekunden. Ab
+**{loesung} — TSP mit MTZ.** Erwartetes Ergebnis: Bei 8 Städten löst das MILP in Sekunden. Ab
 etwa 12–15 Städten wird die schwache MTZ-Relaxation zum Problem, und die Laufzeit steigt
 stark — während OR-Tools weiterhin in Sekundenbruchteilen sehr gute Touren liefert.
 
-### Finde den Denkfehler 7.1 — Die vergessene Dimension
+### Finde den Denkfehler — Die vergessene Dimension
 
 (a) **Was die Fahrzeuge tun.** Fahrzeuge 1, 2 und 3 fahren **gar nicht** — sie stehen mit
 null Stopps im Depot. Fahrzeug 4 bedient alle 16 Kunden und lädt dabei **37 Paletten** bei
@@ -1057,7 +1114,8 @@ nie verletzt sein. Sie prüft also entweder nichts oder gar nichts.
 prüft das Modell gegen sich selbst. Nützlich ist nur eine Prüfung, die von der
 **ausgegebenen Lösung** ausgeht und die Anforderungen der Wirklichkeit unabhängig
 nachrechnet — genau wie die Kostengegenrechnung in
-[Denkfehler 5.1](#kapitel-5) und die Verbrauchsprüfung in [Denkfehler 1.1](#kapitel-1).
+{ref:sec:milp-denkfehler} und die Verbrauchsprüfung in
+{ref:sec:einfuehrung-denkfehler}.
 
 ### Micro-Quiz {#quiz-loesung-graphen}
 
@@ -1077,7 +1135,7 @@ lösen“ mit „unlösbar“.
 
 **3 — (b) fehlende Dimension.** Ohne begrenzende Dimension ist jede zusätzliche Tour reine
 Zusatzstrecke — ein Optimierer legt dann folgerichtig alles auf ein Fahrzeug. Genau dieses
-Bild zeigt Denkfehler 7.1. (a) wäre zu prüfen, wenn die Lösung *schlecht* aussähe, nicht
+Bild zeigt {ref:sec:graphen-denkfehler}. (a) wäre zu prüfen, wenn die Lösung *schlecht* aussähe, nicht
 wenn sie verdächtig gut ist. (c) ist zwar eine sinnvolle Datenprüfung, erklärt aber nicht,
 warum drei Fahrzeuge unbenutzt bleiben.
 
@@ -1096,7 +1154,7 @@ warum drei Fahrzeuge unbenutzt bleiben.
 
 ## Lösungen zu Kapitel „Metaheuristiken — wenn der exakte Solver aussteigt“ {#sec:loesungen-metaheuristiken}
 
-**Die Kurzsichtigkeit von Hand.**
+**{loesung} — Die Kurzsichtigkeit von Hand.**
 Ab *Schwarz* wählt die Faustregel: Schwarz → Dunkelrot (26) → Rot (5) → … und muss dann in
 die helle Gruppe: Rot → Weiß (50) → Elfenbein (2) → Beige (2). Summe **85 Minuten** — also
 noch einen Deut schlechter als die 84 ab Weiß. Der Grund ist derselbe: Die Regel erwischt
@@ -1104,7 +1162,7 @@ den Gruppenwechsel an der teuersten Stelle. Bemerkenswert ist aber, dass der *St
 kaum etwas ändert. Das ist typisch: Eine kurzsichtige Regel scheitert nicht am Anfang,
 sondern an der Reihenfolge, in der sie ihre Möglichkeiten verbraucht.
 
-**Zuggröße und Temperatur.**
+**{loesung} — Zuggröße und Temperatur.**
 Gesucht ist $T$ mit $e^{-70/T} = e^{-1}$, also **$T = 70$**. Die getesteten Temperaturen
 liegen zwischen 0,5 und 8 — allesamt **eine Größenordnung darunter**. Bei $T_0 = 8$ hat eine
 mediane Verschlechterung die Annahmewahrscheinlichkeit $e^{-70/8} \approx 0{,}00016$. Genau
@@ -1112,7 +1170,7 @@ das ist der Punkt der Warnung im Kapitel: Die verbreitete Regel „20 bis 50 % A
 würde hier $T_0 \approx 50$ verlangen, und bei dieser Temperatur ist die Suche ein reiner
 Zufallslauf.
 
-**Die teure Bewertung.**
+**{loesung} — Die teure Bewertung.**
 Statt `delta_verschieben` die Reihenfolge tatsächlich umbauen und `gesamtruestzeit()` neu
 rechnen. Bei $n = 200$ kostet das rund 200 Matrixzugriffe statt sechs. Erwartung: Die
 Zugzahl je Sekunde bricht um etwa zwei Größenordnungen ein. Bei gleichem **Zeitbudget**
@@ -1121,7 +1179,7 @@ identisch (die Bewertung ist ja korrekt, nur langsam). Genau diese Unterscheidun
 Lehrpunkt: Die Implementierung ändert nicht das Verfahren, sondern nur, wie viel davon in
 das Zeitbudget passt.
 
-**Der Umschlagpunkt genauer.**
+**{loesung} — Der Umschlagpunkt genauer.**
 Sinnvolle Zwischengrößen sind 250, 300, 350 und 400. Zu erwarten ist ein **verwaschener**
 Übergang, kein scharfer Punkt: Der exakte Solver verschlechtert sich nicht sprunghaft,
 sondern sein Gap wächst, und irgendwann liegt seine beste gefundene Lösung über der
@@ -1129,7 +1187,7 @@ heuristischen. Wo genau das passiert, hängt zusätzlich vom Zeitlimit ab — mi
 statt 30 verschiebt sich der Punkt nach oben. Die belastbare Aussage ist deshalb nie „ab
 $n = 380$“, sondern immer „ab $n \approx 380$ **bei diesem Zeitbudget**“.
 
-**Zerstören nach Maß.**
+**{loesung} — Zerstören nach Maß.**
 Die kostenbasierte Zerstörung entfernt gezielt dort, wo etwas zu holen ist, und findet
 deshalb pro Runde mehr. Sie hat aber zwei Nachteile: Sie muss die Übergangskosten jedes Mal
 sortieren, und die entfernten Aufträge liegen über den ganzen Plan verstreut — das
@@ -1205,7 +1263,7 @@ damit als Startlösung unbrauchbar.
 
 ## Lösungen zu Kapitel „Spaltengenerierung“ {#sec:loesungen-dekomposition}
 
-**Das Abbruchkriterium.**
+**{loesung} — Das Abbruchkriterium.**
 Die Eins ist der Zielfunktionskoeffizient eines Musters: Jedes geschnittene Muster verbraucht
 **genau eine** Mutterrolle, und die Zielfunktion lautet $\min \sum_p x_p$. Die reduzierten
 Kosten einer neuen Spalte sind $c_p - \pi^\top a_p = 1 - \sum_i \pi_i a_{ip}$; sie sind
@@ -1215,7 +1273,7 @@ Wäre die Zielfunktion eine andere — etwa „minimiere den Verschnitt in Milli
 dort statt der Eins der Verschnitt des Musters. Die Eins ist also kein Zauberwert, sondern
 schlicht die Kosten der Spalte.
 
-**Die Startbasis.**
+**{loesung} — Die Startbasis.**
 Ein Muster, das nur eine einzige Breite enthält, ist immer zulässig: $\lfloor W / b_i \rfloor$
 Stücke der Breite $i$ passen in jede Rolle. Mit diesen $n$ Mustern lässt sich **jeder** Bedarf
 decken — notfalls sehr verschwenderisch, aber zulässig.
@@ -1228,7 +1286,7 @@ in Gang.
 (In der Literatur behilft man sich alternativ mit künstlichen Variablen und sehr hohen
 Strafkosten — dieselbe Idee wie die Big-M-Phase des Simplex aus {ref:kap:lp}.)
 
-**Die Kennzahl prüfen.**
+**{loesung} — Die Kennzahl prüfen.**
 Zu erwarten ist ein deutlicher, monotoner Zusammenhang: Je mehr Stücke auf eine Rolle passen,
 desto kleiner die Ersparnis. Bei zwei Stücken je Rolle entscheidet jede Paarung, und die
 Faustregel verschenkt regelmäßig ganze Rollen; ab acht bis zehn Stücken ist sie praktisch
@@ -1239,7 +1297,7 @@ kleinste nicht mehr passende Stück. Sind die Stücke klein gegen die Rolle, ist
 Rest klein — und der Gesamtverschnitt nähert sich der theoretischen Untergrenze
 $\lceil \sum_i b_i d_i / W \rceil$, die jede Methode erreichen muss.
 
-**Dienstplanung.**
+**{loesung} — Dienstplanung.**
 Eine „Spalte" ist ein **vollständiger zulässiger Wochenplan einer Person**: an welchen Tagen
 sie welche Schicht übernimmt.
 
@@ -1254,7 +1312,7 @@ stehen im Teilproblem und werden dort **einmal je Person** geprüft, statt das M
 überfrachten. Das Teilproblem ist meist ein kürzester Weg über ein Zeit-Zustands-Netz
 ({ref:kap:graphen}) statt eines Rucksacks.
 
-**Branch-and-Price.**
+**{loesung} — Branch-and-Price.**
 Das Problem: Verzweigt man auf einer Mustervariablen ($x_p \le 3$ gegen $x_p \ge 4$), so ist
 diese Bedingung im **Pricing** nicht darstellbar. Das Teilproblem erzeugt Muster, es kennt
 keine Verzweigungsentscheidungen über einzelne Spalten — es könnte im nächsten Schritt genau
@@ -1333,17 +1391,17 @@ suchen. Genau diese Aussage kann eine Heuristik allein nie liefern ({ref:kap:met
 
 ## Lösungen zu Kapitel „Quadratische und nichtlineare Optimierung — KKT, Lagrange, Konvexität“ {#sec:loesungen-qp-nlp}
 
-**8.1 — Konvexität einordnen.** PSD (alle $\ge 0$) → **konvex**, aber **nicht streng**
+**{loesung} — Konvexität einordnen.** PSD (alle $\ge 0$) → **konvex**, aber **nicht streng**
 konvex; die Lösung ist **nicht notwendig eindeutig**. Der Eigenwert 0 bedeutet eine
 **flache Richtung**: Entlang des zugehörigen Eigenvektors ändert sich der quadratische Term
 nicht — es gibt eine Rinne statt eines Punktes.
 
-**8.2 — Komplementärer Schlupf.** Ja, verträglich: $\lambda_i w_i = 0$ gilt für alle $i$
+**{loesung} — Komplementärer Schlupf.** Ja, verträglich: $\lambda_i w_i = 0$ gilt für alle $i$
 ($w_2 = 0$ mit $\lambda_2 > 0$; die anderen mit $\lambda = 0$). $\lambda_2 = 0{,}03$
 bedeutet: Würde man Titel 2 zwingen, ein kleines positives Gewicht zu tragen, verschlechterte
 sich der Zielwert um 0,03 je Einheit — die Nichtnegativitätsschranke ist dort **bindend**.
 
-**8.3 — KKT von Hand.**
+**{loesung} — KKT von Hand.**
 $\mathcal{L} = x_1^2 + x_2^2 + \lambda(4 - x_1 - x_2)$.
 Stationarität: $2x_1 = \lambda$, $2x_2 = \lambda$ → $x_1 = x_2$.
 Bindend ($\lambda > 0$): $x_1 + x_2 = 4$ → $x_1 = x_2 = 2$, $\lambda = 4$.
@@ -1351,14 +1409,14 @@ Prüfung: $\lambda = 4 > 0$ ✓, $f = 8$.
 **Interpretation:** Würde die Forderung auf $\ge 4{,}1$ steigen, stiege $f$ um etwa
 $4 \cdot 0{,}1 = 0{,}4$. Probe: $2\cdot(2{,}05)^2 = 8{,}405$ ✓.
 
-**8.4 — Unmögliche Korrelationsmatrix.**
+**{loesung} — Unmögliche Korrelationsmatrix.**
 Eigenwerte $\approx (-0{,}62;\ 1{,}0;\ 2{,}62)$ → **nicht PSD**, also unmöglich. Anschaulich:
 Wenn A stark **positiv** mit B korreliert und B stark positiv mit C, kann A nicht gleichzeitig
 stark **negativ** mit C korrelieren — Korrelation ist eingeschränkt transitiv. Formal:
 $\rho_{AC} \ge \rho_{AB}\rho_{BC} - \sqrt{(1-\rho_{AB}^2)(1-\rho_{BC}^2)} = 0{,}81 - 0{,}19
 = 0{,}62$; verlangt waren $-0{,}9$.
 
-**8.5 — Gewichtung untersuchen.**
+**{loesung} — Gewichtung untersuchen.**
 Erwartetes Muster: Größeres $\alpha$ → mehr Rendite, mehr Konzentration im Titel mit
 höchstem $\mu$. Größeres $\beta$ → gleichmäßigere Gewichte, Entropie steigt Richtung
 $\ln 4 = 1{,}386$. Ab etwa $\beta \approx 0{,}1$ dominiert die Entropie und man nähert sich
@@ -1366,14 +1424,14 @@ der Gleichgewichtung. **Empfehlung an einen Ausschuss:** Nicht mit $\beta$ argum
 sondern mit der resultierenden **Maximalposition** — „mit dieser Einstellung liegt keine
 Position über 40 %“ ist verständlich, „$\beta = 0{,}015$“ nicht.
 
-**8.6 — Nicht-Konvexität demonstrieren.**
+**{loesung} — Nicht-Konvexität demonstrieren.**
 Mit der bewusst fehlerhaft konstruierten Matrix finden 20 Startpunkte typischerweise
 mehrere verschiedene Optima; die „Portfoliovarianz“ $w^\top\Sigma w$ kann bei geeigneten
 Gewichten negativ werden (der zugehörige Eigenvektor liegt allerdings teilweise außerhalb
 des zulässigen Bereichs $w \ge 0{,}001$, $\sum w = 1$ — deshalb fällt der Fehler bei
 naiver Prüfung nicht auf).
 
-### Finde den Denkfehler 8.1 — Die Kovarianzmatrix aus dem Controlling
+### Finde den Denkfehler — Die Kovarianzmatrix aus dem Controlling
 
 (a) **Ohne zu rechnen.** Stellen Sie sich die drei Anlagen als drei Personen vor, die
 nebeneinander gehen. A und B gehen fast im Gleichschritt ($0{,}9$). B und C gehen fast im
@@ -1449,7 +1507,7 @@ Der Ausweg auf `scipy` hat das Warnsystem umgangen, nicht das Problem gelöst. R
 **1 — (b).** Der `DCPError` ist eine inhaltliche Aussage: Für diese Formulierung kann es
 keine Optimalitätsgarantie geben. Auf `scipy` auszuweichen (a) beseitigt die Meldung, nicht
 die Ursache — man bekommt dann ein lokales Ergebnis ohne Garantie und ohne Warnung, wie
-Denkfehler 8.1 zeigt. Toleranzen (c) haben mit Konvexität nichts zu tun. Richtig ist,
+{ref:sec:qp-nlp-denkfehler} zeigt. Toleranzen (c) haben mit Konvexität nichts zu tun. Richtig ist,
 zwischen zwei bewussten Wegen zu wählen: konvex umformulieren, oder lokal rechnen **und**
 das im Bericht kenntlich machen.
 
@@ -1481,13 +1539,13 @@ bei einer bindenden Bedingung gerade **null** (komplementärer Schlupf).
 
 ## Lösungen zu Kapitel „Optimierung unter Unsicherheit — Monte-Carlo, Stochastik, Robustheit“ {#sec:loesungen-unsicherheit}
 
-**9.1 — Fluch des Durchschnitts.** Weil sich Verzögerungen **fortpflanzen** und die
+**{loesung} — Fluch des Durchschnitts.** Weil sich Verzögerungen **fortpflanzen** und die
 Verteilung rechtsschief ist: Ein Gewerk, das früher fertig wird, beschleunigt selten den
 Gesamtablauf (der nächste Schritt ist noch nicht bereit), ein verspätetes verzögert alles.
 Weitere Beispiele: Wartezeiten in Warteschlangen (nichtlinear in der Auslastung),
 Projektkosten mit Nachträgen.
 
-**9.2 — Ansatz wählen.**
+**{loesung} — Ansatz wählen.**
 (a) robust (Ausfall ist existenziell, Wahrscheinlichkeiten unzuverlässig).
 (b) stochastisch (Verteilung bekannt).
 (c) robust bzw. Extremwertstatistik (seltene Ereignisse, katastrophale Folgen).
@@ -1496,7 +1554,7 @@ Projektkosten mit Nachträgen.
 Wintertage“). Robust wäre hier zu teuer (es gibt immer einen kälteren Tag), der
 Erwartungswert zu schwach (er sagt nichts über die Zusage).
 
-**9.3 — Zweistufig rechnen.**
+**{loesung} — Zweistufig rechnen.**
 (a) Mit Spot = 60: Ableitung bei $x \in (100,250)$: $40 - 60\cdot0{,}5 + 5\cdot0{,}5 =
 40-30+2{,}5 = +12{,}5 > 0$ → Kapazität **senken**. Bei $x < 100$:
 $40 - 60 = -20 < 0$ → erhöhen. Optimum daher $x^* = 100$.
@@ -1505,11 +1563,11 @@ $40 - 60 = -20 < 0$ → erhöhen. Optimum daher $x^* = 100$.
 diskreten Szenarien nur zufällig der Fall; der Mittelwert ist nur bei symmetrischen Kosten
 und stetiger Verteilung optimal.
 
-**9.4 — EVPI interpretieren.** Selbst eine **perfekte** Prognose wäre nur 8 400 € pro Jahr
+**{loesung} — EVPI interpretieren.** Selbst eine **perfekte** Prognose wäre nur 8 400 € pro Jahr
 wert. Eine Lösung für 15 000 € kann sich also **niemals** rechnen — unabhängig von ihrer
 Güte. Argument: „Der theoretische Maximalnutzen liegt unter dem Preis.“
 
-**9.5 — Monte-Carlo erweitern.**
+**{loesung} — Monte-Carlo erweitern.**
 (a) Servicelevel 95 %: Kapazität = 95 %-Quantil des Bedarfs (ca. 485). Die Zusatzkosten
 gegenüber dem Kostenoptimum (180) betragen ein Vielfaches — Servicelevel ist teuer, und
 genau diese Zahl braucht die Geschäftsleitung für die Entscheidung.
@@ -1517,7 +1575,7 @@ genau diese Zahl braucht die Geschäftsleitung für die Entscheidung.
 (c) Erwartetes Bild: Bei kleiner Kapazität ist die Kostenverteilung stark rechtsschief
 (seltene, teure Notzukäufe); bei großer Kapazität schmal und nach rechts verschoben.
 
-**9.6 — Den Preis der Zusage selbst bestimmen.**
+**{loesung} — Den Preis der Zusage selbst bestimmen.**
 (a) Die Kosten je Prozentpunkt steigen weiter steil an; der Mix verschiebt sich dabei fast
 nur noch zugunsten des Gaskraftwerks, weil Biomasse längst an ihrer Ausbaugrenze liegt.
 Wind und Sonne bleiben bei einem kleinen Rest — sie senken über ihre Gegenläufigkeit die
@@ -1537,7 +1595,7 @@ Prozentpunkt ist bereits 4,5-mal so teuer wie der erste. Sagen Sie mir, was ein
 das Unternehmen kostet, dann rechne ich aus, welche Quote sich lohnt. Und die Zusage gilt
 nur für die Wetterlagen, die wir modelliert haben — die Kältewelle gehört hinein.“
 
-**9.7 — Budgeted Uncertainty.**
+**{loesung} — Budgeted Uncertainty.**
 ```python
 abzug = cp.sum_largest(cp.multiply(UNSICHERHEIT, w), Gamma)
 ziel = cp.Maximize(MU_SCHAETZUNG @ w - abzug - 0.5*LAMBDA*cp.quad_form(w, SIGMA))
@@ -1546,7 +1604,7 @@ $\Gamma = 0$ entspricht dem nominalen Fall, $\Gamma = n$ dem vollen Worst Case.
 steuert $\Gamma$ die Vorsicht stufenlos — der praktisch nützlichste Bereich liegt meist bei
 $\Gamma \approx \sqrt{n}$.
 
-### Finde den Denkfehler 9.1 — Warum jedes Projekt zu spät fertig wird
+### Finde den Denkfehler — Warum jedes Projekt zu spät fertig wird
 
 (a) **Warum 14,38 statt 11,34 Tage.** Der Projektleiter hat den Mittelwert der
 **Einzeldauer** berechnet und ihn für den Mittelwert der **Projektdauer** gehalten. Das sind
@@ -1632,7 +1690,7 @@ und interessiert sich darin nur für den schlechtesten Punkt.
 $\mathbb{E}[f(X)] = f(\mathbb{E}[X])$ — dann ist Rechnen mit Mittelwerten korrekt. Sobald
 aber ein Maximum, ein Minimum, ein Betrag oder eine Nachbesserungsentscheidung auftaucht,
 gilt das nicht mehr: Genau das sind die beiden Fälle aus Schnellstart (asymmetrische Kosten
-über `maximum`) und Denkfehler 9.1 (Maximum über parallele Vorgänge). (a) ist die
+über `maximum`) und {ref:sec:unsicherheit-denkfehler} (Maximum über parallele Vorgänge). (a) ist die
 Fehlannahme, um die es im ganzen Kapitel geht; (b) ist zu absolut — es gibt den linearen
 Fall, in dem es tatsächlich zulässig ist.
 
@@ -1663,22 +1721,22 @@ Fall, in dem es tatsächlich zulässig ist.
 
 ## Lösungen zu Kapitel „Dynamische Programmierung — Die Bellman-Gleichung und Order-Execution“ {#sec:loesungen-dynamische-programmierung}
 
-**10.1 — Bausteine.** Stufe = Tag 1–5; Zustand = verbleibende Distanz (ggf. plus
+**{loesung} — Bausteine.** Stufe = Tag 1–5; Zustand = verbleibende Distanz (ggf. plus
 Erschöpfungsgrad); Aktion = heutige Tagesetappe; Wertfunktion = minimale Restanstrengung.
 **Nicht** in den Zustand gehören: bereits gelaufene Kilometer (redundant, wenn die
 Restdistanz bekannt ist) und das Wetter von gestern (ohne Einfluss auf die Zukunft).
 
-**10.2 — Optimalitätsprinzip.** Weil der Wert eines Zustands nur von den *künftigen*
+**{loesung} — Optimalitätsprinzip.** Weil der Wert eines Zustands nur von den *künftigen*
 Entscheidungen abhängt, kann man ihn ab dem Ende rekursiv berechnen. Hängen die Kosten
 zusätzlich von **früheren** Aktionen ab, ist die Markov-Eigenschaft verletzt — die Lösung:
 die relevante Vergangenheit **in den Zustand aufnehmen** (dann wächst allerdings der
 Zustandsraum).
 
-**10.3 — Rückwärtsinduktion.** Mit $C(n) = n^2 + 2n$ und 5 Einheiten in 3 Perioden ergibt
+**{loesung} — Rückwärtsinduktion.** Mit $C(n) = n^2 + 2n$ und 5 Einheiten in 3 Perioden ergibt
 sich als optimaler Pfad $2 \to 2 \to 1$ (oder eine Permutation davon) mit Gesamtkosten
 $8 + 8 + 3 = 19$. Alles auf einmal kostet $25 + 10 = 35$.
 
-**10.4 — Rucksack als DP.**
+**{loesung} — Rucksack als DP.**
 ```python
 V = np.zeros((n + 1, kapazitaet + 1))
 for i in range(1, n + 1):
@@ -1691,19 +1749,19 @@ Ergebnis identisch zum MILP (110). Laufzeit $O(n \cdot C)$ — bei kleinen ganzz
 Kapazitäten schneller als Branch-and-Bound, bei großen oder nicht-ganzzahligen Kapazitäten
 schlechter (dann ist das MILP überlegen). Man nennt das **pseudopolynomiell**.
 
-**10.5 — Risikoaversion kalibrieren.**
+**{loesung} — Risikoaversion kalibrieren.**
 (a) Zwischen $\lambda = 10^{-5}$ (41 %) und $10^{-4}$ (78 %); genauer etwa bei
 $\lambda \approx 3\cdot10^{-5}$.
 (b) Höheres $\lambda$ → höhere Gesamtkosten (man kauft Sicherheit mit Slippage).
 (c) Iterativ: $\lambda$ so wählen, dass der Anteil der Marktauswirkungskosten an den
 Gesamtkosten bei 20 % liegt — im Programm ausrechnen und per Bisektion einstellen.
 
-**10.6 — Zustandsraum erweitern.** Der Zustand wird zu (Restbestand, Orderbuchtiefe); der
+**{loesung} — Zustandsraum erweitern.** Der Zustand wird zu (Restbestand, Orderbuchtiefe); der
 Zustandsraum verdreifacht sich, die Rechenzeit ebenfalls. Die Strategie wird
 **zustandsabhängig**: Bei tiefem Buch wird mehr verkauft, bei dünnem gewartet. Genau diese
 Adaptivität ist der Mehrwert von DP gegenüber einem festen Pfad.
 
-### Finde den Denkfehler 10.1 — Der Zustand, der zu wenig weiß
+### Finde den Denkfehler — Der Zustand, der zu wenig weiß
 
 (a) **Die fehlende Information.** Die Zeile
 
@@ -1784,7 +1842,7 @@ Minuten). (c) ist eine Allgemeinplatz-Aussage ohne Bezug zum Prinzip.
 
 **3 — (b).** Der Rabatt hängt von der bisher kumulierten Menge ab; ohne diese Größe im
 Zustand kann das Modell die Kosten der nächsten Bestellung nicht bestimmen — dasselbe Muster
-wie in Denkfehler 10.1. (a) übersieht genau das: Kosten, die von der Vorgeschichte abhängen,
+wie in {ref:sec:dynamische-programmierung-denkfehler}. (a) übersieht genau das: Kosten, die von der Vorgeschichte abhängen,
 **sind** Zustandsinformation. (c) ist zu absolut — DP bleibt anwendbar, der Zustandsraum
 wird nur größer; ob sich stattdessen ein MILP lohnt, ist eine Frage der Größe, nicht der
 Eignung.
@@ -1805,7 +1863,7 @@ Eignung.
 
 ## Lösungen zu Kapitel „Mehrere Ziele — Pareto-Fronten statt Gewichte“ {#sec:loesungen-mehrziel}
 
-**Dominanz prüfen.**
+**{loesung} — Dominanz prüfen.**
 P (14 000 €, 6 000 kg) und Q (13 800 €, 6 100 kg): **keiner dominiert den anderen.** Q ist
 billiger, P ist sauberer — beide sind pareto-optimal, die Wahl ist eine Präferenzfrage.
 
@@ -1814,7 +1872,7 @@ schmutziger; schmutziger als Q *und* teurer. R kann man wegwerfen, ohne jemanden
 und genau das ist der Zweck des Dominanzbegriffs: Er trennt die Fälle, in denen der
 Modellierer entscheiden darf, von denen, in denen er es nicht darf.
 
-**Der Schattenpreis in der Praxis.**
+**{loesung} — Der Schattenpreis in der Praxis.**
 Man geht die Front von unten durch, solange der Schattenpreis unter 0,90 €/kg liegt. Aus der
 Ausgabe: 0,58 — 0,93 — 0,40 — 0,59 — 0,77 — 0,65 — 0,77 — 1,09 — 1,32. Die Werte steigen
 nicht monoton, weil die Front bei ganzzahligen Modellen keine glatte Kurve ist; maßgeblich
@@ -1828,7 +1886,7 @@ liegt damit über dem internen Preis.
 Begründung in einem Satz: *„Für 646 Euro sparen wir 843 Kilogramm CO₂ — zu 77 Cent je
 Kilogramm, während wir intern mit 90 Cent rechnen.“*
 
-**Mehr Trassen.**
+**{loesung} — Mehr Trassen.**
 Mit 8 statt 5 Trassen wird der Engpass schwächer. Zu erwarten ist eine **kürzere** Front:
 Der Zielkonflikt entsteht ja allein aus der Knappheit; je mehr Trassen, desto näher rücken
 Kostenminimum und CO₂-Minimum zusammen. Im Grenzfall genügend vieler Trassen fallen beide
@@ -1839,7 +1897,7 @@ Der Lehrpunkt: **Ein Zielkonflikt ist keine Eigenschaft der Ziele, sondern der K
 Wer ihn auflösen will, sollte zuerst prüfen, ob sich die Ressource vermehren lässt, statt
 über Gewichte zu verhandeln.
 
-**Die Front der Relaxation.**
+**{loesung} — Die Front der Relaxation.**
 Ohne `integrality` ist der zulässige Bereich konvex, und die Pareto-Front liegt vollständig
 auf ihrer eigenen unteren konvexen Hülle. Es gibt also **keinen** Punkt oberhalb — jeder
 Punkt der Front ist durch ein passendes Gewicht erreichbar.
@@ -1849,7 +1907,7 @@ vorkommt und in der betrieblichen Praxis ständig: Sobald „welcher Träger“,
 oder „welche Schicht“ entschieden wird, zerfällt der Bereich in einzelne Punkte, und
 zwischen ihnen entstehen die Einbuchtungen, in denen die nicht gestützten Lösungen liegen.
 
-**Drei Ziele.**
+**{loesung} — Drei Ziele.**
 Die Front wird zu einer Fläche im dreidimensionalen Zielraum. Das ε-Verfahren braucht dann
 ein **Gitter** über zwei Schranken statt einer Folge über eine — der Aufwand wächst von
 $O(k)$ auf $O(k^2)$, bei $m$ Zielen auf $O(k^{m-1})$.
@@ -1930,7 +1988,7 @@ aber nicht zu: Auch bei exakt gleichem Budget bliebe der Effekt.
 
 ## Lösungen zu Kapitel „Predict-then-Optimize“ {#sec:loesungen-prognose}
 
-**Andere Preise.**
+**{loesung} — Andere Preise.**
 Der Überhang kostet nur noch 1,50 €, die Fehlmenge weiterhin 6 €. Das kritische Verhältnis
 steigt von $6/9 = 0{,}667$ auf $6/7{,}5 = 0{,}80$. Die Bestellmenge verschiebt sich also
 **nach oben** — man bestellt jetzt das 80-%-Quantil statt des 66,7-%-Quantils.
@@ -1939,7 +1997,7 @@ Das ist die richtige Richtung und leicht zu merken: Je billiger der Überhang, d
 großzügiger darf man ansetzen. Im Grenzfall kostenloser Entsorgung ($c_+ \to 0$) geht das
 kritische Verhältnis gegen 1 — man bestellt so viel, dass praktisch nie etwas fehlt.
 
-**Wann ist der Mittelwert richtig?**
+**{loesung} — Wann ist der Mittelwert richtig?**
 Nur wenn $c_- = c_+$ **und** die Nachfrageverteilung symmetrisch ist. Dann liegt das
 kritische Verhältnis bei 0,5, das 50-%-Quantil ist der Median, und bei Symmetrie fällt der
 Median mit dem Mittelwert zusammen.
@@ -1950,7 +2008,7 @@ Nachfrageverteilungen sind meist rechtsschief. Der Mittelwert ist damit die
 Ausnahme, nicht die Regel — er wird nur benutzt, weil Regressionsmodelle ihn standardmäßig
 liefern.
 
-**Die Kennzahl der Prognoseabteilung.**
+**{loesung} — Die Kennzahl der Prognoseabteilung.**
 Die Rangfolge bleibt: Die Punktprognose gewinnt auch beim MAPE, weil beide Maße den
 *Erwartungswert* belohnen — der MAPE etwas anders gewichtet, aber ebenfalls symmetrisch in
 dem Sinne, dass er nicht weiß, dass Unterschätzung teurer ist als Überschätzung.
@@ -1961,7 +2019,7 @@ wechselt; man muss die Kosten selbst messen. (Die einzige Ausnahme ist der *Pinb
 genau das Maß, das die Quantilregression minimiert, und das ist eben kein
 allgemeines Prognosemaß, sondern eines für ein bestimmtes Quantil.)
 
-**Zwei Quantile.**
+**{loesung} — Zwei Quantile.**
 Das Band ist an **Aktionstagen** deutlich breiter — dort ist die Streuung im Modell fast
 viermal so groß. Genau das ist die Information, die eine Punktprognose plus fester Zuschlag
 wegwirft.
@@ -1970,7 +2028,7 @@ Ein praktischer Nebeneffekt: Ein solches Band ist die verständlichste Form, Uns
 die Disposition zu berichten. „Zwischen 130 und 210" sagt einem Menschen mehr als „170 ±
 Sicherheitszuschlag".
 
-**Der Wert der Merkmale.**
+**{loesung} — Der Wert der Merkmale.**
 Zu erwarten ist, dass die **Kosten stärker steigen als der MSE**. Der Grund: Das Merkmal
 „Aktion" trägt zwei verschiedene Informationen — es verschiebt den Erwartungswert (um 45
 Stück) *und* die Streuung (von 8 auf 30). Der MSE bemerkt nur den ersten Teil; die
@@ -2044,7 +2102,7 @@ ist ein brauchbares Maß für *Prognosegüte*, nur eben nicht für *Entscheidung
 
 ## Lösungen zu Kapitel „Die Strukturbrücke — dieselbe Mathematik, zwei Welten“ {#sec:loesungen-bruecke}
 
-**Die dritte Ressource.**
+**{loesung} — Die dritte Ressource.**
 „Liquidität" — wie schnell sich eine Position ohne Kursabschlag verkaufen lässt — entspricht
 in der Werkstatt der **Umrüstbarkeit** oder der **Vorlaufzeit**: Wie schnell lässt sich die
 Fertigung von diesem Produkt wieder wegdrehen, wenn der Auftrag storniert wird? In beiden
@@ -2055,7 +2113,7 @@ Im Modell ist es schlicht eine weitere Zeile in `kapazitaeten` und ein weiterer
 jedem `verbrauch`. Genau das ist der Punkt des Kapitels: Eine neue Ressource kostet keinen
 Modellcode.
 
-**Den Schattenpreis lesen.**
+**{loesung} — Den Schattenpreis lesen.**
 Bis zu **602,60 €** für 10 Einheiten (10 × 60,26 €) lohnt sich der Kauf — darüber nicht.
 
 Die Einschränkung aus {ref:sec:lp-entartung}: Der Schattenpreis gilt nur **lokal**, solange
@@ -2068,7 +2126,7 @@ Zweite Einschränkung: Bei **Entartung** ist der Schattenpreis nicht eindeutig.
 Solver können dann verschiedene, gleichermaßen gültige Werte liefern — auch das steht in
 {ref:sec:lp-entartung}.
 
-**Die Brücke rückwärts.**
+**{loesung} — Die Brücke rückwärts.**
 Shrinkage hilft, wenn man eine **Kovarianzmatrix** aus wenigen Beobachtungen schätzt. Bei
 Lieferzeiten tritt genau dasselbe Problem auf, sobald man die *Korrelationen zwischen*
 Lieferanten braucht — und die braucht man, sobald Lieferanten gemeinsame Ursachen haben:
@@ -2082,7 +2140,7 @@ Benötigt würden: Lieferzeit-Zeitreihen je Lieferant über denselben Zeitraum,
 Genau daran scheitert es in der Praxis meist — die Daten liegen in Bestellvorgängen, nicht in
 einer Matrix.
 
-**CVaR mit Ganzzahligkeit.**
+**{loesung} — CVaR mit Ganzzahligkeit.**
 Man ergänzt Binärvariablen $y_j$ je Lieferant und die Kopplung $w_j \le y_j$ sowie
 $\sum_j y_j \le 3$. Da CVXPY gemischt-ganzzahlige Probleme unterstützt, genügt
 `cp.Variable(n, boolean=True)`.
@@ -2092,7 +2150,7 @@ Feinabstimmung über sechs Lieferanten fällt weg. Der Aufschlag ist der Preis d
 Vertragswirklichkeit — und genau die Zahl, die man dem Einkauf vorlegt, wenn dort jemand
 sagt, drei Lieferanten seien genug.
 
-**Die eigene Brücke.**
+**{loesung} — Die eigene Brücke.**
 Freie Antwort. Eine gute Bearbeitung nennt das Modell, die Entsprechung und **die Zeile der
 Grenztabelle, die im Weg steht** — meist ist es die dritte (Teilbarkeit) oder die erste
 (gemessen gegen geschätzt). Wenn keine im Weg steht, ist die Übertragung wahrscheinlich zu
@@ -2166,7 +2224,7 @@ der Methode.
 
 ## Lösungen zu Kapitel „Supply-Chain und Energieeinsatz unter Unsicherheit“ {#sec:loesungen-supplychain}
 
-**Der Umschlagpunkt.**
+**{loesung} — Der Umschlagpunkt.**
 Bei 60 MW statt 120 MW halbiert sich die Grenzkostendifferenz je Stunde (83 €/MWh × 60 MW =
 4 980 €/h). Der Umschlagpunkt verdoppelt sich auf **7,7 Stunden**.
 
@@ -2176,7 +2234,7 @@ für eine kleine Restlast noch weniger als für eine große — was erklärt, wa
 gerade dann unwirtschaftlich werden, wenn viel Wind einspeist und nur eine kleine Restlast
 bleibt.
 
-**Die fehlende Nebenbedingung.**
+**{loesung} — Die fehlende Nebenbedingung.**
 Analog zum Anfahren braucht man eine Abfahr-Indikatorvariable $b_{k,t} \ge u_{k,t-1} - u_{k,t}$
 und dann:
 
@@ -2191,7 +2249,7 @@ werkstofftechnischen Gründen nicht sofort wieder hochgefahren werden — die
 Temperaturwechsel würden das Material schädigen. Bei Gasturbinen ist die
 Mindeststillstandszeit kurz oder null, bei Kernblöcken beträgt sie viele Stunden.
 
-**Wie viele Szenarien?**
+**{loesung} — Wie viele Szenarien?**
 Zu erwarten ist, dass der Commitment-Plan ab einer gewissen Szenarienzahl stabil bleibt —
 oft schon bei 20 bis 40. Der Grund: Die erste Stufe ist binär und **grob**; sie kann nur
 ganze Blockstunden verschieben. Feine Unterschiede in der Szenarienmenge ändern daran
@@ -2203,7 +2261,7 @@ einem Modell. Beide Male lautet die Frage nicht „wie viele sind genug?", sonde
 ändert sich die Antwort nicht mehr?" — und beide Male beantwortet man sie, indem man es
 ausprobiert, statt eine Faustregel zu übernehmen.
 
-**Der Wert eines Speichers.**
+**{loesung} — Der Wert eines Speichers.**
 Der Speicher braucht Variablen für Ladung, Entladung und Füllstand je Szenario und Stunde,
 mit der Bilanz $F_{t} = F_{t-1} + \eta\, L_t - E_t/\eta$ und Grenzen für Leistung und
 Kapazität. Er gehört in die **zweite** Stufe: Wann geladen wird, darf sich am Tag selbst
@@ -2218,7 +2276,7 @@ Der Wert je MWh Kapazität ergibt sich als Kostenersparnis geteilt durch 400 MWh
 den Investitionskosten vergleichbar — dieselbe Rechnung wie der Schattenpreis in
 {ref:kap:lp}, nur über einen ganzen Tag.
 
-**Wenn es größer wird.**
+**{loesung} — Wenn es größer wird.**
 Mit 20 Blöcken und 168 Stunden hat die erste Stufe 3 360 Binärvariablen statt 120, und die
 Szenarienkopplung vervielfacht die kontinuierlichen Variablen. Zu erwarten ist, dass der
 MIP-Gap nach dem Zeitlimit nicht mehr auf null geht.
@@ -2305,38 +2363,38 @@ die es nicht gibt.
 
 ## Lösungen zu Kapitel „Finanzdaten-Modellierung — Renditen, Kovarianz und Shrinkage“ {#sec:loesungen-finanzdaten}
 
-**11.1 — Renditeart.** (a) diskret. (b) logarithmisch. (c) logarithmisch (bzw. diskret
+**{loesung} — Renditeart.** (a) diskret. (b) logarithmisch. (c) logarithmisch (bzw. diskret
 kumuliert über Produkt). (d) logarithmisch (statistische Eigenschaften).
 
-**11.2 — Mittelwertfalle.**
+**{loesung} — Mittelwertfalle.**
 (a) Arithmetisches Mittel: $(60-40+60-40)/4 = +10\,\%$.
 (b) $10\,000 \cdot 1{,}6 \cdot 0{,}6 \cdot 1{,}6 \cdot 0{,}6 = 10\,000 \cdot 0{,}9216 =
 \mathbf{9216\ €}$ — ein **Verlust**.
 (c) Geometrisches Mittel: $0{,}9216^{1/4} - 1 = -2{,}0\,\%$ p. a. Der Unterschied zwischen
 $+10\,\%$ und $-2\,\%$ ist der Grund, warum Fondswerbung gern arithmetische Mittel zeigt.
 
-**11.3 — Konditionszahl.** Erwartetes Muster: Bei $T = 40 < N = 30$… (hier $T > N$, aber
+**{loesung} — Konditionszahl.** Erwartetes Muster: Bei $T = 40 < N = 30$… (hier $T > N$, aber
 knapp): sehr große Konditionszahl, kleinster Eigenwert nahe null. Bei $T = 100$: deutlich
 besser. Bei $T = 1000$: stabil. Faustregel $T \ge 5N$ bis $10N$.
 
-**11.4 — Spaltenreihenfolge.** `raw["Close"].columns` ist alphabetisch;
+**{loesung} — Spaltenreihenfolge.** `raw["Close"].columns` ist alphabetisch;
 `raw["Close"][tickers]` stellt die eigene Reihenfolge her. Existiert ein Ticker nicht,
 wirft `[tickers]` einen `KeyError` — **das ist erwünscht**: lieber ein lauter Fehler als
 eine stille Verschiebung.
 
-**11.5 — Beide Ziele vergleichen.** Erwartetes Ergebnis: Das
+**{loesung} — Beide Ziele vergleichen.** Erwartetes Ergebnis: Das
 Konstant-Korrelations-Ziel schneidet bei Aktien meist etwas besser ab, weil es die
 unterschiedlichen Einzelvolatilitäten erhält. Der Unterschied ist aber kleiner als der
 Unterschied zwischen „mit“ und „ohne“ Shrinkage — die Wahl des Ziels ist zweitrangig
 gegenüber der Entscheidung, überhaupt zu schrumpfen.
 
-**11.6 — Error-Maximizer messen.**
+**{loesung} — Error-Maximizer messen.**
 (a)/(b) Erwartetes Ergebnis: Die Gleichgewichtung schlägt die Stichproben-Optimierung bis
 etwa $T/N \approx 5$–10; Ledoit-Wolf schlägt sie schon früher. (c) **Praktische Folgerung:**
 Bei knapper Datenlage ist 1/N ein ernstzunehmender Kandidat, und jede Optimierung muss sich
 daran messen lassen.
 
-### Finde den Denkfehler 11.1 — Das risikofreie Portfolio
+### Finde den Denkfehler — Das risikofreie Portfolio
 
 (a) **Der Rang.** Eine aus $T$ Beobachtungen geschätzte Kovarianzmatrix hat höchstens den
 Rang $T-1$ — hier also **19** statt der nötigen 30. Geometrisch heißt das: Die 20
@@ -2434,7 +2492,7 @@ Wahl.
 
 ## Lösungen zu Kapitel „Die moderne Portfoliotheorie nach Markowitz“ {#sec:loesungen-markowitz}
 
-**12.1 — Diversifikationseffekt.**
+**{loesung} — Diversifikationseffekt.**
 
 | $(w_1, w_2)$ | $\mu_p$ | $\sigma_p$ | Sharpe ($r_f=2\,\%$) |
 | --- | ---: | ---: | ---: |
@@ -2453,11 +2511,11 @@ bei $w_1 = 0{,}318$. **Bemerkenswert:** Die Mischung $(0{,}3;\ 0{,}7)$ hat mit 1
 **geringere** Volatilität als *beide* Einzeltitel (25 % und 12 %) — genau der
 Diversifikationseffekt, den die negative Korrelation ermöglicht.
 
-**12.2 — Lambda deuten.** Von $\lambda=0$ (GMV, linker unterer Punkt der Kurve) wandert die
+**{loesung} — Lambda deuten.** Von $\lambda=0$ (GMV, linker unterer Punkt der Kurve) wandert die
 Lösung entlang der Effizienzgrenze nach rechts oben, bis sie bei $\lambda\to\infty$ im Titel
 mit der höchsten Rendite endet (bzw. an der Positionsobergrenze).
 
-**12.3 — Korn-Transformation.**
+**{loesung} — Korn-Transformation.**
 $\text{SR}(c\mathbf{w}) = \frac{c\mathbf{w}^\top\boldsymbol{\mu}-r_f}{\sqrt{c^2\mathbf{w}^\top\boldsymbol{\Sigma}\mathbf{w}}}$
 — bei einem Portfolio mit $\sum w_i = 1$ und Überrenditen geschrieben als
 $\mathbf{w}^\top(\boldsymbol{\mu}-r_f\mathbf{1})$ kürzt sich $c$ heraus. Mit der Bedingung
@@ -2466,27 +2524,27 @@ Transformation ersetzt diese Bedingung durch $\sum y_i = \kappa$ mit freiem $\ka
 normiert stattdessen die Überrendite auf 1 — dadurch wird die Skala wieder frei und das
 Problem konvex.
 
-**12.4 — Restriktionen kosten.** Erwartetes Muster: Sharpe Ratio sinkt monoton mit
+**{loesung} — Restriktionen kosten.** Erwartetes Muster: Sharpe Ratio sinkt monoton mit
 strengerer Grenze. Unlösbar wird es bei $w_{\max} < 1/n$ — dann kann die Summe der Gewichte
 1 nicht mehr erreicht werden.
 
-**12.5 — Den Sektorfehler nachstellen.**
+**{loesung} — Den Sektorfehler nachstellen.**
 (a) AAPL, AMZN, CVX, GS statt AAPL, MSFT, NVDA, AMZN.
 (b) Die Gewichte unterscheiden sich deutlich, weil die eigentlich zu begrenzenden
 Tech-Titel frei laufen. (c) **Nein** — die Kennzahlen sehen völlig plausibel aus. Genau das
 macht den Fehler so gefährlich.
 
-**12.6 — Kardinalität.** Erwartung: Die Sharpe Ratio sinkt leicht, die Rechenzeit steigt
+**{loesung} — Kardinalität.** Erwartung: Die Sharpe Ratio sinkt leicht, die Rechenzeit steigt
 deutlich (MIQP statt QP). Bei $K \ge 5$ und $w_{\max} = 0{,}20$ ist die Restriktion
 praktisch nicht mehr bindend.
 
-**12.7 — Out-of-Sample.** Typisches Ergebnis: Max-Sharpe schneidet in der zweiten Hälfte
+**{loesung} — Out-of-Sample.** Typisches Ergebnis: Max-Sharpe schneidet in der zweiten Hälfte
 **schlechter** ab als in der ersten — es hat Schätzrauschen mitoptimiert. GMV ist stabiler
 (keine Renditeprognose nötig), 1/N oft überraschend gut. Mit Ledoit-Wolf verbessern sich
 GMV und Max-Sharpe spürbar. **Praxisfolgerung:** Renditeprognosen sind viel unzuverlässiger
 als Risikoschätzungen — Modelle, die ohne sie auskommen, sind robuster.
 
-### Finde den Denkfehler 12.1 — Zwölf gleiche Anlagen, ein sehr ungleiches Portfolio
+### Finde den Denkfehler — Zwölf gleiche Anlagen, ein sehr ungleiches Portfolio
 
 (a) **Woher die Spanne kommt.** Aus reinem Rauschen. Der Mittelwert von 250 Beobachtungen
 einer Größe mit Standardabweichung $\sigma = 1{,}2\,\%$ hat selbst noch den **Standardfehler**
@@ -2542,7 +2600,7 @@ zwölf identisch sind.
 3. **Freiheit begrenzen.** Obergrenzen je Position (etwa 15 %), Sektorgrenzen, maximale
    Abweichung von einer Referenzgewichtung. Was der Optimierer nicht darf, kann er auch
    nicht auf Rauschen setzen — dasselbe Rezept wie in
-   [Denkfehler 11.1](#kapitel-11).
+   {ref:sec:finanzdaten-denkfehler}.
 
 **Und die Kontrollfrage für den Alltag:** Rechnen Sie Ihr Modell mit den Daten des halben
 Zeitraums und dann mit denen der anderen Hälfte. Wenn die Gewichte dabei stark springen,
@@ -2586,17 +2644,17 @@ Risikowerten, nicht zu Konzentration.
 
 ## Lösungen zu Kapitel „Tail-Risiko, CVaR und Transaktionskosten“ {#sec:loesungen-cvar}
 
-**13.1 — VaR und CVaR von Hand.**
+**{loesung} — VaR und CVaR von Hand.**
 Sortierte Verluste: $-2{,}0; -1{,}2; -0{,}8; -0{,}4; 0{,}3; 0{,}6; 1{,}1; 2{,}1; 5{,}4;
 8{,}9$. Das 80 %-Quantil ist der 8. Wert: $\text{VaR}_{80\%} = 2{,}1$.
 $\text{CVaR}_{80\%} = $ Mittel der schlechtesten 20 % $= (5{,}4+8{,}9)/2 = \mathbf{7{,}15}$.
 
-**13.2 — Subadditivität.** Ein Risikomaß sollte Diversifikation nie bestrafen: Das Risiko
+**{loesung} — Subadditivität.** Ein Risikomaß sollte Diversifikation nie bestrafen: Das Risiko
 eines zusammengelegten Portfolios darf nicht größer sein als die Summe der Einzelrisiken.
 Wird das verletzt, hätte eine Bank einen Anreiz, Portfolios künstlich aufzuspalten, um
 Eigenkapitalanforderungen zu senken — ökonomisch unsinnig.
 
-**13.3 — Rockafellar-Uryasev nachvollziehen.**
+**{loesung} — Rockafellar-Uryasev nachvollziehen.**
 (a) Schlechtestes Drittel von $(1,4,9)$ ist $\{9\}$ → CVaR $= 9$.
 (b) Mit $\frac{1}{S(1-\alpha)} = \frac{1}{3\cdot(1/3)} = 1$:
 $\gamma=0$: $0 + (1+4+9) = 14$. $\gamma=1$: $1 + (0+3+8) = 12$.
@@ -2605,13 +2663,13 @@ $\gamma=4$: $4 + (0+0+5) = \mathbf{9}$. $\gamma=5$: $5+4 = 9$. $\gamma=9$: $9+0
 ganzen Intervall angenommen, weil die Funktion stückweise linear ist — genau der Grund,
 warum der CVaR nicht *streng* konvex ist.)
 
-**13.4 — Einheiten prüfen.** In einem Modell, das annualisierte Rendite gegen täglichen
+**{loesung} — Einheiten prüfen.** In einem Modell, das annualisierte Rendite gegen täglichen
 CVaR verrechnet, wirkt $1{,}5$ effektiv als $1{,}5/252 \approx 0{,}006$ auf Tagesbasis —
 der Risikoterm ist also um Faktor 252 zu leicht gewichtet. Um dieselbe Wirkung wie
 `RISIKOAVERSION = 1.5` im konsistenten Tagesmodell zu erzielen, hätte man dort
 `lambda_risk = 1.5 * 252 = 378` setzen müssen.
 
-**13.5 — Risikoaversion kalibrieren.**
+**{loesung} — Risikoaversion kalibrieren.**
 (a) Konkav, ähnlich der Markowitz-Frontier, aber im Rendite-CVaR-Raum.
 (b) Bei Normalverteilung entspricht CVaR-Optimierung ungefähr der Varianz-Optimierung; die
 Ergebnisse divergieren umso stärker, je schiefer die Verteilung ist.
@@ -2619,14 +2677,14 @@ Ergebnisse divergieren umso stärker, je schiefer die Verteilung ist.
 an den schlechtesten fünf Prozent der Tage bei X Prozent — bei einer erwarteten Rendite von
 Y Prozent.“ Das ist entscheidbar; „$\lambda = 4$“ ist es nicht.
 
-**13.6 — Grenze statt Strafe.**
+**{loesung} — Grenze statt Strafe.**
 (a) Mit engerer Grenze sinkt die erreichbare Rendite; bei $\tau = 0$ bleibt das Altportfolio.
 (b) **Vorteil der Grenze:** garantierte Obergrenze für die Handelsaktivität — wichtig, wenn
 Liquidität oder Compliance eine harte Schranke verlangen. **Nachteil:** Sie kann das Modell
 unlösbar machen und ignoriert, dass ein sehr lohnender Trade den Aufwand wert wäre.
 (c) Strafe bei ökonomischer Abwägung, Grenze bei regulatorischen oder Liquiditätsvorgaben.
 
-### Finde den Denkfehler 13.1 — Das Risikobudget, das durch Diversifikation stieg
+### Finde den Denkfehler — Das Risikobudget, das durch Diversifikation stieg
 
 (a) **Die entscheidende Wahrscheinlichkeit.** Bei zwei unabhängigen Anleihen mit je 4 %
 Ausfallwahrscheinlichkeit fällt **mindestens eine** aus mit
@@ -2724,38 +2782,38 @@ Anleihen dort sind **gerade unabhängig**, und genau deshalb tritt die Verletzun
 
 ## Lösungen zu Kapitel „Die vollständige quantitative Handelsmaschine“ {#sec:loesungen-handelsmaschine}
 
-**14.1 — Lookahead erkennen.**
+**{loesung} — Lookahead erkennen.**
 (a) sauber (`:heute`). (b) **Lookahead** — gesamter Zeitraum. (c) **Lookahead** —
 Volatilität über den ganzen Zeitraum enthält Zukunft. (d) sauber — Gewichte aus Daten bis
 heute, angewendet auf heute (idealerweise auf morgen). (e) **Survivorship-Bias** — das
 Universum wird danach gefiltert, wer über den gesamten Zeitraum Daten hat.
 
-**14.2 — Kennzahlen deuten.**
+**{loesung} — Kennzahlen deuten.**
 A: Sharpe $= (12-2)/22 = 0{,}45$, Calmar $= 12/35 = 0{,}34$.
 B: Sharpe $= (8-2)/9 = 0{,}67$, Calmar $= 8/12 = 0{,}67$.
 **Empfehlung: B** — für einen Pensionsfonds ist der Drawdown entscheidend, weil laufende
 Auszahlungen in einer Verlustphase Substanz vernichten. B ist in beiden risikoadjustierten
 Maßen besser.
 
-**14.3 — Rebalancing-Kalender.** Etwa 25–30 % der Termine fallen aus. Die Kennzahlen ändern
+**{loesung} — Rebalancing-Kalender.** Etwa 25–30 % der Termine fallen aus. Die Kennzahlen ändern
 sich messbar — in welche Richtung, ist zufällig. Genau das ist der Punkt: Der Fehler
 verzerrt, ohne aufzufallen.
 
-**14.4 — Rebalancing-Frequenz.** Typisches Muster: Turnover und Kosten steigen etwa linear
+**{loesung} — Rebalancing-Frequenz.** Typisches Muster: Turnover und Kosten steigen etwa linear
 mit der Frequenz, der Bruttoertrag verbessert sich nur unterproportional. Bei 0,15 %
 Gebühren ist monatlich meist vertretbar, bei 0,5 % eher quartalsweise. Ein **Toleranzband**
 (nur handeln bei Abweichung > x %) schlägt fast immer die feste Frequenz.
 
-**14.5 — Krisenverhalten.** Erwartung: Die Überrendite ist selten stabil; oft stammt sie aus
+**{loesung} — Krisenverhalten.** Erwartung: Die Überrendite ist selten stabil; oft stammt sie aus
 wenigen Perioden. Folgerung: Eine gute Gesamtkennzahl kann von einer einzigen glücklichen
 Phase getragen sein — **immer** nach Teilzeiträumen aufschlüsseln.
 
-**14.6 — Data Snooping messen.** Erwartetes Ergebnis: Die beste In-Sample-Sharpe-Ratio liegt
+**{loesung} — Data Snooping messen.** Erwartetes Ergebnis: Die beste In-Sample-Sharpe-Ratio liegt
 deutlich über dem Mittelwert aller Varianten; auf dem zurückgehaltenen Zeitraum fällt sie
 Richtung Mittelwert zurück. Die **Differenz zwischen (a) und (c) ist der Selektionseffekt**
 — genau das, was die Deflated Sharpe Ratio korrigieren soll.
 
-### Finde den Denkfehler 14.1 — Die Strategie mit dem hochsignifikanten Ergebnis
+### Finde den Denkfehler — Die Strategie mit dem hochsignifikanten Ergebnis
 
 (a) **Warum ein korrekter Backtest wertlos sein kann.** Der Backtest misst genau das, was er
 messen soll: die Wertentwicklung *dieser einen* Strategie. Die Frage, die beantwortet werden
@@ -2856,38 +2914,58 @@ ist frei erfunden; an der Berechnung ändert sich bei Wiederholung nichts.
 
 ## Lösungen zu Kapitel „Praxisfallen und der Weg zum produktiven Einsatz“ {#sec:loesungen-praxisfallen}
 
-**15.1 — Hart oder weich, revisited.**
+**{loesung} — Hart oder weich, revisited.**
 (a) hart: gesetzliche Ruhezeit, Qualifikationspflicht.
 (b) weich: individuelle Wunschtage, Vermeidung von Freistunden.
 (c) diskutabel: Höchstzahl Vertretungsstunden pro Tag (tariflich vs. Notfall), gleichmäßige
 Wochenendverteilung.
 
-**15.2 — Zeitlimit wählen.**
+**{loesung} — Zeitlimit wählen.**
 (a) 1–3 s, Gap 5–10 % (Echtzeit schlägt Optimalität).
 (b) 1–5 min, Gap 1–2 %.
 (c) Stunden, Gap ~0 % (einmalige, folgenreiche Entscheidung).
 (d) 30–60 s, Gap 1 % — die Datenunsicherheit ist ohnehin größer.
 
-**15.3 — Relaxation einbauen.** Muster wie in `Infeasibility_Diagnose.py`:
+**{loesung} — Relaxation einbauen.** Muster wie in `Infeasibility_Diagnose.py`:
 Schlupfvariable je Mindestbesetzung, Strafe deutlich über allen weichen Zielen, aber
 endlich. Wichtig: **gestaffelte** Strafen, damit der Solver die *am wenigsten schmerzhafte*
 Verletzung wählt.
 
-**15.4 — Erklärbarkeit.** Report-Struktur: (1) Zielwert und Aufschlüsselung nach
+**{loesung} — Erklärbarkeit.** Report-Struktur: (1) Zielwert und Aufschlüsselung nach
 Bestandteilen; (2) je Entscheidung die bindenden Bedingungen; (3) Schattenpreise der
 knappsten Ressourcen mit Handlungsempfehlung.
 
-**15.5 — Gap gegen Laufzeit.** Erwartetes Muster: Von 10 % auf 2 % kostet wenig Zeit; von
+**{loesung} — Den Bericht in die Irre führen.**
+(a) Der Plan kippt: *Rahmen* fällt von 47,5 auf **40** — das Minimum aus dem Liefervertrag —,
+*Deckel* steigt von 97,5 auf **120**, die Marktgrenze. Der Deckungsbeitrag springt von
+3 930 € auf **5 190 €**. Mit ihm wechselt die Engpassstruktur: „Kapazität Lackieren" bindet
+**nicht mehr**, dafür bindet jetzt „Liefervertrag Rahmen" — und zwar als *Kosten* von
+25 € je Stück, weil der Vertrag zur Herstellung eines inzwischen unattraktiven Produkts
+zwingt. Alle Schattenpreise steigen deutlich (Träger von 18 € auf 58 €).
+Der entscheidende Punkt der Aufgabe: Der Satz *„Teuerste Bindung ist Liefervertrag
+Träger"* steht **wörtlich unverändert** im Bericht — obwohl die Zahl dahinter sich mehr
+als verdreifacht hat und ein anderer Engpass die Fabrik begrenzt. Ein Bericht, der sich
+nicht ändert, ist kein Beweis dafür, dass sich nichts geändert hat.
+(b) Etwa: *„Unter der Annahme eines Deckungsbeitrags von 9 € je Deckel ist ‚Liefervertrag
+Träger' die teuerste Bindung (18 € je Stück)."* Die Aussage bekommt damit ihre
+Voraussetzung mit — und wird angreifbar, was sie sein soll.
+(c) Mindestens eines von beidem: den **Gültigkeitsbereich** jedes Schattenpreises (bis
+wohin gilt er?), oder das Ergebnis einer **Sensitivitätsrechnung** über die unsichersten
+Eingangsgrößen — etwa „bei ±20 % Deckungsbeitrag Deckel bleibt die Rangfolge/kippt sie".
+Das Programm rechnet den Gültigkeitsbereich für die auffälligste Stellschraube bereits
+aus; ihn für alle auszuweisen ist eine kleine Erweiterung.
+
+**{loesung} — Gap gegen Laufzeit.** Erwartetes Muster: Von 10 % auf 2 % kostet wenig Zeit; von
 1 % auf 0 % kann die Laufzeit um Größenordnungen steigen, ohne dass sich der Zielwert
 nennenswert verbessert. Empfehlung: Gap dort ansetzen, wo die Kurve knickt — typischerweise
 1–2 %.
 
-**15.6 — Post-Mortem.** Bewertungskriterien: Wird zwischen **Symptom**, **Ursache** und
+**{loesung} — Post-Mortem.** Bewertungskriterien: Wird zwischen **Symptom**, **Ursache** und
 **fehlender Prüfung** unterschieden? Ist die abgeleitete Regel allgemein genug, um beim
 nächsten Projekt zu helfen (z. B. „Nach jeder Vorzeichenumkehr eine numerische Gegenprobe“),
 aber konkret genug, um überprüfbar zu sein?
 
-### Finde den Denkfehler 15.1 — Das Modell, das seit einem Jahr nicht mehr optimiert
+### Finde den Denkfehler — Das Modell, das seit einem Jahr nicht mehr optimiert
 
 (a) **Warum die konstante Laufzeit das Symptom ist.** Ein Solver, der fertig wird, braucht
 so lange, wie das Problem eben dauert — und diese Zeit wächst mit den Daten. Eine Laufzeit,
@@ -2974,6 +3052,15 @@ Ursache zu finden, solange sie noch frisch ist.
 4. Jeder Lauf arbeitet auf einem unveränderlichen, mit ID versehenen Datenstand — nur so
    sind Ergebnisse reproduzierbar und belegbar.
 5. Die **Einführung**: mangelnde Akzeptanz, weil Ergebnisse nicht nachvollziehbar sind.
+6. Sie berührt den Plan, ohne ihn zu verteuern — die Lösung liegt genau auf ihrer Grenze,
+   wäre aber auch ohne sie dieselbe (Entartung). Für eine Nachverhandlung folgt: **nichts
+   tun.** Der Aufwand brächte 0 €. „Bindend" ist ein geometrischer, „teuer" ein
+   wirtschaftlicher Befund.
+7. Weil der Schattenpreis nur für die **nächste** Einheit gilt und sein Gültigkeitsbereich
+   endet, sobald ein anderer Engpass bindend wird. Realistische Lockerungen sind
+   unterschiedlich groß — eine Sonderschicht bringt 50 Einheiten, ein nachverhandelter
+   Vertrag 10. Der Preis je Einheit sagt daher nichts darüber, welcher Hebel insgesamt am
+   meisten bringt; dafür muss man die Lockerung rechnen, nicht den Preis multiplizieren.
 
 ---
 
@@ -2982,7 +3069,7 @@ Ursache zu finden, solange sie noch frisch ist.
 
 ## Lösungen zu Kapitel „Testen, Messen, Ausliefern“ {#sec:loesungen-testing}
 
-**Den Schnellstart reparieren.**
+**{loesung} — Den Schnellstart reparieren.**
 Zwei Wege: (a) **Abrunden statt runden** — `np.floor` statt `np.round`. Das ist immer
 zulässig, weil weniger produzieren nie eine Kapazität sprengt, kostet aber Deckungsbeitrag
 und ist im Allgemeinen **nicht** die optimale ganzzahlige Lösung. (b) **Ganzzahlig
@@ -2994,7 +3081,7 @@ LP-Lösung nicht nur suboptimal, sondern unzulässig ist — genau das zeigt der
 und andere, bei denen zwischen gerundetem LP und echtem Optimum Welten liegen
 (`Runden_Gegenbeispiel.py`).
 
-**Eine Invariante mehr.**
+**{loesung} — Eine Invariante mehr.**
 
 ```python
 def test_kapazitaeten_verdoppeln(bauer):
@@ -3012,7 +3099,7 @@ nicht: Die Ganzzahligkeitsbedingung skaliert nicht mit. Aus 30,67 wird beim Verd
 61,33 — und ob dazwischen eine bessere ganzzahlige Lösung liegt, hängt vom Einzelfall ab.
 Der Test wäre dort also falsch.
 
-**Eine eigene Mutation.**
+**{loesung} — Eine eigene Mutation.**
 Zwei lohnende Kandidaten:
 
 ```python
@@ -3029,7 +3116,7 @@ Suite eine Instanz enthält, in der ein Produkt mit Menge 0 vorkommt. In der Sch
 das nicht der Fall — die Mutation überlebt also und zeigt eine echte Lücke: Es fehlt eine
 Testinstanz, in der ein Produkt nicht produziert wird.
 
-**Der Benchmark mit MILP.**
+**{loesung} — Der Benchmark mit MILP.**
 Zu erwarten ist, dass sich die Reihenfolge ändert. Beim reinen LP entscheidet vor allem der
 Modellaufbau in Python; beim MILP verschiebt sich das Gewicht zum Lösen, und dort spielen
 die Branch-and-Bound-Heuristiken der Bibliotheken gegeneinander. Die Spalte „Anteil" sollte
@@ -3037,7 +3124,7 @@ bei allen deutlich **fallen** — nicht weil der Aufbau schneller würde, sonder
 Lösen langsamer wird. Genau deshalb steht im Kapitel, dass die Tabelle nichts über MILPs
 sagt.
 
-**Der Dienst mit Zeitlimit.**
+**{loesung} — Der Dienst mit Zeitlimit.**
 Der Modellbauer in `or_kern.py` nimmt bisher kein Zeitlimit entgegen — das ist der erste
 Schritt (bei GLOP `solver.SetTimeLimit(millisekunden)`). Danach im Arbeiter durchreichen und
 den Status auswerten: Liefert der Solver `ZEITLIMIT`, ist `stand` weiterhin `gescheitert`,
@@ -3114,3 +3201,7 @@ der Solver, sondern die Bindung davor.
    Eine in reinem Python geschriebene Heuristik hält den GIL; für sie braucht es Prozesse.
 
 ---
+
+---
+
+*Weiter mit:* [{ref:anhang:modellierungsmuster} — Katalog der Modellierungsmuster](91_Anhang_Modellierungsmuster.md)
diff --git a/Operations_Research_mit_Python_Version_04/91_Anhang_Modellierungsmuster.md b/Operations_Research_mit_Python_Version_04/91_Anhang_Modellierungsmuster.md
index 91fd38c..0852106 100644
--- a/Operations_Research_mit_Python_Version_04/91_Anhang_Modellierungsmuster.md
+++ b/Operations_Research_mit_Python_Version_04/91_Anhang_Modellierungsmuster.md
@@ -44,6 +44,11 @@
 | B23 | Zuordnung 1:1 | „Jeder genau eine Aufgabe“ | {ref:kap:graphen} |
 | B24 | Subtour-Eliminierung | „Keine isolierten Kreise“ | {ref:kap:graphen} |
 
+> **Umgekehrte Richtung:** Wer von einem Satz aus der Besprechung kommt und das Muster
+> sucht, findet in {ref:sec:modellierung-glossar} ein Lexikon, das genau so herum
+> aufgebaut ist — und die Wendungen benennt, bei denen es keine eindeutige
+> Übersetzung gibt.
+>
 > Die Spalte „Wo im Buch“ nennt das Kapitel, in dem das Muster **im Zusammenhang**
 > vorkommt — nicht die einzige Stelle, an der es taugt. Die Nummern entstehen beim Bauen;
 > im Quelltext dieses Anhangs steht keine einzige.
@@ -433,4 +438,4 @@ Wenn mehrere Muster passen, entscheiden Sie nach dieser Reihenfolge:
 
 ---
 
-*Weiter mit:* [{ref:anhang:fehlerdiagnose} — Fehlerdiagnose](92_Anhang_Fehlerdiagnose.md)
+*Weiter mit:* [{ref:anhang:fehlerdiagnose} — Fehlerdiagnose-Handbuch](92_Anhang_Fehlerdiagnose.md)
diff --git a/Operations_Research_mit_Python_Version_04/92_Anhang_Fehlerdiagnose.md b/Operations_Research_mit_Python_Version_04/92_Anhang_Fehlerdiagnose.md
index 4a7b5f7..f2bc68b 100644
--- a/Operations_Research_mit_Python_Version_04/92_Anhang_Fehlerdiagnose.md
+++ b/Operations_Research_mit_Python_Version_04/92_Anhang_Fehlerdiagnose.md
@@ -723,7 +723,8 @@ importiert, crasht daher mit derselben Meldung.
 
 **Abhilfen (in dieser Reihenfolge):**
 1. Nur eines von beiden im selben Skript verwenden.
-2. Getrennte Prozesse (`subprocess`) — siehe `Ein_System_Vier_Ansaetze.py`.
+2. Getrennte Prozesse — ein `ProcessPoolExecutor` mit `mp_context="spawn"` und
+   `max_tasks_per_child=1`, siehe `Ein_System_Vier_Ansaetze.py`.
 3. Auf `highspy` verzichten: HiGHS ist ohnehin Backend von `scipy.optimize.linprog` und
    CVXPY.
 4. Getrennte virtuelle Umgebungen.
diff --git a/Operations_Research_mit_Python_Version_04/build_version_04.py b/Operations_Research_mit_Python_Version_04/build_version_04.py
index 3e4f005..09544e6 100644
--- a/Operations_Research_mit_Python_Version_04/build_version_04.py
+++ b/Operations_Research_mit_Python_Version_04/build_version_04.py
@@ -95,25 +95,30 @@ DATEIEN = [
     "11_Mathematisches_Fundament.md",
     "12_Python_Oekosystem.md",
     "13_Vom_Wunsch_zum_Modell.md",
+    "19_Synthese_Grundlagen.md",
     "20_Lineare_Programmierung.md",
     "21_MILP.md",
     "22_CP_SAT.md",
     "23_Graphen_Fluesse_Touren.md",
     "24_Metaheuristiken.md",
     "25_Spaltengenerierung.md",
+    "29_Synthese_Kernverfahren.md",
     "30_QP_und_NLP.md",
     "31_Unsicherheit.md",
     "32_Dynamische_Programmierung.md",
     "33_Mehrziel_und_Pareto.md",
     "34_Predict_then_Optimize.md",
+    "39_Synthese_Nichtlinear.md",
     "35_Strukturbruecke.md",
     "36_Supply_Chain_Energie.md",
     "40_Finanzdaten.md",
     "41_Markowitz.md",
     "42_CVaR.md",
     "43_Handelsmaschine.md",
+    "49_Synthese_Anwendungen.md",
     "50_Praxis.md",
     "51_Testing_und_Deployment.md",
+    "52_Synthese_Praxis.md",
     "59_Projektwerkstatt.md",
     "90_Anhang_Loesungen.md",
     "91_Anhang_Modellierungsmuster.md",
@@ -253,6 +258,111 @@ def pruefe_dateien() -> list[str]:
                           f"Dorthin gehoert ein {{ref:...}}-Verweis.")
                     fehlend.append(name)
 
+    # Die beiden uebrigen Markenfamilien. 'Denkfehler N.M' und 'Micro-Quiz N'
+    # standen bis zum sechsten Fund von Hand im Quelltext und waren in zwoelf
+    # von fuenfzehn Kapiteln falsch; die Loesungsmarke '**9.2 — Titel.**' war
+    # es in allen 98 Faellen und bezeichnete obendrein eine echte, ANDERE
+    # Aufgabe. Vergeben werden sie jetzt beim Bauen.
+    familien = [
+        (re.compile(r"Denkfehler\s+\d+\.\d+"),
+         "auf den Denkfehler-Abschnitt verweist {ref:sec:<kapitel>-denkfehler}"),
+        (re.compile(r"Micro-Quiz\s+\d+"),
+         "die Nummer vergibt nummeriere_marken()"),
+        # 'Uebung 8.5' meinte in Version 03 das QP/NLP-Kapitel; heute ist das
+        # Kapitel 11, und die Nummer zeigt woandershin. Sechs von sieben solcher
+        # Verweise standen noch in alter Zaehlung. Aufgaben haben kein eigenes
+        # Label - verwiesen wird deshalb auf den Abschnitt plus den TITEL der
+        # Aufgabe, und der ist stabil.
+        (re.compile(r"(?:Übung|Uebung)\s+\d+\.\d+"),
+         "gemeint ist 'die Aufgabe *Titel* ({ref:sec:<kapitel>-uebungsaufgaben})'"),
+        (re.compile(r"^\*\*\d{1,2}\.\d{1,2} — ", re.M),
+         "im Quelltext steht dort '**{loesung} — Titel.**'"),
+    ]
+    for name in DATEIEN:
+        with open(os.path.join(HIER, name), encoding="utf-8") as f:
+            inhalt = f.read()
+        for muster, hinweis in familien:
+            for treffer in muster.finditer(inhalt):
+                zeile = inhalt[:treffer.start()].count("\n") + 1
+                gefunden = " ".join(treffer.group(0).split())
+                print(f"FEHLER: {name}:{zeile} enthaelt die harte Nummer "
+                      f"'{gefunden}' - {hinweis}.")
+                fehlend.append(name)
+
+    # Und die Gegenprobe, die keine Textsuche leisten kann: Zu jeder Aufgabe
+    # eines Kapitels muss es im Loesungsanhang genau eine {loesung}-Marke
+    # geben. Das faengt eine vergessene oder doppelte Loesung - der Fall, der
+    # beim Einfuegen einer neuen Aufgabe am leichtesten passiert.
+    kapitel_aufgaben: dict[str, int] = {}
+    for name in DATEIEN:
+        with open(os.path.join(HIER, name), encoding="utf-8") as f:
+            inhalt = f.read()
+        kopf = re.search(r"^# Kapitel: .*?\{#kap:([\w-]+)\}", inhalt, re.M)
+        if kopf:
+            kapitel_aufgaben[kopf.group(1)] = len(
+                re.findall(r"^\*\*Aufgabe [⭐*]", inhalt, re.M))
+
+    anhang = "90_Anhang_Loesungen.md"
+    if anhang in DATEIEN:
+        with open(os.path.join(HIER, anhang), encoding="utf-8") as f:
+            inhalt = f.read()
+        stuecke = re.split(r"^##\s.*\{#sec:loesungen-([\w-]+)\}", inhalt, flags=re.M)
+        for i in range(1, len(stuecke), 2):
+            label, block = stuecke[i], stuecke[i + 1]
+            marken = block.count("**{loesung} — ")
+            erwartet = kapitel_aufgaben.get(label)
+            if erwartet is None:
+                print(f"FEHLER: {anhang} hat '{{#sec:loesungen-{label}}}', "
+                      f"aber es gibt kein Kapitel '{{#kap:{label}}}'.")
+                fehlend.append(anhang)
+            elif marken != erwartet:
+                print(f"FEHLER: {anhang}: Abschnitt 'sec:loesungen-{label}' hat "
+                      f"{marken} Loesungen, das Kapitel aber {erwartet} Aufgaben.")
+                fehlend.append(anhang)
+
+    # Ein {#sec:...}-Label an einer ###-Ueberschrift. ABSCHNITT_RE erkennt nur
+    # '## ' - ein solches Label wird also NIE registriert, und jeder
+    # {ref:...} darauf laeuft ins Leere. Der Fehler sieht dabei voellig
+    # harmlos aus, weil die Ueberschrift richtig gesetzt wird.
+    tiefes_label_re = re.compile(r"^#{3,} .*\{#sec:[\w-]+\}", re.MULTILINE)
+    for name in DATEIEN:
+        with open(os.path.join(HIER, name), encoding="utf-8") as f:
+            inhalt = f.read()
+        for treffer in tiefes_label_re.finditer(inhalt):
+            zeile = inhalt[:treffer.start()].count("\n") + 1
+            print(f"FEHLER: {name}:{zeile} haengt ein {{#sec:...}}-Label an eine "
+                  f"###-Ueberschrift - registriert werden nur '## '-Abschnitte.")
+            fehlend.append(name)
+
+    # Die Lesekette. Jede Datei ausser der letzten schliesst mit
+    # '*Weiter mit:* [...](naechste_datei.md)' - und zwar auf die Datei, die in
+    # DATEIEN als naechste steht.
+    #
+    # Das ist keine Formalie: Nach den acht in Phase 3 eingefuegten Kapiteln
+    # zeigte die Kette an ihnen VORBEI. Wer ihr folgte, uebersprang
+    # stillschweigend acht von 23 Kapiteln - darunter Metaheuristiken,
+    # Spaltengenerierung und das ganze Testing-Kapitel. Gefunden wurde das
+    # erst, als die Synthese-Seiten dazwischenkamen.
+    #
+    # Vorwort und Notation sind ausgenommen: Sie verweisen in eigener Form.
+    OHNE_KETTE = {"00_Vorwort_und_Lesehilfe.md", "01_Notation_und_Abkuerzungen.md"}
+    weiter_re = re.compile(r"^\*Weiter mit:\*.*?\]\((\S+?\.md)\)", re.MULTILINE)
+    for i, name in enumerate(DATEIEN[:-1]):
+        if name in OHNE_KETTE:
+            continue
+        with open(os.path.join(HIER, name), encoding="utf-8") as f:
+            inhalt = f.read()
+        treffer = weiter_re.search(inhalt)
+        soll = DATEIEN[i + 1]
+        if treffer is None:
+            print(f"FEHLER: {name} hat keine '*Weiter mit:*'-Zeile - die Lesekette "
+                  f"bricht dort ab (naechste Datei waere {soll}).")
+            fehlend.append(name)
+        elif treffer.group(1) != soll:
+            print(f"FEHLER: {name} verweist auf '{treffer.group(1)}', in DATEIEN "
+                  f"folgt aber '{soll}' - die Lesekette ueberspringt eine Datei.")
+            fehlend.append(name)
+
     return fehlend
 
 
@@ -534,11 +644,39 @@ def nummeriere_abschnitte(text: str, labels: dict,
 AUFGABE_MARKE_RE = re.compile(r"^\*\*Aufgabe (?=[⭐*])")
 HANDRECHNUNG_MARKE_RE = re.compile(r"^(> \*\*✏️ Handrechnung): ")
 ABBILDUNG_MARKE_RE = re.compile(r"^!\[(?!Abb\. )")
+QUIZ_MARKE_RE = re.compile(r"^(> \*\*❓ Micro-Quiz): ")
+
+# Der Denkfehler bekommt BEWUSST keine Nummer. Es gibt je Kapitel genau einen,
+# und er steht unter der bereits nummerierten Ueberschrift '## 12.8 Finde den
+# Denkfehler'. Eine Marke '12.1', deren zweite Stelle immer 1 ist, traegt
+# nichts bei und holte nur die Fragilitaet zurueck, die hier gerade beseitigt
+# wurde. Verwiesen wird deshalb auf den Abschnitt: {ref:sec:<kapitel>-denkfehler}
+# - dieses Label haben alle 23 Kapitel.
+#
+# Die acht in Phase 3 ergaenzten Kapitel bestaetigen das: Sie schreiben nur den
+# Titel des Raetsels ('> **🐛 „Unsere Heuristik ist 6 % besser“**') und
+# wiederholen die Ueberschrift gar nicht erst.
+
+# Der Loesungsanhang ist der Sonderfall: Er ist EINE Anhang-Ueberschrift, aber
+# jeder seiner Abschnitte gehoert zu einem anderen Kapitel. Der Praefix kann
+# also nicht aus '# Anhang A:' kommen, sondern muss aus dem Kapitel stammen,
+# zu dem der Abschnitt die Loesungen enthaelt.
+#
+# Die Zuordnung ist herleitbar und ohne Sonderfall: '{#sec:loesungen-X}'
+# gehoert zu '{#kap:X}'. Geprueft fuer alle 23 Loesungsabschnitte.
+#
+# Das war der sechste Fund harter Nummern in diesem Projekt - und der
+# schlimmste: Alle 98 Loesungsmarken trugen die Kapitelnummer aus Version 03.
+# '9.2' bezeichnete danach eine echte, ANDERE Aufgabe (Metaheuristiken statt
+# Unsicherheit), wer die Loesung nachschlug, landete beim falschen Thema.
+LOESUNGS_ABSCHNITT_RE = re.compile(r"^##\s.*\{#(sec:loesungen-[\w-]+)\}")
+LOESUNGS_MARKE_RE = re.compile(r"^\*\*\{loesung\} — ")
 
 
-def nummeriere_marken(text: str) -> str:
-    """Vergibt die laufenden Nummern fuer Aufgaben, Handrechnungen und
-    Abbildungen, jeweils kapitelweise und in Lesereihenfolge.
+def nummeriere_marken(text: str, labels: dict | None = None) -> str:
+    """Vergibt die laufenden Nummern fuer Aufgaben, Handrechnungen,
+    Abbildungen, Denkfehler, Micro-Quiz und Loesungen - jeweils kapitelweise
+    und in Lesereihenfolge.
 
     Den Praefix ('5' bzw. 'C') liest die Funktion aus den bereits gesetzten
     '# Kapitel N:'/'# Anhang X:'-Ueberschriften - genau wie
@@ -549,13 +687,21 @@ def nummeriere_marken(text: str) -> str:
     Marken VOR der ersten Kapitel-/Anhang-Ueberschrift (Vorwort, Notation, die
     Entscheidungsdiagramme unter den Teil-Ueberschriften) bleiben unnummeriert.
 
+    Loesungen im Anhang bekommen ihren Praefix NICHT aus '# Anhang A:', sondern
+    aus dem Kapitel, zu dem der jeweilige '{#sec:loesungen-X}'-Abschnitt
+    gehoert - nachgeschlagen ueber 'labels' (siehe LOESUNGS_ABSCHNITT_RE).
+    Ohne 'labels' bleiben Loesungsmarken unveraendert stehen.
+
     Codebloecke werden uebersprungen: Was in einem Programm steht, wird von
     extract_programme_04.py als Datei herausgeloest und darf deshalb keine
     Nummer enthalten, die nur der Buchsatz kennt (Regel 12).
     """
+    leer = {"aufgabe": 0, "handrechnung": 0, "abbildung": 0, "quiz": 0}
     zeilen = text.split("\n")
     praefix: str | None = None
-    zaehler = {"aufgabe": 0, "handrechnung": 0, "abbildung": 0}
+    zaehler = dict(leer)
+    loesungs_praefix: str | None = None
+    loesungs_zaehler = {"loesung": 0}
     im_codeblock = False
 
     for i, zeile in enumerate(zeilen):
@@ -568,8 +714,30 @@ def nummeriere_marken(text: str) -> str:
         kopf = GESETZTE_UEBERSCHRIFT_RE.match(zeile)
         if kopf:
             praefix = kopf.group("kapitel") or kopf.group("anhang")
-            zaehler = {"aufgabe": 0, "handrechnung": 0, "abbildung": 0}
+            zaehler = dict(leer)
+            loesungs_praefix = None
             continue
+
+        # Ein neuer Loesungsabschnitt: Praefix aus dem zugehoerigen Kapitel.
+        # Der Anzeigetext in labels lautet 'Kapitel 12'; gebraucht wird '12'.
+        loesungskopf = LOESUNGS_ABSCHNITT_RE.match(zeile)
+        if loesungskopf and labels is not None:
+            kap_label = "kap:" + loesungskopf.group(1).removeprefix("sec:loesungen-")
+            anzeige = labels.get(kap_label, ("", ""))[0]
+            loesungs_praefix = (anzeige.removeprefix("Kapitel ")
+                                if anzeige.startswith("Kapitel ") else None)
+            if loesungs_praefix is None:
+                print(f"WARNUNG: Zu '{loesungskopf.group(1)}' gibt es kein "
+                      f"'{kap_label}' - Loesungen bleiben unnummeriert.")
+            loesungs_zaehler = {"loesung": 0}
+            continue
+
+        if loesungs_praefix is not None and LOESUNGS_MARKE_RE.match(zeile):
+            loesungs_zaehler["loesung"] += 1
+            zeilen[i] = LOESUNGS_MARKE_RE.sub(
+                f"**{loesungs_praefix}.{loesungs_zaehler['loesung']} — ", zeile)
+            continue
+
         if praefix is None:
             continue
 
@@ -585,6 +753,11 @@ def nummeriere_marken(text: str) -> str:
             zaehler["abbildung"] += 1
             zeilen[i] = ABBILDUNG_MARKE_RE.sub(
                 f"![Abb. {praefix}.{zaehler['abbildung']}: ", zeile)
+        elif QUIZ_MARKE_RE.match(zeile):
+            # Micro-Quiz gibt es je Kapitel nur eines, deshalb ohne laufende
+            # Nummer - 'Micro-Quiz 12', nicht 'Micro-Quiz 12.1'.
+            zaehler["quiz"] += 1
+            zeilen[i] = QUIZ_MARKE_RE.sub(rf"\1 {praefix}: ", zeile)
 
     return "\n".join(zeilen)
 
@@ -633,7 +806,7 @@ def resolve_numbering(text: str) -> str:
     # sonst zeigt der Verweis ins Leere.
     text, registriert = nummeriere_abschnitte(text, labels)
     abschnitte = len(registriert)
-    text = nummeriere_marken(text)
+    text = nummeriere_marken(text, labels)
 
     def ref_repl(m: re.Match) -> str:
         label = m.group(1)
@@ -865,6 +1038,14 @@ def baue_pdf() -> None:
 SONDERSEITEN = {
     "00_Vorwort_und_Lesehilfe.md": ("vorwort.html", "Vorwort & Lesehilfe"),
     "01_Notation_und_Abkuerzungen.md": ("notation.html", "Notation & Abkürzungen"),
+    # Die fuenf Teil-Synthesen. Sie tragen bewusst keine
+    # '# Kapitel:'-Ueberschrift - sie sind keine Kapitel, sondern der Rueckblick
+    # auf einen ganzen Teil - und brauchen deshalb hier ihren Seitennamen.
+    "19_Synthese_Grundlagen.md": ("synthese-grundlagen.html", "Synthese Teil I"),
+    "29_Synthese_Kernverfahren.md": ("synthese-kernverfahren.html", "Synthese Teil II"),
+    "39_Synthese_Nichtlinear.md": ("synthese-nichtlinear.html", "Synthese Teil III"),
+    "49_Synthese_Anwendungen.md": ("synthese-anwendungen.html", "Synthese Teil IV"),
+    "52_Synthese_Praxis.md": ("synthese-praxis.html", "Synthese Teil V"),
     "59_Projektwerkstatt.md": ("projektwerkstatt.html", "Projektwerkstatt"),
 }
 
@@ -1045,7 +1226,7 @@ def resolve_numbering_seite(text: str, aktuelle_seite: str,
         return f"## {nummer} {m.group('titel')} {{#{m.group('label')}}}"
 
     text = ABSCHNITT_RE.sub(abschnitt_sub, text)
-    text = nummeriere_marken(text)
+    text = nummeriere_marken(text, labels)
 
     def ref_sub(m: re.Match) -> str:
         label = m.group(1)
diff --git a/Operations_Research_mit_Python_Version_04_Programme/Benchmark_Skalierung.py b/Operations_Research_mit_Python_Version_04_Programme/Benchmark_Skalierung.py
index 731b813..0e0275b 100644
--- a/Operations_Research_mit_Python_Version_04_Programme/Benchmark_Skalierung.py
+++ b/Operations_Research_mit_Python_Version_04_Programme/Benchmark_Skalierung.py
@@ -33,113 +33,124 @@ Benoetigt: numpy; in den Kindprozessen scipy, highspy, ortools, cvxpy
 
 from __future__ import annotations
 
-import json
-import subprocess
-import sys
-import textwrap
+import multiprocessing
+import resource
+import time
+from concurrent.futures import ProcessPoolExecutor
+
+import numpy as np
 
 GROESSEN = [(10, 10), (32, 32), (100, 100)]   # (Lager, Kunden) -> 100 / 1.024 / 10.000 Variablen
 
 
-# Jeder Eintrag ist ein eigenstaendiges Programm: Instanz aufbauen, loesen,
-# Ergebnis als JSON ausgeben. Die Instanz wird in jedem Kindprozess aus
-# derselben Saat neu erzeugt - so reist nichts ueber die Prozessgrenze,
-# was das Ergebnis verfaelschen koennte.
-VORSPANN = """
-import json, time, resource
-import numpy as np
+# Instanz und Speichermessung stehen als gewoehnliche Funktionen hier - nicht
+# in einem String, den ein Kindprozess ausfuehrt. Jede Messfunktion baut die
+# Instanz aus derselben Saat neu auf, damit ueber die Prozessgrenze nichts
+# reist, was das Ergebnis verfaelschen koennte.
 
-def instanz(m, n):
+def instanz(m: int, n: int):
     rng = np.random.default_rng(20)
     kosten = rng.integers(5, 95, (m, n)).astype(float)
     angebot = rng.integers(50, 150, m).astype(float)
     bedarf = angebot.sum() * rng.dirichlet(np.ones(n))
     return kosten, angebot, bedarf
 
-def speicher_mb():
-    # ru_maxrss ist unter Linux in Kilobyte
+
+def speicher_mb() -> float:
+    # ru_maxrss ist unter Linux in Kilobyte. Gemessen wird der Kindprozess -
+    # deshalb muss jede Messung einen eigenen bekommen.
     return resource.getrusage(resource.RUSAGE_SELF).ru_maxrss / 1024
 
-M, N = {m}, {n}
-kosten, angebot, bedarf = instanz(M, N)
-"""
 
-ANSAETZE = {
-    "scipy.linprog": """
-        from scipy.optimize import linprog
-        t0 = time.perf_counter()
-        c = kosten.reshape(-1)
-        A_ub = np.zeros((M, M * N)); A_eq = np.zeros((N, M * N))
-        for i in range(M):
-            A_ub[i, i * N:(i + 1) * N] = 1.0
-        for j in range(N):
-            A_eq[j, j::N] = 1.0
-        aufbau = time.perf_counter() - t0
-        t0 = time.perf_counter()
-        r = linprog(c=c, A_ub=A_ub, b_ub=angebot, A_eq=A_eq, b_eq=bedarf,
-                    bounds=(0, None), method="highs")
-        loesen = time.perf_counter() - t0
-        ausgabe = (float(r.fun), aufbau, loesen, speicher_mb())
-    """,
-
-    "highspy": """
-        import highspy
-        t0 = time.perf_counter()
-        h = highspy.Highs(); h.setOptionValue("output_flag", False)
-        h.addVars(M * N, np.zeros(M * N), np.full(M * N, highspy.kHighsInf))
-        for k in range(M * N):
-            h.changeColCost(k, float(kosten.reshape(-1)[k]))
-        for i in range(M):
-            idx = np.arange(i * N, (i + 1) * N, dtype=np.int32)
-            h.addRow(-highspy.kHighsInf, float(angebot[i]), N, idx, np.ones(N))
-        for j in range(N):
-            idx = np.arange(j, M * N, N, dtype=np.int32)
-            h.addRow(float(bedarf[j]), float(bedarf[j]), M, idx, np.ones(M))
-        aufbau = time.perf_counter() - t0
-        t0 = time.perf_counter(); h.run(); loesen = time.perf_counter() - t0
-        ausgabe = (h.getInfo().objective_function_value, aufbau, loesen, speicher_mb())
-    """,
-
-    "ortools/GLOP": """
-        from ortools.linear_solver import pywraplp
-        t0 = time.perf_counter()
-        s = pywraplp.Solver.CreateSolver("GLOP")
-        x = [[s.NumVar(0, s.infinity(), f"x{i}_{j}") for j in range(N)]
-             for i in range(M)]
-        for i in range(M):
-            s.Add(sum(x[i]) <= float(angebot[i]))
-        for j in range(N):
-            s.Add(sum(x[i][j] for i in range(M)) == float(bedarf[j]))
-        s.Minimize(sum(float(kosten[i, j]) * x[i][j]
-                       for i in range(M) for j in range(N)))
-        aufbau = time.perf_counter() - t0
-        t0 = time.perf_counter(); s.Solve(); loesen = time.perf_counter() - t0
-        ausgabe = (s.Objective().Value(), aufbau, loesen, speicher_mb())
-    """,
-
-    "cvxpy": """
-        import cvxpy as cp
-        t0 = time.perf_counter()
-        x = cp.Variable((M, N), nonneg=True)
-        problem = cp.Problem(cp.Minimize(cp.sum(cp.multiply(kosten, x))),
-                             [cp.sum(x, axis=1) <= angebot,
-                              cp.sum(x, axis=0) == bedarf])
-        aufbau = time.perf_counter() - t0
-        t0 = time.perf_counter(); problem.solve(); loesen = time.perf_counter() - t0
-        ausgabe = (float(problem.value), aufbau, loesen, speicher_mb())
-    """,
-}
+def messe_scipy(m: int, n: int):
+    from scipy.optimize import linprog
+    kosten, angebot, bedarf = instanz(m, n)
+    t0 = time.perf_counter()
+    c = kosten.reshape(-1)
+    A_ub = np.zeros((m, m * n)); A_eq = np.zeros((n, m * n))
+    for i in range(m):
+        A_ub[i, i * n:(i + 1) * n] = 1.0
+    for j in range(n):
+        A_eq[j, j::n] = 1.0
+    aufbau = time.perf_counter() - t0
+    t0 = time.perf_counter()
+    r = linprog(c=c, A_ub=A_ub, b_ub=angebot, A_eq=A_eq, b_eq=bedarf,
+                bounds=(0, None), method="highs")
+    loesen = time.perf_counter() - t0
+    return float(r.fun), aufbau, loesen, speicher_mb()
 
 
-def messe(name: str, quelltext: str, m: int, n: int):
-    """Fuehrt einen Ansatz in einem eigenen Prozess aus."""
-    programm = (VORSPANN.format(m=m, n=n) + textwrap.dedent(quelltext)
-                + "\nprint(json.dumps(ausgabe))\n")
-    ergebnis = subprocess.run([sys.executable, "-c", programm],
-                              capture_output=True, text=True, timeout=600)
-    if ergebnis.returncode != 0:
-        return None, ergebnis.stderr.strip().splitlines()[-1][:60]
-    return json.loads(ergebnis.stdout.strip().splitlines()[-1]), None
+def messe_highspy(m: int, n: int):
+    import highspy
+    kosten, angebot, bedarf = instanz(m, n)
+    t0 = time.perf_counter()
+    h = highspy.Highs(); h.setOptionValue("output_flag", False)
+    h.addVars(m * n, np.zeros(m * n), np.full(m * n, highspy.kHighsInf))
+    for k in range(m * n):
+        h.changeColCost(k, float(kosten.reshape(-1)[k]))
+    for i in range(m):
+        idx = np.arange(i * n, (i + 1) * n, dtype=np.int32)
+        h.addRow(-highspy.kHighsInf, float(angebot[i]), n, idx, np.ones(n))
+    for j in range(n):
+        idx = np.arange(j, m * n, n, dtype=np.int32)
+        h.addRow(float(bedarf[j]), float(bedarf[j]), m, idx, np.ones(m))
+    aufbau = time.perf_counter() - t0
+    t0 = time.perf_counter(); h.run(); loesen = time.perf_counter() - t0
+    return h.getInfo().objective_function_value, aufbau, loesen, speicher_mb()
+
+
+def messe_ortools(m: int, n: int):
+    from ortools.linear_solver import pywraplp
+    kosten, angebot, bedarf = instanz(m, n)
+    t0 = time.perf_counter()
+    s = pywraplp.Solver.CreateSolver("GLOP")
+    x = [[s.NumVar(0, s.infinity(), f"x{i}_{j}") for j in range(n)]
+         for i in range(m)]
+    for i in range(m):
+        s.Add(sum(x[i]) <= float(angebot[i]))
+    for j in range(n):
+        s.Add(sum(x[i][j] for i in range(m)) == float(bedarf[j]))
+    s.Minimize(sum(float(kosten[i, j]) * x[i][j]
+                   for i in range(m) for j in range(n)))
+    aufbau = time.perf_counter() - t0
+    t0 = time.perf_counter(); s.Solve(); loesen = time.perf_counter() - t0
+    return s.Objective().Value(), aufbau, loesen, speicher_mb()
+
+
+def messe_cvxpy(m: int, n: int):
+    import cvxpy as cp
+    kosten, angebot, bedarf = instanz(m, n)
+    t0 = time.perf_counter()
+    x = cp.Variable((m, n), nonneg=True)
+    problem = cp.Problem(cp.Minimize(cp.sum(cp.multiply(kosten, x))),
+                         [cp.sum(x, axis=1) <= angebot,
+                          cp.sum(x, axis=0) == bedarf])
+    aufbau = time.perf_counter() - t0
+    t0 = time.perf_counter(); problem.solve(); loesen = time.perf_counter() - t0
+    return float(problem.value), aufbau, loesen, speicher_mb()
+
+
+ANSAETZE = {"scipy.linprog": messe_scipy, "highspy": messe_highspy,
+            "ortools/GLOP": messe_ortools, "cvxpy": messe_cvxpy}
+
+
+def messe(funktion, m: int, n: int):
+    """Fuehrt eine Messfunktion in einem FRISCHEN Prozess aus.
+
+    'spawn' und max_tasks_per_child=1 zusammen garantieren, was Regel 1
+    verlangt: Jede Messung sieht einen leeren Interpreter. Ohne das
+    zweite wuerde der Pool seinen Arbeiter wiederverwenden - dann waere
+    der Speicherwert der zweiten Bibliothek um die erste zu hoch, und
+    ortools und highspy saessen im selben Prozess.
+    """
+    with ProcessPoolExecutor(
+            max_workers=1,
+            mp_context=multiprocessing.get_context("spawn"),
+            max_tasks_per_child=1) as pool:
+        try:
+            return pool.submit(funktion, m, n).result(timeout=600), None
+        except Exception as fehler:
+            return None, str(fehler).strip().splitlines()[-1][:60]
 
 
 if __name__ == "__main__":
@@ -157,8 +168,8 @@ if __name__ == "__main__":
               f"{'Loesen':>9} {'Anteil':>8} {'Speicher':>10}")
         print("  " + "-" * 72)
         zielwerte = {}
-        for name, quelltext in ANSAETZE.items():
-            werte, fehler = messe(name, quelltext, m, n)
+        for name, funktion in ANSAETZE.items():
+            werte, fehler = messe(funktion, m, n)
             if werte is None:
                 print(f"  {name:<16} nicht verfuegbar: {fehler}")
                 continue
diff --git a/Operations_Research_mit_Python_Version_04_Programme/Constraint_Attribution.py b/Operations_Research_mit_Python_Version_04_Programme/Constraint_Attribution.py
new file mode 100644
index 0000000..c5a9ab7
--- /dev/null
+++ b/Operations_Research_mit_Python_Version_04_Programme/Constraint_Attribution.py
@@ -0,0 +1,305 @@
+#!/usr/bin/env python3
+
+# Constraint_Attribution.py
+"""
+Kapitel Praxisfallen: Welche Bedingung kostet wie viel - und was sagt man
+dem Management?
+
+Zwischen den beiden bekannten Faellen klafft eine Luecke:
+
+  * Erklaerbarkeit.py beantwortet "warum diese eine Zuweisung?"
+  * Konfliktsuche.py (Anhang Fehlerdiagnose) beantwortet "warum geht es gar
+    nicht?"
+
+Der haeufigste Fall in der Praxis liegt dazwischen: Das Modell rechnet, der
+Plan ist zulaessig - und trotzdem unbefriedigend. Niemand weiss, WORAN es
+liegt. Genau das beantwortet Constraint Attribution.
+
+Gerechnet wird auf derselben Fabrik wie in Konfliktsuche.py, nur nach der
+Reparatur: Dort war die Lackierkapazitaet von 150 Stunden der Kern des
+Widerspruchs (2*40 + 3*30 = 170 > 150). Eine zweite Schicht hat sie auf 210
+gebracht, und der Mindestumsatz wurde auf 10.000 EUR gesenkt. Jetzt ist das
+Modell loesbar - und die Frage lautet nicht mehr "warum nicht?", sondern
+"was kostet uns was?".
+
+Gezeigt werden vier Dinge:
+  1. Welche Bedingungen binden - und dass "bindend" nicht "teuer" heisst.
+  2. Dass der Schattenpreis eine MOMENTAUFNAHME ist: hochgerechnet auf eine
+     realistische Sonderschicht verspricht er hier das Doppelte des
+     tatsaechlichen Nutzens.
+  3. Dass ein Wunsch aus dem Vertrieb nicht teuer, sondern unmoeglich sein
+     kann - und welche Bedingungen ihn gemeinsam blockieren.
+  4. Wie aus alledem ein Bericht in Alltagssprache wird.
+
+Benoetigt: numpy, scipy
+"""
+
+from __future__ import annotations
+
+import textwrap
+
+import numpy as np
+from scipy.optimize import linprog
+
+PRODUKTE = ["Rahmen", "Gehaeuse", "Deckel", "Traeger", "Halter"]
+DECKUNGSBEITRAG = np.array([35.0, 28.0, 9.0, 22.0, 6.0])   # EUR je Stueck
+
+# Dieselben Bedingungen wie in Konfliktsuche.py, mit den beiden Reparaturen.
+# Der sprechende Name ist keine Kosmetik: Ohne ihn ist kein Bericht moeglich,
+# der jemandem ausserhalb der Modellierung etwas sagt.
+BEDINGUNGEN: list[tuple[str, list[float], str, float]] = [
+    ("Kapazitaet Montage",       [3, 2, 1, 4, 2],      "<=",   400),
+    ("Kapazitaet Lackieren",     [2, 3, 0, 1, 0],      "<=",   210),
+    ("Kapazitaet Pruefung",      [1, 1, 1, 1, 1],      "<=",   300),
+    ("Liefervertrag Rahmen",     [1, 0, 0, 0, 0],      ">=",    40),
+    ("Liefervertrag Gehaeuse",   [0, 1, 0, 0, 0],      ">=",    30),
+    ("Liefervertrag Deckel",     [0, 0, 1, 0, 0],      ">=",    20),
+    ("Liefervertrag Traeger",    [0, 0, 0, 1, 0],      ">=",    25),
+    ("Marktgrenze Rahmen",       [1, 0, 0, 0, 0],      "<=",   120),
+    ("Marktgrenze Gehaeuse",     [0, 1, 0, 0, 0],      "<=",    90),
+    ("Marktgrenze Deckel",       [0, 0, 1, 0, 0],      "<=",   150),
+    ("Marktgrenze Halter",       [0, 0, 0, 0, 1],      "<=",   200),
+    ("Mindestumsatz",            [90, 70, 30, 60, 20], ">=", 10000),
+    ("Sortimentsbreite",         [0, 0, 1, 1, 1],      ">=",   100),
+    ("Lackierbudget Schicht 2",  [0, 1, 0, 1, 0],      "<=",    55),
+]
+
+# Was liesse sich im Ernstfall wirklich bewegen - und um wie viel? Nicht "eine
+# Einheit", sondern der Schritt, den ein Planer tatsaechlich gehen kann: eine
+# Sonderschicht, ein nachverhandelter Vertrag. Genau an dieser Groesse
+# scheitert das blosse Hochrechnen des Schattenpreises.
+STELLSCHRAUBEN: dict[str, tuple[float, str]] = {
+    "Kapazitaet Montage":      (+50, "eine Sonderschicht Montage"),
+    "Kapazitaet Lackieren":    (+30, "eine Sonderschicht Lackieren"),
+    "Kapazitaet Pruefung":     (+50, "eine Sonderschicht Pruefung"),
+    "Lackierbudget Schicht 2": (+10, "10 Stunden mehr Budget in Schicht 2"),
+    "Liefervertrag Traeger":   (-10, "10 Stueck weniger Abnahmepflicht Traeger"),
+    "Liefervertrag Gehaeuse":  (-10, "10 Stueck weniger Abnahmepflicht Gehaeuse"),
+}
+
+WUNSCH_MENGE = 55.0      # der Vertrieb haette gern mehr Rahmen
+WUNSCH_PRODUKT = "Rahmen"
+
+
+def loese(bedingungen: list[tuple[str, list[float], str, float]]):
+    """Maximiert den Deckungsbeitrag. linprog minimiert, daher das Vorzeichen."""
+    matrix, rechte_seite = [], []
+    for _, koeffizienten, richtung, grenze in bedingungen:
+        zeile = np.array(koeffizienten, dtype=float)
+        matrix.append(zeile if richtung == "<=" else -zeile)
+        rechte_seite.append(grenze if richtung == "<=" else -grenze)
+    return linprog(-DECKUNGSBEITRAG,
+                   A_ub=np.array(matrix), b_ub=np.array(rechte_seite),
+                   bounds=[(0, None)] * len(PRODUKTE), method="highs")
+
+
+def geaendert(name: str, delta: float,
+              basis=None) -> list[tuple[str, list[float], str, float]]:
+    """Dieselben Bedingungen, eine davon um delta verschoben."""
+    return [(n, k, r, g + delta if n == name else g)
+            for n, k, r, g in (basis or BEDINGUNGEN)]
+
+
+def auswertung(ergebnis, bedingungen=None):
+    """Schlupf und Schattenpreis je Bedingung."""
+    x = ergebnis.x
+    dual = ergebnis.ineqlin.marginals
+    zeilen = []
+    for i, (name, koeff, richtung, grenze) in enumerate(bedingungen or BEDINGUNGEN):
+        links = float(np.array(koeff, dtype=float) @ x)
+        schlupf = (grenze - links) if richtung == "<=" else (links - grenze)
+        zeilen.append((name, links, richtung, grenze, schlupf, abs(dual[i])))
+    return zeilen
+
+
+def blockierer(bedingungen, zusatz) -> list[str]:
+    """Welche Bedingungen verhindern 'zusatz' - einzeln weggelassen.
+
+    Dasselbe Vorgehen wie der Deletion Filter in Konfliktsuche.py, nur mit
+    umgekehrtem Vorzeichen: Dort wird gesucht, was den Widerspruch AUSMACHT,
+    hier, was einen Wunsch VERHINDERT. Wird das Modell ohne eine Bedingung
+    loesbar, gehoert sie zum Konflikt.
+    """
+    gefunden = []
+    for i, (name, _, _, _) in enumerate(bedingungen):
+        rest = [c for j, c in enumerate(bedingungen) if j != i] + [zusatz]
+        if loese(rest).success:
+            gefunden.append(name)
+    return gefunden
+
+
+def euro(betrag: float) -> str:
+    return f"{betrag:,.2f} EUR"
+
+
+if __name__ == "__main__":
+    basis = loese(BEDINGUNGEN)
+    db_basis = -basis.fun
+    plan = dict(zip(PRODUKTE, basis.x))
+
+    print("=" * 78)
+    print("  CONSTRAINT ATTRIBUTION: Was kostet uns welche Bedingung?")
+    print("=" * 78)
+    print(f"Status: {basis.message.split('(')[0].strip()}")
+    print(f"Deckungsbeitrag des Plans: {euro(db_basis)}\n")
+    print("  " + "  ".join(f"{p}: {m:.1f}" for p, m in plan.items()))
+
+    # --- 1. Wer begrenzt den Plan? -----------------------------------------
+    print("\n" + "=" * 78)
+    print("  (1) Welche Bedingungen binden - und was kostet die naechste Einheit?")
+    print("=" * 78)
+    print(f"{'Bedingung':<24} {'genutzt':>9} {'Grenze':>7} {'Schlupf':>8} "
+          f"{'Schattenpreis':>11}")
+    print("-" * 78)
+    bindend = []
+    for name, links, richtung, grenze, schlupf, dual in auswertung(basis):
+        marke = ""
+        if abs(schlupf) < 1e-6:
+            bindend.append((name, dual))
+            marke = "  <-- bindend"
+        print(f"{name:<24} {links:>9.1f} {grenze:>7.0f} {schlupf:>8.1f} "
+              f"{dual:>11.2f}{marke}")
+
+    ohne_preis = [n for n, d in bindend if d < 1e-9]
+    print(f"\n  {len(bindend)} Bedingungen binden. Aber: "
+          f"{', '.join(ohne_preis)} bindet")
+    print("  mit einem Schattenpreis von 0,00 EUR - sie beruehrt den Plan, ohne ihn")
+    print("  zu verteuern. Bindend und kostenrelevant sind zwei verschiedene Dinge.")
+
+    # --- 2. Der Schattenpreis als Momentaufnahme ---------------------------
+    print("\n" + "=" * 78)
+    print("  (2) Was der Schattenpreis verschweigt")
+    print("=" * 78)
+    print("Der Schattenpreis gilt fuer die NAECHSTE Einheit. Ein Planer kauft aber")
+    print("keine Einheit, sondern eine ganze Schicht. Beides gegenuebergestellt:\n")
+    preise = {name: dual for name, *_, dual in auswertung(basis)}
+    print(f"{'Stellschraube':<24} {'Preis':>9} {'Schritt':>7} "
+          f"{'hochgerechnet':>13} {'gemessen':>9} {'Abw.':>9}")
+    print("-" * 78)
+    wirkung = {}
+    for name, (delta, _) in STELLSCHRAUBEN.items():
+        ergebnis = loese(geaendert(name, delta))
+        echt = (-ergebnis.fun) - db_basis if ergebnis.success else 0.0
+        linear = preise[name] * abs(delta)
+        wirkung[name] = echt
+        print(f"{name:<24} {preise[name]:>9.2f} {delta:>+7.0f} "
+              f"{linear:>13.2f} {echt:>9.2f} {echt - linear:>+9.2f}")
+
+    # Wo endet der Gueltigkeitsbereich? Schrittweise nachfahren.
+    abweichler = max(STELLSCHRAUBEN,
+                     key=lambda n: preise[n] * abs(STELLSCHRAUBEN[n][0]) - wirkung[n])
+    delta_max = STELLSCHRAUBEN[abweichler][0]
+    grenze_gueltig = 0.0
+    schritt = delta_max / 60.0
+    vorher = db_basis
+    for i in range(1, 61):
+        d = schritt * i
+        e = loese(geaendert(abweichler, d))
+        db = -e.fun if e.success else vorher
+        if db - vorher > 1e-9:
+            grenze_gueltig = d
+        vorher = db
+    print(f"\n  '{abweichler}': hochgerechnet "
+          f"{preise[abweichler] * abs(delta_max):.2f} EUR, tatsaechlich "
+          f"{wirkung[abweichler]:.2f} EUR.")
+    print(f"  Der Preis von {preise[abweichler]:.2f} EUR gilt nur bis "
+          f"+{grenze_gueltig:.0f} Stunden. Jede weitere Stunde")
+    print("  dieser Sonderschicht bringt exakt nichts - der Engpass ist dann ein anderer.")
+
+    nach_preis = sorted(STELLSCHRAUBEN, key=lambda n: -preise[n])[0]
+    nach_wirkung = max(wirkung, key=wirkung.get)
+    print(f"\n  Und die Ranglisten drehen sich: Nach Schattenpreis fuehrt")
+    print(f"  '{nach_preis}' ({preise[nach_preis]:.2f} EUR je Einheit),")
+    print(f"  nach tatsaechlicher Wirkung '{nach_wirkung}' "
+          f"({wirkung[nach_wirkung]:.2f} EUR).")
+    print("  Der Schattenpreis sagt, was eine Einheit wert ist - nicht, wie viele")
+    print("  Einheiten zu haben sind.")
+
+    # --- 3. Der Wunsch aus dem Vertrieb ------------------------------------
+    print("\n" + "=" * 78)
+    print(f"  (3) Was-waere-wenn: mindestens {WUNSCH_MENGE:.0f} "
+          f"{WUNSCH_PRODUKT} statt {plan[WUNSCH_PRODUKT]:.1f}")
+    print("=" * 78)
+    wunsch = (f"Wunsch Vertrieb {WUNSCH_PRODUKT}",
+              [1 if p == WUNSCH_PRODUKT else 0 for p in PRODUKTE], ">=", WUNSCH_MENGE)
+    mit_wunsch = loese(BEDINGUNGEN + [wunsch])
+    schuldige: list[str] = []
+    engpass = noetig = None
+    wunsch_gratis = False
+
+    if mit_wunsch.success:
+        print(f"Erfuellbar, kostet {euro(db_basis - (-mit_wunsch.fun))}.")
+    else:
+        schuldige = blockierer(BEDINGUNGEN, wunsch)
+        print("Der Wunsch ist nicht teuer - er ist UNMOEGLICH.\n")
+        print(f"Blockiert wird er von {len(schuldige)} Bedingungen gemeinsam. "
+              f"Faellt eine davon")
+        print("weg, ist er erfuellbar; keine allein ist 'der' Grund:")
+        for name in schuldige:
+            e = loese([c for c in BEDINGUNGEN if c[0] != name] + [wunsch])
+            print(f"   ohne '{name}': moeglich, Deckungsbeitrag {euro(-e.fun)}")
+
+        engpass = next((n for n in schuldige if n in STELLSCHRAUBEN), schuldige[0])
+        for schritt in range(1, 61):
+            if loese(geaendert(engpass, schritt) + [wunsch]).success:
+                noetig = schritt
+                break
+        if noetig is not None:
+            e = loese(geaendert(engpass, noetig) + [wunsch])
+            ohne = loese(geaendert(engpass, noetig))
+            wunsch_gratis = abs((-e.fun) - (-ohne.fun)) < 1e-6
+            print(f"\n   Mit +{noetig} bei '{engpass}' wird der Wunsch erfuellbar:")
+            print(f"   Deckungsbeitrag {euro(-e.fun)} "
+                  f"({-e.fun - db_basis:+,.2f} gegenueber heute).")
+            if wunsch_gratis:
+                print(f"   Und ohne den Wunsch ergaebe dieselbe Lockerung "
+                      f"{euro(-ohne.fun)} bei")
+                print(f"   {ohne.x[PRODUKTE.index(WUNSCH_PRODUKT)]:.0f} "
+                      f"{WUNSCH_PRODUKT} - der Wunsch kostet also NICHTS.")
+                print("   Er war nie das Problem. Der Engpass war es.")
+
+    # --- 4. Der Bericht ----------------------------------------------------
+    # Aus denselben Zahlen, die oben in Tabellen stehen, wird hier Prosa. Kein
+    # Satz enthaelt eine Zahl, die nicht vorher gerechnet wurde - das ist der
+    # ganze Trick und zugleich die Bedingung dafuer, dass der Bericht nicht
+    # irgendwann leise falsch wird.
+    print("\n" + "=" * 78)
+    print("  (4) Und so steht es in der Vorlage fuer die Abteilungsleiterrunde")
+    print("=" * 78)
+
+    teuerste = sorted(((n, d) for n, d in bindend if d > 0), key=lambda t: -t[1])
+    gross = STELLSCHRAUBEN[nach_wirkung][1]
+    klein = STELLSCHRAUBEN[abweichler][1]
+
+    absaetze = [
+        f"Der Plan bringt {euro(db_basis)} Deckungsbeitrag. Begrenzt wird er von "
+        f"{len(bindend)} Bedingungen, von denen {len(teuerste)} tatsaechlich Geld "
+        f"kosten; \"{ohne_preis[0]}\" beruehrt den Plan, ohne ihn zu verteuern.",
+
+        f"Teuerste Bindung ist \"{teuerste[0][0]}\" mit "
+        f"{teuerste[0][1]:.2f} EUR je Einheit, gefolgt von \"{teuerste[1][0]}\" "
+        f"mit {teuerste[1][1]:.2f} EUR.",
+
+        f"Die groesste einzelne Verbesserung bringt {gross}: "
+        f"{euro(wirkung[nach_wirkung])} mehr Deckungsbeitrag. {klein[0].upper()}{klein[1:]} "
+        f"dagegen bringt nur {euro(wirkung[abweichler])} statt der rechnerischen "
+        f"{euro(preise[abweichler] * abs(delta_max))} - ab +{grenze_gueltig:.0f} "
+        f"Stunden begrenzt uns etwas anderes. Wer die ganze Schicht bezahlt, "
+        f"bezahlt die zweite Haelfte umsonst.",
+    ]
+
+    if schuldige and noetig is not None:
+        namen = ", ".join(f'"{s}"' for s in schuldige)
+        satz = (f"Zum Wunsch des Vertriebs ({WUNSCH_MENGE:.0f} {WUNSCH_PRODUKT} statt "
+                f"{plan[WUNSCH_PRODUKT]:.1f}): Er ist mit der heutigen Ausstattung "
+                f"nicht erfuellbar - nicht aus Kostengruenden, sondern weil {namen} "
+                f"ihn gemeinsam blockieren. Mit +{noetig} Stunden bei "
+                f'"{engpass}" wird er moeglich')
+        satz += (", und er kostet dann nichts: Der Plan waehlt diese Menge von "
+                 "sich aus." if wunsch_gratis else ".")
+        absaetze.append(satz)
+
+    for absatz in absaetze:
+        print()
+        print(textwrap.fill(absatz, width=76))
+    print("\n" + "=" * 78)
diff --git a/Operations_Research_mit_Python_Version_04_Programme/Ein_System_Vier_Ansaetze.py b/Operations_Research_mit_Python_Version_04_Programme/Ein_System_Vier_Ansaetze.py
index cccb1c5..34bc3e2 100644
--- a/Operations_Research_mit_Python_Version_04_Programme/Ein_System_Vier_Ansaetze.py
+++ b/Operations_Research_mit_Python_Version_04_Programme/Ein_System_Vier_Ansaetze.py
@@ -8,85 +8,104 @@ Kapitel Oekosystem: Dasselbe LP in vier Bibliotheken.
           2*x1 + 3*x2 + x3 <= 50
           x >= 0
 
-Deckt scipy.optimize, highspy, CVXPY und OR-Tools/GLOP ab, mit Kreuzvergleich am Ende.
+Deckt scipy.optimize, highspy, CVXPY und OR-Tools/GLOP ab, mit Kreuzvergleich
+am Ende.
 
-WICHTIG: Jeder Solver läuft in einem EIGENEN Prozess, weil sich ortools und
+WICHTIG: Jeder Solver laeuft in einem EIGENEN Prozess, weil sich ortools und
 highspy auf vielen Systemen nicht gemeinsam importieren lassen (beide bringen
 eine eigene HiGHS-Kopie mit -> Symbolkonflikt).
+
+Die Isolation besorgt ein ProcessPoolExecutor. Drei Einstellungen ergeben
+zusammen die Garantie:
+
+  mp_context "spawn"     Der Kindprozess startet mit einem FRISCHEN
+                         Interpreter, statt den Speicher des Elternprozesses
+                         zu erben. Was hier schon importiert ist, ist dort
+                         nicht importiert. Mit dem Standard "fork" auf Linux
+                         waere das nicht so.
+  max_tasks_per_child=1  Jede Aufgabe bekommt einen NEUEN Prozess. Ohne das
+                         wuerde der Pool seinen Arbeiter wiederverwenden - und
+                         beim zweiten Solver waere der Konflikt zurueck.
+  max_workers=1          Haelt die vier Laeufe nacheinander. Nicht aus
+                         Vorsicht, sondern damit die gemessenen Zeiten
+                         vergleichbar bleiben.
+
+Jeder Solver steht in einer eigenen Funktion mit LOKALEM Import. Das ist der
+Unterschied zu einem Codestring, den man an 'python -c' uebergibt: Die
+Funktion laesst sich einzeln aufrufen, testen und vom Editor pruefen - ein
+String nicht.
+
+Benoetigt: scipy, highspy, cvxpy, ortools
 """
 
-import json
-import subprocess
-import sys
-import textwrap
+import multiprocessing
 import time
+from concurrent.futures import ProcessPoolExecutor
 
 ERWARTET = 530.0            # Ergebnis der Handrechnung zum Produktionsprogramm
 
-# Jeder Eintrag ist ein eigenständiges Miniprogramm, das sein Ergebnis als
-# JSON auf stdout ausgibt. So bleibt jeder Import in seinem eigenen Prozess.
-ANSAETZE: dict[str, str] = {
+# Die Instanz - einmal notiert, von allen vier Funktionen benutzt.
+ZIEL = [10.0, 15.0, 25.0]
+MATRIX = [[1, 1, 2], [2, 3, 1]]
+KAPAZITAET = [40.0, 50.0]
 
-    "scipy.optimize.linprog": """
-        from scipy.optimize import linprog
-        res = linprog(c=[-10.0, -15.0, -25.0],           # linprog MINIMIERT -> negieren
-                      A_ub=[[1, 1, 2], [2, 3, 1]], b_ub=[40, 50],
-                      bounds=[(0, None)] * 3, method="highs")
-        ausgabe = (-res.fun, list(res.x))
-    """,
 
-    "highspy (natives HiGHS)": """
-        import numpy as np, highspy
-        h = highspy.Highs()
-        h.setOptionValue("output_flag", False)
-        h.addVars(3, np.zeros(3), np.full(3, highspy.kHighsInf))
-        h.changeObjectiveSense(highspy.ObjSense.kMaximize)
-        for j, wert in enumerate([10.0, 15.0, 25.0]):
-            h.changeColCost(j, wert)
-        # CSR-Format: starts[i] = Beginn von Zeile i in indices/values
-        h.addRows(2, np.full(2, -highspy.kHighsInf), np.array([40.0, 50.0]), 6,
-                  np.array([0, 3], dtype=np.int32),
-                  np.array([0, 1, 2, 0, 1, 2], dtype=np.int32),
-                  np.array([1.0, 1.0, 2.0, 2.0, 3.0, 1.0]))
-        h.run()
-        ausgabe = (h.getInfo().objective_function_value,
-                   list(h.getSolution().col_value[:3]))
-    """,
+def loese_mit_scipy() -> tuple[float, list[float]]:
+    from scipy.optimize import linprog
+    ergebnis = linprog(c=[-w for w in ZIEL],          # linprog MINIMIERT -> negieren
+                       A_ub=MATRIX, b_ub=KAPAZITAET,
+                       bounds=[(0, None)] * 3, method="highs")
+    return -ergebnis.fun, list(ergebnis.x)
 
-    "cvxpy": """
-        import numpy as np, cvxpy as cp
-        x = cp.Variable(3, nonneg=True)
-        problem = cp.Problem(cp.Maximize(np.array([10.0, 15.0, 25.0]) @ x),
-                             [np.array([[1, 1, 2], [2, 3, 1]]) @ x <= np.array([40, 50])])
-        problem.solve()
-        ausgabe = (float(problem.value), [float(v) for v in x.value])
-    """,
 
-    "ortools / GLOP": """
-        from ortools.linear_solver import pywraplp
-        s = pywraplp.Solver.CreateSolver("GLOP")
-        x = [s.NumVar(0, s.infinity(), f"x{j+1}") for j in range(3)]
-        A = [[1, 1, 2], [2, 3, 1]]
-        for i, kap in enumerate([40, 50]):
-            s.Add(sum(A[i][j] * x[j] for j in range(3)) <= kap)
-        s.Maximize(10 * x[0] + 15 * x[1] + 25 * x[2])
-        s.Solve()
-        ausgabe = (s.Objective().Value(), [v.solution_value() for v in x])
-    """,
+def loese_mit_highspy() -> tuple[float, list[float]]:
+    import highspy
+    import numpy as np
+    h = highspy.Highs()
+    h.setOptionValue("output_flag", False)
+    h.addVars(3, np.zeros(3), np.full(3, highspy.kHighsInf))
+    h.changeObjectiveSense(highspy.ObjSense.kMaximize)
+    for j, wert in enumerate(ZIEL):
+        h.changeColCost(j, wert)
+    # CSR-Format: starts[i] = Beginn von Zeile i in indices/values
+    h.addRows(2, np.full(2, -highspy.kHighsInf), np.array(KAPAZITAET), 6,
+              np.array([0, 3], dtype=np.int32),
+              np.array([0, 1, 2, 0, 1, 2], dtype=np.int32),
+              np.array([float(w) for zeile in MATRIX for w in zeile]))
+    h.run()
+    return (h.getInfo().objective_function_value,
+            list(h.getSolution().col_value[:3]))
+
+
+def loese_mit_cvxpy() -> tuple[float, list[float]]:
+    import cvxpy as cp
+    import numpy as np
+    x = cp.Variable(3, nonneg=True)
+    problem = cp.Problem(cp.Maximize(np.array(ZIEL) @ x),
+                         [np.array(MATRIX) @ x <= np.array(KAPAZITAET)])
+    problem.solve()
+    return float(problem.value), [float(v) for v in x.value]
+
+
+def loese_mit_ortools() -> tuple[float, list[float]]:
+    from ortools.linear_solver import pywraplp
+    s = pywraplp.Solver.CreateSolver("GLOP")
+    x = [s.NumVar(0, s.infinity(), f"x{j+1}") for j in range(3)]
+    for i, kapazitaet in enumerate(KAPAZITAET):
+        s.Add(sum(MATRIX[i][j] * x[j] for j in range(3)) <= kapazitaet)
+    s.Maximize(sum(ZIEL[j] * x[j] for j in range(3)))
+    s.Solve()
+    return s.Objective().Value(), [v.solution_value() for v in x]
+
+
+ANSAETZE = {
+    "scipy.optimize.linprog": loese_mit_scipy,
+    "highspy (natives HiGHS)": loese_mit_highspy,
+    "cvxpy": loese_mit_cvxpy,
+    "ortools / GLOP": loese_mit_ortools,
 }
 
 
-def fuehre_in_eigenem_prozess_aus(quelltext: str) -> tuple[float, list[float]]:
-    """Startet den Codeschnipsel als separaten Python-Prozess und liest das Ergebnis."""
-    programm = textwrap.dedent(quelltext) + "\nimport json; print(json.dumps(ausgabe))\n"
-    ergebnis = subprocess.run([sys.executable, "-c", programm],
-                              capture_output=True, text=True, timeout=120)
-    if ergebnis.returncode != 0:
-        raise RuntimeError(ergebnis.stderr.strip().splitlines()[-1])
-    wert, loesung = json.loads(ergebnis.stdout.strip().splitlines()[-1])
-    return wert, loesung
-
-
 if __name__ == "__main__":
     print("=" * 78)
     print("  EIN SYSTEM - VIER ANSAETZE (je eigener Prozess)")
@@ -95,17 +114,23 @@ if __name__ == "__main__":
     print("-" * 78)
 
     werte = []
-    for name, quelltext in ANSAETZE.items():
-        t0 = time.perf_counter()
-        try:
-            wert, x = fuehre_in_eigenem_prozess_aus(quelltext)
-        except RuntimeError as fehler:
-            print(f"{name:<26} nicht verfuegbar: {fehler[:40]}")
-            continue
-        dauer = time.perf_counter() - t0
-        werte.append(wert)
-        print(f"{name:<26} {wert:>10.2f} {x[0]:>7.2f} {x[1]:>7.2f} {x[2]:>7.2f} "
-              f"{dauer:>8.2f} s")
+    # Ein Pool, vier Aufgaben, vier frische Prozesse. Der Kontext muss
+    # "spawn" sein - siehe Modulkommentar.
+    with ProcessPoolExecutor(
+            max_workers=1,
+            mp_context=multiprocessing.get_context("spawn"),
+            max_tasks_per_child=1) as pool:
+        for name, funktion in ANSAETZE.items():
+            beginn = time.perf_counter()
+            try:
+                wert, x = pool.submit(funktion).result(timeout=120)
+            except Exception as fehler:                     # Bibliothek fehlt o. Ae.
+                print(f"{name:<26} nicht verfuegbar: {str(fehler)[:40]}")
+                continue
+            dauer = time.perf_counter() - beginn
+            werte.append(wert)
+            print(f"{name:<26} {wert:>10.2f} {x[0]:>7.2f} {x[1]:>7.2f} {x[2]:>7.2f} "
+                  f"{dauer:>8.2f} s")
 
     print("-" * 78)
     spanne = max(werte) - min(werte)
@@ -115,6 +140,6 @@ if __name__ == "__main__":
     assert spanne < 1e-6, "Die Bibliotheken widersprechen sich!"
     assert abs(werte[0] - ERWARTET) < 1e-6, "Ergebnis weicht von der Handrechnung ab!"
     print("Alle Wege fuehren zum selben, von Hand bestaetigten Optimum.")
-    print("(Die Zeiten enthalten den Prozessstart und den Import - sie messen")
-    print(" NICHT die reine Solverleistung, siehe Uebung 3.5.)")
+    print("(Die Zeiten enthalten Prozessstart und Import - sie messen NICHT die")
+    print(" reine Solverleistung. Die Uebungsaufgabe 'Laufzeitvergleich' trennt beides.)")
     print("=" * 78)
diff --git a/Operations_Research_mit_Python_Version_04_Programme/Kovarianz_Falle.py b/Operations_Research_mit_Python_Version_04_Programme/Kovarianz_Falle.py
index 7f5bbb1..8cb4af9 100644
--- a/Operations_Research_mit_Python_Version_04_Programme/Kovarianz_Falle.py
+++ b/Operations_Research_mit_Python_Version_04_Programme/Kovarianz_Falle.py
@@ -55,7 +55,8 @@ def minimales_risiko(kovarianz: np.ndarray) -> tuple[np.ndarray, float]:
     exakt positiv semidefinit ist - rechne trotzdem.' Das ist hier bewusst so
     gewaehlt, denn genau diese Eigenschaft wollen wir vorfuehren. Im
     Produktivbetrieb waere die DCP-Fehlermeldung das Warnsignal, dem man
-    nachgehen muss (siehe Denkfehler 8.1).
+    nachgehen muss (siehe den Denkfehler im Kapitel Quadratische und
+    nichtlineare Optimierung).
     """
     gewichte = cp.Variable(ANZAHL_ANLAGEN)
     problem = cp.Problem(cp.Minimize(cp.quad_form(gewichte, cp.psd_wrap(kovarianz))),
diff --git a/Operations_Research_mit_Python_Version_04_Programme/Parallele_Suche.py b/Operations_Research_mit_Python_Version_04_Programme/Parallele_Suche.py
new file mode 100644
index 0000000..a23ed10
--- /dev/null
+++ b/Operations_Research_mit_Python_Version_04_Programme/Parallele_Suche.py
@@ -0,0 +1,195 @@
+#!/usr/bin/env python3
+
+# Parallele_Suche.py
+"""
+Kapitel CP-SAT: Was mehrere Arbeiter wirklich bringen - und was sie kosten.
+
+Das Buch setzt an mehreren Stellen 'num_workers = 1', damit die abgedruckte
+Ausgabe reproduzierbar ist. Behauptet wird dabei zweierlei: dass parallele
+Suche schneller ist, und dass sie von Lauf zu Lauf verschiedene, gleich gute
+Loesungen findet. Beides wird hier gemessen statt geglaubt.
+
+Gerechnet wird auf einem Job-Shop wie in JobShop_Intervalle.py, nur gross
+genug, dass die Suche wirklich arbeitet: 12 Auftraege auf 10 Maschinen,
+jeder Auftrag besucht jede Maschine.
+
+Zwei Messungen:
+  1. Dieselbe Aufgabe mit 1, 2, 4 und 8 Arbeitern - Laufzeit und Ergebnis.
+  2. Dieselbe Konfiguration mehrfach, bei FESTEM random_seed - wie oft kommt
+     derselbe Plan heraus?
+
+Die zweite ist die wichtigere: Sie entscheidet, wie man Tests schreibt.
+
+Achtung, Laufzeiten sind hardwareabhaengig. Die ZAHL der verschiedenen
+Plaene ist es auch - und genau das ist die Aussage.
+
+Benoetigt: numpy, ortools
+"""
+
+from __future__ import annotations
+
+import collections
+import time
+
+import numpy as np
+from ortools.sat.python import cp_model
+
+AUFTRAEGE = 12
+MASCHINEN = 10
+INSTANZ_SEED = 20260908
+SOLVER_SEED = 1          # bleibt ueber ALLE Laeufe gleich - das ist der Punkt
+ARBEITERZAHLEN = (1, 2, 4, 8)
+WIEDERHOLUNGEN = 4
+ZEITLIMIT = 120.0
+
+
+def baue_instanz() -> list[list[tuple[int, int]]]:
+    """Klassischer Job-Shop: Jeder Auftrag besucht jede Maschine genau einmal,
+    in einer eigenen zufaelligen Reihenfolge."""
+    rng = np.random.default_rng(INSTANZ_SEED)
+    return [[(int(m), int(rng.integers(2, 20))) for m in rng.permutation(MASCHINEN)]
+            for _ in range(AUFTRAEGE)]
+
+
+def loese(auftraege, arbeiter: int):
+    """Minimiert den Makespan. Gibt Status, Zielwert, Laufzeit und den Plan
+    zurueck - den Plan als Tupel aller Startzeiten, damit sich zwei Laeufe
+    vergleichen lassen."""
+    horizont = sum(dauer for auftrag in auftraege for _, dauer in auftrag)
+    modell = cp_model.CpModel()
+    Gang = collections.namedtuple("Gang", "start ende intervall")
+    plaene: dict[tuple[int, int], Gang] = {}
+    je_maschine = collections.defaultdict(list)
+
+    for a, auftrag in enumerate(auftraege):
+        for g, (maschine, dauer) in enumerate(auftrag):
+            start = modell.NewIntVar(0, horizont, f"start_{a}_{g}")
+            ende = modell.NewIntVar(0, horizont, f"ende_{a}_{g}")
+            intervall = modell.NewIntervalVar(start, dauer, ende, f"iv_{a}_{g}")
+            plaene[a, g] = Gang(start, ende, intervall)
+            je_maschine[maschine].append(intervall)
+
+    for maschine in range(MASCHINEN):
+        modell.AddNoOverlap(je_maschine[maschine])
+    for a, auftrag in enumerate(auftraege):
+        for g in range(len(auftrag) - 1):
+            modell.Add(plaene[a, g + 1].start >= plaene[a, g].ende)
+
+    makespan = modell.NewIntVar(0, horizont, "makespan")
+    modell.AddMaxEquality(
+        makespan, [plaene[a, len(auftrag) - 1].ende
+                   for a, auftrag in enumerate(auftraege)])
+    modell.Minimize(makespan)
+
+    loeser = cp_model.CpSolver()
+    loeser.parameters.num_workers = arbeiter
+    loeser.parameters.random_seed = SOLVER_SEED
+    loeser.parameters.max_time_in_seconds = ZEITLIMIT
+
+    beginn = time.perf_counter()
+    status = loeser.Solve(modell)
+    dauer = time.perf_counter() - beginn
+
+    if status not in (cp_model.OPTIMAL, cp_model.FEASIBLE):
+        return loeser.StatusName(status), None, dauer, None
+    plan = tuple(loeser.Value(plaene[a, g].start)
+                 for a, auftrag in enumerate(auftraege)
+                 for g in range(len(auftrag)))
+    return loeser.StatusName(status), int(loeser.ObjectiveValue()), dauer, plan
+
+
+if __name__ == "__main__":
+    auftraege = baue_instanz()
+    gaenge = sum(len(a) for a in auftraege)
+
+    print("=" * 78)
+    print("  WAS MEHRERE ARBEITER WIRKLICH BRINGEN")
+    print("=" * 78)
+    print(f"Job-Shop: {AUFTRAEGE} Auftraege, {MASCHINEN} Maschinen, "
+          f"{gaenge} Arbeitsgaenge.")
+    print(f"random_seed = {SOLVER_SEED} in JEDEM Lauf, "
+          f"{WIEDERHOLUNGEN} Wiederholungen je Arbeiterzahl.\n")
+
+    # Jede Konfiguration mehrfach - ein einzelner Zeitwert sagt nichts.
+    ergebnisse: dict[int, list[tuple]] = {}
+    for arbeiter in ARBEITERZAHLEN:
+        ergebnisse[arbeiter] = [loese(auftraege, arbeiter)
+                                for _ in range(WIEDERHOLUNGEN)]
+
+    print("=" * 78)
+    print("  (1) Laufzeit: was die Arbeiter bringen")
+    print("=" * 78)
+    print(f"{'Arbeiter':>9} {'Status':>9} {'Makespan':>9} "
+          f"{'schnellste':>11} {'langsamste':>11} {'Beschleunigung':>15}")
+    print("-" * 78)
+    basis_zeit = min(d for _, _, d, _ in ergebnisse[1])
+    for arbeiter in ARBEITERZAHLEN:
+        laeufe = ergebnisse[arbeiter]
+        zeiten = [d for _, _, d, _ in laeufe]
+        ziele = {o for _, o, _, _ in laeufe}
+        status = {s for s, _, _, _ in laeufe}
+        print(f"{arbeiter:>9} {'/'.join(sorted(status)):>9} "
+              f"{'/'.join(str(z) for z in sorted(ziele)):>9} "
+              f"{min(zeiten):>10.2f}s {max(zeiten):>10.2f}s "
+              f"{basis_zeit / min(zeiten):>14.1f}x")
+
+    beste = min(ARBEITERZAHLEN, key=lambda w: min(d for _, _, d, _ in ergebnisse[w]))
+    faktor = basis_zeit / min(d for _, _, d, _ in ergebnisse[beste])
+    print(f"\n  Am schnellsten sind {beste} Arbeiter: Faktor {faktor:.1f} gegenueber")
+    print(f"  einem einzigen - also MEHR, als {beste} Kerne hergeben sollten.")
+    print(f"  Das ist kein Messfehler. CP-SAT laesst nicht {beste}-mal dieselbe Suche")
+    print("  laufen, sondern verschiedene Strategien nebeneinander, die einander")
+    print("  ihre Schranken zurufen. Der zweite Arbeiter ist deshalb nicht der")
+    print("  'zweite Kern', sondern ein anderes Verfahren.")
+    letzte = ARBEITERZAHLEN[-1]
+    if beste != letzte:
+        zeit_letzte = min(d for _, _, d, _ in ergebnisse[letzte])
+        print(f"\n  Und mehr ist nicht immer besser: {letzte} Arbeiter brauchen "
+              f"{zeit_letzte:.2f}s")
+        print(f"  gegenueber {min(d for _, _, d, _ in ergebnisse[beste]):.2f}s bei "
+              f"{beste}. Ab einer gewissen Zahl kosten Abstimmung")
+        print("  und Speicherbandbreite mehr, als ein weiterer Suchstrang einbringt.")
+
+    print("\n" + "=" * 78)
+    print("  (2) Reproduzierbarkeit: derselbe Seed, derselbe Plan?")
+    print("=" * 78)
+    print(f"{'Arbeiter':>9} {'Laeufe':>7} {'verschiedene Plaene':>21} "
+          f"{'Makespan':>10}")
+    print("-" * 78)
+    for arbeiter in ARBEITERZAHLEN:
+        plaene = {p for _, _, _, p in ergebnisse[arbeiter] if p is not None}
+        ziele = {o for _, o, _, _ in ergebnisse[arbeiter]}
+        print(f"{arbeiter:>9} {WIEDERHOLUNGEN:>7} {len(plaene):>21} "
+              f"{'/'.join(str(z) for z in sorted(ziele)):>10}")
+
+    einer = len({p for _, _, _, p in ergebnisse[1]})
+    # Ab welcher Arbeiterzahl bricht die Reproduzierbarkeit? Das ist die
+    # eigentliche Zahl - nicht, was acht Arbeiter anrichten.
+    ab = next((w for w in ARBEITERZAHLEN
+               if len({p for _, _, _, p in ergebnisse[w]}) > 1), None)
+    print(f"\n  Mit einem Arbeiter: {einer} Plan aus {WIEDERHOLUNGEN} Laeufen.")
+    if ab is not None:
+        viele = len({p for _, _, _, p in ergebnisse[ab]})
+        print(f"  Schon mit {ab} Arbeitern: {viele} verschiedene Plaene aus "
+              f"{WIEDERHOLUNGEN} Laeufen -")
+        print("  bei identischem random_seed und identischem Zielwert.")
+        print(f"  Es braucht also keine acht Arbeiter, um die Reproduzierbarkeit")
+        print(f"  zu verlieren. {ab} genuegen.")
+    print("\n  Der Seed allein macht einen Lauf also NICHT reproduzierbar. Er legt")
+    print("  fest, wie ein einzelner Suchstrang wuerfelt - nicht, welcher von")
+    print("  mehreren zuerst fertig wird. Das entscheidet die Uhr.")
+
+    print("\n" + "=" * 78)
+    print("  (3) Was daraus fuer Tests folgt")
+    print("=" * 78)
+    print("  Ein Test der Form  assert plan == erwarteter_plan  besteht mal und")
+    print("  scheitert mal, ohne dass sich am Code etwas geaendert haette.")
+    print("  Zu pruefen sind stattdessen:")
+    print("    * der ZIELWERT (hier in allen Laeufen gleich),")
+    print("    * die Einhaltung aller Regeln (Abnahmepruefung, Kapitel Praxisfallen),")
+    print("    * und der Status - nicht die Gestalt der Loesung.")
+    print("\n  Wer doch einen bestimmten Plan braucht - fuer eine abgedruckte")
+    print("  Ausgabe, fuer einen Regressionstest -, setzt num_workers = 1.")
+    print(f"  Das kostet hier den Faktor {faktor:.1f} an Laufzeit und ist genau")
+    print("  deshalb eine Entscheidung fuer den Test, nicht fuer den Betrieb.")
+    print("=" * 78)
diff --git a/Operations_Research_mit_Python_Version_04_Programme/README.md b/Operations_Research_mit_Python_Version_04_Programme/README.md
index a47a71c..670ac7c 100644
--- a/Operations_Research_mit_Python_Version_04_Programme/README.md
+++ b/Operations_Research_mit_Python_Version_04_Programme/README.md
@@ -1,6 +1,6 @@
 # Beispielprogramme zu „Optimierte Entscheidungsfindung mit Python" (Version 04)
 
-Diese 74 Dateien sind automatisch aus den Kapiteldateien in
+Diese 76 Dateien sind automatisch aus den Kapiteldateien in
 `../Operations_Research_mit_Python_Version_04/` extrahiert — jede Datei entspricht
 genau einem im Buch vollständig abgedruckten Programm. Sie sind hier zusätzlich als
 eigenständige, direkt ausführbare `.py`-Dateien verfügbar, damit man sie ohne
@@ -15,7 +15,7 @@ python3 Operations_Research_mit_Python_Version_04/extract_programme_04.py
 ```
 
 Das Verzeichnis „Verzeichnis der Beispielprogramme" im Vorwort des Buchs
-(`00_Vorwort_und_Lesehilfe.md`) listet dieselben 74 Programme mit Kurzbeschreibung.
+(`00_Vorwort_und_Lesehilfe.md`) listet dieselben 76 Programme mit Kurzbeschreibung.
 
 Auch dieses README ist selbst generiert: `extract_programme.py` erzeugt es bei jedem
 Lauf aus der Vorlage `README_Programme.md` im Quellverzeichnis und setzt die
diff --git a/Operations_Research_mit_Python_Version_04_Programme/Solverwechsel_CPSAT_HiGHS.py b/Operations_Research_mit_Python_Version_04_Programme/Solverwechsel_CPSAT_HiGHS.py
index 0738ddf..7a294ae 100644
--- a/Operations_Research_mit_Python_Version_04_Programme/Solverwechsel_CPSAT_HiGHS.py
+++ b/Operations_Research_mit_Python_Version_04_Programme/Solverwechsel_CPSAT_HiGHS.py
@@ -36,9 +36,9 @@ Benoetigt: numpy, pydantic, ortools, highspy (jeweils im eigenen Prozess)
 
 from __future__ import annotations
 
-import subprocess
-import sys
+import multiprocessing
 import time
+from concurrent.futures import ProcessPoolExecutor
 
 import numpy as np
 from pydantic import BaseModel, Field, model_validator
@@ -241,25 +241,29 @@ def geoeffnete_lager(problem: Standortproblem, loesung: Loesung) -> list[str]:
             if any(loesung.werte[problem.schluessel(i, j)] > 0.5 for j in range(m))]
 
 
-def loese_in_eigenem_prozess(name: str) -> Loesung:
-    """Startet dieses Programm noch einmal - mit genau einem Solverimport."""
-    ergebnis = subprocess.run([sys.executable, __file__, name],
-                              capture_output=True, text=True, timeout=300)
-    if ergebnis.returncode != 0:
-        raise RuntimeError(ergebnis.stderr.strip().splitlines()[-1])
-    # Das DTO als JSON - genau dafuer ist ein Datenobjekt ohne Solverbezug gut.
-    return Loesung.model_validate_json(ergebnis.stdout.strip().splitlines()[-1])
+def loese_in_eigenem_prozess(name: str, problem: Standortproblem) -> Loesung:
+    """Laesst genau einen Modellbauer in einem frischen Prozess rechnen.
+
+    'spawn' statt des Linux-Standards 'fork': Der Kindprozess startet mit
+    einem leeren Interpreter und importiert nur den Solver, den SEIN
+    Modellbauer braucht. max_tasks_per_child=1 sorgt dafuer, dass der Pool
+    seinen Arbeiter nicht wiederverwendet - sonst saessen beim zweiten Aufruf
+    wieder beide Bibliotheken im selben Prozess.
+
+    Hin und zurueck wandert das Domaenenmodell bzw. das Loesungs-DTO. Beide
+    kennen keinen Solver, sind also serialisierbar - genau dafuer sind sie da.
+    """
+    with ProcessPoolExecutor(
+            max_workers=1,
+            mp_context=multiprocessing.get_context("spawn"),
+            max_tasks_per_child=1) as pool:
+        return pool.submit(MODELLBAUER[name], problem).result(timeout=300)
 
 
 if __name__ == "__main__":
     problem = beispielproblem()
 
-    # --- Kindprozess: rechnen und das DTO als JSON ausgeben ---------------
-    if len(sys.argv) > 1:
-        print(MODELLBAUER[sys.argv[1]](problem).model_dump_json())
-        sys.exit(0)
-
-    # --- Hauptprozess: beide Solver anstossen und vergleichen -------------
+    # --- Beide Solver anstossen und vergleichen ---------------------------
     print("=" * 82)
     print("  DERSELBE FALL, ZWEI SOLVER - UND EIN AUSWERTUNGSCODE")
     print("=" * 82)
@@ -271,7 +275,7 @@ if __name__ == "__main__":
     loesungen: dict[str, Loesung] = {}
     for name, beschriftung in [("cpsat", "OR-Tools CP-SAT"),
                                ("highs", "HiGHS (highspy)")]:
-        loesung = loesungen[name] = loese_in_eigenem_prozess(name)
+        loesung = loesungen[name] = loese_in_eigenem_prozess(name, problem)
         beanstandungen = pruefe_zuordnung(problem, loesung)
 
         print(f"{beschriftung}")
diff --git a/Operations_Research_mit_Python_Version_04_Programme/Warmstart_Effekt.py b/Operations_Research_mit_Python_Version_04_Programme/Warmstart_Effekt.py
index ca1d586..6c08303 100644
--- a/Operations_Research_mit_Python_Version_04_Programme/Warmstart_Effekt.py
+++ b/Operations_Research_mit_Python_Version_04_Programme/Warmstart_Effekt.py
@@ -83,7 +83,8 @@ def loese(dauer: np.ndarray, n_maschinen: int, zeitlimit: float,
 
     loeser = cp_model.CpSolver()
     loeser.parameters.max_time_in_seconds = zeitlimit
-    # Ein Arbeiter und fester Startwert, damit die Messung reproduzierbar ist.
+    # Ein Arbeiter und fester Startwert, damit die Messung reproduzierbar ist -
+    # der Seed allein genuegt dafuer NICHT (Kapitel Constraint Programming).
     # Im Produktivbetrieb laesst man beides auf den Standardwerten.
     loeser.parameters.num_workers = 1
     loeser.parameters.random_seed = 1
diff --git a/PROGRESS.md b/PROGRESS.md
index 2699eee..81fb452 100644
--- a/PROGRESS.md
+++ b/PROGRESS.md
@@ -74,20 +74,20 @@ sie unerwartet ab, ist etwas kaputtgegangen.
 
 | Kennzahl | Version 03 | Version 04 (heute) |
 | --- | --- | --- |
-| Kapiteldateien | 22 | **31** |
+| Kapiteldateien | 22 | **36** (31 + 5 Teil-Synthesen) |
 | Kapitel | 15 | **23** |
 | Anhänge | 4 | **5** |
-| Zeilen im Gesamtdokument | 11 082 | **27 400** |
-| Größe des Gesamtdokuments | 606 KB | **1 536 KB** |
-| Hauptüberschriften | 131 | **289** |
-| registrierte Abschnitte | 122 | **293** |
-| aufgelöste Querverweise | 314 | **712** (0 unaufgelöst) |
-| Indexmarken | 295 | **327** |
-| Beispielprogramme | 41 | **74** (alle lauffähig) |
-| PDF-Seiten | — | **725** |
+| Zeilen im Gesamtdokument | 11 082 | **28 565** |
+| Größe des Gesamtdokuments | 606 KB | **1 622 KB** |
+| Hauptüberschriften | 131 | **302** |
+| registrierte Abschnitte | 122 | **296** |
+| aufgelöste Querverweise | 314 | **825** (0 unaufgelöst) |
+| Indexmarken | 295 | **328** |
+| Beispielprogramme | 41 | **76** (alle lauffähig) |
+| PDF-Seiten | — | **760** |
 | Notebooks | — | **25** |
 | Plotly-Figuren | — | **4** |
-| Diagramme (SVG) | 26 | **32**, davon **18** mit Generatorskript (15 Skripte) |
+| Diagramme (SVG) | 26 | **33**, davon **19** mit Generatorskript (16 Skripte) |
 
 **Gegenprobe:** `build_version_03.py --check` läuft unverändert durch — Version 03 ist von
 allen Änderungen unberührt.
@@ -1327,11 +1327,13 @@ pytest-Tests grün, Version 03 unberührt.
 
 ## 7. Was als Nächstes ansteht
 
-### Der konkret nächste Handgriff
+### Der Stand
 
-**Alle sechs Phasen sind abgeschlossen. Seit dem 08.09.2026 ist `Version_04/` ein eigenes
-Git-Repository**, und Phase 6 (Umsetzung von `Verbesserungen_02/_03`) hat begonnen.
-23 Kapitel, 5 Anhänge, 74 lauffähige Programme, Website mit vier interaktiven Figuren.
+**Alle Phasen sind abgeschlossen** — die sechs des Umbaus, dazu Phase 6 bis 8 aus
+`Verbesserungen_02.md`/`_03.md`. `Version_04/` ist seit dem 08.09.2026 ein eigenes
+Git-Repository. 23 Kapitel, 5 Anhänge, 5 Teil-Synthesen, **76** lauffähige Programme,
+141 Aufgaben mit 141 Lösungen, 33 Diagramme, PDF mit 760 Seiten, Website mit vier
+interaktiven Figuren.
 
 **Zum eigenen Repository — eine Korrektur der früheren Angabe hier:** `git subtree split -P
 Version_04` hätte die Historie **nicht** mitgenommen. Der Pfad `Version_04/` existiert erst
@@ -1341,18 +1343,50 @@ Teilhistorie, die vollständig aussieht und es nicht ist. Volle Historie ginge n
 übergeordnete Repository bleibt das Archiv der 71 Commits und trägt `Version_04/` in seiner
 `.gitignore`.
 
-Offen ist weiterhin, was von außen kommt:
+### Was von außen kommen muss
 
-* **Veröffentlichen.** `Version_04/OR_HTML_04/` ist selbstgenügsam und direkt auf einen
-  Webserver kopierbar.
-* **Remote-Repository anlegen.** Danach **`COLAB_BASIS_URL`** in `build_version_04.py` auf
-  Kontoname und Repository-Name setzen — die 25 Colab-Badges hängen daran, und ein falscher
-  Wert fällt erst beim Klicken auf.
+1. **Remote-Repository anlegen und pushen.**
+2. **Danach `COLAB_BASIS_URL`** in `build_version_04.py` (Zeile 88) auf Kontoname und
+   Repository-Namen setzen. Der Wert dort ist ein **Platzhalter**
+   (`dschlueter/or-mit-python`); die 25 Colab-Badges hängen daran, und ein falscher Wert
+   fällt erst beim Klicken auf. Danach `--html` neu bauen.
+3. **Veröffentlichen.** `OR_HTML_04/` ist selbstgenügsam und direkt auf einen Webserver
+   kopierbar.
 
-Was einer späteren Sitzung als Erstes auffallen wird und **kein Fehler** ist:
+### Bewusst zurückgestellt (aus `Verbesserungen_02/_03`)
 
-* **14 der 32 Diagramme haben keinen Generator.** Dokumentierte Entscheidung — Kästen,
+* **Streamlit-Apps** (V03/1, 2, 5) — Entscheidung des Autors. Sie wären eine neue
+  Artefaktklasse: nicht über die Programmsuite prüfbar, ohne abgedruckte Ausgabe (Regel 4).
+  Der „Was-wäre-wenn"-Gedanke daraus ist in {ref:sec:praxisfallen-attribution} ohne UI
+  eingelöst.
+* **Zielgruppen-Callouts in allen Kapiteln** (V02/5) — die Lernpfade und die One-Pager aus
+  7.1 leisten dasselbe gezielter, ohne Eingriff in jeden Abschnitt.
+* **`joblib`/`ray`** (V02/2) — `num_workers` und `ProcessPoolExecutor` decken den Bedarf;
+  ein Cluster-Framework wäre eine Abhängigkeit ohne Beispiel, das sie braucht.
+* **Folium-Karten** (V03/3) — **blockiert durch eine offene Entscheidung**: Die VRP-Instanz
+  ist ein synthetisches 100 × 100-km-Raster ohne Geokoordinaten. Eine echte Karte verlangt
+  entweder eine neue Instanz (und damit neue abgedruckte Zahlen) oder eine willkürliche
+  Verankerung an einem realen Ort.
+* **Executive-PDF-Report** (V03/6) — ohne Streamlit-Apps fehlt der Ort, an dem er entstünde.
+
+### Offen, rein redaktionell
+
+**53 der 141 Lösungstitel weichen vom Aufgabentitel ab** — durchweg Kürzungen
+(„Zweistufiges Modell rechnen" → „Zweistufig rechnen"), alle in den 15 Abschnitten aus
+Version 03; die acht in Phase 3 ergänzten stimmen vollständig. Seit 6.1a trägt jede Lösung
+wieder die richtige Nummer, die Navigation ist also intakt. Ein Angleichen wäre Kosmetik,
+kein Fehler — aber es würde den Anhang lesbarer machen.
+
+### Was einer späteren Sitzung auffällt und **kein** Fehler ist
+
+* **14 der 33 Diagramme haben keinen Generator.** Dokumentierte Entscheidung — Kästen,
   Pfeile, beschriftete Formeln, generische Funktionsverläufe. Kriterium in Abschnitt 6c.
+* **`Mutationstest.py` benutzt weiterhin `subprocess`.** Richtig so: Dort läuft pytest auf
+  einer mutierten Kopie, das ist ein externes Werkzeug auf veränderten Dateien und keine
+  Import-Isolation (Abschnitt 8.2).
+* **Die abgedruckte Ausgabe von `Parallele_Suche.py` ist absichtlich nicht byteidentisch
+  reproduzierbar.** Die Zahl der verschiedenen Pläne schwankt — und genau das ist die
+  Aussage des Abschnitts.
 * **Version 03 ist eingefroren** und liegt in `../Version_03/`. Ihre READMEs nennen als
   Arbeitsverzeichnis noch `OR_mit_Python`, und ihr generiertes Gesamtdokument liegt minimal
   hinter den Quellen zurück. Beides bleibt bewusst stehen.
@@ -1450,23 +1484,430 @@ Fall mit gedrosselter Biomasse, in dem das **szenariobasierte** Modell `infeasib
 (7,50 % der Szenarien deckt selbst der Vollausbau nicht), das analytische aber `optimal`
 liefert — und dann 87,39 % hält.
 
-### ⏳ Offen: die Lösungsnummern in Anhang A — **sechste** harte Nummer
+### ✅ 6.1a Die letzten handgeschriebenen Nummern — **sechster und siebter** Fund
 
-**Gefunden, noch nicht behoben.** Der Lösungsanhang trägt **97** feste Marken der Bauart
-`**9.2 — Ansatz wählen.**`. Sie stammen aus Version 03, wo Unsicherheit Kapitel 9 war. Heute
-ist es Kapitel 12, und die Aufgabe selbst wird korrekt als **„Aufgabe 12.2"** gesetzt.
+**Der sechste Fund: 98 Lösungsmarken in Anhang A.** Marken der Bauart
+`**9.2 — Ansatz wählen.**`, sämtlich aus Version 03, wo Unsicherheit Kapitel 9 war. Heute ist
+es Kapitel 12, und die Aufgabe wird korrekt als „Aufgabe 12.2" gesetzt.
 
-Das ist keine Schönheitsfrage: **„Aufgabe 9.2" existiert heute wirklich** — sie gehört zum
-Kapitel Metaheuristiken („Zuggröße und Temperatur"). Wer die Lösung zu 9.2 sucht, landet
-beim falschen Thema.
+Das war keine Schönheitsfrage: **„Aufgabe 9.2" existiert wirklich** — sie gehört zum Kapitel
+Metaheuristiken („Zuggröße und Temperatur"). Wer die Lösung zu 9.2 nachschlug, landete beim
+falschen Thema. Beide bisherigen Prüfungen liefen vorbei: Vor der Zahl steht kein
+Schlüsselwort, und es ist keine Tabellenzelle.
 
-Beide Prüfungen laufen daran vorbei: Vor der Zahl steht kein Schlüsselwort, und es ist keine
-Tabellenzelle.
+**Zwei Messungen machten die Reparatur billig.** Erstens: In allen 15 nummerierten
+Abschnitten gab es exakt so viele Lösungen wie Aufgaben, lückenlos 1…n — nur der Kapitelteil
+war falsch, die Umstellung also reine Mechanik. Zweitens: Die **acht in Phase 3 ergänzten
+Kapitel machten es längst richtig** (`**Titel.**` ohne Nummer). Der Anhang wurde damit nicht
+auf etwas Neues umgestellt, sondern auf das, was seine neueren Teile schon taten.
 
-**Vorschlag zur Behebung** (eigenes Arbeitspaket, rührt an 97 Stellen plus Build):
-Die Zuordnung ist herleitbar — der Abschnitt `{#sec:loesungen-<X>}` gehört zum Kapitel
-`{#kap:<X>}`. Der Build kann die Marken also selbst vergeben, so wie er es für Aufgaben
-bereits tut; im Quelltext bliebe nur noch der Titel stehen.
+Der Build vergibt die Marken jetzt selbst. Der Präfix kommt **nicht** aus `# Anhang A:` —
+der Anhang ist *eine* Überschrift, seine Abschnitte gehören aber zu 23 verschiedenen
+Kapiteln. Er kommt aus `{#sec:loesungen-<X>}` → `{#kap:<X>}`; diese Zuordnung gilt geprüft
+für alle 23. Im Quelltext steht `**{loesung} — Titel.**`.
+
+**Der siebte Fund, unterwegs: neun Verweise auf Denkfehler-Nummern.** Sätze wie „siehe
+Denkfehler 8.1" standen in alter Zählung — „8" war in Version 03 das QP/NLP-Kapitel, heute
+ist es Graphen. Eine bloße Umnummerierung hätte sie **stillschweigend woanders hin zeigen
+lassen**; das Ziel wurde deshalb für jeden einzelnen aus dem Zusammenhang bestimmt (die
+Kovarianzmatrix-Stelle in Finanzdaten meint QP/NLP, die „vergessene Dimension" meint Graphen)
+und auf `{ref:sec:<kapitel>-denkfehler}` umgestellt — ein Label, das alle 23 Kapitel haben.
+Einer davon steckte in einem **Programm-Docstring** und bekam nach Regel 12 den Kapitelnamen
+statt eines Verweises.
+
+**Eine Abweichung vom Plan, bewusst:** Der Denkfehler bekommt **gar keine** Nummer. Es gibt
+je Kapitel genau einen, die zweite Stelle wäre immer `.1`, und er steht ohnehin unter einer
+nummerierten Überschrift. Eine Nummer, die nie variiert, holte nur die Fragilität zurück, die
+hier gerade beseitigt wurde. Auch das folgt den acht neuen Kapiteln, die den Denkfehler schon
+vorher nur mit dem Titel des Rätsels ankündigen.
+
+**`--check` bewacht jetzt alle Familien** — `Denkfehler N.M`, `Micro-Quiz N`,
+`**N.M — ` im Anhang — **und zählt zusätzlich ab**, dass jeder Lösungsabschnitt so viele
+`{loesung}`-Marken hat wie sein Kapitel Aufgaben. Das ist die eigentliche Absicherung: Sie
+fängt eine vergessene oder doppelte Lösung, was keine Textsuche leisten kann. Gegengetestet
+mit vier künstlichen Fehlern auf einmal — alle vier gemeldet, nach dem Rückbau null.
+
+**Die Gegenprobe der Umstellung:** Das gebaute Gesamtdokument vorher gesichert, nachher
+verglichen. 168 geänderte Zeilen, restlos einer Familie zuzuordnen — **118** Lösungsmarken,
+15 Anhang-Überschriften, 15 Kapitel-Callouts, 12 Micro-Quiz, 7 Zeilen mit Denkfehler-Verweisen
+(darauf 8 `{ref:}`), 1 Docstring-Zeile. Keine verschobene, verlorene oder inhaltlich
+veränderte Zeile.
+
+Die 118 sind die Probe aufs Exempel: 138 Marken gesamt, davon **20 unverändert** — genau die
+Kapitel 1 bis 3, deren alte Nummern zufällig noch stimmten, weil vor ihnen nichts eingefügt
+worden war.
+
+Ergebnis: **138 Aufgaben, 138 Lösungen, keine ohne Gegenstück.** Micro-Quiz tragen jetzt die
+echten Kapitelnummern (1, 2, 3, 5, 6, 7, 8, 11, 12, 13, 18–22 — die Lücken sind die Kapitel
+ohne Quiz). PDF unverändert 725 Seiten.
+
+**Nicht Teil dieser Runde:** In den 15 alten Abschnitten weichen 69 der 138 Lösungstitel von
+den Aufgabentiteln ab (gekürzt: „Zweistufiges Modell rechnen" → „Zweistufig rechnen"). Da die
+Nummer wieder stimmt, ist sie der Schlüssel; das Angleichen wäre eine rein redaktionelle
+Runde.
+
+### ✅ 6.2 Constraint Attribution und Managementbericht ({ref:kap:praxisfallen})
+
+Neuer Abschnitt {ref:sec:praxisfallen-attribution} plus `Constraint_Attribution.py`
+(75. Programm). Setzt Paket 3 aus `Verbesserungen_02.md` um — den Teil, der noch fehlte.
+
+**Die Lücke, die es schließt.** Zwei Fälle waren abgedeckt: `Erklaerbarkeit.py` beantwortet
+„warum **diese** Zuweisung?", `Konfliktsuche.py` „warum geht es **gar nicht**?". Der
+häufigste Fall der Praxis lag dazwischen und hatte kein Werkzeug: *Das Modell rechnet, der
+Plan ist zulässig — und trotzdem enttäuschend, nur weiß niemand woran es liegt.*
+
+**Dieselbe Fabrik wie die Konfliktsuche, nach der Reparatur.** Dort war die Lackierkapazität
+von 150 Stunden der Kern des Widerspruchs ($2 \cdot 40 + 3 \cdot 30 = 170 > 150$); eine
+zweite Schicht bringt sie auf 210, der Mindestumsatz sinkt auf 10 000 €. Damit kann ein
+Leser dieselben 14 benannten Bedingungen über zwei Kapitel hinweg verfolgen — erst
+„warum nicht?", dann „was kostet was?".
+
+**Drei gemessene Befunde:**
+
+1. **Bindend heißt nicht teuer.** Fünf Bedingungen binden, „Lackierbudget Schicht 2" mit
+   einem Schattenpreis von **0,00 €**. Dieselbe Unterscheidung, die `Erklaerbarkeit.py` an
+   einer einzelnen Zuweisung zeigt — hier im Dualwert eines LP.
+2. **Der Schattenpreis ist eine Momentaufnahme.** Für die Lackiererei verspricht die
+   Hochrechnung $4{,}00 \cdot 30 = 120$ €, gemessen kommen **60 €**; der Preis gilt exakt
+   bis **+15 Stunden**. Die zweite Hälfte der Sonderschicht wäre bezahlt und wirkungslos.
+   Und die Ranglisten drehen sich: nach Schattenpreis führt der Trägervertrag (18 €/Stück),
+   nach tatsächlicher Wirkung die Montage-Sonderschicht (450 €).
+3. **Ein Wunsch kann unmöglich statt teuer sein.** „Mindestens 55 Rahmen" ist `INFEASIBLE`,
+   blockiert von **drei** Bedingungen gemeinsam (jede einzeln entfernt macht ihn möglich) —
+   die Deletion-Filter-Struktur, angewandt auf einen Wunsch statt auf einen Widerspruch. Mit
+   +15 Stunden Lackierkapazität wird er erfüllbar und kostet dann **nichts**: Der Plan wählt
+   diese Menge von sich aus. Der Konflikt bestand nie zwischen Vertrieb und Produktion.
+
+**Der Managementbericht** entsteht in Teil (4) aus genau diesen Zahlen — kein Satz enthält
+eine Zahl, die nicht vorher gerechnet wurde, auch nicht die Rangfolge und nicht die Namen
+der blockierenden Bedingungen. Voraussetzung dafür ist der sprechende Name jeder Bedingung;
+aus `A_ub[7]` wird kein Satz.
+
+**Und die Grenze, die dazugehört** — als ⚠️-Kasten und als Übungsaufgabe: Ein solcher
+Bericht erklärt das **Modell**, nicht die Wirklichkeit. Die Aufgabe lässt den
+Deckungsbeitrag von *Deckel* von 9 € auf 20 € steigen. Gemessen: Der Plan kippt (Rahmen auf
+das Vertragsminimum 40, Deckel auf die Marktgrenze 120), „Kapazität Lackieren" hört auf zu
+binden, „Liefervertrag Rahmen" fängt damit an — **und der Satz „Teuerste Bindung ist
+Liefervertrag Träger" steht wörtlich unverändert im Bericht**, während die Zahl dahinter von
+18 € auf 58 € springt. Ein Bericht, der sich nicht ändert, ist kein Beweis dafür, dass sich
+nichts geändert hat.
+
+**Die neue Zählprobe aus 6.1a hat sich sofort bewährt:** Nach dem Einbau der Übungsaufgabe
+meldete `--check` „6 Loesungen, das Kapitel aber 7 Aufgaben", bevor die Lösung geschrieben
+war. Genau der Fall, für den sie gebaut wurde.
+
+Stand danach: 294 Abschnitte, 725 Querverweise, 328 Indexmarken, **75** Programme,
+139 Aufgaben mit 139 Lösungen, PDF **737** Seiten.
+
+### ✅ 6.3 Parallelität und Determinismus ({ref:kap:cpsat})
+
+Neuer Abschnitt {ref:sec:cpsat-parallele-suche} plus `Parallele_Suche.py` (76. Programm).
+Setzt Paket 2 aus `Verbesserungen_02.md` um.
+
+**Was fehlte, war nicht die Regel, sondern die Messung.** Das Buch setzt an acht Stellen
+`num_workers = 1` mit dem Kommentar „für eine reproduzierbare Ausgabe", und der Spickzettel
+nennt den Grund. Nachgeprüft hatte es nie jemand. Gerechnet wird auf demselben Job-Shop wie
+{ref:sec:cpsat-intervallvariablen-job-shop-scheduling}, nur groß genug, dass die Suche
+arbeitet: 12 Aufträge, 10 Maschinen, 120 Arbeitsgänge.
+
+**Zwei Befunde, beide stärker als die Behauptung:**
+
+1. **Die Beschleunigung ist überlinear.** Acht Arbeiter waren im abgedruckten Lauf nicht
+   achtmal, sondern **12,3-mal** schneller als einer. Kein Messfehler: CP-SAT vervielfacht
+   nicht dieselbe Suche, sondern lässt **verschiedene Strategien** nebeneinander laufen, die
+   einander ihre Schranken mitteilen. Der zweite Arbeiter ist nicht „der zweite Kern",
+   sondern ein anderes Verfahren.
+2. **Der Seed genügt nicht — und zwar schon ab zwei Arbeitern.** Ein Arbeiter: 1 Plan aus
+   4 Läufen. **Zwei** Arbeiter: 3 verschiedene Pläne aus 4 Läufen, bei identischem
+   `random_seed` und identischem Zielwert 183. Es braucht also keine acht Arbeiter, um die
+   Reproduzierbarkeit zu verlieren.
+
+**Die vollständige Antwort kam erst über die Übungsaufgabe**, und sie ist besser als der
+Abschnitt allein: Mit `num_workers = 1`, aber **fünf verschiedenen Seeds**, ergeben sich
+ebenfalls **fünf verschiedene Pläne**. Keiner der beiden Parameter sichert die
+Reproduzierbarkeit allein:
+
+| | Seed fest | Seed variabel |
+| --- | --- | --- |
+| **1 Arbeiter** | reproduzierbar | 5 Pläne aus 5 Läufen |
+| **mehrere Arbeiter** | 3 Pläne aus 4 Läufen | erst recht nicht |
+
+Weiter gemessen für die Aufgabe: Der Gewinn kehrt sich um — auf 24 Kernen Faktor **10,2**
+(8 Arbeiter), **12,3** (16), **9,0** (24). „So viele Arbeiter wie Kerne" ist damit
+widerlegt. Und bei 15 Aufträgen läuft ein Arbeiter ins 60-s-Limit (`FEASIBLE`, Makespan
+200), während acht `OPTIMAL` mit **demselben** Makespan 200 nach 26,4 s melden — der
+Unterschied liegt nicht in der Lösung, sondern im **Beweis**, dass es keine bessere gibt.
+
+**Zur abgedruckten Ausgabe:** Sie trägt die Kennzeichnung „Laufzeiten *und* die Zahl der
+verschiedenen Pläne sind hardwareabhängig" — nach dem Muster, das
+{ref:kap:testing} für `Benchmark_Skalierung.py` schon verwendet. Der Vergleich des
+extrahierten Programms mit dem Abdruck weicht denn auch in genau einer Zelle ab (4 statt 3
+verschiedene Pläne bei 4 Arbeitern); Zielwert und Struktur sind identisch. Hier ist die
+Nichtreproduzierbarkeit der abgedruckten Zahl **die Aussage selbst** — der einzige Fall im
+Buch, in dem das so ist.
+
+Im MILP-Kapitel bekam die entsprechende Stelle in `Warmstart_Effekt.py` einen Verweis;
+dort steht nach Regel 12 der Kapitel**name**, keine Nummer.
+
+Stand danach: 295 Abschnitte, 730 Querverweise, **76** Programme, 140 Aufgaben mit
+140 Lösungen, PDF **744** Seiten.
+
+### ✅ 7.1 Vier Zielgruppen-One-Pager (Vorwort)
+
+Setzt Paket 4 aus `Verbesserungen_03.md` um. Das Titelblatt wirbt seit dem Umbau mit
+Entscheidern, Ingenieuren und Investoren — die Lernpfade im Vorwort waren aber nach
+**Themen** geschnitten, nicht nach **Rollen**. Der neue Abschnitt „Für wen dieses Buch
+geschrieben ist" steht zwischen „Wie dieses Buch aufgebaut ist" und den Lernpfaden und
+schließt genau diese Lücke: vier Einstiege, jeder mit Schmerzpunkt, drei Belegen, dem
+passenden Pfad und der Frage, an der es in dieser Rolle scheitert.
+
+**Die Entscheidung, die den Abschnitt trägt: nur gemessene Zahlen.** Jeder Beleg ist ein
+Ergebnis, das im Buch gerechnet wird — kein Werbeversprechen:
+
+* Entscheider: der Erwartungswert-Plan aus {ref:kap:supplychain} kostet **149 % mehr**
+  (874 870 € statt 351 356 €) und führt in 28 von 40 Szenarien zum Lastabwurf; der Preis
+  eines Prozentpunkts Versorgungssicherheit steigt um das 4,5-fache
+  ({ref:sec:unsicherheit-chance-constraints}).
+* Ingenieure: der Schattenpreis der Lackiererei gilt bis +15 Stunden, eine 30-Stunden-Schicht
+  bringt deshalb 60 € statt 120 € ({ref:sec:praxisfallen-attribution}); das Gesamtbild der
+  Metaheuristiken 2 497 → 2 289 Minuten bei einer Schranke von 1 768.
+* Investoren: VaR 1,86 % gegen CVaR 2,99 %, schlechtester Tag −23,0 % — der am VaR nichts
+  ändert ({ref:kap:cvar}).
+* Studierende: das Modell mit dem **schlechteren** MSE trifft die günstigere Entscheidung
+  ({ref:kap:prognose}).
+
+**Und eine Erwartung wird ausdrücklich enttäuscht.** `Verbesserungen_03` verlangt für die
+Managementseite „typischer ROI und Amortisationszeit". Das Buch hat diese Zahlen nicht, und
+jede hier genannte wäre erfunden. Der One-Pager sagt das offen und nennt stattdessen die
+beiden Werkzeuge, mit denen der Leser **seine eigene** Zahl ausrechnet: den EVPI aus
+{ref:kap:unsicherheit} als Obergrenze für jedes Prognoseprojekt und die Kostenzurechnung
+aus {ref:sec:praxisfallen-attribution}.
+
+Kein neues Programm, keine neue Aufgabe — der Abschnitt bündelt Vorhandenes. Querverweise
+730 → 755, PDF 744 → **746** Seiten.
+
+### ✅ 7.2 Wasserfalldiagramm „was es bringt" ({ref:kap:supplychain})
+
+Setzt den umsetzbaren Teil von Paket 3 aus `Verbesserungen_03.md` um (Vorher-Nachher-
+Wasserfall, Business Impact). Neuer Generator `bilder_04/erzeuge_wirkung.py`; das
+Supply-Chain-Kapitel bekommt damit **sein erstes Diagramm** überhaupt.
+
+**Der Anlass:** Die Tabelle im Kapitel nannte nur die Summen — 874 870 € gegen 351 356 €,
+149 % mehr. Wofür genau, stand nirgends.
+
+**Der Generator rechnet die Instanz erneut**, wie es die Konvention verlangt („so können
+Diagramm und Buchtext nicht auseinanderlaufen"). Die Probe fiel gut aus: Der unabhängige
+Nachbau reproduziert beide abgedruckten Summen **exakt**, dazu 178,7 MWh Fehlmenge und
+28/40 Szenarien mit Abwurf. Kein Auseinanderlaufen — der erste Generator dieser Reihe, der
+nichts findet, und das ist ein Ergebnis für sich.
+
+**Was die Zerlegung zeigt und die Tabelle nicht:**
+
+| | Anfahrt | Brennstoff | Lastabwurf | Gesamt |
+| --- | ---: | ---: | ---: | ---: |
+| zweistufig | 58 000 € | 293 356 € | 0 € | **351 356 €** |
+| Erwartungswert | 58 000 € | 280 631 € | 536 239 € | **874 870 €** |
+
+Die **Anfahrkosten sind identisch** — der Erwartungswert-Plan spart also nicht dort, wo man
+es vermuten würde. Er spart 12 725 € Brennstoff und bezahlt dafür 536 239 € Lastabwurf: das
+**42-fache**. „149 % mehr" ist eine Zahl, über die man streiten kann; „wir sparen 12 725 €
+und riskieren 536 239 €" ist eine, über die man entscheidet.
+
+Die Trennung von Brennstoff- und Abwurfkosten ist der einzige Zusatz gegenüber `bewerte()`
+im Buchprogramm; dort wird sie nicht gebraucht.
+
+**Ein eigener Fehler unterwegs:** Ein `.replace(",", ".")` für deutsche Tausenderpunkte lag
+auf dem **ganzen Titelsatz** und machte aus „Brennstoff, Preis" ein „Brennstoff. Preis".
+Jetzt gibt es `euro()`, das nur auf Zahlen angewandt wird — mit einem Kommentar, der genau
+davor warnt.
+
+SVG byteidentisch über zwei Läufe. Diagramme jetzt **33**, davon **19** mit Generator
+(16 Skripte).
+
+### ✅ 7.3 Glossar „Deutsch — OR" ({ref:kap:modellierung})
+
+Setzt Paket 7 aus `Verbesserungen_03.md` um. Neuer Abschnitt
+{ref:sec:modellierung-glossar}, unmittelbar hinter dem Gesprächsleitfaden: Die zwölf Fragen
+liefern Sätze — hier werden sie übersetzt.
+
+**Die Abgrenzung zu Anhang B war die eigentliche Entwurfsfrage.** Der Musterkatalog hat
+längst eine Spalte „Umgangssprachlich", aber er läuft in die andere Richtung: **Muster →
+Formulierung**. Wer aus einer Besprechung kommt, hat den Satz und sucht den Baustein. Das
+Lexikon ist genau so herum gebaut (21 Einträge, jeweils mit B-Nummer), und Anhang B bekam
+einen Rückverweis. Kein Duplikat, sondern die fehlende Gegenrichtung.
+
+**Der Teil, der den Abschnitt trägt, ist aber nicht die Tabelle**, sondern was danach kommt:
+**fünf Wendungen, bei denen die Übersetzung eine Entscheidung erzwingt** — „möglichst",
+„nicht mehr als drei pro Woche", „im Durchschnitt", „so schnell wie möglich", „fair". Bei
+jeder gibt es zwei bis drei vertretbare Modelle, und die Wahl gehört dem Betrieb, nicht dem
+Modellierer. Das ist die These des Kapitels („Ein Satz ist noch kein Modell"), hier auf die
+Alltagssprache angewandt.
+
+Dazu die **Gegenrichtung OR → Deutsch**: acht Sätze, die sich bewährt haben, wenn ein
+Ergebnis jemandem erklärt werden muss, der das Modell nicht kennt — einschließlich der
+Formulierung für `INFEASIBLE` („Ihre Regeln widersprechen sich", **nicht** „der Computer
+schafft es nicht").
+
+Die neue Übungsaufgabe lässt drei Zielfunktionen für „gleichmäßig ausgelastet" aufstellen;
+die Lösung nennt je einen Fall, in dem die Wahl den Plan sichtbar ändert — und weist darauf
+hin, dass zwei der drei einen Halbtagsmonteur bestrafen.
+
+Mitgezogen: Lernziel, Zusammenfassung, Rückverweis aus Anhang B, Pfad E im Vorwort
+(er führte bisher direkt zum Musterkatalog, jetzt über das Lexikon).
+
+**Damit ist Phase 7 abgeschlossen.** 296 Abschnitte, 766 Querverweise, 141 Aufgaben mit
+141 Lösungen, PDF **749** Seiten.
+
+### ✅ 8.1 Synthese-Seiten je Teil — und ein Fund in der Lesekette
+
+Setzt Paket 5 aus `Verbesserungen_02.md` um (den Teil, der nicht zurückgestellt wurde). Fünf
+neue Dateien `19_/29_/39_/49_/52_Synthese_*.md`, je eine am Ende eines Teils, mit eigener
+Website-Seite (`SONDERSEITEN`, weil sie bewusst **keine** `# Kapitel:`-Überschrift tragen —
+sie sind keine Kapitel, sondern der Rückblick auf einen Teil).
+
+**Der Entwurf musste sich abgrenzen:** Die Teil-**Einleitungen** haben bereits
+Entscheidungsdiagramme („welches Werkzeug passt zu meinem Problem"). Eine zweite
+Entscheidungsmatrix am Teil-Ende wäre eine Dopplung gewesen. Die Synthesen leisten deshalb
+das, was eine Einleitung nicht kann: den **Vergleich über die Kapitel hinweg** (Verfahren
+nebeneinander, mit der Spalte „wo es aufhört"), eine Tabelle **„was dieser Teil gemessen
+hat"** — Behauptung gegen Messung gegen Fundstelle — und drei Fehler, die der Teil
+verhindert. Zitiert wird ausschließlich, was im Buch tatsächlich gerechnet wird.
+
+### Drei Funde beim Einbau
+
+**Erstens: Teil III sagte „die drei Kapitel dieses Teils", hat aber fünf.** Phase 3 hatte
+{ref:kap:mehrziel} und {ref:kap:prognose} hinzugefügt, die Einleitung blieb stehen. Sie
+nennt die drei Abweichungen jetzt weiterhin, schließt die beiden späteren Kapitel aber
+ausdrücklich an.
+
+**Zweitens: `50_Praxis.md` verwies auf die Projektwerkstatt mit „acht eigene Anwendungen"** —
+sie hat elf.
+
+**Drittens, und das ist der eigentliche Fund: Die Lesekette der Quelldateien führte an acht
+Kapiteln vorbei.** Nach Phase 3 zeigte `12_Python_Oekosystem.md` direkt auf
+`20_Lineare_Programmierung.md`, `23_Graphen…` direkt auf `30_QP…`, `32_Dynamische…` direkt
+auf `40_Finanzdaten.md`, `50_Praxis.md` direkt auf die Projektwerkstatt. Wer der Kette
+folgte, übersprang **acht von 23 Kapiteln** — darunter Metaheuristiken, Spaltengenerierung,
+Mehrziel, Predict-then-Optimize, Strukturbrücke, Supply-Chain und das ganze
+Testing-Kapitel. Zehn weitere Dateien hatten gar keine Navigationszeile.
+
+**Zur Reichweite, damit sie nicht überschätzt wird:** Diese Zeilen stehen **nur in den
+Quelldateien**. `entferne_navigation()` streicht sie aus dem Gesamtdokument, und die Website
+baut ihre Vor/Zurück-Knöpfe selbst aus `DATEIEN`. PDF und Website waren also nie betroffen —
+wohl aber jeder, der die Markdown-Dateien im Repository liest, und das wird nach der
+Veröffentlichung der Normalfall sein.
+
+Die Kette ist jetzt über **alle 35 Übergänge** geschlossen, und `--check` bewacht sie: Fehlt
+eine Zeile oder zeigt sie an der in `DATEIEN` folgenden Datei vorbei, ist der Lauf rot.
+Gegengetestet mit beiden Bruchformen.
+
+Stand danach: **36 Dateien** (31 + 5 Synthesen), 296 Abschnitte, **815** Querverweise,
+303 Hauptüberschriften, PDF **758** Seiten.
+
+### ✅ 8.2 Solver-Isolation ohne `subprocess`-Codestrings
+
+Setzt den Isolationsteil von Paket 1 aus `Verbesserungen_02.md` um. Der Plan nannte zwei
+Programme; beim Suchen kam ein **drittes** dazu, das dasselbe Muster verwendete.
+
+**Was ersetzt wurde.** `Ein_System_Vier_Ansaetze.py` und `Benchmark_Skalierung.py` hielten
+ihre vier Solvervarianten als **Zeichenketten** in einem Dictionary und gaben sie an
+`python -c` weiter — bei `Benchmark_Skalierung.py` sogar mit `.format()`-Platzhaltern für
+die Instanzgröße. Aus jeder Variante ist jetzt eine gewöhnliche Funktion mit **lokalem
+Import** geworden. `Solverwechsel_CPSAT_HiGHS.py` rief sich selbst über `sys.argv` erneut
+auf; auch das entfällt.
+
+Ausgeführt wird über einen `ProcessPoolExecutor` mit zwei Einstellungen, die zusammen die
+Garantie ergeben — und beide sind nötig:
+
+* `mp_context="spawn"` — frischer Interpreter statt geerbtem Speicher. Unter Linux ist
+  `fork` der Standard, und damit wäre alles bereits Importierte auch im Kind importiert.
+* `max_tasks_per_child=1` — ein **neuer** Prozess je Aufgabe. Ohne das verwendet der Pool
+  seinen Arbeiter wieder, und beim zweiten Solver ist der Konflikt zurück. Nachgemessen:
+  vier Aufgaben, vier verschiedene PIDs.
+
+Der zweite Punkt hat einen eigenen ⚠️-Kasten bekommen, weil der Fehler leicht zu machen und
+schwer zu finden ist: Der Absturz käme nicht beim ersten Solver, sondern beim zweiten — und
+sähe aus wie ein Problem des zweiten.
+
+**Regel 4, dreifach geprüft.** Alle drei Programme drucken Ausgaben, die im Buch stehen:
+
+* `Ein_System_Vier_Ansaetze.py`: identisch bis auf die Zeitspalte, **einschließlich der
+  Spannweite 2,41 · 10⁻⁸**, auf die sich der Merksatz des Kapitels beruft.
+* `Benchmark_Skalierung.py`: **alle zwölf Zielwerte und alle drei Spannweiten
+  bitgleich**; Zeiten und Speicher haben sich verschoben, beide sind im Abdruck seit jeher
+  als hardwareabhängig gekennzeichnet.
+* `Solverwechsel_CPSAT_HiGHS.py`: Ausgabe ohne Zeiten unverändert.
+
+**Was bewusst `subprocess` bleibt:** `Mutationstest.py`. Dort wird pytest auf einer
+**mutierten Kopie** in einem temporären Verzeichnis gestartet — ein externes Werkzeug auf
+veränderten Dateien, nicht die Isolation eines Imports. Für diesen Fall ist `subprocess`
+richtig.
+
+**Neu im Kapitel Ökosystem:** ein Abschnitt „Wie die Isolation aussieht, wenn sie tragen
+soll" — warum ein Codestring die schlechteste Umsetzung von „eigener Prozess" ist (unsichtbar
+für Editor, Linter und Testwerkzeug; Tippfehler fallen erst zur Laufzeit auf; übergeben
+lassen sich nur Zeichenketten). Anhang C nennt jetzt ebenfalls `ProcessPoolExecutor` statt
+`subprocess`.
+
+**Ein eigener Fehler, gefunden und abgesichert:** Ich hatte dem neuen `###` ein
+`{#sec:...}`-Label gegeben. `ABSCHNITT_RE` erkennt nur `## ` — das Label wäre nie
+registriert worden, und jeder Verweis darauf ins Leere gelaufen, ohne Warnung. Label
+entfernt, und `--check` meldet diesen Fall jetzt. Gegengetestet.
+
+Stand danach: 818 Querverweise, PDF **760** Seiten, 69 netzfreie Programme fehlerfrei.
+
+### ✅ Achter Fund: die „Übung N.N"-Verweise
+
+Sieben Sätze der Bauart „Übung 8.5 lässt Sie diese Balance untersuchen" — und **sechs davon
+standen in alter Zählung**. „8" war in Version 03 das QP/NLP-Kapitel, heute ist es
+Kapitel 11. Dieselbe Familie wie die Denkfehler-Verweise aus 6.1a, nur mit einem Wort, das
+keine der bestehenden Prüfungen kannte.
+
+Aufgaben haben kein eigenes Label, ein `{ref:}` auf eine einzelne Aufgabe ist also nicht
+möglich. Verwiesen wird stattdessen auf **Abschnitt plus Aufgabentitel** — und der ist
+stabil: „die Aufgabe *Gültigkeitsbereich des Schattenpreises*
+({ref:sec:lp-uebungsaufgaben})". Jedes Ziel wurde einzeln über die alte Zählung bestimmt
+und am Zusammenhang geprüft.
+
+**Ein Fall war knifflig:** „Übung 6.7 (Wochendienstplan)" meinte die siebte CP-SAT-Aufgabe
+der alten Zählung, also *Eigener Dienstplan* — die heute an achter Stelle steht, weil ich in
+Phase 6.3 selbst eine Aufgabe davor eingefügt habe. Wer nur die Kapitelnummer angepasst
+hätte, wäre bei der falschen Aufgabe gelandet.
+
+`--check` kennt jetzt auch „Übung"/„Uebung". Gegengetestet. Querverweise 818 → 825.
+
+### ✅ 8.3 Dockerfile — gebaut und durchgemessen
+
+Setzt den letzten Teil von Paket 1 aus `Verbesserungen_02.md` um. Zweistufig: Die erste
+Stufe übersetzt die Abhängigkeiten in eine virtuelle Umgebung und braucht dafür einen
+Compiler, die zweite kopiert nur `/opt/venv` — die Bauumgebung landet nicht im Image.
+Installiert werden die Gruppen `finance`, `large-scale`, `api` und `dev` aus
+`pyproject.toml`; `figures` fehlt bewusst, weil es zusätzlich Graphviz verlangt.
+
+**Es wurde nicht behauptet, sondern gebaut.** Ergebnis: **1,31 GB**, und darin
+
+* der `Installationstest.py` mit allen drei Solver-Funktionstests bestanden,
+* die 33 pytest-Tests bestanden,
+* **alle 69 netzfreien Programme fehlerfrei** — einschließlich der drei aus 8.2, deren
+  `spawn`-Isolation im Container ebenso trägt wie außerhalb.
+
+**Zwei Dinge, die der Bau gelehrt hat.** Erstens: `libgomp1` fehlt im
+`python:3.12-slim`-Image und wird von OR-Tools und HiGHS zur Laufzeit gebraucht — ohne es
+scheitert der erste Solveraufruf mit `libgomp.so.1: cannot open shared object file`.
+Zweitens, ein eigener Fehler: Ich hatte `USER kurs` **vor** das `mkdir /buch/output` gesetzt;
+`/buch` gehört root, und der Bau brach in der letzten Zeile ab. Beides steht jetzt als
+Kommentar im Dockerfile.
+
+Das Image führt die Programme aus und **baut das Buch nicht** — pandoc, xelatex und inkscape
+wären zusammen über ein Gigabyte ohne Nutzen für jemanden, der die Beispiele durchrechnen
+will. Ein `.dockerignore` hält Website, PDF und Notebooks aus dem Build-Kontext.
+
+Und der Punkt, der erklärungsbedürftig ist: Das Image enthält `ortools` **und** `highspy`,
+obwohl sie sich nicht gemeinsam importieren lassen. Der Konflikt wird nicht durch Weglassen
+gelöst, sondern zur Laufzeit durch getrennte Prozesse — ein Image mit nur einem von beiden
+könnte die Hälfte der Beispiele nicht ausführen.
+
+**Damit ist Phase 8 abgeschlossen und der Plan abgearbeitet.**
 
 ---
 
diff --git a/README.md b/README.md
index 7fc9beb..d4a0158 100644
--- a/README.md
+++ b/README.md
@@ -14,15 +14,16 @@ daraus ab, und alle Befehle unten werden **hier** ausgeführt.
 
 | Pfad | Rolle |
 | --- | --- |
-| `Operations_Research_mit_Python_Version_04/` | **Quelle**: 31 Kapiteldateien + Build-Skripte |
+| `Operations_Research_mit_Python_Version_04/` | **Quelle**: 36 Kapiteldateien (inkl. 5 Teil-Synthesen) + Build-Skripte |
 | `bilder_04/` | **Quelle**: Diagramme (SVG/PNG) + `erzeuge_*.py`-Generatoren |
 | `Operations_Research_mit_Python_Version_04.md` | generiert: Gesamtdokument (Pandoc-Eingabe) |
-| `Operations_Research_mit_Python_Version_04.pdf` | generiert: PDF, 725 Seiten |
+| `Operations_Research_mit_Python_Version_04.pdf` | generiert: PDF, 760 Seiten |
 | `OR_HTML_04/` | generiert: **Mehrseiten-Website** — dieser Ordner wird veröffentlicht |
-| `Operations_Research_mit_Python_Version_04_Programme/` | generiert: 74 lauffähige Beispielprogramme |
+| `Operations_Research_mit_Python_Version_04_Programme/` | generiert: 76 lauffähige Beispielprogramme |
 | `Notebooks_04/` | generiert: ein Jupyter-Notebook je Kapitel |
 | `PLAN.md` / `PROGRESS.md` | das Ziel des Umbaus und der erreichte Stand |
 | `pyproject.toml` | Abhängigkeiten in Gruppen (`finance`, `large-scale`, `api`, …) |
+| `Dockerfile`, `.dockerignore` | zweistufiges Kurs-Image (führt die Programme aus, baut nicht das Buch) |
 | `pandoc-defaults-*.yaml`, `pandoc/` | Konfiguration des PDF-Baus |
 
 **Nur die als *Quelle* markierten Verzeichnisse werden von Hand bearbeitet.** Alles andere
@@ -84,6 +85,34 @@ mitgebracht hat.
 `bilder_04/erzeuge_architektur_diagramme.py` gebraucht, nicht von den Beispielprogrammen,
 und steht darum nur in `[figures]`.
 
+### Oder im Container
+
+Wer nichts installieren will, baut das Kurs-Image:
+
+```bash
+docker build -t or-mit-python .
+docker run --rm or-mit-python Installationstest.py
+docker run --rm or-mit-python Rucksack.py
+docker run --rm -it or-mit-python                        # Python-Eingabe
+docker run --rm -v "$PWD/ausgabe:/buch/output" or-mit-python Excel_Bruecke.py
+```
+
+Zweistufiger Bau: Die erste Stufe übersetzt die Abhängigkeiten in eine virtuelle Umgebung
+und braucht dafür einen Compiler, die zweite kopiert nur das Ergebnis — die Bauumgebung
+landet nicht im Image. Enthalten sind die Gruppen `finance`, `large-scale`, `api` und `dev`;
+`figures` fehlt bewusst, weil es zusätzlich Graphviz verlangt und nur dem Neuerzeugen der
+Diagramme dient.
+
+**Das Image führt die Programme aus, es baut das Buch nicht.** Für PDF und Website braucht
+es pandoc, xelatex und inkscape — zusammen über ein Gigabyte, ohne Nutzen für jemanden, der
+die Beispiele durchrechnen will.
+
+Zwei Punkte, die nicht offensichtlich sind: Das Image enthält `ortools` **und** `highspy`,
+obwohl sie sich nicht gemeinsam importieren lassen — der Konflikt wird zur Laufzeit durch
+getrennte Prozesse gelöst, nicht durch Weglassen. Und `libgomp1` muss im schlanken
+Basis-Image nachinstalliert werden, sonst scheitert der erste Solveraufruf mit
+`libgomp.so.1: cannot open shared object file`.
+
 **Externe Werkzeuge**, je nachdem, was gebaut werden soll:
 
 | Werkzeug | wofür | ohne es |
diff --git a/bilder_04/erzeuge_wirkung.py b/bilder_04/erzeuge_wirkung.py
new file mode 100644
index 0000000..cbee3b2
--- /dev/null
+++ b/bilder_04/erzeuge_wirkung.py
@@ -0,0 +1,253 @@
+#!/usr/bin/env python3
+
+# erzeuge_wirkung.py
+"""
+Erzeugt das Wasserfalldiagramm zum Kapitel Supply-Chain und Energieeinsatz:
+
+    bilder_04/kap_supplychain_wirkung.svg   statisch, fuer das PDF
+    bilder_04/kap_supplychain_wirkung.png   Rasterfassung
+
+Die Frage, die es beantwortet, ist die des Managements: WOFUER genau kostet
+der Erwartungswert-Plan 149 % mehr? Die Tabelle im Kapitel nennt nur die
+Summen (874.870 EUR gegen 351.356 EUR). Der Wasserfall zerlegt die
+Differenz - und die Zerlegung ist der eigentliche Befund:
+
+  * Die ANFAHRKOSTEN sind in beiden Plaenen gleich (58.000 EUR). Der
+    Erwartungswert-Plan spart also nicht dort, wo man es vermuten wuerde.
+  * Er spart 12.725 EUR Brennstoff, weil er weniger Blockstunden vorhaelt.
+  * Und zahlt dafuer 536.239 EUR Lastabwurf.
+
+Das ist das 42-fache dessen, was er einspart. Genau diese Gegenueberstellung
+laesst sich in eine Vorlage uebernehmen, eine Summendifferenz nicht.
+
+Verfahren und Instanz sind wortgleich zu Kraftwerkseinsatz.py, und gerechnet
+wird hier ERNEUT - so koennen Diagramm und Buchtext nicht auseinanderlaufen.
+Der Nachbau reproduziert die im Kapitel abgedruckten Summen exakt; das ist
+die Probe darauf, dass beide dasselbe Modell meinen. Zusaetzlich trennt er
+Brennstoff- und Abwurfkosten, was bewerte() im Buchprogramm nicht tut, weil
+es dort nicht gebraucht wird.
+
+Aufruf (aus dem Repository-Wurzelverzeichnis):
+    python3 bilder_04/erzeuge_wirkung.py
+
+Benoetigt: numpy, matplotlib, ortools
+"""
+
+from __future__ import annotations
+
+import os
+
+import matplotlib
+matplotlib.use("Agg")
+import matplotlib.pyplot as plt
+import numpy as np
+from ortools.linear_solver import pywraplp
+
+# Reproduzierbare SVG-Ausgabe (siehe erzeuge_titelseite.py)
+plt.rcParams["svg.hashsalt"] = "or-mit-python-v04"
+
+BASIS = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
+BILDER = os.path.join(BASIS, "bilder_04")
+
+INDIGO, CYAN, AMBER, GRUEN = "#4338ca", "#0891b2", "#b45309", "#059669"
+GRAU = "#64748b"
+
+# --- Instanz: wortgleich zu Kraftwerkseinsatz.py ----------------------------
+# (Name, Mindestleistung, Nennleistung, Grenzkosten, Anfahrkosten, Mindestlaufzeit)
+KRAFTWERKE = [
+    ("Kernblock",   200, 600,  22, 40_000, 8),
+    ("Braunkohle",  100, 400,  35, 18_000, 6),
+    ("Steinkohle",   80, 300,  48, 12_000, 4),
+    ("Gas GuD",      50, 250,  72,  6_000, 2),
+    ("Gasturbine",   20, 150, 105,   1_500, 1),
+]
+STUNDEN, SZENARIEN, FLAUTENANTEIL, SAAT = 24, 40, 0.15, 4
+LASTABWURF = 3_000.0          # EUR je nicht gedeckter MWh
+
+_t = np.arange(STUNDEN)
+LAST = 620 + 260 * np.sin((_t - 7) / 24 * 2 * np.pi) + 90 * np.sin((_t - 4) / 12 * 2 * np.pi)
+WIND_ERWARTUNG = np.maximum(0.0, 160 + 130 * np.sin((_t - 14) / 24 * 2 * np.pi))
+
+
+def euro(betrag: float, vorzeichen: bool = False) -> str:
+    """Deutsche Tausenderpunkte. Nur auf ZAHLEN anwenden, nie auf ganze Saetze."""
+    text = f"{betrag:+,.0f}" if vorzeichen else f"{betrag:,.0f}"
+    return text.replace(",", ".") + " €"
+
+
+def windszenarien() -> tuple[np.ndarray, np.ndarray]:
+    rng = np.random.default_rng(SAAT)
+    niveau = rng.lognormal(0, 0.40, (SZENARIEN, 1))
+    wind = np.clip(WIND_ERWARTUNG * niveau
+                   + rng.normal(0, 25, (SZENARIEN, STUNDEN)), 0, 420)
+    flaute = rng.random(SZENARIEN) < FLAUTENANTEIL
+    wind[flaute] *= 0.05
+    return wind, flaute
+
+
+def plane(wind: np.ndarray, gewichte: np.ndarray) -> np.ndarray:
+    """Stufe 1 (An/Aus, szenariouebergreifend) und Stufe 2 (Fahrweise je
+    Szenario) in einem Modell - wie plane() in Kraftwerkseinsatz.py."""
+    n_s, n_b = wind.shape[0], len(KRAFTWERKE)
+    s = pywraplp.Solver.CreateSolver("SCIP")
+    s.SetTimeLimit(300_000)
+    laeuft = [[s.BoolVar(f"l{k}_{t}") for t in range(STUNDEN)] for k in range(n_b)]
+    start = [[s.BoolVar(f"s{k}_{t}") for t in range(STUNDEN)] for k in range(n_b)]
+    p = [[[s.NumVar(0, KRAFTWERKE[k][2], f"p{j}_{k}_{t}") for t in range(STUNDEN)]
+          for k in range(n_b)] for j in range(n_s)]
+    y = [[s.NumVar(0, s.infinity(), f"y{j}_{t}") for t in range(STUNDEN)]
+         for j in range(n_s)]
+
+    for k, (_, pmin, pmax, _, _, mindestlaufzeit) in enumerate(KRAFTWERKE):
+        for t in range(STUNDEN):
+            vorher = laeuft[k][t - 1] if t > 0 else 0
+            s.Add(start[k][t] >= laeuft[k][t] - vorher)
+            for spaeter in range(t, min(STUNDEN, t + mindestlaufzeit)):
+                s.Add(laeuft[k][spaeter] >= start[k][t])
+            for j in range(n_s):
+                s.Add(p[j][k][t] >= pmin * laeuft[k][t])
+                s.Add(p[j][k][t] <= pmax * laeuft[k][t])
+    for j in range(n_s):
+        for t in range(STUNDEN):
+            s.Add(sum(p[j][k][t] for k in range(n_b))
+                  + float(wind[j, t]) + y[j][t] >= LAST[t])
+
+    s.Minimize(
+        sum(KRAFTWERKE[k][4] * start[k][t]
+            for k in range(n_b) for t in range(STUNDEN))
+        + sum(gewichte[j] * sum(KRAFTWERKE[k][3] * p[j][k][t]
+                                for k in range(n_b) for t in range(STUNDEN))
+              for j in range(n_s))
+        + sum(gewichte[j] * LASTABWURF * sum(y[j][t] for t in range(STUNDEN))
+              for j in range(n_s)))
+    s.Solve()
+    return np.array([[laeuft[k][t].solution_value() for t in range(STUNDEN)]
+                     for k in range(n_b)]).round()
+
+
+def zerlege(plan: np.ndarray, wind: np.ndarray) -> dict:
+    """Setzt einen fertigen Plan der Wirklichkeit aus und trennt dabei die
+    Kostenarten - das ist der Zusatz gegenueber bewerte() im Buchprogramm."""
+    n_b = len(KRAFTWERKE)
+    brennstoff, abwurf, fehlmenge = [], [], []
+    for j in range(wind.shape[0]):
+        s = pywraplp.Solver.CreateSolver("GLOP")
+        p = [[s.NumVar(0, KRAFTWERKE[k][2], f"p{k}_{t}") for t in range(STUNDEN)]
+             for k in range(n_b)]
+        y = [s.NumVar(0, s.infinity(), f"y{t}") for t in range(STUNDEN)]
+        for k, (_, pmin, pmax, _, _, _) in enumerate(KRAFTWERKE):
+            for t in range(STUNDEN):
+                s.Add(p[k][t] >= pmin * plan[k, t])
+                s.Add(p[k][t] <= pmax * plan[k, t])
+        for t in range(STUNDEN):
+            s.Add(sum(p[k][t] for k in range(n_b))
+                  + float(wind[j, t]) + y[t] >= LAST[t])
+        s.Minimize(sum(KRAFTWERKE[k][3] * p[k][t]
+                       for k in range(n_b) for t in range(STUNDEN))
+                   + sum(LASTABWURF * y[t] for t in range(STUNDEN)))
+        s.Solve()
+        brennstoff.append(sum(KRAFTWERKE[k][3] * p[k][t].solution_value()
+                              for k in range(n_b) for t in range(STUNDEN)))
+        fehlt = sum(v.solution_value() for v in y)
+        fehlmenge.append(fehlt)
+        abwurf.append(LASTABWURF * fehlt)
+
+    anfahrt = sum(KRAFTWERKE[k][4]
+                  * max(0.0, plan[k, t] - (plan[k, t - 1] if t > 0 else 0.0))
+                  for k in range(n_b) for t in range(STUNDEN))
+    fehlmenge = np.array(fehlmenge)
+    return {"anfahrt": float(anfahrt),
+            "brennstoff": float(np.mean(brennstoff)),
+            "abwurf": float(np.mean(abwurf)),
+            "fehlmenge": float(fehlmenge.mean()),
+            "szenarien_mit_abwurf": int((fehlmenge > 1e-6).sum()),
+            "gesamt": float(anfahrt + np.mean(brennstoff) + np.mean(abwurf))}
+
+
+def zeichne(zwei: dict, erw: dict) -> None:
+    """Wasserfall vom guten zum schlechten Plan: Was wird gespart, was kostet es."""
+    d_anfahrt = erw["anfahrt"] - zwei["anfahrt"]
+    d_brennstoff = erw["brennstoff"] - zwei["brennstoff"]
+    d_abwurf = erw["abwurf"] - zwei["abwurf"]
+
+    stufen = [("Zweistufiger\nPlan", zwei["gesamt"], None),
+              ("Brennstoff", d_brennstoff, "delta"),
+              ("Anfahren", d_anfahrt, "delta"),
+              ("Lastabwurf", d_abwurf, "delta"),
+              ("Erwartungswert-\nPlan", erw["gesamt"], None)]
+
+    figur, achse = plt.subplots(figsize=(10.2, 5.6))
+    unten = 0.0
+    for i, (name, wert, art) in enumerate(stufen):
+        if art is None:
+            achse.bar(i, wert, 0.62, color=INDIGO, zorder=3)
+            achse.text(i, wert + 18_000, euro(wert),
+                       ha="center", va="bottom", fontsize=11, fontweight="bold",
+                       color=INDIGO)
+            unten = wert
+            continue
+        farbe = AMBER if wert > 0 else GRUEN
+        start = unten if wert > 0 else unten + wert
+        achse.bar(i, abs(wert), 0.62, bottom=start, color=farbe, zorder=3)
+        # Nullbalken (hier: Anfahren) sichtbar machen, sonst fehlt die Aussage
+        if abs(wert) < 5_000:
+            achse.plot([i - 0.31, i + 0.31], [start, start], color=GRAU,
+                       linewidth=2.2, zorder=4)
+        achse.text(i, max(start + abs(wert), unten) + 18_000,
+                   euro(wert, vorzeichen=True),
+                   ha="center", va="bottom", fontsize=10.5, color=farbe,
+                   fontweight="bold")
+        unten = unten + wert
+        if i < len(stufen) - 1:
+            achse.plot([i - 0.31, i + 0.69], [unten, unten], color=GRAU,
+                       linewidth=0.9, linestyle=":", zorder=2)
+
+    achse.set_xticks(range(len(stufen)))
+    achse.set_xticklabels([n for n, _, _ in stufen], fontsize=10.5)
+    achse.set_ylabel("Erwartete Tageskosten")
+    achse.set_ylim(0, erw["gesamt"] * 1.18)
+    achse.yaxis.set_major_formatter(
+        plt.FuncFormatter(lambda v, _: f"{v/1000:,.0f}k €".replace(",", ".")))
+    achse.grid(axis="y", linestyle=":", alpha=0.45, zorder=0)
+    for rand in ("top", "right"):
+        achse.spines[rand].set_visible(False)
+
+    verhaeltnis = abs(d_abwurf / d_brennstoff) if d_brennstoff else float("inf")
+    # Zahlen einzeln setzen: Ein .replace(",", ".") auf den ganzen Satz wuerde
+    # auch das Satzkomma treffen.
+    achse.set_title(
+        "Was der Erwartungswert-Plan spart — und was er dafür bezahlt\n"
+        f"Ersparnis {euro(abs(d_brennstoff))} Brennstoff, Preis "
+        f"{euro(d_abwurf)} Lastabwurf: das {verhaeltnis:.0f}-fache",
+        fontsize=12.5, pad=14)
+    achse.text(0.5, -0.155,
+               f"Lastabwurf in {erw['szenarien_mit_abwurf']} von {SZENARIEN} "
+               f"Szenarien statt in {zwei['szenarien_mit_abwurf']}; "
+               f"Anfahrkosten in beiden Plänen gleich.",
+               transform=achse.transAxes, ha="center", fontsize=10, color=GRAU)
+
+    figur.tight_layout()
+    os.makedirs(BILDER, exist_ok=True)
+    for endung in ("svg", "png"):
+        pfad = os.path.join(BILDER, f"kap_supplychain_wirkung.{endung}")
+        figur.savefig(pfad, format=endung, dpi=160,
+                      metadata={"Date": None} if endung == "svg" else None)
+        print(f"geschrieben: {pfad}")
+    plt.close(figur)
+
+
+if __name__ == "__main__":
+    wind, flaute = windszenarien()
+    gleich = np.full(SZENARIEN, 1.0 / SZENARIEN)
+    print(f"{SZENARIEN} Windszenarien, davon {int(flaute.sum())} Dunkelflauten")
+
+    erw = zerlege(plane(WIND_ERWARTUNG.reshape(1, -1), np.array([1.0])), wind)
+    zwei = zerlege(plane(wind, gleich), wind)
+
+    for name, w in (("Erwartungswert", erw), ("zweistufig", zwei)):
+        print(f"  {name:<16} Anfahrt {w['anfahrt']:>9,.0f}  "
+              f"Brennstoff {w['brennstoff']:>9,.0f}  "
+              f"Abwurf {w['abwurf']:>9,.0f}  = {w['gesamt']:>9,.0f}")
+    print(f"  Aufschlag des Erwartungswert-Plans: "
+          f"{erw['gesamt'] / zwei['gesamt'] - 1:+.0%}")
+    zeichne(zwei, erw)
diff --git a/bilder_04/kap_supplychain_wirkung.png b/bilder_04/kap_supplychain_wirkung.png
new file mode 100644
index 0000000..91c255f
Binary files /dev/null and b/bilder_04/kap_supplychain_wirkung.png differ
diff --git a/bilder_04/kap_supplychain_wirkung.svg b/bilder_04/kap_supplychain_wirkung.svg
new file mode 100644
index 0000000..628d95b
--- /dev/null
+++ b/bilder_04/kap_supplychain_wirkung.svg
@@ -0,0 +1,2093 @@
+<?xml version="1.0" encoding="utf-8" standalone="no"?>
+<!DOCTYPE svg PUBLIC "-//W3C//DTD SVG 1.1//EN"
+  "http://www.w3.org/Graphics/SVG/1.1/DTD/svg11.dtd">
+<svg xmlns:xlink="http://www.w3.org/1999/xlink" width="734.4pt" height="403.2pt" viewBox="0 0 734.4 403.2" xmlns="http://www.w3.org/2000/svg" version="1.1">
+ <metadata>
+  <rdf:RDF xmlns:dc="http://purl.org/dc/elements/1.1/" xmlns:cc="http://creativecommons.org/ns#" xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#">
+   <cc:Work>
+    <dc:type rdf:resource="http://purl.org/dc/dcmitype/StillImage"/>
+    <dc:format>image/svg+xml</dc:format>
+    <dc:creator>
+     <cc:Agent>
+      <dc:title>Matplotlib v3.10.8, https://matplotlib.org/</dc:title>
+     </cc:Agent>
+    </dc:creator>
+   </cc:Work>
+  </rdf:RDF>
+ </metadata>
+ <defs>
+  <style type="text/css">*{stroke-linejoin: round; stroke-linecap: butt}</style>
+ </defs>
+ <g id="figure_1">
+  <g id="patch_1">
+   <path d="M 0 403.2 
+L 734.4 403.2 
+L 734.4 0 
+L 0 0 
+z
+" style="fill: #ffffff"/>
+  </g>
+  <g id="axes_1">
+   <g id="patch_2">
+    <path d="M 75.89 342.11808 
+L 723.6 342.11808 
+L 723.6 49.856 
+L 75.89 49.856 
+z
+" style="fill: #ffffff"/>
+   </g>
+   <g id="matplotlib.axis_1">
+    <g id="xtick_1">
+     <g id="line2d_1">
+      <defs>
+       <path id="mf0a04b41f8" d="M 0 0 
+L 0 3.5 
+" style="stroke: #000000; stroke-width: 0.8"/>
+      </defs>
+      <g>
+       <use xlink:href="#mf0a04b41f8" x="144.841419" y="342.11808" style="stroke: #000000; stroke-width: 0.8"/>
+      </g>
+     </g>
+     <g id="text_1">
+      <!-- Zweistufiger -->
+      <g transform="translate(112.114231 357.096439) scale(0.105 -0.105)">
+       <defs>
+        <path id="DejaVuSans-5a" d="M 359 4666 
+L 4025 4666 
+L 4025 4184 
+L 1075 531 
+L 4097 531 
+L 4097 0 
+L 288 0 
+L 288 481 
+L 3238 4134 
+L 359 4134 
+L 359 4666 
+z
+" transform="scale(0.015625)"/>
+        <path id="DejaVuSans-77" d="M 269 3500 
+L 844 3500 
+L 1563 769 
+L 2278 3500 
+L 2956 3500 
+L 3675 769 
+L 4391 3500 
+L 4966 3500 
+L 4050 0 
+L 3372 0 
+L 2619 2869 
+L 1863 0 
+L 1184 0 
+L 269 3500 
+z
+" transform="scale(0.015625)"/>
+        <path id="DejaVuSans-65" d="M 3597 1894 
+L 3597 1613 
+L 953 1613 
+Q 991 1019 1311 708 
+Q 1631 397 2203 397 
+Q 2534 397 2845 478 
+Q 3156 559 3463 722 
+L 3463 178 
+Q 3153 47 2828 -22 
+Q 2503 -91 2169 -91 
+Q 1331 -91 842 396 
+Q 353 884 353 1716 
+Q 353 2575 817 3079 
+Q 1281 3584 2069 3584 
+Q 2775 3584 3186 3129 
+Q 3597 2675 3597 1894 
+z
+M 3022 2063 
+Q 3016 2534 2758 2815 
+Q 2500 3097 2075 3097 
+Q 1594 3097 1305 2825 
+Q 1016 2553 972 2059 
+L 3022 2063 
+z
+" transform="scale(0.015625)"/>
+        <path id="DejaVuSans-69" d="M 603 3500 
+L 1178 3500 
+L 1178 0 
+L 603 0 
+L 603 3500 
+z
+M 603 4863 
+L 1178 4863 
+L 1178 4134 
+L 603 4134 
+L 603 4863 
+z
+" transform="scale(0.015625)"/>
+        <path id="DejaVuSans-73" d="M 2834 3397 
+L 2834 2853 
+Q 2591 2978 2328 3040 
+Q 2066 3103 1784 3103 
+Q 1356 3103 1142 2972 
+Q 928 2841 928 2578 
+Q 928 2378 1081 2264 
+Q 1234 2150 1697 2047 
+L 1894 2003 
+Q 2506 1872 2764 1633 
+Q 3022 1394 3022 966 
+Q 3022 478 2636 193 
+Q 2250 -91 1575 -91 
+Q 1294 -91 989 -36 
+Q 684 19 347 128 
+L 347 722 
+Q 666 556 975 473 
+Q 1284 391 1588 391 
+Q 1994 391 2212 530 
+Q 2431 669 2431 922 
+Q 2431 1156 2273 1281 
+Q 2116 1406 1581 1522 
+L 1381 1569 
+Q 847 1681 609 1914 
+Q 372 2147 372 2553 
+Q 372 3047 722 3315 
+Q 1072 3584 1716 3584 
+Q 2034 3584 2315 3537 
+Q 2597 3491 2834 3397 
+z
+" transform="scale(0.015625)"/>
+        <path id="DejaVuSans-74" d="M 1172 4494 
+L 1172 3500 
+L 2356 3500 
+L 2356 3053 
+L 1172 3053 
+L 1172 1153 
+Q 1172 725 1289 603 
+Q 1406 481 1766 481 
+L 2356 481 
+L 2356 0 
+L 1766 0 
+Q 1100 0 847 248 
+Q 594 497 594 1153 
+L 594 3053 
+L 172 3053 
+L 172 3500 
+L 594 3500 
+L 594 4494 
+L 1172 4494 
+z
+" transform="scale(0.015625)"/>
+        <path id="DejaVuSans-75" d="M 544 1381 
+L 544 3500 
+L 1119 3500 
+L 1119 1403 
+Q 1119 906 1312 657 
+Q 1506 409 1894 409 
+Q 2359 409 2629 706 
+Q 2900 1003 2900 1516 
+L 2900 3500 
+L 3475 3500 
+L 3475 0 
+L 2900 0 
+L 2900 538 
+Q 2691 219 2414 64 
+Q 2138 -91 1772 -91 
+Q 1169 -91 856 284 
+Q 544 659 544 1381 
+z
+M 1991 3584 
+L 1991 3584 
+z
+" transform="scale(0.015625)"/>
+        <path id="DejaVuSans-66" d="M 2375 4863 
+L 2375 4384 
+L 1825 4384 
+Q 1516 4384 1395 4259 
+Q 1275 4134 1275 3809 
+L 1275 3500 
+L 2222 3500 
+L 2222 3053 
+L 1275 3053 
+L 1275 0 
+L 697 0 
+L 697 3053 
+L 147 3053 
+L 147 3500 
+L 697 3500 
+L 697 3744 
+Q 697 4328 969 4595 
+Q 1241 4863 1831 4863 
+L 2375 4863 
+z
+" transform="scale(0.015625)"/>
+        <path id="DejaVuSans-67" d="M 2906 1791 
+Q 2906 2416 2648 2759 
+Q 2391 3103 1925 3103 
+Q 1463 3103 1205 2759 
+Q 947 2416 947 1791 
+Q 947 1169 1205 825 
+Q 1463 481 1925 481 
+Q 2391 481 2648 825 
+Q 2906 1169 2906 1791 
+z
+M 3481 434 
+Q 3481 -459 3084 -895 
+Q 2688 -1331 1869 -1331 
+Q 1566 -1331 1297 -1286 
+Q 1028 -1241 775 -1147 
+L 775 -588 
+Q 1028 -725 1275 -790 
+Q 1522 -856 1778 -856 
+Q 2344 -856 2625 -561 
+Q 2906 -266 2906 331 
+L 2906 616 
+Q 2728 306 2450 153 
+Q 2172 0 1784 0 
+Q 1141 0 747 490 
+Q 353 981 353 1791 
+Q 353 2603 747 3093 
+Q 1141 3584 1784 3584 
+Q 2172 3584 2450 3431 
+Q 2728 3278 2906 2969 
+L 2906 3500 
+L 3481 3500 
+L 3481 434 
+z
+" transform="scale(0.015625)"/>
+        <path id="DejaVuSans-72" d="M 2631 2963 
+Q 2534 3019 2420 3045 
+Q 2306 3072 2169 3072 
+Q 1681 3072 1420 2755 
+Q 1159 2438 1159 1844 
+L 1159 0 
+L 581 0 
+L 581 3500 
+L 1159 3500 
+L 1159 2956 
+Q 1341 3275 1631 3429 
+Q 1922 3584 2338 3584 
+Q 2397 3584 2469 3576 
+Q 2541 3569 2628 3553 
+L 2631 2963 
+z
+" transform="scale(0.015625)"/>
+       </defs>
+       <use xlink:href="#DejaVuSans-5a"/>
+       <use xlink:href="#DejaVuSans-77" transform="translate(68.505859 0)"/>
+       <use xlink:href="#DejaVuSans-65" transform="translate(150.292969 0)"/>
+       <use xlink:href="#DejaVuSans-69" transform="translate(211.816406 0)"/>
+       <use xlink:href="#DejaVuSans-73" transform="translate(239.599609 0)"/>
+       <use xlink:href="#DejaVuSans-74" transform="translate(291.699219 0)"/>
+       <use xlink:href="#DejaVuSans-75" transform="translate(330.908203 0)"/>
+       <use xlink:href="#DejaVuSans-66" transform="translate(394.287109 0)"/>
+       <use xlink:href="#DejaVuSans-69" transform="translate(429.492188 0)"/>
+       <use xlink:href="#DejaVuSans-67" transform="translate(457.275391 0)"/>
+       <use xlink:href="#DejaVuSans-65" transform="translate(520.751953 0)"/>
+       <use xlink:href="#DejaVuSans-72" transform="translate(582.275391 0)"/>
+      </g>
+      <!-- Plan -->
+      <g transform="translate(133.672864 368.854142) scale(0.105 -0.105)">
+       <defs>
+        <path id="DejaVuSans-50" d="M 1259 4147 
+L 1259 2394 
+L 2053 2394 
+Q 2494 2394 2734 2622 
+Q 2975 2850 2975 3272 
+Q 2975 3691 2734 3919 
+Q 2494 4147 2053 4147 
+L 1259 4147 
+z
+M 628 4666 
+L 2053 4666 
+Q 2838 4666 3239 4311 
+Q 3641 3956 3641 3272 
+Q 3641 2581 3239 2228 
+Q 2838 1875 2053 1875 
+L 1259 1875 
+L 1259 0 
+L 628 0 
+L 628 4666 
+z
+" transform="scale(0.015625)"/>
+        <path id="DejaVuSans-6c" d="M 603 4863 
+L 1178 4863 
+L 1178 0 
+L 603 0 
+L 603 4863 
+z
+" transform="scale(0.015625)"/>
+        <path id="DejaVuSans-61" d="M 2194 1759 
+Q 1497 1759 1228 1600 
+Q 959 1441 959 1056 
+Q 959 750 1161 570 
+Q 1363 391 1709 391 
+Q 2188 391 2477 730 
+Q 2766 1069 2766 1631 
+L 2766 1759 
+L 2194 1759 
+z
+M 3341 1997 
+L 3341 0 
+L 2766 0 
+L 2766 531 
+Q 2569 213 2275 61 
+Q 1981 -91 1556 -91 
+Q 1019 -91 701 211 
+Q 384 513 384 1019 
+Q 384 1609 779 1909 
+Q 1175 2209 1959 2209 
+L 2766 2209 
+L 2766 2266 
+Q 2766 2663 2505 2880 
+Q 2244 3097 1772 3097 
+Q 1472 3097 1187 3025 
+Q 903 2953 641 2809 
+L 641 3341 
+Q 956 3463 1253 3523 
+Q 1550 3584 1831 3584 
+Q 2591 3584 2966 3190 
+Q 3341 2797 3341 1997 
+z
+" transform="scale(0.015625)"/>
+        <path id="DejaVuSans-6e" d="M 3513 2113 
+L 3513 0 
+L 2938 0 
+L 2938 2094 
+Q 2938 2591 2744 2837 
+Q 2550 3084 2163 3084 
+Q 1697 3084 1428 2787 
+Q 1159 2491 1159 1978 
+L 1159 0 
+L 581 0 
+L 581 3500 
+L 1159 3500 
+L 1159 2956 
+Q 1366 3272 1645 3428 
+Q 1925 3584 2291 3584 
+Q 2894 3584 3203 3211 
+Q 3513 2838 3513 2113 
+z
+" transform="scale(0.015625)"/>
+       </defs>
+       <use xlink:href="#DejaVuSans-50"/>
+       <use xlink:href="#DejaVuSans-6c" transform="translate(60.302734 0)"/>
+       <use xlink:href="#DejaVuSans-61" transform="translate(88.085938 0)"/>
+       <use xlink:href="#DejaVuSans-6e" transform="translate(149.365234 0)"/>
+      </g>
+     </g>
+    </g>
+    <g id="xtick_2">
+     <g id="line2d_2">
+      <g>
+       <use xlink:href="#mf0a04b41f8" x="272.293209" y="342.11808" style="stroke: #000000; stroke-width: 0.8"/>
+      </g>
+     </g>
+     <g id="text_2">
+      <!-- Brennstoff -->
+      <g transform="translate(245.064577 357.096439) scale(0.105 -0.105)">
+       <defs>
+        <path id="DejaVuSans-42" d="M 1259 2228 
+L 1259 519 
+L 2272 519 
+Q 2781 519 3026 730 
+Q 3272 941 3272 1375 
+Q 3272 1813 3026 2020 
+Q 2781 2228 2272 2228 
+L 1259 2228 
+z
+M 1259 4147 
+L 1259 2741 
+L 2194 2741 
+Q 2656 2741 2882 2914 
+Q 3109 3088 3109 3444 
+Q 3109 3797 2882 3972 
+Q 2656 4147 2194 4147 
+L 1259 4147 
+z
+M 628 4666 
+L 2241 4666 
+Q 2963 4666 3353 4366 
+Q 3744 4066 3744 3513 
+Q 3744 3084 3544 2831 
+Q 3344 2578 2956 2516 
+Q 3422 2416 3680 2098 
+Q 3938 1781 3938 1306 
+Q 3938 681 3513 340 
+Q 3088 0 2303 0 
+L 628 0 
+L 628 4666 
+z
+" transform="scale(0.015625)"/>
+        <path id="DejaVuSans-6f" d="M 1959 3097 
+Q 1497 3097 1228 2736 
+Q 959 2375 959 1747 
+Q 959 1119 1226 758 
+Q 1494 397 1959 397 
+Q 2419 397 2687 759 
+Q 2956 1122 2956 1747 
+Q 2956 2369 2687 2733 
+Q 2419 3097 1959 3097 
+z
+M 1959 3584 
+Q 2709 3584 3137 3096 
+Q 3566 2609 3566 1747 
+Q 3566 888 3137 398 
+Q 2709 -91 1959 -91 
+Q 1206 -91 779 398 
+Q 353 888 353 1747 
+Q 353 2609 779 3096 
+Q 1206 3584 1959 3584 
+z
+" transform="scale(0.015625)"/>
+       </defs>
+       <use xlink:href="#DejaVuSans-42"/>
+       <use xlink:href="#DejaVuSans-72" transform="translate(68.603516 0)"/>
+       <use xlink:href="#DejaVuSans-65" transform="translate(107.466797 0)"/>
+       <use xlink:href="#DejaVuSans-6e" transform="translate(168.990234 0)"/>
+       <use xlink:href="#DejaVuSans-6e" transform="translate(232.369141 0)"/>
+       <use xlink:href="#DejaVuSans-73" transform="translate(295.748047 0)"/>
+       <use xlink:href="#DejaVuSans-74" transform="translate(347.847656 0)"/>
+       <use xlink:href="#DejaVuSans-6f" transform="translate(387.056641 0)"/>
+       <use xlink:href="#DejaVuSans-66" transform="translate(448.238281 0)"/>
+       <use xlink:href="#DejaVuSans-66" transform="translate(483.443359 0)"/>
+      </g>
+     </g>
+    </g>
+    <g id="xtick_3">
+     <g id="line2d_3">
+      <g>
+       <use xlink:href="#mf0a04b41f8" x="399.745" y="342.11808" style="stroke: #000000; stroke-width: 0.8"/>
+      </g>
+     </g>
+     <g id="text_3">
+      <!-- Anfahren -->
+      <g transform="translate(375.836172 357.096439) scale(0.105 -0.105)">
+       <defs>
+        <path id="DejaVuSans-41" d="M 2188 4044 
+L 1331 1722 
+L 3047 1722 
+L 2188 4044 
+z
+M 1831 4666 
+L 2547 4666 
+L 4325 0 
+L 3669 0 
+L 3244 1197 
+L 1141 1197 
+L 716 0 
+L 50 0 
+L 1831 4666 
+z
+" transform="scale(0.015625)"/>
+        <path id="DejaVuSans-68" d="M 3513 2113 
+L 3513 0 
+L 2938 0 
+L 2938 2094 
+Q 2938 2591 2744 2837 
+Q 2550 3084 2163 3084 
+Q 1697 3084 1428 2787 
+Q 1159 2491 1159 1978 
+L 1159 0 
+L 581 0 
+L 581 4863 
+L 1159 4863 
+L 1159 2956 
+Q 1366 3272 1645 3428 
+Q 1925 3584 2291 3584 
+Q 2894 3584 3203 3211 
+Q 3513 2838 3513 2113 
+z
+" transform="scale(0.015625)"/>
+       </defs>
+       <use xlink:href="#DejaVuSans-41"/>
+       <use xlink:href="#DejaVuSans-6e" transform="translate(68.408203 0)"/>
+       <use xlink:href="#DejaVuSans-66" transform="translate(131.787109 0)"/>
+       <use xlink:href="#DejaVuSans-61" transform="translate(166.992188 0)"/>
+       <use xlink:href="#DejaVuSans-68" transform="translate(228.271484 0)"/>
+       <use xlink:href="#DejaVuSans-72" transform="translate(291.650391 0)"/>
+       <use xlink:href="#DejaVuSans-65" transform="translate(330.513672 0)"/>
+       <use xlink:href="#DejaVuSans-6e" transform="translate(392.037109 0)"/>
+      </g>
+     </g>
+    </g>
+    <g id="xtick_4">
+     <g id="line2d_4">
+      <g>
+       <use xlink:href="#mf0a04b41f8" x="527.196791" y="342.11808" style="stroke: #000000; stroke-width: 0.8"/>
+      </g>
+     </g>
+     <g id="text_4">
+      <!-- Lastabwurf -->
+      <g transform="translate(498.0839 357.096439) scale(0.105 -0.105)">
+       <defs>
+        <path id="DejaVuSans-4c" d="M 628 4666 
+L 1259 4666 
+L 1259 531 
+L 3531 531 
+L 3531 0 
+L 628 0 
+L 628 4666 
+z
+" transform="scale(0.015625)"/>
+        <path id="DejaVuSans-62" d="M 3116 1747 
+Q 3116 2381 2855 2742 
+Q 2594 3103 2138 3103 
+Q 1681 3103 1420 2742 
+Q 1159 2381 1159 1747 
+Q 1159 1113 1420 752 
+Q 1681 391 2138 391 
+Q 2594 391 2855 752 
+Q 3116 1113 3116 1747 
+z
+M 1159 2969 
+Q 1341 3281 1617 3432 
+Q 1894 3584 2278 3584 
+Q 2916 3584 3314 3078 
+Q 3713 2572 3713 1747 
+Q 3713 922 3314 415 
+Q 2916 -91 2278 -91 
+Q 1894 -91 1617 61 
+Q 1341 213 1159 525 
+L 1159 0 
+L 581 0 
+L 581 4863 
+L 1159 4863 
+L 1159 2969 
+z
+" transform="scale(0.015625)"/>
+       </defs>
+       <use xlink:href="#DejaVuSans-4c"/>
+       <use xlink:href="#DejaVuSans-61" transform="translate(55.712891 0)"/>
+       <use xlink:href="#DejaVuSans-73" transform="translate(116.992188 0)"/>
+       <use xlink:href="#DejaVuSans-74" transform="translate(169.091797 0)"/>
+       <use xlink:href="#DejaVuSans-61" transform="translate(208.300781 0)"/>
+       <use xlink:href="#DejaVuSans-62" transform="translate(269.580078 0)"/>
+       <use xlink:href="#DejaVuSans-77" transform="translate(333.056641 0)"/>
+       <use xlink:href="#DejaVuSans-75" transform="translate(414.84375 0)"/>
+       <use xlink:href="#DejaVuSans-72" transform="translate(478.222656 0)"/>
+       <use xlink:href="#DejaVuSans-66" transform="translate(519.335938 0)"/>
+      </g>
+     </g>
+    </g>
+    <g id="xtick_5">
+     <g id="line2d_5">
+      <g>
+       <use xlink:href="#mf0a04b41f8" x="654.648581" y="342.11808" style="stroke: #000000; stroke-width: 0.8"/>
+      </g>
+     </g>
+     <g id="text_5">
+      <!-- Erwartungswert- -->
+      <g transform="translate(611.089167 357.096439) scale(0.105 -0.105)">
+       <defs>
+        <path id="DejaVuSans-45" d="M 628 4666 
+L 3578 4666 
+L 3578 4134 
+L 1259 4134 
+L 1259 2753 
+L 3481 2753 
+L 3481 2222 
+L 1259 2222 
+L 1259 531 
+L 3634 531 
+L 3634 0 
+L 628 0 
+L 628 4666 
+z
+" transform="scale(0.015625)"/>
+        <path id="DejaVuSans-2d" d="M 313 2009 
+L 1997 2009 
+L 1997 1497 
+L 313 1497 
+L 313 2009 
+z
+" transform="scale(0.015625)"/>
+       </defs>
+       <use xlink:href="#DejaVuSans-45"/>
+       <use xlink:href="#DejaVuSans-72" transform="translate(63.183594 0)"/>
+       <use xlink:href="#DejaVuSans-77" transform="translate(104.296875 0)"/>
+       <use xlink:href="#DejaVuSans-61" transform="translate(186.083984 0)"/>
+       <use xlink:href="#DejaVuSans-72" transform="translate(247.363281 0)"/>
+       <use xlink:href="#DejaVuSans-74" transform="translate(288.476562 0)"/>
+       <use xlink:href="#DejaVuSans-75" transform="translate(327.685547 0)"/>
+       <use xlink:href="#DejaVuSans-6e" transform="translate(391.064453 0)"/>
+       <use xlink:href="#DejaVuSans-67" transform="translate(454.443359 0)"/>
+       <use xlink:href="#DejaVuSans-73" transform="translate(517.919922 0)"/>
+       <use xlink:href="#DejaVuSans-77" transform="translate(570.019531 0)"/>
+       <use xlink:href="#DejaVuSans-65" transform="translate(651.806641 0)"/>
+       <use xlink:href="#DejaVuSans-72" transform="translate(713.330078 0)"/>
+       <use xlink:href="#DejaVuSans-74" transform="translate(754.443359 0)"/>
+       <use xlink:href="#DejaVuSans-2d" transform="translate(793.652344 0)"/>
+      </g>
+      <!-- Plan -->
+      <g transform="translate(643.480027 368.854142) scale(0.105 -0.105)">
+       <use xlink:href="#DejaVuSans-50"/>
+       <use xlink:href="#DejaVuSans-6c" transform="translate(60.302734 0)"/>
+       <use xlink:href="#DejaVuSans-61" transform="translate(88.085938 0)"/>
+       <use xlink:href="#DejaVuSans-6e" transform="translate(149.365234 0)"/>
+      </g>
+     </g>
+    </g>
+   </g>
+   <g id="matplotlib.axis_2">
+    <g id="ytick_1">
+     <g id="line2d_6">
+      <path d="M 75.89 342.11808 
+L 723.6 342.11808 
+" clip-path="url(#p83a3789304)" style="fill: none; stroke-dasharray: 0.8,1.32; stroke-dashoffset: 0; stroke: #b0b0b0; stroke-opacity: 0.45; stroke-width: 0.8"/>
+     </g>
+     <g id="line2d_7">
+      <defs>
+       <path id="mc0b9ff744f" d="M 0 0 
+L -3.5 0 
+" style="stroke: #000000; stroke-width: 0.8"/>
+      </defs>
+      <g>
+       <use xlink:href="#mc0b9ff744f" x="75.89" y="342.11808" style="stroke: #000000; stroke-width: 0.8"/>
+      </g>
+     </g>
+     <g id="text_6">
+      <!-- 0k € -->
+      <g transform="translate(47.19625 345.917299) scale(0.1 -0.1)">
+       <defs>
+        <path id="DejaVuSans-30" d="M 2034 4250 
+Q 1547 4250 1301 3770 
+Q 1056 3291 1056 2328 
+Q 1056 1369 1301 889 
+Q 1547 409 2034 409 
+Q 2525 409 2770 889 
+Q 3016 1369 3016 2328 
+Q 3016 3291 2770 3770 
+Q 2525 4250 2034 4250 
+z
+M 2034 4750 
+Q 2819 4750 3233 4129 
+Q 3647 3509 3647 2328 
+Q 3647 1150 3233 529 
+Q 2819 -91 2034 -91 
+Q 1250 -91 836 529 
+Q 422 1150 422 2328 
+Q 422 3509 836 4129 
+Q 1250 4750 2034 4750 
+z
+" transform="scale(0.015625)"/>
+        <path id="DejaVuSans-6b" d="M 581 4863 
+L 1159 4863 
+L 1159 1991 
+L 2875 3500 
+L 3609 3500 
+L 1753 1863 
+L 3688 0 
+L 2938 0 
+L 1159 1709 
+L 1159 0 
+L 581 0 
+L 581 4863 
+z
+" transform="scale(0.015625)"/>
+        <path id="DejaVuSans-20" transform="scale(0.015625)"/>
+        <path id="DejaVuSans-20ac" d="M 3647 4306 
+L 3647 3641 
+Q 3363 3969 3098 4109 
+Q 2834 4250 2516 4250 
+Q 2025 4250 1709 3937 
+Q 1394 3625 1294 3041 
+L 3097 3041 
+L 2925 2656 
+L 1244 2656 
+Q 1238 2581 1236 2509 
+Q 1234 2438 1234 2328 
+Q 1234 2228 1236 2156 
+Q 1238 2084 1244 2009 
+L 2638 2009 
+L 2463 1625 
+L 1294 1625 
+Q 1394 1041 1709 725 
+Q 2025 409 2516 409 
+Q 2834 409 3098 550 
+Q 3363 691 3647 1019 
+L 3647 359 
+Q 3369 134 3080 21 
+Q 2791 -91 2491 -91 
+Q 1750 -91 1267 362 
+Q 784 816 659 1625 
+L 0 1625 
+L 172 2009 
+L 606 2009 
+Q 606 2081 604 2154 
+Q 603 2228 603 2328 
+Q 603 2438 604 2511 
+Q 606 2584 606 2656 
+L 0 2656 
+L 172 3041 
+L 659 3041 
+Q 784 3844 1268 4297 
+Q 1753 4750 2491 4750 
+Q 2797 4750 3086 4639 
+Q 3375 4528 3647 4306 
+z
+" transform="scale(0.015625)"/>
+       </defs>
+       <use xlink:href="#DejaVuSans-30"/>
+       <use xlink:href="#DejaVuSans-6b" transform="translate(63.623047 0)"/>
+       <use xlink:href="#DejaVuSans-20" transform="translate(121.533203 0)"/>
+       <use xlink:href="#DejaVuSans-20ac" transform="translate(153.320312 0)"/>
+      </g>
+     </g>
+    </g>
+    <g id="ytick_2">
+     <g id="line2d_8">
+      <path d="M 75.89 285.497151 
+L 723.6 285.497151 
+" clip-path="url(#p83a3789304)" style="fill: none; stroke-dasharray: 0.8,1.32; stroke-dashoffset: 0; stroke: #b0b0b0; stroke-opacity: 0.45; stroke-width: 0.8"/>
+     </g>
+     <g id="line2d_9">
+      <g>
+       <use xlink:href="#mc0b9ff744f" x="75.89" y="285.497151" style="stroke: #000000; stroke-width: 0.8"/>
+      </g>
+     </g>
+     <g id="text_7">
+      <!-- 200k € -->
+      <g transform="translate(34.47125 289.29637) scale(0.1 -0.1)">
+       <defs>
+        <path id="DejaVuSans-32" d="M 1228 531 
+L 3431 531 
+L 3431 0 
+L 469 0 
+L 469 531 
+Q 828 903 1448 1529 
+Q 2069 2156 2228 2338 
+Q 2531 2678 2651 2914 
+Q 2772 3150 2772 3378 
+Q 2772 3750 2511 3984 
+Q 2250 4219 1831 4219 
+Q 1534 4219 1204 4116 
+Q 875 4013 500 3803 
+L 500 4441 
+Q 881 4594 1212 4672 
+Q 1544 4750 1819 4750 
+Q 2544 4750 2975 4387 
+Q 3406 4025 3406 3419 
+Q 3406 3131 3298 2873 
+Q 3191 2616 2906 2266 
+Q 2828 2175 2409 1742 
+Q 1991 1309 1228 531 
+z
+" transform="scale(0.015625)"/>
+       </defs>
+       <use xlink:href="#DejaVuSans-32"/>
+       <use xlink:href="#DejaVuSans-30" transform="translate(63.623047 0)"/>
+       <use xlink:href="#DejaVuSans-30" transform="translate(127.246094 0)"/>
+       <use xlink:href="#DejaVuSans-6b" transform="translate(190.869141 0)"/>
+       <use xlink:href="#DejaVuSans-20" transform="translate(248.779297 0)"/>
+       <use xlink:href="#DejaVuSans-20ac" transform="translate(280.566406 0)"/>
+      </g>
+     </g>
+    </g>
+    <g id="ytick_3">
+     <g id="line2d_10">
+      <path d="M 75.89 228.876222 
+L 723.6 228.876222 
+" clip-path="url(#p83a3789304)" style="fill: none; stroke-dasharray: 0.8,1.32; stroke-dashoffset: 0; stroke: #b0b0b0; stroke-opacity: 0.45; stroke-width: 0.8"/>
+     </g>
+     <g id="line2d_11">
+      <g>
+       <use xlink:href="#mc0b9ff744f" x="75.89" y="228.876222" style="stroke: #000000; stroke-width: 0.8"/>
+      </g>
+     </g>
+     <g id="text_8">
+      <!-- 400k € -->
+      <g transform="translate(34.47125 232.675441) scale(0.1 -0.1)">
+       <defs>
+        <path id="DejaVuSans-34" d="M 2419 4116 
+L 825 1625 
+L 2419 1625 
+L 2419 4116 
+z
+M 2253 4666 
+L 3047 4666 
+L 3047 1625 
+L 3713 1625 
+L 3713 1100 
+L 3047 1100 
+L 3047 0 
+L 2419 0 
+L 2419 1100 
+L 313 1100 
+L 313 1709 
+L 2253 4666 
+z
+" transform="scale(0.015625)"/>
+       </defs>
+       <use xlink:href="#DejaVuSans-34"/>
+       <use xlink:href="#DejaVuSans-30" transform="translate(63.623047 0)"/>
+       <use xlink:href="#DejaVuSans-30" transform="translate(127.246094 0)"/>
+       <use xlink:href="#DejaVuSans-6b" transform="translate(190.869141 0)"/>
+       <use xlink:href="#DejaVuSans-20" transform="translate(248.779297 0)"/>
+       <use xlink:href="#DejaVuSans-20ac" transform="translate(280.566406 0)"/>
+      </g>
+     </g>
+    </g>
+    <g id="ytick_4">
+     <g id="line2d_12">
+      <path d="M 75.89 172.255294 
+L 723.6 172.255294 
+" clip-path="url(#p83a3789304)" style="fill: none; stroke-dasharray: 0.8,1.32; stroke-dashoffset: 0; stroke: #b0b0b0; stroke-opacity: 0.45; stroke-width: 0.8"/>
+     </g>
+     <g id="line2d_13">
+      <g>
+       <use xlink:href="#mc0b9ff744f" x="75.89" y="172.255294" style="stroke: #000000; stroke-width: 0.8"/>
+      </g>
+     </g>
+     <g id="text_9">
+      <!-- 600k € -->
+      <g transform="translate(34.47125 176.054512) scale(0.1 -0.1)">
+       <defs>
+        <path id="DejaVuSans-36" d="M 2113 2584 
+Q 1688 2584 1439 2293 
+Q 1191 2003 1191 1497 
+Q 1191 994 1439 701 
+Q 1688 409 2113 409 
+Q 2538 409 2786 701 
+Q 3034 994 3034 1497 
+Q 3034 2003 2786 2293 
+Q 2538 2584 2113 2584 
+z
+M 3366 4563 
+L 3366 3988 
+Q 3128 4100 2886 4159 
+Q 2644 4219 2406 4219 
+Q 1781 4219 1451 3797 
+Q 1122 3375 1075 2522 
+Q 1259 2794 1537 2939 
+Q 1816 3084 2150 3084 
+Q 2853 3084 3261 2657 
+Q 3669 2231 3669 1497 
+Q 3669 778 3244 343 
+Q 2819 -91 2113 -91 
+Q 1303 -91 875 529 
+Q 447 1150 447 2328 
+Q 447 3434 972 4092 
+Q 1497 4750 2381 4750 
+Q 2619 4750 2861 4703 
+Q 3103 4656 3366 4563 
+z
+" transform="scale(0.015625)"/>
+       </defs>
+       <use xlink:href="#DejaVuSans-36"/>
+       <use xlink:href="#DejaVuSans-30" transform="translate(63.623047 0)"/>
+       <use xlink:href="#DejaVuSans-30" transform="translate(127.246094 0)"/>
+       <use xlink:href="#DejaVuSans-6b" transform="translate(190.869141 0)"/>
+       <use xlink:href="#DejaVuSans-20" transform="translate(248.779297 0)"/>
+       <use xlink:href="#DejaVuSans-20ac" transform="translate(280.566406 0)"/>
+      </g>
+     </g>
+    </g>
+    <g id="ytick_5">
+     <g id="line2d_14">
+      <path d="M 75.89 115.634365 
+L 723.6 115.634365 
+" clip-path="url(#p83a3789304)" style="fill: none; stroke-dasharray: 0.8,1.32; stroke-dashoffset: 0; stroke: #b0b0b0; stroke-opacity: 0.45; stroke-width: 0.8"/>
+     </g>
+     <g id="line2d_15">
+      <g>
+       <use xlink:href="#mc0b9ff744f" x="75.89" y="115.634365" style="stroke: #000000; stroke-width: 0.8"/>
+      </g>
+     </g>
+     <g id="text_10">
+      <!-- 800k € -->
+      <g transform="translate(34.47125 119.433584) scale(0.1 -0.1)">
+       <defs>
+        <path id="DejaVuSans-38" d="M 2034 2216 
+Q 1584 2216 1326 1975 
+Q 1069 1734 1069 1313 
+Q 1069 891 1326 650 
+Q 1584 409 2034 409 
+Q 2484 409 2743 651 
+Q 3003 894 3003 1313 
+Q 3003 1734 2745 1975 
+Q 2488 2216 2034 2216 
+z
+M 1403 2484 
+Q 997 2584 770 2862 
+Q 544 3141 544 3541 
+Q 544 4100 942 4425 
+Q 1341 4750 2034 4750 
+Q 2731 4750 3128 4425 
+Q 3525 4100 3525 3541 
+Q 3525 3141 3298 2862 
+Q 3072 2584 2669 2484 
+Q 3125 2378 3379 2068 
+Q 3634 1759 3634 1313 
+Q 3634 634 3220 271 
+Q 2806 -91 2034 -91 
+Q 1263 -91 848 271 
+Q 434 634 434 1313 
+Q 434 1759 690 2068 
+Q 947 2378 1403 2484 
+z
+M 1172 3481 
+Q 1172 3119 1398 2916 
+Q 1625 2713 2034 2713 
+Q 2441 2713 2670 2916 
+Q 2900 3119 2900 3481 
+Q 2900 3844 2670 4047 
+Q 2441 4250 2034 4250 
+Q 1625 4250 1398 4047 
+Q 1172 3844 1172 3481 
+z
+" transform="scale(0.015625)"/>
+       </defs>
+       <use xlink:href="#DejaVuSans-38"/>
+       <use xlink:href="#DejaVuSans-30" transform="translate(63.623047 0)"/>
+       <use xlink:href="#DejaVuSans-30" transform="translate(127.246094 0)"/>
+       <use xlink:href="#DejaVuSans-6b" transform="translate(190.869141 0)"/>
+       <use xlink:href="#DejaVuSans-20" transform="translate(248.779297 0)"/>
+       <use xlink:href="#DejaVuSans-20ac" transform="translate(280.566406 0)"/>
+      </g>
+     </g>
+    </g>
+    <g id="ytick_6">
+     <g id="line2d_16">
+      <path d="M 75.89 59.013436 
+L 723.6 59.013436 
+" clip-path="url(#p83a3789304)" style="fill: none; stroke-dasharray: 0.8,1.32; stroke-dashoffset: 0; stroke: #b0b0b0; stroke-opacity: 0.45; stroke-width: 0.8"/>
+     </g>
+     <g id="line2d_17">
+      <g>
+       <use xlink:href="#mc0b9ff744f" x="75.89" y="59.013436" style="stroke: #000000; stroke-width: 0.8"/>
+      </g>
+     </g>
+     <g id="text_11">
+      <!-- 1.000k € -->
+      <g transform="translate(24.930625 62.812655) scale(0.1 -0.1)">
+       <defs>
+        <path id="DejaVuSans-31" d="M 794 531 
+L 1825 531 
+L 1825 4091 
+L 703 3866 
+L 703 4441 
+L 1819 4666 
+L 2450 4666 
+L 2450 531 
+L 3481 531 
+L 3481 0 
+L 794 0 
+L 794 531 
+z
+" transform="scale(0.015625)"/>
+        <path id="DejaVuSans-2e" d="M 684 794 
+L 1344 794 
+L 1344 0 
+L 684 0 
+L 684 794 
+z
+" transform="scale(0.015625)"/>
+       </defs>
+       <use xlink:href="#DejaVuSans-31"/>
+       <use xlink:href="#DejaVuSans-2e" transform="translate(63.623047 0)"/>
+       <use xlink:href="#DejaVuSans-30" transform="translate(95.410156 0)"/>
+       <use xlink:href="#DejaVuSans-30" transform="translate(159.033203 0)"/>
+       <use xlink:href="#DejaVuSans-30" transform="translate(222.65625 0)"/>
+       <use xlink:href="#DejaVuSans-6b" transform="translate(286.279297 0)"/>
+       <use xlink:href="#DejaVuSans-20" transform="translate(344.189453 0)"/>
+       <use xlink:href="#DejaVuSans-20ac" transform="translate(375.976562 0)"/>
+      </g>
+     </g>
+    </g>
+    <g id="text_12">
+     <!-- Erwartete Tageskosten -->
+     <g transform="translate(18.850938 252.805009) rotate(-90) scale(0.1 -0.1)">
+      <defs>
+       <path id="DejaVuSans-54" d="M -19 4666 
+L 3928 4666 
+L 3928 4134 
+L 2272 4134 
+L 2272 0 
+L 1638 0 
+L 1638 4134 
+L -19 4134 
+L -19 4666 
+z
+" transform="scale(0.015625)"/>
+      </defs>
+      <use xlink:href="#DejaVuSans-45"/>
+      <use xlink:href="#DejaVuSans-72" transform="translate(63.183594 0)"/>
+      <use xlink:href="#DejaVuSans-77" transform="translate(104.296875 0)"/>
+      <use xlink:href="#DejaVuSans-61" transform="translate(186.083984 0)"/>
+      <use xlink:href="#DejaVuSans-72" transform="translate(247.363281 0)"/>
+      <use xlink:href="#DejaVuSans-74" transform="translate(288.476562 0)"/>
+      <use xlink:href="#DejaVuSans-65" transform="translate(327.685547 0)"/>
+      <use xlink:href="#DejaVuSans-74" transform="translate(389.208984 0)"/>
+      <use xlink:href="#DejaVuSans-65" transform="translate(428.417969 0)"/>
+      <use xlink:href="#DejaVuSans-20" transform="translate(489.941406 0)"/>
+      <use xlink:href="#DejaVuSans-54" transform="translate(521.728516 0)"/>
+      <use xlink:href="#DejaVuSans-61" transform="translate(566.3125 0)"/>
+      <use xlink:href="#DejaVuSans-67" transform="translate(627.591797 0)"/>
+      <use xlink:href="#DejaVuSans-65" transform="translate(691.068359 0)"/>
+      <use xlink:href="#DejaVuSans-73" transform="translate(752.591797 0)"/>
+      <use xlink:href="#DejaVuSans-6b" transform="translate(804.691406 0)"/>
+      <use xlink:href="#DejaVuSans-6f" transform="translate(858.976562 0)"/>
+      <use xlink:href="#DejaVuSans-73" transform="translate(920.158203 0)"/>
+      <use xlink:href="#DejaVuSans-74" transform="translate(972.257812 0)"/>
+      <use xlink:href="#DejaVuSans-65" transform="translate(1011.466797 0)"/>
+      <use xlink:href="#DejaVuSans-6e" transform="translate(1072.990234 0)"/>
+     </g>
+    </g>
+   </g>
+   <g id="line2d_18">
+    <path d="M 232.783154 246.250134 
+L 360.234945 246.250134 
+" clip-path="url(#p83a3789304)" style="fill: none; stroke-dasharray: 0.9,1.485; stroke-dashoffset: 0; stroke: #64748b; stroke-width: 0.9"/>
+   </g>
+   <g id="line2d_19">
+    <path d="M 360.234945 246.250134 
+L 487.686736 246.250134 
+" clip-path="url(#p83a3789304)" style="fill: none; stroke-dasharray: 0.9,1.485; stroke-dashoffset: 0; stroke: #64748b; stroke-width: 0.9"/>
+   </g>
+   <g id="line2d_20">
+    <path d="M 487.686736 94.438351 
+L 615.138526 94.438351 
+" clip-path="url(#p83a3789304)" style="fill: none; stroke-dasharray: 0.9,1.485; stroke-dashoffset: 0; stroke: #64748b; stroke-width: 0.9"/>
+   </g>
+   <g id="patch_3">
+    <path d="M 75.89 342.11808 
+L 75.89 49.856 
+" style="fill: none; stroke: #000000; stroke-width: 0.8; stroke-linejoin: miter; stroke-linecap: square"/>
+   </g>
+   <g id="patch_4">
+    <path d="M 75.89 342.11808 
+L 723.6 342.11808 
+" style="fill: none; stroke: #000000; stroke-width: 0.8; stroke-linejoin: miter; stroke-linecap: square"/>
+   </g>
+   <g id="patch_5">
+    <path d="M 105.331364 342.11808 
+L 184.351474 342.11808 
+L 184.351474 242.64755 
+L 105.331364 242.64755 
+z
+" clip-path="url(#p83a3789304)" style="fill: #4338ca"/>
+   </g>
+   <g id="text_13">
+    <!-- 351.356 € -->
+    <g style="fill: #4338ca" transform="translate(114.050012 235.26401) scale(0.11 -0.11)">
+     <defs>
+      <path id="DejaVuSans-Bold-33" d="M 2981 2516 
+Q 3453 2394 3698 2092 
+Q 3944 1791 3944 1325 
+Q 3944 631 3412 270 
+Q 2881 -91 1863 -91 
+Q 1503 -91 1142 -33 
+Q 781 25 428 141 
+L 428 1069 
+Q 766 900 1098 814 
+Q 1431 728 1753 728 
+Q 2231 728 2486 893 
+Q 2741 1059 2741 1369 
+Q 2741 1688 2480 1852 
+Q 2219 2016 1709 2016 
+L 1228 2016 
+L 1228 2791 
+L 1734 2791 
+Q 2188 2791 2409 2933 
+Q 2631 3075 2631 3366 
+Q 2631 3634 2415 3781 
+Q 2200 3928 1806 3928 
+Q 1516 3928 1219 3862 
+Q 922 3797 628 3669 
+L 628 4550 
+Q 984 4650 1334 4700 
+Q 1684 4750 2022 4750 
+Q 2931 4750 3382 4451 
+Q 3834 4153 3834 3553 
+Q 3834 3144 3618 2883 
+Q 3403 2622 2981 2516 
+z
+" transform="scale(0.015625)"/>
+      <path id="DejaVuSans-Bold-35" d="M 678 4666 
+L 3669 4666 
+L 3669 3781 
+L 1638 3781 
+L 1638 3059 
+Q 1775 3097 1914 3117 
+Q 2053 3138 2203 3138 
+Q 3056 3138 3531 2711 
+Q 4006 2284 4006 1522 
+Q 4006 766 3489 337 
+Q 2972 -91 2053 -91 
+Q 1656 -91 1267 -14 
+Q 878 63 494 219 
+L 494 1166 
+Q 875 947 1217 837 
+Q 1559 728 1863 728 
+Q 2300 728 2551 942 
+Q 2803 1156 2803 1522 
+Q 2803 1891 2551 2103 
+Q 2300 2316 1863 2316 
+Q 1603 2316 1309 2248 
+Q 1016 2181 678 2041 
+L 678 4666 
+z
+" transform="scale(0.015625)"/>
+      <path id="DejaVuSans-Bold-31" d="M 750 831 
+L 1813 831 
+L 1813 3847 
+L 722 3622 
+L 722 4441 
+L 1806 4666 
+L 2950 4666 
+L 2950 831 
+L 4013 831 
+L 4013 0 
+L 750 0 
+L 750 831 
+z
+" transform="scale(0.015625)"/>
+      <path id="DejaVuSans-Bold-2e" d="M 653 1209 
+L 1778 1209 
+L 1778 0 
+L 653 0 
+L 653 1209 
+z
+" transform="scale(0.015625)"/>
+      <path id="DejaVuSans-Bold-36" d="M 2316 2303 
+Q 2000 2303 1842 2098 
+Q 1684 1894 1684 1484 
+Q 1684 1075 1842 870 
+Q 2000 666 2316 666 
+Q 2634 666 2792 870 
+Q 2950 1075 2950 1484 
+Q 2950 1894 2792 2098 
+Q 2634 2303 2316 2303 
+z
+M 3803 4544 
+L 3803 3681 
+Q 3506 3822 3243 3889 
+Q 2981 3956 2731 3956 
+Q 2194 3956 1894 3657 
+Q 1594 3359 1544 2772 
+Q 1750 2925 1990 3001 
+Q 2231 3078 2516 3078 
+Q 3231 3078 3670 2659 
+Q 4109 2241 4109 1563 
+Q 4109 813 3618 361 
+Q 3128 -91 2303 -91 
+Q 1394 -91 895 523 
+Q 397 1138 397 2266 
+Q 397 3422 980 4083 
+Q 1563 4744 2578 4744 
+Q 2900 4744 3203 4694 
+Q 3506 4644 3803 4544 
+z
+" transform="scale(0.015625)"/>
+      <path id="DejaVuSans-Bold-20" transform="scale(0.015625)"/>
+      <path id="DejaVuSans-Bold-20ac" d="M 4025 256 
+Q 3728 84 3404 -3 
+Q 3081 -91 2731 -91 
+Q 1913 -91 1352 317 
+Q 791 725 556 1491 
+L -122 1491 
+L 153 2100 
+L 459 2100 
+Q 456 2144 454 2192 
+Q 453 2241 453 2328 
+Q 453 2419 454 2469 
+Q 456 2519 459 2566 
+L -122 2566 
+L 153 3175 
+L 556 3175 
+Q 797 3944 1355 4347 
+Q 1913 4750 2731 4750 
+Q 3081 4750 3404 4662 
+Q 3728 4575 4025 4403 
+L 4025 3438 
+Q 3772 3681 3484 3804 
+Q 3197 3928 2888 3928 
+Q 2491 3928 2211 3736 
+Q 1931 3544 1791 3175 
+L 3475 3175 
+L 3206 2566 
+L 1666 2566 
+Q 1659 2516 1657 2459 
+Q 1656 2403 1656 2291 
+Q 1656 2250 1657 2201 
+Q 1659 2153 1663 2100 
+L 3003 2100 
+L 2725 1491 
+L 1791 1491 
+Q 1947 1109 2220 918 
+Q 2494 728 2888 728 
+Q 3197 728 3480 851 
+Q 3763 975 4025 1222 
+L 4025 256 
+z
+" transform="scale(0.015625)"/>
+     </defs>
+     <use xlink:href="#DejaVuSans-Bold-33"/>
+     <use xlink:href="#DejaVuSans-Bold-35" transform="translate(69.580078 0)"/>
+     <use xlink:href="#DejaVuSans-Bold-31" transform="translate(139.160156 0)"/>
+     <use xlink:href="#DejaVuSans-Bold-2e" transform="translate(208.740234 0)"/>
+     <use xlink:href="#DejaVuSans-Bold-33" transform="translate(246.728516 0)"/>
+     <use xlink:href="#DejaVuSans-Bold-35" transform="translate(316.308594 0)"/>
+     <use xlink:href="#DejaVuSans-Bold-36" transform="translate(385.888672 0)"/>
+     <use xlink:href="#DejaVuSans-Bold-20" transform="translate(455.46875 0)"/>
+     <use xlink:href="#DejaVuSans-Bold-20ac" transform="translate(490.283203 0)"/>
+    </g>
+   </g>
+   <g id="patch_6">
+    <path d="M 232.783154 246.250134 
+L 311.803264 246.250134 
+L 311.803264 242.64755 
+L 232.783154 242.64755 
+z
+" clip-path="url(#p83a3789304)" style="fill: #059669"/>
+   </g>
+   <g id="text_14">
+    <!-- -12.725 € -->
+    <g style="fill: #059669" transform="translate(244.375514 235.367995) scale(0.105 -0.105)">
+     <defs>
+      <path id="DejaVuSans-Bold-2d" d="M 347 2297 
+L 2309 2297 
+L 2309 1388 
+L 347 1388 
+L 347 2297 
+z
+" transform="scale(0.015625)"/>
+      <path id="DejaVuSans-Bold-32" d="M 1844 884 
+L 3897 884 
+L 3897 0 
+L 506 0 
+L 506 884 
+L 2209 2388 
+Q 2438 2594 2547 2791 
+Q 2656 2988 2656 3200 
+Q 2656 3528 2436 3728 
+Q 2216 3928 1850 3928 
+Q 1569 3928 1234 3808 
+Q 900 3688 519 3450 
+L 519 4475 
+Q 925 4609 1322 4679 
+Q 1719 4750 2100 4750 
+Q 2938 4750 3402 4381 
+Q 3866 4013 3866 3353 
+Q 3866 2972 3669 2642 
+Q 3472 2313 2841 1759 
+L 1844 884 
+z
+" transform="scale(0.015625)"/>
+      <path id="DejaVuSans-Bold-37" d="M 428 4666 
+L 3944 4666 
+L 3944 3988 
+L 2125 0 
+L 953 0 
+L 2675 3781 
+L 428 3781 
+L 428 4666 
+z
+" transform="scale(0.015625)"/>
+     </defs>
+     <use xlink:href="#DejaVuSans-Bold-2d"/>
+     <use xlink:href="#DejaVuSans-Bold-31" transform="translate(41.503906 0)"/>
+     <use xlink:href="#DejaVuSans-Bold-32" transform="translate(111.083984 0)"/>
+     <use xlink:href="#DejaVuSans-Bold-2e" transform="translate(180.664062 0)"/>
+     <use xlink:href="#DejaVuSans-Bold-37" transform="translate(218.652344 0)"/>
+     <use xlink:href="#DejaVuSans-Bold-32" transform="translate(288.232422 0)"/>
+     <use xlink:href="#DejaVuSans-Bold-35" transform="translate(357.8125 0)"/>
+     <use xlink:href="#DejaVuSans-Bold-20" transform="translate(427.392578 0)"/>
+     <use xlink:href="#DejaVuSans-Bold-20ac" transform="translate(462.207031 0)"/>
+    </g>
+   </g>
+   <g id="patch_7">
+    <path d="M 360.234945 246.250134 
+L 439.255055 246.250134 
+L 439.255055 246.250134 
+L 360.234945 246.250134 
+z
+" clip-path="url(#p83a3789304)" style="fill: #059669"/>
+   </g>
+   <g id="text_15">
+    <!-- +0 € -->
+    <g style="fill: #059669" transform="translate(386.212305 238.970578) scale(0.105 -0.105)">
+     <defs>
+      <path id="DejaVuSans-Bold-2b" d="M 3053 4013 
+L 3053 2375 
+L 4684 2375 
+L 4684 1638 
+L 3053 1638 
+L 3053 0 
+L 2309 0 
+L 2309 1638 
+L 678 1638 
+L 678 2375 
+L 2309 2375 
+L 2309 4013 
+L 3053 4013 
+z
+" transform="scale(0.015625)"/>
+      <path id="DejaVuSans-Bold-30" d="M 2944 2338 
+Q 2944 3213 2780 3570 
+Q 2616 3928 2228 3928 
+Q 1841 3928 1675 3570 
+Q 1509 3213 1509 2338 
+Q 1509 1453 1675 1090 
+Q 1841 728 2228 728 
+Q 2613 728 2778 1090 
+Q 2944 1453 2944 2338 
+z
+M 4147 2328 
+Q 4147 1169 3647 539 
+Q 3147 -91 2228 -91 
+Q 1306 -91 806 539 
+Q 306 1169 306 2328 
+Q 306 3491 806 4120 
+Q 1306 4750 2228 4750 
+Q 3147 4750 3647 4120 
+Q 4147 3491 4147 2328 
+z
+" transform="scale(0.015625)"/>
+     </defs>
+     <use xlink:href="#DejaVuSans-Bold-2b"/>
+     <use xlink:href="#DejaVuSans-Bold-30" transform="translate(83.789062 0)"/>
+     <use xlink:href="#DejaVuSans-Bold-20" transform="translate(153.369141 0)"/>
+     <use xlink:href="#DejaVuSans-Bold-20ac" transform="translate(188.183594 0)"/>
+    </g>
+   </g>
+   <g id="patch_8">
+    <path d="M 487.686736 246.250134 
+L 566.706846 246.250134 
+L 566.706846 94.438351 
+L 487.686736 94.438351 
+z
+" clip-path="url(#p83a3789304)" style="fill: #b45309"/>
+   </g>
+   <g id="text_16">
+    <!-- +536.239 € -->
+    <g style="fill: #b45309" transform="translate(493.405658 87.158796) scale(0.105 -0.105)">
+     <defs>
+      <path id="DejaVuSans-Bold-39" d="M 641 103 
+L 641 966 
+Q 928 831 1190 764 
+Q 1453 697 1709 697 
+Q 2247 697 2547 995 
+Q 2847 1294 2900 1881 
+Q 2688 1725 2447 1647 
+Q 2206 1569 1925 1569 
+Q 1209 1569 770 1986 
+Q 331 2403 331 3084 
+Q 331 3838 820 4291 
+Q 1309 4744 2131 4744 
+Q 3044 4744 3544 4128 
+Q 4044 3513 4044 2388 
+Q 4044 1231 3459 570 
+Q 2875 -91 1856 -91 
+Q 1528 -91 1228 -42 
+Q 928 6 641 103 
+z
+M 2125 2350 
+Q 2441 2350 2600 2554 
+Q 2759 2759 2759 3169 
+Q 2759 3575 2600 3781 
+Q 2441 3988 2125 3988 
+Q 1809 3988 1650 3781 
+Q 1491 3575 1491 3169 
+Q 1491 2759 1650 2554 
+Q 1809 2350 2125 2350 
+z
+" transform="scale(0.015625)"/>
+     </defs>
+     <use xlink:href="#DejaVuSans-Bold-2b"/>
+     <use xlink:href="#DejaVuSans-Bold-35" transform="translate(83.789062 0)"/>
+     <use xlink:href="#DejaVuSans-Bold-33" transform="translate(153.369141 0)"/>
+     <use xlink:href="#DejaVuSans-Bold-36" transform="translate(222.949219 0)"/>
+     <use xlink:href="#DejaVuSans-Bold-2e" transform="translate(292.529297 0)"/>
+     <use xlink:href="#DejaVuSans-Bold-32" transform="translate(330.517578 0)"/>
+     <use xlink:href="#DejaVuSans-Bold-33" transform="translate(400.097656 0)"/>
+     <use xlink:href="#DejaVuSans-Bold-39" transform="translate(469.677734 0)"/>
+     <use xlink:href="#DejaVuSans-Bold-20" transform="translate(539.257812 0)"/>
+     <use xlink:href="#DejaVuSans-Bold-20ac" transform="translate(574.072266 0)"/>
+    </g>
+   </g>
+   <g id="patch_9">
+    <path d="M 615.138526 342.11808 
+L 694.158636 342.11808 
+L 694.158636 94.438351 
+L 615.138526 94.438351 
+z
+" clip-path="url(#p83a3789304)" style="fill: #4338ca"/>
+   </g>
+   <g id="text_17">
+    <!-- 874.870 € -->
+    <g style="fill: #4338ca" transform="translate(623.857175 87.054811) scale(0.11 -0.11)">
+     <defs>
+      <path id="DejaVuSans-Bold-38" d="M 2228 2088 
+Q 1891 2088 1709 1903 
+Q 1528 1719 1528 1375 
+Q 1528 1031 1709 848 
+Q 1891 666 2228 666 
+Q 2563 666 2741 848 
+Q 2919 1031 2919 1375 
+Q 2919 1722 2741 1905 
+Q 2563 2088 2228 2088 
+z
+M 1350 2484 
+Q 925 2613 709 2878 
+Q 494 3144 494 3541 
+Q 494 4131 934 4440 
+Q 1375 4750 2228 4750 
+Q 3075 4750 3515 4442 
+Q 3956 4134 3956 3541 
+Q 3956 3144 3739 2878 
+Q 3522 2613 3097 2484 
+Q 3572 2353 3814 2058 
+Q 4056 1763 4056 1313 
+Q 4056 619 3595 264 
+Q 3134 -91 2228 -91 
+Q 1319 -91 855 264 
+Q 391 619 391 1313 
+Q 391 1763 633 2058 
+Q 875 2353 1350 2484 
+z
+M 1631 3419 
+Q 1631 3141 1786 2991 
+Q 1941 2841 2228 2841 
+Q 2509 2841 2662 2991 
+Q 2816 3141 2816 3419 
+Q 2816 3697 2662 3845 
+Q 2509 3994 2228 3994 
+Q 1941 3994 1786 3844 
+Q 1631 3694 1631 3419 
+z
+" transform="scale(0.015625)"/>
+      <path id="DejaVuSans-Bold-34" d="M 2356 3675 
+L 1038 1722 
+L 2356 1722 
+L 2356 3675 
+z
+M 2156 4666 
+L 3494 4666 
+L 3494 1722 
+L 4159 1722 
+L 4159 850 
+L 3494 850 
+L 3494 0 
+L 2356 0 
+L 2356 850 
+L 288 850 
+L 288 1881 
+L 2156 4666 
+z
+" transform="scale(0.015625)"/>
+     </defs>
+     <use xlink:href="#DejaVuSans-Bold-38"/>
+     <use xlink:href="#DejaVuSans-Bold-37" transform="translate(69.580078 0)"/>
+     <use xlink:href="#DejaVuSans-Bold-34" transform="translate(139.160156 0)"/>
+     <use xlink:href="#DejaVuSans-Bold-2e" transform="translate(208.740234 0)"/>
+     <use xlink:href="#DejaVuSans-Bold-38" transform="translate(246.728516 0)"/>
+     <use xlink:href="#DejaVuSans-Bold-37" transform="translate(316.308594 0)"/>
+     <use xlink:href="#DejaVuSans-Bold-30" transform="translate(385.888672 0)"/>
+     <use xlink:href="#DejaVuSans-Bold-20" transform="translate(455.46875 0)"/>
+     <use xlink:href="#DejaVuSans-Bold-20ac" transform="translate(490.283203 0)"/>
+    </g>
+   </g>
+   <g id="text_18">
+    <!-- Lastabwurf in 28 von 40 Szenarien statt in 0; Anfahrkosten in beiden Plänen gleich. -->
+    <g style="fill: #64748b" transform="translate(190.86375 387.418702) scale(0.1 -0.1)">
+     <defs>
+      <path id="DejaVuSans-76" d="M 191 3500 
+L 800 3500 
+L 1894 563 
+L 2988 3500 
+L 3597 3500 
+L 2284 0 
+L 1503 0 
+L 191 3500 
+z
+" transform="scale(0.015625)"/>
+      <path id="DejaVuSans-53" d="M 3425 4513 
+L 3425 3897 
+Q 3066 4069 2747 4153 
+Q 2428 4238 2131 4238 
+Q 1616 4238 1336 4038 
+Q 1056 3838 1056 3469 
+Q 1056 3159 1242 3001 
+Q 1428 2844 1947 2747 
+L 2328 2669 
+Q 3034 2534 3370 2195 
+Q 3706 1856 3706 1288 
+Q 3706 609 3251 259 
+Q 2797 -91 1919 -91 
+Q 1588 -91 1214 -16 
+Q 841 59 441 206 
+L 441 856 
+Q 825 641 1194 531 
+Q 1563 422 1919 422 
+Q 2459 422 2753 634 
+Q 3047 847 3047 1241 
+Q 3047 1584 2836 1778 
+Q 2625 1972 2144 2069 
+L 1759 2144 
+Q 1053 2284 737 2584 
+Q 422 2884 422 3419 
+Q 422 4038 858 4394 
+Q 1294 4750 2059 4750 
+Q 2388 4750 2728 4690 
+Q 3069 4631 3425 4513 
+z
+" transform="scale(0.015625)"/>
+      <path id="DejaVuSans-7a" d="M 353 3500 
+L 3084 3500 
+L 3084 2975 
+L 922 459 
+L 3084 459 
+L 3084 0 
+L 275 0 
+L 275 525 
+L 2438 3041 
+L 353 3041 
+L 353 3500 
+z
+" transform="scale(0.015625)"/>
+      <path id="DejaVuSans-3b" d="M 750 3309 
+L 1409 3309 
+L 1409 2516 
+L 750 2516 
+L 750 3309 
+z
+M 750 794 
+L 1409 794 
+L 1409 256 
+L 897 -744 
+L 494 -744 
+L 750 256 
+L 750 794 
+z
+" transform="scale(0.015625)"/>
+      <path id="DejaVuSans-64" d="M 2906 2969 
+L 2906 4863 
+L 3481 4863 
+L 3481 0 
+L 2906 0 
+L 2906 525 
+Q 2725 213 2448 61 
+Q 2172 -91 1784 -91 
+Q 1150 -91 751 415 
+Q 353 922 353 1747 
+Q 353 2572 751 3078 
+Q 1150 3584 1784 3584 
+Q 2172 3584 2448 3432 
+Q 2725 3281 2906 2969 
+z
+M 947 1747 
+Q 947 1113 1208 752 
+Q 1469 391 1925 391 
+Q 2381 391 2643 752 
+Q 2906 1113 2906 1747 
+Q 2906 2381 2643 2742 
+Q 2381 3103 1925 3103 
+Q 1469 3103 1208 2742 
+Q 947 2381 947 1747 
+z
+" transform="scale(0.015625)"/>
+      <path id="DejaVuSans-e4" d="M 2194 1759 
+Q 1497 1759 1228 1600 
+Q 959 1441 959 1056 
+Q 959 750 1161 570 
+Q 1363 391 1709 391 
+Q 2188 391 2477 730 
+Q 2766 1069 2766 1631 
+L 2766 1759 
+L 2194 1759 
+z
+M 3341 1997 
+L 3341 0 
+L 2766 0 
+L 2766 531 
+Q 2569 213 2275 61 
+Q 1981 -91 1556 -91 
+Q 1019 -91 701 211 
+Q 384 513 384 1019 
+Q 384 1609 779 1909 
+Q 1175 2209 1959 2209 
+L 2766 2209 
+L 2766 2266 
+Q 2766 2663 2505 2880 
+Q 2244 3097 1772 3097 
+Q 1472 3097 1187 3025 
+Q 903 2953 641 2809 
+L 641 3341 
+Q 956 3463 1253 3523 
+Q 1550 3584 1831 3584 
+Q 2591 3584 2966 3190 
+Q 3341 2797 3341 1997 
+z
+M 2150 4850 
+L 2784 4850 
+L 2784 4219 
+L 2150 4219 
+L 2150 4850 
+z
+M 928 4850 
+L 1563 4850 
+L 1563 4219 
+L 928 4219 
+L 928 4850 
+z
+" transform="scale(0.015625)"/>
+      <path id="DejaVuSans-63" d="M 3122 3366 
+L 3122 2828 
+Q 2878 2963 2633 3030 
+Q 2388 3097 2138 3097 
+Q 1578 3097 1268 2742 
+Q 959 2388 959 1747 
+Q 959 1106 1268 751 
+Q 1578 397 2138 397 
+Q 2388 397 2633 464 
+Q 2878 531 3122 666 
+L 3122 134 
+Q 2881 22 2623 -34 
+Q 2366 -91 2075 -91 
+Q 1284 -91 818 406 
+Q 353 903 353 1747 
+Q 353 2603 823 3093 
+Q 1294 3584 2113 3584 
+Q 2378 3584 2631 3529 
+Q 2884 3475 3122 3366 
+z
+" transform="scale(0.015625)"/>
+     </defs>
+     <use xlink:href="#DejaVuSans-4c"/>
+     <use xlink:href="#DejaVuSans-61" transform="translate(55.712891 0)"/>
+     <use xlink:href="#DejaVuSans-73" transform="translate(116.992188 0)"/>
+     <use xlink:href="#DejaVuSans-74" transform="translate(169.091797 0)"/>
+     <use xlink:href="#DejaVuSans-61" transform="translate(208.300781 0)"/>
+     <use xlink:href="#DejaVuSans-62" transform="translate(269.580078 0)"/>
+     <use xlink:href="#DejaVuSans-77" transform="translate(333.056641 0)"/>
+     <use xlink:href="#DejaVuSans-75" transform="translate(414.84375 0)"/>
+     <use xlink:href="#DejaVuSans-72" transform="translate(478.222656 0)"/>
+     <use xlink:href="#DejaVuSans-66" transform="translate(519.335938 0)"/>
+     <use xlink:href="#DejaVuSans-20" transform="translate(554.541016 0)"/>
+     <use xlink:href="#DejaVuSans-69" transform="translate(586.328125 0)"/>
+     <use xlink:href="#DejaVuSans-6e" transform="translate(614.111328 0)"/>
+     <use xlink:href="#DejaVuSans-20" transform="translate(677.490234 0)"/>
+     <use xlink:href="#DejaVuSans-32" transform="translate(709.277344 0)"/>
+     <use xlink:href="#DejaVuSans-38" transform="translate(772.900391 0)"/>
+     <use xlink:href="#DejaVuSans-20" transform="translate(836.523438 0)"/>
+     <use xlink:href="#DejaVuSans-76" transform="translate(868.310547 0)"/>
+     <use xlink:href="#DejaVuSans-6f" transform="translate(927.490234 0)"/>
+     <use xlink:href="#DejaVuSans-6e" transform="translate(988.671875 0)"/>
+     <use xlink:href="#DejaVuSans-20" transform="translate(1052.050781 0)"/>
+     <use xlink:href="#DejaVuSans-34" transform="translate(1083.837891 0)"/>
+     <use xlink:href="#DejaVuSans-30" transform="translate(1147.460938 0)"/>
+     <use xlink:href="#DejaVuSans-20" transform="translate(1211.083984 0)"/>
+     <use xlink:href="#DejaVuSans-53" transform="translate(1242.871094 0)"/>
+     <use xlink:href="#DejaVuSans-7a" transform="translate(1306.347656 0)"/>
+     <use xlink:href="#DejaVuSans-65" transform="translate(1358.837891 0)"/>
+     <use xlink:href="#DejaVuSans-6e" transform="translate(1420.361328 0)"/>
+     <use xlink:href="#DejaVuSans-61" transform="translate(1483.740234 0)"/>
+     <use xlink:href="#DejaVuSans-72" transform="translate(1545.019531 0)"/>
+     <use xlink:href="#DejaVuSans-69" transform="translate(1586.132812 0)"/>
+     <use xlink:href="#DejaVuSans-65" transform="translate(1613.916016 0)"/>
+     <use xlink:href="#DejaVuSans-6e" transform="translate(1675.439453 0)"/>
+     <use xlink:href="#DejaVuSans-20" transform="translate(1738.818359 0)"/>
+     <use xlink:href="#DejaVuSans-73" transform="translate(1770.605469 0)"/>
+     <use xlink:href="#DejaVuSans-74" transform="translate(1822.705078 0)"/>
+     <use xlink:href="#DejaVuSans-61" transform="translate(1861.914062 0)"/>
+     <use xlink:href="#DejaVuSans-74" transform="translate(1923.193359 0)"/>
+     <use xlink:href="#DejaVuSans-74" transform="translate(1962.402344 0)"/>
+     <use xlink:href="#DejaVuSans-20" transform="translate(2001.611328 0)"/>
+     <use xlink:href="#DejaVuSans-69" transform="translate(2033.398438 0)"/>
+     <use xlink:href="#DejaVuSans-6e" transform="translate(2061.181641 0)"/>
+     <use xlink:href="#DejaVuSans-20" transform="translate(2124.560547 0)"/>
+     <use xlink:href="#DejaVuSans-30" transform="translate(2156.347656 0)"/>
+     <use xlink:href="#DejaVuSans-3b" transform="translate(2219.970703 0)"/>
+     <use xlink:href="#DejaVuSans-20" transform="translate(2253.662109 0)"/>
+     <use xlink:href="#DejaVuSans-41" transform="translate(2285.449219 0)"/>
+     <use xlink:href="#DejaVuSans-6e" transform="translate(2353.857422 0)"/>
+     <use xlink:href="#DejaVuSans-66" transform="translate(2417.236328 0)"/>
+     <use xlink:href="#DejaVuSans-61" transform="translate(2452.441406 0)"/>
+     <use xlink:href="#DejaVuSans-68" transform="translate(2513.720703 0)"/>
+     <use xlink:href="#DejaVuSans-72" transform="translate(2577.099609 0)"/>
+     <use xlink:href="#DejaVuSans-6b" transform="translate(2618.212891 0)"/>
+     <use xlink:href="#DejaVuSans-6f" transform="translate(2672.498047 0)"/>
+     <use xlink:href="#DejaVuSans-73" transform="translate(2733.679688 0)"/>
+     <use xlink:href="#DejaVuSans-74" transform="translate(2785.779297 0)"/>
+     <use xlink:href="#DejaVuSans-65" transform="translate(2824.988281 0)"/>
+     <use xlink:href="#DejaVuSans-6e" transform="translate(2886.511719 0)"/>
+     <use xlink:href="#DejaVuSans-20" transform="translate(2949.890625 0)"/>
+     <use xlink:href="#DejaVuSans-69" transform="translate(2981.677734 0)"/>
+     <use xlink:href="#DejaVuSans-6e" transform="translate(3009.460938 0)"/>
+     <use xlink:href="#DejaVuSans-20" transform="translate(3072.839844 0)"/>
+     <use xlink:href="#DejaVuSans-62" transform="translate(3104.626953 0)"/>
+     <use xlink:href="#DejaVuSans-65" transform="translate(3168.103516 0)"/>
+     <use xlink:href="#DejaVuSans-69" transform="translate(3229.626953 0)"/>
+     <use xlink:href="#DejaVuSans-64" transform="translate(3257.410156 0)"/>
+     <use xlink:href="#DejaVuSans-65" transform="translate(3320.886719 0)"/>
+     <use xlink:href="#DejaVuSans-6e" transform="translate(3382.410156 0)"/>
+     <use xlink:href="#DejaVuSans-20" transform="translate(3445.789062 0)"/>
+     <use xlink:href="#DejaVuSans-50" transform="translate(3477.576172 0)"/>
+     <use xlink:href="#DejaVuSans-6c" transform="translate(3537.878906 0)"/>
+     <use xlink:href="#DejaVuSans-e4" transform="translate(3565.662109 0)"/>
+     <use xlink:href="#DejaVuSans-6e" transform="translate(3626.941406 0)"/>
+     <use xlink:href="#DejaVuSans-65" transform="translate(3690.320312 0)"/>
+     <use xlink:href="#DejaVuSans-6e" transform="translate(3751.84375 0)"/>
+     <use xlink:href="#DejaVuSans-20" transform="translate(3815.222656 0)"/>
+     <use xlink:href="#DejaVuSans-67" transform="translate(3847.009766 0)"/>
+     <use xlink:href="#DejaVuSans-6c" transform="translate(3910.486328 0)"/>
+     <use xlink:href="#DejaVuSans-65" transform="translate(3938.269531 0)"/>
+     <use xlink:href="#DejaVuSans-69" transform="translate(3999.792969 0)"/>
+     <use xlink:href="#DejaVuSans-63" transform="translate(4027.576172 0)"/>
+     <use xlink:href="#DejaVuSans-68" transform="translate(4082.556641 0)"/>
+     <use xlink:href="#DejaVuSans-2e" transform="translate(4145.935547 0)"/>
+    </g>
+   </g>
+   <g id="text_19">
+    <!-- Was der Erwartungswert-Plan spart — und was er dafür bezahlt -->
+    <g transform="translate(201.040898 21.858734) scale(0.125 -0.125)">
+     <defs>
+      <path id="DejaVuSans-57" d="M 213 4666 
+L 850 4666 
+L 1831 722 
+L 2809 4666 
+L 3519 4666 
+L 4500 722 
+L 5478 4666 
+L 6119 4666 
+L 4947 0 
+L 4153 0 
+L 3169 4050 
+L 2175 0 
+L 1381 0 
+L 213 4666 
+z
+" transform="scale(0.015625)"/>
+      <path id="DejaVuSans-70" d="M 1159 525 
+L 1159 -1331 
+L 581 -1331 
+L 581 3500 
+L 1159 3500 
+L 1159 2969 
+Q 1341 3281 1617 3432 
+Q 1894 3584 2278 3584 
+Q 2916 3584 3314 3078 
+Q 3713 2572 3713 1747 
+Q 3713 922 3314 415 
+Q 2916 -91 2278 -91 
+Q 1894 -91 1617 61 
+Q 1341 213 1159 525 
+z
+M 3116 1747 
+Q 3116 2381 2855 2742 
+Q 2594 3103 2138 3103 
+Q 1681 3103 1420 2742 
+Q 1159 2381 1159 1747 
+Q 1159 1113 1420 752 
+Q 1681 391 2138 391 
+Q 2594 391 2855 752 
+Q 3116 1113 3116 1747 
+z
+" transform="scale(0.015625)"/>
+      <path id="DejaVuSans-2014" d="M 313 1978 
+L 6088 1978 
+L 6088 1528 
+L 313 1528 
+L 313 1978 
+z
+" transform="scale(0.015625)"/>
+      <path id="DejaVuSans-fc" d="M 544 1381 
+L 544 3500 
+L 1119 3500 
+L 1119 1403 
+Q 1119 906 1312 657 
+Q 1506 409 1894 409 
+Q 2359 409 2629 706 
+Q 2900 1003 2900 1516 
+L 2900 3500 
+L 3475 3500 
+L 3475 0 
+L 2900 0 
+L 2900 538 
+Q 2691 219 2414 64 
+Q 2138 -91 1772 -91 
+Q 1169 -91 856 284 
+Q 544 659 544 1381 
+z
+M 1991 3584 
+L 1991 3584 
+z
+M 2278 4850 
+L 2913 4850 
+L 2913 4219 
+L 2278 4219 
+L 2278 4850 
+z
+M 1056 4850 
+L 1691 4850 
+L 1691 4219 
+L 1056 4219 
+L 1056 4850 
+z
+" transform="scale(0.015625)"/>
+     </defs>
+     <use xlink:href="#DejaVuSans-57"/>
+     <use xlink:href="#DejaVuSans-61" transform="translate(92.501953 0)"/>
+     <use xlink:href="#DejaVuSans-73" transform="translate(153.78125 0)"/>
+     <use xlink:href="#DejaVuSans-20" transform="translate(205.880859 0)"/>
+     <use xlink:href="#DejaVuSans-64" transform="translate(237.667969 0)"/>
+     <use xlink:href="#DejaVuSans-65" transform="translate(301.144531 0)"/>
+     <use xlink:href="#DejaVuSans-72" transform="translate(362.667969 0)"/>
+     <use xlink:href="#DejaVuSans-20" transform="translate(403.78125 0)"/>
+     <use xlink:href="#DejaVuSans-45" transform="translate(435.568359 0)"/>
+     <use xlink:href="#DejaVuSans-72" transform="translate(498.751953 0)"/>
+     <use xlink:href="#DejaVuSans-77" transform="translate(539.865234 0)"/>
+     <use xlink:href="#DejaVuSans-61" transform="translate(621.652344 0)"/>
+     <use xlink:href="#DejaVuSans-72" transform="translate(682.931641 0)"/>
+     <use xlink:href="#DejaVuSans-74" transform="translate(724.044922 0)"/>
+     <use xlink:href="#DejaVuSans-75" transform="translate(763.253906 0)"/>
+     <use xlink:href="#DejaVuSans-6e" transform="translate(826.632812 0)"/>
+     <use xlink:href="#DejaVuSans-67" transform="translate(890.011719 0)"/>
+     <use xlink:href="#DejaVuSans-73" transform="translate(953.488281 0)"/>
+     <use xlink:href="#DejaVuSans-77" transform="translate(1005.587891 0)"/>
+     <use xlink:href="#DejaVuSans-65" transform="translate(1087.375 0)"/>
+     <use xlink:href="#DejaVuSans-72" transform="translate(1148.898438 0)"/>
+     <use xlink:href="#DejaVuSans-74" transform="translate(1190.011719 0)"/>
+     <use xlink:href="#DejaVuSans-2d" transform="translate(1229.220703 0)"/>
+     <use xlink:href="#DejaVuSans-50" transform="translate(1265.304688 0)"/>
+     <use xlink:href="#DejaVuSans-6c" transform="translate(1325.607422 0)"/>
+     <use xlink:href="#DejaVuSans-61" transform="translate(1353.390625 0)"/>
+     <use xlink:href="#DejaVuSans-6e" transform="translate(1414.669922 0)"/>
+     <use xlink:href="#DejaVuSans-20" transform="translate(1478.048828 0)"/>
+     <use xlink:href="#DejaVuSans-73" transform="translate(1509.835938 0)"/>
+     <use xlink:href="#DejaVuSans-70" transform="translate(1561.935547 0)"/>
+     <use xlink:href="#DejaVuSans-61" transform="translate(1625.412109 0)"/>
+     <use xlink:href="#DejaVuSans-72" transform="translate(1686.691406 0)"/>
+     <use xlink:href="#DejaVuSans-74" transform="translate(1727.804688 0)"/>
+     <use xlink:href="#DejaVuSans-20" transform="translate(1767.013672 0)"/>
+     <use xlink:href="#DejaVuSans-2014" transform="translate(1798.800781 0)"/>
+     <use xlink:href="#DejaVuSans-20" transform="translate(1898.800781 0)"/>
+     <use xlink:href="#DejaVuSans-75" transform="translate(1930.587891 0)"/>
+     <use xlink:href="#DejaVuSans-6e" transform="translate(1993.966797 0)"/>
+     <use xlink:href="#DejaVuSans-64" transform="translate(2057.345703 0)"/>
+     <use xlink:href="#DejaVuSans-20" transform="translate(2120.822266 0)"/>
+     <use xlink:href="#DejaVuSans-77" transform="translate(2152.609375 0)"/>
+     <use xlink:href="#DejaVuSans-61" transform="translate(2234.396484 0)"/>
+     <use xlink:href="#DejaVuSans-73" transform="translate(2295.675781 0)"/>
+     <use xlink:href="#DejaVuSans-20" transform="translate(2347.775391 0)"/>
+     <use xlink:href="#DejaVuSans-65" transform="translate(2379.5625 0)"/>
+     <use xlink:href="#DejaVuSans-72" transform="translate(2441.085938 0)"/>
+     <use xlink:href="#DejaVuSans-20" transform="translate(2482.199219 0)"/>
+     <use xlink:href="#DejaVuSans-64" transform="translate(2513.986328 0)"/>
+     <use xlink:href="#DejaVuSans-61" transform="translate(2577.462891 0)"/>
+     <use xlink:href="#DejaVuSans-66" transform="translate(2638.742188 0)"/>
+     <use xlink:href="#DejaVuSans-fc" transform="translate(2673.947266 0)"/>
+     <use xlink:href="#DejaVuSans-72" transform="translate(2737.326172 0)"/>
+     <use xlink:href="#DejaVuSans-20" transform="translate(2778.439453 0)"/>
+     <use xlink:href="#DejaVuSans-62" transform="translate(2810.226562 0)"/>
+     <use xlink:href="#DejaVuSans-65" transform="translate(2873.703125 0)"/>
+     <use xlink:href="#DejaVuSans-7a" transform="translate(2935.226562 0)"/>
+     <use xlink:href="#DejaVuSans-61" transform="translate(2987.716797 0)"/>
+     <use xlink:href="#DejaVuSans-68" transform="translate(3048.996094 0)"/>
+     <use xlink:href="#DejaVuSans-6c" transform="translate(3112.375 0)"/>
+     <use xlink:href="#DejaVuSans-74" transform="translate(3140.158203 0)"/>
+    </g>
+    <!-- Ersparnis 12.725 € Brennstoff, Preis 536.239 € Lastabwurf: das 42-fache -->
+    <g transform="translate(172.815313 35.856) scale(0.125 -0.125)">
+     <defs>
+      <path id="DejaVuSans-37" d="M 525 4666 
+L 3525 4666 
+L 3525 4397 
+L 1831 0 
+L 1172 0 
+L 2766 4134 
+L 525 4134 
+L 525 4666 
+z
+" transform="scale(0.015625)"/>
+      <path id="DejaVuSans-35" d="M 691 4666 
+L 3169 4666 
+L 3169 4134 
+L 1269 4134 
+L 1269 2991 
+Q 1406 3038 1543 3061 
+Q 1681 3084 1819 3084 
+Q 2600 3084 3056 2656 
+Q 3513 2228 3513 1497 
+Q 3513 744 3044 326 
+Q 2575 -91 1722 -91 
+Q 1428 -91 1123 -41 
+Q 819 9 494 109 
+L 494 744 
+Q 775 591 1075 516 
+Q 1375 441 1709 441 
+Q 2250 441 2565 725 
+Q 2881 1009 2881 1497 
+Q 2881 1984 2565 2268 
+Q 2250 2553 1709 2553 
+Q 1456 2553 1204 2497 
+Q 953 2441 691 2322 
+L 691 4666 
+z
+" transform="scale(0.015625)"/>
+      <path id="DejaVuSans-2c" d="M 750 794 
+L 1409 794 
+L 1409 256 
+L 897 -744 
+L 494 -744 
+L 750 256 
+L 750 794 
+z
+" transform="scale(0.015625)"/>
+      <path id="DejaVuSans-33" d="M 2597 2516 
+Q 3050 2419 3304 2112 
+Q 3559 1806 3559 1356 
+Q 3559 666 3084 287 
+Q 2609 -91 1734 -91 
+Q 1441 -91 1130 -33 
+Q 819 25 488 141 
+L 488 750 
+Q 750 597 1062 519 
+Q 1375 441 1716 441 
+Q 2309 441 2620 675 
+Q 2931 909 2931 1356 
+Q 2931 1769 2642 2001 
+Q 2353 2234 1838 2234 
+L 1294 2234 
+L 1294 2753 
+L 1863 2753 
+Q 2328 2753 2575 2939 
+Q 2822 3125 2822 3475 
+Q 2822 3834 2567 4026 
+Q 2313 4219 1838 4219 
+Q 1578 4219 1281 4162 
+Q 984 4106 628 3988 
+L 628 4550 
+Q 988 4650 1302 4700 
+Q 1616 4750 1894 4750 
+Q 2613 4750 3031 4423 
+Q 3450 4097 3450 3541 
+Q 3450 3153 3228 2886 
+Q 3006 2619 2597 2516 
+z
+" transform="scale(0.015625)"/>
+      <path id="DejaVuSans-39" d="M 703 97 
+L 703 672 
+Q 941 559 1184 500 
+Q 1428 441 1663 441 
+Q 2288 441 2617 861 
+Q 2947 1281 2994 2138 
+Q 2813 1869 2534 1725 
+Q 2256 1581 1919 1581 
+Q 1219 1581 811 2004 
+Q 403 2428 403 3163 
+Q 403 3881 828 4315 
+Q 1253 4750 1959 4750 
+Q 2769 4750 3195 4129 
+Q 3622 3509 3622 2328 
+Q 3622 1225 3098 567 
+Q 2575 -91 1691 -91 
+Q 1453 -91 1209 -44 
+Q 966 3 703 97 
+z
+M 1959 2075 
+Q 2384 2075 2632 2365 
+Q 2881 2656 2881 3163 
+Q 2881 3666 2632 3958 
+Q 2384 4250 1959 4250 
+Q 1534 4250 1286 3958 
+Q 1038 3666 1038 3163 
+Q 1038 2656 1286 2365 
+Q 1534 2075 1959 2075 
+z
+" transform="scale(0.015625)"/>
+      <path id="DejaVuSans-3a" d="M 750 794 
+L 1409 794 
+L 1409 0 
+L 750 0 
+L 750 794 
+z
+M 750 3309 
+L 1409 3309 
+L 1409 2516 
+L 750 2516 
+L 750 3309 
+z
+" transform="scale(0.015625)"/>
+     </defs>
+     <use xlink:href="#DejaVuSans-45"/>
+     <use xlink:href="#DejaVuSans-72" transform="translate(63.183594 0)"/>
+     <use xlink:href="#DejaVuSans-73" transform="translate(104.296875 0)"/>
+     <use xlink:href="#DejaVuSans-70" transform="translate(156.396484 0)"/>
+     <use xlink:href="#DejaVuSans-61" transform="translate(219.873047 0)"/>
+     <use xlink:href="#DejaVuSans-72" transform="translate(281.152344 0)"/>
+     <use xlink:href="#DejaVuSans-6e" transform="translate(320.515625 0)"/>
+     <use xlink:href="#DejaVuSans-69" transform="translate(383.894531 0)"/>
+     <use xlink:href="#DejaVuSans-73" transform="translate(411.677734 0)"/>
+     <use xlink:href="#DejaVuSans-20" transform="translate(463.777344 0)"/>
+     <use xlink:href="#DejaVuSans-31" transform="translate(495.564453 0)"/>
+     <use xlink:href="#DejaVuSans-32" transform="translate(559.1875 0)"/>
+     <use xlink:href="#DejaVuSans-2e" transform="translate(622.810547 0)"/>
+     <use xlink:href="#DejaVuSans-37" transform="translate(654.597656 0)"/>
+     <use xlink:href="#DejaVuSans-32" transform="translate(718.220703 0)"/>
+     <use xlink:href="#DejaVuSans-35" transform="translate(781.84375 0)"/>
+     <use xlink:href="#DejaVuSans-20" transform="translate(845.466797 0)"/>
+     <use xlink:href="#DejaVuSans-20ac" transform="translate(877.253906 0)"/>
+     <use xlink:href="#DejaVuSans-20" transform="translate(940.876953 0)"/>
+     <use xlink:href="#DejaVuSans-42" transform="translate(972.664062 0)"/>
+     <use xlink:href="#DejaVuSans-72" transform="translate(1041.267578 0)"/>
+     <use xlink:href="#DejaVuSans-65" transform="translate(1080.130859 0)"/>
+     <use xlink:href="#DejaVuSans-6e" transform="translate(1141.654297 0)"/>
+     <use xlink:href="#DejaVuSans-6e" transform="translate(1205.033203 0)"/>
+     <use xlink:href="#DejaVuSans-73" transform="translate(1268.412109 0)"/>
+     <use xlink:href="#DejaVuSans-74" transform="translate(1320.511719 0)"/>
+     <use xlink:href="#DejaVuSans-6f" transform="translate(1359.720703 0)"/>
+     <use xlink:href="#DejaVuSans-66" transform="translate(1420.902344 0)"/>
+     <use xlink:href="#DejaVuSans-66" transform="translate(1456.107422 0)"/>
+     <use xlink:href="#DejaVuSans-2c" transform="translate(1491.3125 0)"/>
+     <use xlink:href="#DejaVuSans-20" transform="translate(1523.099609 0)"/>
+     <use xlink:href="#DejaVuSans-50" transform="translate(1554.886719 0)"/>
+     <use xlink:href="#DejaVuSans-72" transform="translate(1613.439453 0)"/>
+     <use xlink:href="#DejaVuSans-65" transform="translate(1652.302734 0)"/>
+     <use xlink:href="#DejaVuSans-69" transform="translate(1713.826172 0)"/>
+     <use xlink:href="#DejaVuSans-73" transform="translate(1741.609375 0)"/>
+     <use xlink:href="#DejaVuSans-20" transform="translate(1793.708984 0)"/>
+     <use xlink:href="#DejaVuSans-35" transform="translate(1825.496094 0)"/>
+     <use xlink:href="#DejaVuSans-33" transform="translate(1889.119141 0)"/>
+     <use xlink:href="#DejaVuSans-36" transform="translate(1952.742188 0)"/>
+     <use xlink:href="#DejaVuSans-2e" transform="translate(2016.365234 0)"/>
+     <use xlink:href="#DejaVuSans-32" transform="translate(2048.152344 0)"/>
+     <use xlink:href="#DejaVuSans-33" transform="translate(2111.775391 0)"/>
+     <use xlink:href="#DejaVuSans-39" transform="translate(2175.398438 0)"/>
+     <use xlink:href="#DejaVuSans-20" transform="translate(2239.021484 0)"/>
+     <use xlink:href="#DejaVuSans-20ac" transform="translate(2270.808594 0)"/>
+     <use xlink:href="#DejaVuSans-20" transform="translate(2334.431641 0)"/>
+     <use xlink:href="#DejaVuSans-4c" transform="translate(2366.21875 0)"/>
+     <use xlink:href="#DejaVuSans-61" transform="translate(2421.931641 0)"/>
+     <use xlink:href="#DejaVuSans-73" transform="translate(2483.210938 0)"/>
+     <use xlink:href="#DejaVuSans-74" transform="translate(2535.310547 0)"/>
+     <use xlink:href="#DejaVuSans-61" transform="translate(2574.519531 0)"/>
+     <use xlink:href="#DejaVuSans-62" transform="translate(2635.798828 0)"/>
+     <use xlink:href="#DejaVuSans-77" transform="translate(2699.275391 0)"/>
+     <use xlink:href="#DejaVuSans-75" transform="translate(2781.0625 0)"/>
+     <use xlink:href="#DejaVuSans-72" transform="translate(2844.441406 0)"/>
+     <use xlink:href="#DejaVuSans-66" transform="translate(2885.554688 0)"/>
+     <use xlink:href="#DejaVuSans-3a" transform="translate(2917.134766 0)"/>
+     <use xlink:href="#DejaVuSans-20" transform="translate(2950.826172 0)"/>
+     <use xlink:href="#DejaVuSans-64" transform="translate(2982.613281 0)"/>
+     <use xlink:href="#DejaVuSans-61" transform="translate(3046.089844 0)"/>
+     <use xlink:href="#DejaVuSans-73" transform="translate(3107.369141 0)"/>
+     <use xlink:href="#DejaVuSans-20" transform="translate(3159.46875 0)"/>
+     <use xlink:href="#DejaVuSans-34" transform="translate(3191.255859 0)"/>
+     <use xlink:href="#DejaVuSans-32" transform="translate(3254.878906 0)"/>
+     <use xlink:href="#DejaVuSans-2d" transform="translate(3318.501953 0)"/>
+     <use xlink:href="#DejaVuSans-66" transform="translate(3354.585938 0)"/>
+     <use xlink:href="#DejaVuSans-61" transform="translate(3389.791016 0)"/>
+     <use xlink:href="#DejaVuSans-63" transform="translate(3451.070312 0)"/>
+     <use xlink:href="#DejaVuSans-68" transform="translate(3506.050781 0)"/>
+     <use xlink:href="#DejaVuSans-65" transform="translate(3569.429688 0)"/>
+    </g>
+   </g>
+   <g id="line2d_21">
+    <path d="M 360.234945 246.250134 
+L 439.255055 246.250134 
+" clip-path="url(#p83a3789304)" style="fill: none; stroke: #64748b; stroke-width: 2.2; stroke-linecap: square"/>
+   </g>
+  </g>
+ </g>
+ <defs>
+  <clipPath id="p83a3789304">
+   <rect x="75.89" y="49.856" width="647.71" height="292.26208"/>
+  </clipPath>
+ </defs>
+</svg>